diff --git a/doc/api/net.md b/doc/api/net.md
index 233821d80214dc..878c6aa762b25e 100644
--- a/doc/api/net.md
+++ b/doc/api/net.md
@@ -620,6 +620,18 @@ is received. For example, it is passed to the listeners of a
 [`'connection'`][] event emitted on a [`net.Server`][], so the user can use
 it to interact with the client.
 
+### Class property: `net.Socket.autoDetectFamily`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean} **Default:** `true`
+
+The default value for the `autoDetectFamily` option for new
+[`socket.connect(options)`][] calls. If set to true it enables the Happy
+Eyeballs connection algorithm. This value may be modified.
+
 ### `new net.Socket([options])`
 
 <!-- YAML
@@ -856,6 +868,10 @@ behavior.
 <!-- YAML
 added: v0.1.90
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/44731
+    description: Added the `autoDetectFamily` option, which enables the Happy
+                 Eyeballs algorithm for dualstack connections.
   - version:
     - v17.7.0
     - v16.15.0
@@ -889,6 +905,7 @@ For TCP connections, available `options` are:
 * `port` {number} Required. Port the socket should connect to.
 * `host` {string} Host the socket should connect to. **Default:** `'localhost'`.
 * `localAddress` {string} Local address the socket should connect from.
+  This is ignored if `autoDetectFamily` is set to `true`.
 * `localPort` {number} Local port the socket should connect from.
 * `family` {number}: Version of IP stack. Must be `4`, `6`, or `0`. The value
   `0` indicates that both IPv4 and IPv6 addresses are allowed. **Default:** `0`.
@@ -902,6 +919,13 @@ For TCP connections, available `options` are:
   **Default:** `false`.
 * `keepAliveInitialDelay` {number} If set to a positive number, it sets the initial delay before
   the first keepalive probe is sent on an idle socket.**Default:** `0`.
+* `autoDetectFamily` {boolean}: Enables the Happy Eyeballs connection algorithm.
+  The `all` option passed to lookup is set to `true` and the sockets attempts to
+  connect to all returned AAAA and A records at the same time, keeping only
+  the first successful connection and disconnecting all the other ones.
+  Connection errors are not emitted if at least a connection succeeds.
+  Ignored if the `family` option is not `0`.
+  **Default:** The value of [`net.Socket.autoDetectFamily`][].
 
 For [IPC][] connections, available `options` are:
 
@@ -1643,6 +1667,7 @@ net.isIPv6('fhqwhgads'); // returns false
 [`dns.lookup()`]: dns.md#dnslookuphostname-options-callback
 [`dns.lookup()` hints]: dns.md#supported-getaddrinfo-flags
 [`net.Server`]: #class-netserver
+[`net.Socket.autoDetectFamily`]: #class-property-netsocketautodetectfamily
 [`net.Socket`]: #class-netsocket
 [`net.connect()`]: #netconnect
 [`net.connect(options)`]: #netconnectoptions-connectlistener
diff --git a/lib/_tls_wrap.js b/lib/_tls_wrap.js
index 11ff14d725b36b..551871fa843ce3 100644
--- a/lib/_tls_wrap.js
+++ b/lib/_tls_wrap.js
@@ -598,11 +598,10 @@ TLSSocket.prototype.disableRenegotiation = function disableRenegotiation() {
   this[kDisableRenegotiation] = true;
 };
 
-TLSSocket.prototype._wrapHandle = function(wrap) {
-  let handle;
-
-  if (wrap)
+TLSSocket.prototype._wrapHandle = function(wrap, handle) {
+  if (!handle && wrap) {
     handle = wrap._handle;
+  }
 
   const options = this._tlsOptions;
   if (!handle) {
@@ -633,6 +632,16 @@ TLSSocket.prototype._wrapHandle = function(wrap) {
   return res;
 };
 
+TLSSocket.prototype._wrapConnectedHandle = function(handle) {
+  this._handle = this._wrapHandle(null, handle);
+  this.ssl = this._handle;
+  this._init();
+
+  if (this._tlsOptions.enableTrace) {
+    this._handle.enableTrace();
+  }
+};
+
 // This eliminates a cyclic reference to TLSWrap
 // Ref: https://github.com/nodejs/node/commit/f7620fb96d339f704932f9bb9a0dceb9952df2d4
 function defineHandleReading(socket, handle) {
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index f6a8ce6549c597..3de2576b4fbf25 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -168,6 +168,13 @@ const aggregateTwoErrors = hideStackFrames((innerError, outerError) => {
   return innerError || outerError;
 });
 
+const aggregateErrors = hideStackFrames((errors, message, code) => {
+  // eslint-disable-next-line no-restricted-syntax
+  const err = new AggregateError(new SafeArrayIterator(errors), message);
+  err.code = errors[0]?.code;
+  return err;
+});
+
 // Lazily loaded
 let util;
 let assert;
@@ -893,6 +900,7 @@ function determineSpecificType(value) {
 module.exports = {
   AbortError,
   aggregateTwoErrors,
+  aggregateErrors,
   captureLargerStackTrace,
   codes,
   connResetException,
diff --git a/lib/net.js b/lib/net.js
index eaa5e594e5f4ef..d9654243b16ebb 100644
--- a/lib/net.js
+++ b/lib/net.js
@@ -24,7 +24,9 @@
 const {
   ArrayIsArray,
   ArrayPrototypeIndexOf,
+  ArrayPrototypePush,
   Boolean,
+  FunctionPrototypeBind,
   Number,
   NumberIsNaN,
   NumberParseInt,
@@ -96,6 +98,7 @@ const {
     ERR_SOCKET_CLOSED,
     ERR_MISSING_ARGS,
   },
+  aggregateErrors,
   errnoException,
   exceptionWithHostPort,
   genericNodeError,
@@ -458,6 +461,8 @@ function Socket(options) {
 ObjectSetPrototypeOf(Socket.prototype, stream.Duplex.prototype);
 ObjectSetPrototypeOf(Socket, stream.Duplex);
 
+Socket.autoDetectFamily = true;
+
 // Refresh existing timeouts.
 Socket.prototype._unrefTimer = function _unrefTimer() {
   for (let s = this; s !== null; s = s._parent) {
@@ -1042,6 +1047,81 @@ function internalConnect(
 }
 
 
+function internalConnectMultiple(
+  self, addresses, port, localPort, flags
+) {
+  assert(self.connecting);
+
+  const context = {
+    errors: [],
+    connecting: 0,
+    completed: false,
+  };
+
+  const oncomplete = FunctionPrototypeBind(afterConnectMultiple, self, context);
+
+  for (let i = 0, l = addresses.length; i < l; i++) {
+    if (!addresses[i]) {
+      continue;
+    }
+
+    const { address, family: addressType } = addresses[i];
+    const handle = new TCP(TCPConstants.SOCKET);
+
+    let localAddress;
+    let err;
+
+    if (localPort) {
+      if (addressType === 4) {
+        localAddress = DEFAULT_IPV4_ADDR;
+        err = handle.bind(localAddress, localPort);
+      } else { // addressType === 6
+        localAddress = DEFAULT_IPV6_ADDR;
+        err = handle.bind6(localAddress, localPort, flags);
+      }
+
+      debug('connect/happy eyeballs: binding to localAddress: %s and localPort: %d (addressType: %d)',
+            localAddress, localPort, addressType);
+
+      err = checkBindError(err, localPort, handle);
+      if (err) {
+        ArrayPrototypePush(context.errors, exceptionWithHostPort(err, 'bind', localAddress, localPort));
+        continue;
+      }
+    }
+
+    const req = new TCPConnectWrap();
+    req.oncomplete = oncomplete;
+    req.address = address;
+    req.port = port;
+    req.localAddress = localAddress;
+    req.localPort = localPort;
+
+    if (addressType === 4) {
+      err = handle.connect(req, address, port);
+    } else {
+      err = handle.connect6(req, address, port);
+    }
+
+    if (err) {
+      const sockname = self._getsockname();
+      let details;
+
+      if (sockname) {
+        details = sockname.address + ':' + sockname.port;
+      }
+
+      ArrayPrototypePush(context.errors, exceptionWithHostPort(err, 'connect', address, port, details));
+    } else {
+      context.connecting++;
+    }
+  }
+
+  if (context.errors.length && context.connecting === 0) {
+    self.destroy(aggregateErrors(context.error));
+  }
+}
+
 Socket.prototype.connect = function(...args) {
   let normalized;
   // If passed an array, it's treated as an array of arguments that have
@@ -1113,6 +1193,7 @@ function socketToDnsFamily(family) {
 function lookupAndConnect(self, options) {
   const { localAddress, localPort } = options;
   const host = options.host || 'localhost';
+  const autoDetectFamily = options.autoDetectFamily ?? Socket.autoDetectFamily;
   let { port } = options;
 
   if (localAddress && !isIP(localAddress)) {
@@ -1166,6 +1247,79 @@ function lookupAndConnect(self, options) {
   debug('connect: dns options', dnsopts);
   self._host = host;
   const lookup = options.lookup || dns.lookup;
+
+  if (dnsopts.family !== 4 && dnsopts.family !== 6 && autoDetectFamily) {
+    debug('connect: autodetecting family via happy eyeballs');
+
+    dnsopts.all = true;
+
+    defaultTriggerAsyncIdScope(self[async_id_symbol], function() {
+      lookup(host, dnsopts, function emitLookup(err, addresses) {
+        // It's possible we were destroyed while looking this up.
+        // XXX it would be great if we could cancel the promise returned by
+        // the look up.
+        if (!self.connecting) {
+          return;
+        } else if (err) {
+          // net.createConnection() creates a net.Socket object and immediately
+          // calls net.Socket.connect() on it (that's us). There are no event
+          // listeners registered yet so defer the error event to the next tick.
+          process.nextTick(connectErrorNT, self, err);
+          return;
+        }
+
+        // This array will contain two elements at most, the first is a AAAA record, the second a A record
+        let ipv4Address;
+        let ipv6Address;
+
+        // Gather all the addresses we can use for happy eyeballs
+        for (let i = 0, l = addresses.length; i < l; i++) {
+          const address = addresses[i];
+          const { address: ip, family: addressType } = address;
+          self.emit('lookup', err, ip, addressType, host);
+
+          if (isIP(ip)) {
+            if (addressType === 6 && !ipv6Address) {
+              ipv6Address = address;
+            } else if (addressType === 4 && !ipv4Address) {
+              ipv4Address = address;
+            }
+          }
+
+          if (ipv6Address && ipv4Address) {
+            break;
+          }
+        }
+
+        // When no AAAA or A records are available, fail on the first one
+        if (!ipv6Address && !ipv4Address) {
+          const { address: firstIp, family: firstAddressType } = addresses[0];
+
+          if (!isIP(firstIp)) {
+            err = new ERR_INVALID_IP_ADDRESS(firstIp);
+            process.nextTick(connectErrorNT, self, err);
+          } else if (firstAddressType !== 4 && firstAddressType !== 6) {
+            err = new ERR_INVALID_ADDRESS_FAMILY(firstAddressType,
+                                                 options.host,
+                                                 options.port);
+            process.nextTick(connectErrorNT, self, err);
+          }
+
+          return;
+        }
+
+        self._unrefTimer();
+        defaultTriggerAsyncIdScope(
+          self[async_id_symbol],
+          internalConnectMultiple,
+          self, [ipv6Address, ipv4Address], port, localPort
+        );
+      });
+    });
+
+    return;
+  }
+
   defaultTriggerAsyncIdScope(self[async_id_symbol], function() {
     lookup(host, dnsopts, function emitLookup(err, ip, addressType) {
       self.emit('lookup', err, ip, addressType, host);
@@ -1294,6 +1448,62 @@ function afterConnect(status, handle, req, readable, writable) {
   }
 }
 
+function afterConnectMultiple(context, status, handle, req, readable, writable) {
+  context.connecting--;
+
+  // Some error occurred, add to the list of exceptions
+  if (status !== 0) {
+    let details;
+    if (req.localAddress && req.localPort) {
+      details = req.localAddress + ':' + req.localPort;
+    }
+    const ex = exceptionWithHostPort(status,
+                                     'connect',
+                                     req.address,
+                                     req.port,
+                                     details);
+    if (details) {
+      ex.localAddress = req.localAddress;
+      ex.localPort = req.localPort;
+    }
+
+    ArrayPrototypePush(context.errors, ex);
+
+    if (context.connecting === 0) {
+      this.destroy(aggregateErrors(context.errors));
+    }
+
+    return;
+  }
+
+  // One of the connection has completed and correctly dispatched, ignore this one
+  if (context.completed) {
+    debug('connect/happy eyeballs: ignoring successful connection to %s:%s', req.address, req.port);
+    handle.close();
+    return;
+  }
+
+  // Mark the connection as successful
+  context.completed = true;
+  this._handle = handle;
+  initSocketHandle(this);
+
+  if (this.encrypted) {
+    this._wrapConnectedHandle(handle);
+    initSocketHandle(this); // This is called again to initialize the TLSWrap
+  }
+
+  if (hasObserver('net')) {
+    startPerf(
+      this,
+      kPerfHooksNetConnectContext,
+      { type: 'net', name: 'connect', detail: { host: req.address, port: req.port } }
+    );
+  }
+
+  afterConnect(status, handle, req, readable, writable);
+}
+
 function addAbortSignalOption(self, options) {
   if (options?.signal === undefined) {
     return;
diff --git a/test/async-hooks/test-async-local-storage-socket.js b/test/async-hooks/test-async-local-storage-socket.js
index 337b4073df5dfc..4ca683d042e3a6 100644
--- a/test/async-hooks/test-async-local-storage-socket.js
+++ b/test/async-hooks/test-async-local-storage-socket.js
@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 
 // Regression tests for https://github.com/nodejs/node/issues/40693
 
@@ -8,6 +8,8 @@ const assert = require('assert');
 const net = require('net');
 const { AsyncLocalStorage } = require('async_hooks');
 
+common.setHappyEyeballsEnabled(false);
+
 net
   .createServer((socket) => {
     socket.write('Hello, world!');
diff --git a/test/async-hooks/test-graph.shutdown.js b/test/async-hooks/test-graph.shutdown.js
index f4f077c0dd1c83..369209b791d35a 100644
--- a/test/async-hooks/test-graph.shutdown.js
+++ b/test/async-hooks/test-graph.shutdown.js
@@ -8,6 +8,8 @@ const initHooks = require('./init-hooks');
 const verifyGraph = require('./verify-graph');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const hooks = initHooks();
 hooks.enable();
 
diff --git a/test/async-hooks/test-graph.tls-write.js b/test/async-hooks/test-graph.tls-write.js
index b493ac819dfbcd..386bde64622c8f 100644
--- a/test/async-hooks/test-graph.tls-write.js
+++ b/test/async-hooks/test-graph.tls-write.js
@@ -12,6 +12,8 @@ const verifyGraph = require('./verify-graph');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const hooks = initHooks();
 hooks.enable();
 
diff --git a/test/async-hooks/test-shutdownwrap.js b/test/async-hooks/test-shutdownwrap.js
index fea4a3a166a270..39734fdb56204c 100644
--- a/test/async-hooks/test-shutdownwrap.js
+++ b/test/async-hooks/test-shutdownwrap.js
@@ -7,6 +7,8 @@ const { checkInvocations } = require('./hook-checks');
 
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const hooks = initHooks();
 hooks.enable();
 
diff --git a/test/async-hooks/test-tlswrap.js b/test/async-hooks/test-tlswrap.js
index 65a4087d1659c6..526a7dcba47987 100644
--- a/test/async-hooks/test-tlswrap.js
+++ b/test/async-hooks/test-tlswrap.js
@@ -12,6 +12,8 @@ const tick = require('../common/tick');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 
+common.setHappyEyeballsEnabled(false);
+
 const hooks = initHooks();
 hooks.enable();
 
diff --git a/test/async-hooks/test-writewrap.js b/test/async-hooks/test-writewrap.js
index 4f3455480ba849..a3dc5ec1bef2fa 100644
--- a/test/async-hooks/test-writewrap.js
+++ b/test/async-hooks/test-writewrap.js
@@ -6,6 +6,8 @@ const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const hooks = initHooks();
 hooks.enable();
 
diff --git a/test/common/index.js b/test/common/index.js
index b3c063b57ab41c..f027141452f052 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -26,6 +26,7 @@ const process = global.process;  // Some tests tamper with the process global.
 const assert = require('assert');
 const { exec, execSync, spawn, spawnSync } = require('child_process');
 const fs = require('fs');
+const { Socket } = require('net');
 // Do not require 'os' until needed so that test-os-checked-function can
 // monkey patch it. If 'os' is required here, that test will fail.
 const path = require('path');
@@ -877,6 +878,10 @@ function spawnPromisified(...args) {
   });
 }
 
+function setHappyEyeballsEnabled(value) {
+  Socket.autoDetectFamily = value;
+}
+
 const common = {
   allowGlobals,
   buildType,
@@ -920,6 +925,7 @@ const common = {
   pwdCommand,
   requireNoPackageJSONAbove,
   runWithInvalidFD,
+  setHappyEyeballsEnabled,
   skip,
   skipIf32Bits,
   skipIfDumbTerminal,
diff --git a/test/parallel/test-async-hooks-http-parser-destroy.js b/test/parallel/test-async-hooks-http-parser-destroy.js
index 6cbc2043b09583..32f529f2d8aa65 100644
--- a/test/parallel/test-async-hooks-http-parser-destroy.js
+++ b/test/parallel/test-async-hooks-http-parser-destroy.js
@@ -8,6 +8,8 @@ const http = require('http');
 // Checks that matching destroys are emitted when creating new/reusing old http
 // parser instances.
 
+common.setHappyEyeballsEnabled(false);
+
 const N = 50;
 const KEEP_ALIVE = 100;
 
diff --git a/test/parallel/test-child-process-fork-net-server.js b/test/parallel/test-child-process-fork-net-server.js
index 3a3f01c6d664cb..d6b5479091da78 100644
--- a/test/parallel/test-child-process-fork-net-server.js
+++ b/test/parallel/test-child-process-fork-net-server.js
@@ -74,6 +74,7 @@ if (process.argv[2] === 'child') {
 
   process.send({ what: 'ready' });
 } else {
+  common.setHappyEyeballsEnabled(false);
 
   const child = fork(process.argv[1], ['child']);
 
diff --git a/test/parallel/test-child-process-fork-net-socket.js b/test/parallel/test-child-process-fork-net-socket.js
index 28da94f4ef566b..f0df243effd024 100644
--- a/test/parallel/test-child-process-fork-net-socket.js
+++ b/test/parallel/test-child-process-fork-net-socket.js
@@ -23,6 +23,7 @@
 const {
   mustCall,
   mustCallAtLeast,
+  setHappyEyeballsEnabled,
 } = require('../common');
 const assert = require('assert');
 const fork = require('child_process').fork;
@@ -42,6 +43,7 @@ if (process.argv[2] === 'child') {
 
   process.send({ what: 'ready' });
 } else {
+  setHappyEyeballsEnabled(false);
 
   const child = fork(process.argv[1], ['child']);
 
diff --git a/test/parallel/test-cluster-send-handle-twice.js b/test/parallel/test-cluster-send-handle-twice.js
index c413f6f82bffca..affbea0675ea4f 100644
--- a/test/parallel/test-cluster-send-handle-twice.js
+++ b/test/parallel/test-cluster-send-handle-twice.js
@@ -40,6 +40,8 @@ if (cluster.isPrimary) {
     }));
   }
 } else {
+  common.setHappyEyeballsEnabled(false);
+
   const server = net.createServer(common.mustCall((socket) => {
     process.send('send-handle-1', socket);
     process.send('send-handle-2', socket);
diff --git a/test/parallel/test-cluster-send-socket-to-worker-http-server.js b/test/parallel/test-cluster-send-socket-to-worker-http-server.js
index 49993514dddc36..ac0bc498805ec8 100644
--- a/test/parallel/test-cluster-send-socket-to-worker-http-server.js
+++ b/test/parallel/test-cluster-send-socket-to-worker-http-server.js
@@ -11,6 +11,8 @@ const http = require('http');
 const net = require('net');
 
 if (cluster.isPrimary) {
+  common.setHappyEyeballsEnabled(false);
+
   const worker = cluster.fork();
   const server = net.createServer(common.mustCall((socket) => {
     worker.send('socket', socket);
@@ -25,6 +27,7 @@ if (cluster.isPrimary) {
     net.createConnection(server.address().port);
   }));
 } else {
+
   const server = http.createServer();
 
   server.on('connection', common.mustCall((socket) => {
diff --git a/test/parallel/test-diagnostics-channel-net.js b/test/parallel/test-diagnostics-channel-net.js
index 4004cbf8df7a00..90cc682066fefb 100644
--- a/test/parallel/test-diagnostics-channel-net.js
+++ b/test/parallel/test-diagnostics-channel-net.js
@@ -4,6 +4,8 @@ const assert = require('assert');
 const net = require('net');
 const dc = require('diagnostics_channel');
 
+common.setHappyEyeballsEnabled(false);
+
 const isNetSocket = (socket) => socket instanceof net.Socket;
 
 dc.subscribe('net.client.socket', common.mustCall(({ socket }) => {
diff --git a/test/parallel/test-gc-http-client-connaborted.js b/test/parallel/test-gc-http-client-connaborted.js
index fd276d30e2beb1..f2bc21b568802b 100644
--- a/test/parallel/test-gc-http-client-connaborted.js
+++ b/test/parallel/test-gc-http-client-connaborted.js
@@ -8,6 +8,8 @@ const onGC = require('../common/ongc');
 const http = require('http');
 const os = require('os');
 
+common.setHappyEyeballsEnabled(false);
+
 const cpus = os.cpus().length;
 let createClients = true;
 let done = 0;
diff --git a/test/parallel/test-gc-net-timeout.js b/test/parallel/test-gc-net-timeout.js
index 6b9d51c98d0e84..9ca0c7c1fef570 100644
--- a/test/parallel/test-gc-net-timeout.js
+++ b/test/parallel/test-gc-net-timeout.js
@@ -3,12 +3,14 @@
 // just like test-gc-http-client-timeout.js,
 // but using a net server/client instead
 
-require('../common');
+const common = require('../common');
 const onGC = require('../common/ongc');
 const assert = require('assert');
 const net = require('net');
 const os = require('os');
 
+common.setHappyEyeballsEnabled(false);
+
 function serverHandler(sock) {
   sock.setTimeout(120000);
   sock.resume();
diff --git a/test/parallel/test-http-client-error-rawbytes.js b/test/parallel/test-http-client-error-rawbytes.js
index c0ea16a6432698..f15942416516bd 100644
--- a/test/parallel/test-http-client-error-rawbytes.js
+++ b/test/parallel/test-http-client-error-rawbytes.js
@@ -4,6 +4,8 @@ const assert = require('assert');
 const http = require('http');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const response = Buffer.from('HTTP/1.1 200 OK\r\n' +
   'Content-Length: 6\r\n' +
   'Transfer-Encoding: Chunked\r\n' +
diff --git a/test/parallel/test-http-client-parse-error.js b/test/parallel/test-http-client-parse-error.js
index 5d0ad4b1463ed5..ce9157934e6639 100644
--- a/test/parallel/test-http-client-parse-error.js
+++ b/test/parallel/test-http-client-parse-error.js
@@ -26,6 +26,8 @@ const net = require('net');
 const assert = require('assert');
 const Countdown = require('../common/countdown');
 
+common.setHappyEyeballsEnabled(false);
+
 const countdown = new Countdown(2, () => server.close());
 
 const payloads = [
diff --git a/test/parallel/test-http-client-reject-chunked-with-content-length.js b/test/parallel/test-http-client-reject-chunked-with-content-length.js
index a3da5180e18f73..b7dd9f8f7c3b18 100644
--- a/test/parallel/test-http-client-reject-chunked-with-content-length.js
+++ b/test/parallel/test-http-client-reject-chunked-with-content-length.js
@@ -5,6 +5,8 @@ const http = require('http');
 const net = require('net');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const reqstr = 'HTTP/1.1 200 OK\r\n' +
                'Content-Length: 1\r\n' +
                'Transfer-Encoding: chunked\r\n\r\n';
diff --git a/test/parallel/test-http-client-reject-cr-no-lf.js b/test/parallel/test-http-client-reject-cr-no-lf.js
index be82caf296d9a2..402b1ee3564747 100644
--- a/test/parallel/test-http-client-reject-cr-no-lf.js
+++ b/test/parallel/test-http-client-reject-cr-no-lf.js
@@ -5,6 +5,8 @@ const http = require('http');
 const net = require('net');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const reqstr = 'HTTP/1.1 200 OK\r\n' +
                'Foo: Bar\r' +
                'Content-Length: 1\r\n\r\n';
diff --git a/test/parallel/test-http-happy-eyeballs.js b/test/parallel/test-http-happy-eyeballs.js
new file mode 100644
index 00000000000000..08f15bbe80f3ad
--- /dev/null
+++ b/test/parallel/test-http-happy-eyeballs.js
@@ -0,0 +1,125 @@
+'use strict';
+
+const common = require('../common');
+const { parseDNSPacket, writeDNSPacket } = require('../common/dns');
+
+const assert = require('assert');
+const dgram = require('dgram');
+const { Resolver } = require('dns');
+const { request, createServer } = require('http');
+
+// Test that happy eyeballs algorithm is properly implemented when using HTTP.
+function _lookup(resolver, hostname, options, cb) {
+  resolver.resolve(hostname, 'ANY', (err, replies) => {
+    assert.notStrictEqual(options.family, 4);
+
+    if (err) {
+      return cb(err);
+    }
+
+    const hosts = replies
+      .map((r) => ({ address: r.address, family: r.type === 'AAAA' ? 6 : 4 }))
+      .sort((a, b) => b.family - a.family);
+
+    if (options.all === true) {
+      return cb(null, hosts);
+    }
+
+    return cb(null, hosts[0].address, hosts[0].family);
+  });
+}
+
+function createDnsServer(ipv6Addr, ipv4Addr, cb) {
+  // Create a DNS server which replies with a AAAA and a A record for the same host
+  const socket = dgram.createSocket('udp4');
+
+  socket.on('message', common.mustCall((msg, { address, port }) => {
+    const parsed = parseDNSPacket(msg);
+    const domain = parsed.questions[0].domain;
+    assert.strictEqual(domain, 'example.org');
+
+    socket.send(writeDNSPacket({
+      id: parsed.id,
+      questions: parsed.questions,
+      answers: [
+        { type: 'AAAA', address: ipv6Addr, ttl: 123, domain: 'example.org' },
+        { type: 'A', address: ipv4Addr, ttl: 123, domain: 'example.org' },
+      ]
+    }), port, address);
+  }));
+
+  socket.bind(0, () => {
+    const resolver = new Resolver();
+    resolver.setServers([`127.0.0.1:${socket.address().port}`]);
+
+    cb({ dnsServer: socket, lookup: _lookup.bind(null, resolver) });
+  });
+}
+
+// Test that IPV4 is reached if IPV6 is not reachable
+{
+  createDnsServer('::1', '127.0.0.1', common.mustCall(function({ dnsServer, lookup }) {
+    const ipv4Server = createServer(common.mustCall((req, res) => {
+      res.writeHead(200, { Connection: 'close' });
+      res.end('response-ipv4');
+    }));
+
+    ipv4Server.listen(0, '0.0.0.0', common.mustCall(() => {
+      request(`http://example.org:${ipv4Server.address().port}/`, { lookup }, (res) => {
+        assert.strictEqual(res.statusCode, 200);
+        res.setEncoding('utf-8');
+
+        let response = '';
+
+        res.on('data', (chunk) => {
+          response += chunk;
+        });
+
+        res.on('end', common.mustCall(() => {
+          assert.strictEqual(response, 'response-ipv4');
+          ipv4Server.close();
+          dnsServer.close();
+        }));
+      }).end();
+    }));
+  }));
+}
+
+// Test that IPV4 is NOT reached if IPV6 is reachable
+{
+  createDnsServer('::1', '127.0.0.1', common.mustCall(function({ dnsServer, lookup }) {
+    const ipv4Server = createServer(common.mustNotCall((req, res) => {
+      res.writeHead(200, { Connection: 'close' });
+      res.end('response-ipv4');
+    }));
+
+    const ipv6Server = createServer(common.mustCall((req, res) => {
+      res.writeHead(200, { Connection: 'close' });
+      res.end('response-ipv6');
+    }));
+
+    ipv4Server.listen(0, '0.0.0.0', common.mustCall(() => {
+      const port = ipv4Server.address().port;
+
+      ipv6Server.listen(port, '::', common.mustCall(() => {
+        request(`http://example.org:${ipv4Server.address().port}/`, { lookup }, (res) => {
+          assert.strictEqual(res.statusCode, 200);
+          res.setEncoding('utf-8');
+
+          let response = '';
+
+          res.on('data', (chunk) => {
+            response += chunk;
+          });
+
+          res.on('end', common.mustCall(() => {
+            assert.strictEqual(response, 'response-ipv6');
+            ipv4Server.close();
+            ipv6Server.close();
+            dnsServer.close();
+          }));
+        }).end();
+      }));
+    }));
+  }));
+}
diff --git a/test/parallel/test-http-header-overflow.js b/test/parallel/test-http-header-overflow.js
index 6abbf2bafc545d..6f15a1491eff35 100644
--- a/test/parallel/test-http-header-overflow.js
+++ b/test/parallel/test-http-header-overflow.js
@@ -1,10 +1,13 @@
 // Flags: --expose-internals
 
 'use strict';
-const { expectsError, mustCall } = require('../common');
+const { expectsError, mustCall, setHappyEyeballsEnabled } = require('../common');
 const assert = require('assert');
 const { createServer, maxHeaderSize } = require('http');
 const { createConnection } = require('net');
+const { getOptionValue } = require('internal/options');
+
+setHappyEyeballsEnabled(false);
 
 const CRLF = '\r\n';
 const DUMMY_HEADER_NAME = 'Cookie: ';
diff --git a/test/parallel/test-http-localaddress-bind-error.js b/test/parallel/test-http-localaddress-bind-error.js
index d4bd72bae1d5db..66b1bb0e85dd1e 100644
--- a/test/parallel/test-http-localaddress-bind-error.js
+++ b/test/parallel/test-http-localaddress-bind-error.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
+common.setHappyEyeballsEnabled(false);
+
 const invalidLocalAddress = '1.2.3.4';
 
 const server = http.createServer(function(req, res) {
diff --git a/test/parallel/test-http-no-content-length.js b/test/parallel/test-http-no-content-length.js
index a3a51c015ec86f..651b0d25d5beb2 100644
--- a/test/parallel/test-http-no-content-length.js
+++ b/test/parallel/test-http-no-content-length.js
@@ -25,6 +25,8 @@ const assert = require('assert');
 const net = require('net');
 const http = require('http');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer(function(socket) {
   // Neither Content-Length nor Connection
   socket.end('HTTP/1.1 200 ok\r\n\r\nHello');
diff --git a/test/parallel/test-http-parser-timeout-reset.js b/test/parallel/test-http-parser-timeout-reset.js
index c51daffaafb056..db9664dbbff883 100644
--- a/test/parallel/test-http-parser-timeout-reset.js
+++ b/test/parallel/test-http-parser-timeout-reset.js
@@ -4,6 +4,8 @@ const common = require('../common');
 const net = require('net');
 const { HTTPParser } = process.binding('http_parser');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer((socket) => {
   socket.write('HTTP/1.1 200 OK\r\n');
   socket.write('Transfer-Encoding: chunked\r\n\r\n');
diff --git a/test/parallel/test-http-pipeline-flood.js b/test/parallel/test-http-pipeline-flood.js
index 29df81e857db60..4b0c9177c844a9 100644
--- a/test/parallel/test-http-pipeline-flood.js
+++ b/test/parallel/test-http-pipeline-flood.js
@@ -14,6 +14,8 @@ const common = require('../common');
 // The issue being tested exists in Node.js 0.10.20 and is resolved in 0.10.21
 // and newer.
 
+common.setHappyEyeballsEnabled(false);
+
 switch (process.argv[2]) {
   case undefined:
     return parent();
diff --git a/test/parallel/test-http-server-close-all.js b/test/parallel/test-http-server-close-all.js
index c4c211d97979a0..06363632e520a0 100644
--- a/test/parallel/test-http-server-close-all.js
+++ b/test/parallel/test-http-server-close-all.js
@@ -5,6 +5,8 @@ const assert = require('assert');
 const { createServer } = require('http');
 const { connect } = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 let connections = 0;
 
 const server = createServer(common.mustCall(function(req, res) {
diff --git a/test/parallel/test-http-server-close-idle.js b/test/parallel/test-http-server-close-idle.js
index 361ccf990fabcc..ac2a065ebcd4a9 100644
--- a/test/parallel/test-http-server-close-idle.js
+++ b/test/parallel/test-http-server-close-idle.js
@@ -5,6 +5,8 @@ const assert = require('assert');
 const { createServer } = require('http');
 const { connect } = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 let connections = 0;
 
 const server = createServer(common.mustCall(function(req, res) {
diff --git a/test/parallel/test-http-server-destroy-socket-on-client-error.js b/test/parallel/test-http-server-destroy-socket-on-client-error.js
index 3cd38a4a7ec9d2..646ae469dd4fd1 100644
--- a/test/parallel/test-http-server-destroy-socket-on-client-error.js
+++ b/test/parallel/test-http-server-destroy-socket-on-client-error.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const { expectsError, mustCall } = require('../common');
+const { expectsError, mustCall, setHappyEyeballsEnabled } = require('../common');
 
 // Test that the request socket is destroyed if the `'clientError'` event is
 // emitted and there is no listener for it.
@@ -9,6 +9,8 @@ const assert = require('assert');
 const { createServer } = require('http');
 const { createConnection } = require('net');
 
+setHappyEyeballsEnabled(false);
+
 const server = createServer();
 
 server.on('connection', mustCall((socket) => {
diff --git a/test/parallel/test-http-server-headers-timeout-delayed-headers.js b/test/parallel/test-http-server-headers-timeout-delayed-headers.js
index af4a5df4b7f530..4d5e648ec42d46 100644
--- a/test/parallel/test-http-server-headers-timeout-delayed-headers.js
+++ b/test/parallel/test-http-server-headers-timeout-delayed-headers.js
@@ -9,6 +9,8 @@ const { connect } = require('net');
 // after server.headersTimeout if the client
 // pauses before start sending the request.
 
+common.setHappyEyeballsEnabled(false);
+
 let sendDelayedRequestHeaders;
 const headersTimeout = common.platformTimeout(2000);
 const server = createServer({
diff --git a/test/parallel/test-http-server-headers-timeout-interrupted-headers.js b/test/parallel/test-http-server-headers-timeout-interrupted-headers.js
index 9d25940ec65cd1..d77fa5129b4109 100644
--- a/test/parallel/test-http-server-headers-timeout-interrupted-headers.js
+++ b/test/parallel/test-http-server-headers-timeout-interrupted-headers.js
@@ -9,6 +9,8 @@ const { connect } = require('net');
 // after server.headersTimeout if the client
 // pauses sending in the middle of a header.
 
+common.setHappyEyeballsEnabled(false);
+
 let sendDelayedRequestHeaders;
 const headersTimeout = common.platformTimeout(2000);
 const server = createServer({
diff --git a/test/parallel/test-http-server-keepalive-end.js b/test/parallel/test-http-server-keepalive-end.js
index 9d1bc0bfc0d116..40ddc6de8540e6 100644
--- a/test/parallel/test-http-server-keepalive-end.js
+++ b/test/parallel/test-http-server-keepalive-end.js
@@ -8,6 +8,8 @@ const { connect } = require('net');
 // on the incoming request object, and that the parser instance does not hold
 // on to that request object afterwards.
 
+common.setHappyEyeballsEnabled(false);
+
 const server = createServer(common.mustCall((req, res) => {
   req.on('end', common.mustCall(() => {
     const parser = req.socket.parser;
diff --git a/test/parallel/test-http-server-request-timeout-delayed-headers.js b/test/parallel/test-http-server-request-timeout-delayed-headers.js
index 304a78b96a77d3..78072871a7fbfb 100644
--- a/test/parallel/test-http-server-request-timeout-delayed-headers.js
+++ b/test/parallel/test-http-server-request-timeout-delayed-headers.js
@@ -9,6 +9,8 @@ const { connect } = require('net');
 // after server.requestTimeout if the client
 // pauses before start sending the request.
 
+common.setHappyEyeballsEnabled(false);
+
 let sendDelayedRequestHeaders;
 const requestTimeout = common.platformTimeout(2000);
 const server = createServer({
diff --git a/test/parallel/test-http-server-request-timeout-interrupted-headers.js b/test/parallel/test-http-server-request-timeout-interrupted-headers.js
index eb9914dad1f56a..c1a383d6b27d73 100644
--- a/test/parallel/test-http-server-request-timeout-interrupted-headers.js
+++ b/test/parallel/test-http-server-request-timeout-interrupted-headers.js
@@ -9,6 +9,8 @@ const { connect } = require('net');
 // after server.requestTimeout if the client
 // pauses sending in the middle of a header.
 
+common.setHappyEyeballsEnabled(false);
+
 let sendDelayedRequestHeaders;
 const requestTimeout = common.platformTimeout(2000);
 const server = createServer({
diff --git a/test/parallel/test-http-server-request-timeout-upgrade.js b/test/parallel/test-http-server-request-timeout-upgrade.js
index ad4fbe5c5e9a03..ae003a289f14bd 100644
--- a/test/parallel/test-http-server-request-timeout-upgrade.js
+++ b/test/parallel/test-http-server-request-timeout-upgrade.js
@@ -7,6 +7,9 @@ const { connect } = require('net');
 
 // This test validates that the requestTimeoout
 // is disabled after the connection is upgraded.
+
+common.setHappyEyeballsEnabled(false);
+
 let sendDelayedRequestHeaders;
 const requestTimeout = common.platformTimeout(2000);
 const server = createServer({
diff --git a/test/parallel/test-http-should-keep-alive.js b/test/parallel/test-http-should-keep-alive.js
index 5cff29adbc54db..5526fa7b229c41 100644
--- a/test/parallel/test-http-should-keep-alive.js
+++ b/test/parallel/test-http-should-keep-alive.js
@@ -20,12 +20,14 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 const net = require('net');
 const Countdown = require('../common/countdown');
 
+common.setHappyEyeballsEnabled(false);
+
 const SERVER_RESPONSES = [
   'HTTP/1.0 200 ok\r\nContent-Length: 0\r\n\r\n',
   'HTTP/1.0 200 ok\r\nContent-Length: 0\r\nConnection: keep-alive\r\n\r\n',
diff --git a/test/parallel/test-http-socket-encoding-error.js b/test/parallel/test-http-socket-encoding-error.js
index 0ce984896d3aea..ec4fe3ef16dab8 100644
--- a/test/parallel/test-http-socket-encoding-error.js
+++ b/test/parallel/test-http-socket-encoding-error.js
@@ -4,6 +4,8 @@ const common = require('../common');
 const assert = require('assert');
 const http = require('http');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = http.createServer().listen(0, connectToServer);
 
 server.on('connection', common.mustCall((socket) => {
diff --git a/test/parallel/test-http-upgrade-binary.js b/test/parallel/test-http-upgrade-binary.js
index 002ac9c564ad1e..2fca4526b7aa0d 100644
--- a/test/parallel/test-http-upgrade-binary.js
+++ b/test/parallel/test-http-upgrade-binary.js
@@ -1,9 +1,11 @@
 'use strict';
-const { mustCall } = require('../common');
+const { mustCall, setHappyEyeballsEnabled } = require('../common');
 const assert = require('assert');
 const http = require('http');
 const net = require('net');
 
+setHappyEyeballsEnabled(false);
+
 // https://github.com/nodejs/node/issues/17789 - a connection upgrade response
 // that has a Transfer-Encoding header and a body whose first byte is > 127
 // triggers a bug where said byte is skipped over.
diff --git a/test/parallel/test-http-upgrade-server.js b/test/parallel/test-http-upgrade-server.js
index 5a660c4072a9a3..c88b2ab40e2c13 100644
--- a/test/parallel/test-http-upgrade-server.js
+++ b/test/parallel/test-http-upgrade-server.js
@@ -21,12 +21,13 @@
 
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 const net = require('net');
 const http = require('http');
 
+common.setHappyEyeballsEnabled(false);
 
 let requests_recv = 0;
 let requests_sent = 0;
diff --git a/test/parallel/test-http2-altsvc.js b/test/parallel/test-http2-altsvc.js
index c5abfc33265330..da1b6ae2f806ee 100644
--- a/test/parallel/test-http2-altsvc.js
+++ b/test/parallel/test-http2-altsvc.js
@@ -8,6 +8,8 @@ const assert = require('assert');
 const http2 = require('http2');
 const Countdown = require('../common/countdown');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = http2.createServer();
 server.on('stream', common.mustCall((stream) => {
   stream.session.altsvc('h2=":8000"', stream.id);
diff --git a/test/parallel/test-http2-autoselect-protocol.js b/test/parallel/test-http2-autoselect-protocol.js
index abd35d4ba75a38..05d054df8eb70e 100644
--- a/test/parallel/test-http2-autoselect-protocol.js
+++ b/test/parallel/test-http2-autoselect-protocol.js
@@ -11,6 +11,8 @@ const http2 = require('http2');
 // Example test for HTTP/1 vs HTTP/2 protocol autoselection.
 // Refs: https://github.com/nodejs/node/issues/34532
 
+common.setHappyEyeballsEnabled(false);
+
 const h1Server = http.createServer(common.mustCall((req, res) => {
   res.end('HTTP/1 Response');
 }));
diff --git a/test/parallel/test-http2-client-settings-before-connect.js b/test/parallel/test-http2-client-settings-before-connect.js
index d370b49ce050dd..83f95992c7974b 100644
--- a/test/parallel/test-http2-client-settings-before-connect.js
+++ b/test/parallel/test-http2-client-settings-before-connect.js
@@ -8,6 +8,8 @@ const h2 = require('http2');
 
 const server = h2.createServer();
 
+common.setHappyEyeballsEnabled(false);
+
 // We use the lower-level API here
 server.on('stream', common.mustCall((stream, headers, flags) => {
   stream.respond();
diff --git a/test/parallel/test-http2-client-shutdown-before-connect.js b/test/parallel/test-http2-client-shutdown-before-connect.js
index 7e6a1a55c1d40a..edda4bbc1319d4 100644
--- a/test/parallel/test-http2-client-shutdown-before-connect.js
+++ b/test/parallel/test-http2-client-shutdown-before-connect.js
@@ -5,6 +5,8 @@ if (!common.hasCrypto)
   common.skip('missing crypto');
 const h2 = require('http2');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = h2.createServer();
 
 // We use the lower-level API here
diff --git a/test/parallel/test-http2-connect-method-extended-cant-turn-off.js b/test/parallel/test-http2-connect-method-extended-cant-turn-off.js
index f4d033efe65707..155988322d372f 100644
--- a/test/parallel/test-http2-connect-method-extended-cant-turn-off.js
+++ b/test/parallel/test-http2-connect-method-extended-cant-turn-off.js
@@ -6,6 +6,8 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const http2 = require('http2');
 
+common.setHappyEyeballsEnabled(false);
+
 const settings = { enableConnectProtocol: true };
 const server = http2.createServer({ settings });
 server.on('stream', common.mustNotCall());
diff --git a/test/parallel/test-http2-connect-method.js b/test/parallel/test-http2-connect-method.js
index 4ada9f47553528..b621bc69ed34be 100644
--- a/test/parallel/test-http2-connect-method.js
+++ b/test/parallel/test-http2-connect-method.js
@@ -16,6 +16,8 @@ const {
   NGHTTP2_REFUSED_STREAM
 } = http2.constants;
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer(common.mustCall((socket) => {
   let data = '';
   socket.setEncoding('utf8');
diff --git a/test/parallel/test-http2-create-client-secure-session.js b/test/parallel/test-http2-create-client-secure-session.js
index 2f7678cc689825..0c30d93f3f6d8d 100644
--- a/test/parallel/test-http2-create-client-secure-session.js
+++ b/test/parallel/test-http2-create-client-secure-session.js
@@ -13,6 +13,8 @@ const h2 = require('http2');
 const { kSocket } = require('internal/http2/util');
 const tls = require('tls');
 
+common.setHappyEyeballsEnabled(false);
+
 function loadKey(keyname) {
   return fixtures.readKey(keyname, 'binary');
 }
diff --git a/test/parallel/test-http2-destroy-after-write.js b/test/parallel/test-http2-destroy-after-write.js
index 399df015b8879e..b65c5beb9044f1 100644
--- a/test/parallel/test-http2-destroy-after-write.js
+++ b/test/parallel/test-http2-destroy-after-write.js
@@ -7,6 +7,8 @@ if (!common.hasCrypto) {
 const http2 = require('http2');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = http2.createServer();
 
 server.on('session', common.mustCall(function(session) {
diff --git a/test/parallel/test-http2-empty-frame-without-eof.js b/test/parallel/test-http2-empty-frame-without-eof.js
index 2cd7d799769882..3bc9c7bc099e13 100644
--- a/test/parallel/test-http2-empty-frame-without-eof.js
+++ b/test/parallel/test-http2-empty-frame-without-eof.js
@@ -7,6 +7,8 @@ const net = require('net');
 const http2 = require('http2');
 const { once } = require('events');
 
+common.setHappyEyeballsEnabled(false);
+
 async function main() {
   const blobWithEmptyFrame = readSync('emptyframe.http2');
   const server = net.createServer((socket) => {
diff --git a/test/parallel/test-http2-invalidheaderfield.js b/test/parallel/test-http2-invalidheaderfield.js
index bc18f2ba42634a..04dc1a0c22d2b4 100644
--- a/test/parallel/test-http2-invalidheaderfield.js
+++ b/test/parallel/test-http2-invalidheaderfield.js
@@ -7,6 +7,8 @@ if (!common.hasCrypto) { common.skip('missing crypto'); }
 // Pseudo headers
 // Capitalized headers
 
+common.setHappyEyeballsEnabled(false);
+
 const http2 = require('http2');
 const { throws, strictEqual } = require('assert');
 
diff --git a/test/parallel/test-http2-invalidheaderfields-client.js b/test/parallel/test-http2-invalidheaderfields-client.js
index a5681970faab27..f63533c27a4e0f 100644
--- a/test/parallel/test-http2-invalidheaderfields-client.js
+++ b/test/parallel/test-http2-invalidheaderfields-client.js
@@ -4,6 +4,8 @@ if (!common.hasCrypto) { common.skip('missing crypto'); }
 const assert = require('assert');
 const http2 = require('http2');
 
+common.setHappyEyeballsEnabled(false);
+
 const server1 = http2.createServer();
 
 server1.listen(0, common.mustCall(() => {
diff --git a/test/parallel/test-http2-max-settings.js b/test/parallel/test-http2-max-settings.js
index 0ae792855ae3d5..abcd8014d37ebd 100644
--- a/test/parallel/test-http2-max-settings.js
+++ b/test/parallel/test-http2-max-settings.js
@@ -6,6 +6,8 @@ if (!common.hasCrypto)
 
 const http2 = require('http2');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = http2.createServer({ maxSettings: 1 });
 
 // TODO(@jasnell): There is still a session event
diff --git a/test/parallel/test-http2-misbehaving-multiplex.js b/test/parallel/test-http2-misbehaving-multiplex.js
index 0e057e1ed28e7a..fd837899766d88 100644
--- a/test/parallel/test-http2-misbehaving-multiplex.js
+++ b/test/parallel/test-http2-misbehaving-multiplex.js
@@ -11,6 +11,9 @@ const h2 = require('http2');
 const net = require('net');
 const { NghttpError } = require('internal/http2/util');
 const h2test = require('../common/http2');
+
+common.setHappyEyeballsEnabled(false);
+
 let client;
 
 const server = h2.createServer();
diff --git a/test/parallel/test-http2-onping.js b/test/parallel/test-http2-onping.js
index 134a94ddb8f582..c3bc9157912e1f 100644
--- a/test/parallel/test-http2-onping.js
+++ b/test/parallel/test-http2-onping.js
@@ -3,7 +3,8 @@
 const {
   hasCrypto,
   mustCall,
-  skip
+  skip,
+  setHappyEyeballsEnabled,
 } = require('../common');
 if (!hasCrypto)
   skip('missing crypto');
@@ -16,6 +17,8 @@ const {
   connect
 } = require('http2');
 
+setHappyEyeballsEnabled(false);
+
 const check = Buffer.from([ 1, 2, 3, 4, 5, 6, 7, 8 ]);
 
 const server = createServer();
diff --git a/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js b/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js
index df3aefff11e7ad..e7e24918ec0966 100644
--- a/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js
+++ b/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js
@@ -7,6 +7,8 @@ const h2 = require('http2');
 const assert = require('assert');
 const { ServerHttp2Session } = require('internal/http2/core');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = h2.createServer();
 
 server.on('stream', common.mustNotCall());
diff --git a/test/parallel/test-http2-origin.js b/test/parallel/test-http2-origin.js
index 5193af6d99ef7e..3e83ee1f5d7714 100644
--- a/test/parallel/test-http2-origin.js
+++ b/test/parallel/test-http2-origin.js
@@ -4,7 +4,8 @@ const {
   hasCrypto,
   mustCall,
   mustNotCall,
-  skip
+  skip,
+  setHappyEyeballsEnabled,
 } = require('../common');
 if (!hasCrypto)
   skip('missing crypto');
@@ -23,6 +24,8 @@ const Countdown = require('../common/countdown');
 
 const { readKey } = require('../common/fixtures');
 
+setHappyEyeballsEnabled(false);
+
 const key = readKey('agent8-key.pem', 'binary');
 const cert = readKey('agent8-cert.pem', 'binary');
 const ca = readKey('fake-startcom-root-cert.pem', 'binary');
diff --git a/test/parallel/test-http2-perf_hooks.js b/test/parallel/test-http2-perf_hooks.js
index 5be9073a56ad5c..adeb0dbdefb071 100644
--- a/test/parallel/test-http2-perf_hooks.js
+++ b/test/parallel/test-http2-perf_hooks.js
@@ -9,6 +9,8 @@ const h2 = require('http2');
 
 const { PerformanceObserver } = require('perf_hooks');
 
+common.setHappyEyeballsEnabled(false);
+
 const obs = new PerformanceObserver(common.mustCallAtLeast((items) => {
   const entry = items.getEntries()[0];
   assert.strictEqual(entry.entryType, 'http2');
diff --git a/test/parallel/test-http2-ping-settings-heapdump.js b/test/parallel/test-http2-ping-settings-heapdump.js
index 7d27310700c7a8..96daf19b781bc6 100644
--- a/test/parallel/test-http2-ping-settings-heapdump.js
+++ b/test/parallel/test-http2-ping-settings-heapdump.js
@@ -11,6 +11,8 @@ const v8 = require('v8');
 // after it is destroyed, either because they are detached from it or have been
 // destroyed themselves.
 
+common.setHappyEyeballsEnabled(false);
+
 for (const variant of ['ping', 'settings']) {
   const server = http2.createServer();
   server.on('session', common.mustCall((session) => {
diff --git a/test/parallel/test-http2-ping-unsolicited-ack.js b/test/parallel/test-http2-ping-unsolicited-ack.js
index 5a3a261cb098b1..42ee4ae946528b 100644
--- a/test/parallel/test-http2-ping-unsolicited-ack.js
+++ b/test/parallel/test-http2-ping-unsolicited-ack.js
@@ -10,6 +10,8 @@ const http2util = require('../common/http2');
 
 // Test that ping flooding causes the session to be torn down
 
+common.setHappyEyeballsEnabled(false);
+
 const kSettings = new http2util.SettingsFrame();
 const kPingAck = new http2util.PingFrame(true);
 
diff --git a/test/parallel/test-http2-priority-cycle-.js b/test/parallel/test-http2-priority-cycle-.js
index af0d66d8343cbf..0b72e0b01978d1 100644
--- a/test/parallel/test-http2-priority-cycle-.js
+++ b/test/parallel/test-http2-priority-cycle-.js
@@ -12,6 +12,8 @@ const largeBuffer = Buffer.alloc(1e4);
 
 // Verify that a dependency cycle may exist, but that it doesn't crash anything
 
+common.setHappyEyeballsEnabled(false);
+
 server.on('stream', common.mustCall((stream) => {
   stream.respond();
   setImmediate(() => {
diff --git a/test/parallel/test-http2-propagate-session-destroy-code.js b/test/parallel/test-http2-propagate-session-destroy-code.js
index c54e52e085af4b..ce3c93e9418cae 100644
--- a/test/parallel/test-http2-propagate-session-destroy-code.js
+++ b/test/parallel/test-http2-propagate-session-destroy-code.js
@@ -10,6 +10,8 @@ const server = http2.createServer();
 const errRegEx = /Session closed with error code 7/;
 const destroyCode = http2.constants.NGHTTP2_REFUSED_STREAM;
 
+common.setHappyEyeballsEnabled(false);
+
 server.on('error', common.mustNotCall());
 
 server.on('session', (session) => {
diff --git a/test/parallel/test-http2-server-close-callback.js b/test/parallel/test-http2-server-close-callback.js
index 5b0b8116a147fd..1519b245bcd67d 100644
--- a/test/parallel/test-http2-server-close-callback.js
+++ b/test/parallel/test-http2-server-close-callback.js
@@ -4,6 +4,8 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
+common.setHappyEyeballsEnabled(false);
+
 const Countdown = require('../common/countdown');
 const http2 = require('http2');
 
diff --git a/test/parallel/test-http2-server-http1-client.js b/test/parallel/test-http2-server-http1-client.js
index 40e97f04a4e888..6b3e02d28bacd0 100644
--- a/test/parallel/test-http2-server-http1-client.js
+++ b/test/parallel/test-http2-server-http1-client.js
@@ -10,6 +10,8 @@ const http = require('http');
 const http2 = require('http2');
 const { NghttpError } = require('internal/http2/util');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = http2.createServer();
 server.on('stream', common.mustNotCall());
 server.on('session', common.mustCall((session) => {
diff --git a/test/parallel/test-http2-server-push-disabled.js b/test/parallel/test-http2-server-push-disabled.js
index 306c916497263f..0b0cbe92cf5f81 100644
--- a/test/parallel/test-http2-server-push-disabled.js
+++ b/test/parallel/test-http2-server-push-disabled.js
@@ -8,6 +8,8 @@ const http2 = require('http2');
 
 const server = http2.createServer();
 
+common.setHappyEyeballsEnabled(false);
+
 server.on('session', common.mustCall((session) => {
   // Verify that the settings disabling push is received
   session.on('remoteSettings', common.mustCall((settings) => {
diff --git a/test/parallel/test-http2-server-sessionerror.js b/test/parallel/test-http2-server-sessionerror.js
index e266661b0cc2c3..7a2bb05bcbc901 100644
--- a/test/parallel/test-http2-server-sessionerror.js
+++ b/test/parallel/test-http2-server-sessionerror.js
@@ -10,6 +10,8 @@ const assert = require('assert');
 const { kSocket } = require('internal/http2/util');
 const { ServerHttp2Session } = require('internal/http2/core');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = http2.createServer();
 server.on('stream', common.mustNotCall());
 
diff --git a/test/parallel/test-http2-server-setLocalWindowSize.js b/test/parallel/test-http2-server-setLocalWindowSize.js
index 8fcb9b9d0d81b0..3787e8b768c271 100644
--- a/test/parallel/test-http2-server-setLocalWindowSize.js
+++ b/test/parallel/test-http2-server-setLocalWindowSize.js
@@ -7,6 +7,8 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const http2 = require('http2');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = http2.createServer();
 server.on('stream', common.mustCall((stream) => {
   stream.respond();
diff --git a/test/parallel/test-http2-server-startup.js b/test/parallel/test-http2-server-startup.js
index c94abd2c22eddb..3e79d4f24acb7c 100644
--- a/test/parallel/test-http2-server-startup.js
+++ b/test/parallel/test-http2-server-startup.js
@@ -15,6 +15,8 @@ const http2 = require('http2');
 const tls = require('tls');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: commonFixtures.readKey('agent2-key.pem'),
   cert: commonFixtures.readKey('agent2-cert.pem')
diff --git a/test/parallel/test-http2-session-unref.js b/test/parallel/test-http2-session-unref.js
index 8afd659d33baa8..3cbdf8b76eef92 100644
--- a/test/parallel/test-http2-session-unref.js
+++ b/test/parallel/test-http2-session-unref.js
@@ -10,6 +10,8 @@ const http2 = require('http2');
 const Countdown = require('../common/countdown');
 const makeDuplexPair = require('../common/duplexpair');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = http2.createServer();
 const { clientSide, serverSide } = makeDuplexPair();
 
diff --git a/test/parallel/test-http2-settings-unsolicited-ack.js b/test/parallel/test-http2-settings-unsolicited-ack.js
index fa63e9ee3f6425..5dc591449cd615 100644
--- a/test/parallel/test-http2-settings-unsolicited-ack.js
+++ b/test/parallel/test-http2-settings-unsolicited-ack.js
@@ -12,6 +12,8 @@ const Countdown = require('../common/countdown');
 
 // Test that an unsolicited settings ack is ignored.
 
+common.setHappyEyeballsEnabled(false);
+
 const kSettings = new http2util.SettingsFrame();
 const kSettingsAck = new http2util.SettingsFrame(true);
 
diff --git a/test/parallel/test-https-agent-session-reuse.js b/test/parallel/test-https-agent-session-reuse.js
index 485f4b1ca308c9..284384529dc6c7 100644
--- a/test/parallel/test-https-agent-session-reuse.js
+++ b/test/parallel/test-https-agent-session-reuse.js
@@ -9,6 +9,8 @@ const https = require('https');
 const crypto = require('crypto');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('agent1-key.pem'),
   cert: fixtures.readKey('agent1-cert.pem')
diff --git a/test/parallel/test-https-agent-unref-socket.js b/test/parallel/test-https-agent-unref-socket.js
index 49169b523e1042..7f1ac738db2011 100644
--- a/test/parallel/test-https-agent-unref-socket.js
+++ b/test/parallel/test-https-agent-unref-socket.js
@@ -7,6 +7,8 @@ if (!common.hasCrypto)
 const https = require('https');
 
 if (process.argv[2] === 'localhost') {
+  common.setHappyEyeballsEnabled(false);
+
   const request = https.get('https://localhost:' + process.argv[3]);
 
   request.on('socket', (socket) => {
diff --git a/test/parallel/test-https-client-resume.js b/test/parallel/test-https-client-resume.js
index 8904e24180b329..ff42cd32ba30a7 100644
--- a/test/parallel/test-https-client-resume.js
+++ b/test/parallel/test-https-client-resume.js
@@ -32,6 +32,8 @@ const https = require('https');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('agent2-key.pem'),
   cert: fixtures.readKey('agent2-cert.pem')
diff --git a/test/parallel/test-https-happy-eyeballs.js b/test/parallel/test-https-happy-eyeballs.js
new file mode 100644
index 00000000000000..62d965c9dbf28e
--- /dev/null
+++ b/test/parallel/test-https-happy-eyeballs.js
@@ -0,0 +1,139 @@
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+
+const { parseDNSPacket, writeDNSPacket } = require('../common/dns');
+const fixtures = require('../common/fixtures');
+
+const assert = require('assert');
+const dgram = require('dgram');
+const { Resolver } = require('dns');
+const { request, createServer } = require('https');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const options = {
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem')
+};
+
+// Test that happy eyeballs algorithm is properly implemented when using HTTP.
+function _lookup(resolver, hostname, options, cb) {
+  resolver.resolve(hostname, 'ANY', (err, replies) => {
+    assert.notStrictEqual(options.family, 4);
+
+    if (err) {
+      return cb(err);
+    }
+
+    const hosts = replies
+      .map((r) => ({ address: r.address, family: r.type === 'AAAA' ? 6 : 4 }))
+      .sort((a, b) => b.family - a.family);
+
+    if (options.all === true) {
+      return cb(null, hosts);
+    }
+
+    return cb(null, hosts[0].address, hosts[0].family);
+  });
+}
+
+function createDnsServer(ipv6Addr, ipv4Addr, cb) {
+  // Create a DNS server which replies with a AAAA and a A record for the same host
+  const socket = dgram.createSocket('udp4');
+
+  socket.on('message', common.mustCall((msg, { address, port }) => {
+    const parsed = parseDNSPacket(msg);
+    const domain = parsed.questions[0].domain;
+    assert.strictEqual(domain, 'example.org');
+
+    socket.send(writeDNSPacket({
+      id: parsed.id,
+      questions: parsed.questions,
+      answers: [
+        { type: 'AAAA', address: ipv6Addr, ttl: 123, domain: 'example.org' },
+        { type: 'A', address: ipv4Addr, ttl: 123, domain: 'example.org' },
+      ]
+    }), port, address);
+  }));
+
+  socket.bind(0, () => {
+    const resolver = new Resolver();
+    resolver.setServers([`127.0.0.1:${socket.address().port}`]);
+
+    cb({ dnsServer: socket, lookup: _lookup.bind(null, resolver) });
+  });
+}
+
+// Test that IPV4 is reached if IPV6 is not reachable
+{
+  createDnsServer('::1', '127.0.0.1', common.mustCall(function({ dnsServer, lookup }) {
+    const ipv4Server = createServer(options, common.mustCall((req, res) => {
+      res.writeHead(200, { Connection: 'close' });
+      res.end('response-ipv4');
+    }));
+
+    ipv4Server.listen(0, '0.0.0.0', common.mustCall(() => {
+      request(`https://example.org:${ipv4Server.address().port}/`, { lookup, rejectUnauthorized: false }, (res) => {
+        assert.strictEqual(res.statusCode, 200);
+        res.setEncoding('utf-8');
+
+        let response = '';
+
+        res.on('data', (chunk) => {
+          response += chunk;
+        });
+
+        res.on('end', common.mustCall(() => {
+          assert.strictEqual(response, 'response-ipv4');
+          ipv4Server.close();
+          dnsServer.close();
+        }));
+      }).end();
+    }));
+  }));
+}
+
+// Test that IPV4 is NOT reached if IPV6 is reachable
+{
+  createDnsServer('::1', '127.0.0.1', common.mustCall(function({ dnsServer, lookup }) {
+    const ipv4Server = createServer(options, common.mustNotCall((req, res) => {
+      res.writeHead(200, { Connection: 'close' });
+      res.end('response-ipv4');
+    }));
+
+    const ipv6Server = createServer(options, common.mustCall((req, res) => {
+      res.writeHead(200, { Connection: 'close' });
+      res.end('response-ipv6');
+    }));
+
+    ipv4Server.listen(0, '0.0.0.0', common.mustCall(() => {
+      const port = ipv4Server.address().port;
+
+      ipv6Server.listen(port, '::', common.mustCall(() => {
+        request(`https://example.org:${ipv4Server.address().port}/`, { lookup, rejectUnauthorized: false }, (res) => {
+          assert.strictEqual(res.statusCode, 200);
+          res.setEncoding('utf-8');
+
+          let response = '';
+
+          res.on('data', (chunk) => {
+            response += chunk;
+          });
+
+          res.on('end', common.mustCall(() => {
+            assert.strictEqual(response, 'response-ipv6');
+            ipv4Server.close();
+            ipv6Server.close();
+            dnsServer.close();
+          }));
+        }).end();
+      }));
+    }));
+  }));
+}
diff --git a/test/parallel/test-https-insecure-parse-per-stream.js b/test/parallel/test-https-insecure-parse-per-stream.js
index 645fbcf2637654..d42dde52ae5438 100644
--- a/test/parallel/test-https-insecure-parse-per-stream.js
+++ b/test/parallel/test-https-insecure-parse-per-stream.js
@@ -4,6 +4,8 @@ if (!common.hasCrypto) {
   common.skip('missing crypto');
 }
 
+common.setHappyEyeballsEnabled(false);
+
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const https = require('https');
diff --git a/test/parallel/test-https-max-header-size-per-stream.js b/test/parallel/test-https-max-header-size-per-stream.js
index f7117e16fb43f6..d4c5d98ab13786 100644
--- a/test/parallel/test-https-max-header-size-per-stream.js
+++ b/test/parallel/test-https-max-header-size-per-stream.js
@@ -5,6 +5,8 @@ if (!common.hasCrypto) {
   common.skip('missing crypto');
 }
 
+common.setHappyEyeballsEnabled(false);
+
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const https = require('https');
diff --git a/test/parallel/test-https-server-close-all.js b/test/parallel/test-https-server-close-all.js
index 1c9092ff5c9237..e34d5dc89ec35e 100644
--- a/test/parallel/test-https-server-close-all.js
+++ b/test/parallel/test-https-server-close-all.js
@@ -6,6 +6,8 @@ if (!common.hasCrypto) {
   common.skip('missing crypto');
 }
 
+common.setHappyEyeballsEnabled(false);
+
 const { createServer } = require('https');
 const { connect } = require('tls');
 
diff --git a/test/parallel/test-https-server-close-idle.js b/test/parallel/test-https-server-close-idle.js
index 7f093c47cd8609..a9595344c8356b 100644
--- a/test/parallel/test-https-server-close-idle.js
+++ b/test/parallel/test-https-server-close-idle.js
@@ -6,6 +6,8 @@ if (!common.hasCrypto) {
   common.skip('missing crypto');
 }
 
+common.setHappyEyeballsEnabled(false);
+
 const { createServer } = require('https');
 const { connect } = require('tls');
 
diff --git a/test/parallel/test-net-after-close.js b/test/parallel/test-net-after-close.js
index 413e8f75992de9..0be93b9c06bfbb 100644
--- a/test/parallel/test-net-after-close.js
+++ b/test/parallel/test-net-after-close.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer(common.mustCall((s) => {
   console.error('SERVER: got connection');
   s.end();
diff --git a/test/parallel/test-net-allow-half-open.js b/test/parallel/test-net-allow-half-open.js
index c7f829a986e447..4aaf0c9839c585 100644
--- a/test/parallel/test-net-allow-half-open.js
+++ b/test/parallel/test-net-allow-half-open.js
@@ -4,6 +4,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 {
   const server = net.createServer(common.mustCall((socket) => {
     socket.end(Buffer.alloc(1024));
diff --git a/test/parallel/test-net-buffersize.js b/test/parallel/test-net-buffersize.js
index 7225d70af318a0..a1a3467225f50e 100644
--- a/test/parallel/test-net-buffersize.js
+++ b/test/parallel/test-net-buffersize.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const iter = 10;
 
 const server = net.createServer(function(socket) {
diff --git a/test/parallel/test-net-bytes-read.js b/test/parallel/test-net-bytes-read.js
index d569d78403e1d5..d7dcf3a3846612 100644
--- a/test/parallel/test-net-bytes-read.js
+++ b/test/parallel/test-net-bytes-read.js
@@ -4,6 +4,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const big = Buffer.alloc(1024 * 1024);
 
 const handler = common.mustCall((socket) => {
diff --git a/test/parallel/test-net-bytes-written-large.js b/test/parallel/test-net-bytes-written-large.js
index 79a997ec5a38f1..228f710bce183d 100644
--- a/test/parallel/test-net-bytes-written-large.js
+++ b/test/parallel/test-net-bytes-written-large.js
@@ -9,6 +9,8 @@ const net = require('net');
 // data up for asynchronous writing.
 // Check that `bytesWritten` accounts for both parts of a write.
 
+common.setHappyEyeballsEnabled(false);
+
 const N = 10000000;
 {
   // Variant 1: Write a Buffer.
diff --git a/test/parallel/test-net-can-reset-timeout.js b/test/parallel/test-net-can-reset-timeout.js
index c72efb5f339c98..e31ea13ebbe4b3 100644
--- a/test/parallel/test-net-can-reset-timeout.js
+++ b/test/parallel/test-net-can-reset-timeout.js
@@ -24,6 +24,8 @@ const common = require('../common');
 
 // Ref: https://github.com/nodejs/node-v0.x-archive/issues/481
 
+common.setHappyEyeballsEnabled(false);
+
 const net = require('net');
 
 const server = net.createServer(common.mustCall(function(stream) {
diff --git a/test/parallel/test-net-connect-buffer.js b/test/parallel/test-net-connect-buffer.js
index 749eee519904f5..f8f8f3c0b49d13 100644
--- a/test/parallel/test-net-connect-buffer.js
+++ b/test/parallel/test-net-connect-buffer.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const tcp = net.Server(common.mustCall((s) => {
   tcp.close();
 
diff --git a/test/parallel/test-net-connect-buffer2.js b/test/parallel/test-net-connect-buffer2.js
index 933141bc872b5a..04c5f70ffa33b8 100644
--- a/test/parallel/test-net-connect-buffer2.js
+++ b/test/parallel/test-net-connect-buffer2.js
@@ -3,6 +3,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const tcp = net.Server(common.mustCall((s) => {
   tcp.close();
 
diff --git a/test/parallel/test-net-connect-keepalive.js b/test/parallel/test-net-connect-keepalive.js
index 3e439c647c36be..c2e200fc9c3b6c 100644
--- a/test/parallel/test-net-connect-keepalive.js
+++ b/test/parallel/test-net-connect-keepalive.js
@@ -4,6 +4,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const truthyValues = [true, 1, 'true', {}, []];
 const delays = [[123, 0], [456123, 456], [-123000, 0], [undefined, 0]];
 const falseyValues = [false, 0, ''];
diff --git a/test/parallel/test-net-connect-memleak.js b/test/parallel/test-net-connect-memleak.js
index 2f06e56e1f631e..20d7195500d464 100644
--- a/test/parallel/test-net-connect-memleak.js
+++ b/test/parallel/test-net-connect-memleak.js
@@ -30,6 +30,8 @@ const net = require('net');
 // Test that the implicit listener for an 'connect' event on net.Sockets is
 // added using `once()`, i.e. can be gc'ed once that event has occurred.
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer(common.mustCall()).listen(0);
 
 let collected = false;
diff --git a/test/parallel/test-net-connect-nodelay.js b/test/parallel/test-net-connect-nodelay.js
index 6810e339e2b6c4..342f56ef3f1bf1 100644
--- a/test/parallel/test-net-connect-nodelay.js
+++ b/test/parallel/test-net-connect-nodelay.js
@@ -4,6 +4,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const truthyValues = [true, 1, 'true', {}, []];
 const falseyValues = [false, 0, ''];
 const genSetNoDelay = (desiredArg) => (enable) => {
diff --git a/test/parallel/test-net-connect-reset-after-destroy.js b/test/parallel/test-net-connect-reset-after-destroy.js
index 89e459229ab1bd..ad0d694320a72d 100644
--- a/test/parallel/test-net-connect-reset-after-destroy.js
+++ b/test/parallel/test-net-connect-reset-after-destroy.js
@@ -3,6 +3,8 @@ const common = require('../common');
 const net = require('net');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer();
 server.listen(0, common.mustCall(function() {
   const port = server.address().port;
diff --git a/test/parallel/test-net-dns-custom-lookup.js b/test/parallel/test-net-dns-custom-lookup.js
index a7c05c82b95419..4900e03104a7ef 100644
--- a/test/parallel/test-net-dns-custom-lookup.js
+++ b/test/parallel/test-net-dns-custom-lookup.js
@@ -3,6 +3,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 function check(addressType, cb) {
   const server = net.createServer(function(client) {
     client.end();
diff --git a/test/parallel/test-net-dns-error.js b/test/parallel/test-net-dns-error.js
index 7232ef10ebb455..d8b6d53e83bcc4 100644
--- a/test/parallel/test-net-dns-error.js
+++ b/test/parallel/test-net-dns-error.js
@@ -25,6 +25,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const host = '*'.repeat(64);
 // Resolving hostname > 63 characters may return EAI_FAIL (permanent failure).
 const errCodes = ['ENOTFOUND', 'EAI_FAIL'];
diff --git a/test/parallel/test-net-dns-lookup.js b/test/parallel/test-net-dns-lookup.js
index 8c7bbef128d7b1..9e266144ecf4b6 100644
--- a/test/parallel/test-net-dns-lookup.js
+++ b/test/parallel/test-net-dns-lookup.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer(function(client) {
   client.end();
   server.close();
diff --git a/test/parallel/test-net-end-destroyed.js b/test/parallel/test-net-end-destroyed.js
index 1670c1b92b21fb..3f2453db79b578 100644
--- a/test/parallel/test-net-end-destroyed.js
+++ b/test/parallel/test-net-end-destroyed.js
@@ -4,6 +4,8 @@ const common = require('../common');
 const net = require('net');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer();
 
 server.on('connection', common.mustCall());
diff --git a/test/parallel/test-net-error-twice.js b/test/parallel/test-net-error-twice.js
index b26b825d16c15f..28318a29348f90 100644
--- a/test/parallel/test-net-error-twice.js
+++ b/test/parallel/test-net-error-twice.js
@@ -20,10 +20,12 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const buf = Buffer.alloc(10 * 1024 * 1024, 0x62);
 
 const errs = [];
diff --git a/test/parallel/test-net-happy-eyeballs.js b/test/parallel/test-net-happy-eyeballs.js
new file mode 100644
index 00000000000000..facaca5ec3e813
--- /dev/null
+++ b/test/parallel/test-net-happy-eyeballs.js
@@ -0,0 +1,194 @@
+'use strict';
+
+const common = require('../common');
+const { parseDNSPacket, writeDNSPacket } = require('../common/dns');
+
+const assert = require('assert');
+const dgram = require('dgram');
+const { Resolver } = require('dns');
+const { createConnection, createServer } = require('net');
+
+// Test that happy eyeballs algorithm is properly implemented.
+
+function _lookup(resolver, hostname, options, cb) {
+  resolver.resolve(hostname, 'ANY', (err, replies) => {
+    assert.notStrictEqual(options.family, 4);
+
+    if (err) {
+      return cb(err);
+    }
+
+    const hosts = replies
+      .map((r) => ({ address: r.address, family: r.type === 'AAAA' ? 6 : 4 }))
+      .sort((a, b) => b.family - a.family);
+
+    if (options.all === true) {
+      return cb(null, hosts);
+    }
+
+    return cb(null, hosts[0].address, hosts[0].family);
+  });
+}
+
+function createDnsServer(ipv6Addr, ipv4Addr, cb) {
+  // Create a DNS server which replies with a AAAA and a A record for the same host
+  const socket = dgram.createSocket('udp4');
+
+  socket.on('message', common.mustCall((msg, { address, port }) => {
+    const parsed = parseDNSPacket(msg);
+    const domain = parsed.questions[0].domain;
+    assert.strictEqual(domain, 'example.org');
+
+    socket.send(writeDNSPacket({
+      id: parsed.id,
+      questions: parsed.questions,
+      answers: [
+        { type: 'AAAA', address: ipv6Addr, ttl: 123, domain: 'example.org' },
+        { type: 'A', address: ipv4Addr, ttl: 123, domain: 'example.org' },
+      ]
+    }), port, address);
+  }));
+
+  socket.bind(0, () => {
+    const resolver = new Resolver();
+    resolver.setServers([`127.0.0.1:${socket.address().port}`]);
+
+    cb({ dnsServer: socket, lookup: _lookup.bind(null, resolver) });
+  });
+}
+
+// Test that IPV4 is reached if IPV6 is not reachable
+{
+  createDnsServer('::1', '127.0.0.1', common.mustCall(function({ dnsServer, lookup }) {
+    const ipv4Server = createServer((socket) => {
+      socket.on('data', common.mustCall(() => {
+        socket.write('response-ipv4');
+        socket.end();
+      }));
+    });
+
+    ipv4Server.listen(0, '0.0.0.0', common.mustCall(() => {
+      const connection = createConnection({
+        host: 'example.org',
+        port: ipv4Server.address().port,
+        lookup: lookup
+      });
+
+      let response = '';
+      connection.setEncoding('utf-8');
+
+      connection.on('data', (chunk) => {
+        response += chunk;
+      });
+
+      connection.on('end', common.mustCall(() => {
+        assert.strictEqual(response, 'response-ipv4');
+        ipv4Server.close();
+        dnsServer.close();
+      }));
+
+      connection.write('request');
+    }));
+  }));
+}
+
+// Test that IPV4 is NOT reached if IPV6 is reachable
+{
+  createDnsServer('::1', '127.0.0.1', common.mustCall(function({ dnsServer, lookup }) {
+    const ipv4Server = createServer((socket) => {
+      socket.on('data', common.mustNotCall(() => {
+        socket.write('response-ipv4');
+        socket.end();
+      }));
+    });
+
+    const ipv6Server = createServer((socket) => {
+      socket.on('data', common.mustCall(() => {
+        socket.write('response-ipv6');
+        socket.end();
+      }));
+    });
+
+    ipv4Server.listen(0, '0.0.0.0', common.mustCall(() => {
+      const port = ipv4Server.address().port;
+
+      ipv6Server.listen(port, '::', common.mustCall(() => {
+        const connection = createConnection({
+          host: 'example.org',
+          port,
+          lookup: lookup
+        });
+
+        let response = '';
+        connection.setEncoding('utf-8');
+
+        connection.on('data', (chunk) => {
+          response += chunk;
+        });
+
+        connection.on('end', common.mustCall(() => {
+          assert.strictEqual(response, 'response-ipv6');
+          ipv4Server.close();
+          ipv6Server.close();
+          dnsServer.close();
+        }));
+
+        connection.write('request');
+      }));
+    }));
+  }));
+}
+
+// Test that when all errors are returned when no connections succeeded
+{
+  createDnsServer('::1', '127.0.0.1', common.mustCall(function({ dnsServer, lookup }) {
+    const connection = createConnection({
+      host: 'example.org',
+      port: 10,
+      lookup: lookup
+    });
+
+    connection.on('ready', common.mustNotCall());
+    connection.on('error', common.mustCall((error) => {
+      assert.strictEqual(error.constructor.name, 'AggregateError');
+      assert.strictEqual(error.errors.length, 2);
+
+      const errors = error.errors.map((e) => e.message);
+      assert.ok(errors.includes('connect ECONNREFUSED 127.0.0.1:10'));
+      assert.ok(errors.includes('connect ECONNREFUSED ::1:10'));
+
+      dnsServer.close();
+    }));
+  }));
+}
+
+// Test that the option can be disabled
+{
+  createDnsServer('::1', '127.0.0.1', common.mustCall(function({ dnsServer, lookup }) {
+    const ipv4Server = createServer((socket) => {
+      socket.on('data', common.mustCall(() => {
+        socket.write('response-ipv4');
+        socket.end();
+      }));
+    });
+
+    ipv4Server.listen(0, '0.0.0.0', common.mustCall(() => {
+      const port = ipv4Server.address().port;
+
+      const connection = createConnection({
+        host: 'example.org',
+        port,
+        lookup: lookup,
+        autoDetectFamily: false
+      });
+
+      connection.on('ready', common.mustNotCall());
+      connection.on('error', common.mustCall((error) => {
+        assert.strictEqual(error.code, 'ECONNREFUSED');
+        assert.strictEqual(error.message, `connect ECONNREFUSED ::1:${port}`);
+        ipv4Server.close();
+        dnsServer.close();
+      }));
+    }));
+  }));
+}
diff --git a/test/parallel/test-net-keepalive.js b/test/parallel/test-net-keepalive.js
index d91ec625f88246..c300a1c7229f19 100644
--- a/test/parallel/test-net-keepalive.js
+++ b/test/parallel/test-net-keepalive.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 let serverConnection;
 let clientConnection;
 const echoServer = net.createServer(function(connection) {
diff --git a/test/parallel/test-net-large-string.js b/test/parallel/test-net-large-string.js
index 93c0d41612a115..8e08c828ab6f05 100644
--- a/test/parallel/test-net-large-string.js
+++ b/test/parallel/test-net-large-string.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const kPoolSize = 40 * 1024;
 const data = 'あ'.repeat(kPoolSize);
 const encoding = 'UTF-8';
diff --git a/test/parallel/test-net-listen-after-destroying-stdin.js b/test/parallel/test-net-listen-after-destroying-stdin.js
index 4ffec304bec008..b9dededd4f0ba1 100644
--- a/test/parallel/test-net-listen-after-destroying-stdin.js
+++ b/test/parallel/test-net-listen-after-destroying-stdin.js
@@ -6,6 +6,8 @@
 const common = require('../common');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 process.stdin.destroy();
 
 const server = net.createServer(common.mustCall((socket) => {
diff --git a/test/parallel/test-net-normalize-args.js b/test/parallel/test-net-normalize-args.js
index 65d569d5d5fd12..cc6e6de44cd5db 100644
--- a/test/parallel/test-net-normalize-args.js
+++ b/test/parallel/test-net-normalize-args.js
@@ -5,6 +5,8 @@ const assert = require('assert');
 const net = require('net');
 const { normalizedArgsSymbol } = require('internal/net');
 
+common.setHappyEyeballsEnabled(false);
+
 function validateNormalizedArgs(input, output) {
   const args = net._normalizeArgs(input);
 
diff --git a/test/parallel/test-net-onread-static-buffer.js b/test/parallel/test-net-onread-static-buffer.js
index ce722f69cd7fa3..ff0d92f994266b 100644
--- a/test/parallel/test-net-onread-static-buffer.js
+++ b/test/parallel/test-net-onread-static-buffer.js
@@ -3,6 +3,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const message = Buffer.from('hello world');
 
 // Test typical usage
diff --git a/test/parallel/test-net-options-lookup.js b/test/parallel/test-net-options-lookup.js
index 0341a9f8d546b5..7f6937f61475c0 100644
--- a/test/parallel/test-net-options-lookup.js
+++ b/test/parallel/test-net-options-lookup.js
@@ -3,6 +3,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 ['foobar', 1, {}, []].forEach((input) => connectThrows(input));
 
 // Using port 0 as lookup is emitted before connecting.
diff --git a/test/parallel/test-net-pause-resume-connecting.js b/test/parallel/test-net-pause-resume-connecting.js
index 920522b7604556..c54ee2d0d331ba 100644
--- a/test/parallel/test-net-pause-resume-connecting.js
+++ b/test/parallel/test-net-pause-resume-connecting.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 let connections = 0;
 let dataEvents = 0;
 let conn;
diff --git a/test/parallel/test-net-perf_hooks.js b/test/parallel/test-net-perf_hooks.js
index 6b0d13aab27019..7e07d4c61184f3 100644
--- a/test/parallel/test-net-perf_hooks.js
+++ b/test/parallel/test-net-perf_hooks.js
@@ -5,6 +5,8 @@ const tmpdir = require('../common/tmpdir');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 tmpdir.refresh();
 
 const { PerformanceObserver } = require('perf_hooks');
diff --git a/test/parallel/test-net-persistent-keepalive.js b/test/parallel/test-net-persistent-keepalive.js
index b25162996e1bd0..8170331ae6ec10 100644
--- a/test/parallel/test-net-persistent-keepalive.js
+++ b/test/parallel/test-net-persistent-keepalive.js
@@ -1,8 +1,10 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 let serverConnection;
 let clientConnection;
 const echoServer = net.createServer(function(connection) {
diff --git a/test/parallel/test-net-pingpong.js b/test/parallel/test-net-pingpong.js
index 3bbe076b4b1658..1feff5c36a6454 100644
--- a/test/parallel/test-net-pingpong.js
+++ b/test/parallel/test-net-pingpong.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 function pingPongTest(port, host) {
   const N = 1000;
   let count = 0;
diff --git a/test/parallel/test-net-reconnect.js b/test/parallel/test-net-reconnect.js
index 233f5b01e5445a..f3281dc201aed0 100644
--- a/test/parallel/test-net-reconnect.js
+++ b/test/parallel/test-net-reconnect.js
@@ -20,9 +20,11 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const net = require('net');
 
 const N = 50;
diff --git a/test/parallel/test-net-remote-address-port.js b/test/parallel/test-net-remote-address-port.js
index 615f22979c2ff9..996e418ffa8fb4 100644
--- a/test/parallel/test-net-remote-address-port.js
+++ b/test/parallel/test-net-remote-address-port.js
@@ -25,6 +25,8 @@ const assert = require('assert');
 
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 let conns_closed = 0;
 
 const remoteAddrCandidates = [ common.localhostIPv4,
diff --git a/test/parallel/test-net-server-capture-rejection.js b/test/parallel/test-net-server-capture-rejection.js
index b1564ec26874af..43edeec87d37e7 100644
--- a/test/parallel/test-net-server-capture-rejection.js
+++ b/test/parallel/test-net-server-capture-rejection.js
@@ -5,6 +5,8 @@ const assert = require('assert');
 const events = require('events');
 const { createServer, connect } = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 events.captureRejections = true;
 
 const server = createServer(common.mustCall(async (sock) => {
diff --git a/test/parallel/test-net-server-close.js b/test/parallel/test-net-server-close.js
index 8291f70432ec97..f35272ee0ea8ff 100644
--- a/test/parallel/test-net-server-close.js
+++ b/test/parallel/test-net-server-close.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const sockets = [];
 
 const server = net.createServer(function(c) {
diff --git a/test/parallel/test-net-server-drop-connections.js b/test/parallel/test-net-server-drop-connections.js
index 4c495bdfb9e981..abfb47ebdfd6dc 100644
--- a/test/parallel/test-net-server-drop-connections.js
+++ b/test/parallel/test-net-server-drop-connections.js
@@ -3,6 +3,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 let firstSocket;
 const server = net.createServer(common.mustCall((socket) => {
   firstSocket = socket;
diff --git a/test/parallel/test-net-server-keepalive.js b/test/parallel/test-net-server-keepalive.js
index 6f3db6468f6696..5495524b746652 100644
--- a/test/parallel/test-net-server-keepalive.js
+++ b/test/parallel/test-net-server-keepalive.js
@@ -3,6 +3,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer({
   keepAlive: true,
   keepAliveInitialDelay: 1000
diff --git a/test/parallel/test-net-server-max-connections.js b/test/parallel/test-net-server-max-connections.js
index ea9a8d29e9f1ed..e97796e1a4fc15 100644
--- a/test/parallel/test-net-server-max-connections.js
+++ b/test/parallel/test-net-server-max-connections.js
@@ -29,6 +29,8 @@ const net = require('net');
 // maxConnections property to 10. The first 10 connections make it through
 // and the last 10 connections are rejected.
 
+common.setHappyEyeballsEnabled(false);
+
 const N = 20;
 let closes = 0;
 const waits = [];
diff --git a/test/parallel/test-net-server-nodelay.js b/test/parallel/test-net-server-nodelay.js
index a7f11475abe2d7..179c7310f09f63 100644
--- a/test/parallel/test-net-server-nodelay.js
+++ b/test/parallel/test-net-server-nodelay.js
@@ -3,6 +3,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer({
   noDelay: true
 }, common.mustCall((socket) => {
diff --git a/test/parallel/test-net-server-pause-on-connect.js b/test/parallel/test-net-server-pause-on-connect.js
index 59c39e8816cc5c..242ccfccd61d9d 100644
--- a/test/parallel/test-net-server-pause-on-connect.js
+++ b/test/parallel/test-net-server-pause-on-connect.js
@@ -24,10 +24,11 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 const msg = 'test';
-let stopped = true;
-let server1Sock;
 
+common.setHappyEyeballsEnabled(false);
 
+let stopped = true;
+let server1Sock;
 const server1ConnHandler = (socket) => {
   socket.on('data', function(data) {
     if (stopped) {
diff --git a/test/parallel/test-net-server-reset.js b/test/parallel/test-net-server-reset.js
index ea78cd2743298e..8bf95af70790aa 100644
--- a/test/parallel/test-net-server-reset.js
+++ b/test/parallel/test-net-server-reset.js
@@ -3,6 +3,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const sockets = [];
 
 const server = net.createServer(function(c) {
diff --git a/test/parallel/test-net-settimeout.js b/test/parallel/test-net-settimeout.js
index 581e27ec327d62..60e3a92f52a565 100644
--- a/test/parallel/test-net-settimeout.js
+++ b/test/parallel/test-net-settimeout.js
@@ -27,6 +27,8 @@ const common = require('../common');
 const net = require('net');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const T = 100;
 
 const server = net.createServer(common.mustCall((c) => {
diff --git a/test/parallel/test-net-socket-close-after-end.js b/test/parallel/test-net-socket-close-after-end.js
index 06bf55f89d6e50..24ea3da18a7a1d 100644
--- a/test/parallel/test-net-socket-close-after-end.js
+++ b/test/parallel/test-net-socket-close-after-end.js
@@ -4,6 +4,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer();
 
 server.on('connection', (socket) => {
diff --git a/test/parallel/test-net-socket-constructor.js b/test/parallel/test-net-socket-constructor.js
index 47010aa3b3e0e6..cd645bd70c16db 100644
--- a/test/parallel/test-net-socket-constructor.js
+++ b/test/parallel/test-net-socket-constructor.js
@@ -27,6 +27,8 @@ function test(sock, readable, writable) {
 }
 
 if (cluster.isPrimary) {
+  common.setHappyEyeballsEnabled(false);
+
   test(undefined, true, true);
 
   const server = net.createServer(common.mustCall((socket) => {
diff --git a/test/parallel/test-net-socket-reset-send.js b/test/parallel/test-net-socket-reset-send.js
index b7b9f66cb93d60..ceac2dbbffbfb4 100644
--- a/test/parallel/test-net-socket-reset-send.js
+++ b/test/parallel/test-net-socket-reset-send.js
@@ -4,6 +4,8 @@ const common = require('../common');
 const net = require('net');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer();
 server.listen(0, common.mustCall(() => {
   const port = server.address().port;
diff --git a/test/parallel/test-net-socket-timeout-unref.js b/test/parallel/test-net-socket-timeout-unref.js
index ae6bde49ab60cd..1a02d106bce0b4 100644
--- a/test/parallel/test-net-socket-timeout-unref.js
+++ b/test/parallel/test-net-socket-timeout-unref.js
@@ -26,6 +26,8 @@
 const common = require('../common');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer(function(c) {
   c.write('hello');
   c.unref();
diff --git a/test/parallel/test-net-write-after-close.js b/test/parallel/test-net-write-after-close.js
index 2647e3d0d97095..70bf73b8f768de 100644
--- a/test/parallel/test-net-write-after-close.js
+++ b/test/parallel/test-net-write-after-close.js
@@ -25,6 +25,8 @@ const assert = require('assert');
 
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 let serverSocket;
 
 const server = net.createServer(common.mustCall(function(socket) {
diff --git a/test/parallel/test-net-write-after-end-nt.js b/test/parallel/test-net-write-after-end-nt.js
index 99edc1d72beb95..a42ae225c08cd1 100644
--- a/test/parallel/test-net-write-after-end-nt.js
+++ b/test/parallel/test-net-write-after-end-nt.js
@@ -4,6 +4,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const { expectsError, mustCall } = common;
 
 // This test ensures those errors caused by calling `net.Socket.write()`
diff --git a/test/parallel/test-net-write-fully-async-buffer.js b/test/parallel/test-net-write-fully-async-buffer.js
index 0dddb51bd76ade..4c8c56428466b6 100644
--- a/test/parallel/test-net-write-fully-async-buffer.js
+++ b/test/parallel/test-net-write-fully-async-buffer.js
@@ -7,6 +7,8 @@
 const common = require('../common');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const data = Buffer.alloc(1000000);
 
 const server = net.createServer(common.mustCall(function(conn) {
diff --git a/test/parallel/test-net-write-fully-async-hex-string.js b/test/parallel/test-net-write-fully-async-hex-string.js
index 37b5cd75c1385c..e6035c1f1d3d35 100644
--- a/test/parallel/test-net-write-fully-async-hex-string.js
+++ b/test/parallel/test-net-write-fully-async-hex-string.js
@@ -5,6 +5,8 @@
 const common = require('../common');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const data = Buffer.alloc(1000000).toString('hex');
 
 const server = net.createServer(common.mustCall(function(conn) {
diff --git a/test/parallel/test-net-write-slow.js b/test/parallel/test-net-write-slow.js
index cf2d5790d93174..b657ce4d4e4802 100644
--- a/test/parallel/test-net-write-slow.js
+++ b/test/parallel/test-net-write-slow.js
@@ -24,6 +24,8 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const SIZE = 2E5;
 const N = 10;
 let flushed = 0;
diff --git a/test/parallel/test-process-getactivehandles.js b/test/parallel/test-process-getactivehandles.js
index 2db3da3c563e6e..4e6a82caa0a726 100644
--- a/test/parallel/test-process-getactivehandles.js
+++ b/test/parallel/test-process-getactivehandles.js
@@ -1,8 +1,11 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const net = require('net');
+
+common.setHappyEyeballsEnabled(false);
+
 const NUM = 8;
 const connections = [];
 const clients = [];
diff --git a/test/parallel/test-process-getactiveresources-track-active-handles.js b/test/parallel/test-process-getactiveresources-track-active-handles.js
index 25a40bc64a102c..b8c7be86876a1d 100644
--- a/test/parallel/test-process-getactiveresources-track-active-handles.js
+++ b/test/parallel/test-process-getactiveresources-track-active-handles.js
@@ -1,8 +1,11 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const net = require('net');
+
+common.setHappyEyeballsEnabled(false);
+
 const NUM = 8;
 const connections = [];
 const clients = [];
diff --git a/test/parallel/test-repl.js b/test/parallel/test-repl.js
index 3eb5d255927421..e44866fc7eb77f 100644
--- a/test/parallel/test-repl.js
+++ b/test/parallel/test-repl.js
@@ -28,6 +28,8 @@ const net = require('net');
 const repl = require('repl');
 const { inspect } = require('util');
 
+common.setHappyEyeballsEnabled(false);
+
 const message = 'Read, Eval, Print Loop';
 const prompt_unix = 'node via Unix socket> ';
 const prompt_tcp = 'node via TCP socket> ';
diff --git a/test/parallel/test-socket-write-after-fin-error.js b/test/parallel/test-socket-write-after-fin-error.js
index 64c8143abebbd9..79d71fb6743661 100644
--- a/test/parallel/test-socket-write-after-fin-error.js
+++ b/test/parallel/test-socket-write-after-fin-error.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 // This is similar to simple/test-socket-write-after-fin, except that
@@ -7,6 +7,8 @@ const assert = require('assert');
 // a FIN, and this is an error.  However, the standard "write after end"
 // message is too vague, and doesn't actually tell you what happens.
 
+common.setHappyEyeballsEnabled(false);
+
 const net = require('net');
 let serverData = '';
 let gotServerEnd = false;
diff --git a/test/parallel/test-socket-write-after-fin.js b/test/parallel/test-socket-write-after-fin.js
index 2551d3f54f651f..6d57f8565100c8 100644
--- a/test/parallel/test-socket-write-after-fin.js
+++ b/test/parallel/test-socket-write-after-fin.js
@@ -2,6 +2,9 @@
 const common = require('../common');
 const assert = require('assert');
 const net = require('net');
+
+common.setHappyEyeballsEnabled(false);
+
 const expected = 'hello1hello2hello3\nbye';
 
 const server = net.createServer({
diff --git a/test/parallel/test-stream-pipeline.js b/test/parallel/test-stream-pipeline.js
index 529b18386e25a6..af020a64bad4b1 100644
--- a/test/parallel/test-stream-pipeline.js
+++ b/test/parallel/test-stream-pipeline.js
@@ -18,6 +18,8 @@ const { promisify } = require('util');
 const net = require('net');
 const tsp = require('timers/promises');
 
+common.setHappyEyeballsEnabled(false);
+
 {
   let finished = false;
   const processed = [];
diff --git a/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js b/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js
index 01d2367bdb5717..77678bef13193a 100644
--- a/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js
+++ b/test/parallel/test-timers-socket-timeout-removes-other-socket-unref-timer.js
@@ -6,6 +6,8 @@ const common = require('../common');
 const net = require('net');
 const Countdown = require('../common/countdown');
 
+common.setHappyEyeballsEnabled(false);
+
 const clients = [];
 
 const server = net.createServer(function onClient(client) {
diff --git a/test/parallel/test-tls-addca.js b/test/parallel/test-tls-addca.js
index 5ca44f7a26e7db..4ed0a8922cc588 100644
--- a/test/parallel/test-tls-addca.js
+++ b/test/parallel/test-tls-addca.js
@@ -6,6 +6,8 @@ const fixtures = require('../common/fixtures');
 // contextWithoutCert. This is tested by trying to connect to a server that
 // depends on that CA using contextWithoutCert.
 
+common.setHappyEyeballsEnabled(false);
+
 const {
   assert, connect, keys, tls
 } = require(fixtures.path('tls-connect'));
diff --git a/test/parallel/test-tls-alert-handling.js b/test/parallel/test-tls-alert-handling.js
index bd86149bc5ac22..a6202d9fb8add4 100644
--- a/test/parallel/test-tls-alert-handling.js
+++ b/test/parallel/test-tls-alert-handling.js
@@ -12,6 +12,8 @@ const net = require('net');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 let clientClosed = false;
 let errorReceived = false;
 function canCloseServer() {
diff --git a/test/parallel/test-tls-ca-concat.js b/test/parallel/test-tls-ca-concat.js
index 38a6a4dfec378f..80c30e16abe42e 100644
--- a/test/parallel/test-tls-ca-concat.js
+++ b/test/parallel/test-tls-ca-concat.js
@@ -5,6 +5,8 @@ const fixtures = require('../common/fixtures');
 // Check ca option can contain concatenated certs by prepending an unrelated
 // non-CA cert and showing that agent6's CA root is still found.
 
+common.setHappyEyeballsEnabled(false);
+
 const {
   connect, keys
 } = require(fixtures.path('tls-connect'));
diff --git a/test/parallel/test-tls-cert-chains-concat.js b/test/parallel/test-tls-cert-chains-concat.js
index c186f0f6c4e4b1..9c7894d0f7015c 100644
--- a/test/parallel/test-tls-cert-chains-concat.js
+++ b/test/parallel/test-tls-cert-chains-concat.js
@@ -5,6 +5,8 @@ const fixtures = require('../common/fixtures');
 // Check cert chain is received by client, and is completed with the ca cert
 // known to the client.
 
+common.setHappyEyeballsEnabled(false);
+
 const {
   assert, connect, debug, keys
 } = require(fixtures.path('tls-connect'));
diff --git a/test/parallel/test-tls-cert-chains-in-ca.js b/test/parallel/test-tls-cert-chains-in-ca.js
index 0e834cc9bd11a2..dde92e3bbb7c69 100644
--- a/test/parallel/test-tls-cert-chains-in-ca.js
+++ b/test/parallel/test-tls-cert-chains-in-ca.js
@@ -1,7 +1,9 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 // Check cert chain is received by client, and is completed with the ca cert
 // known to the client.
 
diff --git a/test/parallel/test-tls-client-abort2.js b/test/parallel/test-tls-client-abort2.js
index b253e6696c6b5c..3e29d7e6b22f53 100644
--- a/test/parallel/test-tls-client-abort2.js
+++ b/test/parallel/test-tls-client-abort2.js
@@ -24,6 +24,8 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
+common.setHappyEyeballsEnabled(false);
+
 const tls = require('tls');
 
 const conn = tls.connect(0, common.mustNotCall());
diff --git a/test/parallel/test-tls-client-auth.js b/test/parallel/test-tls-client-auth.js
index 476238961986cd..0ae9605ec2ca75 100644
--- a/test/parallel/test-tls-client-auth.js
+++ b/test/parallel/test-tls-client-auth.js
@@ -7,6 +7,8 @@ const {
   assert, connect, keys, tls
 } = require(fixtures.path('tls-connect'));
 
+common.setHappyEyeballsEnabled(false);
+
 // Use ec10 and agent10, they are the only identities with intermediate CAs.
 const client = keys.ec10;
 const server = keys.agent10;
diff --git a/test/parallel/test-tls-client-reject.js b/test/parallel/test-tls-client-reject.js
index ea10ef6da20834..f2aa14f3e40fd4 100644
--- a/test/parallel/test-tls-client-reject.js
+++ b/test/parallel/test-tls-client-reject.js
@@ -28,6 +28,8 @@ const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('rsa_private.pem'),
   cert: fixtures.readKey('rsa_cert.crt')
diff --git a/test/parallel/test-tls-client-renegotiation-13.js b/test/parallel/test-tls-client-renegotiation-13.js
index a32baed0249a0a..21a9e57bb8860b 100644
--- a/test/parallel/test-tls-client-renegotiation-13.js
+++ b/test/parallel/test-tls-client-renegotiation-13.js
@@ -9,6 +9,8 @@ const {
   assert, connect, keys
 } = require(fixtures.path('tls-connect'));
 
+common.setHappyEyeballsEnabled(false);
+
 const server = keys.agent10;
 
 connect({
diff --git a/test/parallel/test-tls-client-resume.js b/test/parallel/test-tls-client-resume.js
index 0f5c9caa7c3f8f..51280540a8df2a 100644
--- a/test/parallel/test-tls-client-resume.js
+++ b/test/parallel/test-tls-client-resume.js
@@ -32,6 +32,8 @@ const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('agent2-key.pem'),
   cert: fixtures.readKey('agent2-cert.pem')
diff --git a/test/parallel/test-tls-connect-abort-controller.js b/test/parallel/test-tls-connect-abort-controller.js
index f9a37f1603a7e3..40d21262b6db99 100644
--- a/test/parallel/test-tls-connect-abort-controller.js
+++ b/test/parallel/test-tls-connect-abort-controller.js
@@ -8,6 +8,8 @@ const assert = require('assert');
 const fixtures = require('../common/fixtures');
 const { getEventListeners, once } = require('events');
 
+common.setHappyEyeballsEnabled(false);
+
 const serverOptions = {
   key: fixtures.readKey('agent1-key.pem'),
   cert: fixtures.readKey('agent1-cert.pem')
diff --git a/test/parallel/test-tls-connect-given-socket.js b/test/parallel/test-tls-connect-given-socket.js
index f25cf4582d59b1..4904afb001648b 100644
--- a/test/parallel/test-tls-connect-given-socket.js
+++ b/test/parallel/test-tls-connect-given-socket.js
@@ -29,6 +29,8 @@ const assert = require('assert');
 const tls = require('tls');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('rsa_private.pem'),
   cert: fixtures.readKey('rsa_cert.crt')
diff --git a/test/parallel/test-tls-connect-hints-option.js b/test/parallel/test-tls-connect-hints-option.js
index 4653e0a1418bbd..1a26ddfc426bff 100644
--- a/test/parallel/test-tls-connect-hints-option.js
+++ b/test/parallel/test-tls-connect-hints-option.js
@@ -11,6 +11,8 @@ const assert = require('assert');
 const dns = require('dns');
 const tls = require('tls');
 
+common.setHappyEyeballsEnabled(false);
+
 const hints = 512;
 
 assert.notStrictEqual(hints, dns.ADDRCONFIG);
diff --git a/test/parallel/test-tls-connect-secure-context.js b/test/parallel/test-tls-connect-secure-context.js
index 31941656c09a05..9140bd3519e99c 100644
--- a/test/parallel/test-tls-connect-secure-context.js
+++ b/test/parallel/test-tls-connect-secure-context.js
@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const common = require('../common');
 
 // Verify connection with explicitly created client SecureContext.
 
@@ -8,6 +8,8 @@ const {
   assert, connect, keys, tls
 } = require(fixtures.path('tls-connect'));
 
+common.setHappyEyeballsEnabled(false);
+
 connect({
   client: {
     servername: 'agent1',
diff --git a/test/parallel/test-tls-delayed-attach-error.js b/test/parallel/test-tls-delayed-attach-error.js
index 69a35f011ea774..54fdd3faacbb08 100644
--- a/test/parallel/test-tls-delayed-attach-error.js
+++ b/test/parallel/test-tls-delayed-attach-error.js
@@ -8,6 +8,8 @@ const tls = require('tls');
 const net = require('net');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const bonkers = Buffer.alloc(1024, 42);
 
 const options = {
diff --git a/test/parallel/test-tls-delayed-attach.js b/test/parallel/test-tls-delayed-attach.js
index b756db2d67ca5f..702c177fded620 100644
--- a/test/parallel/test-tls-delayed-attach.js
+++ b/test/parallel/test-tls-delayed-attach.js
@@ -35,6 +35,8 @@ const assert = require('assert');
 const tls = require('tls');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const sent = 'hello world';
 let received = '';
 
diff --git a/test/parallel/test-tls-destroy-stream.js b/test/parallel/test-tls-destroy-stream.js
index a49e985a7e0204..e69350b9916cfd 100644
--- a/test/parallel/test-tls-destroy-stream.js
+++ b/test/parallel/test-tls-destroy-stream.js
@@ -9,6 +9,8 @@ const net = require('net');
 const assert = require('assert');
 const tls = require('tls');
 
+common.setHappyEyeballsEnabled(false);
+
 tls.DEFAULT_MAX_VERSION = 'TLSv1.3';
 
 // This test ensures that an instance of StreamWrap should emit "end" and
diff --git a/test/parallel/test-tls-econnreset.js b/test/parallel/test-tls-econnreset.js
index a056f908190fd6..4e53989a0e09ef 100644
--- a/test/parallel/test-tls-econnreset.js
+++ b/test/parallel/test-tls-econnreset.js
@@ -29,6 +29,8 @@ const fixtures = require('../common/fixtures');
 const net = require('net');
 const tls = require('tls');
 
+common.setHappyEyeballsEnabled(false);
+
 let clientError = null;
 
 const server = tls.createServer({
diff --git a/test/parallel/test-tls-empty-sni-context.js b/test/parallel/test-tls-empty-sni-context.js
index 0c999b2c448f47..d26cf503450d94 100644
--- a/test/parallel/test-tls-empty-sni-context.js
+++ b/test/parallel/test-tls-empty-sni-context.js
@@ -7,6 +7,8 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const tls = require('tls');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   SNICallback: (name, callback) => {
     callback(null, tls.createSecureContext());
diff --git a/test/parallel/test-tls-enable-keylog-cli.js b/test/parallel/test-tls-enable-keylog-cli.js
index 128d9a096a0532..e636543aaa550a 100644
--- a/test/parallel/test-tls-enable-keylog-cli.js
+++ b/test/parallel/test-tls-enable-keylog-cli.js
@@ -32,6 +32,8 @@ child.on('close', common.mustCall((code, signal) => {
 }));
 
 function test() {
+  common.setHappyEyeballsEnabled(false);
+
   const {
     connect, keys
   } = require(fixtures.path('tls-connect'));
diff --git a/test/parallel/test-tls-enable-trace-cli.js b/test/parallel/test-tls-enable-trace-cli.js
index 7b6f7e22397af6..b9d88608bac70d 100644
--- a/test/parallel/test-tls-enable-trace-cli.js
+++ b/test/parallel/test-tls-enable-trace-cli.js
@@ -40,6 +40,8 @@ child.on('close', common.mustCall((code, signal) => {
 }));
 
 function test() {
+  common.setHappyEyeballsEnabled(false);
+
   const {
     connect, keys
   } = require(fixtures.path('tls-connect'));
diff --git a/test/parallel/test-tls-exportkeyingmaterial.js b/test/parallel/test-tls-exportkeyingmaterial.js
index b3173f94001194..a5c1d16f5169bc 100644
--- a/test/parallel/test-tls-exportkeyingmaterial.js
+++ b/test/parallel/test-tls-exportkeyingmaterial.js
@@ -12,6 +12,8 @@ const net = require('net');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const key = fixtures.readKey('agent1-key.pem');
 const cert = fixtures.readKey('agent1-cert.pem');
 
diff --git a/test/parallel/test-tls-friendly-error-message.js b/test/parallel/test-tls-friendly-error-message.js
index 4ae9d3f3f956d4..f6127bf48c047f 100644
--- a/test/parallel/test-tls-friendly-error-message.js
+++ b/test/parallel/test-tls-friendly-error-message.js
@@ -24,6 +24,8 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
+common.setHappyEyeballsEnabled(false);
+
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const tls = require('tls');
diff --git a/test/parallel/test-tls-getcertificate-x509.js b/test/parallel/test-tls-getcertificate-x509.js
index 5be788f6793113..76ceb619045e57 100644
--- a/test/parallel/test-tls-getcertificate-x509.js
+++ b/test/parallel/test-tls-getcertificate-x509.js
@@ -8,6 +8,8 @@ const tls = require('tls');
 const fixtures = require('../common/fixtures');
 const { X509Certificate } = require('crypto');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('agent6-key.pem'),
   cert: fixtures.readKey('agent6-cert.pem')
diff --git a/test/parallel/test-tls-ip-servername-deprecation.js b/test/parallel/test-tls-ip-servername-deprecation.js
index b747caa03d57c4..64a8ad38bd64ae 100644
--- a/test/parallel/test-tls-ip-servername-deprecation.js
+++ b/test/parallel/test-tls-ip-servername-deprecation.js
@@ -6,6 +6,8 @@ const fixtures = require('../common/fixtures');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
+common.setHappyEyeballsEnabled(false);
+
 const tls = require('tls');
 
 // This test expects `tls.connect()` to emit a warning when
diff --git a/test/parallel/test-tls-min-max-version.js b/test/parallel/test-tls-min-max-version.js
index ff337961f9a426..f1af774f204615 100644
--- a/test/parallel/test-tls-min-max-version.js
+++ b/test/parallel/test-tls-min-max-version.js
@@ -11,6 +11,7 @@ const {
 const DEFAULT_MIN_VERSION = tls.DEFAULT_MIN_VERSION;
 const DEFAULT_MAX_VERSION = tls.DEFAULT_MAX_VERSION;
 
+common.setHappyEyeballsEnabled(false);
 
 function test(cmin, cmax, cprot, smin, smax, sprot, proto, cerr, serr) {
   assert(proto || cerr || serr, 'test missing any expectations');
diff --git a/test/parallel/test-tls-onread-static-buffer.js b/test/parallel/test-tls-onread-static-buffer.js
index 6e19184e887d2a..c29114bd5a200b 100644
--- a/test/parallel/test-tls-onread-static-buffer.js
+++ b/test/parallel/test-tls-onread-static-buffer.js
@@ -7,6 +7,8 @@ const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('agent2-key.pem'),
   cert: fixtures.readKey('agent2-cert.pem')
diff --git a/test/parallel/test-tls-over-http-tunnel.js b/test/parallel/test-tls-over-http-tunnel.js
index 503ec1f6600f5f..2b74e2401d81ad 100644
--- a/test/parallel/test-tls-over-http-tunnel.js
+++ b/test/parallel/test-tls-over-http-tunnel.js
@@ -33,6 +33,8 @@ const net = require('net');
 const http = require('http');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 let gotRequest = false;
 
 const key = fixtures.readKey('agent1-key.pem');
diff --git a/test/parallel/test-tls-peer-certificate-encoding.js b/test/parallel/test-tls-peer-certificate-encoding.js
index 154c31c0a1386b..8e76ca6773e64f 100644
--- a/test/parallel/test-tls-peer-certificate-encoding.js
+++ b/test/parallel/test-tls-peer-certificate-encoding.js
@@ -29,6 +29,8 @@ const tls = require('tls');
 const util = require('util');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('agent5-key.pem'),
   cert: fixtures.readKey('agent5-cert.pem'),
diff --git a/test/parallel/test-tls-peer-certificate-multi-keys.js b/test/parallel/test-tls-peer-certificate-multi-keys.js
index ce4a0d406f9ea1..ddaabc15ec0daa 100644
--- a/test/parallel/test-tls-peer-certificate-multi-keys.js
+++ b/test/parallel/test-tls-peer-certificate-multi-keys.js
@@ -28,6 +28,8 @@ const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('rsa_private.pem'),
   cert: fixtures.readKey('rsa_cert.crt')
diff --git a/test/parallel/test-tls-peer-certificate.js b/test/parallel/test-tls-peer-certificate.js
index 5ca086723a6fa1..71b179c55bb80e 100644
--- a/test/parallel/test-tls-peer-certificate.js
+++ b/test/parallel/test-tls-peer-certificate.js
@@ -29,6 +29,8 @@ const crypto = require('crypto');
 
 // Verify that detailed getPeerCertificate() return value has all certs.
 
+common.setHappyEyeballsEnabled(false);
+
 const {
   assert, connect, debug, keys
 } = require(fixtures.path('tls-connect'));
diff --git a/test/parallel/test-tls-psk-errors.js b/test/parallel/test-tls-psk-errors.js
index 4864a66f555d7d..b4ba78094de928 100644
--- a/test/parallel/test-tls-psk-errors.js
+++ b/test/parallel/test-tls-psk-errors.js
@@ -4,6 +4,8 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
+common.setHappyEyeballsEnabled(false);
+
 const assert = require('assert');
 const tls = require('tls');
 
diff --git a/test/parallel/test-tls-secure-session.js b/test/parallel/test-tls-secure-session.js
index b4b9638a2ccc7a..b1d2ee33dede58 100644
--- a/test/parallel/test-tls-secure-session.js
+++ b/test/parallel/test-tls-secure-session.js
@@ -6,6 +6,8 @@ const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const tls = require('tls');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('agent1-key.pem'),
 
diff --git a/test/parallel/test-tls-server-connection-server.js b/test/parallel/test-tls-server-connection-server.js
index 7fb2c74996ab4b..62539d9085d5b5 100644
--- a/test/parallel/test-tls-server-connection-server.js
+++ b/test/parallel/test-tls-server-connection-server.js
@@ -8,6 +8,8 @@ const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const options = {
   key: fixtures.readKey('agent1-key.pem'),
   cert: fixtures.readKey('agent1-cert.pem')
diff --git a/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js b/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js
index c4351008c147c9..13b038f9a42c83 100644
--- a/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js
+++ b/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js
@@ -8,6 +8,8 @@ const tls = require('tls');
 const net = require('net');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const bonkers = Buffer.alloc(1024, 42);
 
 
diff --git a/test/parallel/test-tls-set-ciphers.js b/test/parallel/test-tls-set-ciphers.js
index c2d9740201d74a..7f9dfe7b292ee4 100644
--- a/test/parallel/test-tls-set-ciphers.js
+++ b/test/parallel/test-tls-set-ciphers.js
@@ -12,6 +12,7 @@ const {
   assert, connect, keys
 } = require(fixtures.path('tls-connect'));
 
+common.setHappyEyeballsEnabled(false);
 
 function test(cciphers, sciphers, cipher, cerr, serr, options) {
   assert(cipher || cerr || serr, 'test missing any expectations');
diff --git a/test/parallel/test-tls-set-sigalgs.js b/test/parallel/test-tls-set-sigalgs.js
index 59dc2ca0c786cf..10c047c86ff4c3 100644
--- a/test/parallel/test-tls-set-sigalgs.js
+++ b/test/parallel/test-tls-set-sigalgs.js
@@ -9,6 +9,8 @@ const {
   assert, connect, keys
 } = require(fixtures.path('tls-connect'));
 
+common.setHappyEyeballsEnabled(false);
+
 function assert_arrays_equal(left, right) {
   assert.strictEqual(left.length, right.length);
   for (let i = 0; i < left.length; i++) {
diff --git a/test/parallel/test-tls-sni-option.js b/test/parallel/test-tls-sni-option.js
index 9ac5a8c5622de4..1b156105538154 100644
--- a/test/parallel/test-tls-sni-option.js
+++ b/test/parallel/test-tls-sni-option.js
@@ -28,6 +28,8 @@ const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 function loadPEM(n) {
   return fixtures.readKey(`${n}.pem`);
 }
diff --git a/test/parallel/test-tls-sni-server-client.js b/test/parallel/test-tls-sni-server-client.js
index 79f3601561ee19..267207f4c9d480 100644
--- a/test/parallel/test-tls-sni-server-client.js
+++ b/test/parallel/test-tls-sni-server-client.js
@@ -28,6 +28,7 @@ const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
 
 function loadPEM(n) {
   return fixtures.readKey(`${n}.pem`);
diff --git a/test/parallel/test-tls-sni-servername.js b/test/parallel/test-tls-sni-servername.js
index 2c5785df5426c9..3c24d0cc103b06 100644
--- a/test/parallel/test-tls-sni-servername.js
+++ b/test/parallel/test-tls-sni-servername.js
@@ -9,6 +9,8 @@ const tls = require('tls');
 // We could get the `tlsSocket.servername` even if the event of "tlsClientError"
 // is emitted.
 
+common.setHappyEyeballsEnabled(false);
+
 const serverOptions = {
   requestCert: true,
   rejectUnauthorized: false,
diff --git a/test/parallel/test-tls-socket-close.js b/test/parallel/test-tls-socket-close.js
index 87355cf8d7bd2d..3ec2d77bccebdd 100644
--- a/test/parallel/test-tls-socket-close.js
+++ b/test/parallel/test-tls-socket-close.js
@@ -21,6 +21,8 @@ const fixtures = require('../common/fixtures');
 //   https://github.com/nodejs/node/issues/13184#issuecomment-303700377
 tls.DEFAULT_MAX_VERSION = 'TLSv1.2';
 
+common.setHappyEyeballsEnabled(false);
+
 const key = fixtures.readKey('agent2-key.pem');
 const cert = fixtures.readKey('agent2-cert.pem');
 
diff --git a/test/parallel/test-tls-socket-constructor-alpn-options-parsing.js b/test/parallel/test-tls-socket-constructor-alpn-options-parsing.js
index 686f6444ef9d2f..22af6c2248a1ec 100644
--- a/test/parallel/test-tls-socket-constructor-alpn-options-parsing.js
+++ b/test/parallel/test-tls-socket-constructor-alpn-options-parsing.js
@@ -17,6 +17,8 @@ const assert = require('assert');
 const net = require('net');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const key = fixtures.readKey('agent1-key.pem');
 const cert = fixtures.readKey('agent1-cert.pem');
 
diff --git a/test/parallel/test-tls-socket-destroy.js b/test/parallel/test-tls-socket-destroy.js
index 6f1d4b4186b74f..2c5550ae531128 100644
--- a/test/parallel/test-tls-socket-destroy.js
+++ b/test/parallel/test-tls-socket-destroy.js
@@ -9,6 +9,8 @@ const net = require('net');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const key = fixtures.readKey('agent1-key.pem');
 const cert = fixtures.readKey('agent1-cert.pem');
 
diff --git a/test/parallel/test-tls-socket-failed-handshake-emits-error.js b/test/parallel/test-tls-socket-failed-handshake-emits-error.js
index d67a5498d65195..7f713fb9626e93 100644
--- a/test/parallel/test-tls-socket-failed-handshake-emits-error.js
+++ b/test/parallel/test-tls-socket-failed-handshake-emits-error.js
@@ -8,6 +8,8 @@ const tls = require('tls');
 const net = require('net');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const bonkers = Buffer.alloc(1024, 42);
 
 const server = net.createServer(function(c) {
diff --git a/test/parallel/test-tls-starttls-server.js b/test/parallel/test-tls-starttls-server.js
index d9a1c02fc87c0f..b0e69ce1e07bad 100644
--- a/test/parallel/test-tls-starttls-server.js
+++ b/test/parallel/test-tls-starttls-server.js
@@ -13,6 +13,8 @@ const net = require('net');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const key = fixtures.readKey('agent1-key.pem');
 const cert = fixtures.readKey('agent1-cert.pem');
 
diff --git a/test/parallel/test-tls-ticket-cluster.js b/test/parallel/test-tls-ticket-cluster.js
index 089660258cda41..e88d3478abc9f3 100644
--- a/test/parallel/test-tls-ticket-cluster.js
+++ b/test/parallel/test-tls-ticket-cluster.js
@@ -33,6 +33,8 @@ const workerCount = 4;
 const expectedReqCount = 16;
 
 if (cluster.isPrimary) {
+  common.setHappyEyeballsEnabled(false);
+
   let reusedCount = 0;
   let reqCount = 0;
   let lastSession = null;
diff --git a/test/parallel/test-tls-ticket.js b/test/parallel/test-tls-ticket.js
index 8d9cd8cdd25155..a57b1e6844e617 100644
--- a/test/parallel/test-tls-ticket.js
+++ b/test/parallel/test-tls-ticket.js
@@ -30,6 +30,8 @@ const net = require('net');
 const crypto = require('crypto');
 const fixtures = require('../common/fixtures');
 
+common.setHappyEyeballsEnabled(false);
+
 const keys = crypto.randomBytes(48);
 const serverLog = [];
 const ticketLog = [];
diff --git a/test/parallel/test-tls-writewrap-leak.js b/test/parallel/test-tls-writewrap-leak.js
index 7035764cba5394..2ff87bd1c01c5a 100644
--- a/test/parallel/test-tls-writewrap-leak.js
+++ b/test/parallel/test-tls-writewrap-leak.js
@@ -8,6 +8,8 @@ const assert = require('assert');
 const net = require('net');
 const tls = require('tls');
 
+common.setHappyEyeballsEnabled(false);
+
 const server = net.createServer(common.mustCall((c) => {
   c.destroy();
 })).listen(0, common.mustCall(() => {
diff --git a/test/parallel/test-trace-events-net.js b/test/parallel/test-trace-events-net.js
index 227c168c013245..0b45f7f9e91b1d 100644
--- a/test/parallel/test-trace-events-net.js
+++ b/test/parallel/test-trace-events-net.js
@@ -8,6 +8,7 @@ const tmpdir = require('../common/tmpdir');
 
 const CODE = `
   const net = require('net');
+  net.Socket.autoDetectFamily = false;
   const socket = net.connect('${common.PIPE}');
   socket.on('error', () => {});
   const server = net.createServer((socket) => {
diff --git a/test/report/test-report-uv-handles.js b/test/report/test-report-uv-handles.js
index eff3cbe841b6f7..69a19e6f5fa685 100644
--- a/test/report/test-report-uv-handles.js
+++ b/test/report/test-report-uv-handles.js
@@ -7,6 +7,8 @@ const path = require('path');
 if (common.isIBMi)
   common.skip('IBMi does not support fs.watch()');
 
+common.setHappyEyeballsEnabled(false);
+
 // This is quite similar to common.PIPE except that it uses an extended prefix
 // of "\\?\pipe" on windows.
 const PIPE = (() => {
diff --git a/test/sequential/test-cluster-send-handle-large-payload.js b/test/sequential/test-cluster-send-handle-large-payload.js
index b227a7970ae6ba..76e4bc3104ca60 100644
--- a/test/sequential/test-cluster-send-handle-large-payload.js
+++ b/test/sequential/test-cluster-send-handle-large-payload.js
@@ -5,6 +5,8 @@ const assert = require('assert');
 const cluster = require('cluster');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const payload = 'a'.repeat(800004);
 
 if (cluster.isPrimary) {
diff --git a/test/sequential/test-http-econnrefused.js b/test/sequential/test-http-econnrefused.js
index 7f8c2cee56c4c8..7e2eeebc03a81c 100644
--- a/test/sequential/test-http-econnrefused.js
+++ b/test/sequential/test-http-econnrefused.js
@@ -32,6 +32,7 @@ const common = require('../common');
 const http = require('http');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
 
 const server = http.createServer(function(req, res) {
   let body = '';
diff --git a/test/sequential/test-http-regr-gh-2928.js b/test/sequential/test-http-regr-gh-2928.js
index 149aaeb6e6e420..453fc21b9f0d7b 100644
--- a/test/sequential/test-http-regr-gh-2928.js
+++ b/test/sequential/test-http-regr-gh-2928.js
@@ -8,6 +8,8 @@ const httpCommon = require('_http_common');
 const { HTTPParser } = require('_http_common');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const COUNT = httpCommon.parsers.max + 1;
 
 const parsers = new Array(COUNT);
diff --git a/test/sequential/test-http2-ping-flood.js b/test/sequential/test-http2-ping-flood.js
index b414aca8a4703a..9270345663b365 100644
--- a/test/sequential/test-http2-ping-flood.js
+++ b/test/sequential/test-http2-ping-flood.js
@@ -10,6 +10,8 @@ const net = require('net');
 
 const http2util = require('../common/http2');
 
+common.setHappyEyeballsEnabled(false);
+
 // Test that ping flooding causes the session to be torn down
 
 const kSettings = new http2util.SettingsFrame();
diff --git a/test/sequential/test-http2-settings-flood.js b/test/sequential/test-http2-settings-flood.js
index 15b3696b9c298e..69935713656fc0 100644
--- a/test/sequential/test-http2-settings-flood.js
+++ b/test/sequential/test-http2-settings-flood.js
@@ -10,6 +10,8 @@ const net = require('net');
 
 const http2util = require('../common/http2');
 
+common.setHappyEyeballsEnabled(false);
+
 // Test that settings flooding causes the session to be torn down
 
 const kSettings = new http2util.SettingsFrame();
diff --git a/test/sequential/test-net-better-error-messages-port.js b/test/sequential/test-net-better-error-messages-port.js
index c21427ee395139..5fd1f8be519478 100644
--- a/test/sequential/test-net-better-error-messages-port.js
+++ b/test/sequential/test-net-better-error-messages-port.js
@@ -3,6 +3,8 @@ const common = require('../common');
 const net = require('net');
 const assert = require('assert');
 
+common.setHappyEyeballsEnabled(false);
+
 const c = net.createConnection(common.PORT);
 
 c.on('connect', common.mustNotCall());
diff --git a/test/sequential/test-pipe.js b/test/sequential/test-pipe.js
index c3e0ddef9fe57d..a816a65d18a3b5 100644
--- a/test/sequential/test-pipe.js
+++ b/test/sequential/test-pipe.js
@@ -25,6 +25,8 @@ const assert = require('assert');
 const http = require('http');
 const net = require('net');
 
+common.setHappyEyeballsEnabled(false);
+
 const webPort = common.PORT;
 const tcpPort = webPort + 1;
 const bufferSize = 5 * 1024 * 1024;