csrc/node-v0.10.24/test/simple/test-repl.js - third_party - Git at Google

 // Copyright Joyent, Inc. and other Node contributors.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
 // copy of this software and associated documentation files (the
 // "Software"), to deal in the Software without restriction, including
 // without limitation the rights to use, copy, modify, merge, publish,
 // distribute, sublicense, and/or sell copies of the Software, and to permit
 // persons to whom the Software is furnished to do so, subject to the
 // following conditions:
 //
 // The above copyright notice and this permission notice shall be included
 // in all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 // 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 assert = require('assert');

 common.globalCheck = false;

 var net = require('net'),
     repl = require('repl'),
     message = 'Read, Eval, Print Loop',
     prompt_unix = 'node via Unix socket> ',
     prompt_tcp = 'node via TCP socket> ',
     prompt_multiline = '... ',
     prompt_npm = 'npm should be run outside of the ' +
                  'node repl, in your normal shell.\n' +
                  '(Press Control-D to exit.)\n',
     expect_npm = prompt_npm + prompt_unix,
     server_tcp, server_unix, client_tcp, client_unix, timer;


 // absolute path to test/fixtures/a.js
 var moduleFilename = require('path').join(common.fixturesDir, 'a');

 common.error('repl test');

 // function for REPL to run
 invoke_me = function(arg) {
   return 'invoked ' + arg;
 };

 function send_expect(list) {
   if (list.length > 0) {
     var cur = list.shift();

     common.error('sending ' + JSON.stringify(cur.send));

     cur.client.expect = cur.expect;
     cur.client.list = list;
     if (cur.send.length > 0) {
       cur.client.write(cur.send + '\n');
     }
   }
 }

 function clean_up() {
   client_tcp.end();
   client_unix.end();
   clearTimeout(timer);
 }

 function error_test() {
   // The other stuff is done so reuse unix socket
   var read_buffer = '';
   client_unix.removeAllListeners('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 ?
                   client_unix.expect :
                   JSON.stringify(client_unix.expect)));

     if (read_buffer.indexOf(prompt_unix) !== -1) {
       // if it's an exact match, then don't do the regexp
       if (read_buffer !== client_unix.expect) {
         assert.ok(read_buffer.match(client_unix.expect));
         common.error('match');
       }
       read_buffer = '';
       if (client_unix.list && client_unix.list.length > 0) {
         send_expect(client_unix.list);
       } else {
         common.error('End of Error test, running TCP test.');
         tcp_test();
       }

     } else if (read_buffer.indexOf(prompt_multiline) !== -1) {
       // Check that you meant to send a multiline test
       assert.strictEqual(prompt_multiline, client_unix.expect);
       read_buffer = '';
       if (client_unix.list && client_unix.list.length > 0) {
         send_expect(client_unix.list);
       } else {
         common.error('End of Error test, running TCP test.\n');
         tcp_test();
       }

     } else {
       common.error('didn\'t see prompt yet, buffering.');
     }
   });

   send_expect([
     // Uncaught error throws and prints out
     { client: client_unix, send: 'throw new Error(\'test error\');',
       expect: /^Error: test error/ },
     // Common syntax error is treated as multiline command
     { client: client_unix, send: 'function test_func() {',
       expect: prompt_multiline },
     // You can recover with the .break command
     { client: client_unix, send: '.break',
       expect: prompt_unix },
     // Floating point numbers are not interpreted as REPL commands.
     { client: client_unix, send: '.1234',
       expect: '0.1234' },
     // Floating point expressions are not interpreted as REPL commands
     { client: client_unix, send: '.1+.1',
       expect: '0.2' },
     // Can parse valid JSON
     { client: client_unix, send: 'JSON.parse(\'{"valid": "json"}\');',
       expect: '{ valid: \'json\' }'},
     // invalid input to JSON.parse error is special case of syntax error,
     // should throw
     { client: client_unix, send: 'JSON.parse(\'{invalid: \\\'json\\\'}\');',
       expect: /^SyntaxError: Unexpected token i/ },
     // end of input to JSON.parse error is special case of syntax error,
     // should throw
     { client: client_unix, send: 'JSON.parse(\'066\');',
       expect: /^SyntaxError: Unexpected number/ },
     // should throw
     { client: client_unix, send: 'JSON.parse(\'{\');',
       expect: /^SyntaxError: Unexpected end of input/ },
     // invalid RegExps are a special case of syntax error,
     // should throw
     { client: client_unix, send: '/(/;',
       expect: /^SyntaxError: Invalid regular expression\:/ },
     // invalid RegExp modifiers are a special case of syntax error,
     // should throw (GH-4012)
     { client: client_unix, send: 'new RegExp("foo", "wrong modifier");',
       expect: /^SyntaxError: Invalid flags supplied to RegExp constructor/ },
     // strict mode syntax errors should be caught (GH-5178)
     { client: client_unix, send: '(function() { "use strict"; return 0755; })()',
       expect: /^SyntaxError: Octal literals are not allowed in strict mode/ },
     { client: client_unix, send: '(function() { "use strict"; return { p: 1, p: 2 }; })()',
       expect: /^SyntaxError: Duplicate data property in object literal not allowed in strict mode/ },
     { client: client_unix, send: '(function(a, a, b) { "use strict"; return a + b + c; })()',
       expect: /^SyntaxError: Strict mode function may not have duplicate parameter names/ },
     { client: client_unix, send: '(function() { "use strict"; with (this) {} })()',
       expect: /^SyntaxError: Strict mode code may not include a with statement/ },
     { client: client_unix, send: '(function() { "use strict"; var x; delete x; })()',
       expect: /^SyntaxError: Delete of an unqualified identifier in strict mode/ },
     { client: client_unix, send: '(function() { "use strict"; eval = 17; })()',
       expect: /^SyntaxError: Assignment to eval or arguments is not allowed in strict mode/ },
     { client: client_unix, send: '(function() { "use strict"; if (true){ function f() { } } })()',
       expect: /^SyntaxError: In strict mode code, functions can only be declared at top level or immediately within another function/ },
     // Named functions can be used:
     { client: client_unix, send: 'function blah() { return 1; }',
       expect: prompt_unix },
     { client: client_unix, send: 'blah()',
       expect: '1\n' + prompt_unix },
     // Functions should not evaluate twice (#2773)
     { client: client_unix, send: 'var I = [1,2,3,function() {}]; I.pop()',
       expect: '[Function]' },
     // Multiline object
     { client: client_unix, send: '{ a: ',
       expect: prompt_multiline },
     { client: client_unix, send: '1 }',
       expect: '{ a: 1 }' },
     // Multiline anonymous function with comment
     { client: client_unix, send: '(function () {',
       expect: prompt_multiline },
     { client: client_unix, send: '// blah',
       expect: prompt_multiline },
     { client: client_unix, send: 'return 1;',
       expect: prompt_multiline },
     { client: client_unix, send: '})()',
       expect: '1' },
     // npm prompt error message
     { client: client_unix, send: 'npm install foobar',
       expect: expect_npm },
     { client: client_unix, send: '(function () {\n\nreturn 1;\n})()',
       expect: '1' },
     { client: client_unix, send: '{\n\na: 1\n}',
       expect: '{ a: 1 }' },
     { client: client_unix, send: 'url.format("http://google.com")',
       expect: 'http://google.com/' },
     { client: client_unix, send: 'var path = 42; path',
       expect: '42' }
   ]);
 }

 function tcp_test() {
   server_tcp = net.createServer(function(socket) {
     assert.strictEqual(server_tcp, socket.server);

     socket.on('end', function() {
       socket.end();
     });

     repl.start(prompt_tcp, socket);
   });

   server_tcp.listen(common.PORT, function() {
     var read_buffer = '';

     client_tcp = net.createConnection(common.PORT);

     client_tcp.on('connect', function() {
       assert.equal(true, client_tcp.readable);
       assert.equal(true, client_tcp.writable);

       send_expect([
         { client: client_tcp, send: '',
           expect: prompt_tcp },
         { client: client_tcp, send: 'invoke_me(333)',
           expect: ('\'' + 'invoked 333' + '\'\n' + prompt_tcp) },
         { client: client_tcp, send: 'a += 1',
           expect: ('12346' + '\n' + prompt_tcp) },
         { client: client_tcp,
           send: 'require(' + JSON.stringify(moduleFilename) + ').number',
           expect: ('42' + '\n' + prompt_tcp) }
       ]);
     });

     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));
       if (read_buffer.indexOf(prompt_tcp) !== -1) {
         assert.strictEqual(client_tcp.expect, read_buffer);
         common.error('match');
         read_buffer = '';
         if (client_tcp.list && client_tcp.list.length > 0) {
           send_expect(client_tcp.list);
         } else {
           common.error('End of TCP test.\n');
           clean_up();
         }
       } else {
         common.error('didn\'t see prompt yet, buffering');
       }
     });

     client_tcp.on('error', function(e) {
       throw e;
     });

     client_tcp.on('close', function() {
       server_tcp.close();
     });
   });

 }

 function unix_test() {
   server_unix = net.createServer(function(socket) {
     assert.strictEqual(server_unix, socket.server);

     socket.on('end', function() {
       socket.end();
     });

     repl.start({
       prompt: prompt_unix,
       input: socket,
       output: socket,
       useGlobal: true
     }).context.message = message;
   });

   server_unix.on('listening', function() {
     var read_buffer = '';

     client_unix = net.createConnection(common.PIPE);

     client_unix.on('connect', function() {
       assert.equal(true, client_unix.readable);
       assert.equal(true, client_unix.writable);

       send_expect([
         { client: client_unix, send: '',
           expect: prompt_unix },
         { client: client_unix, send: 'message',
           expect: ('\'' + message + '\'\n' + prompt_unix) },
         { client: client_unix, send: 'invoke_me(987)',
           expect: ('\'' + 'invoked 987' + '\'\n' + prompt_unix) },
         { client: client_unix, send: 'a = 12345',
           expect: ('12345' + '\n' + prompt_unix) },
         { client: client_unix, send: '{a:1}',
           expect: ('{ a: 1 }' + '\n' + prompt_unix) }
       ]);
     });

     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));
       if (read_buffer.indexOf(prompt_unix) !== -1) {
         assert.strictEqual(client_unix.expect, read_buffer);
         common.error('match');
         read_buffer = '';
         if (client_unix.list && client_unix.list.length > 0) {
           send_expect(client_unix.list);
         } else {
           common.error('End of Unix test, running Error test.\n');
           process.nextTick(error_test);
         }
       } else {
         common.error('didn\'t see prompt yet, buffering.');
       }
     });

     client_unix.on('error', function(e) {
       throw e;
     });

     client_unix.on('close', function() {
       server_unix.close();
     });
   });

   server_unix.listen(common.PIPE);
 }

 unix_test();

 timer = setTimeout(function() {
   assert.fail('Timeout');
 }, 5000);
	// Copyright Joyent, Inc. and other Node contributors.
	//
	// Permission is hereby granted, free of charge, to any person obtaining a
	// copy of this software and associated documentation files (the
	// "Software"), to deal in the Software without restriction, including
	// without limitation the rights to use, copy, modify, merge, publish,
	// distribute, sublicense, and/or sell copies of the Software, and to permit
	// persons to whom the Software is furnished to do so, subject to the
	// following conditions:
	//
	// The above copyright notice and this permission notice shall be included
	// in all copies or substantial portions of the Software.
	//
	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
	// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
	// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
	// 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 assert = require('assert');

	common.globalCheck = false;

	var net = require('net'),
	repl = require('repl'),
	message = 'Read, Eval, Print Loop',
	prompt_unix = 'node via Unix socket> ',
	prompt_tcp = 'node via TCP socket> ',
	prompt_multiline = '... ',
	prompt_npm = 'npm should be run outside of the ' +
	'node repl, in your normal shell.\n' +
	'(Press Control-D to exit.)\n',
	expect_npm = prompt_npm + prompt_unix,
	server_tcp, server_unix, client_tcp, client_unix, timer;


	// absolute path to test/fixtures/a.js
	var moduleFilename = require('path').join(common.fixturesDir, 'a');

	common.error('repl test');

	// function for REPL to run
	invoke_me = function(arg) {
	return 'invoked ' + arg;
	};

	function send_expect(list) {
	if (list.length > 0) {
	var cur = list.shift();

	common.error('sending ' + JSON.stringify(cur.send));

	cur.client.expect = cur.expect;
	cur.client.list = list;
	if (cur.send.length > 0) {
	cur.client.write(cur.send + '\n');
	}
	}
	}

	function clean_up() {
	client_tcp.end();
	client_unix.end();
	clearTimeout(timer);
	}

	function error_test() {
	// The other stuff is done so reuse unix socket
	var read_buffer = '';
	client_unix.removeAllListeners('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 ?
	client_unix.expect :
	JSON.stringify(client_unix.expect)));

	if (read_buffer.indexOf(prompt_unix) !== -1) {
	// if it's an exact match, then don't do the regexp
	if (read_buffer !== client_unix.expect) {
	assert.ok(read_buffer.match(client_unix.expect));
	common.error('match');
	}
	read_buffer = '';
	if (client_unix.list && client_unix.list.length > 0) {
	send_expect(client_unix.list);
	} else {
	common.error('End of Error test, running TCP test.');
	tcp_test();
	}

	} else if (read_buffer.indexOf(prompt_multiline) !== -1) {
	// Check that you meant to send a multiline test
	assert.strictEqual(prompt_multiline, client_unix.expect);
	read_buffer = '';
	if (client_unix.list && client_unix.list.length > 0) {
	send_expect(client_unix.list);
	} else {
	common.error('End of Error test, running TCP test.\n');
	tcp_test();
	}

	} else {
	common.error('didn\'t see prompt yet, buffering.');
	}
	});

	send_expect([
	// Uncaught error throws and prints out
	{ client: client_unix, send: 'throw new Error(\'test error\');',
	expect: /^Error: test error/ },
	// Common syntax error is treated as multiline command
	{ client: client_unix, send: 'function test_func() {',
	expect: prompt_multiline },
	// You can recover with the .break command
	{ client: client_unix, send: '.break',
	expect: prompt_unix },
	// Floating point numbers are not interpreted as REPL commands.
	{ client: client_unix, send: '.1234',
	expect: '0.1234' },
	// Floating point expressions are not interpreted as REPL commands
	{ client: client_unix, send: '.1+.1',
	expect: '0.2' },
	// Can parse valid JSON
	{ client: client_unix, send: 'JSON.parse(\'{"valid": "json"}\');',
	expect: '{ valid: \'json\' }'},
	// invalid input to JSON.parse error is special case of syntax error,
	// should throw
	{ client: client_unix, send: 'JSON.parse(\'{invalid: \\\'json\\\'}\');',
	expect: /^SyntaxError: Unexpected token i/ },
	// end of input to JSON.parse error is special case of syntax error,
	// should throw
	{ client: client_unix, send: 'JSON.parse(\'066\');',
	expect: /^SyntaxError: Unexpected number/ },
	// should throw
	{ client: client_unix, send: 'JSON.parse(\'{\');',
	expect: /^SyntaxError: Unexpected end of input/ },
	// invalid RegExps are a special case of syntax error,
	// should throw
	{ client: client_unix, send: '/(/;',
	expect: /^SyntaxError: Invalid regular expression\:/ },
	// invalid RegExp modifiers are a special case of syntax error,
	// should throw (GH-4012)
	{ client: client_unix, send: 'new RegExp("foo", "wrong modifier");',
	expect: /^SyntaxError: Invalid flags supplied to RegExp constructor/ },
	// strict mode syntax errors should be caught (GH-5178)
	{ client: client_unix, send: '(function() { "use strict"; return 0755; })()',
	expect: /^SyntaxError: Octal literals are not allowed in strict mode/ },
	{ client: client_unix, send: '(function() { "use strict"; return { p: 1, p: 2 }; })()',
	expect: /^SyntaxError: Duplicate data property in object literal not allowed in strict mode/ },
	{ client: client_unix, send: '(function(a, a, b) { "use strict"; return a + b + c; })()',
	expect: /^SyntaxError: Strict mode function may not have duplicate parameter names/ },
	{ client: client_unix, send: '(function() { "use strict"; with (this) {} })()',
	expect: /^SyntaxError: Strict mode code may not include a with statement/ },
	{ client: client_unix, send: '(function() { "use strict"; var x; delete x; })()',
	expect: /^SyntaxError: Delete of an unqualified identifier in strict mode/ },
	{ client: client_unix, send: '(function() { "use strict"; eval = 17; })()',
	expect: /^SyntaxError: Assignment to eval or arguments is not allowed in strict mode/ },
	{ client: client_unix, send: '(function() { "use strict"; if (true){ function f() { } } })()',
	expect: /^SyntaxError: In strict mode code, functions can only be declared at top level or immediately within another function/ },
	// Named functions can be used:
	{ client: client_unix, send: 'function blah() { return 1; }',
	expect: prompt_unix },
	{ client: client_unix, send: 'blah()',
	expect: '1\n' + prompt_unix },
	// Functions should not evaluate twice (#2773)
	{ client: client_unix, send: 'var I = [1,2,3,function() {}]; I.pop()',
	expect: '[Function]' },
	// Multiline object
	{ client: client_unix, send: '{ a: ',
	expect: prompt_multiline },
	{ client: client_unix, send: '1 }',
	expect: '{ a: 1 }' },
	// Multiline anonymous function with comment
	{ client: client_unix, send: '(function () {',
	expect: prompt_multiline },
	{ client: client_unix, send: '// blah',
	expect: prompt_multiline },
	{ client: client_unix, send: 'return 1;',
	expect: prompt_multiline },
	{ client: client_unix, send: '})()',
	expect: '1' },
	// npm prompt error message
	{ client: client_unix, send: 'npm install foobar',
	expect: expect_npm },
	{ client: client_unix, send: '(function () {\n\nreturn 1;\n})()',
	expect: '1' },
	{ client: client_unix, send: '{\n\na: 1\n}',
	expect: '{ a: 1 }' },
	{ client: client_unix, send: 'url.format("http://google.com")',
	expect: 'http://google.com/' },
	{ client: client_unix, send: 'var path = 42; path',
	expect: '42' }
	]);
	}

	function tcp_test() {
	server_tcp = net.createServer(function(socket) {
	assert.strictEqual(server_tcp, socket.server);

	socket.on('end', function() {
	socket.end();
	});

	repl.start(prompt_tcp, socket);
	});

	server_tcp.listen(common.PORT, function() {
	var read_buffer = '';

	client_tcp = net.createConnection(common.PORT);

	client_tcp.on('connect', function() {
	assert.equal(true, client_tcp.readable);
	assert.equal(true, client_tcp.writable);

	send_expect([
	{ client: client_tcp, send: '',
	expect: prompt_tcp },
	{ client: client_tcp, send: 'invoke_me(333)',
	expect: ('\'' + 'invoked 333' + '\'\n' + prompt_tcp) },
	{ client: client_tcp, send: 'a += 1',
	expect: ('12346' + '\n' + prompt_tcp) },
	{ client: client_tcp,
	send: 'require(' + JSON.stringify(moduleFilename) + ').number',
	expect: ('42' + '\n' + prompt_tcp) }
	]);
	});

	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));
	if (read_buffer.indexOf(prompt_tcp) !== -1) {
	assert.strictEqual(client_tcp.expect, read_buffer);
	common.error('match');
	read_buffer = '';
	if (client_tcp.list && client_tcp.list.length > 0) {
	send_expect(client_tcp.list);
	} else {
	common.error('End of TCP test.\n');
	clean_up();
	}
	} else {
	common.error('didn\'t see prompt yet, buffering');
	}
	});

	client_tcp.on('error', function(e) {
	throw e;
	});

	client_tcp.on('close', function() {
	server_tcp.close();
	});
	});

	}

	function unix_test() {
	server_unix = net.createServer(function(socket) {
	assert.strictEqual(server_unix, socket.server);

	socket.on('end', function() {
	socket.end();
	});

	repl.start({
	prompt: prompt_unix,
	input: socket,
	output: socket,
	useGlobal: true
	}).context.message = message;
	});

	server_unix.on('listening', function() {
	var read_buffer = '';

	client_unix = net.createConnection(common.PIPE);

	client_unix.on('connect', function() {
	assert.equal(true, client_unix.readable);
	assert.equal(true, client_unix.writable);

	send_expect([
	{ client: client_unix, send: '',
	expect: prompt_unix },
	{ client: client_unix, send: 'message',
	expect: ('\'' + message + '\'\n' + prompt_unix) },
	{ client: client_unix, send: 'invoke_me(987)',
	expect: ('\'' + 'invoked 987' + '\'\n' + prompt_unix) },
	{ client: client_unix, send: 'a = 12345',
	expect: ('12345' + '\n' + prompt_unix) },
	{ client: client_unix, send: '{a:1}',
	expect: ('{ a: 1 }' + '\n' + prompt_unix) }
	]);
	});

	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));
	if (read_buffer.indexOf(prompt_unix) !== -1) {
	assert.strictEqual(client_unix.expect, read_buffer);
	common.error('match');
	read_buffer = '';
	if (client_unix.list && client_unix.list.length > 0) {
	send_expect(client_unix.list);
	} else {
	common.error('End of Unix test, running Error test.\n');
	process.nextTick(error_test);
	}
	} else {
	common.error('didn\'t see prompt yet, buffering.');
	}
	});

	client_unix.on('error', function(e) {
	throw e;
	});

	client_unix.on('close', function() {
	server_unix.close();
	});
	});

	server_unix.listen(common.PIPE);
	}

	unix_test();

	timer = setTimeout(function() {
	assert.fail('Timeout');
	}, 5000);