Throw a TypeError when calling "next" method of a newly created generator with a value

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 56 matching lines @@
     for (var i = 0; i < expected_values_for_next.length; i++) {
       var v1 = expected_values_for_next[i];
       var v2 = i == expected_values_for_next.length - 1;
       // var v3 = iter.next();
       assertIteratorResult(v1, v2, iter.next());
     }
     assertIteratorIsClosed(iter);
   }
   function testSend(thunk) {
     var iter = thunk();
-    for (var i = 0; i < expected_values_for_send.length; i++) {
+    // Throw error when sending a value to a newly created generator.
+    if (expected_values_for_send.length > 0) {
+        assertThrows(function () { iter.next(send_val); }, TypeError);
+        assertIteratorResult(expected_values_for_send[0], 0 == expected_values_for_send.length - 1, iter.next());
+    }
+    for (var i = 1; i < expected_values_for_send.length; i++) {
       assertIteratorResult(expected_values_for_send[i],
                            i == expected_values_for_send.length - 1,
                            iter.next(send_val));
     }
     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++) {
@@ skipping 553 matching lines @@
   function TestThrowRecursion() {
     function* g() { yield iter.throw(1); }
     var iter = g();
     return iter.next();
   }
   assertThrows(TestNextRecursion, Error);
   assertThrows(TestSendRecursion, Error);
   assertThrows(TestThrowRecursion, Error);
 }
 TestRecursion();
+
+function TestNewlyCreated(instantiate) {
+    function * g() { return yield 1; }
+
+    function Test1(iter) {
+        assertThrows(function () { iter.next(1); }, TypeError);
+        // Iterator is still "suspendedStart" state.
+        assertThrows(function () { iter.next(1); }, TypeError);
+        assertIteratorResult(1, false, iter.next());
+        assertIteratorResult(2, true, iter.next(2));
+        assertIteratorIsClosed(iter);
+    }
+    Test1(instantiate(g));
+
+    function Test1(iter) {
+        // If a provided value is undefined, iter with "suspendedStart" status
+        // doesn't throw an error.
+        assertIteratorResult(1, false, iter.next(undefined));
+        assertIteratorResult(2, true, iter.next(2));
+        assertIteratorIsClosed(iter);
+    }
+    Test1(instantiate(g));
+
+    function Test2(iter) {
+        function Sentinel() { }
+        assertThrows(function () { iter.throw(new Sentinel); }, Sentinel);
+        // When calling throw method to an newly created iterator, it becomes
+        // "completed" state.
+        assertThrownIteratorIsClosed(iter);
+    }
+    Test2(instantiate(g));
+}
+TestNewlyCreated(function (g) { return g(); });
+TestNewlyCreated(function* (g) { return yield* g(); });