vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2025-10-16 12:05:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
bfb809e107
DefinitelyTyped/node/node-tests.ts
Joshua Ball 98c9f30fc3 AsyncCompleter for readline 
Previous Completer interface required implementation
of BOTH types (sync and async). Sync type could
be assigned to async type, but not vice versa, forcing
implementers to always implement the sync interface.
2017-03-11 19:14:29 -08:00

2186 lines
66 KiB
TypeScript
Raw Blame History

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";
import * as v8 from "v8";
// 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');
}
{
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): void => {
assert.equal(name, 'abc');
assert.equal(value, '123');
});
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();
}
}
/////////////////////////////////////////////////////
/// 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(rs.path instanceof 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<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']
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'];
}
});
result = readline.createInterface({
input: input,
completer: function(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, 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;
}
{
var writeStream = fs.createWriteStream('./index.d.ts');
var consoleInstance = new console.Console(writeStream)
}
}
///////////////////////////////////////////////////
/// 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
}
////////////////////////////////////////////////////
/// 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');
}
///////////////////////////////////////////////////////////
/// Debugger Tests ///
///////////////////////////////////////////////////////////
import { Client } from "_debugger";
var client = new Client();
client.connect(8888, 'localhost');
client.listbreakpoints((err, body, packet) => {
});
Reference in New Issue View Git Blame Copy Permalink