import assert = require("assert");
import * as fs from "fs";
import * as events from "events";
import events2 = require("events");
import * as zlib from "zlib";
import * as url from "url";
import * as util from "util";
import * as crypto from "crypto";
import * as tls from "tls";
import * as http from "http";
import * as https from "https";
import * as net from "net";
import * as tty from "tty";
import * as dgram from "dgram";
import * as querystring from "querystring";
import * as path from "path";
import * as readline from "readline";
import * as childProcess from "child_process";
import * as cluster from "cluster";
import * as os from "os";
import * as vm from "vm";
import * as console2 from "console";
import * as string_decoder from "string_decoder";
import * as stream from "stream";
import * as timers from "timers";
import * as repl from "repl";
import * as v8 from "v8";
import * as dns from "dns";
import * as async_hooks from "async_hooks";
import * as http2 from "http2";
import * as inspector from "inspector";
import * as perf_hooks from "perf_hooks";
import Module = require("module");

// Specifically test buffer module regression.
import { Buffer as ImportedBuffer, SlowBuffer as ImportedSlowBuffer } from "buffer";

//////////////////////////////////////////////////////////
/// Global Tests : https://nodejs.org/api/global.html  ///
//////////////////////////////////////////////////////////
namespace global_tests {
    {
        let x: NodeModule;
        let y: NodeModule;
        x.children.push(y);
        x.parent = require.main;
        require.main = y;
    }
}

//////////////////////////////////////////////////////////
/// Assert Tests : https://nodejs.org/api/assert.html ///
//////////////////////////////////////////////////////////

namespace assert_tests {
    {
        assert(1 + 1 - 2 === 0, "The universe isn't how it should.");

        assert.deepEqual({ x: { y: 3 } }, { x: { y: 3 } }, "DEEP WENT DERP");

        assert.deepStrictEqual({ a: 1 }, { a: 1 }, "uses === comparator");

        assert.doesNotThrow(() => {
            const b = false;
            if (b) { throw new Error("a hammer at your face"); }
        }, undefined, "What the...*crunch*");

        assert.equal(3, "3", "uses == comparator");

        assert.fail('stuff broke');

        assert.fail('actual', 'expected', 'message');

        assert.fail(1, 2, undefined, '>');

        assert.ifError(0);

        assert.notDeepStrictEqual({ x: { y: "3" } }, { x: { y: 3 } }, "uses !== comparator");

        assert.notEqual(1, 2, "uses != comparator");

        assert.notStrictEqual(2, "2", "uses === comparator");

        assert.ok(true);
        assert.ok(1);

        assert.strictEqual(1, 1, "uses === comparator");

        assert.throws(() => { throw new Error("a hammer at your face"); }, undefined, "DODGED IT");

        assert.strict.strict.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
    }
}

////////////////////////////////////////////////////
/// Events tests : http://nodejs.org/api/events.html
////////////////////////////////////////////////////

namespace events_tests {
    let emitter: events.EventEmitter;
    let event: string | symbol;
    let listener: (...args: any[]) => void;
    let any: any;

    {
        let result: events.EventEmitter;

        result = emitter.addListener(event, listener);
        result = emitter.on(event, listener);
        result = emitter.once(event, listener);
        result = emitter.prependListener(event, listener);
        result = emitter.prependOnceListener(event, listener);
        result = emitter.removeListener(event, listener);
        result = emitter.off(event, listener);
        result = emitter.removeAllListeners();
        result = emitter.removeAllListeners(event);
        result = emitter.setMaxListeners(42);
    }

    {
        let result: number;

        result = events.EventEmitter.defaultMaxListeners;
        result = events.EventEmitter.listenerCount(emitter, event); // deprecated

        result = emitter.getMaxListeners();
        result = emitter.listenerCount(event);
    }

    {
        let result: Function[];

        result = emitter.listeners(event);
    }

    {
        let result: boolean;

        result = emitter.emit(event);
        result = emitter.emit(event, any);
        result = emitter.emit(event, any, any);
        result = emitter.emit(event, any, any, any);
    }

    {
        let result: Array<string | symbol>;

        result = emitter.eventNames();
    }

    {
        class Networker extends events.EventEmitter {
            constructor() {
                super();

                this.emit("mingling");
            }
        }
    }

    {
        new events2();
    }
}

////////////////////////////////////////////////////
/// File system tests : http://nodejs.org/api/fs.html
////////////////////////////////////////////////////

namespace fs_tests {
    {
        fs.writeFile("thebible.txt",
            "Do unto others as you would have them do unto you.",
            assert.ifError);

        fs.write(1234, "test", () => { });

        fs.writeFile("Harry Potter",
            "\"You be wizzing, Harry,\" jived Dumbledore.",
            {
                encoding: "ascii"
            },
            assert.ifError);

        fs.writeFile("testfile", "content", "utf8", assert.ifError);

        fs.writeFileSync("testfile", "content", "utf8");
        fs.writeFileSync("testfile", "content", { encoding: "utf8" });
    }

    {
        fs.appendFile("testfile", "foobar", "utf8", assert.ifError);
        fs.appendFile("testfile", "foobar", { encoding: "utf8" }, assert.ifError);
        fs.appendFileSync("testfile", "foobar", "utf8");
        fs.appendFileSync("testfile", "foobar", { encoding: "utf8" });
    }

    {
        var content: string;
        var buffer: Buffer;
        var stringOrBuffer: string | Buffer;
        var nullEncoding: string | null = null;
        var stringEncoding: string | null = 'utf8';

        content = fs.readFileSync('testfile', 'utf8');
        content = fs.readFileSync('testfile', { encoding: 'utf8' });
        stringOrBuffer = fs.readFileSync('testfile', stringEncoding);
        stringOrBuffer = fs.readFileSync('testfile', { encoding: stringEncoding });

        buffer = fs.readFileSync('testfile');
        buffer = fs.readFileSync('testfile', null);
        buffer = fs.readFileSync('testfile', { encoding: null });
        stringOrBuffer = fs.readFileSync('testfile', nullEncoding);
        stringOrBuffer = fs.readFileSync('testfile', { encoding: nullEncoding });

        buffer = fs.readFileSync('testfile', { flag: 'r' });

        fs.readFile('testfile', 'utf8', (err, data) => content = data);
        fs.readFile('testfile', { encoding: 'utf8' }, (err, data) => content = data);
        fs.readFile('testfile', stringEncoding, (err, data) => stringOrBuffer = data);
        fs.readFile('testfile', { encoding: stringEncoding }, (err, data) => stringOrBuffer = data);

        fs.readFile('testfile', (err, data) => buffer = data);
        fs.readFile('testfile', null, (err, data) => buffer = data);
        fs.readFile('testfile', { encoding: null }, (err, data) => buffer = data);
        fs.readFile('testfile', nullEncoding, (err, data) => stringOrBuffer = data);
        fs.readFile('testfile', { encoding: nullEncoding }, (err, data) => stringOrBuffer = data);

        fs.readFile('testfile', { flag: 'r' }, (err, data) => buffer = data);
    }

    {
        var errno: number;
        fs.readFile('testfile', (err, data) => {
            if (err && err.errno) {
                errno = err.errno;
            }
        });
    }

    {
        let listS: string[];
        listS = fs.readdirSync('path');
        listS = fs.readdirSync('path', { encoding: 'utf8' });
        listS = fs.readdirSync('path', { encoding: null });
        listS = fs.readdirSync('path', { encoding: undefined });
        listS = fs.readdirSync('path', 'utf8');
        listS = fs.readdirSync('path', null);
        listS = fs.readdirSync('path', undefined);

        let listB: Buffer[];
        listB = fs.readdirSync('path', { encoding: 'buffer' });
        listB = fs.readdirSync("path", 'buffer');

        let enc = 'buffer';
        fs.readdirSync('path', { encoding: enc }); // $ExpectType string[] | Buffer[]
        fs.readdirSync('path', { }); // $ExpectType string[] | Buffer[]
    }

    {
        fs.mkdtemp('/tmp/foo-', (err, folder) => {
            console.log(folder);
            // Prints: /tmp/foo-itXde2
        });
    }

    {
        var tempDir: string;
        tempDir = fs.mkdtempSync('/tmp/foo-');
    }

    {
        fs.watch('/tmp/foo-', (event, filename) => {
            console.log(event, filename);
        });

        fs.watch('/tmp/foo-', 'utf8', (event, filename) => {
            console.log(event, filename);
        });

        fs.watch('/tmp/foo-', {
            recursive: true,
            persistent: true,
            encoding: 'utf8'
        }, (event, filename) => {
            console.log(event, filename);
        });
    }

    {
        fs.access('/path/to/folder', (err) => { });

        fs.access(Buffer.from(''), (err) => { });

        fs.access('/path/to/folder', fs.constants.F_OK | fs.constants.R_OK, (err) => { });

        fs.access(Buffer.from(''), fs.constants.F_OK | fs.constants.R_OK, (err) => { });

        fs.accessSync('/path/to/folder');

        fs.accessSync(Buffer.from(''));

        fs.accessSync('path/to/folder', fs.constants.W_OK | fs.constants.X_OK);

        fs.accessSync(Buffer.from(''), fs.constants.W_OK | fs.constants.X_OK);
    }

    {
        let s: string;
        let b: Buffer;
        fs.readlink('/path/to/folder', (err, linkString) => s = linkString);
        fs.readlink('/path/to/folder', undefined, (err, linkString) => s = linkString);
        fs.readlink('/path/to/folder', 'utf8', (err, linkString) => s = linkString);
        fs.readlink('/path/to/folder', 'buffer', (err, linkString) => b = linkString);
        fs.readlink('/path/to/folder', s, (err, linkString) => typeof linkString === 'string' ? s = linkString : b = linkString);
        fs.readlink('/path/to/folder', {}, (err, linkString) => s = linkString);
        fs.readlink('/path/to/folder', { encoding: undefined }, (err, linkString) => s = linkString);
        fs.readlink('/path/to/folder', { encoding: 'utf8' }, (err, linkString) => s = linkString);
        fs.readlink('/path/to/folder', { encoding: 'buffer' }, (err, linkString) => b = linkString);
        fs.readlink('/path/to/folder', { encoding: s }, (err, linkString) => typeof linkString === "string" ? s = linkString : b = linkString);

        s = fs.readlinkSync('/path/to/folder');
        s = fs.readlinkSync('/path/to/folder', undefined);
        s = fs.readlinkSync('/path/to/folder', 'utf8');
        b = fs.readlinkSync('/path/to/folder', 'buffer');
        const v1 = fs.readlinkSync('/path/to/folder', s);
        typeof v1 === "string" ? s = v1 : b = v1;

        s = fs.readlinkSync('/path/to/folder', {});
        s = fs.readlinkSync('/path/to/folder', { encoding: undefined });
        s = fs.readlinkSync('/path/to/folder', { encoding: 'utf8' });
        b = fs.readlinkSync('/path/to/folder', { encoding: 'buffer' });
        const v2 = fs.readlinkSync('/path/to/folder', { encoding: s });
        typeof v2 === "string" ? s = v2 : b = v2;
    }

    {
        let s: string;
        let b: Buffer;
        fs.realpath('/path/to/folder', (err, resolvedPath) => s = resolvedPath);
        fs.realpath('/path/to/folder', undefined, (err, resolvedPath) => s = resolvedPath);
        fs.realpath('/path/to/folder', 'utf8', (err, resolvedPath) => s = resolvedPath);
        fs.realpath('/path/to/folder', 'buffer', (err, resolvedPath) => b = resolvedPath);
        fs.realpath('/path/to/folder', s, (err, resolvedPath) => typeof resolvedPath === 'string' ? s = resolvedPath : b = resolvedPath);
        fs.realpath('/path/to/folder', {}, (err, resolvedPath) => s = resolvedPath);
        fs.realpath('/path/to/folder', { encoding: undefined }, (err, resolvedPath) => s = resolvedPath);
        fs.realpath('/path/to/folder', { encoding: 'utf8' }, (err, resolvedPath) => s = resolvedPath);
        fs.realpath('/path/to/folder', { encoding: 'buffer' }, (err, resolvedPath) => b = resolvedPath);
        fs.realpath('/path/to/folder', { encoding: s }, (err, resolvedPath) => typeof resolvedPath === "string" ? s = resolvedPath : b = resolvedPath);

        s = fs.realpathSync('/path/to/folder');
        s = fs.realpathSync('/path/to/folder', undefined);
        s = fs.realpathSync('/path/to/folder', 'utf8');
        b = fs.realpathSync('/path/to/folder', 'buffer');
        const v1 = fs.realpathSync('/path/to/folder', s);
        typeof v1 === "string" ? s = v1 : b = v1;

        s = fs.realpathSync('/path/to/folder', {});
        s = fs.realpathSync('/path/to/folder', { encoding: undefined });
        s = fs.realpathSync('/path/to/folder', { encoding: 'utf8' });
        b = fs.realpathSync('/path/to/folder', { encoding: 'buffer' });
        const v2 = fs.realpathSync('/path/to/folder', { encoding: s });
        typeof v2 === "string" ? s = v2 : b = v2;

        // native
        fs.realpath.native('/path/to/folder', (err, resolvedPath) => s = resolvedPath);
        fs.realpath.native('/path/to/folder', undefined, (err, resolvedPath) => s = resolvedPath);
        fs.realpath.native('/path/to/folder', 'utf8', (err, resolvedPath) => s = resolvedPath);
        fs.realpath.native('/path/to/folder', 'buffer', (err, resolvedPath) => b = resolvedPath);
        fs.realpath.native('/path/to/folder', s, (err, resolvedPath) => typeof resolvedPath === 'string' ? s = resolvedPath : b = resolvedPath);
        fs.realpath.native('/path/to/folder', {}, (err, resolvedPath) => s = resolvedPath);
        fs.realpath.native('/path/to/folder', { encoding: undefined }, (err, resolvedPath) => s = resolvedPath);
        fs.realpath.native('/path/to/folder', { encoding: 'utf8' }, (err, resolvedPath) => s = resolvedPath);
        fs.realpath.native('/path/to/folder', { encoding: 'buffer' }, (err, resolvedPath) => b = resolvedPath);
        fs.realpath.native('/path/to/folder', { encoding: s }, (err, resolvedPath) => typeof resolvedPath === "string" ? s = resolvedPath : b = resolvedPath);

        s = fs.realpathSync.native('/path/to/folder');
        s = fs.realpathSync.native('/path/to/folder', undefined);
        s = fs.realpathSync.native('/path/to/folder', 'utf8');
        b = fs.realpathSync.native('/path/to/folder', 'buffer');
        const v3 = fs.realpathSync.native('/path/to/folder', s);
        typeof v3 === "string" ? s = v3 : b = v3;

        s = fs.realpathSync.native('/path/to/folder', {});
        s = fs.realpathSync.native('/path/to/folder', { encoding: undefined });
        s = fs.realpathSync.native('/path/to/folder', { encoding: 'utf8' });
        b = fs.realpathSync.native('/path/to/folder', { encoding: 'buffer' });
        const v4 = fs.realpathSync.native('/path/to/folder', { encoding: s });
        typeof v4 === "string" ? s = v4 : b = v4;
    }

    {
        fs.copyFile('/path/to/src', '/path/to/dest', (err) => console.error(err));
        fs.copyFile('/path/to/src', '/path/to/dest', fs.constants.COPYFILE_EXCL, (err) => console.error(err));
        fs.copyFile('/path/to/src', '/path/to/dest', fs.constants.COPYFILE_FICLONE, (err) => console.error(err));
        fs.copyFile('/path/to/src', '/path/to/dest', fs.constants.COPYFILE_FICLONE_FORCE, (err) => console.error(err));

        fs.copyFileSync('/path/to/src', '/path/to/dest', fs.constants.COPYFILE_EXCL);
        fs.copyFileSync('/path/to/src', '/path/to/dest', fs.constants.COPYFILE_FICLONE);
        fs.copyFileSync('/path/to/src', '/path/to/dest', fs.constants.COPYFILE_FICLONE_FORCE);

        const cf = util.promisify(fs.copyFile);
        cf('/path/to/src', '/path/to/dest', fs.constants.COPYFILE_EXCL).then(console.log);
    }
}

///////////////////////////////////////////////////////
/// Buffer tests : https://nodejs.org/api/buffer.html
///////////////////////////////////////////////////////

function bufferTests() {
    var utf8Buffer = new Buffer('test');
    var base64Buffer = new Buffer('', 'base64');
    var octets: Uint8Array = null;
    var octetBuffer = new Buffer(octets);
    var sharedBuffer = new Buffer(octets.buffer);
    var copiedBuffer = new Buffer(utf8Buffer);
    console.log(Buffer.isBuffer(octetBuffer));
    console.log(Buffer.isEncoding('utf8'));
    console.log(Buffer.byteLength('xyz123'));
    console.log(Buffer.byteLength('xyz123', 'ascii'));
    var result1 = Buffer.concat([utf8Buffer, base64Buffer]);
    var result2 = Buffer.concat([utf8Buffer, base64Buffer], 9999999);

    // Class Methods: Buffer.swap16(), Buffer.swa32(), Buffer.swap64()
    {
        const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
        buf.swap16();
        buf.swap32();
        buf.swap64();
    }

    // Class Method: Buffer.from(data)
    {
        // Array
        const buf1: Buffer = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
        // Buffer
        const buf2: Buffer = Buffer.from(buf1);
        // String
        const buf3: Buffer = Buffer.from('this is a tést');
        // ArrayBuffer
        const arrUint16: Uint16Array = new Uint16Array(2);
        arrUint16[0] = 5000;
        arrUint16[1] = 4000;
        const buf4: Buffer = Buffer.from(arrUint16.buffer);
        const arrUint8: Uint8Array = new Uint8Array(2);
        const buf5: Buffer = Buffer.from(arrUint8);
        const buf6: Buffer = Buffer.from(buf1);
        const sharedArrayBuffer: SharedArrayBuffer = {
            byteLength: 10,
            slice: (begin?: number, end?: number) => sharedArrayBuffer
        };
        const buf7: Buffer = Buffer.from(sharedArrayBuffer);
    }

    // Class Method: Buffer.from(arrayBuffer[, byteOffset[, length]])
    {
        const arr: Uint16Array = new Uint16Array(2);
        arr[0] = 5000;
        arr[1] = 4000;

        let buf: Buffer;
        buf = Buffer.from(arr.buffer, 1);
        buf = Buffer.from(arr.buffer, 0, 1);
    }

    // Class Method: Buffer.from(str[, encoding])
    {
        const buf2: Buffer = Buffer.from('7468697320697320612074c3a97374', 'hex');
    }

    // Class Method: Buffer.alloc(size[, fill[, encoding]])
    {
        const buf1: Buffer = Buffer.alloc(5);
        const buf2: Buffer = Buffer.alloc(5, 'a');
        const buf3: Buffer = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
    }
    // Class Method: Buffer.allocUnsafe(size)
    {
        const buf: Buffer = Buffer.allocUnsafe(5);
    }
    // Class Method: Buffer.allocUnsafeSlow(size)
    {
        const buf: Buffer = Buffer.allocUnsafeSlow(10);
    }

    // Class Method byteLenght
    {
        let len: number;
        len = Buffer.byteLength("foo");
        len = Buffer.byteLength("foo", "utf8");

        const b = Buffer.from("bar");
        len = Buffer.byteLength(b);
        len = Buffer.byteLength(b, "utf16le");

        const ab = new ArrayBuffer(15);
        len = Buffer.byteLength(ab);
        len = Buffer.byteLength(ab, "ascii");

        const dv = new DataView(ab);
        len = Buffer.byteLength(dv);
        len = Buffer.byteLength(dv, "utf16le");
    }

    // Class Method poolSize
    {
        let s: number;
        s = Buffer.poolSize;
        Buffer.poolSize = 4096;
    }

    // Test that TS 1.6 works with the 'as Buffer' annotation
    // on isBuffer.
    var a: Buffer | number;
    a = new Buffer(10);
    if (Buffer.isBuffer(a)) {
        a.writeUInt8(3, 4);
    }

    // write* methods return offsets.
    var b = new Buffer(16);
    var result: number = b.writeUInt32LE(0, 0);
    result = b.writeUInt16LE(0, 4);
    result = b.writeUInt8(0, 6);
    result = b.writeInt8(0, 7);
    result = b.writeDoubleLE(0, 8);

    // fill returns the input buffer.
    b.fill('a').fill('b');

    {
        let buffer = new Buffer('123');
        let index: number;
        index = buffer.indexOf("23");
        index = buffer.indexOf("23", 1);
        index = buffer.indexOf("23", 1, "utf8");
        index = buffer.indexOf(23);
        index = buffer.indexOf(buffer);
    }

    {
        let buffer = new Buffer('123');
        let index: number;
        index = buffer.lastIndexOf("23");
        index = buffer.lastIndexOf("23", 1);
        index = buffer.lastIndexOf("23", 1, "utf8");
        index = buffer.lastIndexOf(23);
        index = buffer.lastIndexOf(buffer);
    }

    {
        let buffer = new Buffer('123');
        let val: [number, number];

        /* comment out for --target es5
        for (let entry of buffer.entries()) {
            val = entry;
        }
         */
    }

    {
        let buffer = new Buffer('123');
        let includes: boolean;
        includes = buffer.includes("23");
        includes = buffer.includes("23", 1);
        includes = buffer.includes("23", 1, "utf8");
        includes = buffer.includes(23);
        includes = buffer.includes(23, 1);
        includes = buffer.includes(23, 1, "utf8");
        includes = buffer.includes(buffer);
        includes = buffer.includes(buffer, 1);
        includes = buffer.includes(buffer, 1, "utf8");
    }

    {
        let buffer = new Buffer('123');
        let val: number;

        /* comment out for --target es5
        for (let key of buffer.keys()) {
            val = key;
        }
         */
    }

    {
        let buffer = new Buffer('123');
        let val: number;

        /* comment out for --target es5
        for (let value of buffer.values()) {
            val = value;
        }
         */
    }

    // Imported Buffer from buffer module works properly
    {
        let b = new ImportedBuffer('123');
        b.writeUInt8(0, 6);
        let sb = new ImportedSlowBuffer(43);
        b.writeUInt8(0, 6);
    }

    // Buffer has Uint8Array's buffer field (an ArrayBuffer).
    {
        let buffer = new Buffer('123');
        let octets = new Uint8Array(buffer.buffer);
    }
}

////////////////////////////////////////////////////
/// Url tests : http://nodejs.org/api/url.html
////////////////////////////////////////////////////

namespace url_tests {
    {
        url.format(url.parse('http://www.example.com/xyz'));

        url.format('http://www.example.com/xyz');

        // https://google.com/search?q=you're%20a%20lizard%2C%20gary
        url.format({
            protocol: 'https',
            host: "google.com",
            pathname: 'search',
            query: { q: "you're a lizard, gary" }
        });

        const myURL = new url.URL('https://a:b@你好你好?abc#foo');
        url.format(myURL, { fragment: false, unicode: true, auth: false });
    }

    {
        const helloUrl = url.parse('http://example.com/?hello=world', true);
        let helloQuery = helloUrl.query['hello'];
        assert.equal(helloUrl.query['hello'], 'world');

        let strUrl = url.parse('http://example.com/?hello=world');
        let queryStr: string = strUrl.query;

        strUrl = url.parse('http://example.com/?hello=world', false);
        queryStr = strUrl.query;

        function getBoolean(): boolean { return false; }
        const urlUrl = url.parse('http://example.com/?hello=world', getBoolean());
        if (typeof(urlUrl.query) === 'string') {
            queryStr = urlUrl.query;
        } else if (urlUrl.query) {
            helloQuery = urlUrl.query['hello'];
        }
    }

    {
        const ascii: string = url.domainToASCII('español.com');
        const unicode: string = url.domainToUnicode('xn--espaol-zwa.com');
    }

    {
        let myURL = new url.URL('https://theuser:thepwd@example.org:81/foo/path?query=string#bar');
        assert.equal(myURL.hash, '#bar');
        assert.equal(myURL.host, 'example.org:81');
        assert.equal(myURL.hostname, 'example.org');
        assert.equal(myURL.href, 'https://theuser:thepwd@example.org:81/foo/path?query=string#bar');
        assert.equal(myURL.origin, 'https://example.org:81');
        assert.equal(myURL.password, 'thepwd');
        assert.equal(myURL.username, 'theuser');
        assert.equal(myURL.pathname, '/foo/path');
        assert.equal(myURL.port, "81");
        assert.equal(myURL.protocol, "https:");
        assert.equal(myURL.search, "?query=string");
        assert.equal(myURL.toString(), 'https://theuser:thepwd@example.org:81/foo/path?query=string#bar');
        assert(myURL.searchParams instanceof url.URLSearchParams);

        myURL.host = 'example.org:82';
        myURL.hostname = 'example.com';
        myURL.href = 'http://other.com';
        myURL.hash = 'baz';
        myURL.password = "otherpwd";
        myURL.username = "otheruser";
        myURL.pathname = "/otherPath";
        myURL.port = "82";
        myURL.protocol = "http";
        myURL.search = "a=b";
        assert.equal(myURL.href, 'http://otheruser:otherpwd@other.com:82/otherPath?a=b#baz');

        myURL = new url.URL('/foo', 'https://example.org/');
        assert.equal(myURL.href, 'https://example.org/foo');
        assert.equal(myURL.toJSON(), myURL.href);
    }

    {
        const searchParams = new url.URLSearchParams('abc=123');

        assert.equal(searchParams.toString(), 'abc=123');
        searchParams.forEach((value: string, name: string, me: url.URLSearchParams): void => {
            assert.equal(name, 'abc');
            assert.equal(value, '123');
            assert.equal(me, searchParams);
        });

        assert.equal(searchParams.get('abc'), '123');

        searchParams.append('abc', 'xyz');

        assert.deepEqual(searchParams.getAll('abc'), ['123', 'xyz']);

        const entries = searchParams.entries();
        assert.deepEqual(entries.next(), { value: ["abc", "123"], done: false });
        assert.deepEqual(entries.next(), { value: ["abc", "xyz"], done: false });
        assert.deepEqual(entries.next(), { value: undefined, done: true });

        const keys = searchParams.keys();
        assert.deepEqual(keys.next(), { value: "abc", done: false });
        assert.deepEqual(keys.next(), { value: "abc", done: false });
        assert.deepEqual(keys.next(), { value: undefined, done: true });

        const values = searchParams.values();
        assert.deepEqual(values.next(), { value: "123", done: false });
        assert.deepEqual(values.next(), { value: "xyz", done: false });
        assert.deepEqual(values.next(), { value: undefined, done: true });

        searchParams.set('abc', 'b');
        assert.deepEqual(searchParams.getAll('abc'), ['b']);

        searchParams.delete('a');
        assert(!searchParams.has('a'));
        assert.equal(searchParams.get('a'), null);

        searchParams.sort();
    }

    {
        const searchParams = new url.URLSearchParams({
            user: 'abc',
            query: ['first', 'second']
        });

        assert.equal(searchParams.toString(), 'user=abc&query=first%2Csecond');
        assert.deepEqual(searchParams.getAll('query'), ['first,second']);
    }

    {
        // Using an array
        let params = new url.URLSearchParams([
            ['user', 'abc'],
            ['query', 'first'],
            ['query', 'second']
        ]);
        assert.equal(params.toString(), 'user=abc&query=first&query=second');
    }
}

/////////////////////////////////////////////////////
/// util tests : https://nodejs.org/api/util.html ///
/////////////////////////////////////////////////////

namespace util_tests {
    {
        // Old and new util.inspect APIs
        util.inspect(["This is nice"], false, 5);
        util.inspect(["This is nice"], false, null);
        util.inspect(["This is nice"], {
            colors: true,
            depth: 5,
            customInspect: false,
            showProxy: true,
            maxArrayLength: 10,
            breakLength: 20,
            compact: true
        });
        util.inspect(["This is nice"], {
            colors: true,
            depth: null,
            customInspect: false,
            showProxy: true,
            maxArrayLength: null,
            breakLength: Infinity,
            compact: false
        });
        assert(typeof util.inspect.custom === 'symbol');

        util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 });

        // util.callbackify
        // tslint:disable-next-line no-unnecessary-class
        class callbackifyTest {
            static fn(): Promise<void> {
                assert(arguments.length === 0);

                return Promise.resolve();
            }

            static fnE(): Promise<void> {
                assert(arguments.length === 0);

                return Promise.reject(new Error('fail'));
            }

            static fnT1(arg1: string): Promise<void> {
                assert(arguments.length === 1 && arg1 === 'parameter');

                return Promise.resolve();
            }

            static fnT1E(arg1: string): Promise<void> {
                assert(arguments.length === 1 && arg1 === 'parameter');

                return Promise.reject(new Error('fail'));
            }

            static fnTResult(): Promise<string> {
                assert(arguments.length === 0);

                return Promise.resolve('result');
            }

            static fnTResultE(): Promise<string> {
                assert(arguments.length === 0);

                return Promise.reject(new Error('fail'));
            }

            static fnT1TResult(arg1: string): Promise<string> {
                assert(arguments.length === 1 && arg1 === 'parameter');

                return Promise.resolve('result');
            }

            static fnT1TResultE(arg1: string): Promise<string> {
                assert(arguments.length === 1 && arg1 === 'parameter');

                return Promise.reject(new Error('fail'));
            }

            static test(): void {
                var cfn = util.callbackify(this.fn);
                var cfnE = util.callbackify(this.fnE);
                var cfnT1 = util.callbackify(this.fnT1);
                var cfnT1E = util.callbackify(this.fnT1E);
                var cfnTResult = util.callbackify(this.fnTResult);
                var cfnTResultE = util.callbackify(this.fnTResultE);
                var cfnT1TResult = util.callbackify(this.fnT1TResult);
                var cfnT1TResultE = util.callbackify(this.fnT1TResultE);

                cfn((err: NodeJS.ErrnoException, ...args: string[]) => assert(err === null && args.length === 1 && args[0] === undefined));
                cfnE((err: NodeJS.ErrnoException, ...args: string[]) => assert(err.message === 'fail' && args.length === 0));
                cfnT1('parameter', (err: NodeJS.ErrnoException, ...args: string[]) => assert(err === null && args.length === 1 && args[0] === undefined));
                cfnT1E('parameter', (err: NodeJS.ErrnoException, ...args: string[]) => assert(err.message === 'fail' && args.length === 0));
                cfnTResult((err: NodeJS.ErrnoException, ...args: string[]) => assert(err === null && args.length === 1 && args[0] === 'result'));
                cfnTResultE((err: NodeJS.ErrnoException, ...args: string[]) => assert(err.message === 'fail' && args.length === 0));
                cfnT1TResult('parameter', (err: NodeJS.ErrnoException, ...args: string[]) => assert(err === null && args.length === 1 && args[0] === 'result'));
                cfnT1TResultE('parameter', (err: NodeJS.ErrnoException, ...args: string[]) => assert(err.message === 'fail' && args.length === 0));
            }
        }
        callbackifyTest.test();

        // util.promisify
        var readPromised = util.promisify(fs.readFile);
        var sampleRead: Promise<any> = readPromised(__filename).then((data: Buffer): void => { }).catch((error: Error): void => { });
        var arg0: () => Promise<number> = util.promisify((cb: (err: Error, result: number) => void): void => { });
        var arg0NoResult: () => Promise<any> = util.promisify((cb: (err: Error) => void): void => { });
        var arg1: (arg: string) => Promise<number> = util.promisify((arg: string, cb: (err: Error, result: number) => void): void => { });
        var arg1NoResult: (arg: string) => Promise<any> = util.promisify((arg: string, cb: (err: Error) => void): void => { });
        var cbOptionalError: () => Promise<void> = util.promisify((cb: (err?: Error | null) => void): void => { cb(); });
        assert(typeof util.promisify.custom === 'symbol');
        // util.deprecate
        const foo = () => {};
        // $ExpectType () => void
        util.deprecate(foo, 'foo() is deprecated, use bar() instead');
        // $ExpectType <T extends Function>(fn: T, message: string) => T
        util.deprecate(util.deprecate, 'deprecate() is deprecated, use bar() instead');

        // util.isDeepStrictEqual
        util.isDeepStrictEqual({foo: 'bar'}, {foo: 'bar'});

        // util.TextDecoder()
        var td = new util.TextDecoder();
        new util.TextDecoder("utf-8");
        new util.TextDecoder("utf-8", { fatal: true });
        new util.TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
        var ignoreBom: boolean = td.ignoreBOM;
        var fatal: boolean = td.fatal;
        var encoding: string = td.encoding;
        td.decode(new Int8Array(1));
        td.decode(new Int16Array(1));
        td.decode(new Int32Array(1));
        td.decode(new Uint8Array(1));
        td.decode(new Uint16Array(1));
        td.decode(new Uint32Array(1));
        td.decode(new Uint8ClampedArray(1));
        td.decode(new Float32Array(1));
        td.decode(new Float64Array(1));
        td.decode(new DataView(new Int8Array(1).buffer));
        td.decode(new ArrayBuffer(1));
        td.decode(null);
        td.decode(null, { stream: true });
        td.decode(new Int8Array(1), { stream: true });
        var decode: string = td.decode(new Int8Array(1));

        // util.TextEncoder()
        var te = new util.TextEncoder();
        var teEncoding: string = te.encoding;
        var teEncodeRes: Uint8Array = te.encode("TextEncoder");
    }
}

////////////////////////////////////////////////////
/// Stream tests : http://nodejs.org/api/stream.html
////////////////////////////////////////////////////

// http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
function stream_readable_pipe_test() {
    var rs = fs.createReadStream(Buffer.from('file.txt'));
    var r = fs.createReadStream('file.txt');
    var z = zlib.createGzip({ finishFlush: zlib.constants.Z_FINISH });
    var w = fs.createWriteStream('file.txt.gz');

    assert(typeof z.bytesRead === 'number');
    assert(typeof r.bytesRead === 'number');
    assert(typeof r.path === 'string');
    assert(rs.path instanceof Buffer);

    r.pipe(z).pipe(w);

    z.flush();
    r.close();
    z.close();
    rs.close();
}

// helpers
const compressMe = new Buffer("some data");
const compressMeString = "compress me!";

zlib.deflate(compressMe, (err: Error, result: Buffer) => zlib.inflate(result, (err: Error, result: Buffer) => result));
zlib.deflate(compressMe, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => zlib.inflate(result, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => result));
zlib.deflate(compressMeString, (err: Error, result: Buffer) => zlib.inflate(result, (err: Error, result: Buffer) => result));
zlib.deflate(compressMeString, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => zlib.inflate(result, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => result));
const inflated = zlib.inflateSync(zlib.deflateSync(compressMe));
const inflatedString = zlib.inflateSync(zlib.deflateSync(compressMeString));

zlib.deflateRaw(compressMe, (err: Error, result: Buffer) => zlib.inflateRaw(result, (err: Error, result: Buffer) => result));
zlib.deflateRaw(compressMe, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => zlib.inflateRaw(result, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => result));
zlib.deflateRaw(compressMeString, (err: Error, result: Buffer) => zlib.inflateRaw(result, (err: Error, result: Buffer) => result));
zlib.deflateRaw(compressMeString, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => zlib.inflateRaw(result, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => result));
const inflatedRaw: Buffer = zlib.inflateRawSync(zlib.deflateRawSync(compressMe));
const inflatedRawString: Buffer = zlib.inflateRawSync(zlib.deflateRawSync(compressMeString));

zlib.gzip(compressMe, (err: Error, result: Buffer) => zlib.gunzip(result, (err: Error, result: Buffer) => result));
zlib.gzip(compressMe, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => zlib.gunzip(result, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => result));
const gunzipped: Buffer = zlib.gunzipSync(zlib.gzipSync(compressMe));

zlib.unzip(compressMe, (err: Error, result: Buffer) => result);
zlib.unzip(compressMe, { finishFlush: zlib.Z_SYNC_FLUSH }, (err: Error, result: Buffer) => result);
const unzipped: Buffer = zlib.unzipSync(compressMe);

// Simplified constructors
function simplified_stream_ctor_test() {
    new stream.Readable({
        read(size) {
            // $ExpectType Readable
            this;
            // $ExpectType number
            size;
        },
        destroy(error, cb) {
            // $ExpectType Error
            error;
            // $ExpectType (error: Error) => void
            cb;
        }
    });

    new stream.Writable({
        write(chunk, enc, cb) {
            // $ExpectType Writable
            this;
            // $ExpectType any
            chunk;
            // $ExpectType string
            enc;
            // $ExpectType (error?: Error) => void
            cb;
        },
        writev(chunks, cb) {
            // $ExpectType Writable
            this;
            // $ExpectType { chunk: any; encoding: string; }[]
            chunks;
            // $ExpectType (error?: Error) => void
            cb;
        },
        destroy(error, cb) {
            // $ExpectType Writable
            this;
            // $ExpectType Error
            error;
            // $ExpectType (error: Error) => void
            cb;
        },
        final(cb) {
            // $ExpectType Writable
            this;
            // $ExpectType (error?: Error) => void
            cb;
        }
    });

    new stream.Duplex({
        read(size) {
            // $ExpectType Duplex
            this;
            // $ExpectType number
            size;
        },
        write(chunk, enc, cb) {
            // $ExpectType Duplex
            this;
            // $ExpectType any
            chunk;
            // $ExpectType string
            enc;
            // $ExpectType (error?: Error) => void
            cb;
        },
        writev(chunks, cb) {
            // $ExpectType Duplex
            this;
            // $ExpectType { chunk: any; encoding: string; }[]
            chunks;
            // $ExpectType (error?: Error) => void
            cb;
        },
        destroy(error, cb) {
            // $ExpectType Duplex
            this;
            // $ExpectType Error
            error;
            // $ExpectType (error: Error) => void
            cb;
        },
        final(cb) {
            // $ExpectType Duplex
            this;
            // $ExpectType (error?: Error) => void
            cb;
        },
        readableObjectMode: true,
        writableObjectMode: true
    });

    new stream.Transform({
        read(size) {
            // $ExpectType Transform
            this;
            // $ExpectType number
            size;
        },
        write(chunk, enc, cb) {
            // $ExpectType Transform
            this;
            // $ExpectType any
            chunk;
            // $ExpectType string
            enc;
            // $ExpectType (error?: Error) => void
            cb;
        },
        writev(chunks, cb) {
            // $ExpectType Transform
            this;
            // $ExpectType { chunk: any; encoding: string; }[]
            chunks;
            // $ExpectType (error?: Error) => void
            cb;
        },
        destroy(error, cb) {
            // $ExpectType Transform
            this;
            // $ExpectType Error
            error;
            // $ExpectType (error: Error) => void
            cb;
        },
        final(cb) {
            // $ExpectType Transform
            this;
            // $ExpectType (error?: Error) => void
            cb;
        },
        transform(chunk, enc, cb) {
            // $ExpectType Transform
            this;
            // $ExpectType any
            chunk;
            // $ExpectType string
            enc;
            // $ExpectType TransformCallback
            cb;
        },
        flush(cb) {
            // $ExpectType TransformCallback
            cb;
        },
        allowHalfOpen: true,
        readableObjectMode: true,
        writableObjectMode: true
    });
}

////////////////////////////////////////////////////////
/// Crypto tests : http://nodejs.org/api/crypto.html ///
////////////////////////////////////////////////////////

namespace crypto_tests {
    {
        // crypto_hash_string_test
        var hashResult: string = crypto.createHash('md5').update('world').digest('hex');
    }

    {
        // crypto_hash_buffer_test
        var hashResult: string = crypto.createHash('md5')
            .update(new Buffer('world')).digest('hex');
    }

    {
        // crypto_hash_dataview_test
        var hashResult: string = crypto.createHash('md5')
            .update(new DataView(new Buffer('world').buffer)).digest('hex');
    }

    {
        // crypto_hash_int8array_test
        var hashResult: string = crypto.createHash('md5')
            .update(new Int8Array(new Buffer('world').buffer)).digest('hex');
    }

    {
        // crypto_hmac_string_test
        var hmacResult: string = crypto.createHmac('md5', 'hello').update('world').digest('hex');
    }

    {
        // crypto_hmac_buffer_test
        var hmacResult: string = crypto.createHmac('md5', 'hello')
            .update(new Buffer('world')).digest('hex');
    }

    {
        // crypto_hmac_dataview_test
        var hmacResult: string = crypto.createHmac('md5', 'hello')
            .update(new DataView(new Buffer('world').buffer)).digest('hex');
    }

    {
        // crypto_hmac_int8array_test
        var hmacResult: string = crypto.createHmac('md5', 'hello')
            .update(new Int8Array(new Buffer('world').buffer)).digest('hex');
    }

    {
        let hmac: crypto.Hmac;
        (hmac = crypto.createHmac('md5', 'hello')).end('world', 'utf8', () => {
            let hash: Buffer | string = hmac.read();
        });
    }

    {
        // crypto_cipher_decipher_string_test
        let key: Buffer = new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7]);
        let clearText: string = "This is the clear text.";
        let cipher: crypto.Cipher = crypto.createCipher("aes-128-ecb", key);
        let cipherText: string = cipher.update(clearText, "utf8", "hex");
        cipherText += cipher.final("hex");

        let decipher: crypto.Decipher = crypto.createDecipher("aes-128-ecb", key);
        let clearText2: string = decipher.update(cipherText, "hex", "utf8");
        clearText2 += decipher.final("utf8");

        assert.equal(clearText2, clearText);
    }

    {
        // crypto_cipher_decipher_buffer_test
        let key: Buffer = new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7]);
        let clearText: Buffer = new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4]);
        let cipher: crypto.Cipher = crypto.createCipher("aes-128-ecb", key);
        let cipherBuffers: Buffer[] = [];
        cipherBuffers.push(cipher.update(clearText));
        cipherBuffers.push(cipher.final());

        let cipherText: Buffer = Buffer.concat(cipherBuffers);

        let decipher: crypto.Decipher = crypto.createDecipher("aes-128-ecb", key);
        let decipherBuffers: Buffer[] = [];
        decipherBuffers.push(decipher.update(cipherText));
        decipherBuffers.push(decipher.final());

        let clearText2: Buffer = Buffer.concat(decipherBuffers);

        assert.deepEqual(clearText2, clearText);
    }

    {
        // crypto_cipher_decipher_dataview_test
        let key: Buffer = new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7]);
        let clearText: DataView = new DataView(new Buffer([1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4]).buffer);
        let cipher: crypto.Cipher = crypto.createCipher("aes-128-ecb", key);
        let cipherBuffers: Buffer[] = [];
        cipherBuffers.push(cipher.update(clearText));
        cipherBuffers.push(cipher.final());

        let cipherText: DataView = new DataView(Buffer.concat(cipherBuffers).buffer);

        let decipher: crypto.Decipher = crypto.createDecipher("aes-128-ecb", key);
        let decipherBuffers: Buffer[] = [];
        decipherBuffers.push(decipher.update(cipherText));
        decipherBuffers.push(decipher.final());

        let clearText2: Buffer = Buffer.concat(decipherBuffers);

        assert.deepEqual(clearText2, clearText);
    }

    {
        const key = 'keykeykeykeykeykeykeykey';
        const nonce = crypto.randomBytes(12);
        const aad = Buffer.from('0123456789', 'hex');

        const cipher = crypto.createCipheriv('aes-192-ccm', key, nonce, {
            authTagLength: 16
        });
        const plaintext = 'Hello world';
        cipher.setAAD(aad, {
            plaintextLength: Buffer.byteLength(plaintext)
        });
        const ciphertext = cipher.update(plaintext, 'utf8');
        cipher.final();
        const tag = cipher.getAuthTag();

        const decipher = crypto.createDecipheriv('aes-192-ccm', key, nonce, {
            authTagLength: 16
        });
        decipher.setAuthTag(tag);
        decipher.setAAD(aad, {
            plaintextLength: ciphertext.length
        });
        const receivedPlaintext: string = decipher.update(ciphertext, null, 'utf8');
        decipher.final();
    }

    {
        const key = 'keykeykeykeykeykeykeykey';
        const nonce = crypto.randomBytes(12);
        const aad = Buffer.from('0123456789', 'hex');

        const cipher = crypto.createCipheriv('aes-192-gcm', key, nonce);
        const plaintext = 'Hello world';
        cipher.setAAD(aad, {
            plaintextLength: Buffer.byteLength(plaintext)
        });
        const ciphertext = cipher.update(plaintext, 'utf8');
        cipher.final();
        const tag = cipher.getAuthTag();

        const decipher = crypto.createDecipheriv('aes-192-gcm', key, nonce);
        decipher.setAuthTag(tag);
        decipher.setAAD(aad, {
            plaintextLength: ciphertext.length
        });
        const receivedPlaintext: string = decipher.update(ciphertext, null, 'utf8');
        decipher.final();
    }

    {
        // crypto_timingsafeequal_buffer_test
        let buffer1: Buffer = new Buffer([1, 2, 3, 4, 5]);
        let buffer2: Buffer = new Buffer([1, 2, 3, 4, 5]);
        let buffer3: Buffer = new Buffer([5, 4, 3, 2, 1]);

        assert(crypto.timingSafeEqual(buffer1, buffer2));
        assert(!crypto.timingSafeEqual(buffer1, buffer3));
    }

    {
        // crypto_timingsafeequal_uint32array_test
        let arr1: Uint32Array = Uint32Array.of(1, 2, 3, 4, 5);
        let arr2: Uint32Array = Uint32Array.of(1, 2, 3, 4, 5);
        let arr3: Uint32Array = Uint32Array.of(5, 4, 3, 2, 1);

        assert(crypto.timingSafeEqual(arr1, arr2));
        assert(!crypto.timingSafeEqual(arr1, arr3));
    }

    {
        // crypto_timingsafeequal_safe_typedarray_variant_test
        let arr1: Uint32Array = Uint32Array.of(1, 2, 3, 4, 5);
        let arr2: Int32Array = Int32Array.of(1, 2, 3, 4, 5);
        let arr3: Uint32Array = Uint32Array.of(5, 4, 3, 2, 1);

        assert(crypto.timingSafeEqual(arr1, arr2));
        assert(!crypto.timingSafeEqual(arr1, arr3));
    }

    {
        // crypto_timingsafeequal_safe_int8array_variant_test
        let arr1: Int8Array = Int8Array.of(1, 2, 3, 4, 5, ~0, ~1, ~2, ~3, ~4);
        let arr2: Uint8Array = Uint8Array.of(1, 2, 3, 4, 5, ~0, ~1, ~2, ~3, ~4);
        let arr3: Uint8ClampedArray = Uint8ClampedArray.of(1, 2, 3, 4, 5, ~0, ~1, ~2, ~3, ~4);

        assert(crypto.timingSafeEqual(arr1, arr2)); // binary same
        assert(!crypto.timingSafeEqual(arr1, arr3)); // binary differ
    }

    {
        // crypto_timingsafeequal_safe_arraybufferiew_variant_test
        /* throws as of v10.4.1 */
        // let arr1: Uint8Array = Uint8Array.of(1, 0, 2, 0, 3, 0, 4, 0);
        // let arr2: Uint16Array = Uint16Array.of(1, 2, 3, 4);
        // let arr3: Uint32Array = Uint8ClampedArray.of(131073, 262147);

        // assert(crypto.timingSafeEqual(arr1, arr2)); // binary same
        // assert(crypto.timingSafeEqual(arr1, arr3)); // binary same
    }

    {
        // crypto_timingsafeequal_unsafe_arraybufferiew_variant_test
        /* dumps core as of v10.4.1 */
        // let arr1: Uint8Array = Uint8Array.of(1, 2, 3, 4);
        // let arr2: Uint16Array = Uint16Array.of(1, 2, 3, 4);
        // let arr3: Uint32Array = Uint8ClampedArray.of(1, 2, 3, 4);

        // assert(!crypto.timingSafeEqual(arr1, arr2)); // dumps core
        // assert(!crypto.timingSafeEqual(arr1, arr3)); // dumps core
    }

    {
        // crypto_timingsafeequal_dataview_test
        let dv1B: Uint8Array = Uint8Array.of(1, 2, 3, 4, 5);
        let dv2B: Int8Array = Int8Array.of(1, 2, 3, 4, 5);
        let dv3B: Buffer = Buffer.of(5, 4, 3, 2, 1);
        let dv4B: Uint8ClampedArray = Uint8ClampedArray.of(5, 4, 3, 2, 1);
        let dv1: DataView = new DataView(dv1B.buffer, dv1B.byteOffset, dv1B.byteLength);
        let dv2: DataView = new DataView(dv2B.buffer, dv2B.byteOffset, dv2B.byteLength);
        let dv3: DataView = new DataView(dv3B.buffer, dv3B.byteOffset, dv3B.byteLength);
        let dv4: DataView = new DataView(dv4B.buffer, dv4B.byteOffset, dv4B.byteLength);

        assert(crypto.timingSafeEqual(dv1, dv2));
        assert(crypto.timingSafeEqual(dv1, dv1B));
        assert(crypto.timingSafeEqual(dv2, dv1B));
        assert(crypto.timingSafeEqual(dv3, dv4));

        assert(!crypto.timingSafeEqual(dv1, dv3));
        assert(!crypto.timingSafeEqual(dv2, dv3));
        assert(!crypto.timingSafeEqual(dv1, dv4));
        // ... I'm not going to write all those tests.
    }

    {
        // crypto_timingsafeequal_uint32array_test
        let ui32_1: Uint32Array = Uint32Array.of(1, 2, 3, 4, 5);
        let ui32_2: Uint32Array = Uint32Array.of(1, 2, 3, 4, 5);
        let ui32_3: Uint32Array = Uint32Array.of(5, 4, 3, 2, 1);

        assert(crypto.timingSafeEqual(ui32_1, ui32_2));
        assert(!crypto.timingSafeEqual(ui32_1, ui32_3));
    }

    {
        // crypto_randomfill_buffer_test
        let buffer: Buffer = new Buffer(10);
        crypto.randomFillSync(buffer);
        crypto.randomFillSync(buffer, 2);
        crypto.randomFillSync(buffer, 2, 3);

        crypto.randomFill(buffer, (err: Error, buf: Buffer) => void {});
        crypto.randomFill(buffer, 2, (err: Error, buf: Buffer) => void {});
        crypto.randomFill(buffer, 2, 3, (err: Error, buf: Buffer) => void {});

        // crypto_randomfill_uint8array_test
        let ui8arr: Uint8Array = new Uint8Array(10);
        crypto.randomFillSync(ui8arr);
        crypto.randomFillSync(ui8arr, 2);
        crypto.randomFillSync(ui8arr, 2, 3);

        crypto.randomFill(ui8arr, (err: Error, buf: Uint8Array) => void {});
        crypto.randomFill(ui8arr, 2, (err: Error, buf: Uint8Array) => void {});
        crypto.randomFill(ui8arr, 2, 3, (err: Error, buf: Uint8Array) => void {});

        // crypto_randomfill_int32array_test
        let i32arr: Int32Array = new Int32Array(10);
        crypto.randomFillSync(i32arr);
        crypto.randomFillSync(i32arr, 2);
        crypto.randomFillSync(i32arr, 2, 3);

        crypto.randomFill(i32arr, (err: Error, buf: Int32Array) => void {});
        crypto.randomFill(i32arr, 2, (err: Error, buf: Int32Array) => void {});
        crypto.randomFill(i32arr, 2, 3, (err: Error, buf: Int32Array) => void {});
    }

    {
        // scrypt
        const pwd: string | Buffer | Int32Array | DataView = Buffer.alloc(16);
        const salt: string | Buffer | Int32Array | DataView = Buffer.alloc(16);
        crypto.scrypt(pwd, salt, 64, (err: Error | null, derivedKey: Buffer): void => {});
        const opts: crypto.ScryptOptions = {
            N: 16384,
            r: 8,
            p: 1,
            maxmem: 32 * 1024 * 1024
        };
        crypto.scrypt(pwd, salt, 64, opts, (err: Error | null, derivedKey: Buffer): void => {});
        crypto.scrypt(pwd, salt, 64, { maxmem: 16 * 1024 * 1024 }, (err: Error | null, derivedKey: Buffer): void => {});
        let buf: Buffer = crypto.scryptSync(pwd, salt, 64);
        buf = crypto.scryptSync(pwd, salt, 64, opts);
        buf = crypto.scryptSync(pwd, salt, 64, { N: 1024 });
    }

    {
        let key: string | Buffer = Buffer.from("buf");
        let curve = "secp256k1";
        let ret: string | Buffer = crypto.ECDH.convertKey(key, curve);
        key = "0xfff";
        ret = crypto.ECDH.convertKey(key, curve);
        ret = crypto.ECDH.convertKey(key, curve, "hex");
        ret = crypto.ECDH.convertKey(key, curve, "hex", "hex");
        ret = crypto.ECDH.convertKey(key, curve, "hex", "hex", "uncompressed");
        ret = crypto.ECDH.convertKey(key, curve, "hex", "hex", "compressed");
        ret = crypto.ECDH.convertKey(key, curve, "hex", "hex", "hybrid");
    }
}

//////////////////////////////////////////////////
/// TLS tests : http://nodejs.org/api/tls.html ///
//////////////////////////////////////////////////

namespace tls_tests {
    {
        var ctx: tls.SecureContext = tls.createSecureContext({
            key: "NOT REALLY A KEY",
            cert: "SOME CERTIFICATE",
        });
        var blah = ctx.context;

        var connOpts: tls.ConnectionOptions = {
            host: "127.0.0.1",
            port: 55
        };
        var tlsSocket = tls.connect(connOpts);

        const ciphers: string[] = tls.getCiphers();
        const curve: string = tls.DEFAULT_ECDH_CURVE;
    }

    {
        let _server: tls.Server;
        let _boolean: boolean;
        let _func1 = (err: Error, resp: Buffer) => { };
        let _func2 = (err: Error, sessionData: any) => { };
        /**
         * events.EventEmitter
         * 1. tlsClientError
         * 2. newSession
         * 3. OCSPRequest
         * 4. resumeSession
         * 5. secureConnection
         */

        _server = _server.addListener("tlsClientError", (err, tlsSocket) => {
            let _err: Error = err;
            let _tlsSocket: tls.TLSSocket = tlsSocket;
        });
        _server = _server.addListener("newSession", (sessionId, sessionData, callback) => {
            let _sessionId: any = sessionId;
            let _sessionData: any = sessionData;
            let _func1 = callback;
        });
        _server = _server.addListener("OCSPRequest", (certificate, issuer, callback) => {
            let _certificate: Buffer = certificate;
            let _issuer: Buffer = issuer;
            let _callback: Function = callback;
        });
        _server = _server.addListener("resumeSession", (sessionId, callback) => {
            let _sessionId: any = sessionId;
            let _func2 = callback;
        });
        _server = _server.addListener("secureConnection", (tlsSocket) => {
            let _tlsSocket: tls.TLSSocket = tlsSocket;
        });

        let _err: Error;
        let _tlsSocket: tls.TLSSocket;
        let _any: any;
        let _func: Function;
        let _buffer: Buffer;
        _boolean = _server.emit("tlsClientError", _err, _tlsSocket);
        _boolean = _server.emit("newSession", _any, _any, _func1);
        _boolean = _server.emit("OCSPRequest", _buffer, _buffer, _func);
        _boolean = _server.emit("resumeSession", _any, _func2);
        _boolean = _server.emit("secureConnection", _tlsSocket);

        _server = _server.on("tlsClientError", (err, tlsSocket) => {
            let _err: Error = err;
            let _tlsSocket: tls.TLSSocket = tlsSocket;
        });
        _server = _server.on("newSession", (sessionId, sessionData, callback) => {
            let _sessionId: any = sessionId;
            let _sessionData: any = sessionData;
            let _func1 = callback;
        });
        _server = _server.on("OCSPRequest", (certificate, issuer, callback) => {
            let _certificate: Buffer = certificate;
            let _issuer: Buffer = issuer;
            let _callback: Function = callback;
        });
        _server = _server.on("resumeSession", (sessionId, callback) => {
            let _sessionId: any = sessionId;
            let _func2 = callback;
        });
        _server = _server.on("secureConnection", (tlsSocket) => {
            let _tlsSocket: tls.TLSSocket = tlsSocket;
        });

        _server = _server.once("tlsClientError", (err, tlsSocket) => {
            let _err: Error = err;
            let _tlsSocket: tls.TLSSocket = tlsSocket;
        });
        _server = _server.once("newSession", (sessionId, sessionData, callback) => {
            let _sessionId: any = sessionId;
            let _sessionData: any = sessionData;
            let _func1 = callback;
        });
        _server = _server.once("OCSPRequest", (certificate, issuer, callback) => {
            let _certificate: Buffer = certificate;
            let _issuer: Buffer = issuer;
            let _callback: Function = callback;
        });
        _server = _server.once("resumeSession", (sessionId, callback) => {
            let _sessionId: any = sessionId;
            let _func2 = callback;
        });
        _server = _server.once("secureConnection", (tlsSocket) => {
            let _tlsSocket: tls.TLSSocket = tlsSocket;
        });

        _server = _server.prependListener("tlsClientError", (err, tlsSocket) => {
            let _err: Error = err;
            let _tlsSocket: tls.TLSSocket = tlsSocket;
        });
        _server = _server.prependListener("newSession", (sessionId, sessionData, callback) => {
            let _sessionId: any = sessionId;
            let _sessionData: any = sessionData;
            let _func1 = callback;
        });
        _server = _server.prependListener("OCSPRequest", (certificate, issuer, callback) => {
            let _certificate: Buffer = certificate;
            let _issuer: Buffer = issuer;
            let _callback: Function = callback;
        });
        _server = _server.prependListener("resumeSession", (sessionId, callback) => {
            let _sessionId: any = sessionId;
            let _func2 = callback;
        });
        _server = _server.prependListener("secureConnection", (tlsSocket) => {
            let _tlsSocket: tls.TLSSocket = tlsSocket;
        });

        _server = _server.prependOnceListener("tlsClientError", (err, tlsSocket) => {
            let _err: Error = err;
            let _tlsSocket: tls.TLSSocket = tlsSocket;
        });
        _server = _server.prependOnceListener("newSession", (sessionId, sessionData, callback) => {
            let _sessionId: any = sessionId;
            let _sessionData: any = sessionData;
            let _func1 = callback;
        });
        _server = _server.prependOnceListener("OCSPRequest", (certificate, issuer, callback) => {
            let _certificate: Buffer = certificate;
            let _issuer: Buffer = issuer;
            let _callback: Function = callback;
        });
        _server = _server.prependOnceListener("resumeSession", (sessionId, callback) => {
            let _sessionId: any = sessionId;
            let _func2 = callback;
        });
        _server = _server.prependOnceListener("secureConnection", (tlsSocket) => {
            let _tlsSocket: tls.TLSSocket = tlsSocket;
        });

        // close callback parameter is optional
        _server = _server.close();

        // close callback parameter doesn't specify any arguments, so any
        // function is acceptable
        _server = _server.close(() => { });
        _server = _server.close((...args: any[]) => { });
    }

    {
        let _TLSSocket: tls.TLSSocket;
        let _boolean: boolean;
        /**
         * events.EventEmitter
         * 1. close
         * 2. error
         * 3. listening
         * 4. message
         */

        _TLSSocket = _TLSSocket.addListener("OCSPResponse", (response) => {
            let _response: Buffer = response;
        });
        _TLSSocket = _TLSSocket.addListener("secureConnect", () => { });

        let _buffer: Buffer;
        _boolean = _TLSSocket.emit("OCSPResponse", _buffer);
        _boolean = _TLSSocket.emit("secureConnect");

        _TLSSocket = _TLSSocket.on("OCSPResponse", (response) => {
            let _response: Buffer = response;
        });
        _TLSSocket = _TLSSocket.on("secureConnect", () => { });

        _TLSSocket = _TLSSocket.once("OCSPResponse", (response) => {
            let _response: Buffer = response;
        });
        _TLSSocket = _TLSSocket.once("secureConnect", () => { });

        _TLSSocket = _TLSSocket.prependListener("OCSPResponse", (response) => {
            let _response: Buffer = response;
        });
        _TLSSocket = _TLSSocket.prependListener("secureConnect", () => { });

        _TLSSocket = _TLSSocket.prependOnceListener("OCSPResponse", (response) => {
            let _response: Buffer = response;
        });
        _TLSSocket = _TLSSocket.prependOnceListener("secureConnect", () => { });
    }
}

////////////////////////////////////////////////////
/// Http tests : http://nodejs.org/api/http.html ///
////////////////////////////////////////////////////

namespace http_tests {
    // http Server
    {
        var server: http.Server = new http.Server();

        // test public props
        const maxHeadersCount: number = server.maxHeadersCount;
        const timeout: number = server.timeout;
        const listening: boolean = server.listening;
        const keepAliveTimeout: number = server.keepAliveTimeout;
        server.setTimeout().setTimeout(1000).setTimeout(() => {}).setTimeout(100, () => {});
    }

    // http IncomingMessage
    // http ServerResponse
    {
        // incoming
        var incoming: http.IncomingMessage = new http.IncomingMessage(new net.Socket());

        incoming.setEncoding('utf8');

        // stream
        incoming.pause();
        incoming.resume();

        // response
        var res: http.ServerResponse = new http.ServerResponse(incoming);

        // test headers
        res.setHeader('Content-Type', 'text/plain');
        var bool: boolean = res.hasHeader('Content-Type');
        var headers: string[] = res.getHeaderNames();

        // trailers
        res.addTrailers([
            ['x-fOo', 'xOxOxOx'],
            ['x-foO', 'OxOxOxO'],
            ['X-fOo', 'xOxOxOx'],
            ['X-foO', 'OxOxOxO']
        ]);
        res.addTrailers({ 'x-foo': 'bar' });

        // writeHead
        res.writeHead(200, 'OK\r\nContent-Type: text/html\r\n');
        res.writeHead(200, { 'Transfer-Encoding': 'chunked' });
        res.writeHead(200);

        // write string
        res.write('Part of my res.');
        // write buffer
        const chunk = Buffer.alloc(16390, 'Й');
        req.write(chunk);
        res.write(chunk, 'hex');

        // end
        res.end("end msg");
        // without msg
        res.end();

        // flush
        res.flushHeaders();
    }

    // http ClientRequest
    {
        var req: http.ClientRequest = new http.ClientRequest("https://www.google.com");
        var req: http.ClientRequest = new http.ClientRequest(new url.URL("https://www.google.com"));
        var req: http.ClientRequest = new http.ClientRequest({ path: 'http://0.0.0.0' });

        // header
        req.setHeader('Content-Type', 'text/plain');
        var bool: boolean = req.hasHeader('Content-Type');
        var headers: string[] = req.getHeaderNames();
        req.removeHeader('Date');

        // write
        const chunk = Buffer.alloc(16390, 'Й');
        req.write(chunk);
        req.write('a');
        req.end();

        // abort
        req.abort();

        // connection
        req.connection.on('pause', () => { });

        // event
        req.on('data', () => { });
    }

    {
        // Status codes
        var codeMessage = http.STATUS_CODES['400'];
        var codeMessage = http.STATUS_CODES[400];
    }

    {
        var agent: http.Agent = new http.Agent({
            keepAlive: true,
            keepAliveMsecs: 10000,
            maxSockets: Infinity,
            maxFreeSockets: 256,
            timeout: 15000
        });

        var agent: http.Agent = http.globalAgent;

        http.request({ agent: false });
        http.request({ agent });
        http.request({ agent: undefined });
    }

    {
        http.get('http://www.example.com/xyz');
        http.request('http://www.example.com/xyz');

        http.get('http://www.example.com/xyz', (res: http.IncomingMessage): void => {});
        http.request('http://www.example.com/xyz', (res: http.IncomingMessage): void => {});

        http.get(new url.URL('http://www.example.com/xyz'));
        http.request(new url.URL('http://www.example.com/xyz'));

        http.get(new url.URL('http://www.example.com/xyz'), (res: http.IncomingMessage): void => {});
        http.request(new url.URL('http://www.example.com/xyz'), (res: http.IncomingMessage): void => {});

        const opts: http.RequestOptions = {
            path: '"/some/path'
        };
        http.get(new url.URL('http://www.example.com'), opts);
        http.request(new url.URL('http://www.example.com'), opts);
        http.get(new url.URL('http://www.example.com/xyz'), opts, (res: http.IncomingMessage): void => {});
        http.request(new url.URL('http://www.example.com/xyz'), opts, (res: http.IncomingMessage): void => {});
    }

    {
        // Make sure .listen() and .close() return a Server instance
        http.createServer().listen(0).close().address();
        net.createServer().listen(0).close().address();
    }

    {
        var request = http.request({ path: 'http://0.0.0.0' });
        request.once('error', () => { });
        request.setNoDelay(true);
        request.abort();
    }

    // http request options
    {
        const requestOpts: http.RequestOptions = {
            timeout: 30000
        };

        const clientArgs: http.ClientRequestArgs = {
            timeout: 30000
        };
    }

    // http headers
    {
        const headers: http.IncomingHttpHeaders = {
            'content-type': 'application/json',
            'set-cookie': [ 'type=ninja', 'language=javascript' ]
        };
    }
}

//////////////////////////////////////////////////////
/// Https tests : http://nodejs.org/api/https.html ///
//////////////////////////////////////////////////////

namespace https_tests {
    var agent: https.Agent = new https.Agent({
        keepAlive: true,
        keepAliveMsecs: 10000,
        maxSockets: Infinity,
        maxFreeSockets: 256,
        maxCachedSessions: 100,
        timeout: 15000
    });

    var agent: https.Agent = https.globalAgent;

    https.request({
        agent: false
    });
    https.request({
        agent
    });
    https.request({
        agent: undefined
    });

    https.get('http://www.example.com/xyz');
    https.request('http://www.example.com/xyz');

    https.get('http://www.example.com/xyz', (res: http.IncomingMessage): void => {});
    https.request('http://www.example.com/xyz', (res: http.IncomingMessage): void => {});

    https.get(new url.URL('http://www.example.com/xyz'));
    https.request(new url.URL('http://www.example.com/xyz'));

    https.get(new url.URL('http://www.example.com/xyz'), (res: http.IncomingMessage): void => {});
    https.request(new url.URL('http://www.example.com/xyz'), (res: http.IncomingMessage): void => {});

    const opts: https.RequestOptions = {
        path: '/some/path'
    };
    https.get(new url.URL('http://www.example.com'), opts);
    https.request(new url.URL('http://www.example.com'), opts);
    https.get(new url.URL('http://www.example.com/xyz'), opts, (res: http.IncomingMessage): void => {});
    https.request(new url.URL('http://www.example.com/xyz'), opts, (res: http.IncomingMessage): void => {});

    https.globalAgent.options.ca = [];

    {
        const server = new https.Server();

        const timeout: number = server.timeout;
        const listening: boolean = server.listening;
        const keepAliveTimeout: number = server.keepAliveTimeout;
        server.setTimeout().setTimeout(1000).setTimeout(() => {}).setTimeout(100, () => {});
    }
}

////////////////////////////////////////////////////
/// TTY tests : http://nodejs.org/api/tty.html
////////////////////////////////////////////////////

namespace tty_tests {
    let rs: tty.ReadStream;
    let ws: tty.WriteStream;

    let rsIsRaw: boolean = rs.isRaw;
    rs.setRawMode(true);

    let wsColumns: number = ws.columns;
    let wsRows: number = ws.rows;

    let isTTY: boolean = tty.isatty(1);
}

////////////////////////////////////////////////////
/// Dgram tests : http://nodejs.org/api/dgram.html
////////////////////////////////////////////////////

namespace dgram_tests {
    {
        var ds: dgram.Socket = dgram.createSocket("udp4", (msg: Buffer, rinfo: dgram.RemoteInfo): void => {
        });
        ds.bind();
        ds.bind(41234);
        ds.bind(4123, 'localhost');
        ds.bind(4123, 'localhost', () => { });
        ds.bind(4123, () => { });
        ds.bind(() => { });
        const addr: net.AddressInfo | string = ds.address();
        ds.send(new Buffer("hello"), 0, 5, 5000, "127.0.0.1", (error: Error, bytes: number): void => {
        });
        ds.send(new Buffer("hello"), 5000, "127.0.0.1");
        ds.setMulticastInterface("127.0.0.1");
        ds = dgram.createSocket({ type: "udp4", reuseAddr: true, recvBufferSize: 1000, sendBufferSize: 1000, lookup: dns.lookup });
    }

    {
        let _socket: dgram.Socket;
        let _boolean: boolean;
        let _err: Error;
        let _str: string;
        let _rinfo: net.AddressInfo;
        /**
         * events.EventEmitter
         * 1. close
         * 2. error
         * 3. listening
         * 4. message
         */

        _socket = _socket.addListener("close", () => { });
        _socket = _socket.addListener("error", (err) => {
            let _err: Error = err;
        });
        _socket = _socket.addListener("listening", () => { });
        _socket = _socket.addListener("message", (msg, rinfo) => {
            let _msg: Buffer = msg;
            let _rinfo: net.AddressInfo = rinfo;
        });

        _boolean = _socket.emit("close");
        _boolean = _socket.emit("error", _err);
        _boolean = _socket.emit("listening");
        _boolean = _socket.emit("message", _str, _rinfo);

        _socket = _socket.on("close", () => { });
        _socket = _socket.on("error", (err) => {
            let _err: Error = err;
        });
        _socket = _socket.on("listening", () => { });
        _socket = _socket.on("message", (msg, rinfo) => {
            let _msg: Buffer = msg;
            let _rinfo: net.AddressInfo = rinfo;
        });

        _socket = _socket.once("close", () => { });
        _socket = _socket.once("error", (err) => {
            let _err: Error = err;
        });
        _socket = _socket.once("listening", () => { });
        _socket = _socket.once("message", (msg, rinfo) => {
            let _msg: Buffer = msg;
            let _rinfo: net.AddressInfo = rinfo;
        });

        _socket = _socket.prependListener("close", () => { });
        _socket = _socket.prependListener("error", (err) => {
            let _err: Error = err;
        });
        _socket = _socket.prependListener("listening", () => { });
        _socket = _socket.prependListener("message", (msg, rinfo) => {
            let _msg: Buffer = msg;
            let _rinfo: net.AddressInfo = rinfo;
        });

        _socket = _socket.prependOnceListener("close", () => { });
        _socket = _socket.prependOnceListener("error", (err) => {
            let _err: Error = err;
        });
        _socket = _socket.prependOnceListener("listening", () => { });
        _socket = _socket.prependOnceListener("message", (msg, rinfo) => {
            let _msg: Buffer = msg;
            let _rinfo: net.AddressInfo = rinfo;
        });
    }

    {
        let ds: dgram.Socket = dgram.createSocket({
            type: 'udp4',
            recvBufferSize: 10000,
            sendBufferSize: 15000
        });

        let size: number;
        size = ds.getRecvBufferSize();
        ds.setRecvBufferSize(size);
        size = ds.getSendBufferSize();
        ds.setSendBufferSize(size);
    }
}

////////////////////////////////////////////////////
/// Querystring tests : https://nodejs.org/api/querystring.html
////////////////////////////////////////////////////

namespace querystring_tests {
    interface SampleObject { a: string; b: number; }

    {
        let obj: SampleObject;
        let sep: string;
        let eq: string;
        let options: querystring.StringifyOptions;
        let result: string;

        result = querystring.stringify<SampleObject>(obj);
        result = querystring.stringify<SampleObject>(obj, sep);
        result = querystring.stringify<SampleObject>(obj, sep, eq);
        result = querystring.stringify<SampleObject>(obj, sep, eq);
        result = querystring.stringify<SampleObject>(obj, sep, eq, options);
    }

    {
        let str: string;
        let sep: string;
        let eq: string;
        let options: querystring.ParseOptions;
        let result: SampleObject;

        result = querystring.parse<SampleObject>(str);
        result = querystring.parse<SampleObject>(str, sep);
        result = querystring.parse<SampleObject>(str, sep, eq);
        result = querystring.parse<SampleObject>(str, sep, eq, options);
    }

    {
        let str: string;
        let result: string;

        result = querystring.escape(str);
        result = querystring.unescape(str);
    }
}

////////////////////////////////////////////////////
/// path tests : http://nodejs.org/api/path.html
////////////////////////////////////////////////////

namespace path_tests {
    path.normalize('/foo/bar//baz/asdf/quux/..');

    path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');
    // returns
    // '/foo/bar/baz/asdf'

    try {
        path.join('foo', 'bar');
    } catch (error) { }

    path.resolve('foo/bar', '/tmp/file/', '..', 'a/../subfile');
    // Is similar to:
    //
    // cd foo/bar
    // cd /tmp/file/
    // cd ..
    //    cd a/../subfile
    // pwd

    path.resolve('/foo/bar', './baz');
    // returns
    //    '/foo/bar/baz'

    path.resolve('/foo/bar', '/tmp/file/');
    // returns
    //    '/tmp/file'

    path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif');
    // if currently in /home/myself/node, it returns
    //    '/home/myself/node/wwwroot/static_files/gif/image.gif'

    path.isAbsolute('/foo/bar'); // true
    path.isAbsolute('/baz/..');  // true
    path.isAbsolute('qux/');     // false
    path.isAbsolute('.');        // false

    path.isAbsolute('//server');  // true
    path.isAbsolute('C:/foo/..'); // true
    path.isAbsolute('bar\\baz');   // false
    path.isAbsolute('.');         // false

    path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb');
    // returns
    //    '..\\..\\impl\\bbb'

    path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb');
    // returns
    //    '../../impl/bbb'

    path.dirname('/foo/bar/baz/asdf/quux');
    // returns
    //    '/foo/bar/baz/asdf'

    path.basename('/foo/bar/baz/asdf/quux.html');
    // returns
    //    'quux.html'

    path.basename('/foo/bar/baz/asdf/quux.html', '.html');
    // returns
    //    'quux'

    path.extname('index.html');
    // returns
    //    '.html'

    path.extname('index.coffee.md');
    // returns
    //    '.md'

    path.extname('index.');
    // returns
    //    '.'

    path.extname('index');
    // returns
    //    ''

    'foo/bar/baz'.split(path.sep);
    // returns
    //        ['foo', 'bar', 'baz']

    'foo\\bar\\baz'.split(path.sep);
    // returns
    //        ['foo', 'bar', 'baz']

    process.env["PATH"]; // $ExpectType string

    path.parse('/home/user/dir/file.txt');
    // returns
    //    {
    //        root : "/",
    //        dir : "/home/user/dir",
    //        base : "file.txt",
    //        ext : ".txt",
    //        name : "file"
    //    }

    path.parse('C:\\path\\dir\\index.html');
    // returns
    //    {
    //        root : "C:\",
    //        dir : "C:\path\dir",
    //        base : "index.html",
    //        ext : ".html",
    //        name : "index"
    //    }

    path.format({
        root: "/",
        dir: "/home/user/dir",
        base: "file.txt",
        ext: ".txt",
        name: "file"
    });
    // returns
    //    '/home/user/dir/file.txt'

    path.format({
        root: "/",
        dir: "/home/user/dir",
        ext: ".txt",
        name: "file"
    });
    // returns
    //    '/home/user/dir/file.txt'

    path.format({
        dir: "/home/user/dir",
        base: "file.txt"
    });
    // returns
    //    '/home/user/dir/file.txt'

    path.posix.format({
        root: "/",
        dir: "/home/user/dir",
        base: "file.txt",
        ext: ".txt",
        name: "file"
    });
    // returns
    //    '/home/user/dir/file.txt'

    path.posix.format({
        dir: "/home/user/dir",
        base: "file.txt"
    });
    // returns
    //    '/home/user/dir/file.txt'

    path.win32.format({
        root: "C:\\",
        dir: "C:\\home\\user\\dir",
        ext: ".txt",
        name: "file"
    });
    // returns
    //    'C:\home\user\dir\file.txt'

    path.win32.format({
        dir: "C:\\home\\user\\dir",
        base: "file.txt"
    });
    // returns
    //    'C:\home\user\dir\file.txt'
}

////////////////////////////////////////////////////
/// readline tests : https://nodejs.org/api/readline.html
////////////////////////////////////////////////////

namespace readline_tests {
    let rl: readline.ReadLine;

    {
        let options: readline.ReadLineOptions;
        let input: NodeJS.ReadableStream;
        let output: NodeJS.WritableStream;
        let completer: readline.Completer;
        let terminal: boolean;

        let result: readline.ReadLine;

        result = readline.createInterface(options);
        result = readline.createInterface(input);
        result = readline.createInterface(input, output);
        result = readline.createInterface(input, output, completer);
        result = readline.createInterface(input, output, completer, terminal);
        result = readline.createInterface({
            input,
            completer(str: string): readline.CompleterResult {
                return [['test'], 'test'];
            }
        });
        result = readline.createInterface({
            input,
            completer(str: string, callback: (err: any, result: readline.CompleterResult) => void): any {
                callback(null, [['test'], 'test']);
            }
        });
    }

    {
        let prompt: string;

        rl.setPrompt(prompt);
    }

    {
        let preserveCursor: boolean;

        rl.prompt();
        rl.prompt(preserveCursor);
    }

    {
        let query: string;
        let callback: (answer: string) => void;

        rl.question(query, callback);
    }

    {
        let result: readline.ReadLine;

        result = rl.pause();
    }

    {
        let result: readline.ReadLine;

        result = rl.resume();
    }

    {
        rl.close();
    }

    {
        let data: string | Buffer;
        let key: readline.Key;

        rl.write(data);
        rl.write(null, key);
    }

    {
        let stream: NodeJS.WritableStream;
        let x: number;
        let y: number;

        readline.cursorTo(stream, x);
        readline.cursorTo(stream, x, y);
    }

    {
        let stream: NodeJS.ReadableStream;
        let readLineInterface: readline.ReadLine;

        readline.emitKeypressEvents(stream);
        readline.emitKeypressEvents(stream, readLineInterface);
    }

    {
        let stream: NodeJS.WritableStream;
        let dx: number | string;
        let dy: number | string;

        readline.moveCursor(stream, dx, dy);
    }

    {
        let stream: NodeJS.WritableStream;
        let dir: number;

        readline.clearLine(stream, dir);
    }

    {
        let stream: NodeJS.WritableStream;

        readline.clearScreenDown(stream);
    }

    {
        let _rl: readline.ReadLine;
        let _boolean: boolean;

        _rl = _rl.addListener("close", () => { });
        _rl = _rl.addListener("line", (input) => {
            let _input: any = input;
        });
        _rl = _rl.addListener("pause", () => { });
        _rl = _rl.addListener("resume", () => { });
        _rl = _rl.addListener("SIGCONT", () => { });
        _rl = _rl.addListener("SIGINT", () => { });
        _rl = _rl.addListener("SIGTSTP", () => { });

        _boolean = _rl.emit("close", () => { });
        _boolean = _rl.emit("line", () => { });
        _boolean = _rl.emit("pause", () => { });
        _boolean = _rl.emit("resume", () => { });
        _boolean = _rl.emit("SIGCONT", () => { });
        _boolean = _rl.emit("SIGINT", () => { });
        _boolean = _rl.emit("SIGTSTP", () => { });

        _rl = _rl.on("close", () => { });
        _rl = _rl.on("line", (input) => {
            let _input: any = input;
        });
        _rl = _rl.on("pause", () => { });
        _rl = _rl.on("resume", () => { });
        _rl = _rl.on("SIGCONT", () => { });
        _rl = _rl.on("SIGINT", () => { });
        _rl = _rl.on("SIGTSTP", () => { });

        _rl = _rl.once("close", () => { });
        _rl = _rl.once("line", (input) => {
            let _input: any = input;
        });
        _rl = _rl.once("pause", () => { });
        _rl = _rl.once("resume", () => { });
        _rl = _rl.once("SIGCONT", () => { });
        _rl = _rl.once("SIGINT", () => { });
        _rl = _rl.once("SIGTSTP", () => { });

        _rl = _rl.prependListener("close", () => { });
        _rl = _rl.prependListener("line", (input) => {
            let _input: any = input;
        });
        _rl = _rl.prependListener("pause", () => { });
        _rl = _rl.prependListener("resume", () => { });
        _rl = _rl.prependListener("SIGCONT", () => { });
        _rl = _rl.prependListener("SIGINT", () => { });
        _rl = _rl.prependListener("SIGTSTP", () => { });

        _rl = _rl.prependOnceListener("close", () => { });
        _rl = _rl.prependOnceListener("line", (input) => {
            let _input: any = input;
        });
        _rl = _rl.prependOnceListener("pause", () => { });
        _rl = _rl.prependOnceListener("resume", () => { });
        _rl = _rl.prependOnceListener("SIGCONT", () => { });
        _rl = _rl.prependOnceListener("SIGINT", () => { });
        _rl = _rl.prependOnceListener("SIGTSTP", () => { });
    }
}

////////////////////////////////////////////////////
/// string_decoder tests : https://nodejs.org/api/string_decoder.html
////////////////////////////////////////////////////

namespace string_decoder_tests {
    const StringDecoder = string_decoder.StringDecoder;
    const buffer = new Buffer('test');
    const decoder1 = new StringDecoder();
    const decoder2 = new StringDecoder('utf8');
    const part1: string = decoder1.write(new Buffer('test'));
    const end1: string = decoder1.end();
    const part2: string = decoder2.write(new Buffer('test'));
    const end2: string = decoder1.end(new Buffer('test'));
}

//////////////////////////////////////////////////////////////////////
/// Child Process tests: https://nodejs.org/api/child_process.html ///
//////////////////////////////////////////////////////////////////////

namespace child_process_tests {
    {
        childProcess.exec("echo test");
        childProcess.exec("echo test", { windowsHide: true });
        childProcess.spawn("echo", ["test"], { windowsHide: true });
        childProcess.spawn("echo", ["test"], { windowsHide: true, argv0: "echo-test" });
        childProcess.spawn("echo", ["test"], { stdio: [0xdeadbeef, "inherit", undefined, "pipe"] });
        childProcess.spawnSync("echo test");
        childProcess.spawnSync("echo test", {windowsVerbatimArguments: false});
        childProcess.spawnSync("echo test", {windowsVerbatimArguments: false, argv0: "echo-test"});
    }

    {
        childProcess.execFile("npm", () => {});
        childProcess.execFile("npm", { windowsHide: true }, () => {});
        childProcess.execFile("npm", ["-v"], () => {});
        childProcess.execFile("npm", ["-v"], { windowsHide: true, encoding: 'utf-8' }, (stdout, stderr) => { assert(stdout instanceof String); });
        childProcess.execFile("npm", ["-v"], { windowsHide: true, encoding: 'buffer' }, (stdout, stderr) => { assert(stdout instanceof Buffer); });
        childProcess.execFile("npm", { encoding: 'utf-8' }, (stdout, stderr) => { assert(stdout instanceof String); });
        childProcess.execFile("npm", { encoding: 'buffer' }, (stdout, stderr) => { assert(stdout instanceof Buffer); });
    }

    async function testPromisify() {
        const execFile = util.promisify(childProcess.execFile);
        let r: { stdout: string | Buffer, stderr: string | Buffer } = await execFile("npm");
        r = await execFile("npm", ["-v"]);
        r = await execFile("npm", ["-v"], { encoding: 'utf-8' });
        r = await execFile("npm", ["-v"], { encoding: 'buffer' });
        r = await execFile("npm", { encoding: 'utf-8' });
        r = await execFile("npm", { encoding: 'buffer' });
    }

    {
        let _cp: childProcess.ChildProcess;
        let _socket: net.Socket;
        let _server: net.Server;
        let _boolean: boolean;

        _boolean = _cp.send(1);
        _boolean = _cp.send('one');
        _boolean = _cp.send({
            type: 'test'
        });

        _boolean = _cp.send(1, (error) => {
            let _err: Error = error;
        });
        _boolean = _cp.send('one', (error) => {
            let _err: Error = error;
        });
        _boolean = _cp.send({
            type: 'test'
        }, (error) => {
            let _err: Error = error;
        });

        _boolean = _cp.send(1, _socket);
        _boolean = _cp.send('one', _socket);
        _boolean = _cp.send({
            type: 'test'
        }, _socket);

        _boolean = _cp.send(1, _socket, (error) => {
            let _err: Error = error;
        });
        _boolean = _cp.send('one', _socket, (error) => {
            let _err: Error = error;
        });
        _boolean = _cp.send({
            type: 'test'
        }, _socket, (error) => {
            let _err: Error = error;
        });

        _boolean = _cp.send(1, _socket, {
            keepOpen: true
        });
        _boolean = _cp.send('one', _socket, {
            keepOpen: true
        });
        _boolean = _cp.send({
            type: 'test'
        }, _socket, {
                keepOpen: true
            });

        _boolean = _cp.send(1, _socket, {
            keepOpen: true
        }, (error) => {
            let _err: Error = error;
        });
        _boolean = _cp.send('one', _socket, {
            keepOpen: true
        }, (error) => {
            let _err: Error = error;
        });
        _boolean = _cp.send({
            type: 'test'
        }, _socket, {
                keepOpen: true
            }, (error) => {
                let _err: Error = error;
            });

        _boolean = _cp.send(1, _server);
        _boolean = _cp.send('one', _server);
        _boolean = _cp.send({
            type: 'test'
        }, _server);

        _boolean = _cp.send(1, _server, (error) => {
            let _err: Error = error;
        });
        _boolean = _cp.send('one', _server, (error) => {
            let _err: Error = error;
        });
        _boolean = _cp.send({
            type: 'test'
        }, _server, (error) => {
            let _err: Error = error;
        });

        _boolean = _cp.send(1, _server, {
            keepOpen: true
        });
        _boolean = _cp.send('one', _server, {
            keepOpen: true
        });
        _boolean = _cp.send({
            type: 'test'
        }, _server, {
                keepOpen: true
            });

        _boolean = _cp.send(1, _server, {
            keepOpen: true
        }, (error) => {
            let _err: Error = error;
        });
        _boolean = _cp.send('one', _server, {
            keepOpen: true
        }, (error) => {
            let _err: Error = error;
        });
        _boolean = _cp.send({
            type: 'test'
        }, _server, {
                keepOpen: true
            }, (error) => {
                let _err: Error = error;
            });

        _cp = _cp.addListener("close", (code, signal) => {
            let _code: number = code;
            let _signal: string = signal;
        });
        _cp = _cp.addListener("disconnect", () => { });
        _cp = _cp.addListener("error", (err) => {
            let _err: Error = err;
        });
        _cp = _cp.addListener("exit", (code, signal) => {
            let _code: number = code;
            let _signal: string = signal;
        });
        _cp = _cp.addListener("message", (message, sendHandle) => {
            let _message: any = message;
            let _sendHandle: net.Socket | net.Server = sendHandle;
        });

        _boolean = _cp.emit("close", () => { });
        _boolean = _cp.emit("disconnect", () => { });
        _boolean = _cp.emit("error", () => { });
        _boolean = _cp.emit("exit", () => { });
        _boolean = _cp.emit("message", () => { });

        _cp = _cp.on("close", (code, signal) => {
            let _code: number = code;
            let _signal: string = signal;
        });
        _cp = _cp.on("disconnect", () => { });
        _cp = _cp.on("error", (err) => {
            let _err: Error = err;
        });
        _cp = _cp.on("exit", (code, signal) => {
            let _code: number = code;
            let _signal: string = signal;
        });
        _cp = _cp.on("message", (message, sendHandle) => {
            let _message: any = message;
            let _sendHandle: net.Socket | net.Server = sendHandle;
        });

        _cp = _cp.once("close", (code, signal) => {
            let _code: number = code;
            let _signal: string = signal;
        });
        _cp = _cp.once("disconnect", () => { });
        _cp = _cp.once("error", (err) => {
            let _err: Error = err;
        });
        _cp = _cp.once("exit", (code, signal) => {
            let _code: number = code;
            let _signal: string = signal;
        });
        _cp = _cp.once("message", (message, sendHandle) => {
            let _message: any = message;
            let _sendHandle: net.Socket | net.Server = sendHandle;
        });

        _cp = _cp.prependListener("close", (code, signal) => {
            let _code: number = code;
            let _signal: string = signal;
        });
        _cp = _cp.prependListener("disconnect", () => { });
        _cp = _cp.prependListener("error", (err) => {
            let _err: Error = err;
        });
        _cp = _cp.prependListener("exit", (code, signal) => {
            let _code: number = code;
            let _signal: string = signal;
        });
        _cp = _cp.prependListener("message", (message, sendHandle) => {
            let _message: any = message;
            let _sendHandle: net.Socket | net.Server = sendHandle;
        });

        _cp = _cp.prependOnceListener("close", (code, signal) => {
            let _code: number = code;
            let _signal: string = signal;
        });
        _cp = _cp.prependOnceListener("disconnect", () => { });
        _cp = _cp.prependOnceListener("error", (err) => {
            let _err: Error = err;
        });
        _cp = _cp.prependOnceListener("exit", (code, signal) => {
            let _code: number = code;
            let _signal: string = signal;
        });
        _cp = _cp.prependOnceListener("message", (message, sendHandle) => {
            let _message: any = message;
            let _sendHandle: net.Socket | net.Server = sendHandle;
        });
    }
    {
        process.stdin.setEncoding('utf8');

        process.stdin.on('readable', () => {
            const chunk = process.stdin.read();
            if (chunk !== null) {
              process.stdout.write(`data: ${chunk}`);
            }
        });

        process.stdin.on('end', () => {
            process.stdout.write('end');
        });

        process.stdin.pipe(process.stdout);

        console.log(process.stdin.isTTY);
        console.log(process.stdout.isTTY);

        console.log(process.stdin instanceof net.Socket);
        console.log(process.stdout instanceof fs.ReadStream);

        var stdin: stream.Readable = process.stdin;
        console.log(stdin instanceof net.Socket);
        console.log(stdin instanceof fs.ReadStream);

        var stdout: stream.Writable = process.stdout;
        console.log(stdout instanceof net.Socket);
        console.log(stdout instanceof fs.WriteStream);
    }
}

//////////////////////////////////////////////////////////////////////
/// cluster tests: https://nodejs.org/api/cluster.html ///
//////////////////////////////////////////////////////////////////////

namespace cluster_tests {
    {
        cluster.fork();
        Object.keys(cluster.workers).forEach(key => {
            const worker = cluster.workers[key];
            if (worker.isDead()) {
                console.log('worker %d is dead', worker.process.pid);
            }
        });
    }
}

////////////////////////////////////////////////////
/// os tests : https://nodejs.org/api/os.html
////////////////////////////////////////////////////

namespace os_tests {
    {
        let result: string;

        result = os.tmpdir();
        result = os.homedir();
        result = os.endianness();
        result = os.hostname();
        result = os.type();
        result = os.arch();
        result = os.release();
        result = os.EOL;
    }

    {
        let result: number;

        result = os.uptime();
        result = os.totalmem();
        result = os.freemem();
    }

    {
        let result: number[];

        result = os.loadavg();
    }

    {
        let result: os.CpuInfo[];

        result = os.cpus();
    }

    {
        let result: { [index: string]: os.NetworkInterfaceInfo[] };

        result = os.networkInterfaces();
    }

    {
        let result: number;

        result = os.constants.signals.SIGHUP;
        result = os.constants.signals.SIGINT;
        result = os.constants.signals.SIGQUIT;
        result = os.constants.signals.SIGILL;
        result = os.constants.signals.SIGTRAP;
        result = os.constants.signals.SIGABRT;
        result = os.constants.signals.SIGIOT;
        result = os.constants.signals.SIGBUS;
        result = os.constants.signals.SIGFPE;
        result = os.constants.signals.SIGKILL;
        result = os.constants.signals.SIGUSR1;
        result = os.constants.signals.SIGSEGV;
        result = os.constants.signals.SIGUSR2;
        result = os.constants.signals.SIGPIPE;
        result = os.constants.signals.SIGALRM;
        result = os.constants.signals.SIGTERM;
        result = os.constants.signals.SIGCHLD;
        result = os.constants.signals.SIGSTKFLT;
        result = os.constants.signals.SIGCONT;
        result = os.constants.signals.SIGSTOP;
        result = os.constants.signals.SIGTSTP;
        result = os.constants.signals.SIGTTIN;
        result = os.constants.signals.SIGTTOU;
        result = os.constants.signals.SIGURG;
        result = os.constants.signals.SIGXCPU;
        result = os.constants.signals.SIGXFSZ;
        result = os.constants.signals.SIGVTALRM;
        result = os.constants.signals.SIGPROF;
        result = os.constants.signals.SIGWINCH;
        result = os.constants.signals.SIGIO;
        result = os.constants.signals.SIGPOLL;
        result = os.constants.signals.SIGPWR;
        result = os.constants.signals.SIGSYS;
        result = os.constants.signals.SIGUNUSED;
    }

    {
        let result: number;

        result = os.constants.errno.E2BIG;
        result = os.constants.errno.EACCES;
        result = os.constants.errno.EADDRINUSE;
        result = os.constants.errno.EADDRNOTAVAIL;
        result = os.constants.errno.EAFNOSUPPORT;
        result = os.constants.errno.EAGAIN;
        result = os.constants.errno.EALREADY;
        result = os.constants.errno.EBADF;
        result = os.constants.errno.EBADMSG;
        result = os.constants.errno.EBUSY;
        result = os.constants.errno.ECANCELED;
        result = os.constants.errno.ECHILD;
        result = os.constants.errno.ECONNABORTED;
        result = os.constants.errno.ECONNREFUSED;
        result = os.constants.errno.ECONNRESET;
        result = os.constants.errno.EDEADLK;
        result = os.constants.errno.EDESTADDRREQ;
        result = os.constants.errno.EDOM;
        result = os.constants.errno.EDQUOT;
        result = os.constants.errno.EEXIST;
        result = os.constants.errno.EFAULT;
        result = os.constants.errno.EFBIG;
        result = os.constants.errno.EHOSTUNREACH;
        result = os.constants.errno.EIDRM;
        result = os.constants.errno.EILSEQ;
        result = os.constants.errno.EINPROGRESS;
        result = os.constants.errno.EINTR;
        result = os.constants.errno.EINVAL;
        result = os.constants.errno.EIO;
        result = os.constants.errno.EISCONN;
        result = os.constants.errno.EISDIR;
        result = os.constants.errno.ELOOP;
        result = os.constants.errno.EMFILE;
        result = os.constants.errno.EMLINK;
        result = os.constants.errno.EMSGSIZE;
        result = os.constants.errno.EMULTIHOP;
        result = os.constants.errno.ENAMETOOLONG;
        result = os.constants.errno.ENETDOWN;
        result = os.constants.errno.ENETRESET;
        result = os.constants.errno.ENETUNREACH;
        result = os.constants.errno.ENFILE;
        result = os.constants.errno.ENOBUFS;
        result = os.constants.errno.ENODATA;
        result = os.constants.errno.ENODEV;
        result = os.constants.errno.ENOENT;
        result = os.constants.errno.ENOEXEC;
        result = os.constants.errno.ENOLCK;
        result = os.constants.errno.ENOLINK;
        result = os.constants.errno.ENOMEM;
        result = os.constants.errno.ENOMSG;
        result = os.constants.errno.ENOPROTOOPT;
        result = os.constants.errno.ENOSPC;
        result = os.constants.errno.ENOSR;
        result = os.constants.errno.ENOSTR;
        result = os.constants.errno.ENOSYS;
        result = os.constants.errno.ENOTCONN;
        result = os.constants.errno.ENOTDIR;
        result = os.constants.errno.ENOTEMPTY;
        result = os.constants.errno.ENOTSOCK;
        result = os.constants.errno.ENOTSUP;
        result = os.constants.errno.ENOTTY;
        result = os.constants.errno.ENXIO;
        result = os.constants.errno.EOPNOTSUPP;
        result = os.constants.errno.EOVERFLOW;
        result = os.constants.errno.EPERM;
        result = os.constants.errno.EPIPE;
        result = os.constants.errno.EPROTO;
        result = os.constants.errno.EPROTONOSUPPORT;
        result = os.constants.errno.EPROTOTYPE;
        result = os.constants.errno.ERANGE;
        result = os.constants.errno.EROFS;
        result = os.constants.errno.ESPIPE;
        result = os.constants.errno.ESRCH;
        result = os.constants.errno.ESTALE;
        result = os.constants.errno.ETIME;
        result = os.constants.errno.ETIMEDOUT;
        result = os.constants.errno.ETXTBSY;
        result = os.constants.errno.EWOULDBLOCK;
        result = os.constants.errno.EXDEV;
    }
}

////////////////////////////////////////////////////
/// vm tests : https://nodejs.org/api/vm.html
////////////////////////////////////////////////////

namespace vm_tests {
    {
        const sandbox = {
            animal: 'cat',
            count: 2
        };

        const context = vm.createContext(sandbox);
        console.log(vm.isContext(context));
        const script = new vm.Script('count += 1; name = "kitty"');

        for (let i = 0; i < 10; ++i) {
            script.runInContext(context);
        }

        console.log(util.inspect(sandbox));

        vm.runInNewContext('count += 1; name = "kitty"', sandbox);
        console.log(util.inspect(sandbox));
    }

    {
        const sandboxes = [{}, {}, {}];

        const script = new vm.Script('globalVar = "set"');

        sandboxes.forEach((sandbox) => {
            script.runInNewContext(sandbox);
            script.runInThisContext();
        });

        console.log(util.inspect(sandboxes));

        var localVar = 'initial value';
        vm.runInThisContext('localVar = "vm";');

        console.log(localVar);
    }

    {
        const Debug = vm.runInDebugContext('Debug');
        Debug.scripts().forEach((script: any) => { console.log(script.name); });
    }

    {
        vm.runInThisContext('console.log("hello world"', './my-file.js');
    }
}

/////////////////////////////////////////////////////
/// Timers tests : https://nodejs.org/api/timers.html
/////////////////////////////////////////////////////

namespace timers_tests {
    {
        let immediateId = timers.setImmediate(() => { console.log("immediate"); });
        timers.clearImmediate(immediateId);
    }
    {
        let counter = 0;
        let timeout = timers.setInterval(() => { console.log("interval"); }, 20);
        timeout.unref();
        timeout.ref();
        timers.clearInterval(timeout);
    }
    {
        let counter = 0;
        let timeout = timers.setTimeout(() => { console.log("timeout"); }, 20);
        timeout.unref();
        timeout.ref();
        timers.clearTimeout(timeout);
    }
    async function testPromisify() {
        const setTimeout = util.promisify(timers.setTimeout);
        let v: void = await setTimeout(100); // tslint:disable-line no-void-expression void-return
        let s: string = await setTimeout(100, "");

        const setImmediate = util.promisify(timers.setImmediate);
        v = await setImmediate(); // tslint:disable-line no-void-expression
        s = await setImmediate("");
    }
}

/////////////////////////////////////////////////////////
/// Errors Tests : https://nodejs.org/api/errors.html ///
/////////////////////////////////////////////////////////

namespace errors_tests {
    {
        Error.stackTraceLimit = Infinity;
    }
    {
        const myObject = {};
        Error.captureStackTrace(myObject);
    }
    {
        let frames: NodeJS.CallSite[] = [];
        Error.prepareStackTrace(new Error(), frames);
    }
    {
        let frame: NodeJS.CallSite = null;
        let frameThis: any = frame.getThis();
        let typeName: string = frame.getTypeName();
        let func: Function = frame.getFunction();
        let funcName: string = frame.getFunctionName();
        let meth: string = frame.getMethodName();
        let fname: string = frame.getFileName();
        let lineno: number = frame.getLineNumber();
        let colno: number = frame.getColumnNumber();
        let evalOrigin: string = frame.getEvalOrigin();
        let isTop: boolean = frame.isToplevel();
        let isEval: boolean = frame.isEval();
        let isNative: boolean = frame.isNative();
        let isConstr: boolean = frame.isConstructor();
    }
}

///////////////////////////////////////////////////////////
/// Process Tests : https://nodejs.org/api/process.html ///
///////////////////////////////////////////////////////////

import * as p from "process";
namespace process_tests {
    {
        var eventEmitter: events.EventEmitter;
        eventEmitter = process;                // Test that process implements EventEmitter...

        var _p: NodeJS.Process = process;
        _p = p;
    }
    {
        assert(process.argv[0] === process.argv0);
    }
    {
        var module: NodeModule | undefined;
        module = process.mainModule;
    }
    {
        process.on("message", (req: any) => { });
        process.addListener("beforeExit", (code: number) => { });
        process.once("disconnect", () => { });
        process.prependListener("exit", (code: number) => { });
        process.prependOnceListener("rejectionHandled", (promise: Promise<any>) => { });
        process.on("uncaughtException", (error: Error) => { });
        process.addListener("unhandledRejection", (reason: any, promise: Promise<any>) => { });
        process.once("warning", (warning: Error) => { });
        process.prependListener("message", (message: any, sendHandle: any) => { });
        process.prependOnceListener("SIGBREAK", () => { });
        process.on("newListener", (event: string | symbol, listener: Function) => { });
        process.once("removeListener", (event: string | symbol, listener: Function) => { });

        const listeners = process.listeners('uncaughtException');
        const oldHandler = listeners[listeners.length - 1];
        process.addListener('uncaughtException', oldHandler);
    }
    {
        function myCb(err: Error): void {
        }
        process.setUncaughtExceptionCaptureCallback(myCb);
        process.setUncaughtExceptionCaptureCallback(null);
        const b: boolean = process.hasUncaughtExceptionCaptureCallback();
    }
}

///////////////////////////////////////////////////////////
/// Console Tests : https://nodejs.org/api/console.html ///
///////////////////////////////////////////////////////////

import * as c from "console";
namespace console_tests {
    {
        var _c: Console = console;
        _c = c;
    }
    {
        var writeStream = fs.createWriteStream('./index.d.ts');
        var consoleInstance = new console.Console(writeStream);
    }
}

///////////////////////////////////////////////////
/// Net Tests : https://nodejs.org/api/net.html ///
///////////////////////////////////////////////////

namespace net_tests {
    {
        const connectOpts: net.NetConnectOpts = {
            allowHalfOpen: true,
            family: 4,
            host: "localhost",
            port: 443,
            timeout: 10E3
        };
        const socket: net.Socket = net.createConnection(connectOpts, (): void => {
            // nothing
        });
    }

    {
        let server = net.createServer();
        // Check methods which return server instances by chaining calls
        server = server.listen(0)
            .close()
            .ref()
            .unref();

        // close has an optional callback function. No callback parameters are
        // specified, so any callback function is permissible.
        server = server.close((...args: any[]) => { });

        // test the types of the address object fields
        let address: net.AddressInfo | string = server.address();
    }

    {
        const constructorOpts: net.SocketConstructorOpts = {
            fd: 1,
            allowHalfOpen: false,
            readable: false,
            writable: false
        };

        /**
         * net.Socket - events.EventEmitter
         *   1. close
         *   2. connect
         *   3. data
         *   4. drain
         *   5. end
         *   6. error
         *   7. lookup
         *   8. timeout
         */
        let _socket: net.Socket = new net.Socket(constructorOpts);

        let bool: boolean;
        let buffer: Buffer;
        let error: Error;
        let str: string;
        let num: number;

        let ipcConnectOpts: net.IpcSocketConnectOpts = {
            path: "/"
        };
        let tcpConnectOpts: net.TcpSocketConnectOpts = {
            family: 4,
            hints: 0,
            host: "localhost",
            localAddress: "10.0.0.1",
            localPort: 1234,
            lookup: (_hostname: string, _options: dns.LookupOneOptions, _callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void => {
                // nothing
            },
            port: 80
        };
        _socket = _socket.connect(ipcConnectOpts);
        _socket = _socket.connect(ipcConnectOpts, (): void => {});
        _socket = _socket.connect(tcpConnectOpts);
        _socket = _socket.connect(tcpConnectOpts, (): void => {});
        _socket = _socket.connect(80, "localhost");
        _socket = _socket.connect(80, "localhost", (): void => {});
        _socket = _socket.connect(80);
        _socket = _socket.connect(80, (): void => {});

        /// addListener

        _socket = _socket.addListener("close", had_error => {
            bool = had_error;
        });
        _socket = _socket.addListener("connect", () => { });
        _socket = _socket.addListener("data", data => {
            buffer = data;
        });
        _socket = _socket.addListener("drain", () => { });
        _socket = _socket.addListener("end", () => { });
        _socket = _socket.addListener("error", err => {
            error = err;
        });
        _socket = _socket.addListener("lookup", (err, address, family, host) => {
            error = err;

            if (typeof family === 'string') {
                str = family;
            } else if (typeof family === 'number') {
                num = family;
            }

            str = host;
        });
        _socket = _socket.addListener("timeout", () => { });

        /// emit
        bool = _socket.emit("close", bool);
        bool = _socket.emit("connect");
        bool = _socket.emit("data", buffer);
        bool = _socket.emit("drain");
        bool = _socket.emit("end");
        bool = _socket.emit("error", error);
        bool = _socket.emit("lookup", error, str, str, str);
        bool = _socket.emit("lookup", error, str, num, str);
        bool = _socket.emit("timeout");

        /// on
        _socket = _socket.on("close", had_error => {
            bool = had_error;
        });
        _socket = _socket.on("connect", () => { });
        _socket = _socket.on("data", data => {
            buffer = data;
        });
        _socket = _socket.on("drain", () => { });
        _socket = _socket.on("end", () => { });
        _socket = _socket.on("error", err => {
            error = err;
        });
        _socket = _socket.on("lookup", (err, address, family, host) => {
            error = err;

            if (typeof family === 'string') {
                str = family;
            } else if (typeof family === 'number') {
                num = family;
            }

            str = host;
        });
        _socket = _socket.on("timeout", () => { });

        /// once
        _socket = _socket.once("close", had_error => {
            bool = had_error;
        });
        _socket = _socket.once("connect", () => { });
        _socket = _socket.once("data", data => {
            buffer = data;
        });
        _socket = _socket.once("drain", () => { });
        _socket = _socket.once("end", () => { });
        _socket = _socket.once("error", err => {
            error = err;
        });
        _socket = _socket.once("lookup", (err, address, family, host) => {
            error = err;

            if (typeof family === 'string') {
                str = family;
            } else if (typeof family === 'number') {
                num = family;
            }

            str = host;
        });
        _socket = _socket.once("timeout", () => { });

        /// prependListener
        _socket = _socket.prependListener("close", had_error => {
            bool = had_error;
        });
        _socket = _socket.prependListener("connect", () => { });
        _socket = _socket.prependListener("data", data => {
            buffer = data;
        });
        _socket = _socket.prependListener("drain", () => { });
        _socket = _socket.prependListener("end", () => { });
        _socket = _socket.prependListener("error", err => {
            error = err;
        });
        _socket = _socket.prependListener("lookup", (err, address, family, host) => {
            error = err;

            if (typeof family === 'string') {
                str = family;
            } else if (typeof family === 'number') {
                num = family;
            }

            str = host;
        });
        _socket = _socket.prependListener("timeout", () => { });

        /// prependOnceListener
        _socket = _socket.prependOnceListener("close", had_error => {
            bool = had_error;
        });
        _socket = _socket.prependOnceListener("connect", () => { });
        _socket = _socket.prependOnceListener("data", data => {
            buffer = data;
        });
        _socket = _socket.prependOnceListener("drain", () => { });
        _socket = _socket.prependOnceListener("end", () => { });
        _socket = _socket.prependOnceListener("error", err => {
            error = err;
        });
        _socket = _socket.prependOnceListener("lookup", (err, address, family, host) => {
            error = err;

            if (typeof family === 'string') {
                str = family;
            } else if (typeof family === 'number') {
                num = family;
            }

            str = host;
        });
        _socket = _socket.prependOnceListener("timeout", () => { });

        bool = _socket.connecting;
        bool = _socket.destroyed;
        _socket.destroy();
    }

    {
        /**
         * net.Server - events.EventEmitter
         *   1. close
         *   2. connection
         *   3. error
         *   4. listening
         */
        let _server: net.Server;

        let _socket: net.Socket;
        let bool: boolean;
        let error: Error;

        /// addListener
        _server = _server.addListener("close", () => { });
        _server = _server.addListener("connection", socket => {
            _socket = socket;
        });
        _server = _server.addListener("error", err => {
            error = err;
        });
        _server = _server.addListener("listening", () => { });

        /// emit
        bool = _server.emit("close");
        bool = _server.emit("connection", _socket);
        bool = _server.emit("error", error);
        bool = _server.emit("listening");

        /// once
        _server = _server.once("close", () => { });
        _server = _server.once("connection", socket => {
            _socket = socket;
        });
        _server = _server.once("error", err => {
            error = err;
        });
        _server = _server.once("listening", () => { });

        /// prependListener
        _server = _server.prependListener("close", () => { });
        _server = _server.prependListener("connection", socket => {
            _socket = socket;
        });
        _server = _server.prependListener("error", err => {
            error = err;
        });
        _server = _server.prependListener("listening", () => { });

        /// prependOnceListener
        _server = _server.prependOnceListener("close", () => { });
        _server = _server.prependOnceListener("connection", socket => {
            _socket = socket;
        });
        _server = _server.prependOnceListener("error", err => {
            error = err;
        });
        _server = _server.prependOnceListener("listening", () => { });
    }
}

/////////////////////////////////////////////////////
/// repl Tests : https://nodejs.org/api/repl.html ///
/////////////////////////////////////////////////////

namespace repl_tests {
    {
        let _server: repl.REPLServer;
        let _boolean: boolean;
        let _ctx: any;

        _server = _server.addListener("exit", () => { });
        _server = _server.addListener("reset", () => { });

        _boolean = _server.emit("exit", () => { });
        _boolean = _server.emit("reset", _ctx);

        _server = _server.on("exit", () => { });
        _server = _server.on("reset", () => { });

        _server = _server.once("exit", () => { });
        _server = _server.once("reset", () => { });

        _server = _server.prependListener("exit", () => { });
        _server = _server.prependListener("reset", () => { });

        _server = _server.prependOnceListener("exit", () => { });
        _server = _server.prependOnceListener("reset", () => { });

        _server.outputStream.write("test");
        let line = _server.inputStream.read();

        throw new repl.Recoverable(new Error("test"));
    }
}

///////////////////////////////////////////////////
/// DNS Tests : https://nodejs.org/api/dns.html ///
///////////////////////////////////////////////////

namespace dns_tests {
    dns.lookup("nodejs.org", (err, address, family) => {
        const _err: NodeJS.ErrnoException = err;
        const _address: string = address;
        const _family: number = family;
    });
    dns.lookup("nodejs.org", 4, (err, address, family) => {
        const _err: NodeJS.ErrnoException = err;
        const _address: string = address;
        const _family: number = family;
    });
    dns.lookup("nodejs.org", 6, (err, address, family) => {
        const _err: NodeJS.ErrnoException = err;
        const _address: string = address;
        const _family: number = family;
    });
    dns.lookup("nodejs.org", {}, (err, address, family) => {
        const _err: NodeJS.ErrnoException = err;
        const _address: string = address;
        const _family: number = family;
    });
    dns.lookup(
        "nodejs.org",
        {
            family: 4,
            hints: dns.ADDRCONFIG | dns.V4MAPPED,
            all: false
        },
        (err, address, family) => {
            const _err: NodeJS.ErrnoException = err;
            const _address: string = address;
            const _family: number = family;
        }
    );
    dns.lookup("nodejs.org", { all: true }, (err, addresses) => {
        const _err: NodeJS.ErrnoException = err;
        const _address: dns.LookupAddress[] = addresses;
    });

    function trueOrFalse(): boolean {
        return Math.random() > 0.5 ? true : false;
    }
    dns.lookup("nodejs.org", { all: trueOrFalse() }, (err, addresses, family) => {
        const _err: NodeJS.ErrnoException = err;
        const _addresses: string | dns.LookupAddress[] = addresses;
        const _family: number | undefined = family;
    });

    dns.lookupService("127.0.0.1", 0, (err, hostname, service) => {
        const _err: NodeJS.ErrnoException = err;
        const _hostname: string = hostname;
        const _service: string = service;
    });

    dns.resolve("nodejs.org", (err, addresses) => {
        const _addresses: string[] = addresses;
    });
    dns.resolve("nodejs.org", "A", (err, addresses) => {
        const _addresses: string[] = addresses;
    });
    dns.resolve("nodejs.org", "AAAA", (err, addresses) => {
        const _addresses: string[] = addresses;
    });
    dns.resolve("nodejs.org", "ANY", (err, addresses) => {
        const _addresses: dns.AnyRecord[] = addresses;
    });
    dns.resolve("nodejs.org", "MX", (err, addresses) => {
        const _addresses: dns.MxRecord[] = addresses;
    });

    dns.resolve4("nodejs.org", (err, addresses) => {
        const _addresses: string[] = addresses;
    });
    dns.resolve4("nodejs.org", { ttl: true }, (err, addresses) => {
        const _addresses: dns.RecordWithTtl[] = addresses;
    });
    {
        const ttl = false;
        dns.resolve4("nodejs.org", { ttl }, (err, addresses) => {
            const _addresses: string[] | dns.RecordWithTtl[] = addresses;
        });
    }

    dns.resolve6("nodejs.org", (err, addresses) => {
        const _addresses: string[] = addresses;
    });
    dns.resolve6("nodejs.org", { ttl: true }, (err, addresses) => {
        const _addresses: dns.RecordWithTtl[] = addresses;
    });
    {
        const ttl = false;
        dns.resolve6("nodejs.org", { ttl }, (err, addresses) => {
            const _addresses: string[] | dns.RecordWithTtl[] = addresses;
        });
    }
    {
        const resolver = new dns.Resolver();
        resolver.setServers(["4.4.4.4"]);
        resolver.resolve("nodejs.org", (err, addresses) => {
            const _addresses: string[] = addresses;
        });
        resolver.cancel();
    }
}

/*****************************************************************************
 *                                                                           *
 * The following tests are the modules not mentioned in document but existed *
 *                                                                           *
 *****************************************************************************/

///////////////////////////////////////////////////////////
/// Constants Tests                                     ///
///////////////////////////////////////////////////////////

import * as constants from 'constants';
import { PerformanceObserver, PerformanceObserverCallback } from "perf_hooks";
namespace constants_tests {
    var str: string;
    var num: number;
    num = constants.SIGHUP;
    num = constants.SIGINT;
    num = constants.SIGQUIT;
    num = constants.SIGILL;
    num = constants.SIGTRAP;
    num = constants.SIGABRT;
    num = constants.SIGIOT;
    num = constants.SIGBUS;
    num = constants.SIGFPE;
    num = constants.SIGKILL;
    num = constants.SIGUSR1;
    num = constants.SIGSEGV;
    num = constants.SIGUSR2;
    num = constants.SIGPIPE;
    num = constants.SIGALRM;
    num = constants.SIGTERM;
    num = constants.SIGCHLD;
    num = constants.SIGSTKFLT;
    num = constants.SIGCONT;
    num = constants.SIGSTOP;
    num = constants.SIGTSTP;
    num = constants.SIGTTIN;
    num = constants.SIGTTOU;
    num = constants.SIGURG;
    num = constants.SIGXCPU;
    num = constants.SIGXFSZ;
    num = constants.SIGVTALRM;
    num = constants.SIGPROF;
    num = constants.SIGWINCH;
    num = constants.SIGIO;
    num = constants.SIGPOLL;
    num = constants.SIGPWR;
    num = constants.SIGSYS;
    num = constants.SIGUNUSED;
    num = constants.O_RDONLY;
    num = constants.O_WRONLY;
    num = constants.O_RDWR;
    num = constants.S_IFMT;
    num = constants.S_IFREG;
    num = constants.S_IFDIR;
    num = constants.S_IFCHR;
    num = constants.S_IFBLK;
    num = constants.S_IFIFO;
    num = constants.S_IFLNK;
    num = constants.S_IFSOCK;
    num = constants.O_CREAT;
    num = constants.O_EXCL;
    num = constants.O_NOCTTY;
    num = constants.O_TRUNC;
    num = constants.O_APPEND;
    num = constants.O_DIRECTORY;
    num = constants.O_NOATIME;
    num = constants.O_NOFOLLOW;
    num = constants.O_SYNC;
    num = constants.O_DSYNC;
    num = constants.O_DIRECT;
    num = constants.O_NONBLOCK;
    num = constants.S_IRWXU;
    num = constants.S_IRUSR;
    num = constants.S_IWUSR;
    num = constants.S_IXUSR;
    num = constants.S_IRWXG;
    num = constants.S_IRGRP;
    num = constants.S_IWGRP;
    num = constants.S_IXGRP;
    num = constants.S_IRWXO;
    num = constants.S_IROTH;
    num = constants.S_IWOTH;
    num = constants.S_IXOTH;
    num = constants.F_OK;
    num = constants.R_OK;
    num = constants.W_OK;
    num = constants.X_OK;
    num = constants.SSL_OP_ALL;
    num = constants.SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION;
    num = constants.SSL_OP_CIPHER_SERVER_PREFERENCE;
    num = constants.SSL_OP_CISCO_ANYCONNECT;
    num = constants.SSL_OP_COOKIE_EXCHANGE;
    num = constants.SSL_OP_CRYPTOPRO_TLSEXT_BUG;
    num = constants.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS;
    num = constants.SSL_OP_EPHEMERAL_RSA;
    num = constants.SSL_OP_LEGACY_SERVER_CONNECT;
    num = constants.SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER;
    num = constants.SSL_OP_MICROSOFT_SESS_ID_BUG;
    num = constants.SSL_OP_MSIE_SSLV2_RSA_PADDING;
    num = constants.SSL_OP_NETSCAPE_CA_DN_BUG;
    num = constants.SSL_OP_NETSCAPE_CHALLENGE_BUG;
    num = constants.SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG;
    num = constants.SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG;
    num = constants.SSL_OP_NO_COMPRESSION;
    num = constants.SSL_OP_NO_QUERY_MTU;
    num = constants.SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;
    num = constants.SSL_OP_NO_SSLv2;
    num = constants.SSL_OP_NO_SSLv3;
    num = constants.SSL_OP_NO_TICKET;
    num = constants.SSL_OP_NO_TLSv1;
    num = constants.SSL_OP_NO_TLSv1_1;
    num = constants.SSL_OP_NO_TLSv1_2;
    num = constants.SSL_OP_PKCS1_CHECK_1;
    num = constants.SSL_OP_PKCS1_CHECK_2;
    num = constants.SSL_OP_SINGLE_DH_USE;
    num = constants.SSL_OP_SINGLE_ECDH_USE;
    num = constants.SSL_OP_SSLEAY_080_CLIENT_DH_BUG;
    num = constants.SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG;
    num = constants.SSL_OP_TLS_BLOCK_PADDING_BUG;
    num = constants.SSL_OP_TLS_D5_BUG;
    num = constants.SSL_OP_TLS_ROLLBACK_BUG;
    num = constants.ENGINE_METHOD_RSA;
    num = constants.ENGINE_METHOD_DSA;
    num = constants.ENGINE_METHOD_DH;
    num = constants.ENGINE_METHOD_RAND;
    num = constants.ENGINE_METHOD_ECDH;
    num = constants.ENGINE_METHOD_ECDSA;
    num = constants.ENGINE_METHOD_CIPHERS;
    num = constants.ENGINE_METHOD_DIGESTS;
    num = constants.ENGINE_METHOD_STORE;
    num = constants.ENGINE_METHOD_PKEY_METHS;
    num = constants.ENGINE_METHOD_PKEY_ASN1_METHS;
    num = constants.ENGINE_METHOD_ALL;
    num = constants.ENGINE_METHOD_NONE;
    num = constants.DH_CHECK_P_NOT_SAFE_PRIME;
    num = constants.DH_CHECK_P_NOT_PRIME;
    num = constants.DH_UNABLE_TO_CHECK_GENERATOR;
    num = constants.DH_NOT_SUITABLE_GENERATOR;
    num = constants.NPN_ENABLED;
    num = constants.ALPN_ENABLED;
    num = constants.RSA_PKCS1_PADDING;
    num = constants.RSA_SSLV23_PADDING;
    num = constants.RSA_NO_PADDING;
    num = constants.RSA_PKCS1_OAEP_PADDING;
    num = constants.RSA_X931_PADDING;
    num = constants.RSA_PKCS1_PSS_PADDING;
    num = constants.POINT_CONVERSION_COMPRESSED;
    num = constants.POINT_CONVERSION_UNCOMPRESSED;
    num = constants.POINT_CONVERSION_HYBRID;
    str = constants.defaultCoreCipherList;
    str = constants.defaultCipherList;
}

////////////////////////////////////////////////////
/// v8 tests : https://nodejs.org/api/v8.html
////////////////////////////////////////////////////

namespace v8_tests {
    const heapStats = v8.getHeapStatistics();
    const heapSpaceStats = v8.getHeapSpaceStatistics();

    const zapsGarbage: number = heapStats.does_zap_garbage;

    v8.setFlagsFromString('--collect_maps');
}

////////////////////////////////////////////////////
/// PerfHooks tests : https://nodejs.org/api/perf_hooks.html
////////////////////////////////////////////////////
namespace perf_hooks_tests {
    perf_hooks.performance.mark('start');
    (
        () => {}
    )();
    perf_hooks.performance.mark('end');

    const { duration } = perf_hooks.performance.getEntriesByName('discover')[0];
    const timeOrigin = perf_hooks.performance.timeOrigin;

    const performanceObserverCallback: PerformanceObserverCallback = (list, obs) => {
        const {
            duration,
            entryType,
            name,
            startTime,
        } = list.getEntries()[0];
        obs.disconnect();
        perf_hooks.performance.clearFunctions();
    };
    const obs = new perf_hooks.PerformanceObserver(performanceObserverCallback);
    obs.observe({
        entryTypes: ['function'],
        buffered: true,
    });
}

////////////////////////////////////////////////////
/// AsyncHooks tests : https://nodejs.org/api/async_hooks.html
////////////////////////////////////////////////////
namespace async_hooks_tests {
    const hooks: async_hooks.HookCallbacks = {
        init() {},
        before() {},
        after() {},
        destroy() {},
        promiseResolve() {},
    };

    const asyncHook = async_hooks.createHook(hooks);

    asyncHook.enable().disable().enable();

    const tId: number = async_hooks.triggerAsyncId();
    const eId: number = async_hooks.executionAsyncId();

    class TestResource extends async_hooks.AsyncResource {
        constructor() {
            super('TEST_RESOURCE');
        }
    }

    class AnotherTestResource extends async_hooks.AsyncResource {
        constructor() {
            super('TEST_RESOURCE', 42);
            const aId: number = this.asyncId();
            const tId: number = this.triggerAsyncId();
        }
        run() {
            this.runInAsyncScope(() => {});
            this.runInAsyncScope(Array.prototype.find, [], () => true);
        }
        destroy() {
            this.emitDestroy();
        }
    }

    // check AsyncResource constructor options.
    new async_hooks.AsyncResource('');
    new async_hooks.AsyncResource('', 0);
    new async_hooks.AsyncResource('', {});
    new async_hooks.AsyncResource('', { triggerAsyncId: 0 });
    new async_hooks.AsyncResource('', {
      triggerAsyncId: 0,
      requireManualDestroy: true
    });
}

////////////////////////////////////////////////////
/// zlib tests : http://nodejs.org/api/zlib.html ///
////////////////////////////////////////////////////

namespace zlib_tests {
    {
        const gzipped = zlib.gzipSync('test');
        const unzipped = zlib.gunzipSync(gzipped.toString());
    }

    {
        const deflate = zlib.deflateSync('test');
        const inflate = zlib.inflateSync(deflate.toString());
    }
}

///////////////////////////////////////////////////////////
/// HTTP/2 Tests                                        ///
///////////////////////////////////////////////////////////

namespace http2_tests {
    // Headers & Settings
    {
        let headers: http2.OutgoingHttpHeaders = {
            ':status': 200,
            'content-type': 'text-plain',
            ABC: ['has', 'more', 'than', 'one', 'value'],
            undef: undefined
        };

        let settings: http2.Settings = {
            headerTableSize: 0,
            enablePush: true,
            initialWindowSize: 0,
            maxFrameSize: 0,
            maxConcurrentStreams: 0,
            maxHeaderListSize: 0
        };
    }

    // Http2Session
    {
        let http2Session: http2.Http2Session;
        let ee: events.EventEmitter = http2Session;

        http2Session.on('close', () => {});
        http2Session.on('connect', (session: http2.Http2Session, socket: net.Socket) => {});
        http2Session.on('error', (err: Error) => {});
        http2Session.on('frameError', (frameType: number, errorCode: number, streamID: number) => {});
        http2Session.on('goaway', (errorCode: number, lastStreamID: number, opaqueData: Buffer) => {});
        http2Session.on('localSettings', (settings: http2.Settings) => {});
        http2Session.on('remoteSettings', (settings: http2.Settings) => {});
        http2Session.on('stream', (stream: http2.Http2Stream, headers: http2.IncomingHttpHeaders, flags: number) => {});
        http2Session.on('timeout', () => {});

        http2Session.destroy();

        let alpnProtocol: string = http2Session.alpnProtocol;
        let destroyed: boolean = http2Session.destroyed;
        let encrypted: boolean = http2Session.encrypted;
        let originSet: string[] = http2Session.originSet;
        let pendingSettingsAck: boolean = http2Session.pendingSettingsAck;
        let settings: http2.Settings = http2Session.localSettings;
        let closed: boolean = http2Session.closed;
        let connecting: boolean = http2Session.connecting;
        settings = http2Session.remoteSettings;

        http2Session.ref();
        http2Session.unref();

        let headers: http2.OutgoingHttpHeaders;
        let options: http2.ClientSessionRequestOptions = {
            endStream: true,
            exclusive: true,
            parent: 0,
            weight: 0,
            getTrailers: (trailers: http2.OutgoingHttpHeaders) => {}
        };
        (http2Session as http2.ClientHttp2Session).request();
        (http2Session as http2.ClientHttp2Session).request(headers);
        (http2Session as http2.ClientHttp2Session).request(headers, options);

        let stream: http2.Http2Stream;
        http2Session.rstStream(stream);
        http2Session.rstStream(stream, 0);

        http2Session.setTimeout(100, () => {});
        http2Session.close(() => {});

        let socket: net.Socket | tls.TLSSocket = http2Session.socket;
        let state: http2.SessionState = http2Session.state;
        state = {
            effectiveLocalWindowSize: 0,
            effectiveRecvDataLength: 0,
            nextStreamID: 0,
            localWindowSize: 0,
            lastProcStreamID: 0,
            remoteWindowSize: 0,
            outboundQueueSize: 0,
            deflateDynamicTableSize: 0,
            inflateDynamicTableSize: 0
        };

        http2Session.priority(stream, {
            exclusive: true,
            parent: 0,
            weight: 0,
            silent: true
        });

        http2Session.settings(settings);

      http2Session.ping((err: Error | null, duration: number, payload: Buffer) => {});
      http2Session.ping(Buffer.from(''), (err: Error | null, duration: number, payload: Buffer) => {});
      http2Session.ping(new DataView(new Int8Array(1).buffer), (err: Error | null, duration: number, payload: Buffer) => {});
    }

    // Http2Stream
    {
        let http2Stream: http2.Http2Stream;
        let duplex: stream.Duplex = http2Stream;

        http2Stream.on('aborted', () => {});
        http2Stream.on('error', (err: Error) => {});
        http2Stream.on('frameError', (frameType: number, errorCode: number, streamID: number) => {});
        http2Stream.on('streamClosed', (code: number) => {});
        http2Stream.on('timeout', () => {});
        http2Stream.on('trailers', (trailers: http2.IncomingHttpHeaders, flags: number) => {});

        let aborted: boolean = http2Stream.aborted;
        let closed: boolean = http2Stream.closed;
        let destroyed: boolean = http2Stream.destroyed;
        let pending: boolean = http2Stream.pending;

        http2Stream.priority({
            exclusive: true,
            parent: 0,
            weight: 0,
            silent: true
        });

        let sesh: http2.Http2Session = http2Stream.session;

        http2Stream.setTimeout(100, () => {});

        let state: http2.StreamState = http2Stream.state;
        state = {
            localWindowSize: 0,
            state: 0,
            streamLocalClose: 0,
            streamRemoteClose: 0,
            sumDependencyWeight: 0,
            weight: 0
        };

        http2Stream.close();
        http2Stream.close(0);
        http2Stream.close(0, () => {});
        http2Stream.close(undefined, () => {});

        // ClientHttp2Stream
        let clientHttp2Stream: http2.ClientHttp2Stream;
        clientHttp2Stream.on('headers', (headers: http2.IncomingHttpHeaders, flags: number) => {});
        clientHttp2Stream.on('push', (headers: http2.IncomingHttpHeaders, flags: number) => {});
        clientHttp2Stream.on('response', (headers: http2.IncomingHttpHeaders & http2.IncomingHttpStatusHeader, flags: number) => {
            const s: number = headers[':status'];
        });

        // ServerHttp2Stream
        let serverHttp2Stream: http2.ServerHttp2Stream;
        let headers: http2.OutgoingHttpHeaders;

        serverHttp2Stream.additionalHeaders(headers);
        let headerSent: boolean = serverHttp2Stream.headersSent;
        let pushAllowed: boolean = serverHttp2Stream.pushAllowed;
        serverHttp2Stream.pushStream(headers, (err: Error | null, pushStream: http2.ServerHttp2Stream, headers: http2.OutgoingHttpHeaders) => {});

        let options: http2.ServerStreamResponseOptions = {
            endStream: true,
            getTrailers: (trailers: http2.OutgoingHttpHeaders) => {}
        };
        serverHttp2Stream.respond();
        serverHttp2Stream.respond(headers);
        serverHttp2Stream.respond(headers, options);

        let options2: http2.ServerStreamFileResponseOptions = {
            statCheck: (stats: fs.Stats, headers: http2.OutgoingHttpHeaders, statOptions: http2.StatOptions) => {},
            getTrailers: (trailers: http2.OutgoingHttpHeaders) => {},
            offset: 0,
            length: 0
        };
        serverHttp2Stream.respondWithFD(0);
        serverHttp2Stream.respondWithFD(0, headers);
        serverHttp2Stream.respondWithFD(0, headers, options2);
        serverHttp2Stream.respondWithFD(0, headers, {statCheck: () => false});
        let options3: http2.ServerStreamFileResponseOptionsWithError = {
            onError: (err: NodeJS.ErrnoException) => {},
            statCheck: (stats: fs.Stats, headers: http2.OutgoingHttpHeaders, statOptions: http2.StatOptions) => {},
            getTrailers: (trailers: http2.OutgoingHttpHeaders) => {},
            offset: 0,
            length: 0
        };
        serverHttp2Stream.respondWithFile('');
        serverHttp2Stream.respondWithFile('', headers);
        serverHttp2Stream.respondWithFile('', headers, options3);
        serverHttp2Stream.respondWithFile('', headers, {statCheck: () => false});
    }

    // Http2Server / Http2SecureServer
    {
        let http2Server: http2.Http2Server;
        let http2SecureServer: http2.Http2SecureServer;
        let s1: net.Server = http2Server;
        let s2: tls.Server = http2SecureServer;
        [http2Server, http2SecureServer].forEach((server) => {
            server.on('sessionError', (err: Error) => {});
            server.on('checkContinue', (stream: http2.ServerHttp2Stream, headers: http2.IncomingHttpHeaders, flags: number) => {});
            server.on('stream', (stream: http2.ServerHttp2Stream, headers: http2.IncomingHttpHeaders, flags: number) => {});
            server.on('request', (request: http2.Http2ServerRequest, response: http2.Http2ServerResponse) => {});
            server.on('timeout', () => {});
        });

        http2SecureServer.on('unknownProtocol', (socket: tls.TLSSocket) => {});
    }

    // Public API (except constants)
    {
        let settings: http2.Settings;
        let serverOptions: http2.ServerOptions = {
            maxDeflateDynamicTableSize: 0,
            maxReservedRemoteStreams: 0,
            maxSendHeaderBlockLength: 0,
            paddingStrategy: 0,
            peerMaxConcurrentStreams: 0,
            selectPadding: (frameLen: number, maxFrameLen: number) => 0,
            settings,
            allowHTTP1: true
        };
        // tslint:disable-next-line prefer-object-spread (ts2.1 feature)
        let secureServerOptions: http2.SecureServerOptions = Object.assign({}, serverOptions);
        secureServerOptions.ca = '';
        let onRequestHandler = (request: http2.Http2ServerRequest, response: http2.Http2ServerResponse) => {
            // Http2ServerRequest

            let readable: stream.Readable = request;
            let incomingHeaders: http2.IncomingHttpHeaders = request.headers;
            incomingHeaders = request.trailers;
            let httpVersion: string = request.httpVersion;
            let method: string = request.method;
            let rawHeaders: string[] = request.rawHeaders;
            rawHeaders = request.rawTrailers;
            let socket: net.Socket | tls.TLSSocket = request.socket;
            let stream: http2.ServerHttp2Stream = request.stream;
            let url: string = request.url;

            request.setTimeout(0, () => {});
            request.on('aborted', (hadError: boolean, code: number) => {});

            // Http2ServerResponse

            let outgoingHeaders: http2.OutgoingHttpHeaders;
            response.addTrailers(outgoingHeaders);
            socket = response.connection;
            let finished: boolean = response.finished;
            response.sendDate = true;
            response.statusCode = 200;
            response.statusMessage = '';
            socket = response.socket;
            stream = response.stream;

            method = response.getHeader(':method');
            let headers: string[] = response.getHeaderNames();
            outgoingHeaders = response.getHeaders();
            let hasMethod = response.hasHeader(':method');
            response.removeHeader(':method');
            response.setHeader(':method', 'GET');
            response.setHeader(':status', 200);
            response.setHeader('some-list', ['', '']);
            let headersSent: boolean = response.headersSent;

            response.setTimeout(0, () => {});
            response.createPushResponse(outgoingHeaders, (err: Error | null, res: http2.Http2ServerResponse) => {});

            response.writeContinue();
            response.writeHead(200);
            response.writeHead(200, outgoingHeaders);
            response.writeHead(200, 'OK', outgoingHeaders);
            response.writeHead(200, 'OK');
            response.write('');
            response.write('', (err: Error) => {});
            response.write('', 'utf8');
            response.write('', 'utf8', (err: Error) => {});
            response.write(Buffer.from([]));
            response.write(Buffer.from([]), (err: Error) => {});
            response.write(Buffer.from([]), 'utf8');
            response.write(Buffer.from([]), 'utf8', (err: Error) => {});
            response.end();
            response.end(() => {});
            response.end('');
            response.end('', () => {});
            response.end('', 'utf8');
            response.end('', 'utf8', () => {});
            response.end(Buffer.from([]));
            response.end(Buffer.from([]), () => {});
            response.end(Buffer.from([]), 'utf8');
            response.end(Buffer.from([]), 'utf8', () => {});

            request.on('aborted', (hadError: boolean, code: number) => {});
            request.on('close', () => {});
            request.on('drain', () => {});
            request.on('error', (error: Error) => {});
            request.on('finish', () => {});
        };

        let http2Server: http2.Http2Server;
        let http2SecureServer: http2.Http2SecureServer;

        http2Server = http2.createServer();
        http2Server = http2.createServer(serverOptions);
        http2Server = http2.createServer(onRequestHandler);
        http2Server = http2.createServer(serverOptions, onRequestHandler);

        http2SecureServer = http2.createSecureServer();
        http2SecureServer = http2.createSecureServer(secureServerOptions);
        http2SecureServer = http2.createSecureServer(onRequestHandler);
        http2SecureServer = http2.createSecureServer(secureServerOptions, onRequestHandler);

        let clientSessionOptions: http2.ClientSessionOptions = {
            maxDeflateDynamicTableSize: 0,
            maxReservedRemoteStreams: 0,
            maxSendHeaderBlockLength: 0,
            paddingStrategy: 0,
            peerMaxConcurrentStreams: 0,
            selectPadding: (frameLen: number, maxFrameLen: number) => 0,
            settings
        };
        // tslint:disable-next-line prefer-object-spread (ts2.1 feature)
        let secureClientSessionOptions: http2.SecureClientSessionOptions = Object.assign({}, clientSessionOptions);
        secureClientSessionOptions.ca = '';
        let onConnectHandler = (session: http2.Http2Session, socket: net.Socket) => {};

        let serverHttp2Session: http2.ServerHttp2Session;

        serverHttp2Session.altsvc('', '');
        serverHttp2Session.altsvc('', 0);
        serverHttp2Session.altsvc('', new url.URL(''));
        serverHttp2Session.altsvc('', { origin: '' });
        serverHttp2Session.altsvc('', { origin: 0 });
        serverHttp2Session.altsvc('', { origin: new url.URL('') });

        let clientHttp2Session: http2.ClientHttp2Session;

        clientHttp2Session = http2.connect('');
        clientHttp2Session = http2.connect('', onConnectHandler);
        clientHttp2Session = http2.connect('', clientSessionOptions);
        clientHttp2Session = http2.connect('', clientSessionOptions, onConnectHandler);
        clientHttp2Session = http2.connect('', secureClientSessionOptions);
        clientHttp2Session = http2.connect('', secureClientSessionOptions, onConnectHandler);
        clientHttp2Session.on('altsvc', (alt: string, origin: string, number: number) => {});

        settings = http2.getDefaultSettings();
        settings = http2.getPackedSettings(settings);
        settings = http2.getUnpackedSettings(Buffer.from([]));
        settings = http2.getUnpackedSettings(Uint8Array.from([]));
    }

    // constants
    {
        const constants = http2.constants;
        let num: number;
        let str: string;
        num = constants.NGHTTP2_SESSION_SERVER;
        num = constants.NGHTTP2_SESSION_CLIENT;
        num = constants.NGHTTP2_STREAM_STATE_IDLE;
        num = constants.NGHTTP2_STREAM_STATE_OPEN;
        num = constants.NGHTTP2_STREAM_STATE_RESERVED_LOCAL;
        num = constants.NGHTTP2_STREAM_STATE_RESERVED_REMOTE;
        num = constants.NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL;
        num = constants.NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE;
        num = constants.NGHTTP2_STREAM_STATE_CLOSED;
        num = constants.NGHTTP2_NO_ERROR;
        num = constants.NGHTTP2_PROTOCOL_ERROR;
        num = constants.NGHTTP2_INTERNAL_ERROR;
        num = constants.NGHTTP2_FLOW_CONTROL_ERROR;
        num = constants.NGHTTP2_SETTINGS_TIMEOUT;
        num = constants.NGHTTP2_STREAM_CLOSED;
        num = constants.NGHTTP2_FRAME_SIZE_ERROR;
        num = constants.NGHTTP2_REFUSED_STREAM;
        num = constants.NGHTTP2_CANCEL;
        num = constants.NGHTTP2_COMPRESSION_ERROR;
        num = constants.NGHTTP2_CONNECT_ERROR;
        num = constants.NGHTTP2_ENHANCE_YOUR_CALM;
        num = constants.NGHTTP2_INADEQUATE_SECURITY;
        num = constants.NGHTTP2_HTTP_1_1_REQUIRED;
        num = constants.NGHTTP2_ERR_FRAME_SIZE_ERROR;
        num = constants.NGHTTP2_FLAG_NONE;
        num = constants.NGHTTP2_FLAG_END_STREAM;
        num = constants.NGHTTP2_FLAG_END_HEADERS;
        num = constants.NGHTTP2_FLAG_ACK;
        num = constants.NGHTTP2_FLAG_PADDED;
        num = constants.NGHTTP2_FLAG_PRIORITY;
        num = constants.DEFAULT_SETTINGS_HEADER_TABLE_SIZE;
        num = constants.DEFAULT_SETTINGS_ENABLE_PUSH;
        num = constants.DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE;
        num = constants.DEFAULT_SETTINGS_MAX_FRAME_SIZE;
        num = constants.MAX_MAX_FRAME_SIZE;
        num = constants.MIN_MAX_FRAME_SIZE;
        num = constants.MAX_INITIAL_WINDOW_SIZE;
        num = constants.NGHTTP2_DEFAULT_WEIGHT;
        num = constants.NGHTTP2_SETTINGS_HEADER_TABLE_SIZE;
        num = constants.NGHTTP2_SETTINGS_ENABLE_PUSH;
        num = constants.NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS;
        num = constants.NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE;
        num = constants.NGHTTP2_SETTINGS_MAX_FRAME_SIZE;
        num = constants.NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE;
        num = constants.PADDING_STRATEGY_NONE;
        num = constants.PADDING_STRATEGY_MAX;
        num = constants.PADDING_STRATEGY_CALLBACK;
        num = constants.HTTP_STATUS_CONTINUE;
        num = constants.HTTP_STATUS_SWITCHING_PROTOCOLS;
        num = constants.HTTP_STATUS_PROCESSING;
        num = constants.HTTP_STATUS_OK;
        num = constants.HTTP_STATUS_CREATED;
        num = constants.HTTP_STATUS_ACCEPTED;
        num = constants.HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION;
        num = constants.HTTP_STATUS_NO_CONTENT;
        num = constants.HTTP_STATUS_RESET_CONTENT;
        num = constants.HTTP_STATUS_PARTIAL_CONTENT;
        num = constants.HTTP_STATUS_MULTI_STATUS;
        num = constants.HTTP_STATUS_ALREADY_REPORTED;
        num = constants.HTTP_STATUS_IM_USED;
        num = constants.HTTP_STATUS_MULTIPLE_CHOICES;
        num = constants.HTTP_STATUS_MOVED_PERMANENTLY;
        num = constants.HTTP_STATUS_FOUND;
        num = constants.HTTP_STATUS_SEE_OTHER;
        num = constants.HTTP_STATUS_NOT_MODIFIED;
        num = constants.HTTP_STATUS_USE_PROXY;
        num = constants.HTTP_STATUS_TEMPORARY_REDIRECT;
        num = constants.HTTP_STATUS_PERMANENT_REDIRECT;
        num = constants.HTTP_STATUS_BAD_REQUEST;
        num = constants.HTTP_STATUS_UNAUTHORIZED;
        num = constants.HTTP_STATUS_PAYMENT_REQUIRED;
        num = constants.HTTP_STATUS_FORBIDDEN;
        num = constants.HTTP_STATUS_NOT_FOUND;
        num = constants.HTTP_STATUS_METHOD_NOT_ALLOWED;
        num = constants.HTTP_STATUS_NOT_ACCEPTABLE;
        num = constants.HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED;
        num = constants.HTTP_STATUS_REQUEST_TIMEOUT;
        num = constants.HTTP_STATUS_CONFLICT;
        num = constants.HTTP_STATUS_GONE;
        num = constants.HTTP_STATUS_LENGTH_REQUIRED;
        num = constants.HTTP_STATUS_PRECONDITION_FAILED;
        num = constants.HTTP_STATUS_PAYLOAD_TOO_LARGE;
        num = constants.HTTP_STATUS_URI_TOO_LONG;
        num = constants.HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE;
        num = constants.HTTP_STATUS_RANGE_NOT_SATISFIABLE;
        num = constants.HTTP_STATUS_EXPECTATION_FAILED;
        num = constants.HTTP_STATUS_TEAPOT;
        num = constants.HTTP_STATUS_MISDIRECTED_REQUEST;
        num = constants.HTTP_STATUS_UNPROCESSABLE_ENTITY;
        num = constants.HTTP_STATUS_LOCKED;
        num = constants.HTTP_STATUS_FAILED_DEPENDENCY;
        num = constants.HTTP_STATUS_UNORDERED_COLLECTION;
        num = constants.HTTP_STATUS_UPGRADE_REQUIRED;
        num = constants.HTTP_STATUS_PRECONDITION_REQUIRED;
        num = constants.HTTP_STATUS_TOO_MANY_REQUESTS;
        num = constants.HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE;
        num = constants.HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS;
        num = constants.HTTP_STATUS_INTERNAL_SERVER_ERROR;
        num = constants.HTTP_STATUS_NOT_IMPLEMENTED;
        num = constants.HTTP_STATUS_BAD_GATEWAY;
        num = constants.HTTP_STATUS_SERVICE_UNAVAILABLE;
        num = constants.HTTP_STATUS_GATEWAY_TIMEOUT;
        num = constants.HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED;
        num = constants.HTTP_STATUS_VARIANT_ALSO_NEGOTIATES;
        num = constants.HTTP_STATUS_INSUFFICIENT_STORAGE;
        num = constants.HTTP_STATUS_LOOP_DETECTED;
        num = constants.HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED;
        num = constants.HTTP_STATUS_NOT_EXTENDED;
        num = constants.HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED;
        str = constants.HTTP2_HEADER_STATUS;
        str = constants.HTTP2_HEADER_METHOD;
        str = constants.HTTP2_HEADER_AUTHORITY;
        str = constants.HTTP2_HEADER_SCHEME;
        str = constants.HTTP2_HEADER_PATH;
        str = constants.HTTP2_HEADER_ACCEPT_CHARSET;
        str = constants.HTTP2_HEADER_ACCEPT_ENCODING;
        str = constants.HTTP2_HEADER_ACCEPT_LANGUAGE;
        str = constants.HTTP2_HEADER_ACCEPT_RANGES;
        str = constants.HTTP2_HEADER_ACCEPT;
        str = constants.HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN;
        str = constants.HTTP2_HEADER_AGE;
        str = constants.HTTP2_HEADER_ALLOW;
        str = constants.HTTP2_HEADER_AUTHORIZATION;
        str = constants.HTTP2_HEADER_CACHE_CONTROL;
        str = constants.HTTP2_HEADER_CONNECTION;
        str = constants.HTTP2_HEADER_CONTENT_DISPOSITION;
        str = constants.HTTP2_HEADER_CONTENT_ENCODING;
        str = constants.HTTP2_HEADER_CONTENT_LANGUAGE;
        str = constants.HTTP2_HEADER_CONTENT_LENGTH;
        str = constants.HTTP2_HEADER_CONTENT_LOCATION;
        str = constants.HTTP2_HEADER_CONTENT_MD5;
        str = constants.HTTP2_HEADER_CONTENT_RANGE;
        str = constants.HTTP2_HEADER_CONTENT_TYPE;
        str = constants.HTTP2_HEADER_COOKIE;
        str = constants.HTTP2_HEADER_DATE;
        str = constants.HTTP2_HEADER_ETAG;
        str = constants.HTTP2_HEADER_EXPECT;
        str = constants.HTTP2_HEADER_EXPIRES;
        str = constants.HTTP2_HEADER_FROM;
        str = constants.HTTP2_HEADER_HOST;
        str = constants.HTTP2_HEADER_IF_MATCH;
        str = constants.HTTP2_HEADER_IF_MODIFIED_SINCE;
        str = constants.HTTP2_HEADER_IF_NONE_MATCH;
        str = constants.HTTP2_HEADER_IF_RANGE;
        str = constants.HTTP2_HEADER_IF_UNMODIFIED_SINCE;
        str = constants.HTTP2_HEADER_LAST_MODIFIED;
        str = constants.HTTP2_HEADER_LINK;
        str = constants.HTTP2_HEADER_LOCATION;
        str = constants.HTTP2_HEADER_MAX_FORWARDS;
        str = constants.HTTP2_HEADER_PREFER;
        str = constants.HTTP2_HEADER_PROXY_AUTHENTICATE;
        str = constants.HTTP2_HEADER_PROXY_AUTHORIZATION;
        str = constants.HTTP2_HEADER_RANGE;
        str = constants.HTTP2_HEADER_REFERER;
        str = constants.HTTP2_HEADER_REFRESH;
        str = constants.HTTP2_HEADER_RETRY_AFTER;
        str = constants.HTTP2_HEADER_SERVER;
        str = constants.HTTP2_HEADER_SET_COOKIE;
        str = constants.HTTP2_HEADER_STRICT_TRANSPORT_SECURITY;
        str = constants.HTTP2_HEADER_TRANSFER_ENCODING;
        str = constants.HTTP2_HEADER_TE;
        str = constants.HTTP2_HEADER_UPGRADE;
        str = constants.HTTP2_HEADER_USER_AGENT;
        str = constants.HTTP2_HEADER_VARY;
        str = constants.HTTP2_HEADER_VIA;
        str = constants.HTTP2_HEADER_WWW_AUTHENTICATE;
        str = constants.HTTP2_HEADER_HTTP2_SETTINGS;
        str = constants.HTTP2_HEADER_KEEP_ALIVE;
        str = constants.HTTP2_HEADER_PROXY_CONNECTION;
        str = constants.HTTP2_METHOD_ACL;
        str = constants.HTTP2_METHOD_BASELINE_CONTROL;
        str = constants.HTTP2_METHOD_BIND;
        str = constants.HTTP2_METHOD_CHECKIN;
        str = constants.HTTP2_METHOD_CHECKOUT;
        str = constants.HTTP2_METHOD_CONNECT;
        str = constants.HTTP2_METHOD_COPY;
        str = constants.HTTP2_METHOD_DELETE;
        str = constants.HTTP2_METHOD_GET;
        str = constants.HTTP2_METHOD_HEAD;
        str = constants.HTTP2_METHOD_LABEL;
        str = constants.HTTP2_METHOD_LINK;
        str = constants.HTTP2_METHOD_LOCK;
        str = constants.HTTP2_METHOD_MERGE;
        str = constants.HTTP2_METHOD_MKACTIVITY;
        str = constants.HTTP2_METHOD_MKCALENDAR;
        str = constants.HTTP2_METHOD_MKCOL;
        str = constants.HTTP2_METHOD_MKREDIRECTREF;
        str = constants.HTTP2_METHOD_MKWORKSPACE;
        str = constants.HTTP2_METHOD_MOVE;
        str = constants.HTTP2_METHOD_OPTIONS;
        str = constants.HTTP2_METHOD_ORDERPATCH;
        str = constants.HTTP2_METHOD_PATCH;
        str = constants.HTTP2_METHOD_POST;
        str = constants.HTTP2_METHOD_PRI;
        str = constants.HTTP2_METHOD_PROPFIND;
        str = constants.HTTP2_METHOD_PROPPATCH;
        str = constants.HTTP2_METHOD_PUT;
        str = constants.HTTP2_METHOD_REBIND;
        str = constants.HTTP2_METHOD_REPORT;
        str = constants.HTTP2_METHOD_SEARCH;
        str = constants.HTTP2_METHOD_TRACE;
        str = constants.HTTP2_METHOD_UNBIND;
        str = constants.HTTP2_METHOD_UNCHECKOUT;
        str = constants.HTTP2_METHOD_UNLINK;
        str = constants.HTTP2_METHOD_UNLOCK;
        str = constants.HTTP2_METHOD_UPDATE;
        str = constants.HTTP2_METHOD_UPDATEREDIRECTREF;
        str = constants.HTTP2_METHOD_VERSION_CONTROL;
    }
}

///////////////////////////////////////////////////////////
/// Inspector Tests                                     ///
///////////////////////////////////////////////////////////

namespace inspector_tests {
    {
        inspector.open();
        inspector.open(0);
        inspector.open(0, 'localhost');
        inspector.open(0, 'localhost', true);
        inspector.close();
        const inspectorUrl: string = inspector.url();

        const session = new inspector.Session();
        session.connect();
        session.disconnect();

        // Unknown post method
        session.post('A.b', { key: 'value' }, (err, params) => {});
        // TODO: parameters are implicitly 'any' and need type annotation
        session.post('A.b', (err: Error | null, params?: {}) => {});
        session.post('A.b');
        // Known post method
        const parameter: inspector.Runtime.EvaluateParameterType = { expression: '2 + 2' };
        session.post('Runtime.evaluate', parameter,
            (err: Error, params: inspector.Runtime.EvaluateReturnType) => {});
        session.post('Runtime.evaluate', (err: Error, params: inspector.Runtime.EvaluateReturnType) => {
            const exceptionDetails: inspector.Runtime.ExceptionDetails = params.exceptionDetails;
            const resultClassName: string = params.result.className;
        });
        session.post('Runtime.evaluate');

        // General event
        session.on('inspectorNotification', message => {
            message; // $ExpectType InspectorNotification<{}>
        });
        // Known events
        session.on('Debugger.paused', (message: inspector.InspectorNotification<inspector.Debugger.PausedEventDataType>) => {
            const method: string = message.method;
            const pauseReason: string = message.params.reason;
        });
        session.on('Debugger.resumed', () => {});
    }
}

////////////////////////////////////////////////////
/// module tests : http://nodejs.org/api/modules.html
////////////////////////////////////////////////////

namespace module_tests {
    require.extensions[".ts"] = () => "";

    Module.runMain();
    const s: string = Module.wrap("some code");

    const m1: Module = new Module("moduleId");
    const m2: Module = new Module.Module("moduleId");
    const b: string[] = Module.builtinModules;
    let paths: string[] = module.paths;
    paths = m1.paths;
}

////////////////////////////////////////////////////
/// Node.js ESNEXT Support
////////////////////////////////////////////////////

namespace esnext_string_tests {
    const s: string = 'foo';
    const s1: string = s.trimLeft();
    const s2: string = s.trimRight();
}