Remove all remaining unused variables from tests in test/parallel.
PR-URL: https://github.com/nodejs/node/pull/4511
Reviewed-By: James M Snell<jasnell@gmail.com>
Reviewed-By: Johan Bergström <bugs@bergstroem.nu>
'use strict';
-const common = require('../common');
+require('../common');
const assert = require('assert');
const a = require('assert');
require('../common');
const assert = require('assert');
const Buffer = require('buffer').Buffer;
-const Bp = Buffer.prototype;
function FakeBuffer() { }
FakeBuffer.__proto__ = Buffer;
});
// no encoding (Buffers expected)
-var child = exec('echo ' + str, {
+exec('echo ' + str, {
encoding: null
}, function(err, stdout, stderr) {
assert.ok(stdout instanceof Buffer, 'Expected stdout to be a Buffer');
res.writeHead(200);
res.end('OK');
}).listen(common.PIPE, function() {
- var self = this;
http.get({ socketPath: common.PIPE, path: '/' }, function(res) {
res.resume();
res.on('end', function(err) {
var path = require('path');
// Test Certificates
-var caPem = fs.readFileSync(common.fixturesDir + '/test_ca.pem', 'ascii');
var certPem = fs.readFileSync(common.fixturesDir + '/test_cert.pem', 'ascii');
var certPfx = fs.readFileSync(common.fixturesDir + '/test_cert.pfx');
var keyPem = fs.readFileSync(common.fixturesDir + '/test_key.pem', 'ascii');
var key3 = ecdh3.generateKeys();
assert.throws(function() {
- var secret3 = ecdh2.computeSecret(key3, 'binary', 'buffer');
+ ecdh2.computeSecret(key3, 'binary', 'buffer');
});
// ECDH should allow .setPrivateKey()/.setPublicKey()
var child = spawn(process.execPath, args, options);
var outputLines = [];
-var outputTimerId;
var waitingForDebuggers = false;
var pids = null;
// IPv6 Test
var socket_ipv6 = dgram.createSocket('udp6');
-var family_ipv6 = 'IPv6';
socket_ipv6.on('listening', common.fail);
var callbacks = 0;
var N = 500;
var count = 0;
- var sent_final_ping = false;
var server = dgram.createSocket('udp4', function(msg, rinfo) {
if (debug) console.log('server got: ' + msg +
if (count < N) {
client.send(buf, 0, buf.length, port, 'localhost');
} else {
- sent_final_ping = true;
client.send(buf, 0, buf.length, port, 'localhost', function() {
client.close();
});
var serverCaught = 0;
var clientCaught = 0;
-var disposeEmit = 0;
var server = http.createServer(function(req, res) {
var dom = domain.create();
var expectCaught = 1;
var d = new domain.Domain();
-var e = new events.EventEmitter();
d.on('error', function(er) {
console.error('caught', er);
const domain = require('domain');
const child_process = require('child_process');
-const uncaughtExceptions = {};
-
const tests = [];
function test1() {
if (process.argv[2] === 'child') {
var domain = require('domain');
var d = domain.create();
- var triggeredProcessUncaughtException = false;
process.on('uncaughtException', function onUncaughtException() {
// The process' uncaughtException event must not be emitted when
var child = exec(cmdToExec);
if (child) {
- var childTriggeredOnUncaughtExceptionHandler = false;
- child.on('message', function onChildMsg(msg) {
- if (msg === 'triggeredProcessUncaughtEx') {
- childTriggeredOnUncaughtExceptionHandler = true;
- }
- });
-
child.on('exit', function onChildExited(exitCode, signal) {
// When throwing errors from the top-level domain error handler
// outside of a try/catch block, the process should not exit gracefully
var input = 'hello';
-var dsapub = fs.readFileSync(common.fixturesDir +
- '/keys/dsa_public_1025.pem');
var dsapri = fs.readFileSync(common.fixturesDir +
'/keys/dsa_private_1025.pem');
var sign = crypto.createSign('DSS1');
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) {
+exec(cmd, function(err, stdout, stderr) {
if (err) {
console.log(err.toString());
++error_count;
count++;
}
-function listener3() {
- console.log('listener3');
- count++;
-}
-
function remove1() {
assert(0);
}
function run_test_3() {
- var file, buffer, options;
+ var file, options;
var data = '\u2026\u2026', // 3 bytes * 2 = 6 bytes in UTF-8
fileData;
function run_test_4() {
- var file, options;
+ var options;
options = { start: -5,
flags: 'r+' };
var O_APPEND = constants.O_APPEND || 0;
var O_CREAT = constants.O_CREAT || 0;
-var O_DIRECTORY = constants.O_DIRECTORY || 0;
var O_EXCL = constants.O_EXCL || 0;
-var O_NOCTTY = constants.O_NOCTTY || 0;
-var O_NOFOLLOW = constants.O_NOFOLLOW || 0;
var O_RDONLY = constants.O_RDONLY || 0;
var O_RDWR = constants.O_RDWR || 0;
-var O_SYMLINK = constants.O_SYMLINK || 0;
-var O_SYNC = constants.O_SYNC || 0;
var O_TRUNC = constants.O_TRUNC || 0;
var O_WRONLY = constants.O_WRONLY || 0;
'use strict';
require('../common');
-var constants = require('constants');
var assert = require('assert');
var fs = require('fs');
// would be even better though (node doesn't have such functionality yet)
function runTest(atime, mtime, callback) {
- var fd, err;
+ var fd;
//
// test synchronized code paths, these functions throw on failure
//
fs.closeSync = closeSync;
// Reset the umask for testing
-var mask = process.umask(0o000);
+process.umask(0o000);
// On Windows chmod is only able to manipulate read-only bit. Test if creating
// the file in read-only mode works.
});
// https://github.com/nodejs/node/issues/1691
-var originalCwd = process.cwd();
process.chdir(path.join(__dirname, '../fixtures/'));
child_process.exec(nodeBinary + ' '
+ '--expose_debug_as=v8debug '
'use strict';
-const common = require('../common');
+require('../common');
const assert = require('assert');
const versionParts = process.versions.node.split('.');
asyncTest('Test params of unhandledRejection for a synchronously-rejected' +
'promise', function(done) {
var e = new Error();
- var e2 = new Error();
onUnhandledSucceed(done, function(reason, promise) {
assert.strictEqual(e, reason);
assert.strictEqual(promise, promise);
});
- var promise = Promise.reject(e);
+ Promise.reject(e);
});
asyncTest('When re-throwing new errors in a promise catch, only the ' +
assert.strictEqual(domainReceivedError, domainError);
d.dispose();
});
- var a = Promise.reject(e);
+ Promise.reject(e);
process.nextTick(function() {
throw domainError;
});
const iStream = new PassThrough();
const oStream = new PassThrough();
-const rli = readline.createInterface({
+readline.createInterface({
terminal: true,
input: iStream,
output: oStream,
'use strict';
require('../common');
process.domain = null;
-var timer = setTimeout(function() {
+setTimeout(function() {
console.log('this console.log statement should not make node crash');
}, 1);
'use strict';
var assert = require('assert');
-var util = require('util');
var join = require('path').join;
var fs = require('fs');
var common = require('../common');
common.globalCheck = false;
const putIn = new common.ArrayStream();
-var testMe = repl.start('', putIn, null, true);
+repl.start('', putIn, null, true);
test1();
'use strict';
var common = require('../common');
-var util = require('util');
var repl = require('repl');
const putIn = new common.ArrayStream();
const assert = require('assert');
const path = require('path');
const repl = require('repl');
-const util = require('util');
let found = false;
process.on('exit', () => {
};
const putIn = new common.ArrayStream();
-const testMe = repl.start('', putIn);
+repl.start('', putIn);
let file = path.resolve(__dirname, '../fixtures/syntax/bad_syntax');
if (common.isWindows)
const common = require('../common');
const assert = require('assert');
-const util = require('util');
const repl = require('repl');
var referenceErrorCount = 0;
var common = require('../common');
var assert = require('assert');
-var util = require('util');
var repl = require('repl');
var referenceErrors = 0;
var expectedReferenceErrors = 0;
})();
(function testErrorWithRemovedListenerThrows() {
- var EE = require('events').EventEmitter;
var R = Stream.Readable;
var W = Stream.Writable;
})();
(function testErrorWithRemovedListenerThrows() {
- var EE = require('events').EventEmitter;
var R = Stream.Readable;
var W = Stream.Writable;
}
};
-var v = s.read(0);
+s.read(0);
// ACTUALLY [1, 3, 5, 6, 4, 2]
var hwm = 10;
var r = stream.Readable({ highWaterMark: hwm });
var chunks = 10;
-var t = (chunks * 5);
var data = new Buffer(chunks * hwm + Math.ceil(hwm / 2));
for (var i = 0; i < data.length; i++) {
function cnt(msg) {
expectCount++;
var expect = expectCount;
- var called = false;
return function(er) {
if (er)
throw er;
- called = true;
counter++;
assert.equal(counter, expect);
};
var assert = require('assert');
var util = require('util');
-var EE = require('events').EventEmitter;
var ondataCalled = 0;
this._buffer = new Buffer(0);
};
-var reader = new TestReader();
+new TestReader();
setImmediate(function() {
assert.equal(ondataCalled, 1);
console.log('ok');
setTimeout(push);
}
-// start the flow
-var ret = r.read(0);
-
process.on('exit', function() {
assert.equal(pushes, PUSHCOUNT + 1);
assert(endEmitted);
r.push('foobar');
r.push(null);
- var v = r.read(0);
-
r.pipe(toArray(function(array) {
assert.deepEqual(array, ['foobar']);
test('buffers', function(t) {
- // have a length
- var len = 16;
var list = [ new Buffer('foog'),
new Buffer('bark'),
new Buffer('bazy'),
});
test('strings', function(t) {
- // have a length
- var len = 16;
var list = [ 'foog',
'bark',
'bazy',
var pt = new PassThrough();
var emits = 0;
pt.on('readable', function() {
- var state = pt._readableState;
console.error('>>> emit readable %d', emits);
emits++;
});
- var i = 0;
-
pt.write(new Buffer('foog'));
console.error('need emit 0');
var assert = require('assert');
var Timer = process.binding('timer_wrap').Timer;
-var i;
-
var N = 30;
var last_i = 0;
var last_ts = 0;
-var start = Timer.now();
var f = function(i) {
if (i <= N) {
var ncalled = 0;
setTimeout(f, 0, 'foo', 'bar', 'baz');
- var timer = setTimeout(function() {}, 0);
+ setTimeout(function() {}, 0);
function f(a, b, c) {
assert.equal(a, 'foo');
//if format and parse are inverse operations then
//resolveObject(parse(x), y) == parse(resolve(x, y))
-//host and hostname are special, in this case a '' value is important
-var emptyIsImportant = {'host': true, 'hostname': ''};
-
//format: [from, path, expected]
relativeTests.forEach(function(relativeTest) {
var actual = url.resolveObject(url.parse(relativeTest[0]), relativeTest[1]),
// Flags: --expose_internals
'use strict';
-const common = require('../common');
+require('../common');
const assert = require('assert');
const internalUtil = require('internal/util');
'use strict';
// Flags: --expose_internals
-const common = require('../common');
+require('../common');
const assert = require('assert');
const internalUtil = require('internal/util');
projects / platform / upstream / nodejs.git / commitdiff