diff --git a/doc/api/http.md b/doc/api/http.md
index 83a401d97ee2eb..17bf15d6eccb1b 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -179,6 +179,14 @@ changes:
     **Default:** `'lifo'`.
   * `timeout` {number} Socket timeout in milliseconds.
     This will set the timeout when the socket is created.
+  * `separateHeadersValues` {boolean} If set to `true`, the request and the
+    response headers will never be squashed.
+    All request headers will be sent multiple times if the header
+    value was set to an array or set multiple times.
+    All response headers will always be returned as a string if the
+    header has been received once or as an array of strings if the header has
+    been received multiple times.
+    In both cases headers matching is case insensitive.
 
 `options` in [`socket.connect()`][] are also supported.
 
@@ -983,6 +991,10 @@ or
 request.setHeader('Cookie', ['type=ninja', 'language=javascript']);
 ```
 
+If `separateHeadersValues` was set to `true` when the request was created, then
+using this method will always append a new value to the list of values for this
+header.
+
 ### `request.setNoDelay([noDelay])`
 
 <!-- YAML
@@ -1629,6 +1641,10 @@ Reads out a header that's already been queued but not sent to the client.
 The name is case-insensitive. The type of the return value depends
 on the arguments provided to [`response.setHeader()`][].
 
+If `separateHeadersValues` was set to `true` when the server was created, then
+the return value is always a string if the header has been set once or
+an array of strings if the header has been set multiple times.
+
 ```js
 response.setHeader('Content-Type', 'text/html');
 response.setHeader('Content-Length', Buffer.byteLength(body));
@@ -1652,6 +1668,9 @@ added: v7.7.0
 Returns an array containing the unique names of the current outgoing headers.
 All header names are lowercase.
 
+If `separateHeadersValues` was set to `true` when the server was created, an
+header might be present in the list more than once.
+
 ```js
 response.setHeader('Foo', 'bar');
 response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);
@@ -1679,6 +1698,10 @@ prototypically inherit from the JavaScript `Object`. This means that typical
 `Object` methods such as `obj.toString()`, `obj.hasOwnProperty()`, and others
 are not defined and _will not work_.
 
+If `separateHeadersValues` was set to `true` when the server was created, then
+the values are always a string if the header will be sent once or
+an array of strings if the header will be sent multiple times.
+
 ```js
 response.setHeader('Foo', 'bar');
 response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);
@@ -1788,6 +1811,10 @@ When headers have been set with [`response.setHeader()`][], they will be merged
 with any headers passed to [`response.writeHead()`][], with the headers passed
 to [`response.writeHead()`][] given precedence.
 
+If `separateHeadersValues` was set to `true` when the request was created, then
+using this method will always append a new value to the list of values for this
+header.
+
 ```js
 // Returns content-type = text/plain
 const server = http.createServer((req, res) => {
@@ -2551,11 +2578,15 @@ added: v0.4.0
 -->
 
 * `name` {string} Name of header
-* Returns {string | undefined}
+* Returns {string | string\[] | undefined}
 
 Gets the value of HTTP header with the given name. If such a name doesn't
 exist in message, it will be `undefined`.
 
+If `separateHeadersValues` was set to `true` when the request or the server
+were created, then the return value is always a string if the header has been
+set once or an array of strings if the header has been set multiple times.
+
 ### `outgoingMessage.getHeaderNames()`
 
 <!-- YAML
@@ -2567,6 +2598,9 @@ added: v8.0.0
 Returns an array of names of headers of the outgoing outgoingMessage. All
 names are lowercase.
 
+If `separateHeadersValues` was set to `true` when the request or the server
+were created, an header might be present in the list more than once.
+
 ### `outgoingMessage.getHeaders()`
 
 <!-- YAML
@@ -2594,6 +2628,10 @@ const headers = outgoingMessage.getHeaders();
 // headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }
 ```
 
+If `separateHeadersValues` was set to `true` when the request or the server
+were created, then the values are always a string if the header will be sent
+once or an array of strings if the header will be sent multiple times.
+
 ### `outgoingMessage.hasHeader(name)`
 
 <!-- YAML
@@ -2659,6 +2697,10 @@ added: v0.4.0
 
 Sets a single header value for the header object.
 
+If `separateHeadersValues` was set to `true` when the request or the server
+were created, then using this method will always append a new value to the list
+of values for this header.
+
 ### `outgoingMessage.setTimeout(msesc[, callback])`
 
 <!-- YAML
@@ -2865,6 +2907,14 @@ changes:
     [`--max-http-header-size`][] for requests received by this server, i.e.
     the maximum length of request headers in bytes.
     **Default:** 16384 (16 KB).
+  * `separateHeadersValues` {boolean} If set to `true`, incoming requests and
+    server responses headers will never be squashed.
+    All incoming requests headers will always be returned as a string if the
+    header has been received once or as an array of strings if the header has
+    been received multiple times.
+    All server responses headers will be sent multiple times if the header
+    value was set to an array or set multiple times.
+    In both cases headers matching is case insensitive.
 
 * `requestListener` {Function}
 
@@ -3072,6 +3122,14 @@ changes:
     `hostname`. Valid values are `4` or `6`. When unspecified, both IP v4 and
     v6 will be used.
   * `headers` {Object} An object containing request headers.
+  * `separateHeadersValues` {boolean} If set to `true`, the request and the
+    response headers will never be squashed.
+    All request headers will be sent multiple times if the header
+    value was set to an array or set multiple times.
+    All response headers will always be returned as a string if the
+    header has been received once or as an array of strings if the header has
+    been received multiple times.
+    In both cases headers matching is case insensitive.
   * `hints` {number} Optional [`dns.lookup()` hints][].
   * `host` {string} A domain name or IP address of the server to issue the
     request to. **Default:** `'localhost'`.
diff --git a/lib/_http_agent.js b/lib/_http_agent.js
index 9c15875762dd47..eb8022e4724865 100644
--- a/lib/_http_agent.js
+++ b/lib/_http_agent.js
@@ -24,6 +24,7 @@
 const {
   ArrayPrototypeIncludes,
   ArrayPrototypeIndexOf,
+  ArrayIsArray,
   ArrayPrototypePop,
   ArrayPrototypePush,
   ArrayPrototypeShift,
@@ -60,6 +61,7 @@ const {
   validateOneOf,
   validateString,
 } = require('internal/validators');
+const { kSeparateHeadersValues } = require('_http_incoming');
 
 const kOnKeylog = Symbol('onkeylog');
 const kRequestOptions = Symbol('requestOptions');
@@ -344,7 +346,14 @@ Agent.prototype.createSocket = function createSocket(req, options, cb) {
 
 function calculateServerName(options, req) {
   let servername = options.host;
-  const hostHeader = req.getHeader('host');
+  let hostHeader = req.getHeader('host');
+
+  // If the separateHeadersValues is active, the header might be specified
+  // multiple times. In that case we choose the last value.
+  if (req[kSeparateHeadersValues] && ArrayIsArray(hostHeader)) {
+    hostHeader = hostHeader[hostHeader.length - 1];
+  }
+
   if (hostHeader) {
     validateString(hostHeader, 'options.headers.host');
 
diff --git a/lib/_http_client.js b/lib/_http_client.js
index 59c4cac89e9d9d..b12edcd9d2061c 100644
--- a/lib/_http_client.js
+++ b/lib/_http_client.js
@@ -46,6 +46,7 @@ const assert = require('internal/assert');
 const { once } = require('internal/util');
 const {
   _checkIsHttpToken: checkIsHttpToken,
+  kSeparateHeadersValues,
   freeParser,
   parsers,
   HTTPParser,
@@ -195,6 +196,7 @@ function ClientRequest(input, options, cb) {
   if (maxHeaderSize !== undefined)
     validateInteger(maxHeaderSize, 'maxHeaderSize', 0);
   this.maxHeaderSize = maxHeaderSize;
+  this[kSeparateHeadersValues] = Boolean(options.separateHeadersValues);
 
   const insecureHTTPParser = options.insecureHTTPParser;
   if (insecureHTTPParser !== undefined &&
@@ -726,6 +728,8 @@ function tickOnSocket(req, socket) {
                     0);
   parser.socket = socket;
   parser.outgoing = req;
+  parser[kSeparateHeadersValues] = req[kSeparateHeadersValues];
+
   req.parser = parser;
 
   socket.parser = parser;
diff --git a/lib/_http_common.js b/lib/_http_common.js
index 796deeff055767..acb851f647f591 100644
--- a/lib/_http_common.js
+++ b/lib/_http_common.js
@@ -33,12 +33,12 @@ const { getOptionValue } = require('internal/options');
 const insecureHTTPParser = getOptionValue('--insecure-http-parser');
 
 const FreeList = require('internal/freelist');
-const incoming = require('_http_incoming');
 const {
+  kSeparateHeadersValues,
   IncomingMessage,
   readStart,
   readStop
-} = incoming;
+} = require('_http_incoming');
 
 let debug = require('internal/util/debuglog').debuglog('http', (fn) => {
   debug = fn;
@@ -101,6 +101,7 @@ function parserOnHeadersComplete(versionMajor, versionMinor, headers, method,
   incoming.httpVersion = `${versionMajor}.${versionMinor}`;
   incoming.url = url;
   incoming.upgrade = upgrade;
+  incoming[kSeparateHeadersValues] = parser[kSeparateHeadersValues];
 
   if (socket) {
     debug('requestTimeout timer moved to req');
@@ -272,6 +273,7 @@ module.exports = {
   freeParser,
   methods,
   parsers,
+  kSeparateHeadersValues,
   kIncomingMessage,
   kRequestTimeout,
   HTTPParser,
diff --git a/lib/_http_incoming.js b/lib/_http_incoming.js
index 34de1c559c1a9f..a0870bd269d9f1 100644
--- a/lib/_http_incoming.js
+++ b/lib/_http_incoming.js
@@ -22,6 +22,7 @@
 'use strict';
 
 const {
+  ArrayIsArray,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
   StringPrototypeCharCodeAt,
@@ -34,6 +35,7 @@ const { Readable, finished } = require('stream');
 
 const kHeaders = Symbol('kHeaders');
 const kHeadersCount = Symbol('kHeadersCount');
+const kSeparateHeadersValues = Symbol('kSeparateHeadersValues');
 const kTrailers = Symbol('kTrailers');
 const kTrailersCount = Symbol('kTrailersCount');
 
@@ -112,8 +114,14 @@ ObjectDefineProperty(IncomingMessage.prototype, 'headers', {
       const src = this.rawHeaders;
       const dst = this[kHeaders];
 
-      for (let n = 0; n < this[kHeadersCount]; n += 2) {
-        this._addHeaderLine(src[n + 0], src[n + 1], dst);
+      if (this[kSeparateHeadersValues]) {
+        for (let n = 0; n < this[kHeadersCount]; n += 2) {
+          this._addHeaderLineSeparate(src[n + 0], src[n + 1], dst);
+        }
+      } else {
+        for (let n = 0; n < this[kHeadersCount]; n += 2) {
+          this._addHeaderLine(src[n + 0], src[n + 1], dst);
+        }
       }
     }
     return this[kHeaders];
@@ -131,8 +139,14 @@ ObjectDefineProperty(IncomingMessage.prototype, 'trailers', {
       const src = this.rawTrailers;
       const dst = this[kTrailers];
 
-      for (let n = 0; n < this[kTrailersCount]; n += 2) {
-        this._addHeaderLine(src[n + 0], src[n + 1], dst);
+      if (this[kSeparateHeadersValues]) {
+        for (let n = 0; n < this[kTrailersCount]; n += 2) {
+          this._addHeaderLineSeparate(src[n + 0], src[n + 1], dst);
+        }
+      } else {
+        for (let n = 0; n < this[kTrailersCount]; n += 2) {
+          this._addHeaderLine(src[n + 0], src[n + 1], dst);
+        }
       }
     }
     return this[kTrailers];
@@ -213,8 +227,14 @@ function _addHeaderLines(headers, n) {
     }
 
     if (dest) {
-      for (let i = 0; i < n; i += 2) {
-        this._addHeaderLine(headers[i], headers[i + 1], dest);
+      if (this[kSeparateHeadersValues]) {
+        for (let i = 0; i < n; i += 2) {
+          this._addHeaderLineSeparate(headers[i], headers[i + 1], dest);
+        }
+      } else {
+        for (let i = 0; i < n; i += 2) {
+          this._addHeaderLine(headers[i], headers[i + 1], dest);
+        }
       }
     }
   }
@@ -361,6 +381,20 @@ function _addHeaderLine(field, value, dest) {
   }
 }
 
+// Add the given (field, value) pair to the message, without joining values as
+// in _addHeaderLine. The headers values are always arrays.
+IncomingMessage.prototype._addHeaderLineSeparate = _addHeaderLineSeparate;
+function _addHeaderLineSeparate(field, value, dest) {
+  field = StringPrototypeToLowerCase(field);
+
+  if (ArrayIsArray(dest[field])) {
+    dest[field].push(value);
+  } else if (dest[field] !== undefined) {
+    dest[field] = [dest[field], value];
+  } else {
+    dest[field] = value;
+  }
+}
 
 // Call this instead of resume() if we want to just
 // dump all the data to /dev/null
@@ -385,6 +419,7 @@ function onError(self, error, cb) {
 }
 
 module.exports = {
+  kSeparateHeadersValues,
   IncomingMessage,
   readStart,
   readStop
diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index 71f6e3e72376a5..aa51646c537414 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -24,6 +24,7 @@
 const {
   Array,
   ArrayIsArray,
+  ArrayPrototypeFlat,
   ArrayPrototypeJoin,
   MathFloor,
   NumberPrototypeToString,
@@ -49,6 +50,7 @@ const {
   _checkIsHttpToken: checkIsHttpToken,
   _checkInvalidHeaderChar: checkInvalidHeaderChar,
   chunkExpression: RE_TE_CHUNKED,
+  kSeparateHeadersValues,
 } = require('_http_common');
 const {
   defaultTriggerAsyncIdScope,
@@ -386,9 +388,19 @@ function _storeHeader(firstLine, headers) {
 
   if (headers) {
     if (headers === this[kOutHeaders]) {
-      for (const key in headers) {
-        const entry = headers[key];
-        processHeader(this, state, entry[0], entry[1], false);
+      if (this[kSeparateHeadersValues]) {
+        for (const key in headers) {
+          const entry = headers[key];
+
+          for (let j = 0; j < entry.length; j++) {
+            processHeader(this, state, entry[j][0], entry[j][1], true);
+          }
+        }
+      } else {
+        for (const key in headers) {
+          const entry = headers[key];
+          processHeader(this, state, entry[0], entry[1], false);
+        }
       }
     } else if (ArrayIsArray(headers)) {
       if (headers.length && ArrayIsArray(headers[0])) {
@@ -582,7 +594,17 @@ OutgoingMessage.prototype.setHeader = function setHeader(name, value) {
   if (headers === null)
     this[kOutHeaders] = headers = ObjectCreate(null);
 
-  headers[StringPrototypeToLowerCase(name)] = [name, value];
+  if (this[kSeparateHeadersValues]) {
+    const lowerName = StringPrototypeToLowerCase(name);
+
+    if (headers[lowerName]) {
+      headers[lowerName].push([name, value]);
+    } else {
+      headers[lowerName] = [[name, value]];
+    }
+  } else {
+    headers[StringPrototypeToLowerCase(name)] = [name, value];
+  }
   return this;
 };
 
@@ -595,9 +617,27 @@ OutgoingMessage.prototype.getHeader = function getHeader(name) {
     return;
 
   const entry = headers[StringPrototypeToLowerCase(name)];
-  return entry && entry[1];
-};
 
+  if (!entry) {
+    return;
+  }
+
+  if (this[kSeparateHeadersValues]) {
+    if (entry.length === 1) {
+      return entry[0][1];
+    }
+
+    const values = Array(entry.length);
+
+    for (let i = 0, l = values.length; i < l; i++) {
+      values[i] = entry[i][1];
+    }
+
+    return values;
+  }
+  return entry[1];
+
+};
 
 // Returns an array of the names of the current outgoing headers.
 OutgoingMessage.prototype.getHeaderNames = function getHeaderNames() {
@@ -612,10 +652,21 @@ OutgoingMessage.prototype.getRawHeaderNames = function getRawHeaderNames() {
 
   const values = ObjectValues(headersMap);
   const headers = Array(values.length);
+
   // Retain for(;;) loop for performance reasons
   // Refs: https://github.com/nodejs/node/pull/30958
-  for (let i = 0, l = values.length; i < l; i++) {
-    headers[i] = values[i][0];
+  if (this[kSeparateHeadersValues]) {
+    let k = 0;
+
+    for (let i = 0, l = values.length; i < l; i++) {
+      for (let j = 0, m = values[i].length; j < m; j++) {
+        headers[k++] = values[i][j][0];
+      }
+    }
+  } else {
+    for (let i = 0, l = values.length; i < l; i++) {
+      headers[i] = values[i][0];
+    }
   }
 
   return headers;
@@ -628,12 +679,31 @@ OutgoingMessage.prototype.getHeaders = function getHeaders() {
   const ret = ObjectCreate(null);
   if (headers) {
     const keys = ObjectKeys(headers);
+
     // Retain for(;;) loop for performance reasons
     // Refs: https://github.com/nodejs/node/pull/30958
-    for (let i = 0; i < keys.length; ++i) {
-      const key = keys[i];
-      const val = headers[key][1];
-      ret[key] = val;
+    if (this[kSeparateHeadersValues]) {
+      for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        const entries = headers[key];
+        const values = Array(entries.length);
+
+        for (let j = 0, l = entries.length; j < l; j++) {
+          values[j] = entries[j][1];
+        }
+
+        ret[key] = ArrayPrototypeFlat(values, 1);
+
+        if (ret[key].length === 1) {
+          ret[key] = ret[key][0];
+        }
+      }
+    } else {
+      for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        const val = headers[key][1];
+        ret[key] = val;
+      }
     }
   }
   return ret;
@@ -817,11 +887,23 @@ OutgoingMessage.prototype.addTrailers = function addTrailers(headers) {
     if (typeof field !== 'string' || !field || !checkIsHttpToken(field)) {
       throw new ERR_INVALID_HTTP_TOKEN('Trailer name', field);
     }
-    if (checkInvalidHeaderChar(value)) {
-      debug('Trailer "%s" contains invalid characters', field);
-      throw new ERR_INVALID_CHAR('trailer content', field);
+
+    if (this[kSeparateHeadersValues] && ArrayIsArray(value)) {
+      for (let j = 0, m = value.length; j < m; j++) {
+        if (checkInvalidHeaderChar(value[j])) {
+          debug('Trailer "%s" contains invalid characters', field);
+          throw new ERR_INVALID_CHAR('trailer content', field);
+        }
+
+        this._trailer += field + ': ' + value[j] + '\r\n';
+      }
+    } else {
+      if (checkInvalidHeaderChar(value)) {
+        debug('Trailer "%s" contains invalid characters', field);
+        throw new ERR_INVALID_CHAR('trailer content', field);
+      }
+      this._trailer += field + ': ' + value + '\r\n';
     }
-    this._trailer += field + ': ' + value + '\r\n';
   }
 };
 
diff --git a/lib/_http_server.js b/lib/_http_server.js
index 0d06919ea017a4..ef014dd58149a7 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -23,6 +23,7 @@
 
 const {
   ArrayIsArray,
+  Boolean,
   Error,
   ObjectKeys,
   ObjectSetPrototypeOf,
@@ -40,6 +41,7 @@ const {
   continueExpression,
   chunkExpression,
   kIncomingMessage,
+  kSeparateHeadersValues,
   kRequestTimeout,
   HTTPParser,
   isLenient,
@@ -397,6 +399,7 @@ function Server(options, requestListener) {
   this.maxRequestsPerSocket = 0;
   this.headersTimeout = 60 * 1000; // 60 seconds
   this.requestTimeout = 0;
+  this[kSeparateHeadersValues] = Boolean(options.separateHeadersValues);
 }
 ObjectSetPrototypeOf(Server.prototype, net.Server.prototype);
 ObjectSetPrototypeOf(Server, net.Server);
@@ -467,6 +470,8 @@ function connectionListenerInternal(server, socket) {
     server.headersTimeout || 0,
   );
   parser.socket = socket;
+  parser[kSeparateHeadersValues] = server[kSeparateHeadersValues];
+
   socket.parser = parser;
 
   // Propagate headers limit from server instance to parser
@@ -881,6 +886,7 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
                                                socket, state);
 
   res.shouldKeepAlive = keepAlive;
+  res[kSeparateHeadersValues] = server[kSeparateHeadersValues];
   DTRACE_HTTP_SERVER_REQUEST(req, socket);
 
   if (onRequestStartChannel.hasSubscribers) {
diff --git a/test/parallel/test-http-separate-headers-values.js b/test/parallel/test-http-separate-headers-values.js
new file mode 100644
index 00000000000000..a359669c0b62e1
--- /dev/null
+++ b/test/parallel/test-http-separate-headers-values.js
@@ -0,0 +1,305 @@
+'use strict';
+
+// TODO@PI: Run all tests
+const common = require('../common');
+const assert = require('assert');
+const { createServer, request } = require('http');
+
+const serverWithSquashedHeaders = createServer(common.mustCall((req, res) => {
+  const host = `127.0.0.1:${serverWithSquashedHeaders.address().port}`;
+
+  assert.deepStrictEqual(req.rawHeaders, [
+    'connection', 'close',
+    'X-Req-A', 'bbb',
+    'x-req-b', 'ccc',
+    'x-req-b', 'ddd',
+    'Host', host,
+    'x-req-c', 'fff',
+    'x-req-c', 'ggg',
+    'x-req-d', 'hhh',
+    'Transfer-Encoding', 'chunked',
+  ]);
+  assert.deepStrictEqual(req.headers, {
+    'connection': 'close',
+    'x-req-a': 'bbb',
+    'x-req-b': 'ccc, ddd',
+    host,
+    'x-req-c': 'fff, ggg',
+    'x-req-d': 'hhh',
+    'transfer-encoding': 'chunked'
+  });
+
+  req.on('end', function() {
+    assert.deepStrictEqual(req.rawTrailers, [
+      'x-req-x', 'xxx',
+      'X-Req-X', 'yyy',
+      'X-req-Y', 'zzz,www',
+    ]);
+    assert.deepStrictEqual(
+      req.trailers, { 'x-req-x': 'xxx, yyy', 'x-req-y': 'zzz,www' }
+    );
+
+    res.setHeader('x-res-a', 'AAA');
+    res.setHeader('X-Res-A', 'BBB');
+    res.setHeader('X-Res-B', ['CCC', 'DDD']);
+    res.setHeader('x-res-c', 'EEE');
+    res.setHeader('x-res-c', ['FFF', 'GGG']);
+    res.setHeader('x-res-d', 'HHH');
+
+    res.removeHeader('date');
+    res.writeHead(200, {
+      'Connection': 'close', 'x-res-e': 'III',
+      'x-res-E': 'JJJ', 'X-Res-E': ['KKK', 'LLL']
+    });
+    res.addTrailers({
+      'x-res-x': 'XXX',
+      'X-Res-X': 'YYY',
+      'X-Res-Y': ['ZZZ', 'WWW']
+    });
+    res.write('BODY');
+    res.end();
+
+    assert.strictEqual(res.getHeader('x-res-a'), 'BBB');
+    assert.strictEqual(res.getHeader('X-res-A'), 'BBB');
+    assert.strictEqual(res.getHeader('connection'), 'close');
+    assert.deepStrictEqual(
+      res.getHeaderNames(),
+      ['x-res-a', 'x-res-b', 'x-res-c', 'x-res-d', 'connection', 'x-res-e']
+    );
+    assert.deepStrictEqual(
+      res.getRawHeaderNames(),
+      ['X-Res-A', 'X-Res-B', 'x-res-c', 'x-res-d', 'Connection', 'X-Res-E']
+    );
+    assert.deepStrictEqual(res.getHeaders(), {
+      'x-res-a': 'BBB',
+      'x-res-b': ['CCC', 'DDD'],
+      'x-res-c': [ 'FFF', 'GGG' ],
+      'x-res-d': 'HHH',
+      'connection': 'close',
+      'x-res-e': [ 'KKK', 'LLL' ]
+    });
+  });
+
+  req.resume();
+}));
+
+const serverWithSeparatedHeaders = createServer(
+  { separateHeadersValues: true },
+  common.mustCall((req, res) => {
+    const host = `127.0.0.1:${serverWithSeparatedHeaders.address().port}`;
+
+    assert.deepStrictEqual(req.rawHeaders, [
+      'connection', 'close',
+      'x-req-a', 'aaa',
+      'X-Req-A', 'bbb',
+      'x-req-b', 'ccc',
+      'x-req-b', 'ddd',
+      'Host', host,
+      'x-req-c', 'eee',
+      'x-req-c', 'fff',
+      'x-req-c', 'ggg',
+      'x-req-d', 'hhh',
+      'Transfer-Encoding', 'chunked',
+    ]);
+    assert.deepStrictEqual(req.headers, {
+      'connection': 'close',
+      'x-req-a': ['aaa', 'bbb'],
+      'x-req-b': ['ccc', 'ddd'],
+      host,
+      'x-req-c': ['eee', 'fff', 'ggg'],
+      'x-req-d': 'hhh',
+      'transfer-encoding': 'chunked'
+    });
+
+    req.on('end', function() {
+      assert.deepStrictEqual(req.rawTrailers, [
+        'x-req-x', 'xxx',
+        'X-Req-X', 'yyy',
+        'X-req-Y', 'zzz',
+        'X-req-Y', 'www',
+      ]);
+      assert.deepStrictEqual(
+        req.trailers, { 'x-req-x': ['xxx', 'yyy'], 'x-req-y': ['zzz', 'www'] }
+      );
+
+      res.setHeader('x-res-a', 'AAA');
+      res.setHeader('X-Res-A', 'BBB');
+      res.setHeader('X-Res-B', ['CCC', 'DDD']);
+      res.setHeader('x-res-c', 'EEE');
+      res.setHeader('x-res-c', ['FFF', 'GGG']);
+      res.setHeader('x-res-d', 'HHH');
+
+      res.removeHeader('date');
+      res.writeHead(200, {
+        'Connection': 'close', 'x-res-e': 'III',
+        'x-res-E': 'JJJ', 'X-Res-E': ['KKK', 'LLL']
+      });
+      res.addTrailers({
+        'x-res-x': 'XXX',
+        'X-Res-X': 'YYY',
+        'X-Res-Y': ['ZZZ', 'WWW']
+      });
+      res.write('BODY');
+      res.end();
+
+      assert.deepStrictEqual(res.getHeader('x-res-a'), ['AAA', 'BBB']);
+      assert.deepStrictEqual(res.getHeader('X-res-A'), ['AAA', 'BBB']);
+      assert.strictEqual(res.getHeader('connection'), 'close');
+      assert.deepStrictEqual(
+        res.getHeaderNames(),
+        ['x-res-a', 'x-res-b', 'x-res-c', 'x-res-d', 'connection', 'x-res-e']
+      );
+      assert.deepStrictEqual(
+        res.getRawHeaderNames(),
+        ['x-res-a', 'X-Res-A', 'X-Res-B', 'x-res-c', 'x-res-c', 'x-res-d',
+         'Connection', 'x-res-e', 'x-res-E', 'X-Res-E']
+      );
+      assert.deepStrictEqual(res.getHeaders(), {
+        'x-res-a': [ 'AAA', 'BBB' ],
+        'x-res-b': [ 'CCC', 'DDD' ],
+        'x-res-c': [ 'EEE', 'FFF', 'GGG' ],
+        'x-res-d': 'HHH',
+        'connection': 'close',
+        'x-res-e': [ 'III', 'JJJ', 'KKK', 'LLL' ]
+      });
+    });
+
+    req.resume();
+  }
+  ));
+
+serverWithSquashedHeaders.listen(0, common.mustCall(() => {
+  const req = request({
+    host: '127.0.0.1',
+    port: serverWithSquashedHeaders.address().port,
+    path: '/',
+    method: 'POST',
+    headers: {
+      'connection': 'close',
+      'x-req-a': 'aaa',
+      'X-Req-A': 'bbb',
+      'x-req-b': ['ccc', 'ddd']
+    },
+  }, common.mustCall((res) => {
+    assert.deepStrictEqual(res.rawHeaders, [
+      'X-Res-A', 'BBB',
+      'X-Res-B', 'CCC',
+      'X-Res-B', 'DDD',
+      'x-res-c', 'FFF',
+      'x-res-c', 'GGG',
+      'x-res-d', 'HHH',
+      'Connection', 'close',
+      'X-Res-E', 'KKK',
+      'X-Res-E', 'LLL',
+      'Transfer-Encoding', 'chunked',
+    ]);
+    assert.deepStrictEqual(res.headers, {
+      'x-res-a': 'BBB',
+      'x-res-b': 'CCC, DDD',
+      'x-res-c': 'FFF, GGG',
+      'x-res-d': 'HHH',
+      'connection': 'close',
+      'x-res-e': 'KKK, LLL',
+      'transfer-encoding': 'chunked'
+    });
+
+    res.on('end', function() {
+      assert.deepStrictEqual(res.rawTrailers, [
+        'x-res-x', 'XXX',
+        'X-Res-X', 'YYY',
+        'X-Res-Y', 'ZZZ,WWW',
+      ]);
+      assert.deepStrictEqual(
+        res.trailers,
+        { 'x-res-x': 'XXX, YYY', 'x-res-y': 'ZZZ,WWW' }
+      );
+      serverWithSquashedHeaders.close();
+    });
+    res.resume();
+  }));
+
+  req.setHeader('x-req-c', 'eee');
+  req.setHeader('x-req-c', ['fff', 'ggg']);
+  req.setHeader('x-req-d', 'hhh');
+
+  req.addTrailers({
+    'x-req-x': 'xxx',
+    'X-Req-X': 'yyy',
+    'X-req-Y': ['zzz', 'www']
+  });
+
+  req.write('BODY');
+
+  req.end();
+}));
+
+serverWithSeparatedHeaders.listen(0, common.mustCall(() => {
+  const req = request({
+    host: '127.0.0.1',
+    port: serverWithSeparatedHeaders.address().port,
+    path: '/',
+    method: 'POST',
+    headers: {
+      'connection': 'close',
+      'x-req-a': 'aaa',
+      'X-Req-A': 'bbb',
+      'x-req-b': ['ccc', 'ddd']
+    },
+    separateHeadersValues: true
+  }, common.mustCall((res) => {
+    assert.deepStrictEqual(res.rawHeaders, [
+      'x-res-a', 'AAA',
+      'X-Res-A', 'BBB',
+      'X-Res-B', 'CCC',
+      'X-Res-B', 'DDD',
+      'x-res-c', 'EEE',
+      'x-res-c', 'FFF',
+      'x-res-c', 'GGG',
+      'x-res-d', 'HHH',
+      'Connection', 'close',
+      'x-res-e', 'III',
+      'x-res-E', 'JJJ',
+      'X-Res-E', 'KKK',
+      'X-Res-E', 'LLL',
+      'Transfer-Encoding', 'chunked',
+    ]);
+    assert.deepStrictEqual(res.headers, {
+      'x-res-a': [ 'AAA', 'BBB' ],
+      'x-res-b': [ 'CCC', 'DDD' ],
+      'x-res-c': [ 'EEE', 'FFF', 'GGG' ],
+      'x-res-d': 'HHH',
+      'connection': 'close',
+      'x-res-e': [ 'III', 'JJJ', 'KKK', 'LLL' ],
+      'transfer-encoding': 'chunked'
+    });
+
+    res.on('end', function() {
+      assert.deepStrictEqual(res.rawTrailers, [
+        'x-res-x', 'XXX',
+        'X-Res-X', 'YYY',
+        'X-Res-Y', 'ZZZ',
+        'X-Res-Y', 'WWW',
+      ]);
+      assert.deepStrictEqual(
+        res.trailers,
+        { 'x-res-x': ['XXX', 'YYY'], 'x-res-y': ['ZZZ', 'WWW'] }
+      );
+      serverWithSeparatedHeaders.close();
+    });
+    res.resume();
+  }));
+
+  req.setHeader('x-req-c', 'eee');
+  req.setHeader('x-req-c', ['fff', 'ggg']);
+  req.setHeader('x-req-d', 'hhh');
+
+  req.addTrailers({
+    'x-req-x': 'xxx',
+    'X-Req-X': 'yyy',
+    'X-req-Y': ['zzz', 'www']
+  });
+
+  req.write('BODY');
+
+  req.end();
+}));