Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 

products/sources/formale Sprachen/C/Firefox/dom/promise/tests/   (Browser von der Mozilla Stiftung Version 136.0.1©)  Datei vom 10.2.2025 mit Größe 21 kB image not shown  

Quelle  test_promise.html   Sprache: HTML

 
 products/sources/formale Sprachen/C/Firefox/dom/promise/tests/test_promise.html


<!--
  Any copyright is dedicated to the Public Domain.
  http://creativecommons.org/publicdomain/zero/1.0/
-->
<html>
<head>
  <title>Basic Promise Test</title>
  <script src="/tests/SimpleTest/SimpleTest.js"></script>
  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
</head>
<body>
<p id="display"></p>
<div id="content" style="display: none">

</div>
<pre id="test">
<script type="application/javascript"><!--

function promiseResolve() {
  ok(Promise, "Promise object should exist");

  var promise = new Promise(function(resolve, reject) {
    ok(resolve, "Promise.resolve exists");
    ok(reject, "Promise.reject exists");

    resolve(42);
  });
  promise.then(function(what) {
    ok(true, "Then - resolveCb has been called");
    is(what, 42, "ResolveCb received 42");
    runTest();
  }, function() {
    ok(false, "Then - rejectCb has been called");
    runTest();
  });
}

function promiseResolveNoArg() {
  var promise = new Promise(function(resolve, reject) {
    ok(resolve, "Promise.resolve exists");
    ok(reject, "Promise.reject exists");

    resolve();
  });
  promise.then(function(what) {
    ok(true, "Then - resolveCb has been called");
    is(what, undefined, "ResolveCb received undefined");
    runTest();
  }, function() {
    ok(false, "Then - rejectCb has been called");
    runTest();
  });
}

function promiseReject() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });
  promise.then(function() {
    ok(false, "Then - resolveCb has been called");
    runTest();
  }, function(what) {
    ok(true, "Then - rejectCb has been called");
    is(what, 42, "RejectCb received 42");
    runTest();
  });
}

function promiseRejectNoHandler() {
  // This test only checks that the code that reports unhandled errors in the
  // Promises implementation does not crash or leak.

  new Promise(function() {
    // eslint-disable-next-line no-undef
    noSuchMethod();
  });
  runTest();
}

function promiseRejectNoArg() {
  var promise = new Promise(function(resolve, reject) {
    reject();
  });
  promise.then(function() {
    ok(false, "Then - resolveCb has been called");
    runTest();
  }, function(what) {
    ok(true, "Then - rejectCb has been called");
    is(what, undefined, "RejectCb received undefined");
    runTest();
  });
}

function promiseException() {
  var promise = new Promise(function() {
    // eslint-disable-next-line no-throw-literal
    throw 42;
  });
  promise.then(function() {
    ok(false, "Then - resolveCb has been called");
    runTest();
  }, function(what) {
    ok(true, "Then - rejectCb has been called");
    is(what, 42, "RejectCb received 42");
    runTest();
  });
}

function promiseGC() {
  var resolve;
  var promise = new Promise(function(r1) {
    resolve = r1;
  });
  promise.then(function() {
    ok(true, "Then - promise is still alive");
    runTest();
  });

  promise = null;

  SpecialPowers.gc();
  SpecialPowers.forceGC();
  SpecialPowers.forceCC();

  resolve(42);
}

function promiseAsync_TimeoutResolveThen() {
  var handlerExecuted = false;

  setTimeout(function() {
    ok(handlerExecuted, "Handler should have been called before the timeout.");

    // Allow other assertions to run so the test could fail before the next one.
    setTimeout(runTest, 0);
  }, 0);

  Promise.resolve().then(function() {
    handlerExecuted = true;
  });

  ok(!handlerExecuted, "Handlers are not called before 'then' returns.");
}

function promiseAsync_ResolveTimeoutThen() {
  var handlerExecuted = false;

  var promise = Promise.resolve();

  setTimeout(function() {
    ok(handlerExecuted, "Handler should have been called before the timeout.");

    // Allow other assertions to run so the test could fail before the next one.
    setTimeout(runTest, 0);
  }, 0);

  promise.then(function() {
    handlerExecuted = true;
  });

  ok(!handlerExecuted, "Handlers are not called before 'then' returns.");
}

function promiseAsync_ResolveThenTimeout() {
  var handlerExecuted = false;

  Promise.resolve().then(function() {
    handlerExecuted = true;
  });

  setTimeout(function() {
    ok(handlerExecuted, "Handler should have been called before the timeout.");

    // Allow other assertions to run so the test could fail before the next one.
    setTimeout(runTest, 0);
  }, 0);

  ok(!handlerExecuted, "Handlers are not called before 'then' returns.");
}

function promiseAsync_SyncXHR() {
  var handlerExecuted = false;

  Promise.resolve().then(function() {
    handlerExecuted = true;

    // Allow other assertions to run so the test could fail before the next one.
    setTimeout(runTest, 0);
  });

  ok(!handlerExecuted, "Handlers are not called until the next microtask.");

  var xhr = new XMLHttpRequest();
  xhr.open("GET", "testXHR.txt", false);
  xhr.send(null);

  ok(!handlerExecuted, "Sync XHR should not trigger microtask execution.");
}

function promiseDoubleThen() {
  var steps = 0;
  var promise = new Promise(function(r1) {
    r1(42);
  });

  promise.then(function(what) {
    ok(true, "Then.resolve has been called");
    is(what, 42, "Value == 42");
    steps++;
  }, function() {
    ok(false, "Then.reject has been called");
  });

  promise.then(function(what) {
    ok(true, "Then.resolve has been called");
    is(steps, 1, "Then.resolve - step == 1");
    is(what, 42, "Value == 42");
    runTest();
  }, function() {
    ok(false, "Then.reject has been called");
  });
}

function promiseThenException() {
  var promise = new Promise(function(resolve) {
    resolve(42);
  });

  promise.then(function() {
    ok(true, "Then.resolve has been called");
    // eslint-disable-next-line no-throw-literal
    throw "booh";
  }).catch(function() {
    ok(true, "window.onerror has been called!");
    runTest();
  });
}

function promiseThenCatchThen() {
  var promise = new Promise(function(resolve) {
    resolve(42);
  });

  var promise2 = promise.then(function(what) {
    ok(true, "Then.resolve has been called");
    is(what, 42, "Value == 42");
    return what + 1;
  }, function() {
    ok(false, "Then.reject has been called");
  });

  isnot(promise, promise2, "These 2 promise objs are different");

  promise2.then(function(what) {
    ok(true, "Then.resolve has been called");
    is(what, 43, "Value == 43");
    return what + 1;
  }, function() {
    ok(false, "Then.reject has been called");
  }).catch(function() {
    ok(false, "Catch has been called");
  }).then(function(what) {
    ok(true, "Then.resolve has been called");
    is(what, 44, "Value == 44");
    runTest();
  }, function() {
    ok(false, "Then.reject has been called");
  });
}

function promiseThenNoArg() {
  var promise = new Promise(function(resolve) {
    resolve(42);
  });

  // eslint-disable-next-line promise/valid-params
  var clone = promise.then();
  isnot(promise, clone, "These 2 promise objs are different");
  promise.then(function(v) {
    clone.then(function(cv) {
      is(v, cv, "Both resolve to the same value");
      runTest();
    });
  });
}

function promiseThenUndefinedResolveFunction() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  try {
    promise.then(undefined, function(v) {
      is(v, 42, "Promise rejected with 42");
      runTest();
    });
  } catch (e) {
    ok(false, "then should not throw on undefined resolve function");
  }
}

function promiseThenNullResolveFunction() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  try {
    promise.then(null, function(v) {
      is(v, 42, "Promise rejected with 42");
      runTest();
    });
  } catch (e) {
    ok(false, "then should not throw on null resolve function");
  }
}

function promiseRejectThenCatchThen() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  var promise2 = promise.then(function() {
    ok(false, "Then.resolve has been called");
  }, function(what) {
    ok(true, "Then.reject has been called");
    is(what, 42, "Value == 42");
    return what + 1;
  });

  isnot(promise, promise2, "These 2 promise objs are different");

  promise2.then(function(what) {
    ok(true, "Then.resolve has been called");
    is(what, 43, "Value == 43");
    return what + 1;
  }).catch(function() {
    ok(false, "Catch has been called");
  }).then(function(what) {
    ok(true, "Then.resolve has been called");
    is(what, 44, "Value == 44");
    runTest();
  });
}

function promiseRejectThenCatchThen2() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  promise.then(function(what) {
    ok(true, "Then.resolve has been called");
    is(what, 42, "Value == 42");
    return what + 1;
  }).catch(function(what) {
    is(what, 42, "Value == 42");
    ok(true, "Catch has been called");
    return what + 1;
  }).then(function(what) {
    ok(true, "Then.resolve has been called");
    is(what, 43, "Value == 43");
    runTest();
  });
}

function promiseRejectThenCatchExceptionThen() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  promise.then(function() {
    ok(false, "Then.resolve has been called");
  }, function(what) {
    ok(true, "Then.reject has been called");
    is(what, 42, "Value == 42");
    // eslint-disable-next-line no-throw-literal
    throw (what + 1);
  }).catch(function(what) {
    ok(true, "Catch has been called");
    is(what, 43, "Value == 43");
    return what + 1;
  }).then(function(what) {
    ok(true, "Then.resolve has been called");
    is(what, 44, "Value == 44");
    runTest();
  });
}

function promiseThenCatchOrderingResolve() {
  var global = 0;
  var f = new Promise(function(r1) {
    r1(42);
  });

  f.then(function() {
    f.then(function() {
      global++;
    });
    f.catch(function() {
      global++;
    });
    f.then(function() {
      global++;
    });
    setTimeout(function() {
      is(global, 2, "Many steps... should return 2");
      runTest();
    }, 0);
  });
}

function promiseThenCatchOrderingReject() {
  var global = 0;
  var f = new Promise(function(r1, r2) {
    r2(42);
  });

  f.then(function() {}, function() {
    f.then(function() {
      global++;
    });
    f.catch(function() {
      global++;
    });
    f.then(function() {}, function() {
      global++;
    });
    setTimeout(function() {
      is(global, 2, "Many steps... should return 2");
      runTest();
    }, 0);
  });
}

function promiseCatchNoArg() {
  var promise = new Promise(function(resolve, reject) {
    reject(42);
  });

  // eslint-disable-next-line promise/valid-params
  var clone = promise.catch();
  isnot(promise, clone, "These 2 promise objs are different");
  promise.catch(function(v) {
    clone.catch(function(cv) {
      is(v, cv, "Both reject to the same value");
      runTest();
    });
  });
}

function promiseNestedPromise() {
  new Promise(function(resolve) {
    resolve(new Promise(function(res) {
      ok(true, "Nested promise is executed");
      res(42);
    }));
  }).then(function(value) {
    is(value, 42, "Nested promise is executed and then == 42");
    runTest();
  });
}

function promiseNestedNestedPromise() {
  new Promise(function(resolve) {
    resolve(new Promise(function(res) {
      ok(true, "Nested promise is executed");
      res(42);
    }).then(function(what) { return what + 1; }));
  }).then(function(value) {
    is(value, 43, "Nested promise is executed and then == 43");
    runTest();
  });
}

function promiseWrongNestedPromise() {
  new Promise(function(resolve, reject) {
    resolve(new Promise(function(r) {
      ok(true, "Nested promise is executed");
      r(42);
    }));
    reject(42);
  }).then(function(value) {
    is(value, 42, "Nested promise is executed and then == 42");
    runTest();
  }, function() {
     ok(false, "This is wrong");
  });
}

function promiseLoop() {
  new Promise(function(resolve) {
    resolve(new Promise(function(res) {
      ok(true, "Nested promise is executed");
      res(new Promise(function(resInner) {
        ok(true, "Nested nested promise is executed");
        resInner(42);
      }));
    }));
  }).then(function(value) {
    is(value, 42, "Nested nested promise is executed and then == 42");
    runTest();
  }, function() {
     ok(false, "This is wrong");
  });
}

function promiseStaticReject() {
  var promise = Promise.reject(42);
  promise.then(function() {
    ok(false, "This should not be called");
  }, function(what) {
    is(what, 42, "Value == 42");
    runTest();
  });
}

function promiseStaticResolve() {
  var promise = Promise.resolve(42);
  promise.then(function(what) {
    is(what, 42, "Value == 42");
    runTest();
  }, function() {
    ok(false, "This should not be called");
  });
}

function promiseResolveNestedPromise() {
  var promise = Promise.resolve(new Promise(function(r) {
    ok(true, "Nested promise is executed");
    r(42);
  }, function() {
    ok(false, "This should not be called");
  }));
  promise.then(function(what) {
    is(what, 42, "Value == 42");
    runTest();
  }, function() {
    ok(false, "This should not be called");
  });
}

function promiseSimpleThenableResolve() {
  var thenable = { then(resolve) { resolve(5); } };
  var promise = new Promise(function(resolve) {
    resolve(thenable);
  });

  promise.then(function(v) {
    ok(v === 5, "promiseSimpleThenableResolve");
    runTest();
  }, function() {
    ok(false, "promiseSimpleThenableResolve: Should not reject");
  });
}

function promiseSimpleThenableReject() {
  var thenable = { then(resolve, reject) { reject(5); } };
  var promise = new Promise(function(resolve) {
    resolve(thenable);
  });

  promise.then(function() {
    ok(false, "promiseSimpleThenableReject: Should not resolve");
    runTest();
  }, function(e) {
    ok(e === 5, "promiseSimpleThenableReject");
    runTest();
  });
}

function promiseThenableThrowsBeforeCallback() {
  var thenable = { then(resolve) {
    throw new TypeError("Hi there");

    // eslint-disable-next-line no-unreachable
    resolve(5);
  }};

  var promise = Promise.resolve(thenable);
  promise.then(function() {
    ok(false, "promiseThenableThrowsBeforeCallback: Should've rejected");
    runTest();
  }, function(e) {
    ok(e instanceof TypeError, "promiseThenableThrowsBeforeCallback");
    runTest();
  });
}

function promiseThenableThrowsAfterCallback() {
  var thenable = { then(resolve) {
    resolve(5);
    throw new TypeError("Hi there");
  }};

  var promise = Promise.resolve(thenable);
  promise.then(function(v) {
    ok(v === 5, "promiseThenableThrowsAfterCallback");
    runTest();
  }, function() {
    ok(false, "promiseThenableThrowsAfterCallback: Should've resolved");
    runTest();
  });
}

function promiseThenableRejectThenResolve() {
  var thenable = { then(resolve, reject) {
    reject(new TypeError("Hi there"));
    resolve(5);
  }};

  var promise = Promise.resolve(thenable);
  promise.then(function() {
    ok(false, "promiseThenableRejectThenResolve should have rejected");
    runTest();
  }, function(e) {
    ok(e instanceof TypeError, "promiseThenableRejectThenResolve");
    runTest();
  });
}

function promiseWithThenReplaced() {
  // Ensure that we call the 'then' on the promise and not the internal then.
  var promise = new Promise(function(resolve) {
    resolve(5);
  });

  // Rogue `then` always rejects.
  promise.then = function(onFulfill, onReject) {
    onReject(new TypeError("Foo"));
  };

  var promise2 = Promise.resolve(promise);
  promise2.then(function() {
    ok(false, "promiseWithThenReplaced: Should've rejected");
    runTest();
  }, function(e) {
    ok(e instanceof TypeError, "promiseWithThenReplaced");
    runTest();
  });
}

function promiseStrictHandlers() {
  var promise = Promise.resolve(5);
  promise.then(function() {
    "use strict";
    ok(this === undefined, "Strict mode callback should have this === undefined.");
    runTest();
  });
}

function promiseStrictExecutorThisArg() {
  new Promise(function() {
    "use strict";
    ok(this === undefined, "thisArg should be undefined.");
    runTest();
  });
}

function promiseResolveArray() {
  var p = Promise.resolve([1, 2, 3]);
  ok(p instanceof Promise, "Should return a Promise.");
  p.then(function(v) {
    ok(Array.isArray(v), "Resolved value should be an Array");
    is(v.length, 3, "Length should match");
    is(v[0], 1, "Resolved value should match original");
    is(v[1], 2, "Resolved value should match original");
    is(v[2], 3, "Resolved value should match original");
    runTest();
  });
}

function promiseResolveThenable() {
  var p = Promise.resolve({ then(onFulfill) { onFulfill(2); } });
  ok(p instanceof Promise, "Should cast to a Promise.");
  p.then(function(v) {
    is(v, 2, "Should resolve to 2.");
    runTest();
  }, function() {
    ok(false, "promiseResolveThenable should've resolved");
    runTest();
  });
}

function promiseResolvePromise() {
  var original = Promise.resolve(true);
  var cast = Promise.resolve(original);

  ok(cast instanceof Promise, "Should cast to a Promise.");
  is(cast, original, "Should return original Promise.");
  cast.then(function(v) {
    is(v, true, "Should resolve to true.");
    runTest();
  });
}

// Bug 1009569.
// Ensure that thenables are run on a clean stack asynchronously.
// Test case adopted from
// https://gist.github.com/getify/d64bb01751b50ed6b281#file-bug1-js.
function promiseResolveThenableCleanStack() {
  function immed(s) { x++; s(); }
  function incX() { x++; }

  var x = 0;
  var thenable = { then: immed };
  var results = [];

  var p = Promise.resolve(thenable).then(incX);
  results.push(x);

  // check what happens after all "next cycle" steps
  // have had a chance to complete
  setTimeout(function() {
    // Result should be [0, 2] since `thenable` will be called async.
    is(results[0], 0, "Expected thenable to be called asynchronously");
    // See Bug 1023547 comment 13 for why this check has to be gated on p.
    p.then(function() {
      results.push(x);
      is(results[1], 2, "Expected thenable to be called asynchronously");
      runTest();
    });
  }, 1000);
}

// Bug 1008467 - Promise fails with "too much recursion".
// The bug was that the callbacks passed to a thenable would resolve the
// promise synchronously when the fulfill handler returned a non-thenable.
//
// For example:
// var p = new Promise(function(resolve) {
//   resolve(5);
// });
// var m = Promise.resolve(p);
//
// At this point `m` is a Promise that is resolved with a thenable `p`, so it
// calls `p.then()` with two callbacks, both of which would synchronously resolve
// `m` when `p` invoked them (on account of itself being resolved, possibly
// synchronously. A chain of these 'Promise resolved by a Promise' would lead to
// stack overflow.
function promiseTestAsyncThenableResolution() {
  var k = 3000;
  Promise.resolve().then(function next() {
    k--;
    if (k > 0) return Promise.resolve().then(next);
    return undefined;
  }).then(function() {
    ok(true, "Resolution of a chain of thenables should not be synchronous.");
    runTest();
  });
}

// Bug 1062323
function promiseWrapperAsyncResolution() {
  var p = new Promise(function(resolve) {
    resolve();
  });

  var results = [];
  var q = p.then(function() {
    results.push("1-1");
  }).then(function() {
    results.push("1-2");
  }).then(function() {
    results.push("1-3");
  });

  var r = p.then(function() {
    results.push("2-1");
  }).then(function() {
    results.push("2-2");
  }).then(function() {
    results.push("2-3");
  });

  Promise.all([q, r]).then(function() {
    var match = results[0] == "1-1" &&
                results[1] == "2-1" &&
                results[2] == "1-2" &&
                results[3] == "2-2" &&
                results[4] == "1-3" &&
                results[5] == "2-3";
                info(results);
    ok(match, "Chained promises should resolve asynchronously.");
    runTest();
  }, function() {
    ok(false, "promiseWrapperAsyncResolution: One of the promises failed.");
    runTest();
  });
}

var tests = [ promiseResolve, promiseReject,
              promiseException, promiseGC,
              promiseAsync_TimeoutResolveThen,
              promiseAsync_ResolveTimeoutThen,
              promiseAsync_ResolveThenTimeout,
              promiseAsync_SyncXHR,
              promiseDoubleThen, promiseThenException,
              promiseThenCatchThen, promiseRejectThenCatchThen,
              promiseRejectThenCatchThen2,
              promiseRejectThenCatchExceptionThen,
              promiseThenCatchOrderingResolve,
              promiseThenCatchOrderingReject,
              promiseNestedPromise, promiseNestedNestedPromise,
              promiseWrongNestedPromise, promiseLoop,
              promiseStaticReject, promiseStaticResolve,
              promiseResolveNestedPromise,
              promiseResolveNoArg,
              promiseRejectNoArg,
              promiseThenNoArg,
              promiseThenUndefinedResolveFunction,
              promiseThenNullResolveFunction,
              promiseCatchNoArg,
              promiseRejectNoHandler,
              promiseSimpleThenableResolve,
              promiseSimpleThenableReject,
              promiseThenableThrowsBeforeCallback,
              promiseThenableThrowsAfterCallback,
              promiseThenableRejectThenResolve,
              promiseWithThenReplaced,
              promiseStrictHandlers,
              promiseStrictExecutorThisArg,
              promiseResolveArray,
              promiseResolveThenable,
              promiseResolvePromise,
              promiseResolveThenableCleanStack,
              promiseTestAsyncThenableResolution,
              promiseWrapperAsyncResolution,
            ];

function runTest() {
  if (!tests.length) {
    SimpleTest.finish();
    return;
  }

  var test = tests.shift();
  test();
}

SimpleTest.waitForExplicitFinish();
SimpleTest.requestFlakyTimeout("untriaged");
runTest();
// -->
</script>
</pre>
</body>
</html>

Messung V0.5
C=89 H=91 G=89

¤ Dauer der Verarbeitung: 0.6 Sekunden  ¤

*© Formatika GbR, Deutschland




Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.





                                                                                                                                                                                                                                                                                                                                                                                                     

Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder
Jenseits des Üblichen ....
    

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge