errors += 1;
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(2, successes);
assert.equal(0, errors);
});
assert.equal(child.stdout, null);
assert.notEqual(child.stderr, null);
- child.addListener('exit', function(err) {
+ child.on('exit', function(err) {
if (err) throw err;
fs.close(fd, function(error) {
if (error) throw error;
assert.equal(child.stdin, null);
var actualData = '';
- child.stdout.addListener('data', function(data) {
+ child.stdout.on('data', function(data) {
actualData += data.toString();
});
- child.addListener('exit', function(code) {
+ child.on('exit', function(code) {
if (err) throw err;
assert.equal(actualData, 'hella warld\n');
console.log(' File was filtered successfully');
var filter = spawn(process.argv[0], [fixtPath('stdio-filter.js'), 'o', 'a']);
var echo = spawn('/bin/echo', [expected], {customFds: [-1, filter.fds[0]]});
var actualData = '';
- filter.stdout.addListener('data', function(data) {
+ filter.stdout.on('data', function(data) {
console.log(' Got data --> ' + data);
actualData += data;
});
- filter.addListener('exit', function(code) {
+ filter.on('exit', function(code) {
if (code) throw 'Return code was ' + code;
assert.equal(actualData, 'hella warld\n');
console.log(' Talked to another process successfully');
});
- echo.addListener('exit', function(code) {
+ echo.on('exit', function(code) {
if (code) throw 'Return code was ' + code;
filter.stdin.end();
fs.unlinkSync(helloPath);
var expected = 'xyz';
var server = net.createServer(function(socket) {
- socket.addListener('receive', function(data) {
+ socket.on('receive', function(data) {
found = data;
client.close();
socket.close();
server.listen(common.PORT);
var client = net.createConnection(common.PORT);
-client.addListener('connect', function() {
+client.on('connect', function() {
fs.open(x, 'r').addCallback(function(fd) {
fs.sendfile(client.fd, fd, 0, expected.length)
.addCallback(function(size) {
var count = 0;
- proxy_res.addListener('data', function(d) {
+ proxy_res.on('data', function(d) {
if (count++ % 1000 == 0) common.print('.');
res.write(d);
sent += d.length;
assert.ok(sent <= (len * chunk.length));
});
- proxy_res.addListener('end', function() {
+ proxy_res.on('end', function() {
res.end();
});
headers: {'x-len': len}
}, function(res) {
- res.addListener('data', function(d) {
+ res.on('data', function(d) {
recved += d.length;
assert.ok(recved <= (len * chunk.length));
});
- res.addListener('end', function() {
+ res.on('end', function() {
assert.ok(recved <= (len * chunk.length));
common.debug('end for ' + len + ' chunks.');
call_chargen(list);
call_chargen([100, 1000, 10000, 100000, 1000000]);
}
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(done);
});
var gotEnd = false;
-server.addListener('listening', function() {
+server.on('listening', function() {
var request = http.request({
port: common.PORT,
method: 'HEAD',
path: '/'
}, function(response) {
console.log('got response');
- response.addListener('data', function() {
+ response.on('data', function() {
process.exit(2);
});
- response.addListener('end', function() {
+ response.on('end', function() {
process.exit(0);
});
});
var requests_ok = 0;
var requests_complete = 0;
-server.addListener('listening', function() {
+server.on('listening', function() {
for (var i = 0; i < request_count; i++) {
http.cat('http://localhost:' + common.PORT + '/', 'utf8',
function(err, content) {
}
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(request_count, requests_complete);
assert.equal(request_count, requests_ok);
});
https_server.setSecure(credentials);
https_server.listen(common.PORT);
-https_server.addListener('listening', function() {
+https_server.on('listening', function() {
var c = net.createConnection(common.PORT);
c.setEncoding('utf8');
- c.addListener('connect', function() {
+ c.on('connect', function() {
c.setSecure(credentials);
});
- c.addListener('secure', function() {
+ c.on('secure', function() {
var verified = c.verifyPeer();
var peerDN = JSON.stringify(c.getPeerCertificate());
assert.equal(verified, true);
requests_sent += 1;
});
- c.addListener('data', function(chunk) {
+ c.on('data', function(chunk) {
server_response += chunk;
if (requests_sent == 1) {
});
- c.addListener('end', function() {
+ c.on('end', function() {
client_got_eof = true;
});
- c.addListener('close', function() {
+ c.on('close', function() {
assert.equal(c.readyState, 'closed');
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(4, request_number);
assert.equal(4, requests_sent);
idle.setPriority(process.EVMAXPRI);
idle.start();
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(complete);
});
var initializeSender = function() {
var fdHighway = new net.Socket();
- fdHighway.addListener('connect', function() {
+ fdHighway.on('connect', function() {
var sender = net.createServer(function(socket) {
fdHighway.sendFD(socket);
socket.flush();
socket.forceClose(); // want to close() the fd, not shutdown()
});
- sender.addListener('listening', function() {
+ sender.on('listening', function() {
var client = net.createConnection(port);
- client.addListener('connect', function() {
+ client.on('connect', function() {
client.write(message);
});
- client.addListener('data', function(data) {
+ client.on('data', function(data) {
assert.equal(expectedData[0], data);
if (expectedData.length > 1) {
expectedData.shift();
};
- receiver.addListener('output', function(data) {
+ receiver.on('output', function(data) {
var initialized = false;
if ((! initialized) && (data == 'ready')) {
initializeSender();
fdPassingTest('/tmp/passing-socket-test', 31075);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, tests_run);
});
socket.setNoDelay();
socket.timeout = 0;
- socket.addListener('data', function(data) {
+ socket.on('data', function(data) {
var verified = socket.verifyPeer();
var peerDN = socket.getPeerCertificate('DNstring');
assert.equal(verified, 1);
}
});
- socket.addListener('end', function() {
+ socket.on('end', function() {
assert.equal('writeOnly', socket.readyState);
socket.end();
});
- socket.addListener('close', function(had_error) {
+ socket.on('close', function(had_error) {
assert.equal(false, had_error);
assert.equal('closed', socket.readyState);
socket.server.close();
client.setEncoding('utf8');
client.setSecure('X509_PEM', caPem, 0, keyPem, caPem);
- client.addListener('connect', function() {
+ client.on('connect', function() {
assert.equal('open', client.readyState);
var verified = client.verifyPeer();
var peerDN = client.getPeerCertificate('DNstring');
client.write('PING');
});
- client.addListener('data', function(data) {
+ client.on('data', function(data) {
assert.equal('PONG', data);
count += 1;
}
});
- client.addListener('close', function() {
+ client.on('close', function() {
assert.equal(N + 1, count);
assert.equal(true, sent_final_ping);
tests_run += 1;
tlsTest(common.PORT, 'localhost', caPem, keyPem, certPem);
tlsTest(common.PORT + 1, null, caPem, keyPem, certPem);
- process.addListener('exit', function() {
+ process.on('exit', function() {
assert.equal(2, tests_run);
});
} else {
connection.setSecure(credentials);
connection.setEncoding('UTF8');
- connection.addListener('secure', function() {
+ connection.on('secure', function() {
gotSecureServer = true;
var verified = connection.verifyPeer();
var peerDN = JSON.stringify(connection.getPeerCertificate());
});
- connection.addListener('data', function(chunk) {
+ connection.on('data', function(chunk) {
serverData += chunk;
connection.write(chunk);
});
- connection.addListener('end', function() {
+ connection.on('end', function() {
assert.equal(serverData, testData);
connection.end();
self.close();
});
secureServer.listen(common.PORT);
-secureServer.addListener('listening', function() {
+secureServer.on('listening', function() {
var secureClient = net.createConnection(common.PORT);
secureClient.setEncoding('UTF8');
- secureClient.addListener('connect', function() {
+ secureClient.on('connect', function() {
secureClient.setSecure(credentials);
});
- secureClient.addListener('secure', function() {
+ secureClient.on('secure', function() {
gotSecureClient = true;
var verified = secureClient.verifyPeer();
var peerDN = JSON.stringify(secureClient.getPeerCertificate());
secureClient.end();
});
- secureClient.addListener('data', function(chunk) {
+ secureClient.on('data', function(chunk) {
clientData += chunk;
});
- secureClient.addListener('end', function() {
+ secureClient.on('end', function() {
assert.equal(clientData, testData);
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(gotSecureServer, 'Did not get secure event for server');
assert.ok(gotSecureClient, 'Did not get secure event for client');
});
var buf = '';
ps = spawn('ps');
ps.stdout.setEncoding('utf8');
- ps.stdout.addListener('data', function(s) { buf += s; });
- ps.addListener('exit', function(c) {
+ ps.stdout.on('data', function(s) { buf += s; });
+ ps.on('exit', function(c) {
try {
assert.equal(0, c);
assert.ok(new RegExp(process.pid + ' ', 'm').test(buf));
server.close();
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, modulesLoaded);
});
var seenOrdinals = [];
var pipeReadStream = new net.Stream();
-pipeReadStream.addListener('data', function(data) {
+pipeReadStream.on('data', function(data) {
data.toString('utf8').trim().split('\n').forEach(function(d) {
var rd = JSON.parse(d);
if (s.write(buf, pipeFDs[1])) {
netBinding.close(pipeFDs[1]);
} else {
- s.addListener('drain', function() {
+ s.on('drain', function() {
netBinding.close(pipeFDs[1]);
});
}
[path.join(common.fixturesDir, 'recvfd.js'),
SOCK_PATH]);
-cp.stdout.addListener('data', logChild);
-cp.stderr.addListener('data', logChild);
+cp.stdout.on('data', logChild);
+cp.stderr.on('data', logChild);
// When the child exits, clean up and validate its exit status
var cpp = cp.pid;
-cp.addListener('exit', function(code, signal) {
+cp.on('exit', function(code, signal) {
srv.close();
// fs.unlinkSync(SOCK_PATH);
}
client.setEncoding('UTF8');
-client.addListener('connect', function() {
+client.on('connect', function() {
console.log('client connected.');
client.setSecure(credentials);
});
-client.addListener('secure', function() {
+client.on('secure', function() {
console.log('client secure : ' + JSON.stringify(client.getCipher()));
console.log(JSON.stringify(client.getPeerCertificate()));
console.log('verifyPeer : ' + client.verifyPeer());
client.write('GET / HTTP/1.0\r\n\r\n');
});
-client.addListener('data', function(chunk) {
+client.on('data', function(chunk) {
common.error(chunk);
});
-client.addListener('end', function() {
+client.on('end', function() {
console.log('client disconnected.');
});
connection.setSecure(credentials);
connection.setEncoding('binary');
- connection.addListener('secure', function() {
+ connection.on('secure', function() {
//console.log('Secure');
});
- connection.addListener('data', function(chunk) {
+ connection.on('data', function(chunk) {
console.log('recved: ' + JSON.stringify(chunk));
connection.write('HTTP/1.0 200 OK\r\n' +
'Content-type: text/plain\r\n' +
connection.end();
});
- connection.addListener('end', function() {
+ connection.on('end', function() {
connection.end();
});
exports.number = 42;
-process.addListener('exit', function() {
+process.on('exit', function() {
string = 'A done';
});
return d.D();
};
-process.addListener('exit', function() {
+process.on('exit', function() {
string = 'C done';
console.log('b/c.js exit');
});
return string;
};
-process.addListener('exit', function() {
+process.on('exit', function() {
string = 'D done';
});
var stdin = process.openStdin();
-stdin.addListener('data', function(data) {
+stdin.on('data', function(data) {
process.stdout.write(data.toString());
});
-stdin.addListener('end', function() {
+stdin.on('end', function() {
process.stdout.end();
});
greeting = process.ARGV[3];
receiver = net.createServer(function(socket) {
- socket.addListener('fd', function(fd) {
+ socket.on('fd', function(fd) {
var peerInfo = process.getpeername(fd);
peerInfo.fd = fd;
var passedSocket = new net.Socket(peerInfo);
- passedSocket.addListener('eof', function() {
+ passedSocket.on('eof', function() {
passedSocket.close();
});
- passedSocket.addListener('data', function(data) {
+ passedSocket.on('data', function(data) {
passedSocket.send('[echo] ' + data);
});
- passedSocket.addListener('close', function() {
+ passedSocket.on('close', function() {
receiver.close();
});
passedSocket.send('[greeting] ' + greeting);
});
/* To signal the test runne we're up and listening */
-receiver.addListener('listening', function() {
+receiver.on('listening', function() {
common.print('ready');
});
}
};
- pipeStream.addListener('drain', drainFunc);
+ pipeStream.on('drain', drainFunc);
pipeStream.resume();
if (pipeStream.write(JSON.stringify(d) + '\n')) {
// Create a UNIX socket to the path defined by argv[2] and read a file
// descriptor and misc data from it.
var s = new net.Stream();
-s.addListener('fd', function(fd) {
+s.on('fd', function(fd) {
receivedFDs.unshift(fd);
processData(s);
});
-s.addListener('data', function(data) {
+s.on('data', function(data) {
data.toString('utf8').trim().split('\n').forEach(function(d) {
receivedData.unshift(JSON.parse(d));
});
// USE OR OTHER DEALINGS IN THE SOFTWARE.
function tmp() {}
-process.addListener('SIGINT', tmp);
+process.on('SIGINT', tmp);
process.removeListener('SIGINT', tmp);
setInterval(function() {
process.stdout.write('keep alive\n');
var re = new RegExp(regexIn, 'g');
var stdin = process.openStdin();
-stdin.addListener('data', function(data) {
+stdin.on('data', function(data) {
data = data.toString();
process.stdout.write(data.replace(re, replacement));
});
var count = 0;
child.stdout.setEncoding('ascii');
- child.stdout.addListener('data', function(chunk) {
+ child.stdout.on('data', function(chunk) {
count += chunk.length;
});
- child.stderr.addListener('data', function(chunk) {
+ child.stderr.on('data', function(chunk) {
console.log('stderr: ' + chunk);
});
- child.addListener('exit', function() {
+ child.on('exit', function() {
assert.equal(SIZE + 1, count); // + 1 for \n
if (i < N) {
doSpawn(i + 1);
doSpawn(0);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(finished);
});
assert.ok(/maxBuffer/.test(err.message));
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, success_count);
assert.equal(1, error_count);
});
var filepathTwoAbs = path.join(testDir, filenameTwo);
-process.addListener('exit', function() {
+process.on('exit', function() {
fs.unlinkSync(filepathOne);
fs.unlinkSync(filepathTwoAbs);
assert.equal(1, watchSeenOne);
server.on('listening', function() {
var client = http.createClient(common.PORT);
- client.addListener('error', function(err) {
+ client.on('error', function(err) {
// We should receive one error
console.log('ERROR! ' + err.message);
errorCount++;
});
- client.addListener('end', function() {
+ client.on('end', function() {
// When we remove the old Client interface this will most likely have to be
// changed.
console.log('EOF!');
var request = client.request('GET', '/', {'host': 'localhost'});
request.end();
- request.addListener('response', function(response) {
+ request.on('response', function(response) {
console.log('STATUS: ' + response.statusCode);
});
});
}, 500);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, errorCount);
assert.equal(1, eofCount);
});
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(true, normalReqSec > 50);
assert.equal(true, keepAliveReqSec > 50);
assert.equal(true, normalReqSec < keepAliveReqSec);
}
var server = net.createServer(function(c) {
- c.addListener('connect', function() {
+ c.on('connect', function() {
total_connections++;
common.print('#');
c.write(body);
client.setEncoding('utf8');
- client.addListener('connect', function() {
+ client.on('connect', function() {
common.print('c');
client.recved = '';
client.connections += 1;
});
- client.addListener('data', function(chunk) {
+ client.on('data', function(chunk) {
this.recved += chunk;
});
- client.addListener('end', function() {
+ client.on('end', function() {
client.end();
});
- client.addListener('error', function(e) {
+ client.on('error', function(e) {
console.log('\n\nERROOOOOr');
throw e;
});
- client.addListener('close', function(had_error) {
+ client.on('close', function(had_error) {
common.print('.');
assert.equal(false, had_error);
assert.equal(bytes, client.recved.length);
}
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(connections_per_client * concurrency, total_connections);
console.log('\nokay!');
});
server.on('listening', function() {
var client = net.createConnection(common.PORT);
client.setEncoding('ascii');
- client.addListener('data', function(d) {
+ client.on('data', function(d) {
common.print(d);
recv += d;
});
}, 500);
- client.addListener('end', function() {
+ client.on('end', function() {
server.close();
client.end();
});
});
server.listen(common.PORT);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(N, recv.length);
common.debug('Exit');
});
var server = net.createServer({ allowHalfOpen: true }, function(socket) {
socket.setEncoding('utf8');
- socket.addListener('data', function(data) {
+ socket.on('data', function(data) {
console.log(data);
assert.equal('PING', data);
assert.equal('open', socket.readyState);
}, DELAY);
});
- socket.addListener('timeout', function() {
+ socket.on('timeout', function() {
common.debug('server-side timeout!!');
assert.equal(false, true);
});
- socket.addListener('end', function() {
+ socket.on('end', function() {
console.log('server-side socket EOF');
assert.equal('writeOnly', socket.readyState);
socket.end();
});
- socket.addListener('close', function(had_error) {
+ socket.on('close', function(had_error) {
console.log('server-side socket.end');
assert.equal(false, had_error);
assert.equal('closed', socket.readyState);
client.setEncoding('utf8');
- client.addListener('connect', function() {
+ client.on('connect', function() {
assert.equal('open', client.readyState);
client.write('PING');
});
- client.addListener('data', function(data) {
+ client.on('data', function(data) {
console.log(data);
assert.equal('PONG', data);
assert.equal('open', client.readyState);
}, DELAY);
});
- client.addListener('timeout', function() {
+ client.on('timeout', function() {
common.debug('client-side timeout!!');
assert.equal(false, true);
});
- client.addListener('close', function() {
+ client.on('close', function() {
console.log('client.end');
assert.equal(N + 1, count);
assert.ok(client_ended);
pingPongTest(common.PORT);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, tests_run);
});
socket.setNoDelay();
socket.timeout = 0;
- socket.addListener('data', function(data) {
+ socket.on('data', function(data) {
console.log('server got: ' + JSON.stringify(data));
assert.equal('open', socket.readyState);
assert.equal(true, count <= N);
}
});
- socket.addListener('end', function() {
+ socket.on('end', function() {
assert.equal('writeOnly', socket.readyState);
socket.end();
});
- socket.addListener('close', function(had_error) {
+ socket.on('close', function(had_error) {
assert.equal(false, had_error);
assert.equal('closed', socket.readyState);
socket.server.close();
client.setEncoding('utf8');
- client.addListener('connect', function() {
+ client.on('connect', function() {
assert.equal('open', client.readyState);
client.write('PING');
});
- client.addListener('data', function(data) {
+ client.on('data', function(data) {
console.log('client got: ' + data);
assert.equal('PONG', data);
}
});
- client.addListener('close', function() {
+ client.on('close', function() {
assert.equal(N + 1, count);
assert.equal(true, sent_final_ping);
if (on_complete) on_complete();
var solaris = /sunos/i.test(process.platform);
if (!solaris) pingPongTest(common.PORT + 2, '::1');
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(solaris ? 2 : 3, tests_run);
});
console.log('start server on port ' + common.PORT);
var server = net.createServer(function(connection) {
- connection.addListener('connect', function() {
+ connection.on('connect', function() {
assert.equal(false, connection.write(body));
console.log('bufferSize: ' + connection.bufferSize);
assert.ok(0 <= connection.bufferSize &&
var paused = false;
var client = net.createConnection(common.PORT);
client.setEncoding('ascii');
- client.addListener('data', function(d) {
+ client.on('data', function(d) {
chars_recved += d.length;
console.log('got ' + chars_recved);
if (!paused) {
}
});
- client.addListener('end', function() {
+ client.on('end', function() {
server.close();
client.end();
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(N, chars_recved);
assert.equal(true, npauses > 2);
});
var echo_server = net.createServer(function(socket) {
socket.setTimeout(timeout);
- socket.addListener('timeout', function() {
+ socket.on('timeout', function() {
console.log('server timeout');
timeouttime = new Date;
console.dir(timeouttime);
socket.destroy();
});
- socket.addListener('error', function(e) {
+ socket.on('error', function(e) {
throw new Error('Server side socket should not get error. ' +
'We disconnect willingly.');
});
- socket.addListener('data', function(d) {
+ socket.on('data', function(d) {
console.log(d);
socket.write(d);
});
- socket.addListener('end', function() {
+ socket.on('end', function() {
socket.end();
});
});
var client = net.createConnection(common.PORT);
client.setEncoding('UTF8');
client.setTimeout(0); // disable the timeout for client
- client.addListener('connect', function() {
+ client.on('connect', function() {
console.log('client connected.');
client.write('hello\r\n');
});
- client.addListener('data', function(chunk) {
+ client.on('data', function(chunk) {
assert.equal('hello\r\n', chunk);
if (exchanges++ < 5) {
setTimeout(function() {
}
});
- client.addListener('timeout', function() {
+ client.on('timeout', function() {
throw new Error("client timeout - this shouldn't happen");
});
- client.addListener('end', function() {
+ client.on('end', function() {
console.log('client end');
client.end();
});
- client.addListener('close', function() {
+ client.on('close', function() {
console.log('client disconnect');
echo_server.close();
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(starttime != null);
assert.ok(timeouttime != null);
clearTimeout(y);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(true, setTimeout_called);
assert.equal(3, interval_count);
assert.equal(11, count4);
fs.writeSync(fd, 'xyz\n');
fs.closeSync(fd);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(changes > 0);
});
var child = common.spawnPwd();
child.stdout.setEncoding('utf8');
- child.stdout.addListener('data', function(s) {
+ child.stdout.on('data', function(s) {
console.log('stdout: ' + JSON.stringify(s));
output += s;
});
- child.addListener('exit', function(c) {
+ child.on('exit', function(c) {
console.log('exit: ' + c);
assert.equal(0, c);
callback(output);
assert.equal('\n', result[result.length - 1]);
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(true, pwd_called);
});
child.stdout.setEncoding('utf8');
- child.stdout.addListener('data', function(chunk) {
+ child.stdout.on('data', function(chunk) {
data += chunk;
});
- child.addListener('exit', function(code, signal) {
+ child.on('exit', function(code, signal) {
forData && assert.strictEqual(forData, data.replace(/[\s\r\n]+$/, ''));
assert.strictEqual(forCode, code);
returns--;
// Check whether all tests actually returned
assert.notEqual(0, returns);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(0, returns);
});
child.stdout.setEncoding('utf8');
-child.stdout.addListener('data', function(chunk) {
+child.stdout.on('data', function(chunk) {
console.log('stdout: ' + chunk);
response += chunk;
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(response.indexOf('HELLO=WORLD') >= 0);
assert.ok(response.indexOf('FOO=BAR') >= 0);
});
}
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, success_count);
assert.equal(0, error_count);
});
}
child.stdout.setEncoding('utf8');
-child.stdout.addListener('data', function(chunk) {
+child.stdout.on('data', function(chunk) {
response += chunk;
});
-process.addListener('exit', function() {
+process.on('exit', function() {
console.log('response: ', response);
assert.equal(1, success_count);
assert.equal(0, error_count);
var exitScript = path.join(common.fixturesDir, 'exit.js');
var exitChild = spawn(process.argv[0], [exitScript, 23]);
-exitChild.addListener('exit', function(code, signal) {
+exitChild.on('exit', function(code, signal) {
assert.strictEqual(code, 23);
assert.strictEqual(signal, null);
var errorScript = path.join(common.fixturesDir,
'child_process_should_emit_error.js');
var errorChild = spawn(process.argv[0], [errorScript]);
-errorChild.addListener('exit', function(code, signal) {
+errorChild.on('exit', function(code, signal) {
assert.ok(code !== 0);
assert.strictEqual(signal, null);
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(2, exits);
});
var child = spawn(process.argv[0], [sub]);
-child.stderr.addListener('data', function(data) {
+child.stderr.on('data', function(data) {
console.log('parent stderr: ' + data);
});
child.stdout.setEncoding('utf8');
-child.stdout.addListener('data', function(data) {
+child.stdout.on('data', function(data) {
console.log('child said: ' + JSON.stringify(data));
if (!gotHelloWorld) {
assert.equal('hello world\r\n', data);
}
});
-child.stdout.addListener('end', function(data) {
+child.stdout.on('end', function(data) {
console.log('child end');
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(gotHelloWorld);
assert.ok(gotEcho);
});
var cat = spawn('cat');
-cat.stdout.addListener('data', function(chunk) {
+cat.stdout.on('data', function(chunk) {
assert.ok(false);
});
-cat.stdout.addListener('end', function() {
+cat.stdout.on('end', function() {
gotStdoutEOF = true;
});
-cat.stderr.addListener('data', function(chunk) {
+cat.stderr.on('data', function(chunk) {
assert.ok(false);
});
-cat.stderr.addListener('end', function() {
+cat.stderr.on('end', function() {
gotStderrEOF = true;
});
-cat.addListener('exit', function(code, signal) {
+cat.on('exit', function(code, signal) {
exitCode = code;
termSignal = signal;
});
cat.kill();
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.strictEqual(exitCode, null);
assert.strictEqual(termSignal, 'SIGTERM');
assert.ok(gotStdoutEOF);
var gotStdoutEOF = false;
cat.stdout.setEncoding('utf8');
-cat.stdout.addListener('data', function(chunk) {
+cat.stdout.on('data', function(chunk) {
console.log('stdout: ' + chunk);
response += chunk;
});
-cat.stdout.addListener('end', function() {
+cat.stdout.on('end', function() {
gotStdoutEOF = true;
});
var gotStderrEOF = false;
-cat.stderr.addListener('data', function(chunk) {
+cat.stderr.on('data', function(chunk) {
// shouldn't get any stderr output
assert.ok(false);
});
-cat.stderr.addListener('end', function(chunk) {
+cat.stderr.on('end', function(chunk) {
gotStderrEOF = true;
});
-cat.addListener('exit', function(status) {
+cat.on('exit', function(status) {
console.log('exit event');
exitStatus = status;
assert.equal('hello world', response);
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(0, exitStatus);
assert.equal('hello world', response);
});
var count = 0;
child.stderr.setEncoding('utf8');
-child.stderr.addListener('data', function(data) {
+child.stderr.on('data', function(data) {
console.log('parent stderr: ' + data);
assert.ok(false);
});
child.stderr.setEncoding('utf8');
-child.stdout.addListener('data', function(data) {
+child.stdout.on('data', function(data) {
count += data.length;
console.log(count);
});
-child.addListener('exit', function(data) {
+child.on('exit', function(data) {
assert.equal(n, count);
console.log('okay');
});
var fn = path.join(common.fixturesDir, 'sample.png');
var sha1Hash = crypto.createHash('sha1');
var fileStream = fs.createReadStream(fn);
-fileStream.addListener('data', function(data) {
+fileStream.on('data', function(data) {
sha1Hash.update(data);
});
-fileStream.addListener('close', function() {
+fileStream.on('close', function() {
assert.equal(sha1Hash.digest('hex'),
'22723e553129a336ad96e10f6aecdf0f45e4149e',
'Test SHA1 of sample.png');
a = require('../fixtures/a');
}, 50);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(true, 'A' in a);
assert.equal('A', a.A());
assert.equal('D', a.D());
var buf = new Buffer('PING'),
client = dgram.createSocket('udp4');
- client.addListener('message', function(msg, rinfo) {
+ client.on('message', function(msg, rinfo) {
console.log('client got: ' + msg +
' from ' + rinfo.address + ':' + rinfo.port);
assert.equal('PONG', msg.toString('ascii'));
pingPongTest(20988);
//pingPongTest('/tmp/pingpong.sock');
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(3, tests_run);
console.log('done');
});
tryToKillEventLoop();
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(pos > 10000);
});
});
}
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(N, j);
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(3, exits);
});
++success_count;
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, success_count);
assert.equal(0, error_count);
});
var events_new_listener_emited = [];
var times_hello_emited = 0;
-e.addListener('newListener', function(event, listener) {
+e.on('newListener', function(event, listener) {
console.log('newListener: ' + event);
events_new_listener_emited.push(event);
});
f.setMaxListeners(0);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.deepEqual(['hello'], events_new_listener_emited);
assert.equal(1, times_hello_emited);
});
function callback1() {
callbacks_called.push('callback1');
- e.addListener('foo', callback2);
- e.addListener('foo', callback3);
+ e.on('foo', callback2);
+ e.on('foo', callback3);
e.removeListener('foo', callback1);
}
e.removeListener('foo', callback3);
}
-e.addListener('foo', callback1);
+e.on('foo', callback1);
assert.equal(1, e.listeners('foo').length);
e.emit('foo');
assert.equal(0, e.listeners('foo').length);
assert.deepEqual(['callback1', 'callback2', 'callback3'], callbacks_called);
-e.addListener('foo', callback1);
-e.addListener('foo', callback2);
+e.on('foo', callback1);
+e.on('foo', callback2);
assert.equal(2, e.listeners('foo').length);
e.removeAllListeners('foo');
assert.equal(0, e.listeners('foo').length);
// all listeners
callbacks_called = [];
-e.addListener('foo', callback2);
-e.addListener('foo', callback3);
+e.on('foo', callback2);
+e.on('foo', callback3);
assert.equal(2, e.listeners('foo').length);
e.emit('foo');
assert.deepEqual(['callback2', 'callback3'], callbacks_called);
e.emit('numArgs', null, null, null, null);
e.emit('numArgs', null, null, null, null, null);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.deepEqual([0, 1, 2, 3, 4, 5], num_args_emited);
});
e.removeListener('foo', remove);
e.emit('foo');
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, times_hello_emited);
});
function listener() {}
var e1 = new events.EventEmitter();
-e1.addListener('foo', listener);
-e1.addListener('bar', listener);
+e1.on('foo', listener);
+e1.on('bar', listener);
e1.removeAllListeners('foo');
assert.deepEqual([], e1.listeners('foo'));
assert.deepEqual([listener], e1.listeners('bar'));
var e2 = new events.EventEmitter();
-e2.addListener('foo', listener);
-e2.addListener('bar', listener);
+e2.on('foo', listener);
+e2.on('bar', listener);
e2.removeAllListeners();
console.error(e2);
assert.deepEqual([], e2.listeners('foo'));
}
var e1 = new events.EventEmitter();
-e1.addListener('hello', listener1);
+e1.on('hello', listener1);
e1.removeListener('hello', listener1);
assert.deepEqual([], e1.listeners('hello'));
var e2 = new events.EventEmitter();
-e2.addListener('hello', listener1);
+e2.on('hello', listener1);
e2.removeListener('hello', listener2);
assert.deepEqual([listener1], e2.listeners('hello'));
var e3 = new events.EventEmitter();
-e3.addListener('hello', listener1);
-e3.addListener('hello', listener2);
+e3.on('hello', listener1);
+e3.on('hello', listener2);
e3.removeListener('hello', listener1);
assert.deepEqual([listener2], e3.listeners('hello'));
var MESSAGE = 'catch me if you can';
var caughtException = false;
-process.addListener('uncaughtException', function(e) {
+process.on('uncaughtException', function(e) {
console.log('uncaught exception! 1');
assert.equal(MESSAGE, e.message);
caughtException = true;
});
-process.addListener('uncaughtException', function(e) {
+process.on('uncaughtException', function(e) {
console.log('uncaught exception! 2');
assert.equal(MESSAGE, e.message);
caughtException = true;
throw new Error(MESSAGE);
}, 10);
-process.addListener('exit', function() {
+process.on('exit', function() {
console.log('exit');
assert.equal(true, caughtException);
});
}
});
-process.addListener('exit', function() {
+process.on('exit', function() {
console.log('done');
assert.equal(true, got_error);
});
};
file
- .addListener('open', function(fd) {
+ .on('open', function(fd) {
callbacks.open++;
assert.equal('number', typeof fd);
})
- .addListener('error', function(err) {
+ .on('error', function(err) {
throw err;
})
- .addListener('drain', function() {
+ .on('drain', function() {
callbacks.drain++;
if (callbacks.drain == -1) {
assert.equal(EXPECTED, fs.readFileSync(fn));
});
}
})
- .addListener('close', function() {
+ .on('close', function() {
assert.strictEqual(file.bytesWritten, EXPECTED.length * 2);
callbacks.close++;
})(i);
}
-process.addListener('exit', function() {
+process.on('exit', function() {
for (var k in callbacks) {
assert.equal(0, callbacks[k], k + ' count off by ' + callbacks[k]);
}
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(2, success_count);
assert.equal(false, got_error);
});
assert.ok(0 <= err.message.indexOf(fn));
}
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(expected, errors.length,
'Test fs sync exceptions raised, got ' + errors.length +
' expected ' + expected);
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(4, successes);
});
openFd = fd;
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(openFd);
});
assert.deepEqual(bufferSync, new Buffer(expected));
assert.equal(r, expected.length);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(readCalled, 1);
});
var file = fs.ReadStream(fn);
-file.addListener('open', function(fd) {
+file.on('open', function(fd) {
file.length = 0;
callbacks.open++;
assert.equal('number', typeof fd);
file.resume();
});
-file.addListener('data', function(data) {
+file.on('data', function(data) {
assert.ok(data instanceof Buffer);
assert.ok(!paused);
file.length += data.length;
});
-file.addListener('end', function(chunk) {
+file.on('end', function(chunk) {
callbacks.end++;
});
-file.addListener('close', function() {
+file.on('close', function() {
callbacks.close++;
assert.ok(!file.readable);
var file3 = fs.createReadStream(fn, {encoding: 'utf8'});
file3.length = 0;
-file3.addListener('data', function(data) {
+file3.on('data', function(data) {
assert.equal('string', typeof(data));
file3.length += data.length;
}
});
-file3.addListener('close', function() {
+file3.on('close', function() {
callbacks.close++;
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, callbacks.open);
assert.equal(1, callbacks.end);
assert.equal(1, callbacks.destroy);
var file4 = fs.createReadStream(rangeFile, {bufferSize: 1, start: 1, end: 2});
var contentRead = '';
-file4.addListener('data', function(data) {
+file4.on('data', function(data) {
contentRead += data.toString('utf-8');
});
-file4.addListener('end', function(data) {
+file4.on('end', function(data) {
assert.equal(contentRead, 'yz');
});
var file5 = fs.createReadStream(rangeFile, {bufferSize: 1, start: 1});
file5.data = '';
-file5.addListener('data', function(data) {
+file5.on('data', function(data) {
file5.data += data.toString('utf-8');
});
-file5.addListener('end', function() {
+file5.on('end', function() {
assert.equal(file5.data, 'yz\n');
});
assert.equal(r[0], expected);
assert.equal(r[1], expected.length);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(readCalled, 1);
});
-process.addListener('exit', function() {
+process.on('exit', function() {
unlink.forEach(function(path) { try {fs.unlinkSync(path);} catch (e) {} });
assert.equal(async_completed, async_expected);
});
}
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(5, success_count);
assert.equal(false, got_error);
});
completed++;
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(completed, 2);
});
var filepathThree = path.join(testsubdir, filenameThree);
-process.addListener('exit', function() {
+process.on('exit', function() {
fs.unlinkSync(filepathOne);
fs.unlinkSync(filepathTwoAbs);
fs.unlinkSync(filepathThree);
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, openCalled);
assert.equal(1, writeCalled);
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
common.error('done');
assert.equal(6, ncallbacks);
(function() {
var stream = fs.createWriteStream(file);
- stream.addListener('drain', function() {
+ stream.on('drain', function() {
assert.fail('\'drain\' event must not be emitted before ' +
'stream.write() has been called at least once.');
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(expected, found);
assert.equal(expected, found2);
});
server.listen(common.PORT, function() {
var c = net.createConnection(common.PORT);
- c.addListener('connect', function() {
+ c.on('connect', function() {
common.error('client wrote message');
c.write('GET /blah HTTP/1.1\r\n' +
'Host: mapdevel.trolologames.ru:443\r\n' +
);
});
- c.addListener('end', function() {
+ c.on('end', function() {
c.end();
});
- c.addListener('close', function() {
+ c.on('close', function() {
common.error('client close');
server.close();
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(gotReq);
});
console.log('connection');
- c.addListener('end', function() { c.end(); });
+ c.on('end', function() { c.end(); });
});
var parseError = false;
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(parseError);
});
var body2 = '';
var body3 = '';
-server.addListener('listening', function() {
+server.on('listening', function() {
var client = http.createClient(common.PORT);
//
//
var req1 = client.request('/1');
req1.end();
- req1.addListener('response', function(res1) {
+ req1.on('response', function(res1) {
res1.setEncoding('utf8');
- res1.addListener('data', function(chunk) {
+ res1.on('data', function(chunk) {
body1 += chunk;
});
- res1.addListener('end', function() {
+ res1.on('end', function() {
//
// Delay execution a little to allow the 'close' event to be processed
// (required to trigger this bug!)
//
var req2 = client.request('/2');
req2.end();
- req2.addListener('response', function(res2) {
+ req2.on('response', function(res2) {
res2.setEncoding('utf8');
- res2.addListener('data', function(chunk) { body2 += chunk; });
- res2.addListener('end', function() {
+ res2.on('data', function(chunk) { body2 += chunk; });
+ res2.on('end', function() {
//
// Just to be really sure we've covered all our bases, execute a
//
var req3 = client2.request('/3');
req3.end();
- req3.addListener('response', function(res3) {
+ req3.on('response', function(res3) {
res3.setEncoding('utf8');
- res3.addListener('data', function(chunk) { body3 += chunk });
- res3.addListener('end', function() { server.close(); });
+ res3.on('data', function(chunk) { body3 += chunk });
+ res3.on('end', function() { server.close(); });
});
});
});
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(body1_s, body1);
assert.equal(body2_s, body2);
assert.equal(body3_s, body3);
var body1 = '';
var body2 = '';
-server.addListener('listening', function() {
+server.on('listening', function() {
var req1 = http.request({ port: common.PORT, path: '/1' });
req1.end();
- req1.addListener('response', function(res1) {
+ req1.on('response', function(res1) {
res1.setEncoding('utf8');
- res1.addListener('data', function(chunk) {
+ res1.on('data', function(chunk) {
body1 += chunk;
});
- res1.addListener('end', function() {
+ res1.on('end', function() {
var req2 = http.request({ port: common.PORT, path: '/2' });
req2.end();
- req2.addListener('response', function(res2) {
+ req2.on('response', function(res2) {
res2.setEncoding('utf8');
- res2.addListener('data', function(chunk) { body2 += chunk; });
- res2.addListener('end', function() { server.close(); });
+ res2.on('data', function(chunk) { body2 += chunk; });
+ res2.on('end', function() { server.close(); });
});
});
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(body1_s, body1);
assert.equal(body2_s, body2);
});
var server = http.createServer(function(req, res) {
assert.equal('POST', req.method);
- req.addListener('data', function(chunk) {
+ req.on('data', function(chunk) {
bytesRecieved += chunk.length;
});
- req.addListener('end', function() {
+ req.on('end', function() {
server_req_complete = true;
console.log('request complete from server');
res.writeHead(200, {'Content-Type': 'text/plain'});
});
server.listen(common.PORT);
-server.addListener('listening', function() {
+server.on('listening', function() {
var req = http.request({
port: common.PORT,
method: 'POST',
path: '/'
}, function(res) {
res.setEncoding('utf8');
- res.addListener('data', function(chunk) {
+ res.on('data', function(chunk) {
console.log(chunk);
});
- res.addListener('end', function() {
+ res.on('end', function() {
client_res_complete = true;
server.close();
});
common.error('client finished sending request');
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(N, bytesRecieved);
assert.equal(true, server_req_complete);
assert.equal(true, client_res_complete);
assert.equal('POST', req.method);
req.setEncoding('utf8');
- req.addListener('data', function(chunk) {
+ req.on('data', function(chunk) {
console.log('server got: ' + JSON.stringify(chunk));
sent_body += chunk;
});
- req.addListener('end', function() {
+ req.on('end', function() {
server_req_complete = true;
console.log('request complete from server');
res.writeHead(200, {'Content-Type': 'text/plain'});
});
server.listen(common.PORT);
-server.addListener('listening', function() {
+server.on('listening', function() {
var req = http.request({
port: common.PORT,
method: 'POST',
path: '/'
}, function(res) {
res.setEncoding('utf8');
- res.addListener('data', function(chunk) {
+ res.on('data', function(chunk) {
console.log(chunk);
});
- res.addListener('end', function() {
+ res.on('end', function() {
client_res_complete = true;
server.close();
});
common.error('client finished sending request');
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal('1\n2\n3\n', sent_body);
assert.equal(true, server_req_complete);
assert.equal(true, client_res_complete);
var server = http.createServer(function(req, res) {});
server.listen(common.PORT);
-server.addListener('listening', function() {
- net.createConnection(common.PORT).addListener('connect', function() {
+server.on('listening', function() {
+ net.createConnection(common.PORT).on('connect', function() {
this.destroy();
- }).addListener('close', function() {
+ }).on('close', function() {
server.close();
});
});
var exception_count = 0;
-process.addListener('uncaughtException', function(err) {
+process.on('uncaughtException', function(err) {
console.log('Caught an exception: ' + err);
if (err.name === 'AssertionError') throw err;
if (++exception_count == 4) process.exit(0);
}
var server = http.createServer(handler);
-server.addListener('checkContinue', function(req, res) {
+server.on('checkContinue', function(req, res) {
common.debug('Server got Expect: 100-continue...');
res.writeContinue();
sent_continue = true;
-server.addListener('listening', function() {
+server.on('listening', function() {
var req = http.request({
port: common.PORT,
method: 'POST',
common.debug('Client sending request...');
outstanding_reqs++;
var body = '';
- req.addListener('continue', function() {
+ req.on('continue', function() {
common.debug('Client got 100 Continue...');
got_continue = true;
req.end(test_req_body);
});
- req.addListener('response', function(res) {
+ req.on('response', function(res) {
assert.equal(got_continue, true,
'Full response received before 100 Continue');
assert.equal(200, res.statusCode,
'Final status code was ' + res.statusCode + ', not 200.');
res.setEncoding('utf8');
- res.addListener('data', function(chunk) { body += chunk; });
- res.addListener('end', function() {
+ res.on('data', function(chunk) { body += chunk; });
+ res.on('end', function() {
common.debug('Got full response.');
assert.equal(body, test_res_body, 'Response body doesn\'t match.');
assert.ok('abcd' in res.headers, 'Response headers missing.');
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(3, runs);
});
path: '/'
}, function(response) {
common.error('response start');
- response.addListener('end', function() {
+ response.on('end', function() {
common.error('response end');
gotEnd = true;
});
request.end();
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(gotEnd);
});
var responseComplete = false;
-server.addListener('listening', function() {
+server.on('listening', function() {
var req = http.request({
port: common.PORT,
method: 'HEAD',
path: '/'
}, function(res) {
common.error('response');
- res.addListener('end', function() {
+ res.on('end', function() {
common.error('response end');
server.close();
responseComplete = true;
req.end();
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(responseComplete);
});
var responseComplete = false;
-server.addListener('listening', function() {
+server.on('listening', function() {
var req = http.request({
port: common.PORT,
method: 'HEAD',
path: '/'
}, function(res) {
common.error('response');
- res.addListener('end', function() {
+ res.on('end', function() {
common.error('response end');
server.close();
responseComplete = true;
req.end();
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(responseComplete);
});
port: common.PORT,
agent: agent
}, function(response) {
- response.addListener('end', function() {
+ response.on('end', function() {
assert.equal(1, agent.sockets['localhost:' + common.PORT].length);
server.close();
});
request.end();
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(3, connectCount);
});
});
request.end();
request = http.request({method: 'GET', path: '/', headers: headers, port: common.PORT, agent: agent}, function(response) {
- response.addListener('end', function() {
+ response.on('end', function() {
assert.equal(1, agent.sockets['localhost:' + common.PORT].length);
server.close();
});
});
server.listen(common.PORT);
-server.addListener('listening', function() {
+server.on('listening', function() {
var c = net.createConnection(common.PORT);
- c.addListener('connect', function() {
+ c.on('connect', function() {
c.write('GET /hello?foo=%99bar HTTP/1.1\r\n\r\n');
c.end();
});
// TODO add more!
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(nrequests_expected, nrequests_completed);
});
res.writeHead(proxy_res.statusCode, proxy_res.headers);
- proxy_res.addListener('data', function(chunk) {
+ proxy_res.on('data', function(chunk) {
res.write(chunk);
});
- proxy_res.addListener('end', function() {
+ proxy_res.on('end', function() {
res.end();
common.debug('proxy res');
});
assert.deepEqual(cookies, res.headers['set-cookie']);
res.setEncoding('utf8');
- res.addListener('data', function(chunk) { body += chunk; });
- res.addListener('end', function() {
+ res.on('data', function(chunk) { body += chunk; });
+ res.on('end', function() {
proxy.close();
backend.close();
common.debug('closed both');
common.debug('listen backend');
backend.listen(BACKEND_PORT, startReq);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(body, 'hello world\n');
});
});
server.listen(common.PORT);
-server.addListener('listening', function() {
+server.on('listening', function() {
console.error('make req');
http.get({
port: common.PORT
server.httpAllowHalfOpen = true;
-server.addListener('listening', function() {
+server.on('listening', function() {
var c = net.createConnection(common.PORT);
c.setEncoding('utf8');
- c.addListener('connect', function() {
+ c.on('connect', function() {
c.write('GET /hello?hello=world&foo=b==ar HTTP/1.1\r\n\r\n');
requests_sent += 1;
});
- c.addListener('data', function(chunk) {
+ c.on('data', function(chunk) {
server_response += chunk;
if (requests_sent == 1) {
});
- c.addListener('end', function() {
+ c.on('end', function() {
client_got_eof = true;
});
- c.addListener('close', function() {
+ c.on('close', function() {
assert.equal(c.readyState, 'closed');
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(4, request_number);
assert.equal(4, requests_sent);
});
server.listen(common.PORT);
-server.addListener('listening', function() {
+server.on('listening', function() {
//
// one set-cookie header
//
assert.deepEqual(['A'], res.headers['set-cookie']);
assert.equal('text/plain', res.headers['content-type']);
- res.addListener('data', function(chunk) {
+ res.on('data', function(chunk) {
console.log(chunk.toString());
});
- res.addListener('end', function() {
+ res.on('end', function() {
if (++nresponses == 2) {
server.close();
}
assert.deepEqual(['A', 'B'], res.headers['set-cookie']);
assert.equal('text/plain', res.headers['content-type']);
- res.addListener('data', function(chunk) {
+ res.on('data', function(chunk) {
console.log(chunk.toString());
});
- res.addListener('end', function() {
+ res.on('end', function() {
if (++nresponses == 2) {
server.close();
}
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(2, nresponses);
});
console.log('got request. setting 1 second timeout');
req.connection.setTimeout(500);
- req.connection.addListener('timeout', function() {
+ req.connection.on('timeout', function() {
req.connection.destroy();
common.debug('TIMEOUT');
server.close();
// first, we test an HTTP/1.0 request.
-server.addListener('listening', function() {
+server.on('listening', function() {
var c = net.createConnection(common.PORT);
var res_buffer = '';
c.setEncoding('utf8');
- c.addListener('connect', function() {
+ c.on('connect', function() {
outstanding_reqs++;
c.write('GET / HTTP/1.0\r\n\r\n');
});
- c.addListener('data', function(chunk) {
+ c.on('data', function(chunk) {
//console.log(chunk);
res_buffer += chunk;
});
- c.addListener('end', function() {
+ c.on('end', function() {
c.end();
assert.ok(! /x-foo/.test(res_buffer), 'Trailer in HTTP/1.0 response.');
outstanding_reqs--;
});
// now, we test an HTTP/1.1 request.
-server.addListener('listening', function() {
+server.on('listening', function() {
var c = net.createConnection(common.PORT);
var res_buffer = '';
var tid;
c.setEncoding('utf8');
- c.addListener('connect', function() {
+ c.on('connect', function() {
outstanding_reqs++;
c.write('GET / HTTP/1.1\r\n\r\n');
tid = setTimeout(assert.fail, 2000, 'Couldn\'t find last chunk.');
});
- c.addListener('data', function(chunk) {
+ c.on('data', function(chunk) {
//console.log(chunk);
res_buffer += chunk;
if (/0\r\n/.test(res_buffer)) { // got the end.
});
// now, see if the client sees the trailers.
-server.addListener('listening', function() {
+server.on('listening', function() {
http.get({ port: common.PORT, path: '/hello', headers: {} }, function(res) {
- res.addListener('end', function() {
+ res.on('end', function() {
//console.log(res.trailers);
assert.ok('x-foo' in res.trailers, 'Client doesn\'t see trailers.');
outstanding_reqs--;
// Create a TCP server
var srv = net.createServer(function(c) {
var data = '';
- c.addListener('data', function(d) {
+ c.on('data', function(d) {
data += d.toString('utf8');
c.write('HTTP/1.1 101\r\n');
c.write('nurtzo');
});
- c.addListener('end', function() {
+ c.on('end', function() {
c.end();
});
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(gotUpgrade);
});
// Create a TCP server
var srv = net.createServer(function(c) {
var data = '';
- c.addListener('data', function(d) {
+ c.on('data', function(d) {
data += d.toString('utf8');
c.write('HTTP/1.1 101\r\n');
c.write('nurtzo');
});
- c.addListener('end', function() {
+ c.on('end', function() {
c.end();
});
});
srv.listen(common.PORT, '127.0.0.1', function() {
var req = http.get({ port: common.PORT });
- req.addListener('upgrade', function(res, socket, upgradeHead) {
+ req.on('upgrade', function(res, socket, upgradeHead) {
// XXX: This test isn't fantastic, as it assumes that the entire response
// from the server will arrive in a single data callback
assert.equal(upgradeHead, 'nurtzo');
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(gotUpgrade);
});
var server = this;
http.Server.call(server, function() {});
- server.addListener('connection', function() {
+ server.on('connection', function() {
requests_recv++;
});
- server.addListener('request', function(req, res) {
+ server.on('request', function(req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.write('okay');
res.end();
});
- server.addListener('upgrade', function(req, socket, upgradeHead) {
+ server.on('upgrade', function(req, socket, upgradeHead) {
socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
'Upgrade: WebSocket\r\n' +
'Connection: Upgrade\r\n' +
conn.setEncoding('utf8');
var state = 0;
- conn.addListener('connect', function() {
+ conn.on('connect', function() {
writeReq(conn,
'GET / HTTP/1.1\r\n' +
'Upgrade: WebSocket\r\n' +
'WjN}|M(6');
});
- conn.addListener('data', function(data) {
+ conn.on('data', function(data) {
state++;
assert.equal('string', typeof data);
}
});
- conn.addListener('end', function() {
+ conn.on('end', function() {
assert.equal(2, state);
conn.end();
_server.removeAllListeners('upgrade');
var conn = net.createConnection(common.PORT);
conn.setEncoding('utf8');
- conn.addListener('connect', function() {
+ conn.on('connect', function() {
writeReq(conn,
'GET / HTTP/1.1\r\n' +
'Upgrade: WebSocket\r\n' +
'\r\n');
});
- conn.addListener('end', function() {
+ conn.on('end', function() {
test_upgrade_no_listener_ended = true;
conn.end();
});
- conn.addListener('close', function() {
+ conn.on('close', function() {
test_standard_http();
});
}
var conn = net.createConnection(common.PORT);
conn.setEncoding('utf8');
- conn.addListener('connect', function() {
+ conn.on('connect', function() {
writeReq(conn, 'GET / HTTP/1.1\r\n\r\n');
});
- conn.addListener('data', function(data) {
+ conn.on('data', function(data) {
assert.equal('string', typeof data);
assert.equal('HTTP/1.1 200', data.substr(0, 12));
conn.end();
});
- conn.addListener('close', function() {
+ conn.on('close', function() {
server.close();
});
}
/*-----------------------------------------------
Fin.
-----------------------------------------------*/
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(3, requests_recv);
assert.equal(3, requests_sent);
assert.ok(test_upgrade_no_listener_ended);
throw new Error('This shouldn\'t happen.');
});
-server.addListener('upgrade', function(req, socket, upgradeHead) {
+server.on('upgrade', function(req, socket, upgradeHead) {
common.error('got upgrade event');
// test that throwing an error from upgrade gets
// is uncaught
var gotError = false;
-process.addListener('uncaughtException', function(e) {
+process.on('uncaughtException', function(e) {
common.error('got \'clientError\' event');
assert.equal('upgrade error', e.message);
gotError = true;
server.listen(common.PORT, function() {
var c = net.createConnection(common.PORT);
- c.addListener('connect', function() {
+ c.on('connect', function() {
common.error('client wrote message');
c.write('GET /blah HTTP/1.1\r\n' +
'Upgrade: WebSocket\r\n' +
'\r\n\r\nhello world');
});
- c.addListener('end', function() {
+ c.on('end', function() {
c.end();
});
- c.addListener('close', function() {
+ c.on('close', function() {
common.error('client close');
server.close();
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(gotError);
});
});
server.listen(common.PORT);
-server.addListener('listening', function() {
+server.on('listening', function() {
var c = net.createConnection(common.PORT);
c.setEncoding('utf8');
- c.addListener('connect', function() {
+ c.on('connect', function() {
c.write('GET / HTTP/1.0\r\n' +
'Connection: Keep-Alive\r\n\r\n');
});
- c.addListener('data', function(chunk) {
+ c.on('data', function(chunk) {
console.log(chunk);
server_response += chunk;
});
- c.addListener('end', function() {
+ c.on('end', function() {
client_got_eof = true;
console.log('got end');
c.end();
});
- c.addListener('close', function() {
+ c.on('close', function() {
connection_was_closed = true;
console.log('got close');
server.close();
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
var m = server_response.split('\r\n\r\n');
assert.equal(m[1], 'hello world\n');
assert.ok(client_got_eof);
var response = '';
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal('1\n2\n3\n', response);
});
http.get({ port: common.PORT }, function(res) {
assert.equal(200, res.statusCode);
res.setEncoding('ascii');
- res.addListener('data', function(chunk) {
+ res.on('data', function(chunk) {
response += chunk;
});
common.error('Got /hello response');
this.close();
}
- req.addListener('end', function() {
+ req.on('end', function() {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.write('The path was ' + url.parse(req.url).pathname);
res.end();
});
server.listen(common.PORT);
-server.addListener('listening', function() {
+server.on('listening', function() {
var agent = new http.Agent({ port: common.PORT, maxSockets: 1 });
http.get({
port: common.PORT,
assert.equal(200, res.statusCode);
responses_recvd += 1;
res.setEncoding('utf8');
- res.addListener('data', function(chunk) { body0 += chunk; });
+ res.on('data', function(chunk) { body0 += chunk; });
common.debug('Got /hello response');
});
assert.equal(200, res.statusCode);
responses_recvd += 1;
res.setEncoding('utf8');
- res.addListener('data', function(chunk) { body1 += chunk; });
+ res.on('data', function(chunk) { body1 += chunk; });
common.debug('Got /world response');
});
req.end();
}, 1);
});
-process.addListener('exit', function() {
+process.on('exit', function() {
common.debug('responses_recvd: ' + responses_recvd);
assert.equal(2, responses_recvd);
}
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(false, mkdir_error);
assert.equal(false, rmdir_error);
console.log('exit');
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(common.indirectInstanceOf(a.A, Function));
assert.equal('A done', a.A());
// safe constructor
var echoServer = net.Server(function(connection) {
connection.setEncoding('binary');
- connection.addListener('data', function(chunk) {
+ connection.on('data', function(chunk) {
common.error('recved: ' + JSON.stringify(chunk));
connection.write(chunk, 'binary');
});
- connection.addListener('end', function() {
+ connection.on('end', function() {
connection.end();
});
});
var recv = '';
-echoServer.addListener('listening', function() {
+echoServer.on('listening', function() {
var j = 0;
var c = net.createConnection(common.PORT);
c.setEncoding('binary');
- c.addListener('data', function(chunk) {
+ c.on('data', function(chunk) {
if (j < 256) {
common.error('write ' + j);
c.write(String.fromCharCode(j), 'binary');
recv += chunk;
});
- c.addListener('connect', function() {
+ c.on('connect', function() {
c.write(binaryString, 'binary');
});
- c.addListener('close', function() {
+ c.on('close', function() {
console.dir(recv);
echoServer.close();
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
console.log('recv: ' + JSON.stringify(recv));
assert.equal(2 * 256, recv.length);
var server2 = net.createServer(function(socket) {
});
server1.listen(common.PORT);
-server2.addListener('error', function(error) {
+server2.on('error', function(error) {
assert.equal(true, error.message.indexOf('EADDRINUSE') >= 0);
server1.close();
});
assert.notEqual(connection.setKeepAlive, undefined);
// send a keepalive packet after 1000 ms
connection.setKeepAlive(true, 1000);
- connection.addListener('end', function() {
+ connection.on('end', function() {
connection.end();
});
});
echoServer.listen(common.PORT);
-echoServer.addListener('listening', function() {
+echoServer.on('listening', function() {
var clientConnection = net.createConnection(common.PORT);
clientConnection.setTimeout(0);
socket.timeout = 0;
socket.setEncoding('utf8');
- socket.addListener('data', function(data) {
+ socket.on('data', function(data) {
// Since we never queue data (we're always waiting for the PING
// before sending a pong) the writeQueueSize should always be less
// than one message.
}
});
- socket.addListener('end', function() {
+ socket.on('end', function() {
assert.equal(true, socket.writable); // because allowHalfOpen
assert.equal(false, socket.readable);
socket.end();
});
- socket.addListener('error', function(e) {
+ socket.on('error', function(e) {
throw e;
});
- socket.addListener('close', function() {
+ socket.on('close', function() {
console.log('server socket.endd');
assert.equal(false, socket.writable);
assert.equal(false, socket.readable);
var client = net.createConnection(port, host);
client.setEncoding('ascii');
- client.addListener('connect', function() {
+ client.on('connect', function() {
assert.equal(true, client.readable);
assert.equal(true, client.writable);
client.write('PING');
});
- client.addListener('data', function(data) {
+ client.on('data', function(data) {
console.log('client got: ' + data);
assert.equal('PONG', data);
}
});
- client.addListener('close', function() {
+ client.on('close', function() {
console.log('client.end');
assert.equal(N + 1, count);
assert.equal(N + 1, sentPongs);
tests_run += 1;
});
- client.addListener('error', function(e) {
+ client.on('error', function(e) {
throw e;
});
});
pingPongTest(20989, 'localhost');
pingPongTest(20997, '::1');
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(4, tests_run);
console.log('done');
});
var disconnect_count = 0;
var server = net.createServer(function(socket) {
- socket.addListener('connect', function() {
+ socket.on('connect', function() {
socket.write('hello\r\n');
});
- socket.addListener('end', function() {
+ socket.on('end', function() {
socket.end();
});
- socket.addListener('close', function(had_error) {
+ socket.on('close', function(had_error) {
//console.log('server had_error: ' + JSON.stringify(had_error));
assert.equal(false, had_error);
});
client.setEncoding('UTF8');
- client.addListener('connect', function() {
+ client.on('connect', function() {
console.log('client connected.');
});
- client.addListener('data', function(chunk) {
+ client.on('data', function(chunk) {
client_recv_count += 1;
console.log('client_recv_count ' + client_recv_count);
assert.equal('hello\r\n', chunk);
client.end();
});
- client.addListener('close', function(had_error) {
+ client.on('close', function(had_error) {
console.log('disconnect');
assert.equal(false, had_error);
if (disconnect_count++ < N)
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(N + 1, disconnect_count);
assert.equal(N + 1, client_recv_count);
});
order.push('C');
});
-process.addListener('uncaughtException', function() {
+process.on('uncaughtException', function() {
if (!exceptionHandled) {
exceptionHandled = true;
order.push('B');
}
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.deepEqual(['A', 'B', 'C'], order);
});
console.log('Running from main.');
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal('nextTick', done[0]);
/* Disabling this test. I don't think we can ensure the order
for (i = 0; i < N; i += 1) {
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.deepEqual(order, ['nextTick', 'setTimeout']);
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(5, complete);
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(finished);
});
server.listen(common.PORT, function() {
var conn = net.createConnection(common.PORT);
conn.setEncoding('utf8');
- conn.addListener('data', function(chunk) {
+ conn.on('data', function(chunk) {
common.error('recv data! nchars = ' + chunk.length);
buffer += chunk;
});
- conn.addListener('end', function() {
+ conn.on('end', function() {
conn.end();
});
- conn.addListener('close', function() {
+ conn.on('close', function() {
common.error('client connection close');
conn_closed = true;
});
var buffer = '';
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(true, got_error);
assert.equal(true, conn_closed);
console.log('exiting');
server.listen(common.PORT, function() {
var conn = net.createConnection(common.PORT);
conn.setEncoding('utf8');
- conn.addListener('data', function(chunk) {
+ conn.on('data', function(chunk) {
common.error('recv data! nchars = ' + chunk.length);
buffer += chunk;
});
- conn.addListener('end', function() {
+ conn.on('end', function() {
conn.end();
});
- conn.addListener('close', function() {
+ conn.on('close', function() {
common.error('client connection close');
});
});
var buffer = '';
var count = 0;
-server.addListener('listening', function() {
+server.on('listening', function() {
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(expected, buffer);
});
}
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(false, got_error);
console.log('exit');
});
var read_buffer = '';
client_unix.removeAllListeners('data');
- client_unix.addListener('data', function(data) {
+ client_unix.on('data', function(data) {
read_buffer += data.toString('ascii', 0, data.length);
common.error('Unix data: ' + JSON.stringify(read_buffer) + ', expecting ' +
(client_unix.expect.exec ?
server_tcp = net.createServer(function(socket) {
assert.strictEqual(server_tcp, socket.server);
- socket.addListener('end', function() {
+ socket.on('end', function() {
socket.end();
});
client_tcp = net.createConnection(common.PORT);
- client_tcp.addListener('connect', function() {
+ client_tcp.on('connect', function() {
assert.equal(true, client_tcp.readable);
assert.equal(true, client_tcp.writable);
]);
});
- client_tcp.addListener('data', function(data) {
+ client_tcp.on('data', function(data) {
read_buffer += data.toString('ascii', 0, data.length);
common.error('TCP data: ' + JSON.stringify(read_buffer) +
', expecting ' + JSON.stringify(client_tcp.expect));
}
});
- client_tcp.addListener('error', function(e) {
+ client_tcp.on('error', function(e) {
throw e;
});
- client_tcp.addListener('close', function() {
+ client_tcp.on('close', function() {
server_tcp.close();
});
});
server_unix = net.createServer(function(socket) {
assert.strictEqual(server_unix, socket.server);
- socket.addListener('end', function() {
+ socket.on('end', function() {
socket.end();
});
repl.start(prompt_unix, socket).context.message = message;
});
- server_unix.addListener('listening', function() {
+ server_unix.on('listening', function() {
var read_buffer = '';
client_unix = net.createConnection(common.PIPE);
- client_unix.addListener('connect', function() {
+ client_unix.on('connect', function() {
assert.equal(true, client_unix.readable);
assert.equal(true, client_unix.writable);
]);
});
- client_unix.addListener('data', function(data) {
+ client_unix.on('data', function(data) {
read_buffer += data.toString('ascii', 0, data.length);
common.error('Unix data: ' + JSON.stringify(read_buffer) +
', expecting ' + JSON.stringify(client_unix.expect));
}
});
- client_unix.addListener('error', function(e) {
+ client_unix.on('error', function(e) {
throw e;
});
- client_unix.addListener('close', function() {
+ client_unix.on('close', function() {
server_unix.close();
});
});
var sighup = false;
-process.addListener('SIGUSR1', function() {
+process.on('SIGUSR1', function() {
console.log('Interrupted by SIGUSR1');
first += 1;
});
-process.addListener('SIGUSR1', function() {
+process.on('SIGUSR1', function() {
second += 1;
setTimeout(function() {
console.log('End.');
}
}, 1);
-// Test addListener condition where a watcher for SIGNAL
+// Test on condition where a watcher for SIGNAL
// has been previously registered, and `process.listeners(SIGNAL).length === 1`
-process.addListener('SIGHUP', function() {});
+process.on('SIGHUP', function() {});
process.removeAllListeners('SIGHUP');
-process.addListener('SIGHUP', function() { sighup = true });
+process.on('SIGHUP', function() { sighup = true });
process.kill(process.pid, 'SIGHUP');
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.equal(1, first);
assert.equal(1, second);
assert.equal(true, sighup);
var join = require('path').join;
child = spawn(process.argv[0], [join(common.fixturesDir, 'should_exit.js')]);
-child.addListener('exit', function() {
+child.on('exit', function() {
if (!done) childKilled = true;
});
}, 200);
}, 200);
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(childKilled);
});
});
});
-process.addListener('exit', function() {
+process.on('exit', function() {
assert.ok(finished);
});
projects / platform / upstream / nodejs.git / commitdiff