tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

yield-star-sync-next.js (6812B)


      1 // |reftest| async
      2 // This file was procedurally generated from the following sources:
      3 // - src/async-generators/yield-star-sync-next.case
      4 // - src/async-generators/default/async-declaration.template
      5 /*---
      6 description: execution order for yield* with sync iterator and next() (Async generator Function declaration)
      7 esid: prod-AsyncGeneratorDeclaration
      8 features: [Symbol.iterator, async-iteration, Symbol.asyncIterator]
      9 flags: [generated, async]
     10 info: |
     11    Async Generator Function Definitions
     12 
     13    AsyncGeneratorDeclaration:
     14      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
     15        AsyncGeneratorBody }
     16 
     17 
     18    YieldExpression: yield * AssignmentExpression
     19 
     20    ...
     21    2. Let value be ? GetValue(exprRef).
     22    3. Let generatorKind be ! GetGeneratorKind().
     23    4. Let iterator be ? GetIterator(value, generatorKind).
     24    5. Let received be NormalCompletion(undefined).
     25    6. Repeat
     26      a. If received.[[Type]] is normal, then
     27        i. Let innerResult be ? IteratorNext(iterator, received.[[Value]]).
     28        ii. Let innerResult be ? Invoke(iterator, "next",
     29            « received.[[Value]] »).
     30        iii. If generatorKind is async, then set innerResult to
     31             ? Await(innerResult).
     32        ...
     33        v. Let done be ? IteratorComplete(innerResult).
     34        vi. If done is true, then
     35           1. Return ? IteratorValue(innerResult).
     36        vii. Let received be GeneratorYield(innerResult).
     37      ...
     38 
     39    GetIterator ( obj [ , hint ] )
     40 
     41    ...
     42    3. If hint is async,
     43      a. Set method to ? GetMethod(obj, @@asyncIterator).
     44      b. If method is undefined,
     45        i. Let syncMethod be ? GetMethod(obj, @@iterator).
     46        ii. Let syncIterator be ? Call(syncMethod, obj).
     47        iii. Return ? CreateAsyncFromSyncIterator(syncIterator).
     48    ...
     49 
     50    %AsyncFromSyncIteratorPrototype%.next ( value )
     51 
     52    ...
     53    5. Let nextResult be IteratorNext(syncIterator, value).
     54    ...
     55    7. Let nextValue be IteratorValue(nextResult).
     56    ...
     57    9. Let nextDone be IteratorComplete(nextResult).
     58    ...
     59    12. Perform ! Call(valueWrapperCapability.[[Resolve]], undefined,
     60        « nextValue »).
     61    ...
     62    14. Set onFulfilled.[[Done]] to nextDone.
     63    15. Perform ! PerformPromiseThen(valueWrapperCapability.[[Promise]],
     64        onFulfilled, undefined, promiseCapability).
     65    ...
     66 
     67    Async Iterator Value Unwrap Functions
     68 
     69    1. Return ! CreateIterResultObject(value, F.[[Done]]).
     70 
     71 ---*/
     72 var log = [];
     73 var obj = {
     74  get [Symbol.iterator]() {
     75    log.push({
     76      name: "get [Symbol.iterator]",
     77      thisValue: this
     78    });
     79    return function() {
     80      log.push({
     81        name: "call [Symbol.iterator]",
     82        thisValue: this,
     83        args: [...arguments]
     84      });
     85      var nextCount = 0;
     86      return {
     87        name: "syncIterator",
     88        get next() {
     89          log.push({
     90            name: "get next",
     91            thisValue: this
     92          });
     93          return function() {
     94            log.push({
     95              name: "call next",
     96              thisValue: this,
     97              args: [...arguments]
     98            });
     99 
    100            nextCount++;
    101            if (nextCount == 1) {
    102              return {
    103                name: "next-result-1",
    104                get value() {
    105                  log.push({
    106                    name: "get next value (1)",
    107                    thisValue: this
    108                  });
    109                  return "next-value-1";
    110                },
    111                get done() {
    112                  log.push({
    113                    name: "get next done (1)",
    114                    thisValue: this
    115                  });
    116                  return false;
    117                }
    118              };
    119            }
    120 
    121            return {
    122              name: "next-result-2",
    123              get value() {
    124                log.push({
    125                  name: "get next value (2)",
    126                  thisValue: this
    127                });
    128                return "next-value-2";
    129              },
    130              get done() {
    131                log.push({
    132                  name: "get next done (2)",
    133                  thisValue: this
    134                });
    135                return true;
    136              }
    137            };
    138          };
    139        }
    140      };
    141    };
    142  },
    143  get [Symbol.asyncIterator]() {
    144    log.push({ name: "get [Symbol.asyncIterator]" });
    145    return null;
    146  }
    147 };
    148 
    149 
    150 
    151 var callCount = 0;
    152 
    153 async function *gen() {
    154  callCount += 1;
    155  log.push({ name: "before yield*" });
    156    var v = yield* obj;
    157    log.push({
    158      name: "after yield*",
    159      value: v
    160    });
    161    return "return-value";
    162 
    163 }
    164 
    165 var iter = gen();
    166 
    167 assert.sameValue(log.length, 0, "log.length");
    168 
    169 iter.next("next-arg-1").then(v => {
    170  assert.sameValue(log[0].name, "before yield*");
    171 
    172  assert.sameValue(log[1].name, "get [Symbol.asyncIterator]");
    173 
    174  assert.sameValue(log[2].name, "get [Symbol.iterator]");
    175  assert.sameValue(log[2].thisValue, obj, "get [Symbol.iterator] thisValue");
    176 
    177  assert.sameValue(log[3].name, "call [Symbol.iterator]");
    178  assert.sameValue(log[3].thisValue, obj, "[Symbol.iterator] thisValue");
    179  assert.sameValue(log[3].args.length, 0, "[Symbol.iterator] args.length");
    180 
    181  assert.sameValue(log[4].name, "get next");
    182  assert.sameValue(log[4].thisValue.name, "syncIterator", "get next thisValue");
    183 
    184  assert.sameValue(log[5].name, "call next");
    185  assert.sameValue(log[5].thisValue.name, "syncIterator", "next thisValue");
    186  assert.sameValue(log[5].args.length, 1, "next args.length");
    187  assert.sameValue(log[5].args[0], undefined, "next args[0]");
    188 
    189  assert.sameValue(log[6].name, "get next done (1)");
    190  assert.sameValue(log[6].thisValue.name, "next-result-1", "get next done thisValue");
    191 
    192  assert.sameValue(log[7].name, "get next value (1)");
    193  assert.sameValue(log[7].thisValue.name, "next-result-1", "get next value thisValue");
    194 
    195  assert.sameValue(v.value, "next-value-1");
    196  assert.sameValue(v.done, false);
    197 
    198  assert.sameValue(log.length, 8, "log.length");
    199 
    200  iter.next("next-arg-2").then(v => {
    201    assert.sameValue(log[8].name, "call next");
    202    assert.sameValue(log[8].thisValue.name, "syncIterator", "next thisValue");
    203    assert.sameValue(log[8].args.length, 1, "next args.length");
    204    assert.sameValue(log[8].args[0], "next-arg-2", "next args[0]");
    205 
    206    assert.sameValue(log[9].name, "get next done (2)");
    207    assert.sameValue(log[9].thisValue.name, "next-result-2", "get next done thisValue");
    208 
    209    assert.sameValue(log[10].name, "get next value (2)");
    210    assert.sameValue(log[10].thisValue.name, "next-result-2", "get next value thisValue");
    211 
    212    assert.sameValue(log[11].name, "after yield*");
    213    assert.sameValue(log[11].value, "next-value-2");
    214 
    215    assert.sameValue(v.value, "return-value");
    216    assert.sameValue(v.done, true);
    217 
    218    assert.sameValue(log.length, 12, "log.length");
    219  }).then($DONE, $DONE);
    220 }).catch($DONE);
    221 
    222 assert.sameValue(callCount, 1);