diff --git a/benchmark/querystring/querystring-parse.js b/benchmark/querystring/querystring-parse.js
index fe14d95a53f0a0..2e2ec1417bcd35 100644
--- a/benchmark/querystring/querystring-parse.js
+++ b/benchmark/querystring/querystring-parse.js
@@ -3,17 +3,7 @@ var common = require('../common.js');
 var querystring = require('querystring');
 var v8 = require('v8');
 
-var inputs = {
-  noencode: 'foo=bar&baz=quux&xyzzy=thud',
-  multicharsep: 'foo=bar&&&&&&&&&&baz=quux&&&&&&&&&&xyzzy=thud',
-  encodefake: 'foo=%©ar&baz=%A©uux&xyzzy=%©ud',
-  encodemany: '%66%6F%6F=bar&%62%61%7A=quux&xyzzy=%74h%75d',
-  encodelast: 'foo=bar&baz=quux&xyzzy=thu%64',
-  multivalue: 'foo=bar&foo=baz&foo=quux&quuy=quuz',
-  multivaluemany: 'foo=bar&foo=baz&foo=quux&quuy=quuz&foo=abc&foo=def&' +
-                  'foo=ghi&foo=jkl&foo=mno&foo=pqr&foo=stu&foo=vwxyz',
-  manypairs: 'a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z'
-};
+var inputs = require('../fixtures/url-inputs.js').searchParams;
 
 var bench = common.createBenchmark(main, {
   type: Object.keys(inputs),
diff --git a/benchmark/url/url-format.js b/benchmark/url/url-format.js
index 3f7df8a0bc4536..886958406b91c5 100644
--- a/benchmark/url/url-format.js
+++ b/benchmark/url/url-format.js
@@ -3,8 +3,13 @@ const common = require('../common.js');
 const url = require('url');
 const v8 = require('v8');
 
+const inputs = {
+  slashes: {slashes: true, host: 'localhost'},
+  file: {protocol: 'file:', pathname: '/foo'},
+};
+
 const bench = common.createBenchmark(main, {
-  type: 'one two'.split(' '),
+  type: Object.keys(inputs),
   n: [25e6]
 });
 
@@ -12,10 +17,6 @@ function main(conf) {
   const type = conf.type;
   const n = conf.n | 0;
 
-  const inputs = {
-    one: {slashes: true, host: 'localhost'},
-    two: {protocol: 'file:', pathname: '/foo'},
-  };
   const input = inputs[type] || '';
 
   // Force-optimize url.format() so that the benchmark doesn't get
diff --git a/benchmark/url/url-parse.js b/benchmark/url/url-parse.js
deleted file mode 100644
index 89679548b8f193..00000000000000
--- a/benchmark/url/url-parse.js
+++ /dev/null
@@ -1,37 +0,0 @@
-'use strict';
-var common = require('../common.js');
-var url = require('url');
-var v8 = require('v8');
-
-var bench = common.createBenchmark(main, {
-  type: 'one two three four five six'.split(' '),
-  n: [25e4]
-});
-
-function main(conf) {
-  var type = conf.type;
-  var n = conf.n | 0;
-
-  var inputs = {
-    one: 'http://nodejs.org/docs/latest/api/url.html#url_url_format_urlobj',
-    two: 'http://blog.nodejs.org/',
-    three: 'https://encrypted.google.com/search?q=url&q=site:npmjs.org&hl=en',
-    four: 'javascript:alert("node is awesome");',
-    five: 'some.ran/dom/url.thing?oh=yes#whoo',
-    six: 'https://user:pass@example.com/',
-  };
-  var input = inputs[type] || '';
-
-  // Force-optimize url.parse() so that the benchmark doesn't get
-  // disrupted by the optimizer kicking in halfway through.
-  for (var name in inputs)
-    url.parse(inputs[name]);
-
-  v8.setFlagsFromString('--allow_natives_syntax');
-  eval('%OptimizeFunctionOnNextCall(url.parse)');
-
-  bench.start();
-  for (var i = 0; i < n; i += 1)
-    url.parse(input);
-  bench.end(n);
-}
diff --git a/benchmark/url/url-resolve.js b/benchmark/url/url-resolve.js
index 8372132e4d269e..4335511ca6d2df 100644
--- a/benchmark/url/url-resolve.js
+++ b/benchmark/url/url-resolve.js
@@ -1,36 +1,28 @@
 'use strict';
-var common = require('../common.js');
-var url = require('url');
-var v8 = require('v8');
+const common = require('../common.js');
+const url = require('url');
+const v8 = require('v8');
+const hrefs = require('../fixtures/url-inputs.js').urls;
+hrefs.noscheme = 'some.ran/dom/url.thing?oh=yes#whoo';
 
-var hrefs = [
-  'http://example.com/',
-  'http://nodejs.org/docs/latest/api/url.html#url_url_format_urlobj',
-  'http://blog.nodejs.org/',
-  'https://encrypted.google.com/search?q=url&q=site:npmjs.org&hl=en',
-  'javascript:alert("node is awesome");',
-  'some.ran/dom/url.thing?oh=yes#whoo'
-];
+const paths = {
+  'up': '../../../../../etc/passwd',
+  'sibling': '../foo/bar?baz=boom',
+  'foo/bar': 'foo/bar',
+  'withscheme': 'http://nodejs.org',
+  'down': './foo/bar?baz'
+};
 
-
-var paths = [
-  '../../../../../etc/passwd',
-  '../foo/bar?baz=boom',
-  'foo/bar',
-  'http://nodejs.org',
-  './foo/bar?baz'
-];
-
-var bench = common.createBenchmark(main, {
+const bench = common.createBenchmark(main, {
   href: Object.keys(hrefs),
   path: Object.keys(paths),
   n: [1e5]
 });
 
 function main(conf) {
-  var n = conf.n | 0;
-  var href = hrefs[conf.href];
-  var path = paths[conf.path];
+  const n = conf.n | 0;
+  const href = hrefs[conf.href];
+  const path = paths[conf.path];
 
   // Force-optimize url.resolve() so that the benchmark doesn't get
   // disrupted by the optimizer kicking in halfway through.
diff --git a/benchmark/url/url-searchparams-sort.js b/benchmark/url/url-searchparams-sort.js
new file mode 100644
index 00000000000000..677ce511cf3ea2
--- /dev/null
+++ b/benchmark/url/url-searchparams-sort.js
@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../common.js');
+const URLSearchParams = require('url').URLSearchParams;
+
+const inputs = {
+  empty: '',
+  sorted: 'a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z',
+  almostsorted: 'a&b&c&d&e&f&g&i&h&j&k&l&m&n&o&p&q&r&s&t&u&w&v&x&y&z',
+  reversed: 'z&y&x&w&v&u&t&s&r&q&p&o&n&m&l&k&j&i&h&g&f&e&d&c&b&a',
+  random: 'm&t&d&c&z&v&a&n&p&y&u&o&h&l&f&j&e&q&b&i&s&x&k&w&r&g',
+  // 8 parameters
+  short: 'm&t&d&c&z&v&a&n',
+  // 88 parameters
+  long: 'g&r&t&h&s&r&d&w&b&n&h&k&x&m&k&h&o&e&x&c&c&g&e&b&p&p&s&n&j&b&y&z&' +
+        'u&l&o&r&w&a&u&l&m&f&j&q&p&f&e&y&e&n&e&l&m&w&u&w&t&n&t&q&v&y&c&o&' +
+        'k&f&j&i&l&m&g&j&d&i&z&q&p&x&q&q&d&n&y&w&g&i&v&r'
+};
+
+function getParams(str) {
+  const out = [];
+  for (const key of str.split('&')) {
+    out.push(key, '');
+  }
+  return out;
+}
+
+const bench = common.createBenchmark(main, {
+  type: Object.keys(inputs),
+  n: [1e6]
+}, {
+  flags: ['--expose-internals']
+});
+
+function main(conf) {
+  const searchParams = require('internal/url').searchParamsSymbol;
+  const input = inputs[conf.type];
+  const n = conf.n | 0;
+  const params = new URLSearchParams();
+  const array = getParams(input);
+
+  var i;
+  bench.start();
+  for (i = 0; i < n; i++) {
+    params[searchParams] = array.slice();
+    params.sort();
+  }
+  bench.end(n);
+}
diff --git a/doc/api/url.md b/doc/api/url.md
old mode 100755
new mode 100644
index 50e7433e6110e5..61d27c5b68a15e
--- a/doc/api/url.md
+++ b/doc/api/url.md
@@ -198,6 +198,47 @@ The formatting process operates as follows:
   string, an [`Error`][] is thrown.
 * `result` is returned.
 
+## url.format(URL[, options])
+
+> Stability: 1 - Experimental
+
+* `URL` {URL} A [WHATWG URL][] object
+* `options` {Object}
+  * `auth` {Boolean} `true` if the serialized URL string should include the
+    username and password, `false` otherwise. Defaults to `true`.
+  * `fragment` {Boolean} `true` if the serialized URL string should include the
+    fragment, `false` otherwise. Defaults to `true`.
+  * `search` {Boolean} `true` if the serialized URL string should include the
+    search query, `false` otherwise. Defaults to `true`.
+  * `unicode` (Boolean) `true` if Unicode characters appearing in the host
+    component of the URL string should be encoded directly as opposed to being
+    Punycode encoded. Defaults to `false`.
+
+Returns a customizable serialization of a URL String representation of a
+[WHATWG URL][] object.
+
+The URL object has both a `toString()` method and `href` property that return
+string serializations of the URL. These are not, however, customizable in
+any way. The `url.format(URL[, options])` method allows for basic customization
+of the output.
+
+For example:
+
+```js
+const myURL = new URL('https://a:b@你好你好?abc#foo');
+
+console.log(myURL.href);
+  // Prints https://a:b@xn--6qqa088eba/?abc#foo
+
+console.log(myURL.toString());
+  // Prints https://a:b@xn--6qqa088eba/?abc#foo
+
+console.log(url.format(myURL, {fragment: false, unicode: true, auth: false}));
+  // Prints 'https://你好你好?abc'
+```
+
+*Note*: This variation of the `url.format()` method is currently considered to
+be experimental.
 
 ## url.parse(urlString[, parseQueryString[, slashesDenoteHost]])
 <!-- YAML
@@ -270,6 +311,35 @@ console.log(myURL.pathname); // /foo
 *Note*: Using the `delete` keyword (e.g. `delete myURL.protocol`,
 `delete myURL.pathname`, etc) has no effect but will still return `true`.
 
+A comparison between this API and `url.parse()` is given below. Above the URL
+`'http://user:pass@host.com:8080/p/a/t/h?query=string#hash'`, properties of an
+object returned by `url.parse()` are shown. Below it are properties of a WHATWG
+`URL` object.
+
+*Note*: WHATWG URL's `origin` property includes `protocol` and `host`, but not
+`username` or `password`.
+
+```txt
+┌─────────────────────────────────────────────────────────────────────────────────────────┐
+│                                          href                                           │
+├──────────┬──┬─────────────────────┬─────────────────┬───────────────────────────┬───────┤
+│ protocol │  │        auth         │      host       │           path            │ hash  │
+│          │  │                     ├──────────┬──────┼──────────┬────────────────┤       │
+│          │  │                     │ hostname │ port │ pathname │     search     │       │
+│          │  │                     │          │      │          ├─┬──────────────┤       │
+│          │  │                     │          │      │          │ │    query     │       │
+"  http:    //    user   :   pass   @ host.com : 8080   /p/a/t/h  ?  query=string   #hash "
+│          │  │          │          │ hostname │ port │          │                │       │
+│          │  │          │          ├──────────┴──────┤          │                │       │
+│ protocol │  │ username │ password │      host       │          │                │       │
+├──────────┴──┼──────────┴──────────┼─────────────────┤          │                │       │
+│   origin    │                     │     origin      │ pathname │     search     │ hash  │
+├─────────────┴─────────────────────┴─────────────────┴──────────┴────────────────┴───────┤
+│                                          href                                           │
+└─────────────────────────────────────────────────────────────────────────────────────────┘
+(all spaces in the "" line should be ignored -- they are purely for formatting)
+```
+
 ### Class: URL
 #### Constructor: new URL(input[, base])
 
@@ -299,13 +369,15 @@ automatically converted to ASCII using the [Punycode][] algorithm.
 
 ```js
 const myURL = new URL('https://你好你好');
-  // https://xn--6qqa088eba
+  // https://xn--6qqa088eba/
 ```
 
 Additional [examples of parsed URLs][] may be found in the WHATWG URL Standard.
 
 #### url.hash
 
+* {String}
+
 Gets and sets the fragment portion of the URL.
 
 ```js
@@ -319,12 +391,14 @@ console.log(myURL.href);
 ```
 
 Invalid URL characters included in the value assigned to the `hash` property
-are [percent-encoded](#whatwg-percent-encoding). Note that the selection of
-which characters to percent-encode may vary somewhat from what the
-[`url.parse()`][] and [`url.format()`][] methods would produce.
+are [percent-encoded][]. Note that the selection of which characters to
+percent-encode may vary somewhat from what the [`url.parse()`][] and
+[`url.format()`][] methods would produce.
 
 #### url.host
 
+* {String}
+
 Gets and sets the host portion of the URL.
 
 ```js
@@ -341,6 +415,8 @@ Invalid host values assigned to the `host` property are ignored.
 
 #### url.hostname
 
+* {String}
+
 Gets and sets the hostname portion of the URL. The key difference between
 `url.host` and `url.hostname` is that `url.hostname` does *not* include the
 port.
@@ -359,6 +435,8 @@ Invalid hostname values assigned to the `hostname` property are ignored.
 
 #### url.href
 
+* {String}
+
 Gets and sets the serialized URL.
 
 ```js
@@ -370,15 +448,20 @@ myURL.href = 'https://example.com/bar'
   // Prints https://example.com/bar
 ```
 
-Setting the value of the `href` property to a new value is equivalent to
-creating a new `URL` object using `new URL(value)`. Each of the `URL` object's
-properties will be modified.
+Getting the value of the `href` property is equivalent to calling
+[`url.toString()`][].
+
+Setting the value of this property to a new value is equivalent to creating a
+new `URL` object using [`new URL(value)`][`new URL()`]. Each of the `URL`
+object's properties will be modified.
 
 If the value assigned to the `href` property is not a valid URL, a `TypeError`
 will be thrown.
 
 #### url.origin
 
+* {String}
+
 Gets the read-only serialization of the URL's origin. Unicode characters that
 may be contained within the hostname will be encoded as-is without [Punycode][]
 encoding.
@@ -400,6 +483,8 @@ console.log(idnURL.hostname);
 
 #### url.password
 
+* {String}
+
 Gets and sets the password portion of the URL.
 
 ```js
@@ -413,12 +498,14 @@ console.log(myURL.href);
 ```
 
 Invalid URL characters included in the value assigned to the `password` property
-are [percent-encoded](#whatwg-percent-encoding). Note that the selection of
-which characters to percent-encode may vary somewhat from what the
-[`url.parse()`][] and [`url.format()`][] methods would produce.
+are [percent-encoded][]. Note that the selection of which characters to
+percent-encode may vary somewhat from what the [`url.parse()`][] and
+[`url.format()`][] methods would produce.
 
 #### url.pathname
 
+* {String}
+
 Gets and sets the path portion of the URL.
 
 ```js
@@ -432,23 +519,54 @@ console.log(myURL.href);
 ```
 
 Invalid URL characters included in the value assigned to the `pathname`
-property are [percent-encoded](#whatwg-percent-encoding). Note that the
-selection of which characters to percent-encode may vary somewhat from what the
-[`url.parse()`][] and [`url.format()`][] methods would produce.
+property are [percent-encoded][]. Note that the selection of which characters
+to percent-encode may vary somewhat from what the [`url.parse()`][] and
+[`url.format()`][] methods would produce.
 
 #### url.port
 
-Gets and sets the port portion of the URL. When getting the port, the value
-is returned as a String.
+* {String}
+
+Gets and sets the port portion of the URL.
 
 ```js
 const myURL = new URL('https://example.org:8888');
 console.log(myURL.port);
   // Prints 8888
 
+// Default ports are automatically transformed to the empty string
+// (HTTPS protocol's default port is 443)
+myURL.port = '443';
+console.log(myURL.port);
+  // Prints the empty string
+console.log(myURL.href);
+  // Prints https://example.org/
+
 myURL.port = 1234;
+console.log(myURL.port);
+  // Prints 1234
 console.log(myURL.href);
-  // Prints https://example.org:1234
+  // Prints https://example.org:1234/
+
+// Completely invalid port strings are ignored
+myURL.port = 'abcd';
+console.log(myURL.port);
+  // Prints 1234
+
+// Leading numbers are treated as a port number
+myURL.port = '5678abcd';
+console.log(myURL.port);
+  // Prints 5678
+
+// Non-integers are truncated
+myURL.port = 1234.5678;
+console.log(myURL.port);
+  // Prints 1234
+
+// Out-of-range numbers are ignored
+myURL.port = 1e10;
+console.log(myURL.port);
+  // Prints 1234
 ```
 
 The port value may be set as either a number or as a String containing a number
@@ -456,10 +574,14 @@ in the range `0` to `65535` (inclusive). Setting the value to the default port
 of the `URL` objects given `protocol` will result in the `port` value becoming
 the empty string (`''`).
 
-Invalid URL port values assigned to the `port` property are ignored.
+If an invalid string is assigned to the `port` property, but it begins with a
+number, the leading number is assigned to `port`. Otherwise, or if the number
+lies outside the range denoted above, it is ignored.
 
 #### url.protocol
 
+* {String}
+
 Gets and sets the protocol portion of the URL.
 
 ```js
@@ -476,6 +598,8 @@ Invalid URL protocol values assigned to the `protocol` property are ignored.
 
 #### url.search
 
+* {String}
+
 Gets and sets the serialized query portion of the URL.
 
 ```js
@@ -489,17 +613,23 @@ console.log(myURL.href);
 ```
 
 Any invalid URL characters appearing in the value assigned the `search`
-property will be [percent-encoded](#whatwg-percent-encoding). Note that the
-selection of which characters to percent-encode may vary somewhat from what the
-[`url.parse()`][] and [`url.format()`][] methods would produce.
+property will be [percent-encoded][]. Note that the selection of which
+characters to percent-encode may vary somewhat from what the [`url.parse()`][]
+and [`url.format()`][] methods would produce.
 
 #### url.searchParams
 
-Gets a [`URLSearchParams`](#url_class_urlsearchparams) object representing the
-query parameters of the URL.
+* {URLSearchParams}
+
+Gets the [`URLSearchParams`][] object representing the query parameters of the
+URL. This property is read-only; to replace the entirety of query parameters of
+the URL, use the [`url.search`][] setter. See [`URLSearchParams`][]
+documentation for details.
 
 #### url.username
 
+* {String}
+
 Gets and sets the username portion of the URL.
 
 ```js
@@ -513,20 +643,31 @@ console.log(myURL.href);
 ```
 
 Any invalid URL characters appearing in the value assigned the `username`
-property will be [percent-encoded](#whatwg-percent-encoding). Note that the
-selection of which characters to percent-encode may vary somewhat from what the
-[`url.parse()`][] and [`url.format()`][] methods would produce.
+property will be [percent-encoded][]. Note that the selection of which
+characters to percent-encode may vary somewhat from what the [`url.parse()`][]
+and [`url.format()`][] methods would produce.
 
 #### url.toString()
 
+* Returns: {String}
+
 The `toString()` method on the `URL` object returns the serialized URL. The
-value returned is equivalent to that of `url.href`.
+value returned is equivalent to that of [`url.href`][].
+
+Because of the need for standard compliance, this method does not allow users
+to customize the serialization process of the URL. For more flexibility,
+[`require('url').format()`][] method might be of interest.
 
 ### Class: URLSearchParams
 
-The `URLSearchParams` object provides read and write access to the query of a
+The `URLSearchParams` API provides read and write access to the query of a
 `URL`.
 
+The WHATWG `URLSearchParams` interface and the [`querystring`][] module have
+similar purpose, but the purpose of the [`querystring`][] module is more
+general, as it allows the customization of delimiter characters (`&` and `=`).
+On the other hand, this API is designed purely for URL query strings.
+
 ```js
 const URL = require('url').URL;
 const myURL = new URL('https://example.org/?abc=123');
@@ -568,36 +709,41 @@ Returns an ES6 Iterator over each of the name-value pairs in the query.
 Each item of the iterator is a JavaScript Array. The first item of the Array
 is the `name`, the second item of the Array is the `value`.
 
-Alias for `urlSearchParams\[\@\@iterator\]()`.
+Alias for [`urlSearchParams[@@iterator]()`][`urlSearchParams@@iterator()`].
 
-#### urlSearchParams.forEach(fn)
+#### urlSearchParams.forEach(fn[, thisArg])
 
 * `fn` {Function} Function invoked for each name-value pair in the query.
+* `thisArg` {Object} Object to be used as `this` value for when `fn` is called
 
 Iterates over each name-value pair in the query and invokes the given function.
 
 ```js
 const URL = require('url').URL;
 const myURL = new URL('https://example.org/?a=b&c=d');
-myURL.searchParams.forEach((value, name) => {
-  console.log(name, value);
+myURL.searchParams.forEach((value, name, searchParams) => {
+  console.log(name, value, myURL.searchParams === searchParams);
 });
+  // Prints:
+  // a b true
+  // c d true
 ```
 
 #### urlSearchParams.get(name)
 
 * `name` {String}
-* Returns: {String} or `null` if there is no name-value pair with the given
-  `name`.
+* Returns: {String | Null}
 
-Returns the value of the first name-value pair whose name is `name`.
+Returns the value of the first name-value pair whose name is `name`. If there
+are no such pairs, `null` is returned.
 
 #### urlSearchParams.getAll(name)
 
 * `name` {String}
 * Returns: {Array}
 
-Returns the values of all name-value pairs whose name is `name`.
+Returns the values of all name-value pairs whose name is `name`. If there are
+no such pairs, an empty array is returned.
 
 #### urlSearchParams.has(name)
 
@@ -612,19 +758,64 @@ Returns `true` if there is at least one name-value pair whose name is `name`.
 
 Returns an ES6 Iterator over the names of each name-value pair.
 
+```js
+const { URLSearchParams } = require('url');
+const params = new URLSearchParams('foo=bar&foo=baz');
+for (const name of params.keys()) {
+  console.log(name);
+}
+  // Prints:
+  // foo
+  // foo
+```
+
 #### urlSearchParams.set(name, value)
 
 * `name` {String}
 * `value` {String}
 
-Remove any existing name-value pairs whose name is `name` and append a new
-name-value pair.
+Sets the value in the `URLSearchParams` object associated with `name` to
+`value`. If there are any pre-existing name-value pairs whose names are `name`,
+set the first such pair's value to `value` and remove all others. If not,
+append the name-value pair to the query string.
+
+```js
+const { URLSearchParams } = require('url');
+
+const params = new URLSearchParams();
+params.append('foo', 'bar');
+params.append('foo', 'baz');
+params.append('abc', 'def');
+console.log(params.toString());
+  // Prints foo=bar&foo=baz&abc=def
+
+params.set('foo', 'def');
+params.set('xyz', 'opq');
+console.log(params.toString());
+  // Prints foo=def&abc=def&xyz=opq
+```
+
+#### urlSearchParams.sort()
+
+Sort all existing name-value pairs in-place by their names. Sorting is done
+with a [stable sorting algorithm][], so relative order between name-value pairs
+with the same name is preserved.
+
+This method can be used, in particular, to increase cache hits.
+
+```js
+const params = new URLSearchParams('query[]=abc&type=search&query[]=123');
+params.sort();
+console.log(params.toString());
+  // Prints query%5B%5D=abc&query%5B%5D=123&type=search
+```
 
 #### urlSearchParams.toString()
 
 * Returns: {String}
 
-Returns the search parameters serialized as a URL-encoded string.
+Returns the search parameters serialized as a string, with characters
+percent-encoded where necessary.
 
 #### urlSearchParams.values()
 
@@ -632,7 +823,7 @@ Returns the search parameters serialized as a URL-encoded string.
 
 Returns an ES6 Iterator over the values of each name-value pair.
 
-#### urlSearchParams\[\@\@iterator\]()
+#### urlSearchParams\[@@iterator\]()
 
 * Returns: {Iterator}
 
@@ -640,7 +831,18 @@ Returns an ES6 Iterator over each of the name-value pairs in the query string.
 Each item of the iterator is a JavaScript Array. The first item of the Array
 is the `name`, the second item of the Array is the `value`.
 
-Alias for `urlSearchParams.entries()`.
+Alias for [`urlSearchParams.entries()`][].
+
+```js
+const { URLSearchParams } = require('url');
+const params = new URLSearchParams('foo=bar&xyz=baz');
+for (const [name, value] of params) {
+  console.log(name, value);
+}
+  // Prints:
+  // foo bar
+  // xyz baz
+```
 
 ### require('url').domainToAscii(domain)
 
@@ -711,4 +913,15 @@ console.log(myURL.origin);
 [examples of parsed URLs]: https://url.spec.whatwg.org/#example-url-parsing
 [`url.parse()`]: #url_url_parse_urlstring_parsequerystring_slashesdenotehost
 [`url.format()`]: #url_url_format_urlobject
+[`require('url').format()`]: #url_url_format_url_options
+[`url.toString()`]: #url_url_tostring
 [Punycode]: https://tools.ietf.org/html/rfc5891#section-4.4
+[WHATWG URL]: #url_the_whatwg_url_api
+[`new URL()`]: #url_constructor_new_url_input_base
+[`url.href`]: #url_url_href
+[`url.search`]: #url_url_search
+[percent-encoded]: #whatwg-percent-encoding
+[`URLSearchParams`]: #url_class_urlsearchparams
+[`urlSearchParams.entries()`]: #url_urlsearchparams_entries
+[`urlSearchParams@@iterator()`]: #url_urlsearchparams_iterator
+[stable sorting algorithm]: https://en.wikipedia.org/wiki/Sorting_algorithm#Stability
diff --git a/lib/internal/querystring.js b/lib/internal/querystring.js
new file mode 100644
index 00000000000000..2f8d77d3e9d2e7
--- /dev/null
+++ b/lib/internal/querystring.js
@@ -0,0 +1,15 @@
+'use strict';
+
+const hexTable = new Array(256);
+for (var i = 0; i < 256; ++i)
+  hexTable[i] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();
+
+// Instantiating this is faster than explicitly calling `Object.create(null)`
+// to get a "clean" empty object (tested with v8 v4.9).
+function StorageObject() {}
+StorageObject.prototype = Object.create(null);
+
+module.exports = {
+  hexTable,
+  StorageObject
+};
diff --git a/lib/internal/url.js b/lib/internal/url.js
index b79cc2303592a2..c799ed839b84d8 100644
--- a/lib/internal/url.js
+++ b/lib/internal/url.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const util = require('util');
+const { StorageObject } = require('internal/querystring');
 const binding = process.binding('url');
 const context = Symbol('context');
 const cannotBeBase = Symbol('cannot-be-base');
@@ -22,9 +23,6 @@ const IteratorPrototype = Object.getPrototypeOf(
   Object.getPrototypeOf([][Symbol.iterator]())
 );
 
-function StorageObject() {}
-StorageObject.prototype = Object.create(null);
-
 class OpaqueOrigin {
   toString() {
     return 'null';
@@ -528,73 +526,6 @@ Object.defineProperties(URL.prototype, {
   }
 });
 
-const hexTable = new Array(256);
-
-for (var i = 0; i < 256; ++i)
-  hexTable[i] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();
-function encodeAuth(str) {
-  // faster encodeURIComponent alternative for encoding auth uri components
-  var out = '';
-  var lastPos = 0;
-  for (var i = 0; i < str.length; ++i) {
-    var c = str.charCodeAt(i);
-
-    // These characters do not need escaping:
-    // ! - . _ ~
-    // ' ( ) * :
-    // digits
-    // alpha (uppercase)
-    // alpha (lowercase)
-    if (c === 0x21 || c === 0x2D || c === 0x2E || c === 0x5F || c === 0x7E ||
-        (c >= 0x27 && c <= 0x2A) ||
-        (c >= 0x30 && c <= 0x3A) ||
-        (c >= 0x41 && c <= 0x5A) ||
-        (c >= 0x61 && c <= 0x7A)) {
-      continue;
-    }
-
-    if (i - lastPos > 0)
-      out += str.slice(lastPos, i);
-
-    lastPos = i + 1;
-
-    // Other ASCII characters
-    if (c < 0x80) {
-      out += hexTable[c];
-      continue;
-    }
-
-    // Multi-byte characters ...
-    if (c < 0x800) {
-      out += hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)];
-      continue;
-    }
-    if (c < 0xD800 || c >= 0xE000) {
-      out += hexTable[0xE0 | (c >> 12)] +
-             hexTable[0x80 | ((c >> 6) & 0x3F)] +
-             hexTable[0x80 | (c & 0x3F)];
-      continue;
-    }
-    // Surrogate pair
-    ++i;
-    var c2;
-    if (i < str.length)
-      c2 = str.charCodeAt(i) & 0x3FF;
-    else
-      c2 = 0;
-    c = 0x10000 + (((c & 0x3FF) << 10) | c2);
-    out += hexTable[0xF0 | (c >> 18)] +
-           hexTable[0x80 | ((c >> 12) & 0x3F)] +
-           hexTable[0x80 | ((c >> 6) & 0x3F)] +
-           hexTable[0x80 | (c & 0x3F)];
-  }
-  if (lastPos === 0)
-    return str;
-  if (lastPos < str.length)
-    return out + str.slice(lastPos);
-  return out;
-}
-
 function update(url, params) {
   if (!url)
     return;
@@ -724,6 +655,35 @@ class URLSearchParams {
   }
 }
 
+// for merge sort
+function merge(out, start, mid, end, lBuffer, rBuffer) {
+  const sizeLeft = mid - start;
+  const sizeRight = end - mid;
+  var l, r, o;
+
+  for (l = 0; l < sizeLeft; l++)
+    lBuffer[l] = out[start + l];
+  for (r = 0; r < sizeRight; r++)
+    rBuffer[r] = out[mid + r];
+
+  l = 0;
+  r = 0;
+  o = start;
+  while (l < sizeLeft && r < sizeRight) {
+    if (lBuffer[l] <= rBuffer[r]) {
+      out[o++] = lBuffer[l++];
+      out[o++] = lBuffer[l++];
+    } else {
+      out[o++] = rBuffer[r++];
+      out[o++] = rBuffer[r++];
+    }
+  }
+  while (l < sizeLeft)
+    out[o++] = lBuffer[l++];
+  while (r < sizeRight)
+    out[o++] = rBuffer[r++];
+}
+
 defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
   append(name, value) {
     if (!this || !(this instanceof URLSearchParams)) {
@@ -855,6 +815,51 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
     update(this[context], this);
   },
 
+  sort() {
+    const a = this[searchParams];
+    const len = a.length;
+    if (len <= 2) {
+      return;
+    }
+
+    // arbitrary number found through testing
+    if (len < 100) {
+      // Simple stable in-place insertion sort
+      // Derived from v8/src/js/array.js
+      for (var i = 2; i < len; i += 2) {
+        var curKey = a[i];
+        var curVal = a[i + 1];
+        var j;
+        for (j = i - 2; j >= 0; j -= 2) {
+          if (a[j] > curKey) {
+            a[j + 2] = a[j];
+            a[j + 3] = a[j + 1];
+          } else {
+            break;
+          }
+        }
+        a[j + 2] = curKey;
+        a[j + 3] = curVal;
+      }
+    } else {
+      // Bottom-up iterative stable merge sort
+      const lBuffer = new Array(len);
+      const rBuffer = new Array(len);
+      for (var step = 2; step < len; step *= 2) {
+        for (var start = 0; start < len - 2; start += 2 * step) {
+          var mid = start + step;
+          var end = mid + step;
+          end = end < len ? end : len;
+          if (mid > end)
+            continue;
+          merge(a, start, mid, end, lBuffer, rBuffer);
+        }
+      }
+    }
+
+    update(this[context], this);
+  },
+
   // https://heycam.github.io/webidl/#es-iterators
   // Define entries here rather than [Symbol.iterator] as the function name
   // must be set to `entries`.
@@ -1138,6 +1143,6 @@ exports.URL = URL;
 exports.URLSearchParams = URLSearchParams;
 exports.domainToASCII = domainToASCII;
 exports.domainToUnicode = domainToUnicode;
-exports.encodeAuth = encodeAuth;
 exports.urlToOptions = urlToOptions;
 exports.formatSymbol = kFormat;
+exports.searchParamsSymbol = searchParams;
diff --git a/lib/querystring.js b/lib/querystring.js
index 5ccb5fa77b320f..8360857ba4bfce 100644
--- a/lib/querystring.js
+++ b/lib/querystring.js
@@ -1,5 +1,7 @@
 'use strict';
 
+const { Buffer } = require('buffer');
+const { StorageObject, hexTable } = require('internal/querystring');
 const QueryString = module.exports = {
   unescapeBuffer,
   // `unescape()` is a JS global, so we need to use a different local name
@@ -14,13 +16,6 @@ const QueryString = module.exports = {
   parse,
   decode: parse
 };
-const Buffer = require('buffer').Buffer;
-
-// This constructor is used to store parsed query string values. Instantiating
-// this is faster than explicitly calling `Object.create(null)` to get a
-// "clean" empty object (tested with v8 v4.9).
-function ParsedQueryString() {}
-ParsedQueryString.prototype = Object.create(null);
 
 const unhexTable = [
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0 - 15
@@ -116,10 +111,6 @@ function qsUnescape(s, decodeSpaces) {
 }
 
 
-const hexTable = [];
-for (var i = 0; i < 256; ++i)
-  hexTable[i] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();
-
 // These characters do not need escaping when generating query strings:
 // ! - . _ ~
 // ' ( ) *
@@ -263,7 +254,7 @@ const defEqCodes = [61]; // =
 
 // Parse a key/val string.
 function parse(qs, sep, eq, options) {
-  const obj = new ParsedQueryString();
+  const obj = new StorageObject();
 
   if (typeof qs !== 'string' || qs.length === 0) {
     return obj;
diff --git a/lib/url.js b/lib/url.js
index 9164d5991b7a67..845f22a44447d6 100644
--- a/lib/url.js
+++ b/lib/url.js
@@ -10,8 +10,8 @@ function importPunycode() {
 
 const { toASCII } = importPunycode();
 
+const { StorageObject, hexTable } = require('internal/querystring');
 const internalUrl = require('internal/url');
-const encodeAuth = internalUrl.encodeAuth;
 exports.parse = urlParse;
 exports.resolve = urlResolve;
 exports.resolveObject = urlResolveObject;
@@ -76,12 +76,6 @@ const slashedProtocol = {
 };
 const querystring = require('querystring');
 
-// This constructor is used to store parsed query string values. Instantiating
-// this is faster than explicitly calling `Object.create(null)` to get a
-// "clean" empty object (tested with v8 v4.9).
-function ParsedQueryString() {}
-ParsedQueryString.prototype = Object.create(null);
-
 function urlParse(url, parseQueryString, slashesDenoteHost) {
   if (url instanceof Url) return url;
 
@@ -190,7 +184,7 @@ Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
         }
       } else if (parseQueryString) {
         this.search = '';
-        this.query = new ParsedQueryString();
+        this.query = new StorageObject();
       }
       return this;
     }
@@ -380,7 +374,7 @@ Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
   } else if (parseQueryString) {
     // no query string, but parseQueryString still requested
     this.search = '';
-    this.query = new ParsedQueryString();
+    this.query = new StorageObject();
   }
 
   var firstIdx = (questionIdx !== -1 &&
@@ -959,3 +953,75 @@ function spliceOne(list, index) {
     list[i] = list[k];
   list.pop();
 }
+
+// These characters do not need escaping:
+// ! - . _ ~
+// ' ( ) * :
+// digits
+// alpha (uppercase)
+// alpha (lowercase)
+const noEscapeAuth = [
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x00 - 0x0F
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x10 - 0x1F
+  0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, // 0x20 - 0x2F
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, // 0x30 - 0x3F
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 - 0x4F
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 0x50 - 0x5F
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 - 0x6F
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0  // 0x70 - 0x7F
+];
+
+function encodeAuth(str) {
+  // faster encodeURIComponent alternative for encoding auth uri components
+  var out = '';
+  var lastPos = 0;
+  for (var i = 0; i < str.length; ++i) {
+    var c = str.charCodeAt(i);
+
+    // ASCII
+    if (c < 0x80) {
+      if (noEscapeAuth[c] === 1)
+        continue;
+      if (lastPos < i)
+        out += str.slice(lastPos, i);
+      lastPos = i + 1;
+      out += hexTable[c];
+      continue;
+    }
+
+    if (lastPos < i)
+      out += str.slice(lastPos, i);
+
+    // Multi-byte characters ...
+    if (c < 0x800) {
+      lastPos = i + 1;
+      out += hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)];
+      continue;
+    }
+    if (c < 0xD800 || c >= 0xE000) {
+      lastPos = i + 1;
+      out += hexTable[0xE0 | (c >> 12)] +
+             hexTable[0x80 | ((c >> 6) & 0x3F)] +
+             hexTable[0x80 | (c & 0x3F)];
+      continue;
+    }
+    // Surrogate pair
+    ++i;
+    var c2;
+    if (i < str.length)
+      c2 = str.charCodeAt(i) & 0x3FF;
+    else
+      c2 = 0;
+    lastPos = i + 1;
+    c = 0x10000 + (((c & 0x3FF) << 10) | c2);
+    out += hexTable[0xF0 | (c >> 18)] +
+           hexTable[0x80 | ((c >> 12) & 0x3F)] +
+           hexTable[0x80 | ((c >> 6) & 0x3F)] +
+           hexTable[0x80 | (c & 0x3F)];
+  }
+  if (lastPos === 0)
+    return str;
+  if (lastPos < str.length)
+    return out + str.slice(lastPos);
+  return out;
+}
diff --git a/node.gyp b/node.gyp
index 69b26d340d6666..d14e7ff8f13d62 100644
--- a/node.gyp
+++ b/node.gyp
@@ -92,6 +92,7 @@
       'lib/internal/process/stdio.js',
       'lib/internal/process/warning.js',
       'lib/internal/process.js',
+      'lib/internal/querystring.js',
       'lib/internal/readline.js',
       'lib/internal/repl.js',
       'lib/internal/socket_list.js',
diff --git a/test/common.js b/test/common.js
index 830206ea0f93ef..6cdf698fb5e839 100644
--- a/test/common.js
+++ b/test/common.js
@@ -588,3 +588,28 @@ Object.defineProperty(exports, 'hasIntl', {
     return process.binding('config').hasIntl;
   }
 });
+
+// https://github.com/w3c/testharness.js/blob/master/testharness.js
+exports.WPT = {
+  test: (fn, desc) => {
+    try {
+      fn();
+    } catch (err) {
+      if (err instanceof Error)
+        err.message = `In ${desc}:\n  ${err.message}`;
+      throw err;
+    }
+  },
+  assert_equals: assert.strictEqual,
+  assert_true: (value, message) => assert.strictEqual(value, true, message),
+  assert_false: (value, message) => assert.strictEqual(value, false, message),
+  assert_throws: (code, func, desc) => {
+    assert.throws(func, (err) => {
+      return typeof err === 'object' && 'name' in err && err.name === code.name;
+    }, desc);
+  },
+  assert_array_equals: assert.deepStrictEqual,
+  assert_unreached(desc) {
+    assert.fail(undefined, undefined, `Reached unreachable code: ${desc}`);
+  }
+};
diff --git a/test/fixtures/url-setter-tests.json b/test/fixtures/url-setter-tests.json
index 56a1c00a86fd45..4876b9940c1d98 100644
--- a/test/fixtures/url-setter-tests.json
+++ b/test/fixtures/url-setter-tests.json
@@ -1,5 +1,6 @@
 {
     "comment": [
+        "License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html",
         "## Tests for setters of https://url.spec.whatwg.org/#urlutils-members",
         "",
         "This file contains a JSON object.",
@@ -19,8 +20,7 @@
         "  get the attribute `key` (invoke its getter).",
         "  The returned string must be equal to `value`.",
         "",
-        "Note: the 'href' setter is already covered by urltestdata.json.",
-        "Source: https://github.com/w3c/web-platform-tests/tree/master/url"
+        "Note: the 'href' setter is already covered by urltestdata.json."
     ],
     "protocol": [
         {
@@ -103,7 +103,7 @@
             }
         },
         {
-            "comment": "Can’t switch from special scheme to non-special. Note: this may change, see https://github.com/whatwg/url/issues/104",
+            "comment": "Can’t switch from special scheme to non-special",
             "href": "http://example.net",
             "new_value": "b",
             "expected": {
@@ -111,6 +111,22 @@
                 "protocol": "http:"
             }
         },
+        {
+            "href": "https://example.net",
+            "new_value": "s",
+            "expected": {
+                "href": "https://example.net/",
+                "protocol": "https:"
+            }
+        },
+        {
+            "href": "ftp://example.net",
+            "new_value": "test",
+            "expected": {
+                "href": "ftp://example.net/",
+                "protocol": "ftp:"
+            }
+        },
         {
             "comment": "Cannot-be-a-base URL doesn’t have a host, but URL in a special scheme must.",
             "href": "mailto:me@example.net",
@@ -121,7 +137,7 @@
             }
         },
         {
-            "comment": "Can’t switch from non-special scheme to special. Note: this may change, see https://github.com/whatwg/url/issues/104",
+            "comment": "Can’t switch from non-special scheme to special",
             "href": "ssh://me@example.net",
             "new_value": "http",
             "expected": {
@@ -129,6 +145,30 @@
                 "protocol": "ssh:"
             }
         },
+        {
+            "href": "ssh://me@example.net",
+            "new_value": "gopher",
+            "expected": {
+                "href": "ssh://me@example.net/",
+                "protocol": "ssh:"
+            }
+        },
+        {
+            "href": "ssh://me@example.net",
+            "new_value": "file",
+            "expected": {
+                "href": "ssh://me@example.net/",
+                "protocol": "ssh:"
+            }
+        },
+        {
+            "href": "nonsense:///test",
+            "new_value": "https",
+            "expected": {
+                "href": "nonsense:///test",
+                "protocol": "nonsense:"
+            }
+        },
         {
             "comment": "Stuff after the first ':' is ignored",
             "href": "http://example.net",
diff --git a/test/fixtures/url-tests-additional.js b/test/fixtures/url-tests-additional.js
new file mode 100644
index 00000000000000..7e3282d17d091b
--- /dev/null
+++ b/test/fixtures/url-tests-additional.js
@@ -0,0 +1,87 @@
+module.exports = [
+  {
+    'url': 'tftp://foobar.com/someconfig;mode=netascii',
+    'protocol': 'tftp:',
+    'hostname': 'foobar.com',
+    'pathname': '/someconfig;mode=netascii'
+  },
+  {
+    'url': 'telnet://user:pass@foobar.com:23/',
+    'protocol': 'telnet:',
+    'username': 'user',
+    'password': 'pass',
+    'hostname': 'foobar.com',
+    'port': '23',
+    'pathname': '/'
+  },
+  {
+    'url': 'ut2004://10.10.10.10:7777/Index.ut2',
+    'protocol': 'ut2004:',
+    'hostname': '10.10.10.10',
+    'port': '7777',
+    'pathname': '/Index.ut2'
+  },
+  {
+    'url': 'redis://foo:bar@somehost:6379/0?baz=bam&qux=baz',
+    'protocol': 'redis:',
+    'username': 'foo',
+    'password': 'bar',
+    'hostname': 'somehost',
+    'port': '6379',
+    'pathname': '/0',
+    'search': '?baz=bam&qux=baz'
+  },
+  {
+    'url': 'rsync://foo@host:911/sup',
+    'protocol': 'rsync:',
+    'username': 'foo',
+    'hostname': 'host',
+    'port': '911',
+    'pathname': '/sup'
+  },
+  {
+    'url': 'git://github.com/foo/bar.git',
+    'protocol': 'git:',
+    'hostname': 'github.com',
+    'pathname': '/foo/bar.git'
+  },
+  {
+    'url': 'irc://myserver.com:6999/channel?passwd',
+    'protocol': 'irc:',
+    'hostname': 'myserver.com',
+    'port': '6999',
+    'pathname': '/channel',
+    'search': '?passwd'
+  },
+  {
+    'url': 'dns://fw.example.org:9999/foo.bar.org?type=TXT',
+    'protocol': 'dns:',
+    'hostname': 'fw.example.org',
+    'port': '9999',
+    'pathname': '/foo.bar.org',
+    'search': '?type=TXT'
+  },
+  {
+    'url': 'ldap://localhost:389/ou=People,o=JNDITutorial',
+    'protocol': 'ldap:',
+    'hostname': 'localhost',
+    'port': '389',
+    'pathname': '/ou=People,o=JNDITutorial'
+  },
+  {
+    'url': 'git+https://github.com/foo/bar',
+    'protocol': 'git+https:',
+    'hostname': 'github.com',
+    'pathname': '/foo/bar'
+  },
+  {
+    'url': 'urn:ietf:rfc:2648',
+    'protocol': 'urn:',
+    'pathname': 'ietf:rfc:2648'
+  },
+  {
+    'url': 'tag:joe@example.org,2001:foo/bar',
+    'protocol': 'tag:',
+    'pathname': 'joe@example.org,2001:foo/bar'
+  }
+];
diff --git a/test/parallel/test-url.js b/test/parallel/test-url.js
index fa43e1fd5f1330..6e42b5e78041dd 100644
--- a/test/parallel/test-url.js
+++ b/test/parallel/test-url.js
@@ -1231,6 +1231,15 @@ const formatTests = {
     protocol: 'file',
     pathname: '/home/user',
     path: '/home/user'
+  },
+
+  // surrogate in auth
+  'http://%F0%9F%98%80@www.example.com/': {
+    href: 'http://%F0%9F%98%80@www.example.com/',
+    protocol: 'http:',
+    auth: '\uD83D\uDE00',
+    hostname: 'www.example.com',
+    pathname: '/'
   }
 };
 for (const u in formatTests) {
diff --git a/test/parallel/test-whatwg-url-constructor.js b/test/parallel/test-whatwg-url-constructor.js
new file mode 100644
index 00000000000000..a8a8667fc47021
--- /dev/null
+++ b/test/parallel/test-whatwg-url-constructor.js
@@ -0,0 +1,142 @@
+'use strict';
+const common = require('../common');
+const path = require('path');
+const { URL, URLSearchParams } = require('url');
+const { test, assert_equals, assert_true, assert_throws } = common.WPT;
+
+if (!common.hasIntl) {
+  // A handful of the tests fail when ICU is not included.
+  common.skip('missing Intl');
+  return;
+}
+
+const request = {
+  response: require(path.join(common.fixturesDir, 'url-tests.json'))
+};
+
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/url-constructor.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+function runURLConstructorTests() {
+  // var setup = async_test("Loading data…")
+  // setup.step(function() {
+  //   var request = new XMLHttpRequest()
+  //   request.open("GET", "urltestdata.json")
+  //   request.send()
+  //   request.responseType = "json"
+  //   request.onload = setup.step_func(function() {
+         runURLTests(request.response)
+  //     setup.done()
+  //   })
+  // })
+}
+
+function bURL(url, base) {
+  return new URL(url, base || "about:blank")
+}
+
+
+function runURLTests(urltests) {
+  for(var i = 0, l = urltests.length; i < l; i++) {
+    var expected = urltests[i]
+    if (typeof expected === "string") continue // skip comments
+
+    test(function() {
+      if (expected.failure) {
+        assert_throws(new TypeError(), function() {
+          bURL(expected.input, expected.base)
+        })
+        return
+      }
+
+      var url = bURL(expected.input, expected.base)
+      assert_equals(url.href, expected.href, "href")
+      assert_equals(url.protocol, expected.protocol, "protocol")
+      assert_equals(url.username, expected.username, "username")
+      assert_equals(url.password, expected.password, "password")
+      assert_equals(url.host, expected.host, "host")
+      assert_equals(url.hostname, expected.hostname, "hostname")
+      assert_equals(url.port, expected.port, "port")
+      assert_equals(url.pathname, expected.pathname, "pathname")
+      assert_equals(url.search, expected.search, "search")
+      if ("searchParams" in expected) {
+        assert_true("searchParams" in url)
+      //   assert_equals(url.searchParams.toString(), expected.searchParams, "searchParams")
+      }
+      assert_equals(url.hash, expected.hash, "hash")
+    }, "Parsing: <" + expected.input + "> against <" + expected.base + ">")
+  }
+}
+
+function runURLSearchParamTests() {
+  test(function() {
+    var url = bURL('http://example.org/?a=b')
+    assert_true("searchParams" in url)
+    var searchParams = url.searchParams
+    assert_true(url.searchParams === searchParams, 'Object identity should hold.')
+  }, 'URL.searchParams getter')
+
+  test(function() {
+    var url = bURL('http://example.org/?a=b')
+    assert_true("searchParams" in url)
+    var searchParams = url.searchParams
+    assert_equals(searchParams.toString(), 'a=b')
+
+    searchParams.set('a', 'b')
+    assert_equals(url.searchParams.toString(), 'a=b')
+    assert_equals(url.search, '?a=b')
+    url.search = ''
+    assert_equals(url.searchParams.toString(), '')
+    assert_equals(url.search, '')
+    assert_equals(searchParams.toString(), '')
+  }, 'URL.searchParams updating, clearing')
+
+  test(function() {
+    'use strict'
+    var urlString = 'http://example.org'
+    var url = bURL(urlString)
+    assert_throws(TypeError(), function() { url.searchParams = new URLSearchParams(urlString) })
+  }, 'URL.searchParams setter, invalid values')
+
+  test(function() {
+    var url = bURL('http://example.org/file?a=b&c=d')
+    assert_true("searchParams" in url)
+    var searchParams = url.searchParams
+    assert_equals(url.search, '?a=b&c=d')
+    assert_equals(searchParams.toString(), 'a=b&c=d')
+
+    // Test that setting 'search' propagates to the URL object's query object.
+    url.search = 'e=f&g=h'
+    assert_equals(url.search, '?e=f&g=h')
+    assert_equals(searchParams.toString(), 'e=f&g=h')
+
+    // ..and same but with a leading '?'.
+    url.search = '?e=f&g=h'
+    assert_equals(url.search, '?e=f&g=h')
+    assert_equals(searchParams.toString(), 'e=f&g=h')
+
+    // And in the other direction, altering searchParams propagates
+    // back to 'search'.
+    // searchParams.append('i', ' j ')
+    // assert_equals(url.search, '?e=f&g=h&i=+j+')
+    // assert_equals(url.searchParams.toString(), 'e=f&g=h&i=+j+')
+    // assert_equals(searchParams.get('i'), ' j ')
+
+    // searchParams.set('e', 'updated')
+    // assert_equals(url.search, '?e=updated&g=h&i=+j+')
+    // assert_equals(searchParams.get('e'), 'updated')
+
+    // var url2 = bURL('http://example.org/file??a=b&c=d')
+    // assert_equals(url2.search, '??a=b&c=d')
+    // assert_equals(url2.searchParams.toString(), '%3Fa=b&c=d')
+
+    // url2.href = 'http://example.org/file??a=b'
+    // assert_equals(url2.search, '??a=b')
+    // assert_equals(url2.searchParams.toString(), '%3Fa=b')
+  }, 'URL.searchParams and URL.search setters, update propagation')
+}
+runURLSearchParamTests()
+runURLConstructorTests()
+/* eslint-enable */
diff --git a/test/parallel/test-whatwg-url-historical.js b/test/parallel/test-whatwg-url-historical.js
new file mode 100644
index 00000000000000..452c14fc77a319
--- /dev/null
+++ b/test/parallel/test-whatwg-url-historical.js
@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common');
+const URL = require('url').URL;
+const { test, assert_equals, assert_throws } = common.WPT;
+
+if (!common.hasIntl) {
+  // A handful of the tests fail when ICU is not included.
+  common.skip('missing Intl');
+  return;
+}
+
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/historical.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+// var objects = [
+//   [function() { return window.location }, "location object"],
+//   [function() { return document.createElement("a") }, "a element"],
+//   [function() { return document.createElement("area") }, "area element"],
+// ];
+
+// objects.forEach(function(o) {
+//   test(function() {
+//     var object = o[0]();
+//     assert_false("searchParams" in object,
+//                  o[1] + " should not have a searchParams attribute");
+//   }, "searchParams on " + o[1]);
+// });
+
+test(function() {
+  var url = new URL("./foo", "http://www.example.org");
+  assert_equals(url.href, "http://www.example.org/foo");
+  assert_throws(new TypeError(), function() {
+    url.href = "./bar";
+  });
+}, "Setting URL's href attribute and base URLs");
+
+test(function() {
+  assert_equals(URL.domainToASCII, undefined);
+}, "URL.domainToASCII should be undefined");
+
+test(function() {
+  assert_equals(URL.domainToUnicode, undefined);
+}, "URL.domainToUnicode should be undefined");
+/* eslint-enable */
diff --git a/test/parallel/test-whatwg-url-inspect.js b/test/parallel/test-whatwg-url-inspect.js
new file mode 100644
index 00000000000000..4c6c8771b9f8f4
--- /dev/null
+++ b/test/parallel/test-whatwg-url-inspect.js
@@ -0,0 +1,83 @@
+'use strict';
+
+const common = require('../common');
+const util = require('util');
+const URL = require('url').URL;
+const path = require('path');
+const assert = require('assert');
+
+if (!common.hasIntl) {
+  // A handful of the tests fail when ICU is not included.
+  common.skip('missing Intl');
+  return;
+}
+
+// Tests below are not from WPT.
+const tests = require(path.join(common.fixturesDir, 'url-tests.json'));
+const additional_tests = require(
+  path.join(common.fixturesDir, 'url-tests-additional.js'));
+
+const allTests = additional_tests.slice();
+for (const test of tests) {
+  if (test.failure || typeof test === 'string') continue;
+  allTests.push(test);
+}
+
+for (const test of allTests) {
+  const url = test.url ? new URL(test.url) : new URL(test.input, test.base);
+
+  for (const showHidden of [true, false]) {
+    const res = util.inspect(url, {
+      showHidden
+    });
+
+    const lines = res.split('\n');
+
+    const firstLine = lines[0];
+    assert.strictEqual(firstLine, 'URL {');
+
+    const lastLine = lines[lines.length - 1];
+    assert.strictEqual(lastLine, '}');
+
+    const innerLines = lines.slice(1, lines.length - 1);
+    const keys = new Set();
+    for (const line of innerLines) {
+      const i = line.indexOf(': ');
+      const k = line.slice(0, i).trim();
+      const v = line.slice(i + 2);
+      assert.strictEqual(keys.has(k), false, 'duplicate key found: ' + k);
+      keys.add(k);
+
+      const hidden = new Set([
+        'password',
+        'cannot-be-base',
+        'special'
+      ]);
+      if (showHidden) {
+        if (!hidden.has(k)) {
+          assert.strictEqual(v, url[k], k);
+          continue;
+        }
+
+        if (k === 'password') {
+          assert.strictEqual(v, url[k], k);
+        }
+        if (k === 'cannot-be-base') {
+          assert.ok(v.match(/^true$|^false$/), k + ' is Boolean');
+        }
+        if (k === 'special') {
+          assert.ok(v.match(/^true$|^false$/), k + ' is Boolean');
+        }
+        continue;
+      }
+
+      // showHidden is false
+      if (k === 'password') {
+        assert.strictEqual(v, '--------', k);
+        continue;
+      }
+      assert.strictEqual(hidden.has(k), false, 'no hidden keys: ' + k);
+      assert.strictEqual(v, url[k], k);
+    }
+  }
+}
diff --git a/test/parallel/test-whatwg-url-origin.js b/test/parallel/test-whatwg-url-origin.js
new file mode 100644
index 00000000000000..1186a1d1844147
--- /dev/null
+++ b/test/parallel/test-whatwg-url-origin.js
@@ -0,0 +1,52 @@
+'use strict';
+const common = require('../common');
+const path = require('path');
+const URL = require('url').URL;
+const { test, assert_equals } = common.WPT;
+
+if (!common.hasIntl) {
+  // A handful of the tests fail when ICU is not included.
+  common.skip('missing Intl');
+  return;
+}
+
+const request = {
+  response: require(path.join(common.fixturesDir, 'url-tests.json'))
+};
+
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/url-origin.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+function runURLOriginTests() {
+  // var setup = async_test("Loading data…")
+  // setup.step(function() {
+  //   var request = new XMLHttpRequest()
+  //   request.open("GET", "urltestdata.json")
+  //   request.send()
+  //   request.responseType = "json"
+  //   request.onload = setup.step_func(function() {
+         runURLTests(request.response)
+  //     setup.done()
+  //   })
+  // })
+}
+
+function bURL(url, base) {
+  return new URL(url, base || "about:blank")
+}
+
+function runURLTests(urltests) {
+  for(var i = 0, l = urltests.length; i < l; i++) {
+    var expected = urltests[i]
+    if (typeof expected === "string" || !("origin" in expected)) continue
+    test(function() {
+      var url = bURL(expected.input, expected.base)
+      assert_equals(url.origin, expected.origin, "origin")
+    }, "Origin parsing: <" + expected.input + "> against <" + expected.base + ">")
+  }
+}
+
+runURLOriginTests()
+/* eslint-enable */
diff --git a/test/parallel/test-whatwg-url-parsing.js b/test/parallel/test-whatwg-url-parsing.js
index f1fd2ae9051533..6775f79746a57d 100644
--- a/test/parallel/test-whatwg-url-parsing.js
+++ b/test/parallel/test-whatwg-url-parsing.js
@@ -1,7 +1,9 @@
 'use strict';
 
 const common = require('../common');
-const util = require('util');
+const URL = require('url').URL;
+const path = require('path');
+const assert = require('assert');
 
 if (!common.hasIntl) {
   // A handful of the tests fail when ICU is not included.
@@ -9,25 +11,9 @@ if (!common.hasIntl) {
   return;
 }
 
-const URL = require('url').URL;
-const path = require('path');
-const assert = require('assert');
+// Tests below are not from WPT.
 const tests = require(path.join(common.fixturesDir, 'url-tests.json'));
 
-function verifyURL(url, test) {
-  if (test.href) assert.strictEqual(url.href, test.href);
-  if (test.origin) assert.strictEqual(url.origin, test.origin);
-  if (test.protocol) assert.strictEqual(url.protocol, test.protocol);
-  if (test.username) assert.strictEqual(url.username, test.username);
-  if (test.password) assert.strictEqual(url.password, test.password);
-  if (test.hostname) assert.strictEqual(url.hostname, test.hostname);
-  if (test.host) assert.strictEqual(url.host, test.host);
-  if (test.port !== undefined) assert.strictEqual(url.port, test.port);
-  if (test.pathname) assert.strictEqual(url.pathname, test.pathname);
-  if (test.search) assert.strictEqual(url.search, test.search);
-  if (test.hash) assert.strictEqual(url.hash, test.hash);
-}
-
 for (const test of tests) {
   if (typeof test === 'string')
     continue;
@@ -35,167 +21,23 @@ for (const test of tests) {
   if (test.failure) {
     assert.throws(() => new URL(test.input, test.base),
                   /^TypeError: Invalid URL$/);
-  } else {
-    const url = new URL(test.input, test.base);
-    verifyURL(url, test);
   }
 }
 
-const additional_tests = [
-  {
-    'url': 'tftp://foobar.com/someconfig;mode=netascii',
-    'protocol': 'tftp:',
-    'hostname': 'foobar.com',
-    'pathname': '/someconfig;mode=netascii'
-  },
-  {
-    'url': 'telnet://user:pass@foobar.com:23/',
-    'protocol': 'telnet:',
-    'username': 'user',
-    'password': 'pass',
-    'hostname': 'foobar.com',
-    'port': '23',
-    'pathname': '/'
-  },
-  {
-    'url': 'ut2004://10.10.10.10:7777/Index.ut2',
-    'protocol': 'ut2004:',
-    'hostname': '10.10.10.10',
-    'port': '7777',
-    'pathname': '/Index.ut2'
-  },
-  {
-    'url': 'redis://foo:bar@somehost:6379/0?baz=bam&qux=baz',
-    'protocol': 'redis:',
-    'username': 'foo',
-    'password': 'bar',
-    'hostname': 'somehost',
-    'port': '6379',
-    'pathname': '/0',
-    'search': '?baz=bam&qux=baz'
-  },
-  {
-    'url': 'rsync://foo@host:911/sup',
-    'protocol': 'rsync:',
-    'username': 'foo',
-    'hostname': 'host',
-    'port': '911',
-    'pathname': '/sup'
-  },
-  {
-    'url': 'git://github.com/foo/bar.git',
-    'protocol': 'git:',
-    'hostname': 'github.com',
-    'pathname': '/foo/bar.git'
-  },
-  {
-    'url': 'irc://myserver.com:6999/channel?passwd',
-    'protocol': 'irc:',
-    'hostname': 'myserver.com',
-    'port': '6999',
-    'pathname': '/channel',
-    'search': '?passwd'
-  },
-  {
-    'url': 'dns://fw.example.org:9999/foo.bar.org?type=TXT',
-    'protocol': 'dns:',
-    'hostname': 'fw.example.org',
-    'port': '9999',
-    'pathname': '/foo.bar.org',
-    'search': '?type=TXT'
-  },
-  {
-    'url': 'ldap://localhost:389/ou=People,o=JNDITutorial',
-    'protocol': 'ldap:',
-    'hostname': 'localhost',
-    'port': '389',
-    'pathname': '/ou=People,o=JNDITutorial'
-  },
-  {
-    'url': 'git+https://github.com/foo/bar',
-    'protocol': 'git+https:',
-    'hostname': 'github.com',
-    'pathname': '/foo/bar'
-  },
-  {
-    'url': 'urn:ietf:rfc:2648',
-    'protocol': 'urn:',
-    'pathname': 'ietf:rfc:2648'
-  },
-  {
-    'url': 'tag:joe@example.org,2001:foo/bar',
-    'protocol': 'tag:',
-    'pathname': 'joe@example.org,2001:foo/bar'
-  }
-];
+const additional_tests = require(
+  path.join(common.fixturesDir, 'url-tests-additional.js'));
 
 for (const test of additional_tests) {
   const url = new URL(test.url);
-  verifyURL(url, test);
-}
-
-// test inspect
-const allTests = additional_tests.slice();
-for (const test of tests) {
-  if (test.failure || typeof test === 'string') continue;
-  allTests.push(test);
-}
-
-for (const test of allTests) {
-  const url = test.url ? new URL(test.url) : new URL(test.input, test.base);
-
-  for (const showHidden of [true, false]) {
-    const res = util.inspect(url, {
-      showHidden
-    });
-
-    const lines = res.split('\n');
-
-    const firstLine = lines[0];
-    assert.strictEqual(firstLine, 'URL {');
-
-    const lastLine = lines[lines.length - 1];
-    assert.strictEqual(lastLine, '}');
-
-    const innerLines = lines.slice(1, lines.length - 1);
-    const keys = new Set();
-    for (const line of innerLines) {
-      const i = line.indexOf(': ');
-      const k = line.slice(0, i).trim();
-      const v = line.slice(i + 2);
-      assert.strictEqual(keys.has(k), false, 'duplicate key found: ' + k);
-      keys.add(k);
-
-      const hidden = new Set([
-        'password',
-        'cannot-be-base',
-        'special'
-      ]);
-      if (showHidden) {
-        if (!hidden.has(k)) {
-          assert.strictEqual(v, url[k], k);
-          continue;
-        }
-
-        if (k === 'password') {
-          assert.strictEqual(v, url[k], k);
-        }
-        if (k === 'cannot-be-base') {
-          assert.ok(v.match(/^true$|^false$/), k + ' is Boolean');
-        }
-        if (k === 'special') {
-          assert.ok(v.match(/^true$|^false$/), k + ' is Boolean');
-        }
-        continue;
-      }
-
-      // showHidden is false
-      if (k === 'password') {
-        assert.strictEqual(v, '--------', k);
-        continue;
-      }
-      assert.strictEqual(hidden.has(k), false, 'no hidden keys: ' + k);
-      assert.strictEqual(v, url[k], k);
-    }
-  }
+  if (test.href) assert.strictEqual(url.href, test.href);
+  if (test.origin) assert.strictEqual(url.origin, test.origin);
+  if (test.protocol) assert.strictEqual(url.protocol, test.protocol);
+  if (test.username) assert.strictEqual(url.username, test.username);
+  if (test.password) assert.strictEqual(url.password, test.password);
+  if (test.hostname) assert.strictEqual(url.hostname, test.hostname);
+  if (test.host) assert.strictEqual(url.host, test.host);
+  if (test.port !== undefined) assert.strictEqual(url.port, test.port);
+  if (test.pathname) assert.strictEqual(url.pathname, test.pathname);
+  if (test.search) assert.strictEqual(url.search, test.search);
+  if (test.hash) assert.strictEqual(url.hash, test.hash);
 }
diff --git a/test/parallel/test-whatwg-url-properties.js b/test/parallel/test-whatwg-url-properties.js
index b762659fb6eadc..f093791b2de867 100644
--- a/test/parallel/test-whatwg-url-properties.js
+++ b/test/parallel/test-whatwg-url-properties.js
@@ -2,11 +2,11 @@
 'use strict';
 
 require('../common');
-
 const URL = require('url').URL;
 const assert = require('assert');
 const urlToOptions = require('internal/url').urlToOptions;
 
+// Tests below are not from WPT.
 const url = new URL('http://user:pass@foo.bar.com:21/aaa/zzz?l=24#test');
 const oldParams = url.searchParams;  // for test of [SameObject]
 
diff --git a/test/parallel/test-whatwg-url-searchparams-append.js b/test/parallel/test-whatwg-url-searchparams-append.js
index 44f49d20b09526..2e3a33b26307c3 100644
--- a/test/parallel/test-whatwg-url-searchparams-append.js
+++ b/test/parallel/test-whatwg-url-searchparams-append.js
@@ -1,55 +1,60 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const URLSearchParams = require('url').URLSearchParams;
+const { test, assert_equals, assert_true } = common.WPT;
 
-let params;
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/urlsearchparams-append.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+test(function() {
+    var params = new URLSearchParams();
+    params.append('a', 'b');
+    assert_equals(params + '', 'a=b');
+    params.append('a', 'b');
+    assert_equals(params + '', 'a=b&a=b');
+    params.append('a', 'c');
+    assert_equals(params + '', 'a=b&a=b&a=c');
+}, 'Append same name');
+test(function() {
+    var params = new URLSearchParams();
+    params.append('', '');
+    assert_equals(params + '', '=');
+    params.append('', '');
+    assert_equals(params + '', '=&=');
+}, 'Append empty strings');
+test(function() {
+    var params = new URLSearchParams();
+    params.append(null, null);
+    assert_equals(params + '', 'null=null');
+    params.append(null, null);
+    assert_equals(params + '', 'null=null&null=null');
+}, 'Append null');
+test(function() {
+    var params = new URLSearchParams();
+    params.append('first', 1);
+    params.append('second', 2);
+    params.append('third', '');
+    params.append('first', 10);
+    assert_true(params.has('first'), 'Search params object has name "first"');
+    assert_equals(params.get('first'), '1', 'Search params object has name "first" with value "1"');
+    assert_equals(params.get('second'), '2', 'Search params object has name "second" with value "2"');
+    assert_equals(params.get('third'), '', 'Search params object has name "third" with value ""');
+    params.append('first', 10);
+    assert_equals(params.get('first'), '1', 'Search params object has name "first" with value "1"');
+}, 'Append multiple');
+/* eslint-enable */
 
-// Append same name
-params = new URLSearchParams();
-params.append('a', 'b');
-assert.strictEqual(params + '', 'a=b');
-params.append('a', 'b');
-assert.strictEqual(params + '', 'a=b&a=b');
-params.append('a', 'c');
-assert.strictEqual(params + '', 'a=b&a=b&a=c');
-
-// Append empty strings
-params = new URLSearchParams();
-params.append('', '');
-assert.strictEqual(params + '', '=');
-params.append('', '');
-assert.strictEqual(params + '', '=&=');
-
-// Append null
-params = new URLSearchParams();
-params.append(null, null);
-assert.strictEqual(params + '', 'null=null');
-params.append(null, null);
-assert.strictEqual(params + '', 'null=null&null=null');
-
-// Append multiple
-params = new URLSearchParams();
-params.append('first', 1);
-params.append('second', 2);
-params.append('third', '');
-params.append('first', 10);
-assert.strictEqual(true, params.has('first'),
-                   'Search params object has name "first"');
-assert.strictEqual(params.get('first'), '1',
-                   'Search params object has name "first" with value "1"');
-assert.strictEqual(params.get('second'), '2',
-                   'Search params object has name "second" with value "2"');
-assert.strictEqual(params.get('third'), '',
-                   'Search params object has name "third" with value ""');
-params.append('first', 10);
-assert.strictEqual(params.get('first'), '1',
-                   'Search params object has name "first" with value "1"');
-
-assert.throws(() => {
-  params.append.call(undefined);
-}, /^TypeError: Value of `this` is not a URLSearchParams$/);
-assert.throws(() => {
-  params.set('a');
-}, /^TypeError: "name" and "value" arguments must be specified$/);
+// Tests below are not from WPT.
+{
+  const params = new URLSearchParams();
+  assert.throws(() => {
+    params.append.call(undefined);
+  }, /^TypeError: Value of `this` is not a URLSearchParams$/);
+  assert.throws(() => {
+    params.set('a');
+  }, /^TypeError: "name" and "value" arguments must be specified$/);
+}
diff --git a/test/parallel/test-whatwg-url-searchparams-constructor.js b/test/parallel/test-whatwg-url-searchparams-constructor.js
index 9b7ca1e4e9c54a..4e177ce59ccf20 100644
--- a/test/parallel/test-whatwg-url-searchparams-constructor.js
+++ b/test/parallel/test-whatwg-url-searchparams-constructor.js
@@ -1,130 +1,196 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const URLSearchParams = require('url').URLSearchParams;
+const {
+  test, assert_equals, assert_true, assert_false
+} = common.WPT;
 
-let params;
-
-// Basic URLSearchParams construction
-params = new URLSearchParams();
-assert.strictEqual(params + '', '');
-params = new URLSearchParams('');
-assert.strictEqual(params + '', '');
-params = new URLSearchParams('a=b');
-assert.strictEqual(params + '', 'a=b');
-params = new URLSearchParams(params);
-assert.strictEqual(params + '', 'a=b');
-
-// URLSearchParams constructor, empty.
-assert.throws(() => URLSearchParams(), TypeError,
-              'Calling \'URLSearchParams\' without \'new\' should throw.');
-// assert.throws(() => new URLSearchParams(DOMException.prototype), TypeError);
-assert.throws(() => {
-  new URLSearchParams({
-    toString() { throw new TypeError('Illegal invocation'); }
-  });
-}, TypeError);
-params = new URLSearchParams('');
-assert.notStrictEqual(params, null, 'constructor returned non-null value.');
-// eslint-disable-next-line no-proto
-assert.strictEqual(params.__proto__, URLSearchParams.prototype,
-                   'expected URLSearchParams.prototype as prototype.');
-params = new URLSearchParams({});
-// assert.strictEqual(params + '', '%5Bobject+Object%5D=');
-assert.strictEqual(params + '', '%5Bobject%20Object%5D=');
-
-// URLSearchParams constructor, string.
-params = new URLSearchParams('a=b');
-assert.notStrictEqual(params, null, 'constructor returned non-null value.');
-assert.strictEqual(true, params.has('a'),
-                   'Search params object has name "a"');
-assert.strictEqual(false, params.has('b'),
-                   'Search params object has not got name "b"');
-params = new URLSearchParams('a=b&c');
-assert.notStrictEqual(params, null, 'constructor returned non-null value.');
-assert.strictEqual(true, params.has('a'),
-                   'Search params object has name "a"');
-assert.strictEqual(true, params.has('c'),
-                   'Search params object has name "c"');
-params = new URLSearchParams('&a&&& &&&&&a+b=& c&m%c3%b8%c3%b8');
-assert.notStrictEqual(params, null, 'constructor returned non-null value.');
-assert.strictEqual(true, params.has('a'), 'Search params object has name "a"');
-assert.strictEqual(true, params.has('a b'),
-                   'Search params object has name "a b"');
-assert.strictEqual(true, params.has(' '),
-                   'Search params object has name " "');
-assert.strictEqual(false, params.has('c'),
-                   'Search params object did not have the name "c"');
-assert.strictEqual(true, params.has(' c'),
-                   'Search params object has name " c"');
-assert.strictEqual(true, params.has('møø'),
-                   'Search params object has name "møø"');
-
-// URLSearchParams constructor, object.
-const seed = new URLSearchParams('a=b&c=d');
-params = new URLSearchParams(seed);
-assert.notStrictEqual(params, null, 'constructor returned non-null value.');
-assert.strictEqual(params.get('a'), 'b');
-assert.strictEqual(params.get('c'), 'd');
-assert.strictEqual(false, params.has('d'));
-// The name-value pairs are copied when created; later updates
-// should not be observable.
-seed.append('e', 'f');
-assert.strictEqual(false, params.has('e'));
-params.append('g', 'h');
-assert.strictEqual(false, seed.has('g'));
-
-// Parse +
-params = new URLSearchParams('a=b+c');
-assert.strictEqual(params.get('a'), 'b c');
-params = new URLSearchParams('a+b=c');
-assert.strictEqual(params.get('a b'), 'c');
-
-// Parse space
-params = new URLSearchParams('a=b c');
-assert.strictEqual(params.get('a'), 'b c');
-params = new URLSearchParams('a b=c');
-assert.strictEqual(params.get('a b'), 'c');
-
-// Parse %20
-params = new URLSearchParams('a=b%20c');
-assert.strictEqual(params.get('a'), 'b c');
-params = new URLSearchParams('a%20b=c');
-assert.strictEqual(params.get('a b'), 'c');
-
-// Parse \0
-params = new URLSearchParams('a=b\0c');
-assert.strictEqual(params.get('a'), 'b\0c');
-params = new URLSearchParams('a\0b=c');
-assert.strictEqual(params.get('a\0b'), 'c');
-
-// Parse %00
-params = new URLSearchParams('a=b%00c');
-assert.strictEqual(params.get('a'), 'b\0c');
-params = new URLSearchParams('a%00b=c');
-assert.strictEqual(params.get('a\0b'), 'c');
-
-// Parse \u2384 (Unicode Character 'COMPOSITION SYMBOL' (U+2384))
-params = new URLSearchParams('a=b\u2384');
-assert.strictEqual(params.get('a'), 'b\u2384');
-params = new URLSearchParams('a\u2384b=c');
-assert.strictEqual(params.get('a\u2384b'), 'c');
-
-// Parse %e2%8e%84 (Unicode Character 'COMPOSITION SYMBOL' (U+2384))
-params = new URLSearchParams('a=b%e2%8e%84');
-assert.strictEqual(params.get('a'), 'b\u2384');
-params = new URLSearchParams('a%e2%8e%84b=c');
-assert.strictEqual(params.get('a\u2384b'), 'c');
-
-// Parse \uD83D\uDCA9 (Unicode Character 'PILE OF POO' (U+1F4A9))
-params = new URLSearchParams('a=b\uD83D\uDCA9c');
-assert.strictEqual(params.get('a'), 'b\uD83D\uDCA9c');
-params = new URLSearchParams('a\uD83D\uDCA9b=c');
-assert.strictEqual(params.get('a\uD83D\uDCA9b'), 'c');
-
-// Parse %f0%9f%92%a9 (Unicode Character 'PILE OF POO' (U+1F4A9))
-params = new URLSearchParams('a=b%f0%9f%92%a9c');
-assert.strictEqual(params.get('a'), 'b\uD83D\uDCA9c');
-params = new URLSearchParams('a%f0%9f%92%a9b=c');
-assert.strictEqual(params.get('a\uD83D\uDCA9b'), 'c');
+/* eslint-disable */
+var params;  // Strict mode fix for WPT.
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/405394a/url/urlsearchparams-constructor.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+test(function() {
+    var params = new URLSearchParams();
+    assert_equals(params + '', '');
+    params = new URLSearchParams('');
+    assert_equals(params + '', '');
+    params = new URLSearchParams('a=b');
+    assert_equals(params + '', 'a=b');
+    params = new URLSearchParams(params);
+    assert_equals(params + '', 'a=b');
+}, 'Basic URLSearchParams construction');
+
+test(function() {
+    var params = new URLSearchParams()
+    assert_equals(params.toString(), "")
+}, "URLSearchParams constructor, no arguments")
+
+// test(() => {
+//     params = new URLSearchParams(DOMException.prototype);
+//     assert_equals(params.toString(), "INDEX_SIZE_ERR=1&DOMSTRING_SIZE_ERR=2&HIERARCHY_REQUEST_ERR=3&WRONG_DOCUMENT_ERR=4&INVALID_CHARACTER_ERR=5&NO_DATA_ALLOWED_ERR=6&NO_MODIFICATION_ALLOWED_ERR=7&NOT_FOUND_ERR=8&NOT_SUPPORTED_ERR=9&INUSE_ATTRIBUTE_ERR=10&INVALID_STATE_ERR=11&SYNTAX_ERR=12&INVALID_MODIFICATION_ERR=13&NAMESPACE_ERR=14&INVALID_ACCESS_ERR=15&VALIDATION_ERR=16&TYPE_MISMATCH_ERR=17&SECURITY_ERR=18&NETWORK_ERR=19&ABORT_ERR=20&URL_MISMATCH_ERR=21&QUOTA_EXCEEDED_ERR=22&TIMEOUT_ERR=23&INVALID_NODE_TYPE_ERR=24&DATA_CLONE_ERR=25")
+// }, "URLSearchParams constructor, DOMException.prototype as argument")
+
+test(() => {
+    params = new URLSearchParams('');
+    assert_true(params != null, 'constructor returned non-null value.');
+    assert_equals(params.__proto__, URLSearchParams.prototype, 'expected URLSearchParams.prototype as prototype.');
+}, "URLSearchParams constructor, empty string as argument")
+
+// test(() => {
+//     params = new URLSearchParams({});
+//     assert_equals(params + '', "");
+// }, 'URLSearchParams constructor, {} as argument');
+
+test(function() {
+    var params = new URLSearchParams('a=b');
+    assert_true(params != null, 'constructor returned non-null value.');
+    assert_true(params.has('a'), 'Search params object has name "a"');
+    assert_false(params.has('b'), 'Search params object has not got name "b"');
+    var params = new URLSearchParams('a=b&c');
+    assert_true(params != null, 'constructor returned non-null value.');
+    assert_true(params.has('a'), 'Search params object has name "a"');
+    assert_true(params.has('c'), 'Search params object has name "c"');
+    var params = new URLSearchParams('&a&&& &&&&&a+b=& c&m%c3%b8%c3%b8');
+    assert_true(params != null, 'constructor returned non-null value.');
+    assert_true(params.has('a'), 'Search params object has name "a"');
+    assert_true(params.has('a b'), 'Search params object has name "a b"');
+    assert_true(params.has(' '), 'Search params object has name " "');
+    assert_false(params.has('c'), 'Search params object did not have the name "c"');
+    assert_true(params.has(' c'), 'Search params object has name " c"');
+    assert_true(params.has('møø'), 'Search params object has name "møø"');
+}, 'URLSearchParams constructor, string.');
+
+test(function() {
+    var seed = new URLSearchParams('a=b&c=d');
+    var params = new URLSearchParams(seed);
+    assert_true(params != null, 'constructor returned non-null value.');
+    assert_equals(params.get('a'), 'b');
+    assert_equals(params.get('c'), 'd');
+    assert_false(params.has('d'));
+    // The name-value pairs are copied when created; later updates
+    // should not be observable.
+    seed.append('e', 'f');
+    assert_false(params.has('e'));
+    params.append('g', 'h');
+    assert_false(seed.has('g'));
+}, 'URLSearchParams constructor, object.');
+
+test(function() {
+    var params = new URLSearchParams('a=b+c');
+    assert_equals(params.get('a'), 'b c');
+    params = new URLSearchParams('a+b=c');
+    assert_equals(params.get('a b'), 'c');
+}, 'Parse +');
+
+test(function() {
+    var params = new URLSearchParams('a=b c');
+    assert_equals(params.get('a'), 'b c');
+    params = new URLSearchParams('a b=c');
+    assert_equals(params.get('a b'), 'c');
+}, 'Parse space');
+
+test(function() {
+    var params = new URLSearchParams('a=b%20c');
+    assert_equals(params.get('a'), 'b c');
+    params = new URLSearchParams('a%20b=c');
+    assert_equals(params.get('a b'), 'c');
+}, 'Parse %20');
+
+test(function() {
+    var params = new URLSearchParams('a=b\0c');
+    assert_equals(params.get('a'), 'b\0c');
+    params = new URLSearchParams('a\0b=c');
+    assert_equals(params.get('a\0b'), 'c');
+}, 'Parse \\0');
+
+test(function() {
+    var params = new URLSearchParams('a=b%00c');
+    assert_equals(params.get('a'), 'b\0c');
+    params = new URLSearchParams('a%00b=c');
+    assert_equals(params.get('a\0b'), 'c');
+}, 'Parse %00');
+
+test(function() {
+    var params = new URLSearchParams('a=b\u2384');
+    assert_equals(params.get('a'), 'b\u2384');
+    params = new URLSearchParams('a\u2384b=c');
+    assert_equals(params.get('a\u2384b'), 'c');
+}, 'Parse \u2384');  // Unicode Character 'COMPOSITION SYMBOL' (U+2384)
+
+test(function() {
+    var params = new URLSearchParams('a=b%e2%8e%84');
+    assert_equals(params.get('a'), 'b\u2384');
+    params = new URLSearchParams('a%e2%8e%84b=c');
+    assert_equals(params.get('a\u2384b'), 'c');
+}, 'Parse %e2%8e%84');  // Unicode Character 'COMPOSITION SYMBOL' (U+2384)
+
+test(function() {
+    var params = new URLSearchParams('a=b\uD83D\uDCA9c');
+    assert_equals(params.get('a'), 'b\uD83D\uDCA9c');
+    params = new URLSearchParams('a\uD83D\uDCA9b=c');
+    assert_equals(params.get('a\uD83D\uDCA9b'), 'c');
+}, 'Parse \uD83D\uDCA9');  // Unicode Character 'PILE OF POO' (U+1F4A9)
+
+test(function() {
+    var params = new URLSearchParams('a=b%f0%9f%92%a9c');
+    assert_equals(params.get('a'), 'b\uD83D\uDCA9c');
+    params = new URLSearchParams('a%f0%9f%92%a9b=c');
+    assert_equals(params.get('a\uD83D\uDCA9b'), 'c');
+}, 'Parse %f0%9f%92%a9');  // Unicode Character 'PILE OF POO' (U+1F4A9)
+
+// test(function() {
+//     var params = new URLSearchParams([]);
+//     assert_true(params != null, 'constructor returned non-null value.');
+//     params = new URLSearchParams([['a', 'b'], ['c', 'd']]);
+//     assert_equals(params.get("a"), "b");
+//     assert_equals(params.get("c"), "d");
+//     assert_throws(new TypeError(), function() { new URLSearchParams([[1]]); });
+//     assert_throws(new TypeError(), function() { new URLSearchParams([[1,2,3]]); });
+// }, "Constructor with sequence of sequences of strings");
+
+// [
+//   { "input": {"+": "%C2"}, "output": [[" ", "\uFFFD"]], "name": "object with +" },
+//   { "input": {c: "x", a: "?"}, "output": [["c", "x"], ["a", "?"]], "name": "object with two keys" },
+//   { "input": [["c", "x"], ["a", "?"]], "output": [["c", "x"], ["a", "?"]], "name": "array with two keys" }
+// ].forEach((val) => {
+//     test(() => {
+//         let params = new URLSearchParams(val.input),
+//             i = 0
+//         for (let param of params) {
+//             assert_array_equals(param, val.output[i])
+//             i++
+//         }
+//     }, "Construct with " + val.name)
+// })
+
+// test(() => {
+//   params = new URLSearchParams()
+//   params[Symbol.iterator] = function *() {
+//     yield ["a", "b"]
+//   }
+//   let params2 = new URLSearchParams(params)
+//   assert_equals(params2.get("a"), "b")
+// }, "Custom [Symbol.iterator]")
+/* eslint-enable */
+
+// Tests below are not from WPT.
+{
+//   assert.throws(() => {
+//     new URLSearchParams({
+//         toString() { throw new TypeError('Illegal invocation'); }
+//     });
+//   }, TypeError);
+}
+
+{
+  let params;
+  // URLSearchParams constructor, undefined and null as argument
+  params = new URLSearchParams(undefined);
+  assert.strictEqual(params.toString(), '');
+  params = new URLSearchParams(null);
+  assert.strictEqual(params.toString(), 'null=');
+}
diff --git a/test/parallel/test-whatwg-url-searchparams-delete.js b/test/parallel/test-whatwg-url-searchparams-delete.js
index f39917e8e37712..c6235263f22bad 100644
--- a/test/parallel/test-whatwg-url-searchparams-delete.js
+++ b/test/parallel/test-whatwg-url-searchparams-delete.js
@@ -1,52 +1,57 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
-const url = require('url');
-const URL = url.URL;
-const URLSearchParams = url.URLSearchParams;
+const { URL, URLSearchParams } = require('url');
+const { test, assert_equals, assert_true, assert_false } = common.WPT;
 
-let params;
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/urlsearchparams-delete.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+test(function() {
+    var params = new URLSearchParams('a=b&c=d');
+    params.delete('a');
+    assert_equals(params + '', 'c=d');
+    params = new URLSearchParams('a=a&b=b&a=a&c=c');
+    params.delete('a');
+    assert_equals(params + '', 'b=b&c=c');
+    params = new URLSearchParams('a=a&=&b=b&c=c');
+    params.delete('');
+    assert_equals(params + '', 'a=a&b=b&c=c');
+    params = new URLSearchParams('a=a&null=null&b=b');
+    params.delete(null);
+    assert_equals(params + '', 'a=a&b=b');
+    params = new URLSearchParams('a=a&undefined=undefined&b=b');
+    params.delete(undefined);
+    assert_equals(params + '', 'a=a&b=b');
+}, 'Delete basics');
 
-// Delete basics
-params = new URLSearchParams('a=b&c=d');
-params.delete('a');
-assert.strictEqual(params + '', 'c=d');
-params = new URLSearchParams('a=a&b=b&a=a&c=c');
-params.delete('a');
-assert.strictEqual(params + '', 'b=b&c=c');
-params = new URLSearchParams('a=a&=&b=b&c=c');
-params.delete('');
-assert.strictEqual(params + '', 'a=a&b=b&c=c');
-params = new URLSearchParams('a=a&null=null&b=b');
-params.delete(null);
-assert.strictEqual(params + '', 'a=a&b=b');
-params = new URLSearchParams('a=a&undefined=undefined&b=b');
-params.delete(undefined);
-assert.strictEqual(params + '', 'a=a&b=b');
+test(function() {
+    var params = new URLSearchParams();
+    params.append('first', 1);
+    assert_true(params.has('first'), 'Search params object has name "first"');
+    assert_equals(params.get('first'), '1', 'Search params object has name "first" with value "1"');
+    params.delete('first');
+    assert_false(params.has('first'), 'Search params object has no "first" name');
+    params.append('first', 1);
+    params.append('first', 10);
+    params.delete('first');
+    assert_false(params.has('first'), 'Search params object has no "first" name');
+}, 'Deleting appended multiple');
+/* eslint-enable */
 
-// Deleting appended multiple
-params = new URLSearchParams();
-params.append('first', 1);
-assert.strictEqual(true, params.has('first'),
-                   'Search params object has name "first"');
-assert.strictEqual(params.get('first'), '1',
-                   'Search params object has name "first" with value "1"');
-params.delete('first');
-assert.strictEqual(false, params.has('first'),
-                   'Search params object has no "first" name');
-params.append('first', 1);
-params.append('first', 10);
-params.delete('first');
-assert.strictEqual(false, params.has('first'),
-                   'Search params object has no "first" name');
-
-assert.throws(() => {
-  params.delete.call(undefined);
-}, /^TypeError: Value of `this` is not a URLSearchParams$/);
-assert.throws(() => {
-  params.delete();
-}, /^TypeError: "name" argument must be specified$/);
+// Tests below are not from WPT.
+{
+  const params = new URLSearchParams();
+  assert.throws(() => {
+    params.delete.call(undefined);
+  }, /^TypeError: Value of `this` is not a URLSearchParams$/);
+  assert.throws(() => {
+    params.delete();
+  }, /^TypeError: "name" argument must be specified$/);
+}
 
 // https://github.com/nodejs/node/issues/10480
 // Emptying searchParams should correctly update url's query
diff --git a/test/parallel/test-whatwg-url-searchparams-entries.js b/test/parallel/test-whatwg-url-searchparams-entries.js
index 97f60ceb17fa29..c8b8d129b01ad9 100644
--- a/test/parallel/test-whatwg-url-searchparams-entries.js
+++ b/test/parallel/test-whatwg-url-searchparams-entries.js
@@ -4,6 +4,7 @@ require('../common');
 const assert = require('assert');
 const URLSearchParams = require('url').URLSearchParams;
 
+// Tests below are not from WPT.
 const params = new URLSearchParams('a=b&c=d');
 const entries = params.entries();
 assert.strictEqual(typeof entries[Symbol.iterator], 'function');
diff --git a/test/parallel/test-whatwg-url-searchparams-foreach.js b/test/parallel/test-whatwg-url-searchparams-foreach.js
index 6adbb5789b0c11..9181371ae51c89 100644
--- a/test/parallel/test-whatwg-url-searchparams-foreach.js
+++ b/test/parallel/test-whatwg-url-searchparams-foreach.js
@@ -2,42 +2,53 @@
 
 const common = require('../common');
 const assert = require('assert');
-const url = require('url');
-const URL = url.URL;
-const URLSearchParams = url.URLSearchParams;
+const { URL, URLSearchParams } = require('url');
+const { test, assert_array_equals, assert_unreached } = common.WPT;
 
-let a, b, i;
+/* eslint-disable */
+var i;  // Strict mode fix for WPT.
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/a8b2b1e/url/urlsearchparams-foreach.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+test(function() {
+    var params = new URLSearchParams('a=1&b=2&c=3');
+    var keys = [];
+    var values = [];
+    params.forEach(function(value, key) {
+        keys.push(key);
+        values.push(value);
+    });
+    assert_array_equals(keys, ['a', 'b', 'c']);
+    assert_array_equals(values, ['1', '2', '3']);
+}, "ForEach Check");
 
-// ForEach Check
-const params = new URLSearchParams('a=1&b=2&c=3');
-const keys = [];
-const values = [];
-params.forEach((value, key) => {
-  keys.push(key);
-  values.push(value);
-});
-assert.deepStrictEqual(keys, ['a', 'b', 'c']);
-assert.deepStrictEqual(values, ['1', '2', '3']);
+test(function() {
+    let a = new URL("http://a.b/c?a=1&b=2&c=3&d=4");
+    let b = a.searchParams;
+    var c = [];
+    for (i of b) {
+        a.search = "x=1&y=2&z=3";
+        c.push(i);
+    }
+    assert_array_equals(c[0], ["a","1"]);
+    assert_array_equals(c[1], ["y","2"]);
+    assert_array_equals(c[2], ["z","3"]);
+}, "For-of Check");
 
-// For-of Check
-a = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
-b = a.searchParams;
-const c = [];
-for (i of b) {
-  a.search = 'x=1&y=2&z=3';
-  c.push(i);
-}
-assert.deepStrictEqual(c[0], ['a', '1']);
-assert.deepStrictEqual(c[1], ['y', '2']);
-assert.deepStrictEqual(c[2], ['z', '3']);
+test(function() {
+    let a = new URL("http://a.b/c");
+    let b = a.searchParams;
+    for (i of b) {
+        assert_unreached(i);
+    }
+}, "empty");
+/* eslint-enable */
 
-// empty
-a = new URL('http://a.b/c');
-b = a.searchParams;
-for (i of b) {
-  common.fail('should not be reached');
+// Tests below are not from WPT.
+{
+  const params = new URLSearchParams();
+  assert.throws(() => {
+    params.forEach.call(undefined);
+  }, /^TypeError: Value of `this` is not a URLSearchParams$/);
 }
-
-assert.throws(() => {
-  params.forEach.call(undefined);
-}, /^TypeError: Value of `this` is not a URLSearchParams$/);
diff --git a/test/parallel/test-whatwg-url-searchparams-get.js b/test/parallel/test-whatwg-url-searchparams-get.js
index 95c3f47df5eabb..3a46993214a997 100644
--- a/test/parallel/test-whatwg-url-searchparams-get.js
+++ b/test/parallel/test-whatwg-url-searchparams-get.js
@@ -1,38 +1,45 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const URLSearchParams = require('url').URLSearchParams;
+const { test, assert_equals, assert_true } = common.WPT;
 
-let params;
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/urlsearchparams-get.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+test(function() {
+    var params = new URLSearchParams('a=b&c=d');
+    assert_equals(params.get('a'), 'b');
+    assert_equals(params.get('c'), 'd');
+    assert_equals(params.get('e'), null);
+    params = new URLSearchParams('a=b&c=d&a=e');
+    assert_equals(params.get('a'), 'b');
+    params = new URLSearchParams('=b&c=d');
+    assert_equals(params.get(''), 'b');
+    params = new URLSearchParams('a=&c=d&a=e');
+    assert_equals(params.get('a'), '');
+}, 'Get basics');
 
-// Get basics
-params = new URLSearchParams('a=b&c=d');
-assert.strictEqual(params.get('a'), 'b');
-assert.strictEqual(params.get('c'), 'd');
-assert.strictEqual(params.get('e'), null);
-params = new URLSearchParams('a=b&c=d&a=e');
-assert.strictEqual(params.get('a'), 'b');
-params = new URLSearchParams('=b&c=d');
-assert.strictEqual(params.get(''), 'b');
-params = new URLSearchParams('a=&c=d&a=e');
-assert.strictEqual(params.get('a'), '');
+test(function() {
+    var params = new URLSearchParams('first=second&third&&');
+    assert_true(params != null, 'constructor returned non-null value.');
+    assert_true(params.has('first'), 'Search params object has name "first"');
+    assert_equals(params.get('first'), 'second', 'Search params object has name "first" with value "second"');
+    assert_equals(params.get('third'), '', 'Search params object has name "third" with the empty value.');
+    assert_equals(params.get('fourth'), null, 'Search params object has no "fourth" name and value.');
+}, 'More get() basics');
+/* eslint-enable */
 
-// More get() basics
-params = new URLSearchParams('first=second&third&&');
-assert.notStrictEqual(params, null, 'constructor returned non-null value.');
-assert.strictEqual(true, params.has('first'),
-                   'Search params object has name "first"');
-assert.strictEqual(params.get('first'), 'second',
-                   'Search params object has name "first" with value "second"');
-assert.strictEqual(params.get('third'), '',
-                   'Search params object has name "third" with empty value.');
-assert.strictEqual(params.get('fourth'), null,
-                   'Search params object has no "fourth" name and value.');
-
-assert.throws(() => {
-  params.get.call(undefined);
-}, /^TypeError: Value of `this` is not a URLSearchParams$/);
-assert.throws(() => {
-  params.get();
-}, /^TypeError: "name" argument must be specified$/);
+// Tests below are not from WPT.
+{
+  const params = new URLSearchParams();
+  assert.throws(() => {
+    params.get.call(undefined);
+  }, /^TypeError: Value of `this` is not a URLSearchParams$/);
+  assert.throws(() => {
+    params.get();
+  }, /^TypeError: "name" argument must be specified$/);
+}
diff --git a/test/parallel/test-whatwg-url-searchparams-getall.js b/test/parallel/test-whatwg-url-searchparams-getall.js
index 52f581c0158a90..df055e009e7e4d 100644
--- a/test/parallel/test-whatwg-url-searchparams-getall.js
+++ b/test/parallel/test-whatwg-url-searchparams-getall.js
@@ -1,45 +1,49 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const URLSearchParams = require('url').URLSearchParams;
+const { test, assert_equals, assert_true, assert_array_equals } = common.WPT;
 
-let params;
-let matches;
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/urlsearchparams-getall.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+test(function() {
+    var params = new URLSearchParams('a=b&c=d');
+    assert_array_equals(params.getAll('a'), ['b']);
+    assert_array_equals(params.getAll('c'), ['d']);
+    assert_array_equals(params.getAll('e'), []);
+    params = new URLSearchParams('a=b&c=d&a=e');
+    assert_array_equals(params.getAll('a'), ['b', 'e']);
+    params = new URLSearchParams('=b&c=d');
+    assert_array_equals(params.getAll(''), ['b']);
+    params = new URLSearchParams('a=&c=d&a=e');
+    assert_array_equals(params.getAll('a'), ['', 'e']);
+}, 'getAll() basics');
 
-// getAll() basics
-params = new URLSearchParams('a=b&c=d');
-assert.deepStrictEqual(params.getAll('a'), ['b']);
-assert.deepStrictEqual(params.getAll('c'), ['d']);
-assert.deepStrictEqual(params.getAll('e'), []);
-params = new URLSearchParams('a=b&c=d&a=e');
-assert.deepStrictEqual(params.getAll('a'), ['b', 'e']);
-params = new URLSearchParams('=b&c=d');
-assert.deepStrictEqual(params.getAll(''), ['b']);
-params = new URLSearchParams('a=&c=d&a=e');
-assert.deepStrictEqual(params.getAll('a'), ['', 'e']);
+test(function() {
+    var params = new URLSearchParams('a=1&a=2&a=3&a');
+    assert_true(params.has('a'), 'Search params object has name "a"');
+    var matches = params.getAll('a');
+    assert_true(matches && matches.length == 4, 'Search params object has values for name "a"');
+    assert_array_equals(matches, ['1', '2', '3', ''], 'Search params object has expected name "a" values');
+    params.set('a', 'one');
+    assert_equals(params.get('a'), 'one', 'Search params object has name "a" with value "one"');
+    var matches = params.getAll('a');
+    assert_true(matches && matches.length == 1, 'Search params object has values for name "a"');
+    assert_array_equals(matches, ['one'], 'Search params object has expected name "a" values');
+}, 'getAll() multiples');
+/* eslint-enable */
 
-// getAll() multiples
-params = new URLSearchParams('a=1&a=2&a=3&a');
-assert.strictEqual(true, params.has('a'),
-                   'Search params object has name "a"');
-matches = params.getAll('a');
-assert(matches && matches.length == 4,
-       'Search params object has values for name "a"');
-assert.deepStrictEqual(matches, ['1', '2', '3', ''],
-                       'Search params object has expected name "a" values');
-params.set('a', 'one');
-assert.strictEqual(params.get('a'), 'one',
-                   'Search params object has name "a" with value "one"');
-matches = params.getAll('a');
-assert(matches && matches.length == 1,
-       'Search params object has values for name "a"');
-assert.deepStrictEqual(matches, ['one'],
-                       'Search params object has expected name "a" values');
-
-assert.throws(() => {
-  params.getAll.call(undefined);
-}, /^TypeError: Value of `this` is not a URLSearchParams$/);
-assert.throws(() => {
-  params.getAll();
-}, /^TypeError: "name" argument must be specified$/);
+// Tests below are not from WPT.
+{
+  const params = new URLSearchParams();
+  assert.throws(() => {
+    params.getAll.call(undefined);
+  }, /^TypeError: Value of `this` is not a URLSearchParams$/);
+  assert.throws(() => {
+    params.getAll();
+  }, /^TypeError: "name" argument must be specified$/);
+}
diff --git a/test/parallel/test-whatwg-url-searchparams-has.js b/test/parallel/test-whatwg-url-searchparams-has.js
index bab34515d99ac2..1be9cf6121593e 100644
--- a/test/parallel/test-whatwg-url-searchparams-has.js
+++ b/test/parallel/test-whatwg-url-searchparams-has.js
@@ -1,42 +1,48 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const URLSearchParams = require('url').URLSearchParams;
+const { test, assert_false, assert_true } = common.WPT;
 
-let params;
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/urlsearchparams-has.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+test(function() {
+    var params = new URLSearchParams('a=b&c=d');
+    assert_true(params.has('a'));
+    assert_true(params.has('c'));
+    assert_false(params.has('e'));
+    params = new URLSearchParams('a=b&c=d&a=e');
+    assert_true(params.has('a'));
+    params = new URLSearchParams('=b&c=d');
+    assert_true(params.has(''));
+    params = new URLSearchParams('null=a');
+    assert_true(params.has(null));
+}, 'Has basics');
 
-// Has basics
-params = new URLSearchParams('a=b&c=d');
-assert.strictEqual(true, params.has('a'));
-assert.strictEqual(true, params.has('c'));
-assert.strictEqual(false, params.has('e'));
-params = new URLSearchParams('a=b&c=d&a=e');
-assert.strictEqual(true, params.has('a'));
-params = new URLSearchParams('=b&c=d');
-assert.strictEqual(true, params.has(''));
-params = new URLSearchParams('null=a');
-assert.strictEqual(true, params.has(null));
+test(function() {
+    var params = new URLSearchParams('a=b&c=d&&');
+    params.append('first', 1);
+    params.append('first', 2);
+    assert_true(params.has('a'), 'Search params object has name "a"');
+    assert_true(params.has('c'), 'Search params object has name "c"');
+    assert_true(params.has('first'), 'Search params object has name "first"');
+    assert_false(params.has('d'), 'Search params object has no name "d"');
+    params.delete('first');
+    assert_false(params.has('first'), 'Search params object has no name "first"');
+}, 'has() following delete()');
+/* eslint-enable */
 
-// has() following delete()
-params = new URLSearchParams('a=b&c=d&&');
-params.append('first', 1);
-params.append('first', 2);
-assert.strictEqual(true, params.has('a'),
-                   'Search params object has name "a"');
-assert.strictEqual(true, params.has('c'),
-                   'Search params object has name "c"');
-assert.strictEqual(true, params.has('first'),
-                   'Search params object has name "first"');
-assert.strictEqual(false, params.has('d'),
-                   'Search params object has no name "d"');
-params.delete('first');
-assert.strictEqual(false, params.has('first'),
-                   'Search params object has no name "first"');
-
-assert.throws(() => {
-  params.has.call(undefined);
-}, /^TypeError: Value of `this` is not a URLSearchParams$/);
-assert.throws(() => {
-  params.has();
-}, /^TypeError: "name" argument must be specified$/);
+// Tests below are not from WPT.
+{
+  const params = new URLSearchParams();
+  assert.throws(() => {
+    params.has.call(undefined);
+  }, /^TypeError: Value of `this` is not a URLSearchParams$/);
+  assert.throws(() => {
+    params.has();
+  }, /^TypeError: "name" argument must be specified$/);
+}
diff --git a/test/parallel/test-whatwg-url-searchparams-inspect.js b/test/parallel/test-whatwg-url-searchparams-inspect.js
index 12472e1df0601a..768ec5aa390f06 100644
--- a/test/parallel/test-whatwg-url-searchparams-inspect.js
+++ b/test/parallel/test-whatwg-url-searchparams-inspect.js
@@ -3,12 +3,9 @@
 require('../common');
 const assert = require('assert');
 const util = require('util');
-const URL = require('url').URL;
-
-// Until we export URLSearchParams
-const m = new URL('http://example.org');
-const URLSearchParams = m.searchParams.constructor;
+const URLSearchParams = require('url').URLSearchParams;
 
+// Tests below are not from WPT.
 const sp = new URLSearchParams('?a=a&b=b&b=c');
 assert.strictEqual(util.inspect(sp),
                    "URLSearchParams { 'a' => 'a', 'b' => 'b', 'b' => 'c' }");
diff --git a/test/parallel/test-whatwg-url-searchparams-keys.js b/test/parallel/test-whatwg-url-searchparams-keys.js
index d538422654065c..6942b152cd78e8 100644
--- a/test/parallel/test-whatwg-url-searchparams-keys.js
+++ b/test/parallel/test-whatwg-url-searchparams-keys.js
@@ -4,6 +4,7 @@ require('../common');
 const assert = require('assert');
 const URLSearchParams = require('url').URLSearchParams;
 
+// Tests below are not from WPT.
 const params = new URLSearchParams('a=b&c=d');
 const keys = params.keys();
 
diff --git a/test/parallel/test-whatwg-url-searchparams-set.js b/test/parallel/test-whatwg-url-searchparams-set.js
index c818cc9f71af48..e78ce4763158b5 100644
--- a/test/parallel/test-whatwg-url-searchparams-set.js
+++ b/test/parallel/test-whatwg-url-searchparams-set.js
@@ -1,41 +1,46 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const URLSearchParams = require('url').URLSearchParams;
+const { test, assert_equals, assert_true } = common.WPT;
 
-let params;
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/urlsearchparams-set.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+test(function() {
+    var params = new URLSearchParams('a=b&c=d');
+    params.set('a', 'B');
+    assert_equals(params + '', 'a=B&c=d');
+    params = new URLSearchParams('a=b&c=d&a=e');
+    params.set('a', 'B');
+    assert_equals(params + '', 'a=B&c=d')
+    params.set('e', 'f');
+    assert_equals(params + '', 'a=B&c=d&e=f')
+}, 'Set basics');
 
-// Set basics
-params = new URLSearchParams('a=b&c=d');
-params.set('a', 'B');
-assert.strictEqual(params + '', 'a=B&c=d');
-params = new URLSearchParams('a=b&c=d&a=e');
-params.set('a', 'B');
-assert.strictEqual(params + '', 'a=B&c=d');
-params.set('e', 'f');
-assert.strictEqual(params + '', 'a=B&c=d&e=f');
+test(function() {
+    var params = new URLSearchParams('a=1&a=2&a=3');
+    assert_true(params.has('a'), 'Search params object has name "a"');
+    assert_equals(params.get('a'), '1', 'Search params object has name "a" with value "1"');
+    params.set('first', 4);
+    assert_true(params.has('a'), 'Search params object has name "a"');
+    assert_equals(params.get('a'), '1', 'Search params object has name "a" with value "1"');
+    params.set('a', 4);
+    assert_true(params.has('a'), 'Search params object has name "a"');
+    assert_equals(params.get('a'), '4', 'Search params object has name "a" with value "4"');
+}, 'URLSearchParams.set');
+/* eslint-enable */
 
-// URLSearchParams.set
-params = new URLSearchParams('a=1&a=2&a=3');
-assert.strictEqual(true, params.has('a'),
-                   'Search params object has name "a"');
-assert.strictEqual(params.get('a'), '1',
-                   'Search params object has name "a" with value "1"');
-params.set('first', 4);
-assert.strictEqual(true, params.has('a'),
-                   'Search params object has name "a"');
-assert.strictEqual(params.get('a'), '1',
-                   'Search params object has name "a" with value "1"');
-params.set('a', 4);
-assert.strictEqual(true, params.has('a'),
-                   'Search params object has name "a"');
-assert.strictEqual(params.get('a'), '4',
-                   'Search params object has name "a" with value "4"');
-
-assert.throws(() => {
-  params.set.call(undefined);
-}, /^TypeError: Value of `this` is not a URLSearchParams$/);
-assert.throws(() => {
-  params.set('a');
-}, /^TypeError: "name" and "value" arguments must be specified$/);
+// Tests below are not from WPT.
+{
+  const params = new URLSearchParams();
+  assert.throws(() => {
+    params.set.call(undefined);
+  }, /^TypeError: Value of `this` is not a URLSearchParams$/);
+  assert.throws(() => {
+    params.set('a');
+  }, /^TypeError: "name" and "value" arguments must be specified$/);
+}
diff --git a/test/parallel/test-whatwg-url-searchparams-sort.js b/test/parallel/test-whatwg-url-searchparams-sort.js
new file mode 100644
index 00000000000000..0fcc01335aed57
--- /dev/null
+++ b/test/parallel/test-whatwg-url-searchparams-sort.js
@@ -0,0 +1,84 @@
+'use strict';
+
+const common = require('../common');
+const { URL, URLSearchParams } = require('url');
+const { test, assert_array_equals } = common.WPT;
+
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/5903e00e77e85f8bcb21c73d1d7819fcd04763bd/url/urlsearchparams-sort.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+[
+  {
+    "input": "z=b&a=b&z=a&a=a",
+    "output": [["a", "b"], ["a", "a"], ["z", "b"], ["z", "a"]]
+  },
+  {
+    "input": "\uFFFD=x&\uFFFC&\uFFFD=a",
+    "output": [["\uFFFC", ""], ["\uFFFD", "x"], ["\uFFFD", "a"]]
+  },
+  {
+    "input": "ffi&🌈", // 🌈 > code point, but < code unit because two code units
+    "output": [["🌈", ""], ["ffi", ""]]
+  },
+  {
+    "input": "é&e\uFFFD&e\u0301",
+    "output": [["e\u0301", ""], ["e\uFFFD", ""], ["é", ""]]
+  },
+  {
+    "input": "z=z&a=a&z=y&a=b&z=x&a=c&z=w&a=d&z=v&a=e&z=u&a=f&z=t&a=g",
+    "output": [["a", "a"], ["a", "b"], ["a", "c"], ["a", "d"], ["a", "e"], ["a", "f"], ["a", "g"], ["z", "z"], ["z", "y"], ["z", "x"], ["z", "w"], ["z", "v"], ["z", "u"], ["z", "t"]]
+  }
+].forEach((val) => {
+  test(() => {
+    let params = new URLSearchParams(val.input),
+        i = 0
+    params.sort()
+    for(let param of params) {
+      assert_array_equals(param, val.output[i])
+      i++
+    }
+  }, "Parse and sort: " + val.input)
+
+  test(() => {
+    let url = new URL("?" + val.input, "https://example/")
+    url.searchParams.sort()
+    let params = new URLSearchParams(url.search),
+        i = 0
+    for(let param of params) {
+      assert_array_equals(param, val.output[i])
+      i++
+    }
+  }, "URL parse and sort: " + val.input)
+})
+/* eslint-enable */
+
+// Tests below are not from WPT.
+;[
+  {
+    'input': 'z=a&=b&c=d',
+    'output': [['', 'b'], ['c', 'd'], ['z', 'a']]
+  }
+].forEach((val) => {
+  test(() => {
+    const params = new URLSearchParams(val.input);
+    let i = 0;
+    params.sort();
+    for (const param of params) {
+      assert_array_equals(param, val.output[i]);
+      i++;
+    }
+  }, 'Parse and sort: ' + val.input);
+
+  test(() => {
+    const url = new URL(`?${val.input}`, 'https://example/');
+    url.searchParams.sort();
+    const params = new URLSearchParams(url.search);
+    let i = 0;
+    for (const param of params) {
+      assert_array_equals(param, val.output[i]);
+      i++;
+    }
+  }, 'URL parse and sort: ' + val.input);
+});
diff --git a/test/parallel/test-whatwg-url-searchparams-stringifier.js b/test/parallel/test-whatwg-url-searchparams-stringifier.js
index ba3f42683b46e6..7e85b9726167ad 100644
--- a/test/parallel/test-whatwg-url-searchparams-stringifier.js
+++ b/test/parallel/test-whatwg-url-searchparams-stringifier.js
@@ -1,115 +1,131 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const URLSearchParams = require('url').URLSearchParams;
-
-let params;
-
-// Serialize space
-// querystring does not currently handle spaces intelligently
-// params = new URLSearchParams();
-// params.append('a', 'b c');
-// assert.strictEqual(params + '', 'a=b+c');
-// params.delete('a');
-// params.append('a b', 'c');
-// assert.strictEqual(params + '', 'a+b=c');
-
-// Serialize empty value
-params = new URLSearchParams();
-params.append('a', '');
-assert.strictEqual(params + '', 'a=');
-params.append('a', '');
-assert.strictEqual(params + '', 'a=&a=');
-params.append('', 'b');
-assert.strictEqual(params + '', 'a=&a=&=b');
-params.append('', '');
-assert.strictEqual(params + '', 'a=&a=&=b&=');
-params.append('', '');
-assert.strictEqual(params + '', 'a=&a=&=b&=&=');
-
-// Serialize empty name
-params = new URLSearchParams();
-params.append('', 'b');
-assert.strictEqual(params + '', '=b');
-params.append('', 'b');
-assert.strictEqual(params + '', '=b&=b');
-
-// Serialize empty name and value
-params = new URLSearchParams();
-params.append('', '');
-assert.strictEqual(params + '', '=');
-params.append('', '');
-assert.strictEqual(params + '', '=&=');
-
-// Serialize +
-params = new URLSearchParams();
-params.append('a', 'b+c');
-assert.strictEqual(params + '', 'a=b%2Bc');
-params.delete('a');
-params.append('a+b', 'c');
-assert.strictEqual(params + '', 'a%2Bb=c');
-
-// Serialize =
-params = new URLSearchParams();
-params.append('=', 'a');
-assert.strictEqual(params + '', '%3D=a');
-params.append('b', '=');
-assert.strictEqual(params + '', '%3D=a&b=%3D');
-
-// Serialize &
-params = new URLSearchParams();
-params.append('&', 'a');
-assert.strictEqual(params + '', '%26=a');
-params.append('b', '&');
-assert.strictEqual(params + '', '%26=a&b=%26');
-
-// Serialize *-._
-params = new URLSearchParams();
-params.append('a', '*-._');
-assert.strictEqual(params + '', 'a=*-._');
-params.delete('a');
-params.append('*-._', 'c');
-assert.strictEqual(params + '', '*-._=c');
-
-// Serialize %
-params = new URLSearchParams();
-params.append('a', 'b%c');
-assert.strictEqual(params + '', 'a=b%25c');
-params.delete('a');
-params.append('a%b', 'c');
-assert.strictEqual(params + '', 'a%25b=c');
-
-// Serialize \\0
-params = new URLSearchParams();
-params.append('a', 'b\0c');
-assert.strictEqual(params + '', 'a=b%00c');
-params.delete('a');
-params.append('a\0b', 'c');
-assert.strictEqual(params + '', 'a%00b=c');
-
-// Serialize \uD83D\uDCA9
-// Unicode Character 'PILE OF POO' (U+1F4A9)
-params = new URLSearchParams();
-params.append('a', 'b\uD83D\uDCA9c');
-assert.strictEqual(params + '', 'a=b%F0%9F%92%A9c');
-params.delete('a');
-params.append('a\uD83D\uDCA9b', 'c');
-assert.strictEqual(params + '', 'a%F0%9F%92%A9b=c');
-
-// URLSearchParams.toString
-
-// querystring parses `&&` as {'': ''}
-// params = new URLSearchParams('a=b&c=d&&e&&');
-// assert.strictEqual(params.toString(), 'a=b&c=d&e=');
-
-// querystring does not currently handle spaces intelligently
-// params = new URLSearchParams('a = b &a=b&c=d%20');
-// assert.strictEqual(params.toString(), 'a+=+b+&a=b&c=d+');
-
-// The lone '=' _does_ survive the roundtrip.
-params = new URLSearchParams('a=&a=b');
-assert.strictEqual(params.toString(), 'a=&a=b');
-assert.throws(() => {
-  params.toString.call(undefined);
-}, /^TypeError: Value of `this` is not a URLSearchParams$/);
+const { test, assert_equals } = common.WPT;
+
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/urlsearchparams-stringifier.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+// test(function() {
+//     var params = new URLSearchParams();
+//     params.append('a', 'b c');
+//     assert_equals(params + '', 'a=b+c');
+//     params.delete('a');
+//     params.append('a b', 'c');
+//     assert_equals(params + '', 'a+b=c');
+// }, 'Serialize space');
+
+test(function() {
+    var params = new URLSearchParams();
+    params.append('a', '');
+    assert_equals(params + '', 'a=');
+    params.append('a', '');
+    assert_equals(params + '', 'a=&a=');
+    params.append('', 'b');
+    assert_equals(params + '', 'a=&a=&=b');
+    params.append('', '');
+    assert_equals(params + '', 'a=&a=&=b&=');
+    params.append('', '');
+    assert_equals(params + '', 'a=&a=&=b&=&=');
+}, 'Serialize empty value');
+
+test(function() {
+    var params = new URLSearchParams();
+    params.append('', 'b');
+    assert_equals(params + '', '=b');
+    params.append('', 'b');
+    assert_equals(params + '', '=b&=b');
+}, 'Serialize empty name');
+
+test(function() {
+    var params = new URLSearchParams();
+    params.append('', '');
+    assert_equals(params + '', '=');
+    params.append('', '');
+    assert_equals(params + '', '=&=');
+}, 'Serialize empty name and value');
+
+test(function() {
+    var params = new URLSearchParams();
+    params.append('a', 'b+c');
+    assert_equals(params + '', 'a=b%2Bc');
+    params.delete('a');
+    params.append('a+b', 'c');
+    assert_equals(params + '', 'a%2Bb=c');
+}, 'Serialize +');
+
+test(function() {
+    var params = new URLSearchParams();
+    params.append('=', 'a');
+    assert_equals(params + '', '%3D=a');
+    params.append('b', '=');
+    assert_equals(params + '', '%3D=a&b=%3D');
+}, 'Serialize =');
+
+test(function() {
+    var params = new URLSearchParams();
+    params.append('&', 'a');
+    assert_equals(params + '', '%26=a');
+    params.append('b', '&');
+    assert_equals(params + '', '%26=a&b=%26');
+}, 'Serialize &');
+
+test(function() {
+    var params = new URLSearchParams();
+    params.append('a', '*-._');
+    assert_equals(params + '', 'a=*-._');
+    params.delete('a');
+    params.append('*-._', 'c');
+    assert_equals(params + '', '*-._=c');
+}, 'Serialize *-._');
+
+test(function() {
+    var params = new URLSearchParams();
+    params.append('a', 'b%c');
+    assert_equals(params + '', 'a=b%25c');
+    params.delete('a');
+    params.append('a%b', 'c');
+    assert_equals(params + '', 'a%25b=c');
+}, 'Serialize %');
+
+test(function() {
+    var params = new URLSearchParams();
+    params.append('a', 'b\0c');
+    assert_equals(params + '', 'a=b%00c');
+    params.delete('a');
+    params.append('a\0b', 'c');
+    assert_equals(params + '', 'a%00b=c');
+}, 'Serialize \\0');
+
+test(function() {
+    var params = new URLSearchParams();
+    params.append('a', 'b\uD83D\uDCA9c');
+    assert_equals(params + '', 'a=b%F0%9F%92%A9c');
+    params.delete('a');
+    params.append('a\uD83D\uDCA9b', 'c');
+    assert_equals(params + '', 'a%F0%9F%92%A9b=c');
+}, 'Serialize \uD83D\uDCA9');  // Unicode Character 'PILE OF POO' (U+1F4A9)
+
+test(function() {
+    var params;
+    // params = new URLSearchParams('a=b&c=d&&e&&');
+    // assert_equals(params.toString(), 'a=b&c=d&e=');
+    // params = new URLSearchParams('a = b &a=b&c=d%20');
+    // assert_equals(params.toString(), 'a+=+b+&a=b&c=d+');
+    // The lone '=' _does_ survive the roundtrip.
+    params = new URLSearchParams('a=&a=b');
+    assert_equals(params.toString(), 'a=&a=b');
+}, 'URLSearchParams.toString');
+/* eslint-enable */
+
+// Tests below are not from WPT.
+{
+  const params = new URLSearchParams();
+  assert.throws(() => {
+    params.toString.call(undefined);
+  }, /^TypeError: Value of `this` is not a URLSearchParams$/);
+}
diff --git a/test/parallel/test-whatwg-url-searchparams-values.js b/test/parallel/test-whatwg-url-searchparams-values.js
index 36aa1da9f057bb..eb6fa05daf3496 100644
--- a/test/parallel/test-whatwg-url-searchparams-values.js
+++ b/test/parallel/test-whatwg-url-searchparams-values.js
@@ -4,6 +4,7 @@ require('../common');
 const assert = require('assert');
 const URLSearchParams = require('url').URLSearchParams;
 
+// Tests below are not from WPT.
 const params = new URLSearchParams('a=b&c=d');
 const values = params.values();
 
diff --git a/test/parallel/test-whatwg-url-searchparams.js b/test/parallel/test-whatwg-url-searchparams.js
index b3885a48be91e7..d855ccee841851 100644
--- a/test/parallel/test-whatwg-url-searchparams.js
+++ b/test/parallel/test-whatwg-url-searchparams.js
@@ -4,6 +4,7 @@ require('../common');
 const assert = require('assert');
 const URL = require('url').URL;
 
+// Tests below are not from WPT.
 const serialized = 'a=a&a=1&a=true&a=undefined&a=null&a=%5Bobject%20Object%5D';
 const values = ['a', 1, true, undefined, null, {}];
 
diff --git a/test/parallel/test-whatwg-url-setters.js b/test/parallel/test-whatwg-url-setters.js
index 8cd9fc51d52ae8..409ed1bd00d36c 100644
--- a/test/parallel/test-whatwg-url-setters.js
+++ b/test/parallel/test-whatwg-url-setters.js
@@ -1,6 +1,9 @@
 'use strict';
 
 const common = require('../common');
+const path = require('path');
+const URL = require('url').URL;
+const { test, assert_equals } = common.WPT;
 
 if (!common.hasIntl) {
   // A handful of the tests fail when ICU is not included.
@@ -8,25 +11,68 @@ if (!common.hasIntl) {
   return;
 }
 
-const path = require('path');
-const URL = require('url').URL;
-const assert = require('assert');
-const attrs = require(path.join(common.fixturesDir, 'url-setter-tests.json'));
+const request = {
+  response: require(path.join(common.fixturesDir, 'url-setter-tests.json'))
+};
 
-for (const attr in attrs) {
-  if (attr === 'comment')
-    continue;
-  const tests = attrs[attr];
-  let n = 0;
-  for (const test of tests) {
-    if (test.skip) continue;
-    n++;
-    const url = new URL(test.href);
-    url[attr] = test.new_value;
-    for (const test_attr in test.expected) {
-      assert.strictEqual(test.expected[test_attr], url[test_attr],
-                         `${n} ${attr} ${test_attr} ` +
-                         `${test.href} ${test.comment}`);
+/* eslint-disable */
+/* WPT Refs:
+   https://github.com/w3c/web-platform-tests/blob/8791bed/url/url-setters.html
+   License: http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html
+*/
+function startURLSettersTests() {
+//   var setup = async_test("Loading data…")
+//   setup.step(function() {
+//     var request = new XMLHttpRequest()
+//     request.open("GET", "setters_tests.json")
+//     request.send()
+//     request.responseType = "json"
+//     request.onload = setup.step_func(function() {
+         runURLSettersTests(request.response)
+//       setup.done()
+//     })
+//   })
+}
+
+function runURLSettersTests(all_test_cases) {
+  for (var attribute_to_be_set in all_test_cases) {
+    if (attribute_to_be_set == "comment") {
+      continue;
+    }
+    var test_cases = all_test_cases[attribute_to_be_set];
+    for(var i = 0, l = test_cases.length; i < l; i++) {
+      var test_case = test_cases[i];
+      var name = "Setting <" + test_case.href + ">." + attribute_to_be_set +
+                 " = '" + test_case.new_value + "'";
+      if ("comment" in test_case) {
+        name += " " + test_case.comment;
+      }
+      test(function() {
+        var url = new URL(test_case.href);
+        url[attribute_to_be_set] = test_case.new_value;
+        for (var attribute in test_case.expected) {
+          assert_equals(url[attribute], test_case.expected[attribute])
+        }
+      }, "URL: " + name)
+      // test(function() {
+      //   var url = document.createElement("a");
+      //   url.href = test_case.href;
+      //   url[attribute_to_be_set] = test_case.new_value;
+      //   for (var attribute in test_case.expected) {
+      //     assert_equals(url[attribute], test_case.expected[attribute])
+      //   }
+      // }, "<a>: " + name)
+      // test(function() {
+      //   var url = document.createElement("area");
+      //   url.href = test_case.href;
+      //   url[attribute_to_be_set] = test_case.new_value;
+      //   for (var attribute in test_case.expected) {
+      //     assert_equals(url[attribute], test_case.expected[attribute])
+      //   }
+      // }, "<area>: " + name)
     }
   }
 }
+
+startURLSettersTests()
+/* eslint-enable */
diff --git a/test/parallel/test-whatwg-url-tostringtag.js b/test/parallel/test-whatwg-url-tostringtag.js
index 83653368a7a4f2..689056fd238dda 100644
--- a/test/parallel/test-whatwg-url-tostringtag.js
+++ b/test/parallel/test-whatwg-url-tostringtag.js
@@ -3,6 +3,8 @@
 require('../common');
 const assert = require('assert');
 const URL = require('url').URL;
+
+// Tests below are not from WPT.
 const toString = Object.prototype.toString;
 
 const url = new URL('http://example.org');
diff --git a/tools/doc/type-parser.js b/tools/doc/type-parser.js
index 0ac15a14b93341..c5c416e2b3bdc2 100644
--- a/tools/doc/type-parser.js
+++ b/tools/doc/type-parser.js
@@ -16,28 +16,45 @@ const jsGlobalTypes = [
   'Uint16Array', 'Uint32Array', 'Int8Array', 'Int16Array', 'Int32Array',
   'Uint8ClampedArray', 'Float32Array', 'Float64Array', 'Date', 'RegExp',
   'ArrayBuffer', 'DataView', 'Promise', 'EvalError', 'RangeError',
-  'ReferenceError', 'SyntaxError', 'TypeError', 'URIError'
+  'ReferenceError', 'SyntaxError', 'TypeError', 'URIError', 'Proxy', 'Map',
+  'Set', 'WeakMap', 'WeakSet', 'Generator', 'GeneratorFunction',
+  'AsyncFunction', 'SharedArrayBuffer'
 ];
 const typeMap = {
+  'Iterable': jsDocPrefix +
+              'Reference/Iteration_protocols#The_iterable_protocol',
+  'Iterator': jsDocPrefix +
+              'Reference/Iteration_protocols#The_iterator_protocol',
+
   'Buffer': 'buffer.html#buffer_class_buffer',
-  'Handle': 'net.html#net_server_listen_handle_backlog_callback',
-  'Stream': 'stream.html#stream_stream',
-  'stream.Writable': 'stream.html#stream_class_stream_writable',
-  'stream.Readable': 'stream.html#stream_class_stream_readable',
+
   'ChildProcess': 'child_process.html#child_process_class_childprocess',
+
   'cluster.Worker': 'cluster.html#cluster_class_worker',
+
   'dgram.Socket': 'dgram.html#dgram_class_dgram_socket',
-  'net.Socket': 'net.html#net_class_net_socket',
-  'tls.TLSSocket': 'tls.html#tls_class_tls_tlssocket',
+
   'EventEmitter': 'events.html#events_class_eventemitter',
-  'Timer': 'timers.html#timers_timers',
+
   'http.Agent': 'http.html#http_class_http_agent',
   'http.ClientRequest': 'http.html#http_class_http_clientrequest',
   'http.IncomingMessage': 'http.html#http_class_http_incomingmessage',
   'http.Server': 'http.html#http_class_http_server',
   'http.ServerResponse': 'http.html#http_class_http_serverresponse',
-  'Iterator': jsDocPrefix +
-              'Reference/Iteration_protocols#The_iterator_protocol'
+
+  'Handle': 'net.html#net_server_listen_handle_backlog_callback',
+  'net.Socket': 'net.html#net_class_net_socket',
+
+  'Stream': 'stream.html#stream_stream',
+  'stream.Readable': 'stream.html#stream_class_stream_readable',
+  'stream.Writable': 'stream.html#stream_class_stream_writable',
+
+  'tls.TLSSocket': 'tls.html#tls_class_tls_tlssocket',
+
+  'Timer': 'timers.html#timers_timers',
+
+  'URL': 'url.html#url_the_whatwg_url_api',
+  'URLSearchParams': 'url.html#url_class_urlsearchparams'
 };
 
 module.exports = {