diff --git a/doc/api/errors.md b/doc/api/errors.md
index 17e9de0040..aa8711e423 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1703,13 +1703,6 @@ TBD
 
 TBD
 
-<a id="ERR_QUICSOCKET_CLOSING"></a>
-### `ERR_QUICSOCKET_CLOSING`
-
-> Stability: 1 - Experimental
-
-TBD
-
 <a id="ERR_QUICSOCKET_DESTROYED"></a>
 ### `ERR_QUICSOCKET_DESTROYED`
 
diff --git a/doc/api/quic.md b/doc/api/quic.md
index 4ea548e148..f075f34a4c 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -913,6 +913,15 @@ added: REPLACEME
 
 A `BigInt` representing the length of time taken to complete the TLS handshake.
 
+#### quicsession.idleTimeout
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {boolean}
+
+Set to `true` if the `QuicSession` was closed due to an idle timeout.
+
 #### quicsession.keyUpdateCount
 <!-- YAML
 added: REPLACEME
@@ -1655,7 +1664,6 @@ added: REPLACEME
     `object.passphrase` if provided, or `options.passphrase` if it is not.
   * `activeConnectionIdLimit` {number}
   * `maxAckDelay` {number}
-  * `maxActiveConnectionIDLimit` {number}
   * `maxData` {number}
   * `maxPacketSize` {number}
   * `maxStreamsBidi` {number}
@@ -1707,6 +1715,15 @@ added: REPLACEME
 A `BigInt` representing the length of time this `QuicSocket` has been listening
 for connections.
 
+#### quicsocket.listening
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {boolean}
+
+Set to `true` if the `QuicSocket` is listening for new connections.
+
 #### quicsocket.packetsIgnored
 <!-- YAML
 added: REPLACEME
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 15795233e5..f0b7261e61 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -1240,8 +1240,6 @@ E('ERR_QUICSESSION_VERSION_NEGOTIATION',
       `Supported: ${supportedVersions.join(', ')}`;
   },
   Error);
-E('ERR_QUICSOCKET_CLOSING',
-  'Cannot call %s while a QuicSocket is closing', Error);
 E('ERR_QUICSOCKET_DESTROYED',
   'Cannot call %s after a QuicSocket has been destroyed', Error);
 E('ERR_QUICSOCKET_INVALID_STATELESS_RESET_SECRET_LENGTH',
diff --git a/lib/internal/quic/core.js b/lib/internal/quic/core.js
index 54ed016354..406c3d456b 100644
--- a/lib/internal/quic/core.js
+++ b/lib/internal/quic/core.js
@@ -96,7 +96,6 @@ const {
     ERR_QUIC_ERROR,
     ERR_QUICSESSION_DESTROYED,
     ERR_QUICSESSION_VERSION_NEGOTIATION,
-    ERR_QUICSOCKET_CLOSING,
     ERR_QUICSOCKET_DESTROYED,
     ERR_QUICSOCKET_LISTENING,
     ERR_QUICCLIENTSESSION_FAILED,
@@ -136,6 +135,7 @@ const {
     IDX_QUIC_SESSION_STATE_MAX_STREAMS_UNI,
     IDX_QUIC_SESSION_STATE_MAX_DATA_LEFT,
     IDX_QUIC_SESSION_STATE_HANDSHAKE_CONFIRMED,
+    IDX_QUIC_SESSION_STATE_IDLE_TIMEOUT,
     IDX_QUIC_SESSION_STATE_BYTES_IN_FLIGHT,
     IDX_QUIC_SESSION_STATS_CREATED_AT,
     IDX_QUIC_SESSION_STATS_HANDSHAKE_START_AT,
@@ -1118,17 +1118,16 @@ class QuicSocket extends EventEmitter {
       options = {};
     }
 
-    if (callback && typeof callback !== 'function')
-      throw new ERR_INVALID_CALLBACK();
+    if (callback != null && typeof callback !== 'function')
+      throw new ERR_INVALID_CALLBACK(callback);
 
     if (this.#serverListening)
       throw new ERR_QUICSOCKET_LISTENING();
 
-    if (this.#state === kSocketDestroyed)
+    if (this.#state === kSocketDestroyed ||
+        this.#state === kSocketClosing) {
       throw new ERR_QUICSOCKET_DESTROYED('listen');
-
-    if (this.#state === kSocketClosing)
-      throw new ERR_QUICSOCKET_CLOSING('listen');
+    }
 
     options = {
       secureProtocol: 'TLSv1_3_server_method',
@@ -1137,17 +1136,46 @@ class QuicSocket extends EventEmitter {
     };
 
     // The ALPN protocol identifier is strictly required.
-    const { alpn = NGTCP2_ALPN_H3 } = options;
+    const {
+      alpn = NGTCP2_ALPN_H3,
+      rejectUnauthorized,
+      requestCert,
+    } = options;
+
     if (typeof alpn !== 'string')
       throw new ERR_INVALID_ARG_TYPE('options.alpn', 'string', alpn);
 
+    if (rejectUnauthorized !== undefined &&
+        typeof rejectUnauthorized !== 'boolean') {
+      throw new ERR_INVALID_ARG_TYPE(
+        'options.rejectUnauthorized',
+        'boolean',
+        rejectUnauthorized);
+    }
+
+    if (requestCert !== undefined && typeof requestCert !== 'boolean') {
+      throw new ERR_INVALID_ARG_TYPE(
+        'options.requestCert',
+        'boolean',
+        requestCert);
+    }
+
     // Store the secure context so that it is not garbage collected
     // while we still need to make use of it.
     // TODO(@jasnell): We could store a reference at the C++ level instead
     // since we do not need to access this anywhere else.
     // The secure context options will be validated. Keep this before the
     // kMaybeBind call below.
-    this.#serverSecureContext = createSecureContext(options, initSecureContext);
+    const transportParams =
+      validateTransportParams(
+        options,
+        NGTCP2_MAX_CIDLEN,
+        NGTCP2_MIN_CIDLEN);
+    this.#serverSecureContext =
+      createSecureContext(
+        options,
+        initSecureContext);
+
     this.#serverListening = true;
     this.#alpn = alpn;
 
@@ -1160,11 +1188,7 @@ class QuicSocket extends EventEmitter {
     // Bind the QuicSocket to the local port if it hasn't been bound already.
     this[kMaybeBind]();
 
-    const doListen =
-      continueListen.bind(
-        this,
-        validateTransportParams(options, NGTCP2_MAX_CIDLEN, NGTCP2_MIN_CIDLEN),
-        this.#lookup);
+    const doListen = continueListen.bind(this, transportParams, this.#lookup);
 
     // If the QuicSocket is already bound, we'll begin listening
     // immediately. If we're still pending, however, wait until
@@ -1195,11 +1219,10 @@ class QuicSocket extends EventEmitter {
       address,
     } = options;
 
-    if (this.#state === kSocketDestroyed)
+    if (this.#state === kSocketDestroyed ||
+        this.#state === kSocketClosing) {
       throw new ERR_QUICSOCKET_DESTROYED('connect');
-
-    if (this.#state === kSocketClosing)
-      throw new ERR_QUICSOCKET_CLOSING('connect');
+    }
 
     const session = new QuicClientSession(this, options);
 
@@ -1411,6 +1434,10 @@ class QuicSocket extends EventEmitter {
     return this.#state === kSocketDestroyed;
   }
 
+  get listening() {
+    return this.#serverListening;
+  }
+
   get pending() {
     return this.#state === kSocketPending;
   }
@@ -1543,6 +1570,7 @@ class QuicSession extends EventEmitter {
   #closing = false;
   #destroyed = false;
   #handshakeComplete = false;
+  #idleTimeout = false;
   #maxPacketLength = IDX_QUIC_SESSION_MAX_PACKET_SIZE_DEFAULT;
   #servername = undefined;
   #socket = undefined;
@@ -1797,6 +1825,7 @@ class QuicSession extends EventEmitter {
     if (handle !== undefined) {
       // Copy the stats for use after destruction
       this.#stats = new BigInt64Array(handle.stats);
+      this.#idleTimeout = !!handle.state[IDX_QUIC_SESSION_STATE_IDLE_TIMEOUT];
       // Calling destroy will cause a CONNECTION_CLOSE to be
       // sent to the peer and will destroy the QuicSession
       // handler immediately.
@@ -1874,6 +1903,10 @@ class QuicSession extends EventEmitter {
       this[kHandle].state[IDX_QUIC_SESSION_STATE_HANDSHAKE_CONFIRMED] : 0);
   }
 
+  get idleTimeout() {
+    return this.#idleTimeout;
+  }
+
   get alpnProtocol() {
     return this.#alpn;
   }
diff --git a/lib/internal/quic/util.js b/lib/internal/quic/util.js
index 9e13baf509..6dc1f711a2 100644
--- a/lib/internal/quic/util.js
+++ b/lib/internal/quic/util.js
@@ -92,7 +92,7 @@ function getAllowUnauthorized() {
   return allowUnauthorized;
 }
 
-function getSocketType(type) {
+function getSocketType(type = 'udp4') {
   switch (type) {
     case 'udp4': return AF_INET;
     case 'udp6': return AF_INET6;
@@ -264,6 +264,30 @@ function validateTransportParams(params) {
     'options.maxHeaderLength',
     '>=0');
 
+  if (preferredAddress !== undefined) {
+    if (preferredAddress == null || typeof preferredAddress !== 'object') {
+      throw new ERR_INVALID_ARG_TYPE(
+        'options.preferredAddress',
+        'Object',
+        preferredAddress);
+    }
+    if (preferredAddress.address !== undefined &&
+        typeof preferredAddress.address !== 'string') {
+      throw new ERR_INVALID_ARG_TYPE(
+        'options.preferredAddress.address',
+        'string',
+        preferredAddress.address);
+    }
+    if (preferredAddress.port !== undefined &&
+        !isLegalPort(preferredAddress.port)) {
+      throw new ERR_INVALID_ARG_VALUE(
+        'options.port',
+        preferredAddress.port,
+        'is not a valid IP port');
+    }
+    getSocketType(preferredAddress.type);
+  }
+
   return {
     activeConnectionIdLimit,
     maxStreamDataBidiLocal,
diff --git a/src/quic/node_quic.cc b/src/quic/node_quic.cc
index 9687d6bbdb..de11a8c878 100644
--- a/src/quic/node_quic.cc
+++ b/src/quic/node_quic.cc
@@ -171,6 +171,7 @@ void Initialize(Local<Object> target,
   V(IDX_QUIC_SESSION_STATE_MAX_DATA_LEFT)                                      \
   V(IDX_QUIC_SESSION_STATE_BYTES_IN_FLIGHT)                                    \
   V(IDX_QUIC_SESSION_STATE_HANDSHAKE_CONFIRMED)                                \
+  V(IDX_QUIC_SESSION_STATE_IDLE_TIMEOUT)                                       \
   V(MAX_RETRYTOKEN_EXPIRATION)                                                 \
   V(MIN_RETRYTOKEN_EXPIRATION)                                                 \
   V(NGTCP2_APP_NOERROR)                                                        \
diff --git a/src/quic/node_quic_session-inl.h b/src/quic/node_quic_session-inl.h
index da51d09d19..80dfed2c7c 100644
--- a/src/quic/node_quic_session-inl.h
+++ b/src/quic/node_quic_session-inl.h
@@ -273,6 +273,7 @@ void QuicSession::InitApplication() {
 // the peer. All existing streams are abandoned and closed.
 void QuicSession::OnIdleTimeout() {
   if (!is_flag_set(QUICSESSION_FLAG_DESTROYED)) {
+    state_[IDX_QUIC_SESSION_STATE_IDLE_TIMEOUT] = 1;
     Debug(this, "Idle timeout");
     SilentClose();
   }
diff --git a/src/quic/node_quic_session.h b/src/quic/node_quic_session.h
index 6bd382d3b5..f7af441181 100644
--- a/src/quic/node_quic_session.h
+++ b/src/quic/node_quic_session.h
@@ -184,6 +184,9 @@ enum QuicSessionState : int {
 
   IDX_QUIC_SESSION_STATE_HANDSHAKE_CONFIRMED,
 
+  // Communicates whether a session was closed due to idle timeout
+  IDX_QUIC_SESSION_STATE_IDLE_TIMEOUT,
+
   // Just the number of session state enums for use when
   // creating the AliasedBuffer.
   IDX_QUIC_SESSION_STATE_COUNT
diff --git a/test/parallel/test-quic-binding.js b/test/parallel/test-quic-binding.js
index e262fb4404..843bb67a8e 100644
--- a/test/parallel/test-quic-binding.js
+++ b/test/parallel/test-quic-binding.js
@@ -1,6 +1,8 @@
 // Flags: --expose-internals --no-warnings
 'use strict';
 
+// Tests the availability and correctness of internalBinding(quic)
+
 const common = require('../common');
 if (!common.hasQuic)
   common.skip('missing quic');
@@ -11,8 +13,10 @@ const { internalBinding } = require('internal/test/binding');
 const quic = internalBinding('quic');
 assert(quic);
 
-// Version numbers used to identify IETF drafts are created by adding the draft
-// number to 0xff0000, in this case 19 (25).
+assert(quic.constants);
+
+// Version numbers used to identify IETF drafts are created by
+// adding the draft number to 0xff0000, in this case 19 (25).
 assert.strictEqual(quic.constants.NGTCP2_PROTO_VER.toString(16), 'ff000019');
 assert.strictEqual(quic.constants.NGTCP2_ALPN_H3, '\u0005h3-25');
 
@@ -32,3 +36,4 @@ assert.strictEqual(typeof quic.openUnidirectionalStream, 'function');
 assert.strictEqual(typeof quic.setCallbacks, 'function');
 assert.strictEqual(typeof quic.initSecureContext, 'function');
 assert.strictEqual(typeof quic.initSecureContextClient, 'function');
+assert.strictEqual(typeof quic.silentCloseSession, 'function');
diff --git a/test/parallel/test-quic-client-empty-preferred-address.js b/test/parallel/test-quic-client-empty-preferred-address.js
index 1b57332197..6518c8a279 100644
--- a/test/parallel/test-quic-client-empty-preferred-address.js
+++ b/test/parallel/test-quic-client-empty-preferred-address.js
@@ -12,42 +12,46 @@ if (!common.hasQuic)
 const assert = require('assert');
 const { key, cert, ca } = require('../common/quic');
 const { createSocket } = require('quic');
+const { once } = require('events');
 
-const kServerName = 'agent2';
-const server = createSocket();
+(async () => {
+  const server = createSocket();
 
-let client;
-const options = { key, cert, ca, alpn: 'zzz' };
-server.listen(options);
+  let client;
+  const options = { key, cert, ca, alpn: 'zzz' };
+  server.listen(options);
+
+  server.on('session', common.mustCall((serverSession) => {
+    serverSession.on('stream', common.mustCall(async (stream) => {
+      stream.on('data', common.mustCall((data) => {
+        assert.strictEqual(data.toString('utf8'), 'hello');
+      }));
+
+      await once(stream, 'end');
 
-server.on('session', common.mustCall((serverSession) => {
-  serverSession.on('stream', common.mustCall((stream) => {
-    stream.on('data', common.mustCall((data) => {
-      assert.strictEqual(data.toString('utf8'), 'hello');
-    }));
-    stream.on('end', common.mustCall(() => {
       stream.close();
       client.close();
       server.close();
     }));
   }));
-}));
 
-server.on('ready', common.mustCall(() => {
+  await once(server, 'ready');
+
   client = createSocket({ client: options });
 
   const clientSession = client.connect({
-    address: 'localhost',
+    address: common.localhostIPv4,
     port: server.endpoints[0].address.port,
-    servername: kServerName,
     preferredAddressPolicy: 'accept',
   });
 
-  clientSession.on('close', common.mustCall());
+  await once(clientSession, 'secure');
 
-  clientSession.on('secure', common.mustCall(() => {
-    const stream = clientSession.openStream();
-    stream.end('hello');
-    stream.on('close', common.mustCall());
-  }));
-}));
+  const stream = clientSession.openStream();
+  stream.end('hello');
+
+  await Promise.all([
+    once(stream, 'close'),
+    once(client, 'close'),
+    once(server, 'close')]);
+})().then(common.mustCall());
diff --git a/test/parallel/test-quic-openstream-errors.js b/test/parallel/test-quic-errors-quicsession-openstream.js
similarity index 79%
rename from test/parallel/test-quic-openstream-errors.js
rename to test/parallel/test-quic-errors-quicsession-openstream.js
index d367737ed3..a4c157a881 100644
--- a/test/parallel/test-quic-openstream-errors.js
+++ b/test/parallel/test-quic-errors-quicsession-openstream.js
@@ -7,9 +7,17 @@ if (!common.hasQuic)
 // Test errors thrown when openStream is called incorrectly
 // or is not permitted
 
+const { createHook } = require('async_hooks');
 const assert = require('assert');
 const quic = require('quic');
 
+// Ensure that no QUICSTREAM instances are created during the test
+createHook({
+  init(id, type) {
+    assert.notStrictEqual(type, 'QUICSTREAM');
+  }
+}).enable();
+
 const Countdown = require('../common/countdown');
 const { key, cert, ca } = require('../common/quic');
 
@@ -29,7 +37,7 @@ server.on('session', common.mustCall((session) => {
 
 server.on('ready', common.mustCall(() => {
   const req = client.connect({
-    address: 'localhost',
+    address: common.localhostIPv4,
     port: server.endpoints[0].address.port
   });
 
@@ -41,7 +49,8 @@ server.on('ready', common.mustCall(() => {
   });
 
   // Unidirectional streams are not allowed. openStream will succeeed
-  // but the stream will be destroyed immediately.
+  // but the stream will be destroyed immediately. The underlying
+  // QuicStream C++ handle will not be created.
   req.openStream({ halfOpen: true })
     .on('error', common.expectsError({
       code: 'ERR_QUICSTREAM_OPEN_FAILED'
diff --git a/test/parallel/test-quic-client-connect-err.js b/test/parallel/test-quic-errors-quicsocket-connect.js
similarity index 89%
rename from test/parallel/test-quic-client-connect-err.js
rename to test/parallel/test-quic-errors-quicsocket-connect.js
index 03ff67254f..256da5530a 100644
--- a/test/parallel/test-quic-client-connect-err.js
+++ b/test/parallel/test-quic-errors-quicsocket-connect.js
@@ -1,15 +1,26 @@
 // Flags: --no-warnings
 'use strict';
 
-// Tests QuicClientSession constructor options errors
+// Tests error and input validation checks for QuicSocket.connect()
 
 const common = require('../common');
+
 if (!common.hasQuic)
   common.skip('missing quic');
 
+const { createHook } = require('async_hooks');
 const assert = require('assert');
 const { createSocket } = require('quic');
 
+// Ensure that a QuicClientSession handle is never created during the
+// error condition tests (ensures that argument and error validation)
+// is occurring before the underlying handle is created.
+createHook({
+  init(id, type) {
+    assert.notStrictEqual(type, 'QUICCLIENTSESSION');
+  }
+}).enable();
+
 const client = createSocket();
 
 // Test invalid minDHSize options argument
@@ -20,7 +31,7 @@ const client = createSocket();
 });
 
 // Test invalid port argument option
-[-1, 'test', 1n, {}, [], NaN, false].forEach((port) => {
+[-1, 'test', 1n, {}, [], NaN, false, 65536].forEach((port) => {
   assert.throws(() => client.connect({ port }), {
     code: 'ERR_INVALID_ARG_VALUE'
   });
@@ -162,6 +173,12 @@ const client = createSocket();
   });
 });
 
+// Test that connect cannot be called after QuicSocket is closed.
+client.close();
+assert.throws(() => client.connect(), {
+  code: 'ERR_QUICSOCKET_DESTROYED'
+});
+
 // TODO(@jasnell): Test additional options:
 //
 // Client QuicSession Related:
@@ -205,3 +222,4 @@ const client = createSocket();
 //  [ ] passphrase - must be a string
 //  [ ] pfx - must be a string, string array, Buffer, or Buffer array
 //  [ ] secureOptions - must be a number
+//  [x] minDHSize - must be a number
diff --git a/test/parallel/test-quic-createsocket-err.js b/test/parallel/test-quic-errors-quicsocket-create.js
similarity index 100%
rename from test/parallel/test-quic-createsocket-err.js
rename to test/parallel/test-quic-errors-quicsocket-create.js
diff --git a/test/parallel/test-quic-errors-quicsocket-listen.js b/test/parallel/test-quic-errors-quicsocket-listen.js
new file mode 100644
index 0000000000..08ac4577af
--- /dev/null
+++ b/test/parallel/test-quic-errors-quicsocket-listen.js
@@ -0,0 +1,162 @@
+// Flags: --no-warnings
+'use strict';
+
+// Tests error and input validation checks for QuicSocket.connect()
+
+const common = require('../common');
+
+if (!common.hasQuic)
+  common.skip('missing quic');
+
+const assert = require('assert');
+const { createSocket } = require('quic');
+
+// Test invalid callback function
+{
+  const server = createSocket();
+  [1, 1n].forEach((cb) => {
+    assert.throws(() => server.listen({}, cb), {
+      code: 'ERR_INVALID_CALLBACK'
+    });
+  });
+}
+
+// Test QuicSocket is already listening
+{
+  const server = createSocket();
+  server.listen();
+  assert.throws(() => server.listen(), {
+    code: 'ERR_QUICSOCKET_LISTENING'
+  });
+  server.close();
+}
+
+// Test QuicSocket listen after destroy error
+{
+  const server = createSocket();
+  server.close();
+  assert.throws(() => server.listen(), {
+    code: 'ERR_QUICSOCKET_DESTROYED'
+  });
+}
+
+{
+  // Test incorrect ALPN
+  const server = createSocket();
+  [1, 1n, true, {}, [], null].forEach((alpn) => {
+    assert.throws(() => server.listen({ alpn }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+
+  // Test invalid idle timeout
+  [
+    'idleTimeout',
+    'activeConnectionIdLimit',
+    'maxAckDelay',
+    'maxData',
+    'maxPacketSize',
+    'maxStreamDataBidiLocal',
+    'maxStreamDataBidiRemote',
+    'maxStreamDataUni',
+    'maxStreamsBidi',
+    'maxStreamsUni',
+  ].forEach((prop) => {
+    assert.throws(() => server.listen({ [prop]: -1 }), {
+      code: 'ERR_OUT_OF_RANGE'
+    });
+
+    ['a', 1n, [], {}, false, Number.MAX_SAFE_INTEGER + 1].forEach((val) => {
+      assert.throws(() => server.listen({ [prop]: val }), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      });
+    });
+  });
+
+  [1, 1n, 'test', {}, []].forEach((rejectUnauthorized) => {
+    assert.throws(() => server.listen({ rejectUnauthorized }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+
+  [1, 1n, 'test', {}, []].forEach((requestCert) => {
+    assert.throws(() => server.listen({ requestCert }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+
+  [1, 1n, 'test', null, false].forEach((preferredAddress) => {
+    assert.throws(() => server.listen({ preferredAddress }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+
+    [1, 1n, null, false, {}, []].forEach((address) => {
+      assert.throws(() => server.listen({ preferredAddress: { address } }), {
+        code: 'ERR_INVALID_ARG_TYPE'
+      });
+    });
+
+    [-1].forEach((port) => {
+      assert.throws(() => server.listen({ preferredAddress: { port } }), {
+        code: 'ERR_INVALID_ARG_VALUE'
+      });
+    });
+
+    [1, 'test', false, null, {}, []].forEach((type) => {
+      assert.throws(() => server.listen({ preferredAddress: { type } }), {
+        code: 'ERR_INVALID_ARG_VALUE'
+      });
+    });
+  });
+
+  [1, 1n, false, [], {}, null].forEach((ciphers) => {
+    assert.throws(() => server.listen({ ciphers }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+
+  [1, 1n, false, [], {}, null].forEach((groups) => {
+    assert.throws(() => server.listen({ groups }), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  });
+
+
+  // Make sure that after all of the validation checks, the socket
+  // is not actually marked as listening at all.
+  assert.strictEqual(typeof server.listening, 'boolean');
+  assert(!server.listening);
+}
+
+
+// Options to check
+// * [x] alpn
+// * [x] idleTimeout
+// * [x] activeConnectionIdLimit
+// * [x] maxAckDelay
+// * [x] maxData
+// * [x] maxPacketSize
+// * [x] maxStreamsBidi
+// * [x] maxStreamsUni
+// * [x] maxStreamDataBidiLocal
+// * [x] maxStreamDataBidiRemote
+// * [x] maxStreamDataUni
+// * [x] preferredAddress
+// * [x] requestCert
+// * [x] rejectUnauthorized
+
+// SecureContext Options
+// * [ ] ca
+// * [ ] cert
+// * [x] ciphers
+// * [ ] clientCertEngine
+// * [ ] crl
+// * [ ] dhparam
+// * [ ] groups
+// * [ ] ecdhCurve
+// * [ ] honorCipherOrder
+// * [ ] key
+// * [ ] passphrase
+// * [ ] pfx
+// * [ ] secureOptions
+// * [ ] sessionIdContext
diff --git a/test/parallel/test-quic-idle-timeout.js b/test/parallel/test-quic-idle-timeout.js
index 585eaea621..af38c511f5 100644
--- a/test/parallel/test-quic-idle-timeout.js
+++ b/test/parallel/test-quic-idle-timeout.js
@@ -8,63 +8,66 @@ if (!common.hasQuic)
 const assert = require('assert');
 const { createSocket } = require('quic');
 const { key, cert, ca } = require('../common/quic');
+const { once } = require('events');
 
-const kServerName = 'agent2';
 const kALPN = 'zzz';
-// Allow error for 500 milliseconds more.
-const error = common.platformTimeout(500);
-const idleTimeout = common.platformTimeout(1000);
+const idleTimeout = common.platformTimeout(1);
+const options = { key, cert, ca, alpn: kALPN };
 
-// Test client idle timeout.
-{
-  let client;
-  const server = createSocket();
-  server.listen({ key, cert, ca, alpn: kALPN });
+// Test idleTimeout. The test will hang and fail with a timeout
+// if the idleTimeout is not working correctly.
 
+(async () => {
+  const server = createSocket({ server: options });
+  const client = createSocket({ client: options });
+
+  server.listen();
   server.on('session', common.mustCall());
 
-  server.on('ready', common.mustCall(() => {
-    client = createSocket({ client: { key, cert, ca, alpn: kALPN } });
-    const start = Date.now();
-    const clientSession = client.connect({
-      address: 'localhost',
-      port: server.endpoints[0].address.port,
-      servername: kServerName,
-      idleTimeout,
-    });
-
-    clientSession.on('close', common.mustCall(() => {
-      client.close();
-      server.close();
-      assert(Date.now() - start < idleTimeout + error);
-    }));
-  }));
-}
-
-// Test server idle timeout.
-{
-  let client;
-  let start;
-  const server = createSocket();
-  server.listen({ key, cert, ca, alpn: kALPN, idleTimeout });
-
-  server.on('session', common.mustCall((serverSession) => {
-    serverSession.on('close', common.mustCall(() => {
-      client.close();
-      server.close();
-      assert(Date.now() - start < idleTimeout + error);
-    }));
-  }));
+  await once(server, 'ready');
+
+  const session = client.connect({
+    address: common.localhostIPv4,
+    port: server.endpoints[0].address.port,
+    idleTimeout,
+  });
+
+  await once(session, 'close');
+
+  assert(session.idleTimeout);
+  client.close();
+  server.close();
 
-  server.on('ready', common.mustCall(() => {
-    client = createSocket({ client: { key, cert, ca, alpn: kALPN } });
-    start = Date.now();
-    const clientSession = client.connect({
-      address: 'localhost',
-      port: server.endpoints[0].address.port,
-      servername: kServerName,
-    });
+  await Promise.all([
+    once(client, 'close'),
+    once(server, 'close')
+  ]);
+})().then(common.mustCall());
 
-    clientSession.on('close', common.mustCall());
+
+(async () => {
+  const server = createSocket({ server: options });
+  const client = createSocket({ client: options });
+
+  server.listen({ idleTimeout });
+
+  server.on('session', common.mustCall(async (session) => {
+    await once(session, 'close');
+    assert(session.idleTimeout);
+    client.close();
+    server.close();
+    await Promise.all([
+      once(client, 'close'),
+      once(server, 'close')
+    ]);
   }));
-}
+
+  await once(server, 'ready');
+
+  const session = client.connect({
+    address: common.localhostIPv4,
+    port: server.endpoints[0].address.port,
+  });
+
+  await once(session, 'close');
+})().then(common.mustCall());
diff --git a/test/parallel/test-quic-ipv6only.js b/test/parallel/test-quic-ipv6only.js
index 08de554c65..d54200d658 100644
--- a/test/parallel/test-quic-ipv6only.js
+++ b/test/parallel/test-quic-ipv6only.js
@@ -12,8 +12,8 @@ if (!common.hasQuic)
 const assert = require('assert');
 const { createSocket } = require('quic');
 const { key, cert, ca } = require('../common/quic');
+const { once } = require('events');
 
-const kServerName = 'agent2';
 const kALPN = 'zzz';
 
 // Setting `type` to `udp4` while setting `ipv6Only` to `true` is possible
@@ -31,8 +31,9 @@ const kALPN = 'zzz';
 
 // Connecting ipv6 server by "127.0.0.1" should work when `ipv6Only`
 // is set to `false`.
-{
+(async () => {
   const server = createSocket({ endpoint: { type: 'udp6', ipv6Only: false } });
+  const client = createSocket({ client: { key, cert, ca, alpn: kALPN } });
 
   server.listen({ key, cert, ca, alpn: kALPN });
 
@@ -40,83 +41,88 @@ const kALPN = 'zzz';
     serverSession.on('stream', common.mustCall());
   }));
 
-  server.on('ready', common.mustCall(() => {
-    const client = createSocket({ client: { key, cert, ca, alpn: kALPN } });
-
-    const clientSession = client.connect({
-      address: common.localhostIPv4,
-      port: server.endpoints[0].address.port,
-      servername: kServerName,
-    });
-
-    clientSession.on('secure', common.mustCall(() => {
-      const clientStream = clientSession.openStream({ halfOpen: true });
-      clientStream.end('hello');
-      clientStream.on('close', common.mustCall(() => {
-        client.close();
-        server.close();
-      }));
-    }));
-  }));
-}
+  await once(server, 'ready');
+
+  const session = client.connect({
+    address: common.localhostIPv4,
+    port: server.endpoints[0].address.port,
+  });
+
+  await once(session, 'secure');
+
+  const stream = session.openStream({ halfOpen: true });
+  stream.end('hello');
+
+  await once(stream, 'close');
+
+  client.close();
+  server.close();
+
+  await Promise.allSettled([
+    once(client, 'close'),
+    once(server, 'close')
+  ]);
+})().then(common.mustCall());
 
 // When the `ipv6Only` set to `true`, a client cann't connect to it
 // through "127.0.0.1".
-{
+(async () => {
   const server = createSocket({ endpoint: { type: 'udp6', ipv6Only: true } });
+  const client = createSocket({ client: { key, cert, ca, alpn: kALPN } });
 
   server.listen({ key, cert, ca, alpn: kALPN });
   server.on('session', common.mustNotCall());
 
-  server.on('ready', common.mustCall(() => {
-    const client = createSocket({ client: { key, cert, ca, alpn: kALPN } });
+  await once(server, 'ready');
 
-    client.on('ready', common.mustCall());
+  const session = client.connect({
+    address: common.localhostIPv4,
+    port: server.endpoints[0].address.port,
+    idleTimeout: common.platformTimeout(1),
+  });
 
-    const clientSession = client.connect({
-      address: common.localhostIPv4,
-      port: server.endpoints[0].address.port,
-      servername: kServerName,
-      idleTimeout: common.platformTimeout(1),
-    });
+  session.on('secure', common.mustNotCall());
 
-    clientSession.on('secure', common.mustNotCall());
-    clientSession.on('close', common.mustCall(() => {
-      client.close();
-      server.close();
-    }));
-  }));
-}
+  await once(session, 'close');
+
+  client.close();
+  server.close();
+
+  await Promise.allSettled([
+    once(client, 'close'),
+    once(server, 'close')
+  ]);
+})();
 
 // Creating the QuicSession fails when connect type does not match the
 // the connect IP address...
-{
+(async () => {
   const server = createSocket({ endpoint: { type: 'udp6' } });
+  const client = createSocket({ client: { key, cert, ca, alpn: kALPN } });
 
   server.listen({ key, cert, ca, alpn: kALPN });
   server.on('session', common.mustNotCall());
 
-  server.on('ready', common.mustCall(() => {
-    const client = createSocket({ client: { key, cert, ca, alpn: kALPN } });
+  await once(server, 'ready');
 
-    client.on('ready', common.mustCall());
+  const session = client.connect({
+    address: common.localhostIPv4,
+    port: server.endpoints[0].address.port,
+    type: 'udp6',
+    idleTimeout: common.platformTimeout(1),
+  });
 
-    const clientSession = client.connect({
-      address: common.localhostIPv4,
-      port: server.endpoints[0].address.port,
-      type: 'udp6',
-      servername: kServerName,
-      idleTimeout: common.platformTimeout(1),
-    });
+  session.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_QUICCLIENTSESSION_FAILED');
+    client.close();
+    server.close();
+  }));
 
-    clientSession.on('error', common.mustCall((err) => {
-      assert.strictEqual(err.code, 'ERR_QUICCLIENTSESSION_FAILED');
-    }));
+  session.on('secure', common.mustNotCall());
+  session.on('close', common.mustCall());
 
-    clientSession.on('secure', common.mustNotCall());
-    clientSession.on('close', common.mustCall(() => {
-      client.close();
-      server.close();
-    }));
-  }));
-}
+  await Promise.allSettled([
+    once(client, 'close'),
+    once(server, 'close')
+  ]);
+})().then(common.mustCall());
diff --git a/test/parallel/test-quic-keylog.js b/test/parallel/test-quic-keylog.js
index fa5bcbb567..ef0702f529 100644
--- a/test/parallel/test-quic-keylog.js
+++ b/test/parallel/test-quic-keylog.js
@@ -9,61 +9,59 @@ if (!common.hasQuic)
 
 const assert = require('assert');
 const { key, cert, ca } = require('../common/quic');
+const { once } = require('events');
 
 const { createSocket } = require('quic');
 
-let client;
-
-const server = createSocket();
-
 const kKeylogs = [
-  /CLIENT_HANDSHAKE_TRAFFIC_SECRET.*/,
-  /SERVER_HANDSHAKE_TRAFFIC_SECRET.*/,
-  /QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET.*/,
-  /QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET.*/,
-  /CLIENT_TRAFFIC_SECRET_0.*/,
-  /SERVER_TRAFFIC_SECRET_0.*/,
-  /QUIC_CLIENT_TRAFFIC_SECRET_0.*/,
-  /QUIC_SERVER_TRAFFIC_SECRET_0.*/,
+  /^CLIENT_HANDSHAKE_TRAFFIC_SECRET .*/,
+  /^SERVER_HANDSHAKE_TRAFFIC_SECRET .*/,
+  /^QUIC_CLIENT_HANDSHAKE_TRAFFIC_SECRET .*/,
+  /^QUIC_SERVER_HANDSHAKE_TRAFFIC_SECRET .*/,
+  /^CLIENT_TRAFFIC_SECRET_0 .*/,
+  /^SERVER_TRAFFIC_SECRET_0 .*/,
+  /^QUIC_CLIENT_TRAFFIC_SECRET_0 .*/,
+  /^QUIC_SERVER_TRAFFIC_SECRET_0 .*/,
 ];
 
-server.listen({ key, cert, ca, alpn: 'zzz' });
+const options = { key, cert, ca, alpn: 'zzz' };
+
+(async () => {
+  const server = createSocket({ server: options });
+  const client = createSocket({ client: options });
 
-server.on('session', common.mustCall((session) => {
   const kServerKeylogs = Array.from(kKeylogs);
-  session.on('keylog', common.mustCall((line) => {
-    assert(kServerKeylogs.shift().test(line));
-  }, kServerKeylogs.length));
-
-  session.on('stream', common.mustCall((stream) => {
-    stream.setEncoding('utf8');
-    stream.end('hello world');
-    stream.resume();
+  const kClientKeylogs = Array.from(kKeylogs);
+
+  server.listen();
+
+  server.on('session', common.mustCall((session) => {
+    session.on('keylog', common.mustCall((line) => {
+      assert.match(line.toString(), kServerKeylogs.shift());
+    }, kServerKeylogs.length));
   }));
-}));
 
-server.on('ready', common.mustCall(() => {
-  client = createSocket({ client: { key, cert, ca, alpn: 'zzz' } });
+  await once(server, 'ready');
 
   const req = client.connect({
-    address: 'localhost',
+    address: common.localhostIPv4,
     port: server.endpoints[0].address.port,
   });
 
-  const kClientKeylogs = Array.from(kKeylogs);
-
   req.on('keylog', common.mustCall((line) => {
-    assert(kClientKeylogs.shift().test(line));
+    assert.match(line.toString(), kClientKeylogs.shift());
   }, kClientKeylogs.length));
 
-  req.on('secure', common.mustCall((servername, alpn, cipher) => {
-    const stream = req.openStream();
-    stream.setEncoding('utf8');
-    stream.end('hello world');
-    stream.resume();
-    stream.on('close', common.mustCall(() => {
-      server.close();
-      client.close();
-    }));
-  }));
-}));
+  await once(req, 'secure');
+
+  server.close();
+  client.close();
+
+  await Promise.allSettled([
+    once(server, 'close'),
+    once(client, 'close')
+  ]);
+
+  assert.strictEqual(kServerKeylogs.length, 0);
+  assert.strictEqual(kClientKeylogs.length, 0);
+})().then(common.mustCall());
diff --git a/test/parallel/test-quic-openstream-pending.js b/test/parallel/test-quic-openstream-pending.js
deleted file mode 100644
index f1747722a7..0000000000
--- a/test/parallel/test-quic-openstream-pending.js
+++ /dev/null
@@ -1,52 +0,0 @@
-// Flags: --no-warnings
-'use strict';
-const common = require('../common');
-if (!common.hasQuic)
-  common.skip('missing quic');
-
-// Test that opening a stream works even if the session isn’t ready yet.
-
-const assert = require('assert');
-const quic = require('quic');
-
-const { key, cert, ca } = require('../common/quic');
-
-const server = quic.createSocket();
-
-server.listen({ key, cert, ca, alpn: 'meow' });
-
-server.on('session', common.mustCall((session) => {
-  session.on('stream', common.mustCall((stream) => {
-    let data = '';
-    stream.setEncoding('utf8');
-    stream.on('data', (chunk) => data += chunk);
-    stream.on('end', common.mustCall(() => {
-      assert.strictEqual(data, 'Hello!');
-      session.close();
-      server.close();
-    }));
-  }));
-
-  session.on('close', common.mustCall());
-}));
-
-server.on('ready', common.mustCall(() => {
-  const client = quic.createSocket({ client: { key, cert, ca, alpn: 'meow' } });
-
-  const req = client.connect({
-    address: 'localhost',
-    port: server.endpoints[0].address.port
-  });
-
-  const stream = req.openStream({ halfOpen: true });
-  stream.end('Hello!');
-
-  assert.strictEqual(stream.pending, true);
-  stream.on('ready', common.mustCall(() => {
-    assert.strictEqual(stream.pending, false);
-  }));
-
-  req.on('close', common.mustCall(() => client.close()));
-}));
-
-server.on('close', common.mustCall());
diff --git a/test/parallel/test-quic-process-cleanup.js b/test/parallel/test-quic-process-cleanup.js
index 4305fbe83a..24b8d9e3fa 100644
--- a/test/parallel/test-quic-process-cleanup.js
+++ b/test/parallel/test-quic-process-cleanup.js
@@ -18,10 +18,11 @@ if (workerData === null) {
 }
 
 const { key, cert, ca } = require('../common/quic');
+const options = { key, cert, ca, alpn: 'meow' };
 
-const server = quic.createSocket();
+const server = quic.createSocket({ server: options });
 
-server.listen({ key, cert, ca, alpn: 'meow' });
+server.listen();
 
 server.on('session', common.mustCall((session) => {
   session.on('secure', common.mustCall((servername, alpn, cipher) => {
@@ -37,17 +38,17 @@ server.on('session', common.mustCall((session) => {
 }));
 
 server.on('ready', common.mustCall(() => {
-  const client = quic.createSocket({ client: { key, cert, ca, alpn: 'meow' } });
+  const client = quic.createSocket({ client: options });
 
   const req = client.connect({
-    address: 'localhost',
+    address: common.localhostIPv4,
     port: server.endpoints[0].address.port
   });
 
   req.on('stream', common.mustCall(() => {
     if (workerData.removeFromSocket)
       req.removeFromSocket();
-    process.exit();
+    process.exit();  // Exits the worker thread
   }));
 
   req.on('close', common.mustNotCall());
diff --git a/test/parallel/test-quic-endpoint-address.js b/test/parallel/test-quic-quicendpoint-address.js
similarity index 98%
rename from test/parallel/test-quic-endpoint-address.js
rename to test/parallel/test-quic-quicendpoint-address.js
index 27954fbd65..7df428c680 100644
--- a/test/parallel/test-quic-endpoint-address.js
+++ b/test/parallel/test-quic-quicendpoint-address.js
@@ -37,7 +37,7 @@ async function Test1(options, address) {
   assert.strictEqual(endpoint.destroyed, true);
 }
 
-async function Test2(options) {
+async function Test2() {
   // Creates a server with multiple endpoints (one on udp4 and udp6)
   const server = createSocket({ endpoint: { type: 'udp6' } });
   server.addEndpoint();
@@ -90,4 +90,4 @@ if (common.hasIPv6) {
     Test2());
 }
 
-Promise.all(tests);
+Promise.allSettled(tests);
diff --git a/test/parallel/test-quic-quicsession-openstream-pending.js b/test/parallel/test-quic-quicsession-openstream-pending.js
new file mode 100644
index 0000000000..1812cb8a1b
--- /dev/null
+++ b/test/parallel/test-quic-quicsession-openstream-pending.js
@@ -0,0 +1,55 @@
+// Flags: --no-warnings
+'use strict';
+const common = require('../common');
+if (!common.hasQuic)
+  common.skip('missing quic');
+
+// Test that opening a stream works even if the session isn’t ready yet.
+
+const assert = require('assert');
+const quic = require('quic');
+const { key, cert, ca } = require('../common/quic');
+const { once } = require('events');
+const options = { key, cert, ca, alpn: 'meow' };
+
+(async () => {
+  const server = quic.createSocket({ server: options });
+  const client = quic.createSocket({ client: options });
+
+  server.listen();
+
+  server.on('session', common.mustCall((session) => {
+    session.on('stream', common.mustCall(async (stream) => {
+      let data = '';
+      stream.setEncoding('utf8');
+      stream.on('data', (chunk) => data += chunk);
+      await once(stream, 'end');
+      assert.strictEqual(data, 'Hello!');
+      server.close();
+      client.close();
+    }));
+  }));
+
+  await once(server, 'ready');
+
+  const req = client.connect({
+    address: common.localhostIPv4,
+    port: server.endpoints[0].address.port
+  });
+
+  const stream = req.openStream({ halfOpen: true });
+  stream.end('Hello!');
+
+  assert.strictEqual(stream.pending, true);
+
+  await once(stream, 'ready');
+
+  assert.strictEqual(stream.pending, false);
+
+  await once(stream, 'close');
+
+  await Promise.allSettled([
+    once(server, 'close'),
+    once(client, 'close')
+  ]);
+})().then(common.mustCall());
diff --git a/test/parallel/test-quic-send-fd.js b/test/parallel/test-quic-quicsession-send-fd.js
similarity index 100%
rename from test/parallel/test-quic-send-fd.js
rename to test/parallel/test-quic-quicsession-send-fd.js
diff --git a/test/parallel/test-quic-send-file-close-before-open.js b/test/parallel/test-quic-quicsession-send-file-close-before-open.js
similarity index 100%
rename from test/parallel/test-quic-send-file-close-before-open.js
rename to test/parallel/test-quic-quicsession-send-file-close-before-open.js
diff --git a/test/parallel/test-quic-send-file-open-error-handled.js b/test/parallel/test-quic-quicsession-send-file-open-error-handled.js
similarity index 100%
rename from test/parallel/test-quic-send-file-open-error-handled.js
rename to test/parallel/test-quic-quicsession-send-file-open-error-handled.js
diff --git a/test/parallel/test-quic-send-file-open-error.js b/test/parallel/test-quic-quicsession-send-file-open-error.js
similarity index 100%
rename from test/parallel/test-quic-send-file-open-error.js
rename to test/parallel/test-quic-quicsession-send-file-open-error.js
diff --git a/test/parallel/test-quic-socket-close.js b/test/parallel/test-quic-quicsocket-close.js
similarity index 63%
rename from test/parallel/test-quic-socket-close.js
rename to test/parallel/test-quic-quicsocket-close.js
index 0636d95fed..c287e958a6 100644
--- a/test/parallel/test-quic-socket-close.js
+++ b/test/parallel/test-quic-quicsocket-close.js
@@ -7,20 +7,13 @@ if (!common.hasQuic)
 
 const assert = require('assert');
 const { createSocket } = require('quic');
-const { kClientPort } = require('../common/quic');
 
 {
-  const socket = createSocket({ endpoint: { port: kClientPort } });
-  socket.close();
+  const socket = createSocket();
+  socket.close(common.mustCall());
+  socket.on('close', common.mustCall());
   assert.throws(() => socket.close(), {
     code: 'ERR_QUICSOCKET_DESTROYED',
-    name: 'Error',
     message: 'Cannot call close after a QuicSocket has been destroyed'
   });
 }
-
-{
-  const socket = createSocket({ endpoint: { port: kClientPort } });
-
-  socket.close(common.mustCall());
-}
diff --git a/test/parallel/test-quic-packetloss.js b/test/parallel/test-quic-quicsocket-packetloss-stream-rx.js
similarity index 59%
rename from test/parallel/test-quic-packetloss.js
rename to test/parallel/test-quic-quicsocket-packetloss-stream-rx.js
index 09a1ee78cf..0b82a9381f 100644
--- a/test/parallel/test-quic-packetloss.js
+++ b/test/parallel/test-quic-quicsocket-packetloss-stream-rx.js
@@ -1,9 +1,12 @@
 // Flags: --no-warnings
 'use strict';
 
-// This test is not yet working correctly because data
-// retransmission and the requisite data buffering is
-// not yet working correctly
+// Tests that stream data is successfully transmitted under
+// packet loss conditions on the receiving end.
+
+// TODO(@jasnell): We need an equivalent test that checks
+// transmission end random packet loss.
+
 const common = require('../common');
 if (!common.hasQuic)
   common.skip('missing quic');
@@ -16,16 +19,24 @@ const {
   ca,
   debug
 } = require('../common/quic');
+const { pipeline } = require('stream');
 
 const { createSocket } = require('quic');
 
-let client;
-const server = createSocket();
+const kData = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const options = { key, cert, ca, alpn: 'echo' };
 
-const kServerName = 'agent1';
-const kALPN = 'echo';
+const client = createSocket({ client: options });
+const server = createSocket({ server: options });
 
-const kData = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+// Both client and server will drop received packets about 20% of the time
+// It is important to keep in mind that this will make the runtime of the
+// test non-deterministic. If we encounter flaky timeouts with this test,
+// the randomized packet loss will be the reason, but random packet loss
+// is exactly what is being tested. So if flaky timeouts do occur, it will
+// be best to extend the failure timeout for this test.
+server.setDiagnosticPacketLoss({ rx: 0.2 });
+client.setDiagnosticPacketLoss({ rx: 0.2 });
 
 const countdown = new Countdown(1, () => {
   debug('Countdown expired. Destroying sockets');
@@ -33,36 +44,36 @@ const countdown = new Countdown(1, () => {
   client.close();
 });
 
-server.listen({ key, cert, ca, alpn: kALPN });
+server.listen();
 server.on('session', common.mustCall((session) => {
   debug('QuicServerSession Created');
 
   session.on('stream', common.mustCall((stream) => {
     debug('Bidirectional, Client-initiated stream %d received', stream.id);
-    stream.pipe(stream);
+    pipeline(stream, stream, common.mustCall((err) => {
+      assert(!err);
+    }));
   }));
 
 }));
 
 server.on('ready', common.mustCall(() => {
   debug('Server is listening on port %d', server.endpoints[0].address.port);
-  client = createSocket({ client: { key, cert, ca, alpn: kALPN } });
 
   const req = client.connect({
-    address: 'localhost',
+    address: common.localhostIPv4,
     port: server.endpoints[0].address.port,
-    servername: kServerName,
   });
 
   req.on('secure', common.mustCall((servername, alpn, cipher) => {
     debug('QuicClientSession TLS Handshake Complete');
 
-    // Set for 20% received packet loss on the server
-    server.setDiagnosticPacketLoss({ rx: 0.2 });
-
     const stream = req.openStream();
 
     let n = 0;
+    // This forces multiple stream packets to be sent out
+    // rather than all the data being written in a single
+    // packet.
     function sendChunk() {
       if (n < kData.length) {
         stream.write(kData[n++], common.mustCall());
@@ -78,7 +89,7 @@ server.on('ready', common.mustCall(() => {
     stream.setEncoding('utf8');
     stream.on('data', (chunk) => data += chunk);
     stream.on('end', common.mustCall(() => {
-      console.log(data, data.length);
+      debug('Received data: %s', kData);
       assert.strictEqual(data, kData);
     }));
 
diff --git a/test/parallel/test-quic-serverbusy.js b/test/parallel/test-quic-quicsocket-serverbusy.js
similarity index 91%
rename from test/parallel/test-quic-serverbusy.js
rename to test/parallel/test-quic-quicsocket-serverbusy.js
index 3fe0872128..d53b321906 100644
--- a/test/parallel/test-quic-serverbusy.js
+++ b/test/parallel/test-quic-quicsocket-serverbusy.js
@@ -18,11 +18,12 @@ const {
 } = require('../common/quic');
 
 const { createSocket } = require('quic');
+const options = { key, cert, ca, alpn: 'zzz' };
 
 let client;
 const server = createSocket({
   endpoint: { port: kServerPort },
-  server: { key, cert, ca, alpn: 'zzz' }
+  server: options
 });
 
 server.on('busy', common.mustCall((busy) => {
@@ -42,13 +43,13 @@ server.on('ready', common.mustCall(() => {
   debug('Server is listening on port %d', server.endpoints[0].address.port);
   client = createSocket({
     endpoint: { port: kClientPort },
-    client: { key, cert, ca, alpn: 'zzz' }
+    client: options
   });
 
   client.on('close', common.mustCall());
 
   const req = client.connect({
-    address: 'localhost',
+    address: common.localhostIPv4,
     port: server.endpoints[0].address.port,
   });
 
diff --git a/test/parallel/test-quic-quicsocket.js b/test/parallel/test-quic-quicsocket.js
index f26f5a7002..5a5cf57505 100644
--- a/test/parallel/test-quic-quicsocket.js
+++ b/test/parallel/test-quic-quicsocket.js
@@ -43,6 +43,7 @@ assert.strictEqual(socket.serverSessions, 0n);
 assert.strictEqual(socket.clientSessions, 0n);
 
 const endpoint = socket.endpoints[0];
+assert(endpoint);
 
 // Will throw because the QuicSocket is not bound
 {
@@ -52,6 +53,7 @@ const endpoint = socket.endpoints[0];
   assert.throws(() => endpoint.setBroadcast(), err);
   assert.throws(() => endpoint.setMulticastLoopback(), err);
   assert.throws(() => endpoint.setMulticastInterface('0.0.0.0'), err);
+  // TODO(@jasnell): Verify behavior of add/drop membership then test
   // assert.throws(() => endpoint.addMembership(
   //     '127.0.0.1', '127.0.0.1'), err);
   // assert.throws(() => endpoint.dropMembership(
@@ -70,37 +72,14 @@ const endpoint = socket.endpoints[0];
   });
 });
 
-assert.throws(() => socket.setDiagnosticPacketLoss({ rx: -1 }), {
-  code: 'ERR_OUT_OF_RANGE'
-});
-
-assert.throws(() => socket.setDiagnosticPacketLoss({ rx: 1.1 }), {
-  code: 'ERR_OUT_OF_RANGE'
-});
-
-assert.throws(() => socket.setDiagnosticPacketLoss({ tx: -1 }), {
-  code: 'ERR_OUT_OF_RANGE'
-});
-
-assert.throws(() => socket.setDiagnosticPacketLoss({ tx: 1.1 }), {
-  code: 'ERR_OUT_OF_RANGE'
-});
-
-[1, 1n, false, [], {}, null].forEach((alpn) => {
-  assert.throws(() => socket.listen({ alpn }), {
-    code: 'ERR_INVALID_ARG_TYPE'
-  });
-});
-
-[1, 1n, false, [], {}, null].forEach((ciphers) => {
-  assert.throws(() => socket.listen({ ciphers }), {
-    code: 'ERR_INVALID_ARG_TYPE'
-  });
-});
-
-[1, 1n, false, [], {}, null].forEach((groups) => {
-  assert.throws(() => socket.listen({ groups }), {
-    code: 'ERR_INVALID_ARG_TYPE'
+[
+  { rx: -1 },
+  { rx: 1.1 },
+  { tx: -1 },
+  { tx: 1.1 }
+].forEach((options) => {
+  assert.throws(() => socket.setDiagnosticPacketLoss(options), {
+    code: 'ERR_OUT_OF_RANGE'
   });
 });
 
@@ -147,49 +126,29 @@ socket.on('ready', common.mustCall(() => {
 }));
 
 socket.on('close', common.mustCall(() => {
-  const makeError = (method) => ({
-    code: 'ERR_QUICSOCKET_DESTROYED',
-    message: `Cannot call ${method} after a QuicSocket has been destroyed`
+  [
+    'ref',
+    'unref',
+    'setTTL',
+    'setMulticastTTL',
+    'setBroadcast',
+    'setMulticastLoopback',
+    'setMulticastInterface',
+    'addMembership',
+    'dropMembership'
+  ].forEach((op) => {
+    assert.throws(() => endpoint[op](), {
+      code: 'ERR_QUICSOCKET_DESTROYED',
+      message: `Cannot call ${op} after a QuicSocket has been destroyed`
+    });
   });
 
-  assert.throws(
-    () => socket.ref(),
-    makeError('ref')
-  );
-  assert.throws(
-    () => socket.unref(),
-    makeError('unref')
-  );
-  assert.throws(
-    () => endpoint.setTTL(1),
-    makeError('setTTL')
-  );
-  assert.throws(
-    () => endpoint.setMulticastTTL(1),
-    makeError('setMulticastTTL')
-  );
-  assert.throws(
-    () => endpoint.setBroadcast(true),
-    makeError('setBroadcast')
-  );
-  assert.throws(
-    () => endpoint.setMulticastLoopback(),
-    makeError('setMulticastLoopback')
-  );
-  assert.throws(
-    () => endpoint.setMulticastInterface(true),
-    makeError('setMulticastInterface')
-  );
-  assert.throws(
-    () => endpoint.addMembership('foo', 'bar'),
-    makeError('addMembership')
-  );
-  assert.throws(
-    () => endpoint.dropMembership('foo', 'bar'),
-    makeError('dropMembership')
-  );
-  assert.throws(
-    () => socket.setServerBusy(true),
-    makeError('setServerBusy')
-  );
+  [
+    'setServerBusy',
+  ].forEach((op) => {
+    assert.throws(() => socket[op](), {
+      code: 'ERR_QUICSOCKET_DESTROYED',
+      message: `Cannot call ${op} after a QuicSocket has been destroyed`
+    });
+  });
 }));
diff --git a/test/parallel/test-quic-stream-destroy.js b/test/parallel/test-quic-quicstream-destroy.js
similarity index 68%
rename from test/parallel/test-quic-stream-destroy.js
rename to test/parallel/test-quic-quicstream-destroy.js
index 249d1d5c48..ca5c508320 100644
--- a/test/parallel/test-quic-stream-destroy.js
+++ b/test/parallel/test-quic-quicstream-destroy.js
@@ -14,33 +14,24 @@ const {
   debug,
   key,
   cert,
-  ca,
-  kServerPort,
-  kClientPort,
-  setupKeylog
+  ca
 } = require('../common/quic');
 
 const { createSocket } = require('quic');
 
-const kServerName = 'agent2';
-const kALPN = 'zzz';
+const options = { key, cert, ca, alpn: 'zzz' };
 
-const server = createSocket({ endpoint: { port: kServerPort } });
+const server = createSocket({ server: options });
 
-server.listen({ key, cert, ca, alpn: kALPN });
+server.listen();
 
 server.on('session', common.mustCall((session) => {
   debug('QuicServerSession Created');
-  setupKeylog(session);
 
   session.on('stream', common.mustCall((stream) => {
     stream.destroy();
     stream.on('close', common.mustCall());
     stream.on('error', common.mustNotCall());
-    // Abort will not be called in this case because close()
-    // is not used. The stream is just immediately destroyed
-    // and no longer available for use.
-    stream.on('abort', common.mustNotCall());
     assert(stream.destroyed);
   }));
 }));
@@ -48,22 +39,18 @@ server.on('session', common.mustCall((session) => {
 server.on('ready', common.mustCall(() => {
   debug('Server is listening on port %d', server.endpoints[0].address.port);
 
-  const client = createSocket({
-    endpoint: { port: kClientPort },
-    client: { key, cert, ca, alpn: kALPN }
-  });
+  const client = createSocket({ client: options });
 
   client.on('close', common.mustCall(() => {
     debug('Client closing. Duration', client.duration);
   }));
 
   const req = client.connect({
-    address: 'localhost',
-    port: server.endpoints[0].address.port,
-    servername: kServerName,
+    address: common.localhostIPv4,
+    port: server.endpoints[0].address.port
   });
 
-  req.on('secure', common.mustCall((servername, alpn, cipher) => {
+  req.on('secure', common.mustCall(() => {
     debug('QuicClientSession TLS Handshake Complete');
 
     const stream = req.openStream();
diff --git a/test/parallel/test-quic-stream-identifiers.js b/test/parallel/test-quic-quicstream-identifiers.js
similarity index 95%
rename from test/parallel/test-quic-stream-identifiers.js
rename to test/parallel/test-quic-quicstream-identifiers.js
index cf41da0bff..dd3443c0b4 100644
--- a/test/parallel/test-quic-stream-identifiers.js
+++ b/test/parallel/test-quic-quicstream-identifiers.js
@@ -27,9 +27,10 @@ const assert = require('assert');
 const { debug, key, cert } = require('../common/quic');
 
 const { createSocket } = require('quic');
+const options = { key, cert, alpn: 'zzz' };
 
 let client;
-const server = createSocket();
+const server = createSocket({ server: options });
 
 const countdown = new Countdown(4, () => {
   debug('Countdown expired. Closing sockets');
@@ -39,7 +40,7 @@ const countdown = new Countdown(4, () => {
 
 const closeHandler = common.mustCall(() => countdown.dec(), 4);
 
-server.listen({ key, cert, alpn: 'zzz' });
+server.listen();
 server.on('session', common.mustCall((session) => {
   debug('QuicServerSession created');
   session.on('secure', common.mustCall(() => {
@@ -98,14 +99,10 @@ server.on('session', common.mustCall((session) => {
 
 server.on('ready', common.mustCall(() => {
   debug('Server listening on port %d', server.endpoints[0].address.port);
-  client = createSocket();
+  client = createSocket({ client: options });
   const req = client.connect({
-    type: 'udp4',
-    address: 'localhost',
+    address: common.localhostIPv4,
     port: server.endpoints[0].address.port,
-    rejectUnauthorized: false,
-    maxStreamsUni: 10,
-    alpn: 'zzz',
   });
 
   req.on('secure', common.mustCall(() => {