1 files changed, 104 insertions, 115 deletions
diff --git a/tests/wpt/web-platform-tests/webrtc-quic/RTCQuicTransport.https.html b/tests/wpt/web-platform-tests/webrtc-quic/RTCQuicTransport.https.html
index 081f0b4d976..c64ed6af093 100644
--- a/tests/wpt/web-platform-tests/webrtc-quic/RTCQuicTransport.https.html
+++ b/tests/wpt/web-platform-tests/webrtc-quic/RTCQuicTransport.https.html
@@ -17,153 +17,50 @@
 //   makeAndGatherTwoIceTransports
 
 // The following helper functions are called from RTCQuicTransport-helper.js:
-//   generateCertificate
 //   makeQuicTransport
 //   makeStandaloneQuicTransport
 //   makeAndStartTwoQuicTransports
 //   makeTwoConnectedQuicTransports
 
-promise_test(async t => {
-  const certificate = await generateCertificate();
+test(t => {
   const iceTransport = makeIceTransport(t);
-  const quicTransport = makeQuicTransport(t, iceTransport, [ certificate ]);
+  const quicTransport = makeQuicTransport(t, iceTransport);
   assert_equals(quicTransport.transport, iceTransport,
       'Expect transport to be the same as the one passed in the constructor.');
   assert_equals(quicTransport.state, 'new', `Expect state to be 'new'.`);
-  assert_object_equals(quicTransport.getLocalParameters(),
-      { role: 'auto', fingerprints: certificate.getFingerprints() },
-      'Expect local parameters to be initialized.');
-  assert_equals(quicTransport.getRemoteParameters(), null,
-      'Expect no remote parameters.');
-  assert_array_equals(quicTransport.getCertificates(), [ certificate ],
-      'Expect one certificate.');
-  assert_array_equals(quicTransport.getRemoteCertificates(), [],
-      'Expect no remote certificates.');
 }, 'RTCQuicTransport initial properties are set.');
 
-promise_test(async t => {
-  const [ firstCertificate, secondCertificate ] =
-      await Promise.all([ generateCertificate(), generateCertificate() ]);
-  const quicTransport =
-      makeQuicTransport(t, makeIceTransport(t),
-          [ firstCertificate, secondCertificate ]);
-  assert_array_equals(quicTransport.getCertificates(),
-      [ firstCertificate, secondCertificate ]);
-}, 'getCertificates() returns the certificates passed in the constructor.');
-
-promise_test(async t => {
-  const [ firstCertificate, secondCertificate ] =
-      await Promise.all([ generateCertificate(), generateCertificate() ]);
-  const quicTransport =
-      makeQuicTransport(t, makeIceTransport(t),
-          [ firstCertificate, secondCertificate ]);
-  assert_object_equals(quicTransport.getLocalParameters(), {
-    role: 'auto',
-    fingerprints:
-        [ firstCertificate.getFingerprints()[0],
-            secondCertificate.getFingerprints()[0] ],
-  });
-  assert_array_equals(quicTransport.getCertificates(),
-      [ firstCertificate, secondCertificate ]);
-}, 'getLocalParameters() has fingerprints for all certificates passed in the ' +
-    'constructor.');
-
-promise_test(async t => {
-  const expiredCertificate = await generateCertificate({ expires: 0 });
-  assert_throws(new TypeError(),
-      () => makeQuicTransport(t, makeIceTransport(t), [ expiredCertificate ]));
-}, 'RTCQuicTransport constructor throws if passed an expired certificate.');
-
-promise_test(async t => {
-  const certificate = await generateCertificate();
+test(t => {
   const iceTransport = makeIceTransport(t);
   iceTransport.stop();
   assert_throws('InvalidStateError',
-      () => makeQuicTransport(t, iceTransport, [ certificate ]));
+      () => makeQuicTransport(t, iceTransport));
 }, 'RTCQuicTransport constructor throws if passed a closed RTCIceTransport.');
 
-promise_test(async t => {
-  const certificate = await generateCertificate();
+test(t => {
   const iceTransport = makeIceTransport(t);
   const firstQuicTransport =
-      makeQuicTransport(t, iceTransport, [ certificate ]);
+      makeQuicTransport(t, iceTransport);
   assert_throws('InvalidStateError',
-      () => makeQuicTransport(t, iceTransport, [ certificate ]));
+      () => makeQuicTransport(t, iceTransport));
 }, 'RTCQuicTransport constructor throws if passed an RTCIceTransport that ' +
     'already has an active RTCQuicTransport.');
 
-promise_test(async t => {
-  const quicTransport = await makeStandaloneQuicTransport(t);
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
   quicTransport.stop();
   assert_equals(quicTransport.state, 'closed');
 }, `stop() changes state to 'closed'.`);
 
-promise_test(async t => {
-  const quicTransport = await makeStandaloneQuicTransport(t);
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
   quicTransport.transport.stop();
   assert_equals(quicTransport.state, 'closed');
 }, `RTCIceTransport.stop() changes RTCQuicTransport.state to 'closed'.`);
 
 promise_test(async t => {
-  const quicTransport = await makeStandaloneQuicTransport(t);
-  quicTransport.start(quicTransport.getLocalParameters());
-  assert_equals(quicTransport.state, 'new');
-}, 'start() with a non-started RTCIceTransport does not change state.');
-
-promise_test(async t => {
-  const certificate = await generateCertificate();
-  const [ localIceTransport, remoteIceTransport ] =
-      makeAndGatherTwoIceTransports(t);
-  const quicTransport =
-      makeQuicTransport(t, localIceTransport, [ certificate ]);
-  quicTransport.start(quicTransport.getLocalParameters());
-  const iceTransportWatcher =
-      new EventWatcher(t, remoteIceTransport, 'icecandidate');
-  await iceTransportWatcher.wait_for('icecandidate');
-  localIceTransport.start(remoteIceTransport.getLocalParameters(),
-      'controlling');
-  assert_equals(quicTransport.state, 'connecting');
-}, 'start() with a non-started RTCIceTransport later changes state to ' +
-    `'connecting' once the RTCIceTransport.start() is called.`);
-
-promise_test(async t => {
-  const certificate = await generateCertificate();
-  const [ localIceTransport, remoteIceTransport ] =
-      makeAndGatherTwoIceTransports(t);
-  const quicTransport =
-      makeQuicTransport(t, localIceTransport, [ certificate ]);
-  const iceTransportWatcher =
-      new EventWatcher(t, remoteIceTransport, 'icecandidate');
-  await iceTransportWatcher.wait_for('icecandidate');
-  localIceTransport.start(remoteIceTransport.getLocalParameters());
-  quicTransport.start(quicTransport.getLocalParameters());
-  assert_equals(quicTransport.state, 'connecting');
-}, `start() with a started RTCIceTransport changes state to 'connecting'.`);
-
-promise_test(async t => {
-  const quicTransport = await makeStandaloneQuicTransport(t);
-  quicTransport.stop();
-  assert_throws('InvalidStateError',
-      () => quicTransport.start(quicTransport.getLocalParameters()));
-}, 'start() throws if called after stop().');
-
-promise_test(async t => {
-  const quicTransport = await makeStandaloneQuicTransport(t);
-  quicTransport.transport.stop();
-  assert_throws('InvalidStateError',
-      () => quicTransport.start(quicTransport.getLocalParameters()));
-}, 'start() throws if called after the RTCIceTransport has stopped.');
-
-promise_test(async t => {
-  const quicTransport = await makeStandaloneQuicTransport(t);
-  quicTransport.start(quicTransport.getLocalParameters());
-  assert_throws('InvalidStateError',
-      () => quicTransport.start(quicTransport.getLocalParameters()));
-}, 'start() throws if called twice.');
-
-promise_test(async t => {
   const [ localQuicTransport, remoteQuicTransport ] =
-      await makeAndStartTwoQuicTransports(t);
+      makeAndStartTwoQuicTransports(t);
   const localWatcher = new EventWatcher(t, localQuicTransport, 'statechange');
   const remoteWatcher = new EventWatcher(t, remoteQuicTransport, 'statechange');
   await Promise.all([
@@ -185,5 +82,97 @@ promise_test(async t => {
   assert_equals(remoteQuicTransport.state, 'closed');
 }, `stop() fires a statechange event to 'closed' on the remote transport`);
 
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  quicTransport.connect();
+  assert_equals(quicTransport.state, 'connecting');
+}, `connect() changes state to 'connecting'.`);
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  quicTransport.connect();
+  assert_throws('InvalidStateError',
+      () => quicTransport.connect());
+}, 'connect() throws if already called connect().');
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  quicTransport.listen(new Uint8Array([12345]));
+  assert_throws('InvalidStateError',
+      () => quicTransport.connect());
+}, 'connect() throws if already called listen().');
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  quicTransport.stop();
+  assert_throws('InvalidStateError',
+      () => quicTransport.connect());
+}, 'connect() throws after stop().');
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  quicTransport.transport.stop();
+  assert_throws('InvalidStateError',
+      () => quicTransport.connect());
+}, 'connect() throws if called after RTCIceTransport has stopped.');
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  quicTransport.listen(new Uint8Array([12345]));
+  assert_equals(quicTransport.state, 'connecting');
+}, `listen() changes state to 'connecting'.`);
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  quicTransport.connect();
+  assert_throws('InvalidStateError',
+      () => quicTransport.listen(new Uint8Array([12345])));
+}, 'listen() throws if already called connect().');
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  quicTransport.listen(new Uint8Array([12345]));
+  assert_throws('InvalidStateError',
+      () => quicTransport.listen(new Uint8Array([12345])));
+}, 'listen() throws if already called listen().');
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  quicTransport.stop();
+  assert_throws('InvalidStateError',
+      () => quicTransport.listen(new Uint8Array([12345])));
+}, 'listen() throws after stop().');
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  quicTransport.transport.stop();
+  assert_throws('InvalidStateError',
+      () => quicTransport.listen(new Uint8Array([12345])));
+}, 'listen() throws if called after RTCIceTransport has stopped.');
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  const key = quicTransport.getKey();
+  assert_equals(key.byteLength, 16);
+}, 'RTCQuicTransport.getKey() attribute is 16 bytes.');
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  const key = new Uint8Array();
+  assert_throws('NotSupportedError',
+      () => quicTransport.listen(key));
+}, 'listen() throws if given an empty key.');
+
+test(t => {
+  const quicTransport = makeStandaloneQuicTransport(t);
+  const key = quicTransport.getKey();
+  let update_key = new Uint8Array(key);
+  for (let i = 0; i < update_key.length; i++) {
+    update_key[i] = 0;
+  }
+  const new_key = quicTransport.getKey();
+  assert_not_equals(update_key, new Uint8Array(new_key));
+}, 'Cannot mutate key retrieved from getKey().');
+
 </script>