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 17 matching lines @@
 // Flags: --harmony-generators --expose-gc
 
 // Test generator iteration.
 
 var GeneratorFunction = (function*(){yield 1;}).__proto__.constructor;
 
 function assertIteratorResult(value, done, result) {
   assertEquals({ value: value, done: done}, result);
 }
 
+function assertIteratorIsClosed(iter) {
+  assertIteratorResult(undefined, true, iter.next());
+  assertDoesNotThrow(function() { iter.next(); });
+}
+
+function assertThrownIteratorIsClosed(iter) {
+  // TODO(yusukesuzuki): Since status of a thrown generator is "executing",
+  // following tests are failed.
+  // https://code.google.com/p/v8/issues/detail?id=3096
+  // assertIteratorIsClosed(iter);
+}
+
 function TestGeneratorResultPrototype() {
   function* g() { yield 1; }
   var iter = g();
   var result = iter.next();
 
   assertSame(Object.prototype, Object.getPrototypeOf(result));
   property_names = Object.getOwnPropertyNames(result);
   property_names.sort();
   assertEquals(["done", "value"], property_names);
   assertIteratorResult(1, false, result);
 }
 TestGeneratorResultPrototype()
 
 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);
+    assertIteratorIsClosed(iter);
   }
   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);
+    assertIteratorIsClosed(iter);
   }
   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);
+      assertThrownIteratorIsClosed(iter);
     }
   }
 
   testNext(g);
   testSend(g);
   testThrow(g);
 
   testNext(function*() { return yield* g(); });
   testSend(function*() { return yield* g(); });
   testThrow(function*() { return yield* g(); });
@@ skipping 294 matching lines @@
 TestDelegatingYield();
 
 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);
+    assertIteratorIsClosed(iter);
   }
   Test1(instantiate(g));
 
   function Test2(iter) {
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    assertThrownIteratorIsClosed(iter);
   }
   Test2(instantiate(g));
 
   function Test3(iter) {
     assertIteratorResult(1, false, iter.next());
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    assertThrownIteratorIsClosed(iter);
   }
   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);
+    assertIteratorIsClosed(iter);
   }
   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);
-
+    assertThrownIteratorIsClosed(iter);
   }
   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);
+    assertThrownIteratorIsClosed(iter);
   }
   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);
+    assertIteratorIsClosed(iter);
   }
   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);
+    assertIteratorIsClosed(iter);
   }
   Test1(instantiate(g));
 
   function Test2(iter) {
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    assertThrownIteratorIsClosed(iter);
   }
   Test2(instantiate(g));
 
   function Test3(iter) {
     assertIteratorResult(1, false, iter.next());
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    assertThrownIteratorIsClosed(iter);
   }
   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);
-
+    assertThrownIteratorIsClosed(iter);
   }
   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);
+    assertThrownIteratorIsClosed(iter);
   }
   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);
+    assertThrownIteratorIsClosed(iter);
   }
   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);
+    assertThrownIteratorIsClosed(iter);
   }
   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);
-
+    assertIteratorIsClosed(iter);
   }
   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);
+    assertIteratorIsClosed(iter);
   }
   Test1(instantiate(g));
 
   function Test2(iter) {
     assertThrows(function() { iter.throw(new Sentinel); }, Sentinel);
-    assertThrows(function() { iter.next(); }, Error);
+    assertThrownIteratorIsClosed(iter);
   }
   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);
+    assertThrownIteratorIsClosed(iter);
   }
   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);
+    assertThrownIteratorIsClosed(iter);
   }
   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);
-
+    assertIteratorIsClosed(iter);
   }
   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);
+    assertThrownIteratorIsClosed(iter);
   }
   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);
-
+    assertThrownIteratorIsClosed(iter);
   }
   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();