tor-browser

from_async.js (7620B)

---

// |reftest| skip-if(!xulRuntime.shell) -- needs drainJobQueue

// Basic Smoke Test
async function* asyncGen(n) {
 for (let i = 0; i < n; i++) {
   yield i * 2;
 }
}

let done = false;
Array.fromAsync(asyncGen(4)).then((x) => {
 assertEq(Array.isArray(x), true);
 assertEq(x.length, 4);
 assertEq(x[0], 0);
 assertEq(x[1], 2);
 assertEq(x[2], 4);
 assertEq(x[3], 6);
 done = true;
}
);

drainJobQueue();
assertEq(done, true);

(async function () {
 class InterruptableAsyncIterator {
   count = 0
   closed = false
   throwAfter = NaN
   constructor(n, throwAfter = NaN) {
     this.count = n;
     this.throwAfter = throwAfter;
   }
   [Symbol.asyncIterator] = function () {
     return {
       iter: this,
       i: 0,
       async next() {
         if (this.i > this.iter.throwAfter) {
           throw "Exception"
         }
         if (this.i++ < this.iter.count) {
           return Promise.resolve({ done: false, value: this.i - 1 });
         }
         return Promise.resolve({ done: true, value: undefined });
       },
       async return(x) {
         this.iter.closed = true;
         return { value: x, done: true };
       }
     }
   }
 }

 var one = await Array.fromAsync(new InterruptableAsyncIterator(2));
 assertEq(one.length, 2)
 assertEq(one[0], 0);
 assertEq(one[1], 1);

 var two = new InterruptableAsyncIterator(10, 2);
 var threw = false;
 try {
   var res = await Array.fromAsync(two);
 } catch (e) {
   threw = true;
   assertEq(e, "Exception");
 }
 assertEq(threw, true);
 // The iterator is not closed unless we have an abrupt completion while mapping.
 assertEq(two.closed, false);

 // Test throwing while mapping: Iterator should be closed.
 var three = new InterruptableAsyncIterator(10, 9);
 threw = false;
 try {
   var res = await Array.fromAsync(three, (x) => {
     if (x > 3) {
       throw "Range"
     }
     return x;
   });
 } catch (e) {
   assertEq(e, "Range");
   threw = true;
 }
 assertEq(threw, true);
 assertEq(three.closed, true);

 var sync = await Array.fromAsync([1, 2, 3]);
 assertEq(sync.length, 3);
 assertEq(sync[0], 1)
 assertEq(sync[1], 2)
 assertEq(sync[2], 3)

 let closed_frozen = false;
 class Frozen {
   constructor(x) {
     this.count = x;
     Object.freeze(this);
   }
   [Symbol.asyncIterator] = function () {
     return {
       iter: this,
       i: 0,
       async next() {
         if (this.i++ < this.iter.count) {
           return Promise.resolve({ done: false, value: this.i - 1 });
         }
         return Promise.resolve({ done: true, value: undefined });
       },
       async return(x) {
         // Can't use Frozen instance, becuse frozen is frozen.
         closed_frozen = true;
         return { value: x, done: true };
       }
     }
   }
 }

 // We should close the iterator when define property throws.
 // Test by defining into a frozen object. 
 var frozen = new Frozen(10);
 threw = false;
 try {
   var result = await Array.fromAsync.call(Frozen, frozen);
 } catch (e) {
   threw = true;
 }

 assertEq(threw, true);
 assertEq(closed_frozen, true);

})();

drainJobQueue();

(async function () {
 var badSyncIterator = {
   [Symbol.iterator]() {
     return null;
   }
 };

 var badAsyncIterator = {
   [Symbol.asyncIterator]() {
     return null;
   }
 };

 async function errorMessage(fn) {
   try {
     await fn();
   } catch (e) {
     return e.message;
   }
   throw new Error("missing error");
 }

 // Ensure Array.from and Array.fromAsync use consistent error reporting.
 var expected = await errorMessage(() => Array.from(badSyncIterator));
 var actual = await errorMessage(() => Array.fromAsync(badSyncIterator));
 assertEq(actual, expected);

 // Ensure for-of iteration and Array.fromAsync use consistent error reporting.
 var expected = await errorMessage(() => { for (var _ of badSyncIterator); });
 var actual = await errorMessage(() => Array.fromAsync(badSyncIterator));
 assertEq(actual, expected);

 // Ensure await for-of iteration and Array.fromAsync use consistent error reporting.
 var expected = await errorMessage(async () => { for await (var _ of badAsyncIterator); });
 var actual = await errorMessage(() => Array.fromAsync(badAsyncIterator));
 assertEq(actual, expected);
})();

drainJobQueue();

(async function () {
 function* gen() {
   for (let i = 0; i < 4; ++i) {
     yield Promise.resolve(i);
   }
 };

 var array = await Array.fromAsync(gen());

 // Promise values are unwrapped via AsyncFromSyncIterator.
 assertEqArray(array, [0, 1, 2, 3]);
})();

drainJobQueue();

(async function () {
 var badSyncIterator = {
   [Symbol.iterator]: 123,
 };

 var badAsyncIterator = {
   [Symbol.asyncIterator]: 123,
 };

 async function errorMessage(fn) {
   try {
     await fn();
   } catch (e) {
     return e.message;
   }
   throw new Error("missing error");
 }

 // Ensure Array.from and Array.fromAsync use consistent error reporting.
 var expected = await errorMessage(() => Array.from(badSyncIterator));
 var actual = await errorMessage(() => Array.fromAsync(badSyncIterator));
 assertEq(actual.endsWith("is not iterable"), expected.endsWith("is not iterable"));

 // Ensure for-of iteration and Array.fromAsync use consistent error reporting.
 var expected = await errorMessage(() => { for (var _ of badSyncIterator); });
 var actual = await errorMessage(() => Array.fromAsync(badSyncIterator));
 assertEq(actual.endsWith("is not iterable"), expected.endsWith("is not iterable"));

 // Ensure await for-of iteration and Array.fromAsync use consistent error reporting.
 var expected = await errorMessage(async () => { for await (var _ of badAsyncIterator); });
 var actual = await errorMessage(() => Array.fromAsync(badAsyncIterator));
 assertEq(actual.endsWith("is not iterable"), expected.endsWith("is not iterable"));
})();

drainJobQueue();


var g = newGlobal();
g.asyncGen = asyncGen;
var p = g.evaluate(`
Array.fromAsync(asyncGen(4))
`)

p.then((x) => {
 assertEq(x instanceof Array, false); // Should use the other global's Array.
 assertEq(x instanceof g.Array, true);
})

drainJobQueue();


var g2 = newGlobal({ newCompartment: true });
g2.asyncGen = asyncGen;
var p = g2.evaluate(`
Array.fromAsync(asyncGen(4))
`)

p.then((x) => {
 assertEq(x instanceof Array, false); // Should use the other global's Array.
 assertEq(x instanceof g2.Array, true);
 nukeCCW(x); // this will throw if x happens to not be a CCW (it should be!)
})
drainJobQueue();

// Test having a CCW 'this' value.
g2.obj = {};
var p2 = g2.evaluate(`
Array.fromAsync.call(obj, asyncGen(4))
`)

p2.then((x) => {
 assertEq(x instanceof Array, false); // Should use the other global's Array.
 assertEq(x instanceof g2.Array, true);
 nukeCCW(x);
})

drainJobQueue();

// Verify user promise resolution behaviour.
var myThenCalled = false;
var obj = { then: () => { myThenCalled = true; } }
function* genO() {
 yield obj;
 return;
}

var res = Array.fromAsync(genO());
res.then((x) => {
 assertEq(x[0], obj);
 assertEq(myThenCalled, true);
});

drainJobQueue();

function* thrower() {
 throw new Error();
}

g2.thrower = thrower;
var p = g2.evaluate(`Array.fromAsync(thrower())`)
p.catch((e) => {
 assertEq(e instanceof Error, true, "Should throw an error from the current global");
})
drainJobQueue();

p = g2.evaluate(`Array.fromAsync(thrower, 1)`);
p.catch((e) => assertEq(e instanceof g2.Error, true, "Should throw error from g2"))
drainJobQueue();

if (typeof reportCompare === 'function')
 reportCompare(true, true);