import * as assert from "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"; // 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 "a hammer at your face"; } }, undefined, "What the...*crunch*"); assert.equal(3, "3", "uses == comparator"); 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 "a hammer at your face"; }, undefined, "DODGED IT"); } } //////////////////////////////////////////////////// /// Events tests : http://nodejs.org/api/events.html //////////////////////////////////////////////////// namespace events_tests { let emitter: events.EventEmitter; let event: string | symbol; let listener: Function; 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.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: (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); } { var content: string; var buffer: Buffer; content = fs.readFileSync('testfile', 'utf8'); content = fs.readFileSync('testfile', { encoding: 'utf8' }); buffer = fs.readFileSync('testfile'); 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', (err, data) => buffer = 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; } }); } { 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); } } /////////////////////////////////////////////////////// /// 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(array) { const buf: Buffer = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]); } // 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); buf = Buffer.from(arr.buffer, 1); buf = Buffer.from(arr.buffer, 0, 1); } // Class Method: Buffer.from(buffer) { const buf1: Buffer = Buffer.from('buffer'); const buf2: Buffer = Buffer.from(buf1); } // Class Method: Buffer.from(str[, encoding]) { const buf1: Buffer = Buffer.from('this is a tést'); const buf2: Buffer = Buffer.from('7468697320697320612074c3a97374', 'hex'); } // 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')); // 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" } }); } { var helloUrl = url.parse('http://example.com/?hello=world', true) assert.equal(helloUrl.query.hello, 'world'); } } ///////////////////////////////////////////////////// /// 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"], { colors: true, depth: 5, customInspect: false }); } } //////////////////////////////////////////////////// /// 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 r.bytesRead === 'number'); assert(typeof r.path === 'string'); assert(typeof rs.path === 'Buffer'); r.pipe(z).pipe(w); r.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(compressMeString, (err: Error, result: Buffer) => zlib.inflate(result, (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(compressMeString, (err: Error, result: Buffer) => zlib.inflateRaw(result, (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)); const gunzipped: Buffer = zlib.gunzipSync(zlib.gzipSync(compressMe)); zlib.unzip(compressMe, (err: Error, result: Buffer) => result); const unzipped: Buffer = zlib.unzipSync(compressMe); // Simplified constructors function simplified_stream_ctor_test() { new stream.Readable({ read: function(size) { size.toFixed(); } }); new stream.Writable({ write: function(chunk, enc, cb) { chunk.slice(1); enc.charAt(0); cb() }, writev: function(chunks, cb) { chunks[0].chunk.slice(0); chunks[0].encoding.charAt(0); cb(); } }); new stream.Duplex({ read: function(size) { size.toFixed(); }, write: function(chunk, enc, cb) { chunk.slice(1); enc.charAt(0); cb() }, writev: function(chunks, cb) { chunks[0].chunk.slice(0); chunks[0].encoding.charAt(0); cb(); }, readableObjectMode: true, writableObjectMode: true }); new stream.Transform({ transform: function(chunk, enc, cb) { chunk.slice(1); enc.charAt(0); cb(); }, flush: function(cb) { cb() }, read: function(size) { size.toFixed(); }, write: function(chunk, enc, cb) { chunk.slice(1); enc.charAt(0); cb() }, writev: function(chunks, cb) { chunks[0].chunk.slice(0); chunks[0].encoding.charAt(0); cb(); }, allowHalfOpen: true, readableObjectMode: true, writableObjectMode: true }) } //////////////////////////////////////////////////////// /// Crypto tests : http://nodejs.org/api/crypto.html /// //////////////////////////////////////////////////////// namespace crypto_tests { { var hmacResult: string = crypto.createHmac('md5', 'hello').update('world').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); } { 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)) } } ////////////////////////////////////////////////// /// 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); } { let _server: tls.Server; let _boolean: boolean; let _func1 = function(err: Error, resp: Buffer){}; let _func2 = function(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 { { // 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 }); var agent: http.Agent = http.globalAgent; http.request({ agent: false }); http.request({ agent: agent }); http.request({ agent: undefined }); } { // Make sure .listen() and .close() retuern a Server instance http.createServer().listen(0).close().address(); net.createServer().listen(0).close().address(); } { var request = http.request('http://0.0.0.0'); request.once('error', function() { }); request.setNoDelay(true); request.abort(); } const options: http.RequestOptions = { timeout: 30000 }; } ////////////////////////////////////////////////////// /// 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 }); var agent: https.Agent = https.globalAgent; https.request({ agent: false }); https.request({ agent: agent }); https.request({ agent: undefined }); } //////////////////////////////////////////////////// /// 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); var ai: dgram.AddressInfo = 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"); } { let _socket: dgram.Socket; let _boolean: boolean; let _err: Error; let _str: string; let _rinfo: dgram.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: dgram.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: dgram.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: dgram.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: dgram.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: dgram.AddressInfo = rinfo; }) } } //////////////////////////////////////////////////// ///Querystring tests : https://nodejs.org/api/querystring.html //////////////////////////////////////////////////// namespace querystring_tests { type SampleObject = { a: string; b: number; } { let obj: SampleObject; let sep: string; let eq: string; let options: querystring.StringifyOptions; let result: string; result = querystring.stringify(obj); result = querystring.stringify(obj, sep); result = querystring.stringify(obj, sep, eq); result = querystring.stringify(obj, sep, eq); result = querystring.stringify(obj, sep, eq, options); } { let str: string; let sep: string; let eq: string; let options: querystring.ParseOptions; let result: SampleObject; result = querystring.parse(str); result = querystring.parse(str, sep); result = querystring.parse(str, sep, eq); result = querystring.parse(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'] console.log(process.env.PATH) // '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin' process.env.PATH.split(path.delimiter) // returns // ['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin'] console.log(process.env.PATH) // 'C:\Windows\system32;C:\Windows;C:\Program Files\nodejs\' process.env.PATH.split(path.delimiter) // returns // ['C:\Windows\system32', 'C:\Windows', 'C:\Program Files\nodejs\'] 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' } //////////////////////////////////////////////////// /// 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: input, completer: function(str: string): readline.CompleterResult { return [['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, y); } { 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.spawnSync("echo test"); } { let _cp: childProcess.ChildProcess; let _boolean: boolean; _cp = _cp.addListener("close", (code, signal) => { let _code: number = code; let _signal: string = signal; }) _cp = _cp.addListener("disconnet", () => { }); _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("disconnet", () => { }); _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("disconnet", () => { }); _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("disconnet", () => { }); _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("disconnet", () => { }); _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("disconnet", () => { }); _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; }) } } ////////////////////////////////////////////////////////////////////// /// 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(); } } //////////////////////////////////////////////////// /// 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(function(script: any) { console.log(script.name); }); } } ///////////////////////////////////////////////////// /// Timers tests : https://nodejs.org/api/timers.html ///////////////////////////////////////////////////// namespace timers_tests { { let immediateId = timers.setImmediate(function() { console.log("immediate"); }); timers.clearImmediate(immediateId); } { let counter = 0; let timeout = timers.setInterval(function() { console.log("interval"); }, 20); timeout.unref(); timeout.ref(); timers.clearInterval(timeout); } { let counter = 0; let timeout = timers.setTimeout(function() { console.log("timeout"); }, 20); timeout.unref(); timeout.ref(); timers.clearTimeout(timeout); } } ///////////////////////////////////////////////////////// /// Errors Tests : https://nodejs.org/api/errors.html /// ///////////////////////////////////////////////////////// namespace errors_tests { { Error.stackTraceLimit = Infinity; } { const myObject = {}; Error.captureStackTrace(myObject); } } /////////////////////////////////////////////////////////// /// 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; } } /////////////////////////////////////////////////////////// /// Console Tests : https://nodejs.org/api/console.html /// /////////////////////////////////////////////////////////// import * as c from "console"; namespace console_tests { { var _c: Console = console; _c = c; } } /////////////////////////////////////////////////// /// Net Tests : https://nodejs.org/api/net.html /// /////////////////////////////////////////////////// namespace net_tests { { 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 = server.address(); address.port = 1234; address.family = "ipv4"; address.address = "127.0.0.1"; } { /** * net.Socket - events.EventEmitter * 1. close * 2. connect * 3. data * 4. drain * 5. end * 6. error * 7. lookup * 8. timeout */ let _socket: net.Socket; let bool: boolean; let buffer: Buffer; let error: Error; let str: string; let num: number; /// 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.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", () => { }); } } /***************************************************************************** * * * The following tests are the modules not mentioned in document but existed * * * *****************************************************************************/ /////////////////////////////////////////////////////////// /// Constants Tests /// /////////////////////////////////////////////////////////// import * as constants from 'constants'; 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_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 } /////////////////////////////////////////////////////////// /// Debugger Tests /// /////////////////////////////////////////////////////////// import { Client } from "_debugger"; var client = new Client(); client.connect(8888, 'localhost'); client.listbreakpoints((err, body, packet) => { });