async-eval-state.js

Enable keyboard shortcuts

// Test module fields related to asynchronous evaluation.

// Hardcoded values of ModuleStatus. Keep these in sync if the code changes.

const StatusUnlinked = 0;

const StatusLinked = 2;

const StatusEvaluating = 3;

const StatusEvaluatingAsync = 4;

const StatusEvaluated = 5;

  let m = parseModule('');

  assertEq(m.status, StatusUnlinked);

  moduleLink(m);

  assertEq(m.isAsyncEvaluating, false);

  assertEq(m.status, StatusLinked);

  moduleEvaluate(m);

  assertEq(m.isAsyncEvaluating, false);

  assertEq(m.status, StatusEvaluated);

  let m = parseModule('await 1;');

  moduleLink(m);

  assertEq(m.isAsyncEvaluating, false);

  moduleEvaluate(m);

  assertEq(m.isAsyncEvaluating, true);

  assertEq(m.status, StatusEvaluatingAsync);

  assertEq(m.asyncEvaluatingPostOrder, 1);

  drainJobQueue();

  assertEq(m.isAsyncEvaluating, true);

  assertEq(m.status, StatusEvaluated);

  assertEq(m.asyncEvaluatingPostOrder, undefined);

  let m = parseModule('await 1; throw 2;');

  moduleLink(m);

  moduleEvaluate(m).catch(() => 0);

  assertEq(m.isAsyncEvaluating, true);

  assertEq(m.status, StatusEvaluatingAsync);

  assertEq(m.asyncEvaluatingPostOrder, 1);

  drainJobQueue();

  assertEq(m.isAsyncEvaluating, true);

  assertEq(m.status, StatusEvaluated);

  assertEq(m.evaluationError, 2);

  assertEq(m.asyncEvaluatingPostOrder, undefined);

  let m = parseModule('throw 1; await 2;');

  moduleLink(m);

  moduleEvaluate(m).catch(() => 0);

  assertEq(m.isAsyncEvaluating, true);

  assertEq(m.status, StatusEvaluatingAsync);

  assertEq(m.asyncEvaluatingPostOrder, 1);

  drainJobQueue();

  assertEq(m.isAsyncEvaluating, true);

  assertEq(m.status, StatusEvaluated);

  assertEq(m.evaluationError, 1);

  assertEq(m.asyncEvaluatingPostOrder, undefined);

  clearModules();

  let a = registerModule('a', parseModule(''));

  let b = registerModule('b', parseModule('import {} from "a"; await 1;'));

  moduleLink(b);

  moduleEvaluate(b);

  assertEq(a.isAsyncEvaluating, false);

  assertEq(a.status, StatusEvaluated);

  assertEq(b.isAsyncEvaluating, true);

  assertEq(b.status, StatusEvaluatingAsync);

  assertEq(b.asyncEvaluatingPostOrder, 1);

  drainJobQueue();

  assertEq(a.isAsyncEvaluating, false);

  assertEq(a.status, StatusEvaluated);

  assertEq(b.isAsyncEvaluating, true);

  assertEq(b.status, StatusEvaluated);

  assertEq(b.asyncEvaluatingPostOrder, undefined);

  clearModules();

  let a = registerModule('a', parseModule('await 1;'));

  let b = registerModule('b', parseModule('import {} from "a";'));

  moduleLink(b);

  moduleEvaluate(b);

  assertEq(a.isAsyncEvaluating, true);

  assertEq(a.status, StatusEvaluatingAsync);

  assertEq(a.asyncEvaluatingPostOrder, 1);

  assertEq(b.isAsyncEvaluating, true);

  assertEq(b.status, StatusEvaluatingAsync);

  assertEq(b.asyncEvaluatingPostOrder, 2);

  drainJobQueue();

  assertEq(a.isAsyncEvaluating, true);

  assertEq(a.status, StatusEvaluated);

  assertEq(a.asyncEvaluatingPostOrder, undefined);

  assertEq(b.isAsyncEvaluating, true);

  assertEq(b.status, StatusEvaluated);

  assertEq(b.asyncEvaluatingPostOrder, undefined);

  clearModules();

  let resolve;

  var promise = new Promise(r => { resolve = r; });

  let a = registerModule('a', parseModule('await promise;'));

  let b = registerModule('b', parseModule('await 2;'));

  let c = registerModule('c', parseModule('import {} from "a"; import {} from "b";'));

  moduleLink(c);

  moduleEvaluate(c);

  assertEq(a.isAsyncEvaluating, true);

  assertEq(a.status, StatusEvaluatingAsync);

  assertEq(a.asyncEvaluatingPostOrder, 1);

  assertEq(b.isAsyncEvaluating, true);

  assertEq(b.status, StatusEvaluatingAsync);

  assertEq(b.asyncEvaluatingPostOrder, 2);

  assertEq(c.isAsyncEvaluating, true);

  assertEq(c.status, StatusEvaluatingAsync);

  assertEq(c.asyncEvaluatingPostOrder, 3);

  resolve(1);

  drainJobQueue();

  assertEq(a.isAsyncEvaluating, true);

  assertEq(a.status, StatusEvaluated);

  assertEq(a.asyncEvaluatingPostOrder, undefined);

  assertEq(b.isAsyncEvaluating, true);

  assertEq(b.status, StatusEvaluated);

  assertEq(b.asyncEvaluatingPostOrder, undefined);

  assertEq(c.isAsyncEvaluating, true);

  assertEq(c.status, StatusEvaluated);

  assertEq(c.asyncEvaluatingPostOrder, undefined);

  clearModules();

  let a = registerModule('a', parseModule('throw 1;'));

  let b = registerModule('b', parseModule('import {} from "a"; await 2;'));

  moduleLink(b);

  moduleEvaluate(b).catch(() => 0);

  assertEq(a.status, StatusEvaluated);

  assertEq(a.isAsyncEvaluating, false);

  assertEq(a.evaluationError, 1);

  assertEq(b.status, StatusEvaluated);

  assertEq(b.isAsyncEvaluating, false);

  assertEq(b.evaluationError, 1);

  clearModules();

  let a = registerModule('a', parseModule('throw 1; await 2;'));

  let b = registerModule('b', parseModule('import {} from "a";'));

  moduleLink(b);

  moduleEvaluate(b).catch(() => 0);

  assertEq(a.isAsyncEvaluating, true);

  assertEq(a.status, StatusEvaluatingAsync);

  assertEq(b.isAsyncEvaluating, true);

  assertEq(b.status, StatusEvaluatingAsync);

  drainJobQueue();

  assertEq(a.isAsyncEvaluating, true);

  assertEq(a.status, StatusEvaluated);

  assertEq(a.evaluationError, 1);

  assertEq(a.asyncEvaluatingPostOrder, undefined);

  assertEq(b.isAsyncEvaluating, true);

  assertEq(b.status, StatusEvaluated);

  assertEq(b.evaluationError, 1);

  assertEq(b.asyncEvaluatingPostOrder, undefined);

  clearModules();

  let a = registerModule('a', parseModule('await 1; throw 2;'));

  let b = registerModule('b', parseModule('import {} from "a";'));

  moduleLink(b);

  moduleEvaluate(b).catch(() => 0);

  assertEq(a.isAsyncEvaluating, true);

  assertEq(a.status, StatusEvaluatingAsync);

  assertEq(b.isAsyncEvaluating, true);

  assertEq(b.status, StatusEvaluatingAsync);

  drainJobQueue();

  assertEq(a.isAsyncEvaluating, true);

  assertEq(a.status, StatusEvaluated);

  assertEq(a.evaluationError, 2);

  assertEq(a.asyncEvaluatingPostOrder, undefined);

  assertEq(b.isAsyncEvaluating, true);

  assertEq(b.status, StatusEvaluated);

  assertEq(b.evaluationError, 2);

  assertEq(b.asyncEvaluatingPostOrder, undefined);