Client.prototype.reqVersion = function(cb) {
- cb = cb || function () {};
+ cb = cb || function() {};
this.req({ command: 'version' } , function(err, body, res) {
if (err) return cb(err);
cb(null, res.body.body.V8Version, res.body.running);
}
};
- cb = cb || function () {};
+ cb = cb || function() {};
this.req(req, function(err, res) {
if (err) return cb(err);
for (var ref in res) {
}
}
- cb(null, res);
+ cb(null, res);
});
};
arguments: {}
};
- cb = cb || function () {};
+ cb = cb || function() {};
this.req(req, function(err, res) {
if (err) return cb(err);
var refs = res.scopes.map(function(scope) {
return;
}
- cb = cb || function () {};
+ cb = cb || function() {};
// Otherwise we need to get the current frame to see which scopes it has.
this.reqBacktrace(function(err, bt) {
if (err || !bt.frames) {
var self = this;
var i = evalFrames.shift();
- cb = cb || function () {};
+ cb = cb || function() {};
this.reqFrameEval(expression, i, function(err, res) {
if (!err) return cb(null, res);
self._reqFramesEval(expression, evalFrames, cb);
req.arguments.frame = frame;
}
- cb = cb || function () {};
+ cb = cb || function() {};
this.req(req, function(err, res) {
if (!err) self._addHandle(res);
cb(err, res);
//
Client.prototype.reqScripts = function(cb) {
var self = this;
- cb = cb || function () {};
+ cb = cb || function() {};
this.req({ command: 'scripts' } , function(err, res) {
if (err) return cb(err);
return p.ref;
});
- cb = cb || function () {};
+ cb = cb || function() {};
this.reqLookup(propertyRefs, function(err, res) {
if (err) {
console.error('problem with reqLookup');
Client.prototype.fullTrace = function(cb) {
var self = this;
- cb = cb || function () {};
+ cb = cb || function() {};
this.reqBacktrace(function(err, trace) {
if (err) return cb(err);
if (trace.totalFrames <= 0) return cb(Error('No frames'));
'out (o)',
'backtrace (bt)',
'setBreakpoint (sb)',
- 'clearBreakpoint (cb)',
+ 'clearBreakpoint (cb)'
],
[
'watch',
self.resume();
});
}, 10);
-};
+}
// Stream control
this.print(SourceInfo(r));
// Show watchers' values
- this.watchers(true, function (err) {
+ this.watchers(true, function(err) {
if (err) return self.error(err);
// And list source
script.name == client.currentScript ||
!script.isNative) {
scripts.push(
- (script.name == client.currentScript ? '* ' : ' ') +
- id + ': ' +
- path.basename(script.name)
+ (script.name == client.currentScript ? '* ' : ' ') +
+ id + ': ' +
+ path.basename(script.name)
);
}
}
});
client.on('close', function() {
- self.pause()
+ self.pause();
self.print('program terminated');
self.resume();
self.client = null;
assert.AssertionError.prototype.toString = function() {
if (this.message) {
- return [ this.name + ':', this.message ].join(' ');
+ return [this.name + ':', this.message].join(' ');
} else {
return [
this.name + ':',
function ok(value, message) {
if (!!!value) fail(value, true, message, '==', assert.ok);
-};
+}
assert.ok = ok;
// 5. The equality assertion tests shallow, coercive equality with
// Copyright (c) 2008, Fair Oaks Labs, Inc.
// All rights reserved.
-//
+//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
-//
+//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
-//
+//
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
-//
+//
// * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
-//
+//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
eMax = (1 << eLen) - 1,
eBias = eMax >> 1,
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
- i = isBE ? (nBytes-1) : 0,
+ i = isBE ? (nBytes - 1) : 0,
d = isBE ? -1 : 1,
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
e--;
c *= 2;
}
- if (e+eBias >= 1) {
+ if (e + eBias >= 1) {
value += rt / c;
} else {
value += rt * Math.pow(2, 1 - eBias);
if (options.customFds[index] === index) {
options[name] = null;
} else {
- throw new Error("customFds not yet supported");
+ throw new Error('customFds not yet supported');
}
} else {
options[name] = createPipe();
ChildProcess.prototype.spawn = function(options) {
var self = this;
- setStreamOption("stdinStream", 0, options);
- setStreamOption("stdoutStream", 1, options);
- setStreamOption("stderrStream", 2, options);
+ setStreamOption('stdinStream', 0, options);
+ setStreamOption('stdoutStream', 1, options);
+ setStreamOption('stderrStream', 2, options);
var r = this._internal.spawn(options);
this._internal.close();
this._internal = null;
- throw errnoException("spawn", errno)
+ throw errnoException('spawn', errno);
}
this.pid = this._internal.pid;
if (options.crl) {
if (Array.isArray(options.crl)) {
- for(var i = 0, len = options.crl.length; i < len; i++) {
+ for (var i = 0, len = options.crl.length; i < len; i++) {
c.context.addCRL(options.crl[i]);
}
} else {
return new DiffieHellman(size_or_key, enc);
}
-}
+};
exports.pbkdf2 = PBKDF2;
// c-ares invokes a callback either synchronously or asynchronously,
// but the dns API should always invoke a callback asynchronously.
-//
+//
// This function makes sure that the callback is invoked asynchronously.
// It returns a function that invokes the callback within nextTick().
-//
+//
// To avoid invoking unnecessary nextTick(), `immediately` property of
// returned function should be set to true after c-ares returned.
-//
+//
// Usage:
-//
+//
// function someAPI(callback) {
// callback = makeAsync(callback);
// channel.someAPI(..., callback);
// c-ares invokes a callback either synchronously or asynchronously,
// but the dns API should always invoke a callback asynchronously.
-//
+//
// This function makes sure that the callback is invoked asynchronously.
// It returns a function that invokes the callback within nextTick().
-//
+//
// To avoid invoking unnecessary nextTick(), `immediately` property of
// returned function should be set to true after c-ares returned.
-//
-// Usage:
-//
+//
+// Usage:
+//
// function someAPI(callback) {
// callback = makeAsync(callback);
// channel.someAPI(..., callback);
var resolveMap = {};
-exports.resolve4 = resolveMap.A = resolver('queryA');
-exports.resolve6 = resolveMap.AAAA = resolver('queryAaaa');
+exports.resolve4 = resolveMap.A = resolver('queryA');
+exports.resolve6 = resolveMap.AAAA = resolver('queryAaaa');
exports.resolveCname = resolveMap.CNAME = resolver('queryCname');
-exports.resolveMx = resolveMap.MX = resolver('queryMx');
-exports.resolveNs = resolveMap.NS = resolver('queryNs');
-exports.resolveTxt = resolveMap.TXT = resolver('queryTxt');
-exports.resolveSrv = resolveMap.SRV = resolver('querySrv');
-exports.reverse = resolveMap.PTR = resolver('getHostByAddr');
+exports.resolveMx = resolveMap.MX = resolver('queryMx');
+exports.resolveNs = resolveMap.NS = resolver('queryNs');
+exports.resolveTxt = resolveMap.TXT = resolver('queryTxt');
+exports.resolveSrv = resolveMap.SRV = resolver('querySrv');
+exports.reverse = resolveMap.PTR = resolver('getHostByAddr');
exports.resolve = function(domain, type_, callback_) {
};
function modeNum(m, def) {
- switch(typeof m) {
+ switch (typeof m) {
case 'number': return m;
case 'string': return parseInt(m, 8);
default:
if (constants.hasOwnProperty('O_SYMLINK')) {
fs.lchmod = function(path, mode, callback) {
callback = callback || noop;
- fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, function (err, fd) {
+ fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, function(err, fd) {
if (err) {
callback(err);
return;
if (constants.hasOwnProperty('O_SYMLINK')) {
fs.lchown = function(path, uid, gid, callback) {
callback = callback || noop;
- fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, function (err, fd) {
+ fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, function(err, fd) {
if (err) {
callback(err);
return;
// convert to 123.456 UNIX timestamp
return time.getTime() / 1000;
}
- throw new Error("Cannot parse time: " + time);
+ throw new Error('Cannot parse time: ' + time);
}
// exported for unit tests, not for public consumption
if (openErr) {
if (callback) callback(openErr);
} else {
- var buffer = Buffer.isBuffer(data) ? data : new Buffer('' + data, encoding);
+ var buffer = Buffer.isBuffer(data) ? data : new Buffer('' + data,
+ encoding);
writeAll(fd, buffer, 0, buffer.length, callback);
}
});
if (r) {
this._handle.close();
- throw errnoException(errno, "watch")
+ throw errnoException(errno, 'watch');
}
};
this._handle = new binding.StatWatcher();
this._handle.onchange = function(current, previous) {
- self.emit('change', current, previous);
+ self.emit('change', current, previous);
};
this._handle.onstop = function() {
- self.emit('stop');
+ self.emit('stop');
};
}
util.inherits(StatWatcher, EventEmitter);
this.bytesWritten += bytesWritten;
- debug('wrote ' + bytesWritten + ' bytes to socket.')
+ debug('wrote ' + bytesWritten + ' bytes to socket.');
debug('[fd, off, len] = ' + JSON.stringify([this.fd, off, len]));
timers.active(this);
Socket.prototype._onBufferChange = function() {
// Put DTrace hooks here.
- ;
};
/* Bit flags for socket._flags */
-var FLAG_GOT_EOF = 1 << 0;
-var FLAG_SHUTDOWN = 1 << 1;
+var FLAG_GOT_EOF = 1 << 0;
+var FLAG_SHUTDOWN = 1 << 1;
var FLAG_DESTROY_SOON = 1 << 2;
var FLAG_SHUTDOWNQUED = 1 << 3;
if (this._connectQueue) {
this._connectQueue.push([data, encoding, fd, cb]);
} else {
- this._connectQueue = [ [data, encoding, fd, cb] ];
+ this._connectQueue = [[data, encoding, fd, cb]];
}
return false;
}
if (req.cb) req.cb();
- if (self._writeRequests.length == 0 && self._flags & FLAG_DESTROY_SOON) {
+ if (self._writeRequests.length == 0 && self._flags & FLAG_DESTROY_SOON) {
self.destroy();
}
}
connect(self, /*pipe_name=*/port);
} else if (typeof host == 'string') {
- debug("connect: find host " + host);
+ debug('connect: find host ' + host);
require('dns').lookup(host, function(err, ip, addressType) {
// It's possible we were destroyed while looking this up.
// XXX it would be great if we could cancel the promise returned by
});
} else {
- debug("connect: missing host");
+ debug('connect: missing host');
connect(self, '127.0.0.1', port, 4);
}
};
assert.equal(handle, self._handle);
- debug("afterConnect");
+ debug('afterConnect');
assert.ok(self._connecting);
self._connecting = false;
self.end();
}
} else {
- self._connectQueueCleanUp()
+ self._connectQueueCleanUp();
self.destroy(errnoException(errno, 'connect'));
}
}
self.on('connection', arguments[0]);
} else {
options = arguments[0] || {};
-
+
if (typeof arguments[1] == 'function') {
self.on('connection', arguments[1]);
}
self._handle.onconnection = onconnection;
if (address || port) {
- debug("bind to " + address);
+ debug('bind to ' + address);
if (addressType == 6) {
r = self._handle.bind6(address, port);
} else {
var self = handle.socket;
var peername;
- debug("onconnection");
+ debug('onconnection');
if (!clientHandle) {
self.emit('error', errnoException(errno, 'accept'));
}
}
return 4;
- } else if (/^::|^::1|^([a-fA-F0-9]{1,4}::?){1,7}([a-fA-F0-9]{1,4})$/.test(input)) {
+ } else if (/^::|^::1|^([a-fA-F0-9]{1,4}::?){1,7}([a-fA-F0-9]{1,4})$/.test(
+ input)) {
return 6;
} else {
return 0;
}
-}
+};
exports.isIPv4 = function(input) {
function normalizeArray(parts, allowAboveRoot) {
// if the path tries to go above the root, `up` ends up > 0
var up = 0;
- for (var i = parts.length-1; i >= 0; i--) {
+ for (var i = parts.length - 1; i >= 0; i--) {
var last = parts[i];
if (last == '.') {
parts.splice(i, 1);
// Regex to split the tail part of the above into [*, dir, basename, ext]
var splitTailRe = /^([\s\S]+[\\\/](?!$)|[\\\/])?((?:[\s\S]+?)?(\.[^.]*)?)$/;
- // Function to split a filename into [root, dir, basename, ext]
- // windows version
+ // Function to split a filename into [root, dir, basename, ext]
+ // windows version
var splitPath = function(filename) {
// Separate device+slash from tail
var result = splitDeviceRe.exec(filename),
basename = result2[2] || '',
ext = result2[3] || '';
return [device, dir, basename, ext];
- }
+ };
// path.resolve([from ...], to)
// windows version
resolvedTail = '',
resolvedAbsolute = false;
- for (var i = arguments.length-1; i >= -1; i--) {
+ for (var i = arguments.length - 1; i >= -1; i--) {
var path = (i >= 0) ? arguments[i] : process.cwd();
// Skip empty and invalid entries
var resolvedPath = '',
resolvedAbsolute = false;
- for (var i = arguments.length-1; i >= -1 && !resolvedAbsolute; i--) {
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
var path = (i >= 0) ? arguments[i] : process.cwd();
// Skip empty and invalid entries
var item = group[idx];
self.output.write(item);
if (col < maxColumns - 1) {
- for (var s = 0, itemLen = item.length; s < width - itemLen; s++) {
+ for (var s = 0, itemLen = item.length; s < width - itemLen;
+ s++) {
self.output.write(' ');
}
}
this.commands = {};
defineDefaultCommands(this);
- if (rli.enabled && !exports.disableColors && exports.writer === util.inspect) {
+ if (rli.enabled && !exports.disableColors &&
+ exports.writer === util.inspect) {
// Turn on ANSI coloring.
exports.writer = function(obj, showHidden, depth) {
return util.inspect(obj, showHidden, depth, true);
self.context,
'repl',
function(e, ret) {
- if (e && !isSyntaxError(e)) return finish(e);
+ if (e && !isSyntaxError(e)) return finish(e);
- if (typeof ret === 'function' || e) {
- // Now as statement without parens.
- self.eval(evalCmd, self.context, 'repl', finish);
- } else {
- finish(null, ret);
- }
- });
+ if (typeof ret === 'function' || e) {
+ // Now as statement without parens.
+ self.eval(evalCmd, self.context, 'repl', finish);
+ } else {
+ finish(null, ret);
+ }
+ });
} else {
finish(null);
// they just get in the way.
if (filter) {
completionGroups.push(['break', 'case', 'catch', 'const',
- 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'export',
- 'false', 'finally', 'for', 'function', 'if', 'import', 'in',
- 'instanceof', 'let', 'new', 'null', 'return', 'switch', 'this',
- 'throw', 'true', 'try', 'typeof', 'undefined', 'var', 'void',
- 'while', 'with', 'yield']);
+ 'continue', 'debugger', 'default', 'delete', 'do', 'else',
+ 'export', 'false', 'finally', 'for', 'function', 'if',
+ 'import', 'in', 'instanceof', 'let', 'new', 'null', 'return',
+ 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'undefined',
+ 'var', 'void', 'while', 'with', 'yield']);
}
}
exports.setRawMode = function(flag) {
- assert.ok(stdinHandle, "stdin must be initialized before calling setRawMode");
+ assert.ok(stdinHandle, 'stdin must be initialized before calling setRawMode');
stdinHandle.setRawMode(flag);
};
exports.setWindowSize = function() {
- throw new Error("implement me");
+ throw new Error('implement me');
};
}
}
return str;
-}
+};
exports.print = function() {
var ctx = {
showHidden: showHidden,
seen: [],
- stylize: colors ? stylizeWithColor : stylizeNoColor,
+ stylize: colors ? stylizeWithColor : stylizeNoColor
};
return formatValue(ctx, obj, (typeof depth === 'undefined' ? 2 : depth));
}
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
var colors = {
- 'bold' : [1, 22],
- 'italic' : [3, 23],
- 'underline' : [4, 24],
- 'inverse' : [7, 27],
- 'white' : [37, 39],
- 'grey' : [90, 39],
- 'black' : [30, 39],
- 'blue' : [34, 39],
- 'cyan' : [36, 39],
- 'green' : [32, 39],
- 'magenta' : [35, 39],
- 'red' : [31, 39],
- 'yellow' : [33, 39]
+ 'bold' : [1, 22],
+ 'italic' : [3, 23],
+ 'underline' : [4, 24],
+ 'inverse' : [7, 27],
+ 'white' : [37, 39],
+ 'grey' : [90, 39],
+ 'black' : [30, 39],
+ 'blue' : [34, 39],
+ 'cyan' : [36, 39],
+ 'green' : [32, 39],
+ 'magenta' : [35, 39],
+ 'red' : [31, 39],
+ 'yellow' : [33, 39]
};
var styles = {
- 'special': 'cyan',
- 'number': 'blue',
- 'boolean': 'yellow',
- 'undefined': 'grey',
- 'null': 'bold',
- 'string': 'green',
- 'date': 'magenta',
- // "name": intentionally not styling
- 'regexp': 'red'
+ 'special': 'cyan',
+ 'number': 'blue',
+ 'boolean': 'yellow',
+ 'undefined': 'grey',
+ 'null': 'bold',
+ 'string': 'green',
+ 'date': 'magenta',
+ // "name": intentionally not styling
+ 'regexp': 'red'
};
for (var i = 0, l = value.length; i < l; ++i) {
if (Object.prototype.hasOwnProperty.call(value, String(i))) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
- String(i), true));
+ String(i), true));
} else {
output.push('');
}
keys.forEach(function(key) {
if (!key.match(/^\d+$/)) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
- key, true));
+ key, true));
}
});
return output;
function isRegExp(re) {
return re instanceof RegExp ||
- (typeof re === 'object' && objectToString(re) === '[object RegExp]');
+ (typeof re === 'object' && objectToString(re) === '[object RegExp]');
}
function isDate(d) {
return d instanceof Date ||
- (typeof d === 'object' && objectToString(d) === '[object Date]');
+ (typeof d === 'object' && objectToString(d) === '[object Date]');
}
function isError(e) {
return e instanceof Error ||
- (typeof e === 'object' && objectToString(e) === '[object Error]');
+ (typeof e === 'object' && objectToString(e) === '[object Error]');
}
case 'TTY':
var tty = NativeModule.require('tty');
stdout = new tty.WriteStream(fd);
- stdout._type = "tty";
+ stdout._type = 'tty';
// Hack to have stdout not keep the event loop alive.
// See https://github.com/joyent/node/issues/1726
case 'FILE':
var fs = NativeModule.require('fs');
stdout = new fs.WriteStream(null, {fd: fd});
- stdout._type = "fs";
+ stdout._type = 'fs';
break;
case 'PIPE':
// we'll just add this hack and set the `readable` member to false.
// Test: ./node test/fixtures/echo.js < /etc/passwd
stdout.readable = false;
- stdout._type = "pipe";
+ stdout._type = 'pipe';
// FIXME Hack to have stdout not keep the event loop alive.
// See https://github.com/joyent/node/issues/1726
default:
// Probably an error on in uv_guess_handle()
- throw new Error("Implement me. Unknown stdout file type!");
+ throw new Error('Implement me. Unknown stdout file type!');
}
// For supporting legacy API we put the FD here.
default:
// Probably an error on in uv_guess_handle()
- throw new Error("Implement me. Unknown stdin file type!");
+ throw new Error('Implement me. Unknown stdin file type!');
}
// For supporting legacy API we put the FD here.
'mixin': 'process.mixin() has been removed.',
'createChildProcess': 'childProcess API has changed. See doc/api.txt.',
'inherits': 'process.inherits() has moved to sys.inherits.',
- '_byteLength': 'process._byteLength() has moved to Buffer.byteLength',
+ '_byteLength': 'process._byteLength() has moved to Buffer.byteLength'
};
startup.removedMethods = function() {
throw new Error('No such native module ' + id);
}
- process.moduleLoadList.push("NativeModule " + id);
+ process.moduleLoadList.push('NativeModule ' + id);
var nativeModule = new NativeModule(id);
exports.spawnPwd = function(options) {
var spawn = require('child_process').spawn;
- if (process.platform == "win32") {
+ if (process.platform == 'win32') {
return spawn('cmd.exe', ['/c', 'cd'], options);
} else {
return spawn('pwd', [], options);
function loadDom() {
// Do a lot of computation to stall the process.
// In the meantime the socket will be disconnected.
- for (var i = 0; i < 1e8; i++) {
- ;
- }
+ for (var i = 0; i < 1e8; i++);
console.log('Dom loaded.');
}
// libuv-broken
-var assert = require("assert");
-var spawn = require("child_process").spawn;
+var assert = require('assert');
+var spawn = require('child_process').spawn;
var fs = require('fs');
var myUid = process.getuid();
var myGid = process.getgid();
if (myUid != 0) {
- console.error('must be run as root, otherwise the gid/uid setting will fail.');
+ console.error('must be run as root, otherwise the gid/uid setting will' +
+ ' fail.');
process.exit(1);
}
var passwd = fs.readFileSync('/etc/passwd', 'utf8');
passwd = passwd.trim().split(/\n/);
-for (var i = 0, l = passwd.length; i < l; i ++) {
- if (passwd[i].charAt(0) === "#") continue;
- passwd[i] = passwd[i].split(":");
+for (var i = 0, l = passwd.length; i < l; i++) {
+ if (passwd[i].charAt(0) === '#') continue;
+ passwd[i] = passwd[i].split(':');
var otherName = passwd[i][0];
var otherUid = +passwd[i][2];
var otherGid = +passwd[i][3];
whoName.stdout.buf = 'byName:';
whoNumber.stdout.on('data', onData);
whoName.stdout.on('data', onData);
-function onData (c) { this.buf += c; }
+function onData(c) { this.buf += c; }
-whoNumber.on("exit", onExit);
-whoName.on("exit", onExit);
+whoNumber.on('exit', onExit);
+whoName.on('exit', onExit);
-function onExit (code) {
+function onExit(code) {
var buf = this.stdout.buf;
console.log(buf);
- var expr = new RegExp("^(byName|byNumber):uid=" +
+ var expr = new RegExp('^(byName|byNumber):uid=' +
otherUid +
- "\\(" +
+ '\\(' +
otherName +
- "\\) gid=" +
+ '\\) gid=' +
otherGid +
- "\\(");
- assert.ok(buf.match(expr), "uid and gid should match " + otherName);
+ '\\(');
+ assert.ok(buf.match(expr), 'uid and gid should match ' + otherName);
}
if (receivedMessages.length == sendMessages.length) {
listenSocket.dropMembership(LOCAL_BROADCAST_HOST);
process.nextTick(function() { // TODO should be changed to below.
- // listenSocket.dropMembership(LOCAL_BROADCAST_HOST, function() {
+ // listenSocket.dropMembership(LOCAL_BROADCAST_HOST, function() {
listenSocket.close();
});
}
var server = http.Server(function(req, res) {
res.writeHead(200);
- res.end("hello world\n");
+ res.end('hello world\n');
var buffer = '';
var N = 10;
var M = 10;
-var body = ''
+var body = '';
for (var i = 0; i < 1000; i++) {
body += 'hello world';
}
server.listen(common.PORT, function() {
for (var i = 0; i < N; i++) {
- setTimeout(function () {
+ setTimeout(function() {
for (var j = 0; j < M; j++) {
var req = http.request(options, function(res) {
}
var proxy_req = http.request({
- host: 'localhost',
- port: 9000,
- method: req.method,
- path: req.url,
+ host: 'localhost',
+ port: 9000,
+ method: req.method,
+ path: req.url,
headers: req.headers
}, function(proxy_res) {
res.writeHead(proxy_res.statusCode, proxy_res.headers);
var recved = 0;
var req = http.request({
- port: 9001,
- host: 'localhost',
- path: '/',
+ port: 9001,
+ host: 'localhost',
+ path: '/',
headers: {'x-len': len}
}, function(res) {
// This must be run as root.
-var http = require("http"),
- https = require("https"),
+var http = require('http'),
+ https = require('https'),
PORT = 80,
SSLPORT = 443,
- assert = require("assert"),
- hostExpect = "localhost",
- fs = require("fs"),
- path = require("path"),
- fixtures = path.resolve(__dirname, "../fixtures/keys"),
+ assert = require('assert'),
+ hostExpect = 'localhost',
+ fs = require('fs'),
+ path = require('path'),
+ fixtures = path.resolve(__dirname, '../fixtures/keys'),
options = {
key: fs.readFileSync(fixtures + '/agent1-key.pem'),
cert: fs.readFileSync(fixtures + '/agent1-cert.pem')
};
-http.createServer(function (req, res) {
+http.createServer(function(req, res) {
console.error(req.headers);
assert.equal(req.headers.host, hostExpect);
res.writeHead(200);
- res.end("ok");
+ res.end('ok');
this.close();
}).listen(PORT);
-https.createServer(options, function (req, res) {
+https.createServer(options, function(req, res) {
console.error(req.headers);
assert.equal(req.headers.host, hostExpect);
res.writeHead(200);
- res.end("ok");
+ res.end('ok');
this.close();
}).listen(SSLPORT);
http
- .get({ host: "localhost",
- port: PORT,
- headers: { "x-port": PORT } })
- .on("response", function(res) {});
+ .get({ host: 'localhost',
+ port: PORT,
+ headers: { 'x-port': PORT } })
+ .on('response', function(res) {});
https
- .get({ host: "localhost",
- port: SSLPORT,
- headers: { "x-port": SSLPORT } })
- .on("response", function(res) {});
+ .get({ host: 'localhost',
+ port: SSLPORT,
+ headers: { 'x-port': SSLPORT } })
+ .on('response', function(res) {});
server.addListener('listening', function() {
var request = http.request({
- port: common.PORT,
+ port: common.PORT,
method: 'HEAD',
- path: '/'
+ path: '/'
}, function(response) {
console.log('got response');
response.addListener('data', function() {
var https = require('https');
-for(var i = 0; i < 10; ++i)
+for (var i = 0; i < 10; ++i)
{
https.get(
- {
- host: 'www.google.com',
- path: '/accounts/o8/id',
- port: 443,
- }, function(res)
- {
- var data = '';
- res.on('data', function(chunk)
- {
- data += chunk;
- });
- res.on('end', function()
- {
- console.log(res.statusCode);
- });
- }).on('error', function(error)
- {
- console.log(error);
- });
+ {
+ host: 'www.google.com',
+ path: '/accounts/o8/id',
+ port: 443
+ }, function(res)
+ {
+ var data = '';
+ res.on('data', function(chunk)
+ {
+ data += chunk;
+ });
+ res.on('end', function()
+ {
+ console.log(res.statusCode);
+ });
+ }).on('error', function(error)
+ {
+ console.log(error);
+ });
}
var body = '';
process.stdout.write('build body...');
-for (var i = 0; i < 10*1024*1024; i++) {
+for (var i = 0; i < 10 * 1024 * 1024; i++) {
body += 'hello world\n';
}
process.stdout.write('done\n');
var cert = fs.readFileSync(join(common.fixturesDir, 'agent.crt')).toString();
s = tls.Server({ key: key,
- cert: cert,
- ca: [],
- requestCert: true,
- rejectUnauthorized: true });
+ cert: cert,
+ ca: [],
+ requestCert: true,
+ rejectUnauthorized: true });
s.listen(common.PORT, function() {
console.log('TLS server on 127.0.0.1:%d', common.PORT);
// most servers don't require certificates
var options = {
- key: fs.readFileSync(common.fixturesDir + '/keys/agent1-key.pem'),
+ key: fs.readFileSync(common.fixturesDir + '/keys/agent1-key.pem')
};
-var s = tls.connect(443, "joyent.com", options, function() {
+var s = tls.connect(443, 'joyent.com', options, function() {
if (!s.authorized) {
- console.error("CONNECTED: " + s.authorizationError);
+ console.error('CONNECTED: ' + s.authorizationError);
s.destroy();
return;
}
var req = https.request(options, function(res) {
assert.equal(200, res.statusCode);
gotResponse = true;
- console.error("DONE");
+ console.error('DONE');
});
req.end(new Buffer(bytesExpected));
while (--i != 0);
debugger;
return i;
-};
+}
function b() {
return ['hello', 'world'].join(' ');
-};
+}
a();
a(1);
b();
var assert = require('assert');
-console.log("NODE_CHANNEL_FD", process.env.NODE_CHANNEL_FD);
+console.log('NODE_CHANNEL_FD', process.env.NODE_CHANNEL_FD);
assert.ok(process.env.NODE_CHANNEL_FD);
var fd = parseInt(process.env.NODE_CHANNEL_FD);
// USE OR OTHER DEALINGS IN THE SOFTWARE.
console.error(__filename);
-console.error(module.paths.join('\n')+'\n');
+console.error(module.paths.join('\n') + '\n');
throw new Error('Should not ever get here.');
// USE OR OTHER DEALINGS IN THE SOFTWARE.
console.error(__filename);
-console.error(module.paths.join('\n')+'\n');
+console.error(module.paths.join('\n') + '\n');
// USE OR OTHER DEALINGS IN THE SOFTWARE.
console.error(__filename);
-console.error(module.paths.join('\n')+'\n');
+console.error(module.paths.join('\n') + '\n');
// this should work, and get the one that doesn't throw
var assert = require('assert');
assert.equal(require('bar'), require('../bar.js'));
// USE OR OTHER DEALINGS IN THE SOFTWARE.
console.error(__filename);
-console.error(module.paths.join('\n')+'\n');
+console.error(module.paths.join('\n') + '\n');
// USE OR OTHER DEALINGS IN THE SOFTWARE.
console.error(__filename);
-console.error(module.paths.join('\n')+'\n');
+console.error(module.paths.join('\n') + '\n');
var assert = require('assert');
assert.equal(require('baz'), require('./baz/index.js'));
// USE OR OTHER DEALINGS IN THE SOFTWARE.
console.error(__filename);
-console.error(module.paths.join('\n')+'\n');
+console.error(module.paths.join('\n') + '\n');
throw new Error('Should not ever get here.');
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-exports.ok = "ok"
+exports.ok = 'ok';
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-exports.ok = "ok"
+exports.ok = 'ok';
(function() {
require('util').print('Loaded successfully!');
-})();
\ No newline at end of file
+})();
+
if (fs.readFile) {
require('util').print('fs loaded successfully');
}
-})();
\ No newline at end of file
+})();
+
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-var assert = require('assert');
+var assert = require('assert'),
dns = require('dns'),
- net = require('net_uv');
+ net = require('net_uv'),
isIP = net.isIP,
isIPv4 = net.isIPv4,
isIPv6 = net.isIPv6,
var req = dns.reverse('bogus ip', function() {
assert.ok(false);
});
- } catch(e) {
+ } catch (e) {
error = e;
}
TEST(function test_lookup_failure(done) {
var req = dns.lookup('does.not.exist', 4, function(err, ip, family) {
assert.ok(err instanceof Error);
- assert.strictEqual(err.errno, dns.NOTFOUND)
+ assert.strictEqual(err.errno, dns.NOTFOUND);
uv && assert.strictEqual(err.errno, 'ENOTFOUND');
done();
common.error('before');
// custom error throwing
-throw { name: 'MyCustomError', message: 'This is a custom message' };
+throw { name: 'MyCustomError', message: 'This is a custom message' }
common.error('after');
common.error('before');
// custom error throwing
-throw { foo : 'bar' };
+throw { foo: 'bar' }
common.error('after');
req.on('end', function() {
connections--;
res.writeHead(200);
- res.end("done\n");
+ res.end('done\n');
if (connections == 0) {
server.close();
}
var request = http.request({
port: common.PORT,
method: 'POST',
- path: '/'
+ path: '/'
});
function ping() {
var body = '';
process.stdout.write('build body...');
-for (var i = 0; i < 1024*1024; i++) {
+for (var i = 0; i < 1024 * 1024; i++) {
body += 'hello world\n';
}
process.stdout.write('done\n');
-var server = https.createServer(options, function (req, res) {
+var server = https.createServer(options, function(req, res) {
reqCount++;
console.log('got request');
res.writeHead(200, { 'content-type': 'text/plain' });
var count = 0;
var gotResEnd = false;
-server.listen(common.PORT, function () {
+server.listen(common.PORT, function() {
https.get({ port: common.PORT }, function(res) {
- console.log("response!");
+ console.log('response!');
res.on('data', function(d) {
process.stdout.write('.');
count += d.length;
res.pause();
- process.nextTick(function () {
+ process.nextTick(function() {
res.resume();
});
});
res.on('end', function(d) {
process.stdout.write('\n');
- console.log("expected: ", body.length);
- console.log(" got: ", count);
+ console.log('expected: ', body.length);
+ console.log(' got: ', count);
server.close();
gotResEnd = true;
});
});
-process.on('exit', function () {
+process.on('exit', function() {
assert.equal(1, reqCount);
assert.equal(body.length, count);
assert.ok(gotResEnd);
var server = net.Server(function(socket) {
socket.on('data', function(d) {
- console.error("got %d bytes", d.length);
+ console.error('got %d bytes', d.length);
});
socket.on('end', function() {
- console.error("end");
+ console.error('end');
socket.destroy();
server.close();
});
client.on('connect', function() {
for (var i = 0; i < N; i++) {
- client.write("hello world", function() {
+ client.write('hello world', function() {
cbcount++;
});
}
// Regression test GH-511: https://github.com/ry/node/issues/issue/511
// Make sure nextTick loops quickly
-setTimeout(function () {
- t = Date.now() - t;
- STOP = 1;
- console.log(["ctr: ",ctr, ", t:", t, "ms -> ", (ctr/t).toFixed(2), "KHz"].join(''));
- assert.ok(ctr > 1000);
+setTimeout(function() {
+ t = Date.now() - t;
+ STOP = 1;
+ console.log(['ctr: ', ctr, ', t:', t, 'ms -> ', (ctr / t).toFixed(2), 'KHz']
+ .join(''));
+ assert.ok(ctr > 1000);
}, 2000);
var ctr = 0;
var STOP = 0;
-var t = Date.now()+ 2;
-while (t > Date.now()) ; //get in sync with clock
+var t = Date.now() + 2;
+while (t > Date.now()); //get in sync with clock
-(function foo () {
+(function foo() {
if (STOP) return;
process.nextTick(foo);
ctr++;
var body = '';
process.stdout.write('build body...');
-for (var i = 0; i < 1024*1024; i++) {
+for (var i = 0; i < 1024 * 1024; i++) {
body += 'hello world\n';
}
process.stdout.write('done\n');
recvCount += d.length;
client.pause();
- process.nextTick(function () {
+ process.nextTick(function() {
client.resume();
});
});
}
-var timeout = setTimeout(displayCounts, 10*1000);
+var timeout = setTimeout(displayCounts, 10 * 1000);
process.on('exit', function() {
var interval = setInterval(function() {
try {
require('vm').runInNewContext('throw 1;');
- } catch(e) {
+ } catch (e) {
}
var rss = process.memoryUsage().rss;
maxMem = Math.max(rss, maxMem);
- if (Date.now() - start > 5*1000) {
+ if (Date.now() - start > 5 * 1000) {
// wait 10 seconds.
clearInterval(interval);
}
}, 1);
process.on('exit', function() {
- console.error('max mem: %dmb', Math.round(maxMem / (1024*1024)));
+ console.error('max mem: %dmb', Math.round(maxMem / (1024 * 1024)));
// make sure we stay below 100mb
assert.ok(maxMem < 50 * 1024 * 1024);
});
threw = false;
try {
assert.throws(
- function() {
- throw {};
- },
- Array
+ function() {
+ throw {}
+ },
+ Array
);
-} catch(e) {
+} catch (e) {
threw = true;
}
-assert.ok(threw, "wrong constructor validation");
+assert.ok(threw, 'wrong constructor validation');
// use a RegExp to validate error message
a.throws(makeBlock(thrower, TypeError), /test/);
// use a fn to validate error object
a.throws(makeBlock(thrower, TypeError), function(err) {
- if ( (err instanceof TypeError) && /test/.test(err)) {
+ if ((err instanceof TypeError) && /test/.test(err)) {
return true;
}
});
var gotError = false;
try {
assert.deepEqual(b, c);
-} catch(e) {
+} catch (e) {
gotError = true;
}
testAssertionMessage('', '""');
testAssertionMessage('foo', '"foo"');
testAssertionMessage([], '[]');
-testAssertionMessage([1,2,3], '[1,2,3]');
+testAssertionMessage([1, 2, 3], '[1,2,3]');
testAssertionMessage(/a/, '"/a/"');
testAssertionMessage(/abc/gim, '"/abc/gim"');
testAssertionMessage(function f() {}, '"function f() {}"');
testAssertionMessage({}, '{}');
-testAssertionMessage({a:undefined, b:null}, '{"a":"undefined","b":null}');
-testAssertionMessage({a:NaN, b:Infinity, c:-Infinity},
+testAssertionMessage({a: undefined, b: null}, '{"a":"undefined","b":null}');
+testAssertionMessage({a: NaN, b: Infinity, c: -Infinity},
'{"a":"NaN","b":"Infinity","c":"-Infinity"}');
assert.equal(f.length, 5);
var size = f.write('あいうえお', 'ucs2');
console.error('bytes written to buffer: %d (should be 4)', size);
-console.error('chars written to buffer: %d (should be 2)', Buffer._charsWritten);
+console.error('chars written to buffer: %d (should be 2)',
+ Buffer._charsWritten);
assert.equal(size, 4);
assert.equal(Buffer._charsWritten, 2);
assert.deepEqual(f, new Buffer([0x42, 0x30, 0x44, 0x30, 0x00]));
// Writing base64 at a position > 0 should not mangle the result.
//
// https://github.com/joyent/node/issues/402
-var segments = ['TWFkbmVzcz8h','IFRoaXM=','IGlz','IG5vZGUuanMh'];
+var segments = ['TWFkbmVzcz8h', 'IFRoaXM=', 'IGlz', 'IG5vZGUuanMh'];
var buf = new Buffer(64);
var pos = 0;
// test hex toString
console.log('Create hex string from buffer');
var hexb = new Buffer(256);
-for (var i = 0; i < 256; i ++) {
+for (var i = 0; i < 256; i++) {
hexb[i] = i;
}
var hexStr = hexb.toString('hex');
assert.equal(hexStr,
- '000102030405060708090a0b0c0d0e0f'+
- '101112131415161718191a1b1c1d1e1f'+
- '202122232425262728292a2b2c2d2e2f'+
- '303132333435363738393a3b3c3d3e3f'+
- '404142434445464748494a4b4c4d4e4f'+
- '505152535455565758595a5b5c5d5e5f'+
- '606162636465666768696a6b6c6d6e6f'+
- '707172737475767778797a7b7c7d7e7f'+
- '808182838485868788898a8b8c8d8e8f'+
- '909192939495969798999a9b9c9d9e9f'+
- 'a0a1a2a3a4a5a6a7a8a9aaabacadaeaf'+
- 'b0b1b2b3b4b5b6b7b8b9babbbcbdbebf'+
- 'c0c1c2c3c4c5c6c7c8c9cacbcccdcecf'+
- 'd0d1d2d3d4d5d6d7d8d9dadbdcdddedf'+
- 'e0e1e2e3e4e5e6e7e8e9eaebecedeeef'+
+ '000102030405060708090a0b0c0d0e0f' +
+ '101112131415161718191a1b1c1d1e1f' +
+ '202122232425262728292a2b2c2d2e2f' +
+ '303132333435363738393a3b3c3d3e3f' +
+ '404142434445464748494a4b4c4d4e4f' +
+ '505152535455565758595a5b5c5d5e5f' +
+ '606162636465666768696a6b6c6d6e6f' +
+ '707172737475767778797a7b7c7d7e7f' +
+ '808182838485868788898a8b8c8d8e8f' +
+ '909192939495969798999a9b9c9d9e9f' +
+ 'a0a1a2a3a4a5a6a7a8a9aaabacadaeaf' +
+ 'b0b1b2b3b4b5b6b7b8b9babbbcbdbebf' +
+ 'c0c1c2c3c4c5c6c7c8c9cacbcccdcecf' +
+ 'd0d1d2d3d4d5d6d7d8d9dadbdcdddedf' +
+ 'e0e1e2e3e4e5e6e7e8e9eaebecedeeef' +
'f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff');
console.log('Create buffer from hex string');
var hexb2 = new Buffer(hexStr, 'hex');
-for (var i = 0; i < 256; i ++) {
+for (var i = 0; i < 256; i++) {
assert.equal(hexb2[i], hexb[i]);
}
// test an invalid slice end.
console.log('Try to slice off the end of the buffer');
-var b = new Buffer([1,2,3,4,5]);
+var b = new Buffer([1, 2, 3, 4, 5]);
var b2 = b.toString('hex', 1, 10000);
var b3 = b.toString('hex', 1, 5);
var b4 = b.toString('hex', 1);
// Test slice on SlowBuffer GH-843
var SlowBuffer = process.binding('buffer').SlowBuffer;
-function buildSlowBuffer (data) {
+function buildSlowBuffer(data) {
if (Array.isArray(data)) {
var buffer = new SlowBuffer(data.length);
- data.forEach(function(v,k) {
+ data.forEach(function(v, k) {
buffer[k] = v;
});
return buffer;
- };
+ }
return null;
}
-var x = buildSlowBuffer([0x81,0xa3,0x66,0x6f,0x6f,0xa3,0x62,0x61,0x72]);
+var x = buildSlowBuffer([0x81, 0xa3, 0x66, 0x6f, 0x6f, 0xa3, 0x62, 0x61, 0x72]);
-console.log(x.inspect())
+console.log(x.inspect());
assert.equal('<SlowBuffer 81 a3 66 6f 6f a3 62 61 72>', x.inspect());
var z = x.slice(4);
-console.log(z.inspect())
-console.log(z.length)
+console.log(z.inspect());
+console.log(z.length);
assert.equal(5, z.length);
assert.equal(0x6f, z[0]);
assert.equal(0xa3, z[1]);
assert.equal(0x72, z[4]);
var z = x.slice(0);
-console.log(z.inspect())
-console.log(z.length)
+console.log(z.inspect());
+console.log(z.length);
assert.equal(z.length, x.length);
var z = x.slice(0, 4);
-console.log(z.inspect())
-console.log(z.length)
+console.log(z.inspect());
+console.log(z.length);
assert.equal(4, z.length);
assert.equal(0x81, z[0]);
assert.equal(0xa3, z[1]);
var z = x.slice(0, 9);
-console.log(z.inspect())
-console.log(z.length)
+console.log(z.inspect());
+console.log(z.length);
assert.equal(9, z.length);
var z = x.slice(1, 4);
-console.log(z.inspect())
-console.log(z.length)
+console.log(z.inspect());
+console.log(z.length);
assert.equal(3, z.length);
assert.equal(0xa3, z[0]);
var z = x.slice(2, 4);
-console.log(z.inspect())
-console.log(z.length)
+console.log(z.inspect());
+console.log(z.length);
assert.equal(2, z.length);
assert.equal(0x66, z[0]);
assert.equal(0x6f, z[1]);
-assert.equal(0, Buffer('hello').slice(0, 0).length)
+assert.equal(0, Buffer('hello').slice(0, 0).length);
b = new Buffer(50);
-b.fill("h");
+b.fill('h');
for (var i = 0; i < b.length; i++) {
- assert.equal("h".charCodeAt(0), b[i]);
+ assert.equal('h'.charCodeAt(0), b[i]);
}
b.fill(0);
// Binary encoding should write only one byte per character.
var b = Buffer([0xde, 0xad, 0xbe, 0xef]);
var s = String.fromCharCode(0xffff);
-b.write(s, 0, 'binary')
+b.write(s, 0, 'binary');
assert.equal(0xff, b[0]);
assert.equal(0xad, b[1]);
assert.equal(0xbe, b[2]);
assert.equal(0xef, b[3]);
s = String.fromCharCode(0xaaee);
-b.write(s, 0, 'binary')
+b.write(s, 0, 'binary');
assert.equal(0xee, b[0]);
assert.equal(0xad, b[1]);
assert.equal(0xbe, b[2]);
// This should not segfault the program.
assert.throws(function() {
- new Buffer('"pong"', 0, 6, 8031, '127.0.0.1')
+ new Buffer('"pong"', 0, 6, 8031, '127.0.0.1');
});
// #1210 Test UTF-8 string includes null character
assert.equal(Buffer(-1).length, 0);
assert.equal(Buffer(NaN).length, 0);
assert.equal(Buffer(3.3).length, 4);
-assert.equal(Buffer({length:3.3}).length, 4);
-assert.equal(Buffer({length:"BAM"}).length, 0);
+assert.equal(Buffer({length: 3.3}).length, 4);
+assert.equal(Buffer({length: 'BAM'}).length, 0);
// Make sure that strings are not coerced to numbers.
-assert.equal(Buffer("99").length, 2);
-assert.equal(Buffer("13.37").length, 5);
\ No newline at end of file
+assert.equal(Buffer('99').length, 2);
+assert.equal(Buffer('13.37').length, 5);
var sub = common.fixturesDir + '/child-process-channel.js';
-var child = spawn(process.execPath, [ sub ], {
+var child = spawn(process.execPath, [sub], {
customFds: [0, 1, 2],
wantChannel: true
});
-console.log("fds", child.fds);
+console.log('fds', child.fds);
assert.ok(child.fds.length == 4);
assert.ok(child.fds[3] >= 0);
var bigish = Array(200);
for (var i = 0, il = bigish.length; i < il; ++i)
- bigish[i] = -1;
+ bigish[i] = -1;
common.spawnPwd({ customFds: bigish });
}
// Assume these exist, and 'pwd' gives us the right directory back
-if (process.platform == "win32") {
+if (process.platform == 'win32') {
testCwd({cwd: process.env.windir}, 0, process.env.windir);
testCwd({cwd: 'c:\\'}, 0, 'c:\\');
} else {
// pipe echo | grep
echo.stdout.on('data', function(data) {
- console.error("grep stdin write " + data.length);
+ console.error('grep stdin write ' + data.length);
if (!grep.stdin.write(data)) {
echo.stdout.pause();
}
});
echo.on('exit', function() {
- console.error("echo exit");
-})
+ console.error('echo exit');
+});
grep.on('exit', function() {
- console.error("grep exit");
-})
+ console.error('grep exit');
+});
sed.on('exit', function() {
- console.error("sed exit");
-})
+ console.error('sed exit');
+});
// pipe grep | sed
grep.stdout.on('data', function(data) {
- console.error("grep stdout " + data.length);
+ console.error('grep stdout ' + data.length);
if (!sed.stdin.write(data)) {
grep.stdout.pause();
}
// propagate end from grep to sed
grep.stdout.on('end', function(code) {
- console.error("grep stdout end");
+ console.error('grep stdout end');
sed.stdin.end();
});
};
env.__proto__ = {
'FOO': 'BAR'
-}
+};
if (isWindows) {
var child = spawn('cmd.exe', ['/c', 'set'], {env: env});
var pwdcommand, dir;
if (process.platform == 'win32') {
- pwdcommand = 'echo %cd%';
+ pwdcommand = 'echo %cd%';
dir = 'c:\\windows';
} else {
- pwdcommand = 'pwd';
+ pwdcommand = 'pwd';
dir = '/dev';
}
});
process.addListener('exit', function() {
- console.log("response: ", response);
+ console.log('response: ', response);
assert.equal(1, success_count);
assert.equal(0, error_count);
assert.ok(response.indexOf('HELLO=WORLD') >= 0);
var common = require('../common');
var assert = require('assert');
-var ch = require("child_process")
+var ch = require('child_process');
-var SIZE = 100000
+var SIZE = 100000;
var childGone = false;
-var cp = ch.spawn("python", ['-c', 'print ' + SIZE + ' * "C"'], {
+var cp = ch.spawn('python', ['-c', 'print ' + SIZE + ' * "C"'], {
customFds: [0, 1, 2]
});
-cp.on("exit", function (code) {
+cp.on('exit', function(code) {
childGone = true;
assert.equal(0, code);
});
// assert that "42\n" is written to stderr
child.exec(nodejs + ' --eval "console.error(42)"',
function(err, stdout, stderr) {
- assert.equal(stderr, "42\n");
+ assert.equal(stderr, '42\n');
});
// assert that module loading works
var common = require('../common');
var assert = require('assert');
-var func = function () {};
+var func = function() {};
var toStringCalled = false;
-func.toString = function () {
+func.toString = function() {
toStringCalled = true;
};
console.log('foo');
console.log('foo', 'bar');
console.log('%s %s', 'foo', 'bar', 'hop');
-console.log({slashes: '\\\\'})
+console.log({slashes: '\\\\'});
global.process.stdout.write = stdout_write;
assert.equal('foo\n', strings.shift());
assert.equal('foo bar hop\n', strings.shift());
assert.equal("{ slashes: '\\\\\\\\' }\n", strings.shift());
-assert.equal(true, process.stderr.write("hello world"));
+assert.equal(true, process.stderr.write('hello world'));
// bump, we register a lot of exit listeners
process.setMaxListeners(256);
-[ crypto.randomBytes,
+[crypto.randomBytes,
crypto.pseudoRandomBytes
].forEach(function(f) {
- [ -1,
+ [-1,
undefined,
null,
false,
[]
].forEach(function(value) {
assert.throws(function() { f(value); });
- assert.throws(function() { f(value, function(){}); });
+ assert.throws(function() { f(value, function() {}); });
});
[0, 1, 2, 4, 16, 256, 1024].forEach(function(len) {
var caPem = fs.readFileSync(common.fixturesDir + '/test_ca.pem', 'ascii');
var certPem = fs.readFileSync(common.fixturesDir + '/test_cert.pem', 'ascii');
var keyPem = fs.readFileSync(common.fixturesDir + '/test_key.pem', 'ascii');
-var rsaPubPem = fs.readFileSync(common.fixturesDir + '/test_rsa_pubkey.pem', 'ascii');
-var rsaKeyPem = fs.readFileSync(common.fixturesDir + '/test_rsa_privkey.pem', 'ascii');
+var rsaPubPem = fs.readFileSync(common.fixturesDir + '/test_rsa_pubkey.pem',
+ 'ascii');
+var rsaKeyPem = fs.readFileSync(common.fixturesDir + '/test_rsa_privkey.pem',
+ 'ascii');
try {
var credentials = crypto.createCredentials(
sha224: '896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22',
sha256: 'b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7',
sha384: 'afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6',
- sha512: '87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854',
- },
+ sha512: '87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854'
+ }
},
{
key: new Buffer('4a656665', 'hex'), // 'Jefe'
sha224: 'a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44',
sha256: '5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843',
sha384: 'af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649',
- sha512: '164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737',
- },
+ sha512: '164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737'
+ }
},
{
key: new Buffer('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
sha224: '7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea',
sha256: '773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe',
sha384: '88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e3ab6e101a34f27',
- sha512: 'fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb',
- },
+ sha512: 'fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb'
+ }
},
{
key: new Buffer('0102030405060708090a0b0c0d0e0f10111213141516171819', 'hex'),
sha224: '6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a',
sha256: '82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b',
sha384: '3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679ccf8a386c674cffb',
- sha512: 'b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd',
- },
+ sha512: 'b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd'
+ }
},
{
key: new Buffer('0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c', 'hex'),
sha224: '0e2aea68a90c8d37c988bcdb9fca6fa8',
sha256: 'a3b6167473100ee06e0c796c2955552b',
sha384: '3abf34c3503b2a23a46efc619baef897',
- sha512: '415fad6271580a531d4179bc891d87a6',
+ sha512: '415fad6271580a531d4179bc891d87a6'
},
- truncate: true,
+ truncate: true
},
{
key: new Buffer('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
sha224: '95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e',
sha256: '60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54',
sha384: '4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05033ac4c60c2ef6ab4030fe8296248df163f44952',
- sha512: '80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598',
- },
+ sha512: '80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598'
+ }
},
{
key: new Buffer('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
sha224: '3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1',
sha256: '9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2',
sha384: '6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82461e99c5a678cc31e799176d3860e6110c46523e',
- sha512: 'e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58',
- },
- },
+ sha512: 'e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58'
+ }
+ }
];
for (var i = 0, l = rfc4231.length; i < l; i++) {
}
assert.equal(rfc4231[i]['hmac'][hash],
result,
- "Test HMAC-" + hash + ": Test case " + (i+1) + " rfc 4231");
+ 'Test HMAC-' + hash + ': Test case ' + (i + 1) + ' rfc 4231');
}
}
{
key: new Buffer('0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b', 'hex'),
data: 'Hi There',
- hmac: '9294727a3638bb1c13f48ef8158bfc9d',
+ hmac: '9294727a3638bb1c13f48ef8158bfc9d'
},
{
key: 'Jefe',
data: 'what do ya want for nothing?',
- hmac: '750c783e6ab0b503eaa86e310a5db738',
+ hmac: '750c783e6ab0b503eaa86e310a5db738'
},
{
key: new Buffer('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
data: new Buffer('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd', 'hex'),
- hmac: '56be34521d144c88dbb8c733f0e8b3f6',
+ hmac: '56be34521d144c88dbb8c733f0e8b3f6'
},
{
key: new Buffer('0102030405060708090a0b0c0d0e0f10111213141516171819', 'hex'),
data: new Buffer('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd', 'hex'),
- hmac: '697eaf0aca3a3aea3a75164746ffaa79',
+ hmac: '697eaf0aca3a3aea3a75164746ffaa79'
},
{
key: new Buffer('0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c', 'hex'),
data: 'Test With Truncation',
- hmac: '56461ef2342edc00f9bab995690efd4c',
+ hmac: '56461ef2342edc00f9bab995690efd4c'
},
{
key: new Buffer('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
data: 'Test Using Larger Than Block-Size Key - Hash Key First',
- hmac: '6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd',
+ hmac: '6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd'
},
{
key: new Buffer('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
data: 'Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data',
- hmac: '6f630fad67cda0ee1fb1f562db3aa53e',
- },
+ hmac: '6f630fad67cda0ee1fb1f562db3aa53e'
+ }
];
var rfc2202_sha1 = [
{
key: new Buffer('0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b', 'hex'),
data: 'Hi There',
- hmac: 'b617318655057264e28bc0b6fb378c8ef146be00',
+ hmac: 'b617318655057264e28bc0b6fb378c8ef146be00'
},
{
key: 'Jefe',
data: 'what do ya want for nothing?',
- hmac: 'effcdf6ae5eb2fa2d27416d5f184df9c259a7c79',
+ hmac: 'effcdf6ae5eb2fa2d27416d5f184df9c259a7c79'
},
{
key: new Buffer('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
data: new Buffer('dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd', 'hex'),
- hmac: '125d7342b9ac11cd91a39af48aa17b4f63f175d3',
+ hmac: '125d7342b9ac11cd91a39af48aa17b4f63f175d3'
},
{
key: new Buffer('0102030405060708090a0b0c0d0e0f10111213141516171819', 'hex'),
data: new Buffer('cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd', 'hex'),
- hmac: '4c9007f4026250c6bc8414f9bf50c86c2d7235da',
+ hmac: '4c9007f4026250c6bc8414f9bf50c86c2d7235da'
},
{
key: new Buffer('0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c', 'hex'),
data: 'Test With Truncation',
- hmac: '4c1a03424b55e07fe7f27be1d58bb9324a9a5a04',
+ hmac: '4c1a03424b55e07fe7f27be1d58bb9324a9a5a04'
},
{
key: new Buffer('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
data: 'Test Using Larger Than Block-Size Key - Hash Key First',
- hmac: 'aa4ae5e15272d00e95705637ce8a3b55ed402112',
+ hmac: 'aa4ae5e15272d00e95705637ce8a3b55ed402112'
},
{
key: new Buffer('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'hex'),
data: 'Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data',
- hmac: 'e8e99d0f45237d786d6bbaa7965c7808bbff1a91',
- },
+ hmac: 'e8e99d0f45237d786d6bbaa7965c7808bbff1a91'
+ }
];
for (var i = 0, l = rfc2202_md5.length; i < l; i++) {
crypto.createHmac('md5', rfc2202_md5[i]['key'])
.update(rfc2202_md5[i]['data'])
.digest('hex'),
- "Test HMAC-MD5 : Test case " + (i+1) + " rfc 2202");
+ 'Test HMAC-MD5 : Test case ' + (i + 1) + ' rfc 2202');
}
for (var i = 0, l = rfc2202_sha1.length; i < l; i++) {
assert.equal(rfc2202_sha1[i]['hmac'],
crypto.createHmac('sha1', rfc2202_sha1[i]['key'])
.update(rfc2202_sha1[i]['data'])
.digest('hex'),
- "Test HMAC-SHA1 : Test case " + (i+1) + " rfc 2202");
+ 'Test HMAC-SHA1 : Test case ' + (i + 1) + ' rfc 2202');
}
// Test hashing
// encryption and decryption with Base64
// reported in https://github.com/joyent/node/issues/738
var plaintext =
- '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
- 'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJjAfaFg**';
+ '32|RmVZZkFUVmpRRkp0TmJaUm56ZU9qcnJkaXNNWVNpTTU*|iXmckfRWZBGWWELw' +
+ 'eCBsThSsfUHLeRe0KCsK8ooHgxie0zOINpXxfZi/oNG7uq9JWFVCk70gfzQH8ZUJjAfaFg**';
var cipher = crypto.createCipher('aes256', '0123456789abcdef');
// encrypt plaintext which is in utf8 format
// Test PBKDF2 with RFC 6070 test vectors (except #4)
-crypto.pbkdf2('password', 'salt', 1, 20, function (err, result) {
+crypto.pbkdf2('password', 'salt', 1, 20, function(err, result) {
assert.equal(result, '\x0c\x60\xc8\x0f\x96\x1f\x0e\x71\xf3\xa9\xb5\x24\xaf\x60\x12\x06\x2f\xe0\x37\xa6', 'pbkdf1 test vector 1');
});
-crypto.pbkdf2('password', 'salt', 2, 20, function (err, result) {
+crypto.pbkdf2('password', 'salt', 2, 20, function(err, result) {
assert.equal(result, '\xea\x6c\x01\x4d\xc7\x2d\x6f\x8c\xcd\x1e\xd9\x2a\xce\x1d\x41\xf0\xd8\xde\x89\x57', 'pbkdf1 test vector 2');
});
-crypto.pbkdf2('password', 'salt', 4096, 20, function (err, result) {
+crypto.pbkdf2('password', 'salt', 4096, 20, function(err, result) {
assert.equal(result, '\x4b\x00\x79\x01\xb7\x65\x48\x9a\xbe\xad\x49\xd9\x26\xf7\x21\xd0\x65\xa4\x29\xc1', 'pbkdf1 test vector 3');
});
-crypto.pbkdf2('passwordPASSWORDpassword', 'saltSALTsaltSALTsaltSALTsaltSALTsalt', 4096, 25, function (err, result) {
+crypto.pbkdf2('passwordPASSWORDpassword', 'saltSALTsaltSALTsaltSALTsaltSALTsalt', 4096, 25, function(err, result) {
assert.equal(result, '\x3d\x2e\xec\x4f\xe4\x1c\x84\x9b\x80\xc8\xd8\x36\x62\xc0\xe4\x4a\x8b\x29\x1a\x96\x4c\xf2\xf0\x70\x38', 'pbkdf1 test vector 5');
});
-crypto.pbkdf2('pass\0word', 'sa\0lt', 4096, 16, function (err, result) {
+crypto.pbkdf2('pass\0word', 'sa\0lt', 4096, 16, function(err, result) {
assert.equal(result, '\x56\xfa\x6a\xa7\x55\x48\x09\x9d\xcc\x37\xd7\xf0\x34\x25\xe0\xc3', 'pbkdf1 test vector 6');
});
var resCount = 0;
var p = new debug.Protocol();
-p.onResponse = function (res) {
+p.onResponse = function(res) {
resCount++;
};
-p.execute("Type: connect\r\n" +
- "V8-Version: 3.0.4.1\r\n" +
- "Protocol-Version: 1\r\n" +
- "Embedding-Host: node v0.3.3-pre\r\n" +
- "Content-Length: 0\r\n\r\n");
+p.execute('Type: connect\r\n' +
+ 'V8-Version: 3.0.4.1\r\n' +
+ 'Protocol-Version: 1\r\n' +
+ 'Embedding-Host: node v0.3.3-pre\r\n' +
+ 'Content-Length: 0\r\n\r\n');
assert.equal(1, resCount);
// Make sure split messages go in.
var expectedConnections = 0;
var tests = [];
-function addTest (cb) {
+function addTest(cb) {
expectedConnections++;
tests.push(cb);
}
-addTest(function (client, done) {
- console.error("requesting version");
- client.reqVersion(function (err, v) {
+addTest(function(client, done) {
+ console.error('requesting version');
+ client.reqVersion(function(err, v) {
assert.ok(!err);
- console.log("version: %s", v);
+ console.log('version: %s', v);
assert.equal(process.versions.v8, v);
done();
});
});
-addTest(function (client, done) {
- console.error("requesting scripts");
- client.reqScripts(function (err) {
+addTest(function(client, done) {
+ console.error('requesting scripts');
+ client.reqScripts(function(err) {
assert.ok(!err);
- console.error("got %d scripts", Object.keys(client.scripts).length);
+ console.error('got %d scripts', Object.keys(client.scripts).length);
var foundMainScript = false;
for (var k in client.scripts) {
});
});
-addTest(function (client, done) {
- console.error("eval 2+2");
- client.reqEval("2+2", function (err, res) {
+addTest(function(client, done) {
+ console.error('eval 2+2');
+ client.reqEval('2+2', function(err, res) {
console.error(res);
assert.ok(!err);
assert.equal('4', res.text);
var nodeProcess = spawn(process.execPath,
['-e', 'setInterval(function () { console.log("blah"); }, 100);']);
- nodeProcess.stdout.once('data', function () {
- console.log(">>> new node process: %d", nodeProcess.pid);
- process.kill(nodeProcess.pid, "SIGUSR1");
- console.log(">>> signaling it with SIGUSR1");
+ nodeProcess.stdout.once('data', function() {
+ console.log('>>> new node process: %d', nodeProcess.pid);
+ process.kill(nodeProcess.pid, 'SIGUSR1');
+ console.log('>>> signaling it with SIGUSR1');
});
var didTryConnect = false;
nodeProcess.stderr.setEncoding('utf8');
- var b = ''
- nodeProcess.stderr.on('data', function (data) {
+ var b = '';
+ nodeProcess.stderr.on('data', function(data) {
b += data;
if (didTryConnect == false && /debugger listening on port/.test(b)) {
didTryConnect = true;
setTimeout(function() {
// Wait for some data before trying to connect
var c = new debug.Client();
- process.stdout.write(">>> connecting...");
- c.connect(debug.port)
- c.on('ready', function () {
+ process.stdout.write('>>> connecting...');
+ c.connect(debug.port);
+ c.on('ready', function() {
connectCount++;
- console.log("ready!");
- cb(c, function () {
- console.error(">>> killing node process %d\n\n", nodeProcess.pid);
+ console.log('ready!');
+ cb(c, function() {
+ console.error('>>> killing node process %d\n\n', nodeProcess.pid);
nodeProcess.kill();
done();
});
}
-function run () {
+function run() {
var t = tests[0];
if (!t) return;
- doTest(t, function () {
+ doTest(t, function() {
tests.shift();
run();
});
}
};
expected.push({input: input, lines: output, callback: next});
-};
+}
// Initial lines
addTest(null, [
function finish() {
process.exit(0);
-};
+}
function quit() {
if (quit.called) return;
quit.called = true;
child.stdin.write('quit');
-};
+}
setTimeout(function() {
throw new Error('timeout!');
var exits = 0;
function errExec(script, callback) {
- var cmd = '"' + process.argv[0] + '" "' + path.join(common.fixturesDir, script) + '"';
+ var cmd = '"' + process.argv[0] + '" "' +
+ path.join(common.fixturesDir, script) + '"';
return exec(cmd, function(err, stdout, stderr) {
// There was some error
assert.ok(err);
var success_count = 0;
var error_count = 0;
-var cmd = [process.execPath, '-e', '"console.error(process.argv)"', 'foo', 'bar'].join(' ');
-var expected = util.format([process.execPath, 'foo', 'bar']) + "\n";
+var cmd = [process.execPath, '-e', '"console.error(process.argv)"', 'foo', 'bar']
+ .join(' ');
+var expected = util.format([process.execPath, 'foo', 'bar']) + '\n';
var child = exec(cmd, function(err, stdout, stderr) {
if (err) {
console.log(err.toString());
e.emit('hello', 'a', 'b');
var remove = function() {
- assert.fail(1,0, 'once->foo should not be emitted', '!');
+ assert.fail(1, 0, 'once->foo should not be emitted', '!');
};
e.once('foo', remove);
process.on('exit', function() {
removeTestFile();
- if ( cb_occurred !== cb_expected) {
+ if (cb_occurred !== cb_expected) {
console.log(' Test callback events missing or out of order:');
console.log(' expected: %j', cb_expected);
console.log(' occurred: %j', cb_occurred);
assert.strictEqual(cb_occurred, cb_expected,
- 'events missing or out of order: "' +
- cb_occurred + '" !== "' + cb_expected + '"');
+ 'events missing or out of order: "' +
+ cb_occurred + '" !== "' + cb_expected + '"');
}
});
process.on('exit', function() {
removeTestFile();
- if ( cb_occurred !== cb_expected) {
+ if (cb_occurred !== cb_expected) {
console.log(' Test callback events missing or out of order:');
console.log(' expected: %j', cb_expected);
console.log(' occurred: %j', cb_occurred);
assert.strictEqual(cb_occurred, cb_expected,
- 'events missing or out of order: "' +
- cb_occurred + '" !== "' + cb_expected + '"');
+ 'events missing or out of order: "' +
+ cb_occurred + '" !== "' + cb_expected + '"');
}
});
// Error: start must be >= zero
assert.throws(
- function() {
- file = fs.createWriteStream(filepath, options);
- },
- /start must be/
+ function() {
+ file = fs.createWriteStream(filepath, options);
+ },
+ /start must be/
);
}
var caughtException = false;
try {
- // should throw ENOENT, not EBADF - see https://github.com/joyent/node/pull/1228
+ // should throw ENOENT, not EBADF
+ // see https://github.com/joyent/node/pull/1228
fs.openSync('/path/to/file/that/does/not/exist', 'r');
}
catch (e) {
});
-fs.writeFileSync(filepathOne, "hello");
+fs.writeFileSync(filepathOne, 'hello');
assert.throws(
- function() {
- fs.watchFile(filepathOne);
- },
- function(e) {
- return e.message === 'watchFile requires a listener function';
- }
+ function() {
+ fs.watchFile(filepathOne);
+ },
+ function(e) {
+ return e.message === 'watchFile requires a listener function';
+ }
);
assert.doesNotThrow(
- function() {
- fs.watchFile(filepathOne, function(curr, prev) {
- fs.unwatchFile(filepathOne);
- ++watchSeenOne;
- });
- }
+ function() {
+ fs.watchFile(filepathOne, function(curr, prev) {
+ fs.unwatchFile(filepathOne);
+ ++watchSeenOne;
+ });
+ }
);
setTimeout(function() {
- fs.writeFileSync(filepathOne, "world");
+ fs.writeFileSync(filepathOne, 'world');
}, 1000);
process.chdir(testDir);
-fs.writeFileSync(filepathTwoAbs, "howdy");
+fs.writeFileSync(filepathTwoAbs, 'howdy');
assert.throws(
- function() {
- fs.watchFile(filepathTwo);
- },
- function(e) {
- return e.message === 'watchFile requires a listener function';
- }
+ function() {
+ fs.watchFile(filepathTwo);
+ },
+ function(e) {
+ return e.message === 'watchFile requires a listener function';
+ }
);
assert.doesNotThrow(
- function() {
- fs.watchFile(filepathTwo, function(curr, prev) {
- fs.unwatchFile(filepathTwo);
- ++watchSeenTwo;
- });
- }
+ function() {
+ fs.watchFile(filepathTwo, function(curr, prev) {
+ fs.unwatchFile(filepathTwo);
+ ++watchSeenTwo;
+ });
+ }
);
setTimeout(function() {
- fs.writeFileSync(filepathTwoAbs, "pardner");
+ fs.writeFileSync(filepathTwoAbs, 'pardner');
}, 1000);
});
-fs.writeFileSync(filepathOne, "hello");
+fs.writeFileSync(filepathOne, 'hello');
assert.throws(
- function() {
- fs.watch(filepathOne);
- },
- function(e) {
- return e.message === 'watch requires a listener function';
- }
+ function() {
+ fs.watch(filepathOne);
+ },
+ function(e) {
+ return e.message === 'watch requires a listener function';
+ }
);
assert.doesNotThrow(
- function() {
- var watcher = fs.watch(filepathOne, function(event, filename) {
- assert.equal('change', event);
- if (expectFilePath) {
- assert.equal('watch.txt', filename);
- } else {
- assert.equal(null, filename);
- }
- watcher.close();
- ++watchSeenOne;
- });
- }
+ function() {
+ var watcher = fs.watch(filepathOne, function(event, filename) {
+ assert.equal('change', event);
+ if (expectFilePath) {
+ assert.equal('watch.txt', filename);
+ } else {
+ assert.equal(null, filename);
+ }
+ watcher.close();
+ ++watchSeenOne;
+ });
+ }
);
setTimeout(function() {
- fs.writeFileSync(filepathOne, "world");
+ fs.writeFileSync(filepathOne, 'world');
}, 1000);
process.chdir(testDir);
-fs.writeFileSync(filepathTwoAbs, "howdy");
+fs.writeFileSync(filepathTwoAbs, 'howdy');
assert.throws(
- function() {
- fs.watch(filepathTwo);
- },
- function(e) {
- return e.message === 'watch requires a listener function';
- }
+ function() {
+ fs.watch(filepathTwo);
+ },
+ function(e) {
+ return e.message === 'watch requires a listener function';
+ }
);
assert.doesNotThrow(
- function() {
- var watcher = fs.watch(filepathTwo, function(event, filename) {
- assert.equal('change', event);
- if (expectFilePath) {
- assert.equal('hasOwnProperty', filename);
- } else {
- assert.equal(null, filename);
- }
- watcher.close();
- ++watchSeenTwo;
- });
- }
+ function() {
+ var watcher = fs.watch(filepathTwo, function(event, filename) {
+ assert.equal('change', event);
+ if (expectFilePath) {
+ assert.equal('hasOwnProperty', filename);
+ } else {
+ assert.equal(null, filename);
+ }
+ watcher.close();
+ ++watchSeenTwo;
+ });
+ }
);
setTimeout(function() {
- fs.writeFileSync(filepathTwoAbs, "pardner");
+ fs.writeFileSync(filepathTwoAbs, 'pardner');
}, 1000);
-try { fs.unlinkSync(filepathThree); } catch(e) {}
-try { fs.mkdirSync(testsubdir, 0700); } catch(e) {}
+try { fs.unlinkSync(filepathThree); } catch (e) {}
+try { fs.mkdirSync(testsubdir, 0700); } catch (e) {}
assert.doesNotThrow(
- function() {
- var watcher = fs.watch(testsubdir, function(event, filename) {
- assert.equal('rename', event);
- if (expectFilePath) {
- assert.equal('newfile.txt', filename);
- } else {
- assert.equal(null, filename);
- }
- watcher.close();
- ++watchSeenThree;
- });
- }
+ function() {
+ var watcher = fs.watch(testsubdir, function(event, filename) {
+ assert.equal('rename', event);
+ if (expectFilePath) {
+ assert.equal('newfile.txt', filename);
+ } else {
+ assert.equal(null, filename);
+ }
+ watcher.close();
+ ++watchSeenThree;
+ });
+ }
);
setTimeout(function() {
var fd = fs.openSync(filepathThree, 'w');
fs.closeSync(fd);
-}, 1000);
\ No newline at end of file
+}, 1000);
assert.equal(1, req.httpVersionMajor);
assert.equal(0, req.httpVersionMinor);
res.writeHead(200, {'Content-Type': 'text/plain'});
- res.write("Hello, "); res._send('');
- res.write("world!"); res._send('');
+ res.write('Hello, '); res._send('');
+ res.write('world!'); res._send('');
res.end();
}
function request_generator() {
- return ("GET / HTTP/1.0\r\n"
- + "User-Agent: curl/7.19.7 (x86_64-pc-linux-gnu) libcurl/7.19.7 OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n"
- + "Host: 127.0.0.1:1337\r\n"
- + "Accept: */*\r\n"
- + "\r\n");
+ return ('GET / HTTP/1.0\r\n' +
+ 'User-Agent: curl/7.19.7 (x86_64-pc-linux-gnu) libcurl/7.19.7 OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n' +
+ 'Host: 127.0.0.1:1337\r\n' +
+ 'Accept: */*\r\n' +
+ '\r\n');
}
function response_validator(server_response, client_got_eof, timed_out) {
- var expected_response = ("HTTP/1.1 200 OK\r\n"
- + "Content-Type: text/plain\r\n"
- + "Connection: close\r\n"
- + "\r\n"
- + "Hello, world!");
+ var expected_response = ('HTTP/1.1 200 OK\r\n' +
+ 'Content-Type: text/plain\r\n' +
+ 'Connection: close\r\n' +
+ '\r\n' +
+ 'Hello, world!');
assert.equal(expected_response, server_response.data);
assert.equal(1, server_response.chunks.length);
assert.equal(1, req.httpVersionMajor);
assert.equal(1, req.httpVersionMinor);
res.writeHead(200, {'Content-Type': 'text/plain'});
- res.write("Hello, "); res._send('');
- res.write("world!"); res._send('');
+ res.write('Hello, '); res._send('');
+ res.write('world!'); res._send('');
res.end();
}
function request_generator() {
- return ("GET / HTTP/1.1\r\n"
- + "User-Agent: curl/7.19.7 (x86_64-pc-linux-gnu) libcurl/7.19.7 OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n"
- + "Connection: close\r\n"
- + "Host: 127.0.0.1:1337\r\n"
- + "Accept: */*\r\n"
- + "\r\n");
+ return ('GET / HTTP/1.1\r\n' +
+ 'User-Agent: curl/7.19.7 (x86_64-pc-linux-gnu) libcurl/7.19.7 OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n' +
+ 'Connection: close\r\n' +
+ 'Host: 127.0.0.1:1337\r\n' +
+ 'Accept: */*\r\n' +
+ '\r\n');
}
function response_validator(server_response, client_got_eof, timed_out) {
- var expected_response = ("HTTP/1.1 200 OK\r\n"
- + "Content-Type: text/plain\r\n"
- + "Connection: close\r\n"
- + "Transfer-Encoding: chunked\r\n"
- + "\r\n"
- + "7\r\n"
- + "Hello, \r\n"
- + "6\r\n"
- + "world!\r\n"
- + "0\r\n"
- + "\r\n");
+ var expected_response = ('HTTP/1.1 200 OK\r\n' +
+ 'Content-Type: text/plain\r\n' +
+ 'Connection: close\r\n' +
+ 'Transfer-Encoding: chunked\r\n' +
+ '\r\n' +
+ '7\r\n' +
+ 'Hello, \r\n' +
+ '6\r\n' +
+ 'world!\r\n' +
+ '0\r\n' +
+ '\r\n');
assert.equal(expected_response, server_response.data);
assert.equal(1, server_response.chunks.length);
}
test(handler, request_generator, response_validator);
-})();
\ No newline at end of file
+})();
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-var common = require("../common");
-var http = require("http");
-var assert = require("assert");
+var common = require('../common');
+var http = require('http');
+var assert = require('assert');
-var server = http.Server(function (req, res) {
- console.log("Server accepted request.");
+var server = http.Server(function(req, res) {
+ console.log('Server accepted request.');
res.writeHead(200);
- res.write("Part of my res.");
+ res.write('Part of my res.');
res.destroy();
});
-var responseClose = false
+var responseClose = false;
server.listen(common.PORT, function() {
var client = http.get({
port: common.PORT,
- headers: { connection: "keep-alive" }
+ headers: { connection: 'keep-alive' }
}, function(res) {
server.close();
- console.log("Got res: " + res.statusCode);
+ console.log('Got res: ' + res.statusCode);
console.dir(res.headers);
- res.on("data", function (chunk) {
- console.log("Read " + chunk.length + " bytes");
+ res.on('data', function(chunk) {
+ console.log('Read ' + chunk.length + ' bytes');
console.log(chunk.toString());
});
- res.on("end", function () {
- console.log("Response ended.");
+ res.on('end', function() {
+ console.log('Response ended.');
});
// it would be nice if this worked:
- res.on("close", function () {
- console.log("Response aborted");
+ res.on('close', function() {
+ console.log('Response aborted');
responseClose = true;
});
});
var server = http.Server(function(req, res) {
res.writeHead(200);
- res.end("hello world\n");
+ res.end('hello world\n');
});
var responses = 0;
server.listen(common.PORT, function() {
for (var i = 0; i < N; i++) {
- setTimeout(function () {
+ setTimeout(function() {
for (var j = 0; j < M; j++) {
- http.get({ port: common.PORT, path: '/', }, function(res) {
+ http.get({ port: common.PORT, path: '/' }, function(res) {
console.log(res.statusCode);
if (++responses == N * M) server.close();
}).on('error', function(e) {
console.error('writing request: %s', method);
var request = http.request({
- port: common.PORT,
+ port: common.PORT,
method: method,
- path: '/'
+ path: '/'
}, function(response) {
response.on('end', function() {
if (methods.length == 0) {
console.log('Making request');
var req = http.request({
- port: common.PORT,
- method: 'GET',
- path: '/',
+ port: common.PORT,
+ method: 'GET',
+ path: '/',
headers: { 'content-length': buffer.length }
}, function(res) {
console.log('Got response');
});
server.listen(common.PORT, function() {
var data = '';
- var get = http.get({path:'/', host:'localhost', port:common.PORT}, function (x) {
- x.setEncoding('utf8')
- x.on('data', function (c) {data += c});
- x.on('error', function (e) {
+ var get = http.get({
+ path: '/',
+ host: 'localhost',
+ port: common.PORT
+ }, function(x) {
+ x.setEncoding('utf8');
+ x.on('data', function(c) {data += c});
+ x.on('error', function(e) {
throw e;
- })
- x.on('end', function () {
+ });
+ x.on('end', function() {
assert.equal('string', typeof data);
console.log('here is the response:');
assert.equal(UTF8_STRING, data);
console.log(data);
server.close();
- })
- })
- get.on('error', function (e) {throw e});
+ });
+ });
+ get.on('error', function(e) {throw e});
get.end();
});
var clientAborts = 0;
var server = http.Server(function(req, res) {
- console.log("Got connection");
+ console.log('Got connection');
res.writeHead(200);
- res.write("Working on it...");
+ res.write('Working on it...');
// I would expect an error event from req or res that the client aborted
// before completing the HTTP request / response cycle, or maybe a new
// event like "aborted" or something.
- req.on("aborted", function () {
+ req.on('aborted', function() {
clientAborts++;
- console.log("Got abort " + clientAborts);
+ console.log('Got abort ' + clientAborts);
if (clientAborts === N) {
- console.log("All aborts detected, you win.");
+ console.log('All aborts detected, you win.');
server.close();
}
});
// since there is already clientError, maybe that would be appropriate,
// since "error" is magical
- req.on("clientError", function () {
- console.log("Got clientError");
+ req.on('clientError', function() {
+ console.log('Got clientError');
});
});
var requests = [];
server.listen(common.PORT, function() {
- console.log("Server listening.");
+ console.log('Server listening.');
for (var i = 0; i < N; i++) {
- console.log("Making client " + i);
+ console.log('Making client ' + i);
var options = { port: common.PORT, path: '/?id=' + i };
var req = http.get(options, function(res) {
- console.log("Client response code " + res.statusCode);
+ console.log('Client response code ' + res.statusCode);
if (++responses == N) {
- console.log("All clients connected, destroying.");
- requests.forEach(function (outReq) {
- console.log("abort");
+ console.log('All clients connected, destroying.');
+ requests.forEach(function(outReq) {
+ console.log('abort');
outReq.abort();
});
}
srv.listen(common.PORT, '127.0.0.1', function() {
var req = http.request({
- host: '127.0.0.1',
- port: common.PORT,
+ host: '127.0.0.1',
+ port: common.PORT,
method: 'GET',
- path: '/'});
+ path: '/'});
req.end();
req.on('error', function(e) {
server.addListener('listening', function() {
var req = http.request({
- port: common.PORT,
+ port: common.PORT,
method: 'POST',
- path: '/'
+ path: '/'
}, function(res) {
res.setEncoding('utf8');
res.addListener('data', function(chunk) {
server.addListener('listening', function() {
var req = http.request({
- port: common.PORT,
+ port: common.PORT,
method: 'POST',
- path: '/'
+ path: '/'
}, function(res) {
res.setEncoding('utf8');
res.addListener('data', function(chunk) {
process.on('exit', function() {
assert.equal(caughtError, true);
-});
\ No newline at end of file
+});
+
// USE OR OTHER DEALINGS IN THE SOFTWARE.
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
var ddcmd = common.ddCommand(filename, 10240);
-console.log("dd command: ", ddcmd);
+console.log('dd command: ', ddcmd);
cp.exec(ddcmd, function(err, stdout, stderr) {
if (err) throw err;
}, 100);
res.writeHead(200);
- res.end("hello world\n");
+ res.end('hello world\n');
});
server.listen(common.PORT, function() {
host += host;
function do_not_call() {
- throw new Error("This function should not have been called.");
+ throw new Error('This function should not have been called.');
}
function test(mod) {
// Bad host name should not throw an uncatchable exception.
// Ensure that there is time to attach an error listener.
- var req = mod.get({host:host, port:42}, do_not_call);
+ var req = mod.get({host: host, port: 42}, do_not_call);
req.on('error', function(err) {
- assert.equal(err.code, 'EBADNAME');
- actual_bad_requests++;
+ assert.equal(err.code, 'EBADNAME');
+ actual_bad_requests++;
});
// http.get() called req.end() for us
- var req = mod.request({method:'GET', host:host, port:42}, do_not_call);
+ var req = mod.request({method: 'GET', host: host, port: 42}, do_not_call);
req.on('error', function(err) {
- assert.equal(err.code, 'EBADNAME');
- actual_bad_requests++;
+ assert.equal(err.code, 'EBADNAME');
+ actual_bad_requests++;
});
req.end();
}
process.on('exit', function() {
assert.equal(actual_bad_requests, expected_bad_requests);
-});
\ No newline at end of file
+});
+
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-/*
+/*
* Repeated requests for a domain that fails to resolve
* should trigger the error event after each attempt.
*/
var assert = require('assert');
var http = require('http');
-var resDespiteError = false
-var hadError = 0
+var resDespiteError = false;
+var hadError = 0;
function httpreq(count) {
- if ( 1 < count ) return
+ if (1 < count) return;
var req = http.request({
- host:'not-a-real-domain-name.nobody-would-register-this-as-a-tld',
+ host: 'not-a-real-domain-name.nobody-would-register-this-as-a-tld',
port: 80,
path: '/',
method: 'GET'
}, function(res) {
- resDespiteError = true
+ resDespiteError = true;
});
- req.on('error', function(e){
+ req.on('error', function(e) {
console.log(e.message);
assert.strictEqual(e.code, 'ENOTFOUND');
- hadError++
- httpreq(count + 1)
- })
+ hadError++;
+ httpreq(count + 1);
+ });
- req.end()
+ req.end();
}
-httpreq(0)
+httpreq(0);
process.on('exit', function() {
server.addListener('listening', function() {
var req = http.request({
- port: common.PORT,
- method: 'POST',
- path: '/world',
+ port: common.PORT,
+ method: 'POST',
+ path: '/world',
headers: { 'Expect': '100-continue' }
});
common.debug('Client sending request...');
var body = 'hello world\r\n';
var fullResponse =
- 'HTTP/1.1 500 Internal Server Error\r\n' +
- 'Content-Length: ' + body.length + '\r\n' +
- 'Content-Type: text/plain\r\n' +
- 'Date: Fri + 18 Feb 2011 06:22:45 GMT\r\n' +
- 'Host: 10.20.149.2\r\n' +
- 'Access-Control-Allow-Credentials: true\r\n' +
- 'Server: badly broken/0.1 (OS NAME)\r\n' +
- '\r\n' +
- body;
+ 'HTTP/1.1 500 Internal Server Error\r\n' +
+ 'Content-Length: ' + body.length + '\r\n' +
+ 'Content-Type: text/plain\r\n' +
+ 'Date: Fri + 18 Feb 2011 06:22:45 GMT\r\n' +
+ 'Host: 10.20.149.2\r\n' +
+ 'Access-Control-Allow-Credentials: true\r\n' +
+ 'Server: badly broken/0.1 (OS NAME)\r\n' +
+ '\r\n' +
+ body;
var gotResponse = false;
-var server = net.createServer(function (socket) {
+var server = net.createServer(function(socket) {
var postBody = '';
socket.setEncoding('utf8');
- socket.on('data', function (chunk) {
+ socket.on('data', function(chunk) {
postBody += chunk;
if (postBody.indexOf('\r\n') > -1) {
console.log('Got res code: ' + res.statusCode);
res.setEncoding('utf8');
- res.on('data', function (chunk) {
+ res.on('data', function(chunk) {
buffer += chunk;
});
- res.on('end', function () {
+ res.on('end', function() {
console.log('Response ended, read ' + buffer.length + ' bytes');
assert.equal(body, buffer);
server.close();
var image = fs.readFileSync(common.fixturesDir + '/person.jpg');
-console.log("image.length = " + image.length);
+console.log('image.length = ' + image.length);
var total = 100;
var requests = 0, responses = 0;
};
http.get(opts, function(res) {
- console.error("recv " + x);
- var s = fs.createWriteStream(common.tmpDir + '/' + x + ".jpg");
+ console.error('recv ' + x);
+ var s = fs.createWriteStream(common.tmpDir + '/' + x + '.jpg');
res.pipe(s);
// TODO there should be a callback to pipe() that will allow
// us to get a callback when the pipe is finished.
res.on('end', function() {
- console.error("done " + x);
+ console.error('done ' + x);
if (++responses == total) {
s.on('close', checkFiles);
}
});
}).on('error', function(e) {
- console.error('error! ', e.message)
+ console.error('error! ', e.message);
throw e;
});
})();
var stat = fs.statSync(common.tmpDir + '/' + fn);
assert.equal(image.length, stat.size,
"size doesn't match on '" + fn +
- "'. Got " + stat.size + " bytes");
+ "'. Got " + stat.size + ' bytes');
}
checkedFiles = true;
server.listen(common.PORT, function() {
var request = http.request({
- port: common.PORT,
+ port: common.PORT,
method: 'HEAD',
- path: '/'
+ path: '/'
}, function(response) {
common.error('response start');
response.addListener('end', function() {
server.addListener('listening', function() {
var req = http.request({
- port: common.PORT,
+ port: common.PORT,
method: 'HEAD',
- path: '/'
+ path: '/'
}, function(res) {
common.error('response');
res.addListener('end', function() {
// This checks that after the headers have been sent, getHeader works
// and does not throw an exception (Issue 752)
assert.doesNotThrow(
- function() {
- assert.equal(plain, res.getHeader(contentType));
- }
+ function() {
+ assert.equal(plain, res.getHeader(contentType));
+ }
);
});
host: 'localhost',
//agent: false,
port: common.PORT }, cb).on('error', thrower).end();
-
+
https.get({ method: 'GET',
path: '/setHostFalse' + (counter++),
host: 'localhost',
server.listen(common.PORT, function() {
- var agent = new http.Agent({maxSockets:1})
- var request = http.request({method:'GET', path:'/', headers:headers, port:common.PORT, agent:agent}, function () {
- assert.equal(1, agent.sockets['localhost:'+common.PORT].length)
+ var agent = new http.Agent({ maxSockets: 1 });
+ var request = http.request({
+ method: 'GET',
+ path: '/',
+ headers: headers,
+ port: common.PORT,
+ agent: agent
+ }, function() {
+ assert.equal(1, agent.sockets['localhost:' + common.PORT].length);
});
- request.on('socket', function (s) {
- s.on('connect', function () {
+ request.on('socket', function(s) {
+ s.on('connect', function() {
connectCount++;
- })
- })
+ });
+ });
request.end();
-
- request = http.request({method:'GET', path:'/', headers:headers, port:common.PORT, agent:agent}, function () {
- assert.equal(1, agent.sockets['localhost:'+common.PORT].length)
+
+ request = http.request({
+ method: 'GET',
+ path: '/',
+ headers: headers,
+ port: common.PORT,
+ agent: agent
+ }, function() {
+ assert.equal(1, agent.sockets['localhost:' + common.PORT].length);
});
- request.on('socket', function (s) {
- s.on('connect', function () {
+ request.on('socket', function(s) {
+ s.on('connect', function() {
connectCount++;
- })
- })
+ });
+ });
request.end();
- request = http.request({method:'GET', path:'/', headers:headers, port:common.PORT, agent:agent}, function(response) {
+ request = http.request({
+ method: 'GET',
+ path: '/',
+ headers: headers,
+ port: common.PORT,
+ agent: agent
+ }, function(response) {
response.addListener('end', function() {
- assert.equal(1, agent.sockets['localhost:'+common.PORT].length)
+ assert.equal(1, agent.sockets['localhost:' + common.PORT].length);
server.close();
});
});
- request.on('socket', function (s) {
- s.on('connect', function () {
+ request.on('socket', function(s) {
+ s.on('connect', function() {
connectCount++;
- })
- })
+ });
+ });
request.end();
});
var connectCount = 0;
server.listen(common.PORT, function() {
- var agent = new http.Agent({maxSockets:1})
- var request = http.request({method:'GET', path:'/', headers:headers, port:common.PORT, agent:agent}, function () {
- assert.equal(1, agent.sockets['localhost:'+common.PORT].length)
+ var agent = new http.Agent({maxSockets: 1});
+ var request = http.request({method: 'GET', path: '/', headers: headers, port: common.PORT, agent: agent}, function() {
+ assert.equal(1, agent.sockets['localhost:' + common.PORT].length);
});
request.end();
-
- request = http.request({method:'GET', path:'/', headers:headers, port:common.PORT, agent:agent}, function () {
- assert.equal(1, agent.sockets['localhost:'+common.PORT].length)
+
+ request = http.request({method: 'GET', path: '/', headers: headers, port: common.PORT, agent: agent}, function() {
+ assert.equal(1, agent.sockets['localhost:' + common.PORT].length);
});
request.end();
- request = http.request({method:'GET', path:'/', headers:headers, port:common.PORT, agent:agent}, function(response) {
+ request = http.request({method: 'GET', path: '/', headers: headers, port: common.PORT, agent: agent}, function(response) {
response.addListener('end', function() {
- assert.equal(1, agent.sockets['localhost:'+common.PORT].length)
+ assert.equal(1, agent.sockets['localhost:' + common.PORT].length);
server.close();
});
});
requests++;
assert.equal(req.connection, connection);
res.writeHead(200);
- res.end("hello world\n");
+ res.end('hello world\n');
});
server.once('connection', function(c) {
var gotResponse = false;
var server = net.createServer(function(conn) {
- var body = "Yet another node.js server.";
+ var body = 'Yet another node.js server.';
var response =
- "HTTP/1.1 200 OK\r\n" +
- "Connection: close\r\n" +
- "Content-Length: " + body.length + "\r\n" +
- "Content-Type: text/plain;\r\n" +
- " x-unix-mode=0600;\r\n" +
- " name=\"hello.txt\"\r\n" +
- "\r\n" +
- body;
+ 'HTTP/1.1 200 OK\r\n' +
+ 'Connection: close\r\n' +
+ 'Content-Length: ' + body.length + '\r\n' +
+ 'Content-Type: text/plain;\r\n' +
+ ' x-unix-mode=0600;\r\n' +
+ ' name=\"hello.txt\"\r\n' +
+ '\r\n' +
+ body;
conn.write(response, function() {
conn.destroy();
});
server.listen(common.PORT, function() {
- http.get({host:'127.0.0.1', port:common.PORT}, function(res) {
+ http.get({host: '127.0.0.1', port: common.PORT}, function(res) {
assert.equal(res.headers['content-type'],
'text/plain;x-unix-mode=0600;name="hello.txt"');
gotResponse = true;
var s = http.createServer(function(req, res) {
switch (test) {
case 'headers':
- assert.throws(function () { res.setHeader() });
- assert.throws(function () { res.setHeader('someHeader') });
- assert.throws(function () { res.getHeader() });
- assert.throws(function () { res.removeHeader() });
+ assert.throws(function() { res.setHeader() });
+ assert.throws(function() { res.setHeader('someHeader') });
+ assert.throws(function() { res.getHeader() });
+ assert.throws(function() { res.removeHeader() });
res.setHeader('x-test-header', 'testing');
res.setHeader('X-TEST-HEADER2', 'testing');
s.listen(common.PORT, nextTest);
-function nextTest () {
+function nextTest() {
if (test === 'end') {
return s.close();
}
assert.equal(response.headers['x-test-header'],
'testing');
assert.equal(response.headers['x-test-array-header'],
- [1,2,3].join(', '));
+ [1, 2, 3].join(', '));
assert.deepEqual(cookies,
response.headers['set-cookie']);
assert.equal(response.headers['x-test-header2'] !== undefined, false);
break;
default:
- throw Error("?");
+ throw Error('?');
}
response.setEncoding('utf8');
var server = http.Server(function(req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
- res.end("hello world\n");
+ res.end('hello world\n');
});
server.listen(common.PORT, function() {
var req = http.get({port: common.PORT}, function(res) {
});
res.writeHead(200);
- res.end("hello world\n");
+ res.end('hello world\n');
});
server.listen(common.PORT, function() {
res.write('a');
req.on('close', function() {
- console.error("aborted");
+ console.error('aborted');
gotEnd = true;
});
});
server.listen(common.PORT);
server.addListener('listening', function() {
- console.error("make req");
+ console.error('make req');
http.get({
port: common.PORT
}, function(res) {
- console.error("got res");
+ console.error('got res');
res.on('data', function(data) {
- console.error("destroy res");
+ console.error('destroy res');
res.destroy();
server.close();
});
throw new Error('Timeout was not sucessful');
}, 2000);
- var x = http.get({port:common.PORT, path:'/'});
- x.on('error', function () {
+ var x = http.get({port: common.PORT, path: '/'});
+ x.on('error', function() {
clearTimeout(errorTimer);
console.log('HTTP REQUEST COMPLETE (this is good)');
- })
+ });
x.end();
});
var s = http.createServer(function(req, res) {
var t = tests[testIdx];
res.writeHead(t, {'Content-Type': 'text/plain'});
- console.log('--\nserver: statusCode after writeHead: '+res.statusCode);
+ console.log('--\nserver: statusCode after writeHead: ' + res.statusCode);
assert.equal(res.statusCode, t);
res.end('hello world\n');
});
s.listen(common.PORT, nextTest);
-function nextTest () {
+function nextTest() {
if (testIdx + 1 === tests.length) {
return s.close();
}
var fs = require('fs');
var http = require('http');
-var status_ok = false; // status code == 200?
+var status_ok = false; // status code == 200?
var headers_ok = false;
-var body_ok = false;
+var body_ok = false;
var server = http.createServer(function(req, res) {
- res.writeHead(200, {'Content-Type': 'text/plain',
- 'Connection': 'close'
- });
+ res.writeHead(200, {
+ 'Content-Type': 'text/plain',
+ 'Connection': 'close'
+ });
res.write('hello ');
res.write('world\n');
res.end();
res.body = '';
res.setEncoding('utf8');
- res.on('data', function (chunk) {
+ res.on('data', function(chunk) {
res.body += chunk;
});
'connection': 'upgrade',
'upgrade': 'websocket' };
assert.deepEqual(expectedHeaders, res.headers);
- assert.equal(http.globalAgent.sockets[options.host+':'+options.port].length, 1);
-
- process.nextTick(function () {
+ assert.equal(http.globalAgent.sockets[options.host + ':' + options.port].length, 1);
+
+ process.nextTick(function() {
// Make sure this request got removed from the pool.
- assert.equal(http.globalAgent.sockets[options.host+':'+options.port].length, 0);
+ assert.equal(http.globalAgent.sockets[options.host + ':' + options.port].length, 0);
socket.end();
srv.close();
-
+
gotUpgrade = true;
- })
+ });
});
});
server.listen(common.PORT, function() {
function upgradeRequest(fn) {
- console.log("req");
+ console.log('req');
var header = { 'Connection': 'Upgrade', 'Upgrade': 'Test' };
var request = http.request({ port: common.PORT, headers: header });
var wasUpgrade = false;
function onUpgrade(res, socket, head) {
- console.log("client upgraded");
+ console.log('client upgraded');
wasUpgrade = true;
request.removeListener('upgrade', onUpgrade);
request.on('upgrade', onUpgrade);
function onEnd() {
- console.log("client end");
+ console.log('client end');
request.removeListener('end', onEnd);
if (!wasUpgrade) {
throw new Error('hasn\'t received upgrade event');
var req = http.request({
port: common.PORT,
method: 'POST',
- path: '/world',
- agent: agent
+ path: '/world',
+ agent: agent
}, function(res) {
assert.equal(200, res.statusCode);
responses_recvd += 1;
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
var server = https.Server(options, function(req, res) {
res.writeHead(200);
- res.end("hello world\n");
+ res.end('hello world\n');
});
server.listen(common.PORT, function() {
for (var i = 0; i < N; i++) {
- setTimeout(function () {
+ setTimeout(function() {
for (var j = 0; j < M; j++) {
- https.get({ port: common.PORT, path: '/', }, function(res) {
+ https.get({ port: common.PORT, path: '/' }, function(res) {
console.log(res.statusCode);
if (++responses == N * M) server.close();
}).on('error', function(e) {
var body = 'hello world\n';
-var server = http.createServer(function (req, res) {
+var server = http.createServer(function(req, res) {
reqCount++;
console.log('got request');
res.writeHead(200, { 'content-type': 'text/plain' });
var bodyBuffer = '';
server.listen(common.PORT, function() {
- console.log('1) Making Request');
+ console.log('1) Making Request');
var req = https.get({ port: common.PORT }, function(res) {
server.close();
console.log('3) Client got response headers.');
// USE OR OTHER DEALINGS IN THE SOFTWARE.
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
var modulus;
var exponent;
-var server = https.createServer(options, function (req, res) {
+var server = https.createServer(options, function(req, res) {
reqCount++;
- console.log("got request");
+ console.log('got request');
cert = req.connection.getPeerCertificate();
res.writeHead(200, { 'content-type': 'text/plain' });
res.end(body);
-})
+});
-server.listen(common.PORT, function () {
- var cmd = 'curl --insecure https://127.0.0.1:' + common.PORT + '/';
- cmd += ' --cert '+join(common.fixturesDir, 'foafssl.crt');
- cmd += ' --key '+join(common.fixturesDir, 'foafssl.key');
- console.error("executing %j", cmd);
+server.listen(common.PORT, function() {
+ var cmd = 'curl --insecure https://127.0.0.1:' + common.PORT + '/';
+ cmd += ' --cert ' + join(common.fixturesDir, 'foafssl.crt');
+ cmd += ' --key ' + join(common.fixturesDir, 'foafssl.key');
+ console.error('executing %j', cmd);
exec(cmd, function(err, stdout, stderr) {
if (err) throw err;
common.error(common.inspect(stdout));
});
-process.on('exit', function () {
+process.on('exit', function() {
assert.equal(subjectaltname, 'URI:http://example.com/#me');
- assert.equal(modulus, 'A6F44A9C25791431214F5C87AF9E040177A8BB89AC803F7E09BBC\
-3A5519F349CD9B9C40BE436D0AA823A94147E26C89248ADA2BE3DD4D34E8C28964694B2047D217\
-B4F1299371EA93A83C89AB9440724131E65F2B0161DE9560CDE9C13455552B2F49CF0FB00D8D77\
-532324913F6F80FF29D0A131D29DB06AFF8BE191B7920DC2DAE1C26EA82A47847A10391EF3BF6A\
-ABB3CC40FF82100B03A4F0FF1809278E4DDFDA7DE954ED56DC7AD9A47EEBC37D771A366FC60A5B\
-CB72373BEC180649B3EFA0E9092707210B41B90032BB18BC91F2046EBDAF1191F4A4E26D71879C\
-4C7867B62FCD508E8CE66E82D128A71E915809FCF44E8DE774067F1DE5D70B9C03687');
+ assert.equal(modulus, 'A6F44A9C25791431214F5C87AF9E040177A8BB89AC803F7E09' +
+ 'BBC3A5519F349CD9B9C40BE436D0AA823A94147E26C89248ADA2BE3DD4D34E8C2896' +
+ '4694B2047D217B4F1299371EA93A83C89AB9440724131E65F2B0161DE9560CDE9C13' +
+ '455552B2F49CF0FB00D8D77532324913F6F80FF29D0A131D29DB06AFF8BE191B7920' +
+ 'DC2DAE1C26EA82A47847A10391EF3BF6AABB3CC40FF82100B03A4F0FF1809278E4DD' +
+ 'FDA7DE954ED56DC7AD9A47EEBC37D771A366FC60A5BCB72373BEC180649B3EFA0E90' +
+ '92707210B41B90032BB18BC91F2046EBDAF1191F4A4E26D71879C4C7867B62FCD508' +
+ 'E8CE66E82D128A71E915809FCF44E8DE774067F1DE5D70B9C03687');
assert.equal(exponent, '10001');
});
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
var reqCount = 0;
var body = 'hello world\n';
-var server = https.createServer(options, function (req, res) {
+var server = https.createServer(options, function(req, res) {
reqCount++;
- console.log("got request");
+ console.log('got request');
res.writeHead(200, { 'content-type': 'text/plain' });
res.end(body);
-})
+});
-server.listen(common.PORT, function () {
- var cmd = 'curl --insecure https://127.0.0.1:' + common.PORT + '/';
- console.error("executing %j", cmd);
+server.listen(common.PORT, function() {
+ var cmd = 'curl --insecure https://127.0.0.1:' + common.PORT + '/';
+ console.error('executing %j', cmd);
exec(cmd, function(err, stdout, stderr) {
if (err) throw err;
common.error(common.inspect(stdout));
// Do the same thing now without --insecure
// The connection should not be accepted.
- var cmd = 'curl https://127.0.0.1:' + common.PORT + '/';
- console.error("executing %j", cmd);
+ var cmd = 'curl https://127.0.0.1:' + common.PORT + '/';
+ console.error('executing %j', cmd);
exec(cmd, function(err, stdout, stderr) {
assert.ok(err);
server.close();
});
});
-process.on('exit', function () {
+process.on('exit', function() {
assert.equal(1, reqCount);
});
(function() {
var assert = require('assert'),
- child = require('child_process'),
- util = require('util'),
+ child = require('child_process'),
+ util = require('util'),
common = require('../common');
if (process.env['TEST_INIT']) {
util.print('Loaded successfully!');
// being in the test folder
process.chdir(__dirname);
- child.exec(process.execPath + ' test-init',{env:{'TEST_INIT':1}},
- function(err, stdout, stderr) {
- assert.equal(stdout, 'Loaded successfully!', '`node test-init` failed!');
- });
- child.exec(process.execPath + ' test-init.js', {env:{'TEST_INIT':1}},
- function(err, stdout, stderr) {
- assert.equal(stdout, 'Loaded successfully!', '`node test-init.js` failed!');
- });
+ child.exec(process.execPath + ' test-init', {env: {'TEST_INIT': 1}},
+ function(err, stdout, stderr) {
+ assert.equal(stdout, 'Loaded successfully!', '`node test-init` failed!');
+ });
+ child.exec(process.execPath + ' test-init.js', {env: {'TEST_INIT': 1}},
+ function(err, stdout, stderr) {
+ assert.equal(stdout, 'Loaded successfully!', '`node test-init.js` failed!');
+ });
// test-init-index is in fixtures dir as requested by ry, so go there
process.chdir(common.fixturesDir);
- child.exec(process.execPath + ' test-init-index',{env:{'TEST_INIT':1}},
- function(err, stdout, stderr) {
- assert.equal(stdout, 'Loaded successfully!', '`node test-init-index failed!');
- });
+ child.exec(process.execPath + ' test-init-index', {env: {'TEST_INIT': 1}},
+ function(err, stdout, stderr) {
+ assert.equal(stdout, 'Loaded successfully!', '`node test-init-index failed!');
+ });
// ensures that `node fs` does not mistakenly load the native 'fs' module
// instead of the desired file and that the fs module loads as expected in node
process.chdir(common.fixturesDir + '/test-init-native/');
- child.exec(process.execPath + ' fs', {env:{'TEST_INIT':1}},
- function(err, stdout, stderr) {
- assert.equal(stdout, 'fs loaded successfully', '`node fs` failed!');
- });
+ child.exec(process.execPath + ' fs', {env: {'TEST_INIT': 1}},
+ function(err, stdout, stderr) {
+ assert.equal(stdout, 'fs loaded successfully', '`node fs` failed!');
+ });
}
})();
// Now do the test again after we console.log something.
-console.log("load console.log. process.stdout._type is " +
+console.log('load console.log. process.stdout._type is ' +
process.stdout._type);
-if (!process.features.uv) {
+if (!process.features.uv) {
// legacy
expected = expected.concat([
'NativeModule console',
case 'fs':
expected = expected.concat([
'NativeModule console',
- 'Binding tty_wrap',
+ 'Binding tty_wrap'
]);
break;
'NativeModule timers_uv',
'Binding timer_wrap',
'NativeModule _linklist',
- 'Binding pipe_wrap',
+ 'Binding pipe_wrap'
]);
break;
default:
- assert.ok(0, "prcoess.stdout._type is bad");
+ assert.ok(0, 'prcoess.stdout._type is bad');
}
}
-console.error("process.moduleLoadList", process.moduleLoadList)
-console.error("expected", expected)
+console.error('process.moduleLoadList', process.moduleLoadList);
+console.error('expected', expected);
checkExpected();
// #1357 Loading JSON files with require()
var json = require('../fixtures/packages/main/package.json');
-assert.deepEqual(json, { name: 'package-name',
- version: '1.2.3',
- main: 'package-main-module' });
+assert.deepEqual(json, {
+ name: 'package-name',
+ version: '1.2.3',
+ main: 'package-main-module'
+});
process.addListener('exit', function() {
});
});
-tcp.listen(common.PORT, function () {
+tcp.listen(common.PORT, function() {
var socket = net.createConnection(tcpPort);
socket.on('connect', function() {
count++;
console.log('tcp client connection #' + count);
- socket.write('foo', function () {
+ socket.write('foo', function() {
socket.end('bar');
});
});
socket.connect(tcpPort);
} else {
tcp.close();
- };
+ }
});
});
-process.on('exit', function () {
+process.on('exit', function() {
assert.equal(bytesRead, 12);
assert.equal(bytesWritten, 12);
});
});
});
-tcp.listen(common.PORT, function () {
+tcp.listen(common.PORT, function() {
var socket = net.Stream();
console.log('Connecting to socket ');
assert.equal('opening', socket.readyState);
- var r = socket.write('foo', function () {
+ var r = socket.write('foo', function() {
fooWritten = true;
assert.ok(connectHappened);
- console.error("foo written");
+ console.error('foo written');
});
assert.equal(false, r);
assert.equal('opening', socket.readyState);
});
-process.on('exit', function () {
+process.on('exit', function() {
assert.ok(connectHappened);
assert.ok(fooWritten);
});
socket0.setTimeout(T);
socket0.on('timeout', function() {
- console.error("timeout");
+ console.error('timeout');
gotTimeout0 = true;
var now = new Date();
assert.ok(now - start < T + 500);
});
socket0.on('connect', function() {
- console.error("connect");
+ console.error('connect');
gotConnect0 = true;
socket0.destroy();
});
socket1.setTimeout(T);
socket1.on('timeout', function() {
- console.error("timeout");
+ console.error('timeout');
gotTimeout1 = true;
var now = new Date();
assert.ok(now - start < T + 500);
});
socket1.on('connect', function() {
- console.error("connect");
+ console.error('connect');
gotConnect1 = true;
socket1.destroy();
});
net.createConnection(tcpPort, 'localhost', cb);
});
-process.on('exit', function () {
+process.on('exit', function() {
assert.equal(clientConnected, 4);
});
assert.equal(true, socket.readable);
assert.equal(true, count <= N);
if (/PING/.exec(data)) {
- socket.write('PONG', function () {
+ socket.write('PONG', function() {
sentPongs++;
console.error('sent PONG');
});
pingPongTest(20989, 'localhost');
pingPongTest(20997, '::1');
-process.addListener('exit', function () {
+process.addListener('exit', function() {
assert.equal(4, tests_run);
console.log('done');
});
var server1listening = false;
var server2listening = false;
-var server1 = net.Server(function (socket) {
+var server1 = net.Server(function(socket) {
connections++;
socket.destroy();
});
-var server2 = net.Server(function (socket) {
+var server2 = net.Server(function(socket) {
connections++;
socket.destroy();
});
var server2errors = 0;
server2.on('error', function() {
server2errors++;
- console.error("server2 error");
+ console.error('server2 error');
});
-server1.listen(common.PORT, function () {
- console.error("server1 listening");
+server1.listen(common.PORT, function() {
+ console.error('server1 listening');
server1listening = true;
// This should make server2 emit EADDRINUSE
server2.listen(common.PORT);
// Then we could avoid this very unlikely but potential race condition
// here.
setTimeout(function() {
- server2.listen(common.PORT + 1, function () {
- console.error("server2 listening");
+ server2.listen(common.PORT + 1, function() {
+ console.error('server2 listening');
server2listening = true;
server1.close();
s.server.connections = 10;
assert.equal(10, s.server.connections);
-s.destroy()
+s.destroy();
assert.equal(9, s.server.connections);
-s.destroy()
+s.destroy();
assert.equal(9, s.server.connections);
var os = require('os');
-var hostname = os.hostname()
-console.log("hostname = %s", hostname);
+var hostname = os.hostname();
+console.log('hostname = %s', hostname);
assert.ok(hostname.length > 0);
var uptime = os.uptime();
-console.log("uptime = %d", uptime);
+console.log('uptime = %d', uptime);
assert.ok(uptime > 0);
var cpus = os.cpus();
-console.log("cpus = ", cpus);
+console.log('cpus = ', cpus);
assert.ok(cpus.length > 0);
var type = os.type();
-console.log("type = ", type);
+console.log('type = ', type);
assert.ok(type.length > 0);
var release = os.release();
-console.log("release = ", release);
+console.log('release = ', release);
assert.ok(release.length > 0);
var platform = os.platform();
-console.log("platform = ", platform);
+console.log('platform = ', platform);
assert.ok(platform.length > 0);
var arch = os.arch();
-console.log("arch = ", arch);
+console.log('arch = ', arch);
assert.ok(arch.length > 0);
if (process.platform != 'sunos') {
if (isWindows) {
// windows
var resolveTests =
- // arguments result
- [[['c:/blah\\blah', 'd:/games', 'c:../a' ], 'c:\\blah\\a' ],
- [['c:/ignore', 'd:\\a/b\\c/d', '\\e.exe' ], 'd:\\e.exe' ],
- [['c:/ignore', 'c:/some/file' ], 'c:\\some\\file' ],
- [['d:/ignore', 'd:some/dir//' ], 'd:\\ignore\\some\\dir' ],
- [['.' ], process.cwd() ],
- [['//server/share', '..', 'relative\\' ], '\\\\server\\share\\relative' ]];
+ // arguments result
+ [[['c:/blah\\blah', 'd:/games', 'c:../a'], 'c:\\blah\\a'],
+ [['c:/ignore', 'd:\\a/b\\c/d', '\\e.exe'], 'd:\\e.exe'],
+ [['c:/ignore', 'c:/some/file'], 'c:\\some\\file'],
+ [['d:/ignore', 'd:some/dir//'], 'd:\\ignore\\some\\dir'],
+ [['.'], process.cwd()],
+ [['//server/share', '..', 'relative\\'], '\\\\server\\share\\relative']];
} else {
// Posix
var resolveTests =
- // arguments result
- [[['/var/lib', '../', 'file/' ], '/var/file' ],
- [['/var/lib', '/../', 'file/' ], '/file' ],
- [['a/b/c/', '../../..' ], process.cwd() ],
- [['.' ], process.cwd() ],
- [['/some/dir', '.', '/absolute/' ], '/absolute' ]];
+ // arguments result
+ [[['/var/lib', '../', 'file/'], '/var/file'],
+ [['/var/lib', '/../', 'file/'], '/file'],
+ [['a/b/c/', '../../..'], process.cwd()],
+ [['.'], process.cwd()],
+ [['/some/dir', '.', '/absolute/'], '/absolute']];
}
-var failures = []
+var failures = [];
resolveTests.forEach(function(test) {
var actual = path.resolve.apply(path, test[0]);
var expected = test[1];
if (isWindows) {
// windows
var relativeTests =
- // arguments result
- [['c:/blah\\blah', 'd:/games', 'd:\\games'],
- ['c:/aaaa/bbbb', 'c:/aaaa', '..'],
- ['c:/aaaa/bbbb', 'c:/cccc', '..\\..\\cccc'],
- ['c:/aaaa/bbbb', 'c:/aaaa/bbbb',''],
- ['c:/aaaa/bbbb', 'c:/aaaa/cccc','..\\cccc'],
- ['c:/aaaa/', 'c:/aaaa/cccc', 'cccc'],
- ['c:/', 'c:\\aaaa\\bbbb', 'aaaa\\bbbb'],
- ['c:/aaaa/bbbb', 'd:\\', 'd:\\']];
+ // arguments result
+ [['c:/blah\\blah', 'd:/games', 'd:\\games'],
+ ['c:/aaaa/bbbb', 'c:/aaaa', '..'],
+ ['c:/aaaa/bbbb', 'c:/cccc', '..\\..\\cccc'],
+ ['c:/aaaa/bbbb', 'c:/aaaa/bbbb', ''],
+ ['c:/aaaa/bbbb', 'c:/aaaa/cccc', '..\\cccc'],
+ ['c:/aaaa/', 'c:/aaaa/cccc', 'cccc'],
+ ['c:/', 'c:\\aaaa\\bbbb', 'aaaa\\bbbb'],
+ ['c:/aaaa/bbbb', 'd:\\', 'd:\\']];
} else {
// posix
var relativeTests =
- // arguments result
- [['/var/lib', '/var', '..'],
- ['/var/lib', '/bin', '../../bin'],
- ['/var/lib', '/var/lib', ''],
- ['/var/lib', '/var/apache', '../apache'],
- ['/var/', '/var/lib', 'lib'],
- ['/', '/var/lib', 'var/lib']];
+ // arguments result
+ [['/var/lib', '/var', '..'],
+ ['/var/lib', '/bin', '../../bin'],
+ ['/var/lib', '/var/lib', ''],
+ ['/var/lib', '/var/apache', '../apache'],
+ ['/var/', '/var/lib', 'lib'],
+ ['/', '/var/lib', 'var/lib']];
}
var failures = [];
relativeTests.forEach(function(test) {
server.on('listening', function() {
var cmd = common.ddCommand(filename, 10240);
- console.log("dd command: ", cmd);
+ console.log('dd command: ', cmd);
cp.exec(cmd, function(err, stdout, stderr) {
if (err) throw err;
});
conn.on('data', function(data) {
- assert.equal(data.toString(), 'PONG')
+ assert.equal(data.toString(), 'PONG');
have_pong = true;
conn.destroy();
});
});
conn.on('data', function(data) {
- assert.equal(data.toString(), 'PING')
+ assert.equal(data.toString(), 'PING');
have_ping = true;
conn.write('PONG', 'utf-8');
});
test(net.Stream, function() {
test(net.Socket);
-});
\ No newline at end of file
+});
+
console.log('Making request');
var req = http.request({
- port: common.PORT,
- method: 'GET',
- path: '/',
+ port: common.PORT,
+ method: 'GET',
+ path: '/',
headers: { 'content-length': buffer.length }
}, function(res) {
console.log('Got response');
* environment variables. The problem is that various V8 platform backends
* deal with timezone in different ways. The windows platform backend caches
* the timezone value while the Linux one hits libc for every query.
-
+
https://github.com/joyent/node/blob/08782931205bc4f6d28102ebc29fd806e8ccdf1f/deps/v8/src/platform-linux.cc#L339-345
https://github.com/joyent/node/blob/08782931205bc4f6d28102ebc29fd806e8ccdf1f/deps/v8/src/platform-win32.cc#L590-596
process.kill(cat.pid, 0);
-cat.stdout.on('data', function(){
+cat.stdout.on('data', function() {
called = true;
process.kill(cat.pid, 'SIGKILL');
});
// EPIPE when null sig fails
cat.stdin.write('test');
-process.on('exit', function(){
+process.on('exit', function() {
assert.ok(called);
});
var gotPipeData = false;
p.onexit = function(exitCode, signal) {
- console.log("exit");
+ console.log('exit');
p.close();
pipe.readStart();
assert.equal(0, signal);
processExited = true;
-}
+};
pipe.onread = function(b, off, len) {
assert.ok(processExited);
if (b) {
gotPipeData = true;
- console.log("read %d", len);
+ console.log('read %d', len);
} else {
gotPipeEOF = true;
pipe.close();
}
-}
+};
p.spawn({
file: process.execPath,
- args: [ process.execPath, "-v" ],
+ args: [process.execPath, '-v'],
stdoutStream: pipe
});
['foo=%zx', 'foo=%25zx', {'foo': '%zx'}],
['foo=%EF%BF%BD', 'foo=%EF%BF%BD', {'foo': '\ufffd' }],
// See: https://github.com/joyent/node/issues/1707
- [ 'hasOwnProperty=x&toString=foo&valueOf=bar&__defineGetter__=baz',
+ ['hasOwnProperty=x&toString=foo&valueOf=bar&__defineGetter__=baz',
'hasOwnProperty=x&toString=foo&valueOf=bar&__defineGetter__=baz',
{ hasOwnProperty: 'x',
toString: 'foo',
valueOf: 'bar',
- __defineGetter__: 'baz' } ]
+ __defineGetter__: 'baz' }]
];
// [ wonkyQS, canonicalQS, obj ]
buffer[6] = 0;
ASSERT.equal(0, buffer.readDoubleBE(0));
ASSERT.equal(0, buffer.readDoubleLE(0));
- ASSERT.equal(false, 1/buffer.readDoubleLE(0)<0);
+ ASSERT.equal(false, 1 / buffer.readDoubleLE(0) < 0);
buffer[7] = 0x80;
ASSERT.equal(6.3e-322, buffer.readDoubleBE(0));
ASSERT.equal(0, buffer.readDoubleLE(0));
- ASSERT.equal(true, 1/buffer.readDoubleLE(0)<0);
+ ASSERT.equal(true, 1 / buffer.readDoubleLE(0) < 0);
buffer[6] = 0xf0;
buffer[7] = 0x7f;
buffer[3] = 0;
ASSERT.equal(0, buffer.readFloatBE(0));
ASSERT.equal(0, buffer.readFloatLE(0));
- ASSERT.equal(false, 1/buffer.readFloatLE(0)<0);
+ ASSERT.equal(false, 1 / buffer.readFloatLE(0) < 0);
buffer[3] = 0x80;
ASSERT.equal(1.793662034335766e-43, buffer.readFloatBE(0));
ASSERT.equal(0, buffer.readFloatLE(0));
- ASSERT.equal(true, 1/buffer.readFloatLE(0)<0);
+ ASSERT.equal(true, 1 / buffer.readFloatLE(0) < 0);
buffer[0] = 0;
buffer[1] = 0;
// USE OR OTHER DEALINGS IN THE SOFTWARE.
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
var server = https.createServer(options, function(req, res) {
res.writeHead(200);
- res.end("hello world\n");
+ res.end('hello world\n');
});
server.listen(common.PORT, function() {
- https.get({
- path: '/',
- port: common.PORT,
+ https.get({
+ path: '/',
+ port: common.PORT,
agent: false
- }, function (res) {
+ }, function(res) {
console.error(res.statusCode);
gotCallback = true;
server.close();
- }).on('error', function (e) {
+ }).on('error', function(e) {
console.error(e.message);
process.exit(1);
});
}
var child = ch.spawn(process.execPath, [__filename, gen + 1], {
- customFds: [ 0, -1, 2]
+ customFds: [0, -1, 2]
});
assert.ok(!child.stdin);
assert.ok(child.stdout);
}, 1000);
*/
-child.on('exit', function (code) {
+child.on('exit', function(code) {
console.error('exit %d from gen %d', code, gen + 1);
//clearTimeout(timer);
});
child.stdout.pipe(process.stdout);
-child.stdout.on("close", function() {
- console.error("child.stdout close gen=%d", gen);
+child.stdout.on('close', function() {
+ console.error('child.stdout close gen=%d', gen);
});
function serverOn() {
- console.error("Server ON");
+ console.error('Server ON');
server.listen(common.PORT);
}
function serverOff() {
- console.error("Server OFF");
+ console.error('Server OFF');
server.close();
pingping();
}
-var responses = []
+var responses = [];
function afterPing(result) {
function ping() {
- console.error("making req");
+ console.error('making req');
var opt = {
port: common.PORT,
assert.equal('PONG', body);
assert.ok(!hadError);
gotEnd = true;
- afterPing("success");
+ afterPing('success');
});
});
var hadError = false;
req.on('error', function(error) {
- console.log("Error making ping req: " + error);
+ console.log('Error making ping req: ' + error);
hadError = true;
assert.ok(!gotEnd);
afterPing(error.message);
var assert = require('assert');
// Connect to something that we need to DNS resolve
-var c = net.createConnection(80, "google.com");
+var c = net.createConnection(80, 'google.com');
c.destroy();
var agent = http.globalAgent;
agent.maxSockets = 10;
-var server = http.createServer(function (req, res) {
+var server = http.createServer(function(req, res) {
res.writeHead(200);
res.end('Hello World\n');
});
-server.listen(common.PORT, "127.0.0.1", function() {
+server.listen(common.PORT, '127.0.0.1', function() {
for (var i = 0; i < N; i++) {
var options = {
host: '127.0.0.1',
- port: common.PORT,
+ port: common.PORT
};
var req = http.get(options, function(res) {
assert.equal(req.agent, agent);
- console.log('Socket: ' + agent.sockets['127.0.0.1:'+common.PORT].length +
+ console.log('Socket: ' + agent.sockets['127.0.0.1:' + common.PORT].length +
'/' + agent.maxSockets +
- ' queued: '+ (agent.requests['127.0.0.1:'+common.PORT] ? agent.requests['127.0.0.1:'+common.PORT].length : 0));
+ ' queued: ' + (agent.requests['127.0.0.1:' + common.PORT] ? agent.requests['127.0.0.1:' + common.PORT].length : 0));
- if (maxQueued < (agent.requests['127.0.0.1:'+common.PORT] ? agent.requests['127.0.0.1:'+common.PORT].length : 0)) {
- maxQueued = (agent.requests['127.0.0.1:'+common.PORT] ? agent.requests['127.0.0.1:'+common.PORT].length : 0);
+ if (maxQueued < (agent.requests['127.0.0.1:' + common.PORT] ? agent.requests['127.0.0.1:' + common.PORT].length : 0)) {
+ maxQueued = (agent.requests['127.0.0.1:' + common.PORT] ? agent.requests['127.0.0.1:' + common.PORT].length : 0);
}
}
});
var https = require('https');
var fs = require('fs');
-var PORT = 8000
+var PORT = 8000;
var bytesExpected = 1024 * 1024 * 32;
var stderrBuffer = '';
var child = spawn(process.execPath,
- [ childScript, common.PORT, bytesExpected ]);
+ [childScript, common.PORT, bytesExpected]);
child.on('exit', function(code) {
assert.ok(/DONE/.test(stderrBuffer));
});
server.listen(common.PORT, function() {
- console.log("expecting %d bytes", bytesExpected);
+ console.log('expecting %d bytes', bytesExpected);
makeRequest();
});
process.on('exit', function() {
- console.error("got %d bytes", uploadCount);
+ console.error('got %d bytes', uploadCount);
assert.equal(uploadCount, bytesExpected);
});
var t = Date.now();
var diff;
-setTimeout(function () {
+setTimeout(function() {
diff = Date.now() - t;
console.error(diff);
}, 0.1);
{ client: client_unix, send: 'function blah() { return 1; }',
expect: prompt_unix },
{ client: client_unix, send: 'blah()',
- expect: "1\n" + prompt_unix },
+ expect: '1\n' + prompt_unix },
// Multiline object
{ client: client_unix, send: '{ a: ',
expect: prompt_multiline },
{ client: client_unix, send: '1 }',
- expect: "{ a: 1 }" },
+ expect: '{ a: 1 }' },
// Multiline anonymous function with comment
{ client: client_unix, send: '(function () {',
expect: prompt_multiline },
{ client: client_unix, send: 'return 1;',
expect: prompt_multiline },
{ client: client_unix, send: '})()',
- expect: "1" },
+ expect: '1' }
]);
}
{ client: client_unix, send: 'a = 12345\n',
expect: ('12345' + '\n' + prompt_unix) },
{ client: client_unix, send: '{a:1}\n',
- expect: ('{ a: 1 }' + '\n' + prompt_unix) },
+ expect: ('{ a: 1 }' + '\n' + prompt_unix) }
]);
});
require('./../fixtures/a.js');
require('http');
-console.log("counterBefore = %d", counter);
+console.log('counterBefore = %d', counter);
var counterBefore = counter;
// Now load the module a bunch of times with equivalent paths.
require('http');
}
-console.log("counterAfter = %d", counter);
+console.log('counterAfter = %d', counter);
var counterAfter = counter;
assert.equal(counterBefore, counterAfter);
common.debug('test runInContext signature');
var gh1140Exception;
try {
- Script.runInContext('throw new Error()', context, 'expected-filename.js');
+ Script.runInContext('throw new Error()', context, 'expected-filename.js');
}
catch (e) {
- gh1140Exception = e;
- assert.ok(/expected-filename/.test(e.stack), 'expected appearance of filename in Error stack');
+ gh1140Exception = e;
+ assert.ok(/expected-filename/.test(e.stack), 'expected appearance of filename in Error stack');
}
assert.ok(gh1140Exception, 'expected exception from runInContext signature test');
// Test addListener condition where a watcher for SIGNAL
// has been previously registered, and `process.listeners(SIGNAL).length === 1`
-process.addListener('SIGHUP', function () {});
+process.addListener('SIGHUP', function() {});
process.removeAllListeners('SIGHUP');
-process.addListener('SIGHUP', function () { sighup = true });
+process.addListener('SIGHUP', function() { sighup = true });
process.kill(process.pid, 'SIGHUP');
process.addListener('exit', function() {
var stdoutScript = join(common.fixturesDir, 'echo.js');
var tmpFile = join(common.fixturesDir, 'stdin.txt');
-var cmd = '"' + process.argv[0] + '" "' + stdoutScript + '" < "' + tmpFile + '"';
+var cmd = '"' + process.argv[0] + '" "' + stdoutScript + '" < "' +
+ tmpFile + '"';
var string = 'abc\nümlaut.\nsomething else\n' +
'南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，' +
var assert = require('assert');
var util = require('util');
-function Writable () {
+function Writable() {
this.writable = true;
this.endCalls = 0;
stream.Stream.call(this);
}
util.inherits(Writable, stream.Stream);
-Writable.prototype.end = function () {
+Writable.prototype.end = function() {
this.endCalls++;
-}
+};
-Writable.prototype.destroy = function () {
+Writable.prototype.destroy = function() {
this.endCalls++;
-}
+};
-function Readable () {
+function Readable() {
this.readable = true;
stream.Stream.call(this);
}
var w = new Writable();
-console.error = function (text) {
+console.error = function(text) {
throw new Error(text);
-}
+};
var r;
for (i = 0; i < limit; i++) {
- r = new Readable()
- r.pipe(w)
- r.emit('end')
+ r = new Readable();
+ r.pipe(w);
+ r.emit('end');
}
assert.equal(0, r.listeners('end').length);
assert.equal(limit, w.endCalls);
w.endCalls = 0;
for (i = 0; i < limit; i++) {
- r = new Readable()
- r.pipe(w)
- r.emit('close')
+ r = new Readable();
+ r.pipe(w);
+ r.emit('close');
}
assert.equal(0, r.listeners('close').length);
assert.equal(limit, w.endCalls);
w.endCalls = 0;
var r2;
-r = new Readable()
+r = new Readable();
r2 = new Readable();
-r.pipe(w)
-r2.pipe(w)
-r.emit('close')
-r2.emit('close')
+r.pipe(w);
+r2.pipe(w);
+r.emit('close');
+r2.emit('close');
assert.equal(1, w.endCalls);
r = new Readable();
var assert = require('assert');
var util = require('util');
-function Writable () {
+function Writable() {
this.writable = true;
stream.Stream.call(this);
}
util.inherits(Writable, stream.Stream);
-function Readable () {
+function Readable() {
this.readable = true;
stream.Stream.call(this);
}
var passed = false;
var w = new Writable();
-w.on('pipe', function (src) {
+w.on('pipe', function(src) {
passed = true;
});
var r = new Readable();
r.pipe(w);
-assert.ok(passed)
+assert.ok(passed);
// Test that having a bunch of streams piping in parallel
// doesn't break anything.
-var common = require("../common");
-var assert = require("assert");
-var Stream = require("stream").Stream;
+var common = require('../common');
+var assert = require('assert');
+var Stream = require('stream').Stream;
var rr = [];
var ww = [];
var cnt = 100;
FakeStream.prototype = Object.create(Stream.prototype);
FakeStream.prototype.write = function(chunk) {
- console.error(this.ID, "write", this.wait)
+ console.error(this.ID, 'write', this.wait);
if (this.wait) {
- process.nextTick(this.emit.bind(this, "drain"));
+ process.nextTick(this.emit.bind(this, 'drain'));
}
this.wait = !this.wait;
return this.wait;
};
FakeStream.prototype.end = function() {
- this.emit("end");
+ this.emit('end');
process.nextTick(this.close.bind(this));
};
// noop - closes happen automatically on end.
FakeStream.prototype.close = function() {
- this.emit("close");
+ this.emit('close');
};
// expect all streams to close properly.
-process.on("exit", function() {
- assert.equal(cnt, wclosed, "writable streams closed");
- assert.equal(cnt, rclosed, "readable streams closed");
+process.on('exit', function() {
+ assert.equal(cnt, wclosed, 'writable streams closed');
+ assert.equal(cnt, rclosed, 'readable streams closed');
});
-for (var i = 0; i < chunkSize; i ++) {
+for (var i = 0; i < chunkSize; i++) {
chunkSize[i] = i % 256;
}
for (var i = 0; i < cnt; i++) {
var r = new FakeStream();
- r.on("close", function() {
- console.error(this.ID, "read close");
+ r.on('close', function() {
+ console.error(this.ID, 'read close');
rclosed++;
});
rr.push(r);
var w = new FakeStream();
- w.on("close", function() {
- console.error(this.ID, "write close");
+ w.on('close', function() {
+ console.error(this.ID, 'write close');
wclosed++;
});
ww.push(w);
// now start passing through data
// simulate a relatively fast async stream.
-rr.forEach(function (r) {
+rr.forEach(function(r) {
var cnt = chunks;
var paused = false;
- r.on("pause", function() {
+ r.on('pause', function() {
paused = true;
});
- r.on("resume", function() {
+ r.on('resume', function() {
paused = false;
step();
});
function step() {
- r.emit("data", data);
+ r.emit('data', data);
if (--cnt === 0) {
r.end();
return;
assert.equal(client, client_);
assert.equal(req, req_);
- console.log("connected");
+ console.log('connected');
var shutdownReq = client.shutdown();
shutdownReq.oncomplete = function(status, client_, req_) {
- console.log("shutdown complete");
+ console.log('shutdown complete');
assert.equal(0, status);
assert.equal(client, client_);
assert.equal(shutdownReq, req_);
var shutdownCount = 0;
var server = require('net').Server(function(s) {
- console.log("got connection");
+ console.log('got connection');
connectCount++;
s.on('end', function() {
- console.log("got eof");
+ console.log('got eof');
endCount++;
s.destroy();
server.close();
var server = new TCP();
-var r = server.bind("0.0.0.0", common.PORT);
+var r = server.bind('0.0.0.0', common.PORT);
assert.equal(0, r);
server.listen(128);
server.onconnection = function(client) {
assert.equal(0, client.writeQueueSize);
- console.log("got connection");
+ console.log('got connection');
function maybeCloseClient() {
if (client.pendingWrites.length == 0 && client.gotEOF) {
- console.log("close client");
+ console.log('close client');
client.close();
}
}
var req = client.write(buffer, offset, length);
client.pendingWrites.push(req);
- console.log("client.writeQueueSize: " + client.writeQueueSize);
+ console.log('client.writeQueueSize: ' + client.writeQueueSize);
// 11 bytes should flush
assert.equal(0, client.writeQueueSize);
assert.equal(req, req_);
assert.equal(buffer, buffer_);
- console.log("client.writeQueueSize: " + client.writeQueueSize);
+ console.log('client.writeQueueSize: ' + client.writeQueueSize);
assert.equal(0, client.writeQueueSize);
writeCount++;
- console.log("write " + writeCount);
+ console.log('write ' + writeCount);
maybeCloseClient();
};
sliceCount++;
} else {
- console.log("eof");
+ console.log('eof');
client.gotEOF = true;
server.close();
eofCount++;
var c = net.createConnection(common.PORT);
c.on('connect', function() {
- c.end("hello world");
+ c.end('hello world');
});
c.setEncoding('utf8');
});
c.on('close', function() {
- console.error("client closed");
+ console.error('client closed');
});
process.on('exit', function() {
var handle = new TCP();
// Should be able to bind to the common.PORT
-var r = handle.bind("0.0.0.0", common.PORT);
+var r = handle.bind('0.0.0.0', common.PORT);
assert.equal(0, r);
// Should not be able to bind to the same port again
-var r = handle.bind("0.0.0.0", common.PORT);
+var r = handle.bind('0.0.0.0', common.PORT);
assert.equal(-1, r);
console.log(errno);
-assert.equal(errno, "EINVAL");
+assert.equal(errno, 'EINVAL');
handle.close();
var L = require('_linklist');
-var list = { name: "list" };
-var A = { name: "A" };
-var B = { name: "B" };
-var C = { name: "C" };
-var D = { name: "D" };
+var list = { name: 'list' };
+var A = { name: 'A' };
+var B = { name: 'B' };
+var C = { name: 'C' };
+var D = { name: 'D' };
L.init(list);
assert.equal(D, L.peek(list));
L.remove(D);
-// list
+// list
assert.equal(null, L.peek(list));
// USE OR OTHER DEALINGS IN THE SOFTWARE.
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
var cert = fs.readFileSync(path.join(common.fixturesDir, 'test_cert.pem'));
var key = fs.readFileSync(path.join(common.fixturesDir, 'test_key.pem'));
-var conn = tls.connect(common.PORT, {cert:cert, key:key}, function() {
+var conn = tls.connect(common.PORT, {cert: cert, key: key}, function() {
assert.ok(false); // callback should never be executed
});
conn.on('error', function() {
// ASSERT resumption.
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
// create server
var server = tls.Server(options, function(socket) {
- socket.end("Goodbye");
+ socket.end('Goodbye');
connections++;
});
server.listen(common.PORT, function() {
var session1 = null;
- var client1 = tls.connect(common.PORT, function () {
+ var client1 = tls.connect(common.PORT, function() {
console.log('connect1');
- assert.ok(!client1.isSessionReused(), "Session *should not* be reused.");
+ assert.ok(!client1.isSessionReused(), 'Session *should not* be reused.');
session1 = client1.getSession();
});
client1.on('close', function() {
console.log('close1');
- var client2 = tls.connect(common.PORT, {'session':session1}, function () {
+ var client2 = tls.connect(common.PORT, {'session': session1}, function() {
console.log('connect2');
- assert.ok(client2.isSessionReused(), "Session *should* be reused.");
+ assert.ok(client2.isSessionReused(), 'Session *should* be reused.');
});
client2.on('close', function() {
// USE OR OTHER DEALINGS IN THE SOFTWARE.
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
var testCases =
- [ { ca: ['ca1-cert'],
- key: 'agent2-key',
- cert: 'agent2-cert',
- servers: [
- { ok: true, key: 'agent1-key', cert: 'agent1-cert' },
- { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
- { ok: false, key: 'agent3-key', cert: 'agent3-cert' },
- ]
- },
-
- { ca: [],
- key: 'agent2-key',
- cert: 'agent2-cert',
- servers: [
- { ok: false, key: 'agent1-key', cert: 'agent1-cert' },
- { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
- { ok: false, key: 'agent3-key', cert: 'agent3-cert' },
- ]
- },
-
- { ca: ['ca1-cert', 'ca2-cert'],
- key: 'agent2-key',
- cert: 'agent2-cert',
- servers: [
- { ok: true, key: 'agent1-key', cert: 'agent1-cert' },
- { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
- { ok: true, key: 'agent3-key', cert: 'agent3-cert' },
- ]
- },
- ];
+ [{ ca: ['ca1-cert'],
+ key: 'agent2-key',
+ cert: 'agent2-cert',
+ servers: [
+ { ok: true, key: 'agent1-key', cert: 'agent1-cert' },
+ { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
+ { ok: false, key: 'agent3-key', cert: 'agent3-cert' }
+ ]
+ },
+
+ { ca: [],
+ key: 'agent2-key',
+ cert: 'agent2-cert',
+ servers: [
+ { ok: false, key: 'agent1-key', cert: 'agent1-cert' },
+ { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
+ { ok: false, key: 'agent3-key', cert: 'agent3-cert' }
+ ]
+ },
+
+ { ca: ['ca1-cert', 'ca2-cert'],
+ key: 'agent2-key',
+ cert: 'agent2-cert',
+ servers: [
+ { ok: true, key: 'agent1-key', cert: 'agent1-cert' },
+ { ok: false, key: 'agent2-key', cert: 'agent2-cert' },
+ { ok: true, key: 'agent3-key', cert: 'agent3-cert' }
+ ]
+ }
+ ];
var common = require('../common');
function filenamePEM(n) {
- return require('path').join(common.fixturesDir, 'keys', n + ".pem");
+ return require('path').join(common.fixturesDir, 'keys', n + '.pem');
}
var ok = serverOptions.ok;
if (serverOptions.key) {
- serverOptions.key = loadPEM(serverOptions.key);
+ serverOptions.key = loadPEM(serverOptions.key);
}
- if (serverOptions.cert) {
- serverOptions.cert = loadPEM(serverOptions.cert);
+ if (serverOptions.cert) {
+ serverOptions.cert = loadPEM(serverOptions.cert);
}
var server = tls.createServer(serverOptions, function(s) {
- s.end("hello world\n");
+ s.end('hello world\n');
});
server.listen(common.PORT, function() {
var b = '';
- console.error("connecting...");
- var client = tls.connect(common.PORT, clientOptions, function () {
+ console.error('connecting...');
+ var client = tls.connect(common.PORT, clientOptions, function() {
- console.error("expected: " + ok + " authed: " + client.authorized);
+ console.error('expected: ' + ok + ' authed: ' + client.authorized);
- assert.equal(ok, client.authorized);
+ assert.equal(ok, client.authorized);
server.close();
});
}
-function runTest (testIndex) {
+function runTest(testIndex) {
var tcase = testCases[testIndex];
if (!tcase) return;
};
- testServers(0, tcase.servers, clientOptions, function () {
+ testServers(0, tcase.servers, clientOptions, function() {
successfulTests++;
runTest(testIndex + 1);
});
process.on('exit', function() {
- console.log("successful tests: %d", successfulTests);
+ console.log('successful tests: %d', successfulTests);
assert.equal(successfulTests, testCases.length);
});
// USE OR OTHER DEALINGS IN THE SOFTWARE.
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
var tls = require('tls');
var path = require('path');
-// https://github.com/joyent/node/issues/1218 - uncatchable exception on TLS connection error
+// https://github.com/joyent/node/issues/1218
+// uncatchable exception on TLS connection error
(function() {
var cert = fs.readFileSync(path.join(common.fixturesDir, 'test_cert.pem'));
var key = fs.readFileSync(path.join(common.fixturesDir, 'test_key.pem'));
assert.ok(errorEmitted);
});
- var conn = tls.connect(common.PORT, {cert:cert, key:key}, function() {
+ var conn = tls.connect(common.PORT, {cert: cert, key: key}, function() {
assert.ok(false); // callback should never be executed
});
// test for all openssl versions less than 1.0.0.
if (!process.versions.openssl ||
parseInt(process.versions.openssl[0]) < 1) {
- console.error("Skipping due to old OpenSSL version.");
+ console.error('Skipping due to old OpenSSL version.');
process.exit(0);
}
});
-var timeout = setTimeout(function () {
+var timeout = setTimeout(function() {
server.kill();
process.exit(1);
}, 5000);
// "TLS Web Client Authentication"
assert.equal(pair.cleartext.getPeerCertificate().ext_key_usage.length, 1);
- assert.equal(pair.cleartext.getPeerCertificate().ext_key_usage[0], '1.3.6.1.5.5.7.3.2');
+ assert.equal(pair.cleartext.getPeerCertificate().ext_key_usage[0],
+ '1.3.6.1.5.5.7.3.2');
console.log('client pair.cleartext.getCipher(): %j',
pair.cleartext.getCipher());
setTimeout(function() {
- pair.cleartext.write('hello\r\n', function () {
+ pair.cleartext.write('hello\r\n', function() {
gotWriteCallback = true;
});
}, 500);
// USE OR OTHER DEALINGS IN THE SOFTWARE.
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
cert: fs.readFileSync(common.fixturesDir + '/keys/agent2-cert.pem')
};
-var server = tls.createServer(function (s) {
- s.write("welcome!\n");
+var server = tls.createServer(function(s) {
+ s.write('welcome!\n');
s.pipe(s);
});
-server.listen(common.PORT, function () {
+server.listen(common.PORT, function() {
var c = net.createConnection(common.PORT);
- c.on('connect', function () {
- c.write("blah\nblah\nblah\n");
+ c.on('connect', function() {
+ c.write('blah\nblah\nblah\n');
});
- c.on('end', function () {
+ c.on('end', function() {
server.close();
});
// USE OR OTHER DEALINGS IN THE SOFTWARE.
if (!process.features.tls_npn) {
- console.error("Skipping because node compiled without OpenSSL or " +
- "with old OpenSSL version.");
+ console.error('Skipping because node compiled without OpenSSL or ' +
+ 'with old OpenSSL version.');
process.exit(0);
}
tls = require('tls');
function filenamePEM(n) {
- return require('path').join(common.fixturesDir, 'keys', n + ".pem");
+ return require('path').join(common.fixturesDir, 'keys', n + '.pem');
}
function loadPEM(n) {
});
});
});
-};
+}
process.on('exit', function() {
assert.equal(serverResults[0], clientsResults[0]);
// USE OR OTHER DEALINGS IN THE SOFTWARE.
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
// test for all openssl versions less than 1.0.0.
if (!process.versions.openssl ||
parseInt(process.versions.openssl[0]) < 1) {
- console.error("Skipping due to old OpenSSL version.");
+ console.error('Skipping due to old OpenSSL version.');
process.exit(0);
}
});
-var timeout = setTimeout(function () {
+var timeout = setTimeout(function() {
server.kill();
process.exit(1);
}, 5000);
console.log('client pair.cleartext.getCipher(): %j',
pair.cleartext.getCipher());
setTimeout(function() {
- pair.cleartext.write('hello\r\n', function () {
+ pair.cleartext.write('hello\r\n', function() {
gotWriteCallback = true;
});
}, 500);
// USE OR OTHER DEALINGS IN THE SOFTWARE.
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
server.listen(common.PORT, function() {
// To test use: openssl s_client -connect localhost:8000
- var client = spawn('openssl', ['s_client', '-connect', '127.0.0.1:' + common.PORT]);
+ var client = spawn('openssl', ['s_client', '-connect', '127.0.0.1:' +
+ common.PORT]);
var out = '';
if (!process.versions.openssl) {
- console.error("Skipping because node compiled without OpenSSL.");
+ console.error('Skipping because node compiled without OpenSSL.');
process.exit(0);
}
// - accepted and "authorized".
var testCases =
- [ { title: "Do not request certs. Everyone is unauthorized.",
+ [{ title: 'Do not request certs. Everyone is unauthorized.',
requestCert: false,
rejectUnauthorized: false,
CAs: ['ca1-cert'],
clients:
- [ { name: 'agent1', shouldReject: false, shouldAuth: false },
- { name: 'agent2', shouldReject: false, shouldAuth: false },
- { name: 'agent3', shouldReject: false, shouldAuth: false },
- { name: 'nocert', shouldReject: false, shouldAuth: false }
- ]
+ [{ name: 'agent1', shouldReject: false, shouldAuth: false },
+ { name: 'agent2', shouldReject: false, shouldAuth: false },
+ { name: 'agent3', shouldReject: false, shouldAuth: false },
+ { name: 'nocert', shouldReject: false, shouldAuth: false }
+ ]
},
- { title: "Allow both authed and unauthed connections with CA1",
+ { title: 'Allow both authed and unauthed connections with CA1',
requestCert: true,
rejectUnauthorized: false,
CAs: ['ca1-cert'],
clients:
- [ { name: 'agent1', shouldReject: false, shouldAuth: true },
- { name: 'agent2', shouldReject: false, shouldAuth: false },
- { name: 'agent3', shouldReject: false, shouldAuth: false },
- { name: 'nocert', shouldReject: false, shouldAuth: false }
- ]
+ [{ name: 'agent1', shouldReject: false, shouldAuth: true },
+ { name: 'agent2', shouldReject: false, shouldAuth: false },
+ { name: 'agent3', shouldReject: false, shouldAuth: false },
+ { name: 'nocert', shouldReject: false, shouldAuth: false }
+ ]
},
- { title: "Allow only authed connections with CA1",
+ { title: 'Allow only authed connections with CA1',
requestCert: true,
rejectUnauthorized: true,
CAs: ['ca1-cert'],
clients:
- [ { name: 'agent1', shouldReject: false, shouldAuth: true },
- { name: 'agent2', shouldReject: true },
- { name: 'agent3', shouldReject: true },
- { name: 'nocert', shouldReject: true }
- ]
+ [{ name: 'agent1', shouldReject: false, shouldAuth: true },
+ { name: 'agent2', shouldReject: true },
+ { name: 'agent3', shouldReject: true },
+ { name: 'nocert', shouldReject: true }
+ ]
},
- { title: "Allow only authed connections with CA1 and CA2",
+ { title: 'Allow only authed connections with CA1 and CA2',
requestCert: true,
rejectUnauthorized: true,
CAs: ['ca1-cert', 'ca2-cert'],
clients:
- [ { name: 'agent1', shouldReject: false, shouldAuth: true },
- { name: 'agent2', shouldReject: true },
- { name: 'agent3', shouldReject: false, shouldAuth: true },
- { name: 'nocert', shouldReject: true }
- ]
+ [{ name: 'agent1', shouldReject: false, shouldAuth: true },
+ { name: 'agent2', shouldReject: true },
+ { name: 'agent3', shouldReject: false, shouldAuth: true },
+ { name: 'nocert', shouldReject: true }
+ ]
},
- { title: "Allow only certs signed by CA2 but not in the CRL",
+ { title: 'Allow only certs signed by CA2 but not in the CRL',
requestCert: true,
rejectUnauthorized: true,
CAs: ['ca2-cert'],
crl: 'ca2-crl',
clients:
- [ { name: 'agent1', shouldReject: true, shouldAuth: false },
- { name: 'agent2', shouldReject: true, shouldAuth: false },
- { name: 'agent3', shouldReject: false, shouldAuth: true },
- // Agent4 has a cert in the CRL.
- { name: 'agent4', shouldReject: true, shouldAuth: false },
- { name: 'nocert', shouldReject: true }
- ]
- },
- ];
+ [
+ { name: 'agent1', shouldReject: true, shouldAuth: false },
+ { name: 'agent2', shouldReject: true, shouldAuth: false },
+ { name: 'agent3', shouldReject: false, shouldAuth: true },
+ // Agent4 has a cert in the CRL.
+ { name: 'agent4', shouldReject: true, shouldAuth: false },
+ { name: 'nocert', shouldReject: true }
+ ]
+ }
+ ];
var common = require('../common');
function filenamePEM(n) {
- return require('path').join(common.fixturesDir, 'keys', n + ".pem");
+ return require('path').join(common.fixturesDir, 'keys', n + '.pem');
}
var serverCert = loadPEM('agent2-cert');
-function runClient (options, cb) {
+function runClient(options, cb) {
// Client can connect in three ways:
// - Self-signed cert
var args = ['s_client', '-connect', '127.0.0.1:' + common.PORT];
- console.log(" connecting with", options.name);
+ console.log(' connecting with', options.name);
switch (options.name) {
case 'agent1':
break;
default:
- throw new Error("Unknown agent name");
+ throw new Error('Unknown agent name');
}
// To test use: openssl s_client -connect localhost:8000
out += d;
if (/_unauthed/g.test(out)) {
- console.error(" * unauthed");
+ console.error(' * unauthed');
client.stdin.end('goodbye\n');
authed = false;
rejected = false;
}
if (/_authed/g.test(out)) {
- console.error(" * authed");
+ console.error(' * authed');
client.stdin.end('goodbye\n');
authed = true;
rejected = false;
// ": s_client exited with error code " + code);
if (options.shouldReject) {
assert.equal(true, rejected, options.name +
- " NOT rejected, but should have been");
+ ' NOT rejected, but should have been');
} else {
assert.equal(false, rejected, options.name +
- " rejected, but should NOT have been");
+ ' rejected, but should NOT have been');
assert.equal(options.shouldAuth, authed);
}
// Run the tests
var successfulTests = 0;
-function runTest (testIndex) {
+function runTest(testIndex) {
var tcase = testCases[testIndex];
if (!tcase) return;
var connections = 0;
- var server = tls.Server(serverOptions, function (c) {
+ var server = tls.Server(serverOptions, function(c) {
connections++;
if (c.authorized) {
console.error('- authed connection: ' +
function runNextClient(clientIndex) {
var options = tcase.clients[clientIndex];
if (options) {
- runClient(options, function () {
+ runClient(options, function() {
runNextClient(clientIndex + 1);
});
} else {
server.listen(common.PORT, function() {
if (tcase.debug) {
- console.error("TLS server running on port " + common.PORT);
+ console.error('TLS server running on port ' + common.PORT);
} else {
runNextClient(0);
}
};
var connections = 0;
-var message = "hello world\n";
+var message = 'hello world\n';
var server = tls.Server(options, function(socket) {
if (!process.features.tls_sni) {
- console.error("Skipping because node compiled without OpenSSL or " +
- "with old OpenSSL version.");
+ console.error('Skipping because node compiled without OpenSSL or ' +
+ 'with old OpenSSL version.');
process.exit(0);
}
tls = require('tls');
function filenamePEM(n) {
- return require('path').join(common.fixturesDir, 'keys', n + ".pem");
+ return require('path').join(common.fixturesDir, 'keys', n + '.pem');
}
function loadPEM(n) {
});
});
});
-};
+}
process.on('exit', function() {
assert.deepEqual(serverResults, ['a.example.com', 'b.test.com',
var isTTY = process.binding('tty_wrap').isTTY;
if (isTTY(1) == false) {
- console.error("fd 1 is not a tty. skipping test.");
+ console.error('fd 1 is not a tty. skipping test.');
process.exit(0);
}
var handle = new TTY(1);
var callbacks = 0;
-var req1 = handle.write(Buffer("hello world\n"));
+var req1 = handle.write(Buffer('hello world\n'));
req1.oncomplete = function() {
callbacks++;
};
-var req2 = handle.write(Buffer("hello world\n"));
+var req2 = handle.write(Buffer('hello world\n'));
req2.oncomplete = function() {
callbacks++;
};
assert.equal(orig, after);
// test for sparse array
-var a = [ 'foo', 'bar', 'baz' ];
+var a = ['foo', 'bar', 'baz'];
assert.equal(util.inspect(a), "[ 'foo', 'bar', 'baz' ]");
delete a[1];
assert.equal(util.inspect(a), "[ 'foo', , 'baz' ]");
}
var ex = util.inspect(new Error('FAIL'), true);
console.log(ex);
-assert.ok(ex.indexOf("[Error: FAIL]") != -1);
-assert.ok(ex.indexOf("[stack]") != -1);
-assert.ok(ex.indexOf("[message]") != -1);
-assert.ok(ex.indexOf("[arguments]") != -1);
-assert.ok(ex.indexOf("[type]") != -1);
+assert.ok(ex.indexOf('[Error: FAIL]') != -1);
+assert.ok(ex.indexOf('[stack]') != -1);
+assert.ok(ex.indexOf('[message]') != -1);
+assert.ok(ex.indexOf('[arguments]') != -1);
+assert.ok(ex.indexOf('[type]') != -1);
sbx.test = 123;
-assert.equal(sbx.window.window.window.window.window.test, 123);
\ No newline at end of file
+assert.equal(sbx.window.window.window.window.window.test, 123);
+
ASSERT.equal(0xef, buffer[14]);
ASSERT.equal(0x7f, buffer[15]);
- buffer.writeDoubleBE(0*-1, 0);
- buffer.writeDoubleLE(0*-1, 8);
+ buffer.writeDoubleBE(0 * -1, 0);
+ buffer.writeDoubleLE(0 * -1, 8);
ASSERT.equal(0x80, buffer[0]);
ASSERT.equal(0x00, buffer[1]);
ASSERT.equal(0x00, buffer[2]);
ASSERT.equal(0x00, buffer[6]);
ASSERT.equal(0x00, buffer[7]);
- buffer.writeFloatBE(1/3, 0);
- buffer.writeFloatLE(1/3, 4);
+ buffer.writeFloatBE(1 / 3, 0);
+ buffer.writeFloatLE(1 / 3, 4);
ASSERT.equal(0x3e, buffer[0]);
ASSERT.equal(0xaa, buffer[1]);
ASSERT.equal(0xaa, buffer[2]);
ASSERT.equal(0x7f, buffer[6]);
ASSERT.equal(0x7f, buffer[7]);
- buffer.writeFloatBE(0*-1, 0);
- buffer.writeFloatLE(0*-1, 4);
+ buffer.writeFloatBE(0 * -1, 0);
+ buffer.writeFloatLE(0 * -1, 4);
ASSERT.equal(0x80, buffer[0]);
ASSERT.equal(0x00, buffer[1]);
ASSERT.equal(0x00, buffer[2]);
var path = require('path');
var zlibPairs =
- [ [zlib.Deflate, zlib.Inflate],
- [zlib.Gzip, zlib.Gunzip],
- [zlib.Deflate, zlib.Unzip],
- [zlib.Gzip, zlib.Unzip],
- [zlib.DeflateRaw, zlib.InflateRaw ] ];
+ [[zlib.Deflate, zlib.Inflate],
+ [zlib.Gzip, zlib.Gunzip],
+ [zlib.Deflate, zlib.Unzip],
+ [zlib.Gzip, zlib.Unzip],
+ [zlib.DeflateRaw, zlib.InflateRaw]];
// how fast to trickle through the slowstream
var trickle = [128, 1024, 1024 * 1024];
var fs = require('fs');
-var testFiles = [ 'person.jpg', 'elipses.txt', 'empty.txt' ];
+var testFiles = ['person.jpg', 'elipses.txt', 'empty.txt'];
if (process.env.FAST) {
- zlibPairs = [ [zlib.Gzip, zlib.Unzip] ];
- var testFiles = [ 'person.jpg' ];
+ zlibPairs = [[zlib.Gzip, zlib.Unzip]];
+ var testFiles = ['person.jpg'];
}
-var tests = {}
+var tests = {};
testFiles.forEach(function(file) {
tests[file] = fs.readFileSync(path.resolve(common.fixturesDir, file));
});
self.emit('data', c);
process.nextTick(emit);
}
-}
+};
SlowStream.prototype.end = function(chunk) {
// walk over the chunk in blocks.
Object.keys(tests).forEach(function(file) {
var test = tests[file];
chunkSize.forEach(function(chunkSize) {
- trickle.forEach(function(trickle) {
- windowBits.forEach(function(windowBits) {
- level.forEach(function(level) {
- memLevel.forEach(function(memLevel) {
- strategy.forEach(function(strategy) {
- zlibPairs.forEach(function(pair) {
- var Def = pair[0];
- var Inf = pair[1];
- var opts = { level: level,
- windowBits: windowBits,
- memLevel: memLevel,
- strategy: strategy };
-
- total ++;
-
- var def = new Def(opts);
- var inf = new Inf(opts);
- var ss = new SlowStream(trickle);
- var buf = new BufferStream();
-
- // verify that the same exact buffer comes out the other end.
- buf.on('data', function(c) {
- var msg = file + ' ' +
- chunkSize + ' ' +
- JSON.stringify(opts) + ' ' +
- Def.name + ' -> ' + Inf.name;
- var ok = true;
- var testNum = ++done;
- for (var i = 0; i < Math.max(c.length, test.length); i++) {
- if (c[i] !== test[i]) {
- ok = false;
- failures ++;
- break;
- }
- }
- if (ok) {
- console.log('ok ' + (testNum) + ' ' + msg);
- } else {
- console.log('not ok ' + (testNum) + ' ' + msg);
- console.log(' ...');
- console.log(' testfile: ' + file);
- console.log(' type: ' + Def.name + ' -> ' + Inf.name);
- console.log(' position: ' + i);
- console.log(' options: ' + JSON.stringify(opts));
- console.log(' expect: ' + test[i]);
- console.log(' actual: ' + c[i]);
- console.log(' chunkSize: ' + chunkSize);
- console.log(' ---');
- }
- });
-
- // the magic happens here.
- ss.pipe(def).pipe(inf).pipe(buf);
- ss.end(test);
- });
- }); }); }); }); }); }); // sad stallman is sad.
+ trickle.forEach(function(trickle) {
+ windowBits.forEach(function(windowBits) {
+ level.forEach(function(level) {
+ memLevel.forEach(function(memLevel) {
+ strategy.forEach(function(strategy) {
+ zlibPairs.forEach(function(pair) {
+ var Def = pair[0];
+ var Inf = pair[1];
+ var opts = { level: level,
+ windowBits: windowBits,
+ memLevel: memLevel,
+ strategy: strategy };
+
+ total++;
+
+ var def = new Def(opts);
+ var inf = new Inf(opts);
+ var ss = new SlowStream(trickle);
+ var buf = new BufferStream();
+
+ // verify that the same exact buffer comes out the other end.
+ buf.on('data', function(c) {
+ var msg = file + ' ' +
+ chunkSize + ' ' +
+ JSON.stringify(opts) + ' ' +
+ Def.name + ' -> ' + Inf.name;
+ var ok = true;
+ var testNum = ++done;
+ for (var i = 0; i < Math.max(c.length, test.length); i++) {
+ if (c[i] !== test[i]) {
+ ok = false;
+ failures++;
+ break;
+ }
+ }
+ if (ok) {
+ console.log('ok ' + (testNum) + ' ' + msg);
+ } else {
+ console.log('not ok ' + (testNum) + ' ' + msg);
+ console.log(' ...');
+ console.log(' testfile: ' + file);
+ console.log(' type: ' + Def.name + ' -> ' + Inf.name);
+ console.log(' position: ' + i);
+ console.log(' options: ' + JSON.stringify(opts));
+ console.log(' expect: ' + test[i]);
+ console.log(' actual: ' + c[i]);
+ console.log(' chunkSize: ' + chunkSize);
+ console.log(' ---');
+ }
+ });
+
+ // the magic happens here.
+ ss.pipe(def).pipe(inf).pipe(buf);
+ ss.end(test);
+ });
+ }); }); }); }); }); }); // sad stallman is sad.
});
process.on('exit', function(code) {
projects / platform / upstream / nodejs.git / commitdiff