Closed generator returns a completed object instead of throwing a error

test/mjsunit/harmony/generators-iteration.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 39 matching lines @@
 
 function TestGenerator(g, expected_values_for_next,
                        send_val, expected_values_for_send) {
   function testNext(thunk) {
     var iter = thunk();
     for (var i = 0; i < expected_values_for_next.length; i++) {
       assertIteratorResult(expected_values_for_next[i],
                            i == expected_values_for_next.length - 1,
                            iter.next());
     }
-    assertThrows(function() { iter.next(); }, Error);
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });

[wingo, 2014/01/13 13:44:49]

Consider factoring this common double-check out to assertIteratorFinished, and
using that here and below.

[yusukesuzuki, 2014/01/13 14:27:51]

Introduced assertIteratorIsClosed and assertThrownIteratorIsClosed and used
them.
When v8:3096 is fixed, we can remove commented code in
assertThrownIteratorIsClosed.

   }
   function testSend(thunk) {
     var iter = thunk();
     for (var i = 0; i < expected_values_for_send.length; i++) {
       assertIteratorResult(expected_values_for_send[i],
                            i == expected_values_for_send.length - 1,
                            iter.next(send_val));
     }
-    assertThrows(function() { iter.next(send_val); }, Error);
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(send_val); });
   }
   function testThrow(thunk) {
     for (var i = 0; i < expected_values_for_next.length; i++) {
       var iter = thunk();
       for (var j = 0; j < i; j++) {
         assertIteratorResult(expected_values_for_next[j],
                              j == expected_values_for_next.length - 1,
                              iter.next());
       }
       function Sentinel() {}
       assertThrows(function () { iter.throw(new Sentinel); }, Sentinel);
-      assertThrows(function () { iter.next(); }, Error);
+      // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+      // following tests are failed.
+      // https://code.google.com/p/v8/issues/detail?id=3096
+      /*
+      assertIteratorResult(undefined, true, iter.next());
+      assertDoesNotThrow(function() { iter.next(); });
+      */

[wingo, 2014/01/13 13:44:49]

The correct check is assertThrows(iter.next.bind(iter), TypeError), no?  (Per
http://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume)

[yusukesuzuki, 2014/01/13 14:27:51]

When iter.throw is executed and inserted error doesn't caught in the generator,
iter.throw propagates the error and iter's status becomes "completed"
(25.3.3.1-4-b and 25.3.3.1-4-d). So after that, `iter.next()` returns { value:
undefined, done: true } since iter's status is "completed". (25.3.3.2-5)

     }
   }
 
   testNext(g);
   testSend(g);
   testThrow(g);
 
   testNext(function*() { return yield* g(); });
   testSend(function*() { return yield* g(); });
   testThrow(function*() { return yield* g(); });
@@ skipping 295 matching lines @@
 
 function TestTryCatch(instantiate) {
   function* g() { yield 1; try { yield 2; } catch (e) { yield e; } yield 3; }
   function Sentinel() {}
 
   function Test1(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     assertIteratorResult(3, false, iter.next());
     assertIteratorResult(undefined, true, iter.next());
-    assertThrows(function() { iter.next(); }, Error);
+    assertDoesNotThrow(function() { iter.next(); });
   }
   Test1(instantiate(g));
 
   function Test2(iter) {
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test2(instantiate(g));
 
   function Test3(iter) {
     assertIteratorResult(1, false, iter.next());
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test3(instantiate(g));
 
   function Test4(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     var exn = new Sentinel;
     assertIteratorResult(exn, false, iter.throw(exn));
     assertIteratorResult(3, false, iter.next());
     assertIteratorResult(undefined, true, iter.next());
-    assertThrows(function() { iter.next(); }, Error);
+    assertDoesNotThrow(function() { iter.next(); });
   }
   Test4(instantiate(g));
 
   function Test5(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     var exn = new Sentinel;
     assertIteratorResult(exn, false, iter.throw(exn));
     assertIteratorResult(3, false, iter.next());
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
-
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test5(instantiate(g));
 
   function Test6(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     var exn = new Sentinel;
     assertIteratorResult(exn, false, iter.throw(exn));
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test6(instantiate(g));
 
   function Test7(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     assertIteratorResult(3, false, iter.next());
     assertIteratorResult(undefined, true, iter.next());
-    assertThrows(function() { iter.next(); }, Error);
+    assertDoesNotThrow(function() { iter.next(); });
   }
   Test7(instantiate(g));
 }
 TestTryCatch(function (g) { return g(); });
 TestTryCatch(function* (g) { return yield* g(); });
 
 function TestTryFinally(instantiate) {
   function* g() { yield 1; try { yield 2; } finally { yield 3; } yield 4; }
   function Sentinel() {}
   function Sentinel2() {}
 
   function Test1(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     assertIteratorResult(3, false, iter.next());
     assertIteratorResult(4, false, iter.next());
     assertIteratorResult(undefined, true, iter.next());
-    assertThrows(function() { iter.next(); }, Error);
+    assertDoesNotThrow(function() { iter.next(); });
   }
   Test1(instantiate(g));
 
   function Test2(iter) {
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test2(instantiate(g));
 
   function Test3(iter) {
     assertIteratorResult(1, false, iter.next());
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test3(instantiate(g));
 
   function Test4(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     assertIteratorResult(3, false, iter.throw(new Sentinel));
     assertThrows(function() { iter.next(); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
-
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test4(instantiate(g));
 
   function Test5(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     assertIteratorResult(3, false, iter.throw(new Sentinel));
     assertThrows(function() { iter.throw(new Sentinel2); }, Sentinel2);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test5(instantiate(g));
 
   function Test6(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     assertIteratorResult(3, false, iter.next());
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test6(instantiate(g));
 
   function Test7(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     assertIteratorResult(3, false, iter.next());
     assertIteratorResult(4, false, iter.next());
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test7(instantiate(g));
 
   function Test8(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     assertIteratorResult(3, false, iter.next());
     assertIteratorResult(4, false, iter.next());
     assertIteratorResult(undefined, true, iter.next());
-    assertThrows(function() { iter.next(); }, Error);
-
+    assertDoesNotThrow(function() { iter.next(); });
   }
   Test8(instantiate(g));
 }
 TestTryFinally(function (g) { return g(); });
 TestTryFinally(function* (g) { return yield* g(); });
 
 function TestNestedTry(instantiate) {
   function* g() {
     try {
       yield 1;
       try { yield 2; } catch (e) { yield e; }
       yield 3;
     } finally {
       yield 4;
     }
     yield 5;
   }
   function Sentinel() {}
   function Sentinel2() {}
 
   function Test1(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     assertIteratorResult(3, false, iter.next());
     assertIteratorResult(4, false, iter.next());
     assertIteratorResult(5, false, iter.next());
     assertIteratorResult(undefined, true, iter.next());
-    assertThrows(function() { iter.next(); }, Error);
+    assertDoesNotThrow(function() { iter.next(); });
   }
   Test1(instantiate(g));
 
   function Test2(iter) {
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test2(instantiate(g));
 
   function Test3(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(4, false, iter.throw(new Sentinel));
     assertThrows(function() { iter.next(); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test3(instantiate(g));
 
   function Test4(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(4, false, iter.throw(new Sentinel));
     assertThrows(function() { iter.throw(new Sentinel2); }, Sentinel2);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test4(instantiate(g));
 
   function Test5(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     var exn = new Sentinel;
     assertIteratorResult(exn, false, iter.throw(exn));
     assertIteratorResult(3, false, iter.next());
     assertIteratorResult(4, false, iter.next());
     assertIteratorResult(5, false, iter.next());
     assertIteratorResult(undefined, true, iter.next());
-    assertThrows(function() { iter.next(); }, Error);
-
+    assertDoesNotThrow(function() { iter.next(); });
   }
   Test5(instantiate(g));
 
   function Test6(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     var exn = new Sentinel;
     assertIteratorResult(exn, false, iter.throw(exn));
     assertIteratorResult(4, false, iter.throw(new Sentinel2));
     assertThrows(function() { iter.next(); }, Sentinel2);
-    assertThrows(function() { iter.next(); }, Error);
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test6(instantiate(g));
 
   function Test7(iter) {
     assertIteratorResult(1, false, iter.next());
     assertIteratorResult(2, false, iter.next());
     var exn = new Sentinel;
     assertIteratorResult(exn, false, iter.throw(exn));
     assertIteratorResult(3, false, iter.next());
     assertIteratorResult(4, false, iter.throw(new Sentinel2));
     assertThrows(function() { iter.next(); }, Sentinel2);
-    assertThrows(function() { iter.next(); }, Error);
-
+    // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+    // following tests are failed.
+    // https://code.google.com/p/v8/issues/detail?id=3096
+    /*
+    assertIteratorResult(undefined, true, iter.next());
+    assertDoesNotThrow(function() { iter.next(); });
+    */
   }
   Test7(instantiate(g));
 
   // That's probably enough.
 }
 TestNestedTry(function (g) { return g(); });
 TestNestedTry(function* (g) { return yield* g(); });
 
 function TestRecursion() {
   function TestNextRecursion() {
     function* g() { yield iter.next(); }
     var iter = g();
     return iter.next();
   }
   function TestSendRecursion() {
     function* g() { yield iter.next(42); }
     var iter = g();
     return iter.next();
   }
   function TestThrowRecursion() {
     function* g() { yield iter.throw(1); }
     var iter = g();
     return iter.next();
   }
   assertThrows(TestNextRecursion, Error);
   assertThrows(TestSendRecursion, Error);
   assertThrows(TestThrowRecursion, Error);
 }
 TestRecursion();