Adding tests for RTCQuicStream.

Bug: 874296
Change-Id: I33e79a0641e38b420a23d0ff42933cd26bc0b368
Reviewed-on: https://chromium-review.googlesource.com/c/1341153
Commit-Queue: Seth Hampson <shampson@chromium.org>
Reviewed-by: Steve Anton <steveanton@chromium.org>
Cr-Commit-Position: refs/heads/master@{#611242}

third_party/blink/renderer/modules/peerconnection/rtc_quic_stream_test.cc

@@ -310,6 +310,38 @@ TEST_F(RTCQuicStreamTest, OnRemoteResetSetsWriteBufferedAmountToZero) {
   RunUntilIdle();
 }
 
+// Test that writeBufferedAmount is set to 0 if the stream calls finish(),
+// followed by receiving a finish from the remote side, and reading it out.
+//
+// TODO(https://crbug.com/874296): It doesn't really make sense the write buffer
+// gets cleared in this case. Consider changing this.
+TEST_F(RTCQuicStreamTest,
+       FinishThenReceiveFinishSetsWriteBufferedAmountToZero) {
+  V8TestingScope scope;
+
+  P2PQuicStream::Delegate* stream_delegate = nullptr;
+  auto p2p_quic_stream = std::make_unique<MockP2PQuicStream>(&stream_delegate);
+
+  Persistent<RTCQuicStream> stream =
+      CreateQuicStream(scope, p2p_quic_stream.get());
+  stream->write(CreateUint8ArrayOfLength(4), ASSERT_NO_EXCEPTION);
+  stream->finish();
+
+  RunUntilIdle();
+
+  ASSERT_TRUE(stream_delegate);
+  stream_delegate->OnDataReceived({}, /*fin=*/true);
+
+  RunUntilIdle();
+
+  EXPECT_EQ(4u, stream->writeBufferedAmount());
+  NotShared<DOMUint8Array> read_buffer(DOMUint8Array::Create(10));
+  EXPECT_TRUE(stream->readInto(read_buffer, ASSERT_NO_EXCEPTION)->finished());
+  EXPECT_EQ(0u, stream->writeBufferedAmount());
+
+  RunUntilIdle();
+}
+
 // Test that write throws an InvalidStateError if the stream was reset by the
 // remote peer.
 TEST_F(RTCQuicStreamTest, WriteThrowsIfRemoteReset) {
@@ -488,6 +520,34 @@ TEST_F(RTCQuicStreamTest,
             promise_90.V8Value().As<v8::Promise>()->State());
 }
 
+// Test that when receiving OnRemoteReset() the waitForWriteBufferedAmountBelow
+// Promise will be rejected.
+TEST_F(RTCQuicStreamTest,
+       WaitForWriteBufferedAmountBelowPromisesRejectedOnRemoteReset) {
+  V8TestingScope scope;
+
+  P2PQuicStream::Delegate* stream_delegate = nullptr;
+  auto p2p_quic_stream = std::make_unique<MockP2PQuicStream>(&stream_delegate);
+
+  Persistent<RTCQuicStream> stream =
+      CreateQuicStream(scope, p2p_quic_stream.get());
+  stream->write(CreateUint8ArrayOfLength(stream->maxWriteBufferedAmount()),
+                ASSERT_NO_EXCEPTION);
+
+  ScriptPromise promise = stream->waitForWriteBufferedAmountBelow(
+      scope.GetScriptState(), 0, ASSERT_NO_EXCEPTION);
+
+  RunUntilIdle();
+
+  ASSERT_TRUE(stream_delegate);
+  stream_delegate->OnRemoteReset();
+
+  RunUntilIdle();
+
+  EXPECT_EQ(v8::Promise::kRejected,
+            promise.V8Value().As<v8::Promise>()->State());
+}
+
 // Test that there is no crash when the ExecutionContext is being destroyed and
 // there are pending waitForWriteBufferedAmountBelow() promises. If the
 // RTCQuicStream attempts to resolve the promise in ContextDestroyed, it will
@@ -845,6 +905,32 @@ TEST_F(RTCQuicStreamTest, WaitForReadableResolveImmediately) {
   RunUntilIdle();
 }
 
+// Test that a waitForReadable() promise resolves immediately if finish has
+// been received, but not yet read out.
+TEST_F(RTCQuicStreamTest,
+       WaitForReadableResolveImmediatelyAfterFinishReceived) {
+  V8TestingScope scope;
+
+  P2PQuicStream::Delegate* stream_delegate = nullptr;
+  auto p2p_quic_stream = std::make_unique<MockP2PQuicStream>(&stream_delegate);
+  Persistent<RTCQuicStream> stream =
+      CreateQuicStream(scope, p2p_quic_stream.get());
+
+  RunUntilIdle();
+
+  ASSERT_TRUE(stream_delegate);
+  stream_delegate->OnDataReceived({}, /*fin=*/true);
+
+  RunUntilIdle();
+
+  ScriptPromise promise =
+      stream->waitForReadable(scope.GetScriptState(), 10, ASSERT_NO_EXCEPTION);
+  EXPECT_EQ(v8::Promise::kFulfilled,
+            promise.V8Value().As<v8::Promise>()->State());
+
+  RunUntilIdle();
+}
+
 // Test that a waitForReadable() promise does not resolve until OnDataReceived()
 // delivers at least the readable amount.
 TEST_F(RTCQuicStreamTest, WaitForReadableDoesNotResolveUntilExceedsThreshold) {
@@ -1001,9 +1087,8 @@ TEST_F(RTCQuicStreamTest, WaitForReadableResolvesImmediatelyIfRemoteFinished) {
 // The following group tests state transitions with reset(), finish(), remote
 // reset() and remote finish()
 
-// Test that a OnRemoteReset() immediately transitions the state to 'closed'
-// and clears any buffered data.
-TEST_F(RTCQuicStreamTest, OnRemoteResetTransitionsToClosedAndClearsBuffers) {
+// Test that a OnRemoteReset() immediately transitions the state to 'closed'.
+TEST_F(RTCQuicStreamTest, OnRemoteResetTransitionsToClosed) {
   V8TestingScope scope;
 
   P2PQuicStream::Delegate* stream_delegate = nullptr;
@@ -1011,26 +1096,15 @@ TEST_F(RTCQuicStreamTest, OnRemoteResetTransitionsToClosedAndClearsBuffers) {
   Persistent<RTCQuicStream> stream =
       CreateQuicStream(scope, p2p_quic_stream.get());
 
-  stream->write(CreateUint8Array({1, 2}), ASSERT_NO_EXCEPTION);
-
   RunUntilIdle();
 
   ASSERT_TRUE(stream_delegate);
-  stream_delegate->OnDataReceived({5, 6, 7, 8}, /*fin=*/false);
-
-  RunUntilIdle();
-
   EXPECT_EQ("open", stream->state());
-  EXPECT_EQ(2u, stream->writeBufferedAmount());
-  EXPECT_EQ(4u, stream->readBufferedAmount());
-
   stream_delegate->OnRemoteReset();
 
   RunUntilIdle();
 
   EXPECT_EQ("closed", stream->state());
-  EXPECT_EQ(0u, stream->writeBufferedAmount());
-  EXPECT_EQ(0u, stream->readBufferedAmount());
 
   RunUntilIdle();
 }

third_party/blink/web_tests/external/wpt/webrtc-quic/RTCQuicStream-helper.js

@@ -35,6 +35,43 @@ function closed_stream_test(test_func, description) {
     return test_func(t, remoteStream);
   }, 'Stream closed by remote reset(): ' + description);
 
+  promise_test(async t => {
+    const [ localQuicTransport, remoteQuicTransport ] =
+        await makeTwoConnectedQuicTransports(t);
+    const localStream = localQuicTransport.createStream();
+    localStream.finish();
+    const remoteWatcher =
+        new EventWatcher(t, remoteQuicTransport, 'quicstream');
+    const { stream: remoteStream } = await remoteWatcher.wait_for('quicstream');
+    remoteStream.finish();
+    await localStream.waitForReadable(localStream.maxReadBufferedAmount);
+    assert_object_equals(
+        localStream.readInto(new Uint8Array(10)),
+        { amount: 0, finished: true });
+    assert_equals(localStream.state, 'closed');
+    return test_func(t, localStream);
+  }, 'Stream closed by finish(), followed by reading remote finish: ' +
+      description);
+
+  promise_test(async t => {
+    const [ localQuicTransport, remoteQuicTransport ] =
+        await makeTwoConnectedQuicTransports(t);
+    const localStream = localQuicTransport.createStream();
+    localStream.write(new Uint8Array(1));
+    const remoteWatcher =
+        new EventWatcher(t, remoteQuicTransport, 'quicstream');
+    const { stream: remoteStream } = await remoteWatcher.wait_for('quicstream');
+    remoteStream.finish();
+    await localStream.waitForReadable(localStream.maxReadBufferedAmount);
+    assert_object_equals(
+        localStream.readInto(new Uint8Array(10)),
+        { amount: 0, finished: true });
+    localStream.finish();
+    assert_equals(localStream.state, 'closed');
+    return test_func(t, localStream);
+  }, 'Stream closed by by reading remote finish, followed by finish(): ' +
+      description);
+
   promise_test(async t => {
     const [ localQuicTransport, remoteQuicTransport ] =
         await makeTwoConnectedQuicTransports(t);

third_party/blink/web_tests/external/wpt/webrtc-quic/RTCQuicStream.https.html

@@ -119,12 +119,72 @@ promise_test(async t => {
 
 promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
-    await makeTwoConnectedQuicTransports(t);
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.finish();
+  const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream: remoteStream } = await remoteWatcher.wait_for('quicstream');
+  assert_equals(remoteStream.state, 'open');
+  const remoteStreamWatcher = new EventWatcher(t, remoteStream, 'statechange');
+  await remoteStream.waitForReadable(remoteStream.maxReadBufferedAmount);
+  assert_object_equals(
+      remoteStream.readInto(new Uint8Array(10)),
+      { amount: 0, finished: true } );
+  assert_equals(remoteStream.state, 'closing');
+}, 'waitForReadable() resolves with remote finish');
+
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.finish();
+  const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream: remoteStream } = await remoteWatcher.wait_for('quicstream');
+  await remoteStream.waitForReadable(remoteStream.maxReadBufferedAmount);
+  assert_object_equals(
+      remoteStream.readInto(new Uint8Array(10)),
+      { amount: 0, finished: true } );
+  assert_equals(remoteStream.state, 'closing');
+  remoteStream.finish()
+  assert_equals(remoteStream.state, 'closed');
+}, 'finish() on a stream that has already read out finish changes ' +
+    `state to 'closed'.`);
+
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.finish();
+  const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream: remoteStream } = await remoteWatcher.wait_for('quicstream');
+  remoteStream.finish();
+  assert_equals(localStream.state, 'closing');
+  await localStream.waitForReadable(localStream.maxReadBufferedAmount);
+  assert_object_equals(
+      localStream.readInto(new Uint8Array(10)),
+      { amount: 0, finished: true } );
+  assert_equals(localStream.state, 'closed');
+}, 'Reading out finish on stream that has already called finish()  ' +
+    `state to 'closed'.`);
+
+promise_test(async t => {
+    const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
   const localStream = localQuicTransport.createStream();
-  const promise = localStream.waitForReadable(1);
+  localStream.finish();
+  const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream: remoteStream } = await remoteWatcher.wait_for('quicstream');
+  await remoteStream.waitForReadable(remoteStream.maxReadBufferedAmount);
+  assert_object_equals(
+      remoteStream.readInto(new Uint8Array(10)),
+      { amount: 0, finished: true } );
+  assert_equals(remoteStream.state, 'closing');
   localStream.reset();
-  await promise_rejects(t, 'InvalidStateError', promise);
-}, 'reset() rejects pending waitForReadable() promises.');
+  const remoteStreamWatcher = new EventWatcher(t, remoteStream, 'statechange');
+  await remoteStreamWatcher.wait_for('statechange');
+  assert_equals(remoteStream.state, 'closed');
+}, 'Reading out finish then a getting a remote reset fires a statechange event ' +
+    `to 'closed'.`);
 
 promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
@@ -210,6 +270,36 @@ closed_stream_test(async (t, stream) => {
   assert_throws('InvalidStateError', () => stream.write(new Uint8Array()));
 }, 'write() throws InvalidStateError.');
 
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.write(generateData(10));
+  const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream : remoteStream} = await remoteWatcher.wait_for('quicstream');
+  await remoteStream.waitForReadable(10);
+  assert_equals(10, remoteStream.readBufferedAmount);
+  remoteStream.reset();
+  assert_equals(0, remoteStream.readBufferedAmount);
+}, 'readBufferedAmount set to 0 after local reset().');
+
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.write(generateData(10));
+  const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream : remoteStream} = await remoteWatcher.wait_for('quicstream');
+  await remoteStream.waitForReadable(10);
+  assert_equals(10, remoteStream.readBufferedAmount);
+  localStream.reset();
+  const remoteStreamWatcher =
+        new EventWatcher(t, remoteStream, 'statechange');
+  await remoteStreamWatcher.wait_for('statechange');
+  assert_equals(remoteStream.state, 'closed');
+  assert_equals(0, remoteStream.readBufferedAmount);
+}, 'readBufferedAmount set to 0 after remote reset().');
+
 promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
       await makeTwoConnectedQuicTransports(t);
@@ -219,6 +309,26 @@ promise_test(async t => {
   assert_equals(localStream.writeBufferedAmount, 0);
 }, 'writeBufferedAmount set to 0 after local reset().');
 
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.write(new Uint8Array(1));
+  const remoteWatcher =
+      new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream: remoteStream } = await remoteWatcher.wait_for('quicstream');
+  remoteStream.finish();
+  await localStream.waitForReadable(localStream.maxReadBufferedAmount);
+  assert_object_equals(
+      localStream.readInto(new Uint8Array(10)),
+      { amount: 0, finished: true });
+  localStream.write(new Uint8Array(10));
+  assert_equals(localStream.writeBufferedAmount, 10);
+  localStream.finish();
+  assert_equals(localStream.writeBufferedAmount, 0);
+}, 'writeBufferedAmount set to 0 after reading remote finish, followed ' +
+    'by finish().');
+
 promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
       await makeTwoConnectedQuicTransports(t);
@@ -251,7 +361,7 @@ promise_test(async t => {
   await localStream.waitForWriteBufferedAmountBelow(
       localStream.maxWriteBufferedAmount);
 }, 'waitForWriteBufferedAmountBelow(maxWriteBufferedAmount) resolves ' +
-  'immediately.');
+    'immediately.');
 
 promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
@@ -265,7 +375,21 @@ promise_test(async t => {
       promise_rejects(t, 'InvalidStateError', promise1),
       promise_rejects(t, 'InvalidStateError', promise2)]);
 }, 'Pending waitForWriteBufferedAmountBelow() promises rejected after ' +
-  'finish().');
+    'finish().');
+
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.write(new Uint8Array(localStream.maxWriteBufferedAmount));
+  localStream.finish();
+  const promise1 = localStream.waitForWriteBufferedAmountBelow(0);
+  const promise2 = localStream.waitForWriteBufferedAmountBelow(0);
+  await Promise.all([
+      promise_rejects(t, 'InvalidStateError', promise1),
+      promise_rejects(t, 'InvalidStateError', promise2)]);
+}, 'waitForWriteBufferedAmountBelow() promises immediately rejected after ' +
+    'finish().');
 
 promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
@@ -279,7 +403,21 @@ promise_test(async t => {
       promise_rejects(t, 'InvalidStateError', promise1),
       promise_rejects(t, 'InvalidStateError', promise2)]);
 }, 'Pending waitForWriteBufferedAmountBelow() promises rejected after ' +
-  'reset().');
+    'reset().');
+
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.write(new Uint8Array(localStream.maxWriteBufferedAmount));
+  const promise1 = localStream.waitForWriteBufferedAmountBelow(0);
+  const promise2 = localStream.waitForWriteBufferedAmountBelow(0);
+  localQuicTransport.stop();
+  await Promise.all([
+      promise_rejects(t, 'InvalidStateError', promise1),
+      promise_rejects(t, 'InvalidStateError', promise2)]);
+}, 'Pending waitForWriteBufferedAmountBelow() promises rejected after ' +
+    'RTCQuicTransport stop().');
 
 closed_stream_test(async (t, stream) => {
   await promise_rejects(t, 'InvalidStateError',
@@ -292,7 +430,7 @@ promise_test(async t => {
   const localStream = localQuicTransport.createStream();
   assert_object_equals(
       localStream.readInto(new Uint8Array(10)),
-      { amount: 0, finished: false });
+      { amount: 0, finished: false } );
 }, 'readInto() on new local stream returns amount 0.');
 
 closed_stream_test(async (t, stream) => {
@@ -311,7 +449,7 @@ promise_test(async t => {
   const readBuffer = new Uint8Array(3);
   assert_object_equals(
       remoteStream.readInto(readBuffer),
-      { amount: 1, finished: false });
+      { amount: 1, finished: false } );
   assert_array_equals(readBuffer, [ 65, 0, 0 ]);
   assert_equals(remoteStream.readBufferedAmount, 0);
 }, 'Read 1 byte.');
@@ -337,6 +475,30 @@ async function writeGeneratedData(stream, amount) {
   }
 }
 
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  const data = generateData(10);
+  localStream.write(data);
+  localStream.finish();
+  const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream: remoteStream } = await remoteWatcher.wait_for('quicstream');
+  await remoteStream.waitForReadable(data.length + 1);
+  const readBuffer = new Uint8Array(5);
+  assert_object_equals(
+      remoteStream.readInto(readBuffer),
+      { amount: 5, finished: false} );
+  assert_array_equals(
+      readBuffer, data.subarray(0, 5));
+  const finReadBuffer = new Uint8Array(5);
+  assert_object_equals(
+      remoteStream.readInto(finReadBuffer),
+      { amount: 5, finished: true} );
+  assert_array_equals(
+    finReadBuffer, data.subarray(5, data.length));
+}, 'readInto() reads out finish after reading all data.');
+
 promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
       await makeTwoConnectedQuicTransports(t);
@@ -348,11 +510,24 @@ promise_test(async t => {
   const readBuffer = new Uint8Array(localStream.maxReadBufferedAmount);
   assert_object_equals(
       remoteStream.readInto(readBuffer),
-      { amount: localStream.maxReadBufferedAmount, finished: false });
+      { amount: localStream.maxReadBufferedAmount, finished: false } );
   assert_array_equals(
       readBuffer, generateData(localStream.maxReadBufferedAmount));
 }, 'Read maxReadBufferedAmount bytes all at once.');
 
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.finish();
+  const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream: remoteStream } = await remoteWatcher.wait_for('quicstream');
+  await remoteStream.waitForReadable(remoteStream.maxReadBufferedAmount);
+  assert_object_equals(
+      remoteStream.readInto(new Uint8Array(10)),
+      { amount: 0, finished: true } );
+}, 'waitForReadable() resolves with finish().');
+
 promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
       await makeTwoConnectedQuicTransports(t);
@@ -366,9 +541,9 @@ promise_test(async t => {
   assert_equals(remoteStream.readBufferedAmount, 10);
   const readBuffer = new Uint8Array(10);
   assert_object_equals(
-    remoteStream.readInto(readBuffer), { amount: 10, finished: true });
+      remoteStream.readInto(readBuffer), { amount: 10, finished: true } );
   assert_array_equals(readBuffer, writeData);
-}, 'waitForReadable() resolves early if remote fin is received.');
+}, 'waitForReadable() resolves early if remote finish is received.');
 
 promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
@@ -377,7 +552,27 @@ promise_test(async t => {
   await promise_rejects(t, new TypeError(),
       localStream.waitForReadable(localStream.maxReadBufferedAmount + 1));
 }, 'waitForReadable() rejects with TypeError if amount is more than ' +
-  'maxReadBufferedAmount.');
+    'maxReadBufferedAmount.');
+
+promise_test(async t => {
+    const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.finish();
+  const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream: remoteStream } = await remoteWatcher.wait_for('quicstream');
+  await remoteStream.waitForReadable(remoteStream.maxReadBufferedAmount);
+  assert_object_equals(
+      remoteStream.readInto(new Uint8Array(10)),
+      { amount: 0, finished: true } );
+
+  const promise1 = remoteStream.waitForReadable(10);
+  const promise2 = remoteStream.waitForReadable(10);
+  await Promise.all([
+      promise_rejects(t, 'InvalidStateError', promise1),
+      promise_rejects(t, 'InvalidStateError', promise2)]);
+}, 'waitForReadable() promises immediately rejected with InvalidStateError ' +
+    'after finish is read out.');
 
 promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
@@ -406,6 +601,35 @@ promise_test(async t => {
       promise_rejects(t, 'InvalidStateError', promise2)]);
 }, 'Pending waitForReadable() promises rejected after remote reset().');
 
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  const promise1 = localStream.waitForReadable(10);
+  const promise2 = localStream.waitForReadable(10);
+  localQuicTransport.stop();
+  await Promise.all([
+      promise_rejects(t, 'InvalidStateError', promise1),
+      promise_rejects(t, 'InvalidStateError', promise2)]);
+}, 'Pending waitForReadable() promises rejected after RTCQuicTransport ' +
+   'stop().');
+
+promise_test(async t => {
+  const [ localQuicTransport, remoteQuicTransport ] =
+      await makeTwoConnectedQuicTransports(t);
+  const localStream = localQuicTransport.createStream();
+  localStream.write(new Uint8Array(1));
+  const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'quicstream');
+  const { stream : remoteStream} = await remoteWatcher.wait_for('quicstream');
+  const promise1 = remoteStream.waitForReadable(10);
+  const promise2 = remoteStream.waitForReadable(10);
+  localQuicTransport.stop();
+  await Promise.all([
+      promise_rejects(t, 'InvalidStateError', promise1),
+      promise_rejects(t, 'InvalidStateError', promise2)]);
+}, 'Pending waitForReadable() promises rejected after remote RTCQuicTransport ' +
+    'stop().');
+
 closed_stream_test(async (t, stream) => {
   await promise_rejects(t, 'InvalidStateError',
       stream.waitForReadable(1));