Reflect recent spec changes to V8 Extra ReadableStream impl

third_party/WebKit/LayoutTests/http/tests/streams/readable-streams/general.js

 'use strict';
 
 if (self.importScripts) {
   self.importScripts('../resources/test-utils.js');
   self.importScripts('../resources/rs-utils.js');
   self.importScripts('/resources/testharness.js');
 }
 
 test(() => {
 
   new ReadableStream(); // ReadableStream constructed with no parameters
   new ReadableStream({ }); // ReadableStream constructed with an empty object as parameter
+  new ReadableStream({ type: undefined }); // ReadableStream constructed with undefined type
   new ReadableStream(undefined); // ReadableStream constructed with undefined as parameter
 
   let x;
   new ReadableStream(x); // ReadableStream constructed with an undefined variable as parameter
 
 }, 'ReadableStream can be constructed with no errors');
 
 test(() => {
 
   assert_throws(new TypeError(), () => new ReadableStream(null), 'constructor should throw when the source is null');
 
 }, 'ReadableStream can\'t be constructed with garbage');
 
 test(() => {
 
+  assert_throws(new RangeError(), () => new ReadableStream({ type: null }),
+    'constructor should throw when the type is null');
+  assert_throws(new RangeError(), () => new ReadableStream({ type: '' }),
+    'constructor should throw when the type is empty string');
+  assert_throws(new RangeError(), () => new ReadableStream({ type: 'asdf' }),
+    'constructor should throw when the type is asdf');
+
+}, 'ReadableStream can\'t be constructed with an invalid type');
+
+test(() => {
+
   const methods = ['cancel', 'constructor', 'getReader', 'tee'];
   const properties = methods.concat(['locked']).sort();
 
   const rs = new ReadableStream();
   const proto = Object.getPrototypeOf(rs);
 
   assert_array_equals(Object.getOwnPropertyNames(proto).sort(), properties, 'should have all the correct methods');
 
   for (const m of methods) {
     const propDesc = Object.getOwnPropertyDescriptor(proto, m);
@@ skipping 61 matching lines @@
       }
 
       const desiredSizePropDesc = Object.getOwnPropertyDescriptor(proto, 'desiredSize');
       assert_false(desiredSizePropDesc.enumerable, 'desiredSize should be non-enumerable');
       assert_equals(desiredSizePropDesc.writable, undefined, 'desiredSize should not be a data property');
       assert_equals(typeof desiredSizePropDesc.get, 'function', 'desiredSize should have a getter');
       assert_equals(desiredSizePropDesc.set, undefined, 'desiredSize should not have a setter');
       assert_true(desiredSizePropDesc.configurable, 'desiredSize should be configurable');
 
       assert_equals(controller.close.length, 0, 'close should have no parameters');
-      assert_equals(controller.constructor.length, 1, 'constructor should have 1 parameter');
+      assert_equals(controller.constructor.length, 5, 'constructor should have 4 parameter');
       assert_equals(controller.enqueue.length, 1, 'enqueue should have 1 parameter');
       assert_equals(controller.error.length, 1, 'error should have 1 parameter');
 
       startCalled = true;
     }
   };
 
   new ReadableStream(source);
   assert_true(startCalled);
 
@@ skipping 479 matching lines @@
     }
   });
 
   const reader = rs.getReader();
   return reader.closed.then(() => {
     assert_true(pullCalled);
   });
 
 }, 'ReadableStream pull should be able to close a stream.');
 
-test(() => {
+promise_test(t => {
 
-  let startCalled = false;
+  const controllerError = { name: 'controller error' };
 
-  new ReadableStream({
-    start(c) {
-      assert_equals(c.enqueue('a'), undefined, 'the first enqueue should return undefined');
-      c.close();
-
-      assert_throws(new TypeError(), () => c.enqueue('b'), 'enqueue after close should throw a TypeError');
-      startCalled = true;
+  const rs = new ReadableStream({
+    pull(c) {
+      c.error(controllerError);
     }
   });
 
-  assert_true(startCalled);
+  return promise_rejects(t, controllerError, rs.getReader().closed);
 
-}, 'ReadableStream: enqueue should throw when the stream is readable but draining');
+}, 'ReadableStream pull should be able to error a stream.');
+
+promise_test(t => {
+
+  const controllerError = { name: 'controller error' };
+  const thrownError = { name: 'thrown error' };
+
+  const rs = new ReadableStream({
+    pull(c) {
+      c.error(controllerError);
+      throw thrownError;
+    }
+  });
+
+  return promise_rejects(t, controllerError, rs.getReader().closed);
+
+}, 'ReadableStream pull should be able to error a stream and throw.');
 
 test(() => {
 
   let startCalled = false;
 
   new ReadableStream({
     start(c) {
+      assert_equals(c.enqueue('a'), undefined, 'the first enqueue should return undefined');
+      c.close();
+
+      assert_throws(new TypeError(), () => c.enqueue('b'), 'enqueue after close should throw a TypeError');
+      startCalled = true;
+    }
+  });
+
+  assert_true(startCalled);
+
+}, 'ReadableStream: enqueue should throw when the stream is readable but draining');
+
+test(() => {
+
+  let startCalled = false;
+
+  new ReadableStream({
+    start(c) {
       c.close();
 
       assert_throws(new TypeError(), () => c.enqueue('a'), 'enqueue after close should throw a TypeError');
       startCalled = true;
     }
   });
 
   assert_true(startCalled);
 
 }, 'ReadableStream: enqueue should throw when the stream is closed');
 
-test(() => {
-
-  let startCalled = false;
-  const expectedError = new Error('i am sad');
-
-  new ReadableStream({
-    start(c) {
-      c.error(expectedError);
-
-      assert_throws(expectedError, () => c.enqueue('a'), 'enqueue after error should throw that error');
-      startCalled = true;
-    }
-  });
-
-  assert_true(startCalled);
-
-}, 'ReadableStream: enqueue should throw the stored error when the stream is errored');
-
 promise_test(() => {
 
   let startCalled = 0;
   let pullCalled = 0;
   let cancelCalled = 0;
 
   /* eslint-disable no-use-before-define */
   class Source {
     start(c) {
       startCalled++;
@@ skipping 148 matching lines @@
   const rs = sequentialReadableStream(10, { async: true });
 
   return readableStreamToArray(rs).then(chunks => {
     assert_true(rs.source.closed, 'source should be closed after all chunks are read');
     assert_array_equals(chunks, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'the expected 10 chunks should be read');
   });
 
 }, 'ReadableStream integration test: adapting an async pull source');
 
 done();