Revert "repl,util: insert carriage returns in output"

This reverts commit fce4b981eacbce0b85a2418d042f1f67d40e9834.

This was a breaking change and should have been marked semver-major.
The change that was made altered the output of util.format() and
util.inspect(). With how much those are used in the wild, this type of
change deserves more justification.

Fixes: https://github.com/nodejs/node/issues/8138
PR-URL: https://github.com/nodejs/node/pull/8143
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>

17 files changed, 160 insertions, 168 deletions

diff --git a/test/parallel/test-preload.js b/test/parallel/test-preload.js
index 96ce9559a5..e60b29dfbe 100644
--- a/test/parallel/test-preload.js
+++ b/test/parallel/test-preload.js
@@ -123,7 +123,7 @@ const interactive = childProcess.exec(nodeBinary + ' '
   + '-i',
   common.mustCall(function(err, stdout, stderr) {
     assert.ifError(err);
-    assert.strictEqual(stdout, `> 'test'\r\n> `);
+    assert.strictEqual(stdout, `> 'test'\n> `);
   }));
 
 interactive.stdin.write('a\n');
diff --git a/test/parallel/test-repl-.save.load.js b/test/parallel/test-repl-.save.load.js
index 1d2526d405..b9c5bc88af 100644
--- a/test/parallel/test-repl-.save.load.js
+++ b/test/parallel/test-repl-.save.load.js
@@ -27,8 +27,7 @@ putIn.run(testFile);
 putIn.run(['.save ' + saveFileName]);
 
 // the file should have what I wrote
-assert.equal(fs.readFileSync(saveFileName, 'utf8'), testFile.join('\r\n')
-             + '\r\n');
+assert.equal(fs.readFileSync(saveFileName, 'utf8'), testFile.join('\n') + '\n');
 
 // make sure that the REPL data is "correct"
 // so when I load it back I know I'm good
@@ -55,7 +54,7 @@ var loadFile = join(common.tmpDir, 'file.does.not.exist');
 // should not break
 putIn.write = function(data) {
   // make sure I get a failed to load message and not some crazy error
-  assert.equal(data, 'Failed to load:' + loadFile + '\r\n');
+  assert.equal(data, 'Failed to load:' + loadFile + '\n');
   // eat me to avoid work
   putIn.write = function() {};
 };
@@ -64,7 +63,7 @@ putIn.run(['.load ' + loadFile]);
 // throw error on loading directory
 loadFile = common.tmpDir;
 putIn.write = function(data) {
-  assert.equal(data, 'Failed to load:' + loadFile + ' is not a valid file\r\n');
+  assert.equal(data, 'Failed to load:' + loadFile + ' is not a valid file\n');
   putIn.write = function() {};
 };
 putIn.run(['.load ' + loadFile]);
@@ -79,7 +78,7 @@ const invalidFileName = join(common.tmpDir, '\0\0\0\0\0');
 // should not break
 putIn.write = function(data) {
   // make sure I get a failed to save message and not some other error
-  assert.equal(data, 'Failed to save:' + invalidFileName + '\r\n');
+  assert.equal(data, 'Failed to save:' + invalidFileName + '\n');
   // reset to no-op
   putIn.write = function() {};
 };
diff --git a/test/parallel/test-repl-autolibs.js b/test/parallel/test-repl-autolibs.js
index 1be2c33d28..15f779d3b1 100644
--- a/test/parallel/test-repl-autolibs.js
+++ b/test/parallel/test-repl-autolibs.js
@@ -19,7 +19,7 @@ function test1() {
     if (data.length) {
 
       // inspect output matches repl output
-      assert.equal(data, util.inspect(require('fs'), null, 2, false) + '\r\n');
+      assert.equal(data, util.inspect(require('fs'), null, 2, false) + '\n');
       // globally added lib matches required lib
       assert.equal(global.fs, require('fs'));
       test2();
@@ -36,7 +36,7 @@ function test2() {
     gotWrite = true;
     if (data.length) {
       // repl response error message
-      assert.equal(data, '{}\r\n');
+      assert.equal(data, '{}\n');
       // original value wasn't overwritten
       assert.equal(val, global.url);
     }
diff --git a/test/parallel/test-repl-definecommand.js b/test/parallel/test-repl-definecommand.js
index d6a6fee192..c0e1b3269a 100644
--- a/test/parallel/test-repl-definecommand.js
+++ b/test/parallel/test-repl-definecommand.js
@@ -34,10 +34,10 @@ r.defineCommand('say2', function() {
   this.displayPrompt();
 });
 
-inputStream.write('.help\r\n');
-assert(/\r\nsay1\thelp for say1\r\n/.test(output), 'help for say1 not present');
-assert(/\r\nsay2\t\r\n/.test(output), 'help for say2 not present');
-inputStream.write('.say1 node developer\r\n');
+inputStream.write('.help\n');
+assert(/\nsay1\thelp for say1\n/.test(output), 'help for say1 not present');
+assert(/\nsay2\t\n/.test(output), 'help for say2 not present');
+inputStream.write('.say1 node developer\n');
 assert(/> hello node developer/.test(output), 'say1 outputted incorrectly');
-inputStream.write('.say2 node developer\r\n');
+inputStream.write('.say2 node developer\n');
 assert(/> hello from say2/.test(output), 'say2 outputted incorrectly');
diff --git a/test/parallel/test-repl-mode.js b/test/parallel/test-repl-mode.js
index d5d9f12100..08b296c2c3 100644
--- a/test/parallel/test-repl-mode.js
+++ b/test/parallel/test-repl-mode.js
@@ -21,14 +21,14 @@ function testSloppyMode() {
 
   cli.input.emit('data', `
     x = 3
-  `.trim() + '\r\n');
-  assert.equal(cli.output.accumulator.join(''), '> 3\r\n> ');
+  `.trim() + '\n');
+  assert.equal(cli.output.accumulator.join(''), '> 3\n> ');
   cli.output.accumulator.length = 0;
 
   cli.input.emit('data', `
     let y = 3
-  `.trim() + '\r\n');
-  assert.equal(cli.output.accumulator.join(''), 'undefined\r\n> ');
+  `.trim() + '\n');
+  assert.equal(cli.output.accumulator.join(''), 'undefined\n> ');
 }
 
 function testStrictMode() {
@@ -36,15 +36,15 @@ function testStrictMode() {
 
   cli.input.emit('data', `
     x = 3
-  `.trim() + '\r\n');
+  `.trim() + '\n');
   assert.ok(/ReferenceError: x is not defined/.test(
       cli.output.accumulator.join('')));
   cli.output.accumulator.length = 0;
 
   cli.input.emit('data', `
     let y = 3
-  `.trim() + '\r\n');
-  assert.equal(cli.output.accumulator.join(''), 'undefined\r\n> ');
+  `.trim() + '\n');
+  assert.equal(cli.output.accumulator.join(''), 'undefined\n> ');
 }
 
 function testAutoMode() {
@@ -52,14 +52,14 @@ function testAutoMode() {
 
   cli.input.emit('data', `
     x = 3
-  `.trim() + '\r\n');
-  assert.equal(cli.output.accumulator.join(''), '> 3\r\n> ');
+  `.trim() + '\n');
+  assert.equal(cli.output.accumulator.join(''), '> 3\n> ');
   cli.output.accumulator.length = 0;
 
   cli.input.emit('data', `
     let y = 3
-  `.trim() + '\r\n');
-  assert.equal(cli.output.accumulator.join(''), 'undefined\r\n> ');
+  `.trim() + '\n');
+  assert.equal(cli.output.accumulator.join(''), 'undefined\n> ');
 }
 
 function initRepl(mode) {
diff --git a/test/parallel/test-repl-persistent-history.js b/test/parallel/test-repl-persistent-history.js
index 40951fd5ed..0a38cfc480 100644
--- a/test/parallel/test-repl-persistent-history.js
+++ b/test/parallel/test-repl-persistent-history.js
@@ -37,7 +37,7 @@ class ActionStream extends stream.Stream {
       if (typeof action === 'object') {
         self.emit('keypress', '', action);
       } else {
-        self.emit('data', action + '\r\n');
+        self.emit('data', action + '\n');
       }
       setImmediate(doAction);
     }
@@ -138,7 +138,7 @@ const tests = [
     env: { NODE_REPL_HISTORY_FILE: oldHistoryPath },
     test: [UP, CLEAR, '\'42\'', ENTER],
     expected: [prompt, convertMsg, prompt, prompt + '\'=^.^=\'', prompt, '\'',
-               '4', '2', '\'', '\'42\'\r\n', prompt, prompt],
+               '4', '2', '\'', '\'42\'\n', prompt, prompt],
     after: function ensureHistoryFixture() {
       // XXX(Fishrock123) Make sure nothing weird happened to our fixture
       //  or it's temporary copy.
@@ -154,7 +154,7 @@ const tests = [
   { // Requires the above testcase
     env: {},
     test: [UP, UP, ENTER],
-    expected: [prompt, prompt + '\'42\'', prompt + '\'=^.^=\'', '\'=^.^=\'\r\n',
+    expected: [prompt, prompt + '\'42\'', prompt + '\'=^.^=\'', '\'=^.^=\'\n',
                prompt]
   },
   {
diff --git a/test/parallel/test-repl-recoverable.js b/test/parallel/test-repl-recoverable.js
index bec1badd24..6788d84595 100644
--- a/test/parallel/test-repl-recoverable.js
+++ b/test/parallel/test-repl-recoverable.js
@@ -21,7 +21,7 @@ putIn.write = function(msg) {
     recovered = true;
   }
 
-  if (msg === 'true\r\n') {
+  if (msg === 'true\n') {
     rendered = true;
   }
 };
@@ -30,8 +30,8 @@ repl.start('', putIn, customEval);
 
 // https://github.com/nodejs/node/issues/2939
 // Expose recoverable errors to the consumer.
-putIn.emit('data', '1\r\n');
-putIn.emit('data', '2\r\n');
+putIn.emit('data', '1\n');
+putIn.emit('data', '2\n');
 
 process.on('exit', function() {
   assert(recovered, 'REPL never recovered');
diff --git a/test/parallel/test-repl-require.js b/test/parallel/test-repl-require.js
index 2c8ac4ecd2..9dc3b51de7 100644
--- a/test/parallel/test-repl-require.js
+++ b/test/parallel/test-repl-require.js
@@ -24,11 +24,11 @@ server.listen(options, function() {
   const conn = net.connect(options);
   conn.setEncoding('utf8');
   conn.on('data', (data) => answer += data);
-  conn.write('require("baz")\r\nrequire("./baz")\r\n.exit\r\n');
+  conn.write('require("baz")\nrequire("./baz")\n.exit\n');
 });
 
 process.on('exit', function() {
   assert.strictEqual(false, /Cannot find module/.test(answer));
   assert.strictEqual(false, /Error/.test(answer));
-  assert.strictEqual(answer, '\'eye catcher\'\r\n\'perhaps I work\'\r\n');
+  assert.strictEqual(answer, '\'eye catcher\'\n\'perhaps I work\'\n');
 });
diff --git a/test/parallel/test-repl-sigint.js b/test/parallel/test-repl-sigint.js
index 303973194f..5ee974aaea 100644
--- a/test/parallel/test-repl-sigint.js
+++ b/test/parallel/test-repl-sigint.js
@@ -34,18 +34,17 @@ child.stdout.once('data', common.mustCall(() => {
     process.kill(child.pid, 'SIGINT');
     child.stdout.once('data', common.mustCall(() => {
       // Make sure state from before the interruption is still available.
-      child.stdin.end('a*2*3*7\r\n');
+      child.stdin.end('a*2*3*7\n');
     }));
   }));
 
   child.stdin.write('a = 1001;' +
                     'process.kill(+process.env.REPL_TEST_PPID, "SIGUSR2");' +
-                    'while(true){}\r\n');
+                    'while(true){}\n');
 }));
 
 child.on('close', function(code) {
   assert.strictEqual(code, 0);
-  assert.notStrictEqual(stdout.indexOf('Script execution interrupted.' +
-                                       '\r\n'), -1);
-  assert.notStrictEqual(stdout.indexOf('42042\r\n'), -1);
+  assert.notStrictEqual(stdout.indexOf('Script execution interrupted.\n'), -1);
+  assert.notStrictEqual(stdout.indexOf('42042\n'), -1);
 });
diff --git a/test/parallel/test-repl-underscore.js b/test/parallel/test-repl-underscore.js
index bdcf4e82ec..97fc508ad9 100644
--- a/test/parallel/test-repl-underscore.js
+++ b/test/parallel/test-repl-underscore.js
@@ -151,6 +151,6 @@ function initRepl(mode) {
 }
 
 function assertOutput(output, expected) {
-  const lines = output.accum.trim().split('\r\n');
+  const lines = output.accum.trim().split('\n');
   assert.deepStrictEqual(lines, expected);
 }
diff --git a/test/parallel/test-repl-unexpected-token-recoverable.js b/test/parallel/test-repl-unexpected-token-recoverable.js
index 96c8cbedf4..84668c8657 100644
--- a/test/parallel/test-repl-unexpected-token-recoverable.js
+++ b/test/parallel/test-repl-unexpected-token-recoverable.js
@@ -10,9 +10,9 @@ var spawn = require('child_process').spawn;
 var args = [ '-i' ];
 var child = spawn(process.execPath, args);
 
-var input = 'var foo = "bar\\\r\nbaz"';
+var input = 'var foo = "bar\\\nbaz"';
 // Match '...' as well since it marks a multi-line statement
-var expectOut = /^> ... undefined\r\n/;
+var expectOut = /^> ... undefined\n/;
 
 child.stderr.setEncoding('utf8');
 child.stderr.on('data', function(c) {
diff --git a/test/parallel/test-repl-use-global.js b/test/parallel/test-repl-use-global.js
index 7ac6088679..79e13cd819 100644
--- a/test/parallel/test-repl-use-global.js
+++ b/test/parallel/test-repl-use-global.js
@@ -24,7 +24,7 @@ const globalTest = (useGlobal, cb, output) => (err, repl) => {
   let str = '';
   output.on('data', (data) => (str += data));
   global.lunch = 'tacos';
-  repl.write('global.lunch;\r\n');
+  repl.write('global.lunch;\n');
   repl.close();
   delete global.lunch;
   cb(null, str.trim());
@@ -54,8 +54,8 @@ const processTest = (useGlobal, cb, output) => (err, repl) => {
   output.on('data', (data) => (str += data));
 
   // if useGlobal is false, then `let process` should work
-  repl.write('let process;\r\n');
-  repl.write('21 * 2;\r\n');
+  repl.write('let process;\n');
+  repl.write('21 * 2;\n');
   repl.close();
   cb(null, str.trim());
 };
@@ -63,7 +63,7 @@ const processTest = (useGlobal, cb, output) => (err, repl) => {
 for (const option of processTestCases) {
   runRepl(option, processTest, common.mustCall((err, output) => {
     assert.ifError(err);
-    assert.strictEqual(output, 'undefined\r\n42');
+    assert.strictEqual(output, 'undefined\n42');
   }));
 }
 
diff --git a/test/parallel/test-repl.js b/test/parallel/test-repl.js
index 5984340b8a..495125f6dc 100644
--- a/test/parallel/test-repl.js
+++ b/test/parallel/test-repl.js
@@ -12,8 +12,8 @@ const prompt_unix = 'node via Unix socket> ';
 const prompt_tcp = 'node via TCP socket> ';
 const prompt_multiline = '... ';
 const prompt_npm = 'npm should be run outside of the ' +
-                   'node repl, in your normal shell.\r\n' +
-                   '(Press Control-D to exit.)\r\n';
+                   'node repl, in your normal shell.\n' +
+                   '(Press Control-D to exit.)\n';
 const expect_npm = prompt_npm + prompt_unix;
 var server_tcp, server_unix, client_tcp, client_unix, replServer;
 
@@ -37,7 +37,7 @@ function send_expect(list) {
     cur.client.expect = cur.expect;
     cur.client.list = list;
     if (cur.send.length > 0) {
-      cur.client.write(cur.send + '\r\n');
+      cur.client.write(cur.send + '\n');
     }
   }
 }
@@ -99,7 +99,7 @@ function error_test() {
         run_strict_test = false;
         strict_mode_error_test();
       } else {
-        console.error('End of Error test, running TCP test.\r\n');
+        console.error('End of Error test, running TCP test.\n');
         tcp_test();
       }
 
@@ -109,11 +109,6 @@ function error_test() {
   });
 
   send_expect([
-    // Can handle carriage returns
-    { client: client_unix, send: '(function(){return "JungMinu";})()',
-      expect: "'JungMinu'\r\n" + prompt_unix },
-    { client: client_unix, send: 'const JungMinu="\\r\\nMinwooJung";JungMinu',
-      expect: 'MinwooJung' },
     // Uncaught error throws and prints out
     { client: client_unix, send: 'throw new Error(\'test error\');',
       expect: /^Error: test error/ },
@@ -136,12 +131,12 @@ function error_test() {
     { client: client_unix, send: '`io.js ${"1.0"',
       expect: prompt_multiline },
     { client: client_unix, send: '+ ".2"}`',
-      expect: `'io.js 1.0.2'\r\n${prompt_unix}` },
+      expect: `'io.js 1.0.2'\n${prompt_unix}` },
     // Dot prefix in multiline commands aren't treated as commands
     { client: client_unix, send: '("a"',
       expect: prompt_multiline },
     { client: client_unix, send: '.charAt(0))',
-      expect: `'a'\r\n${prompt_unix}` },
+      expect: `'a'\n${prompt_unix}` },
     // Floating point numbers are not interpreted as REPL commands.
     { client: client_unix, send: '.1234',
       expect: '0.1234' },
@@ -187,7 +182,7 @@ function error_test() {
     { client: client_unix, send: 'function blah() { return 1; }',
       expect: prompt_unix },
     { client: client_unix, send: 'blah()',
-      expect: '1\r\n' + prompt_unix },
+      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]' },
@@ -211,13 +206,13 @@ function error_test() {
     { client: client_unix, send: '2)',
       expect: prompt_multiline },
     { client: client_unix, send: ')',
-      expect: 'undefined\r\n' + prompt_unix },
+      expect: 'undefined\n' + prompt_unix },
     // npm prompt error message
     { client: client_unix, send: 'npm install foobar',
       expect: expect_npm },
-    { client: client_unix, send: '(function() {\r\n\r\nreturn 1;\r\n})()',
+    { client: client_unix, send: '(function() {\n\nreturn 1;\n})()',
       expect: '1' },
-    { client: client_unix, send: '{\r\n\r\na: 1\r\n}',
+    { client: client_unix, send: '{\n\na: 1\n}',
       expect: '{ a: 1 }' },
     { client: client_unix, send: 'url.format("http://google.com")',
       expect: 'http://google.com/' },
@@ -226,18 +221,18 @@ function error_test() {
     // this makes sure that we don't print `undefined` when we actually print
     // the error message
     { client: client_unix, send: '.invalid_repl_command',
-      expect: 'Invalid REPL keyword\r\n' + prompt_unix },
+      expect: 'Invalid REPL keyword\n' + prompt_unix },
     // this makes sure that we don't crash when we use an inherited property as
     // a REPL command
     { client: client_unix, send: '.toString',
-      expect: 'Invalid REPL keyword\r\n' + prompt_unix },
+      expect: 'Invalid REPL keyword\n' + prompt_unix },
     // fail when we are not inside a String and a line continuation is used
     { client: client_unix, send: '[] \\',
       expect: /\bSyntaxError: Invalid or unexpected token/ },
     // do not fail when a String is created with line continuation
-    { client: client_unix, send: '\'the\\\r\nfourth\\\r\neye\'',
+    { client: client_unix, send: '\'the\\\nfourth\\\neye\'',
       expect: prompt_multiline + prompt_multiline +
-              '\'thefourtheye\'\r\n' + prompt_unix },
+              '\'thefourtheye\'\n' + prompt_unix },
     // Don't fail when a partial String is created and line continuation is used
     // with whitespace characters at the end of the string. We are to ignore it.
     // This test is to make sure that we properly remove the whitespace
@@ -245,99 +240,99 @@ function error_test() {
     { client: client_unix, send: '  \t    .break  \t  ',
       expect: prompt_unix },
     // multiline strings preserve whitespace characters in them
-    { client: client_unix, send: '\'the \\\r\n   fourth\t\t\\\r\n  eye  \'',
+    { client: client_unix, send: '\'the \\\n   fourth\t\t\\\n  eye  \'',
       expect: prompt_multiline + prompt_multiline +
-              '\'the    fourth\\t\\t  eye  \'\r\n' + prompt_unix },
+              '\'the    fourth\\t\\t  eye  \'\n' + prompt_unix },
     // more than one multiline strings also should preserve whitespace chars
-    { client: client_unix, send: '\'the \\\r\n   fourth\' +  \'\t\t\\\r\n  eye  \'',
+    { client: client_unix, send: '\'the \\\n   fourth\' +  \'\t\t\\\n  eye  \'',
       expect: prompt_multiline + prompt_multiline +
-              '\'the    fourth\\t\\t  eye  \'\r\n' + prompt_unix },
+              '\'the    fourth\\t\\t  eye  \'\n' + prompt_unix },
     // using REPL commands within a string literal should still work
-    { client: client_unix, send: '\'\\\r\n.break',
+    { client: client_unix, send: '\'\\\n.break',
       expect: prompt_unix },
     // using REPL command "help" within a string literal should still work
-    { client: client_unix, send: '\'thefourth\\\r\n.help\r\neye\'',
+    { client: client_unix, send: '\'thefourth\\\n.help\neye\'',
       expect: /'thefourtheye'/ },
     // empty lines in the REPL should be allowed
-    { client: client_unix, send: '\r\n\r\r\n\r\r\n',
+    { client: client_unix, send: '\n\r\n\r\n',
       expect: prompt_unix + prompt_unix + prompt_unix },
     // empty lines in the string literals should not affect the string
-    { client: client_unix, send: '\'the\\\r\n\\\r\nfourtheye\'\r\n',
+    { client: client_unix, send: '\'the\\\n\\\nfourtheye\'\n',
       expect: prompt_multiline + prompt_multiline +
-              '\'thefourtheye\'\r\n' + prompt_unix },
+              '\'thefourtheye\'\n' + prompt_unix },
     // Regression test for https://github.com/nodejs/node/issues/597
     { client: client_unix,
-      send: '/(.)(.)(.)(.)(.)(.)(.)(.)(.)/.test(\'123456789\')\r\n',
-      expect: `true\r\n${prompt_unix}` },
+      send: '/(.)(.)(.)(.)(.)(.)(.)(.)(.)/.test(\'123456789\')\n',
+      expect: `true\n${prompt_unix}` },
     // the following test's result depends on the RegEx's match from the above
     { client: client_unix,
-      send: 'RegExp.$1\r\nRegExp.$2\r\nRegExp.$3\r\nRegExp.$4\r\nRegExp.$5\r\n' +
-            'RegExp.$6\r\nRegExp.$7\r\nRegExp.$8\r\nRegExp.$9\r\n',
-      expect: ['\'1\'\r\n', '\'2\'\r\n', '\'3\'\r\n', '\'4\'\r\n', '\'5\'\r\n', '\'6\'\r\n',
-               '\'7\'\r\n', '\'8\'\r\n', '\'9\'\r\n'].join(`${prompt_unix}`) },
+      send: 'RegExp.$1\nRegExp.$2\nRegExp.$3\nRegExp.$4\nRegExp.$5\n' +
+            'RegExp.$6\nRegExp.$7\nRegExp.$8\nRegExp.$9\n',
+      expect: ['\'1\'\n', '\'2\'\n', '\'3\'\n', '\'4\'\n', '\'5\'\n', '\'6\'\n',
+               '\'7\'\n', '\'8\'\n', '\'9\'\n'].join(`${prompt_unix}`) },
     // regression tests for https://github.com/nodejs/node/issues/2749
-    { client: client_unix, send: 'function x() {\r\nreturn \'\\r\\n\';\r\n }',
+    { client: client_unix, send: 'function x() {\nreturn \'\\n\';\n }',
       expect: prompt_multiline + prompt_multiline +
-              'undefined\r\n' + prompt_unix },
-    { client: client_unix, send: 'function x() {\r\nreturn \'\\\\\';\r\n }',
+              'undefined\n' + prompt_unix },
+    { client: client_unix, send: 'function x() {\nreturn \'\\\\\';\n }',
       expect: prompt_multiline + prompt_multiline +
-              'undefined\r\n' + prompt_unix },
+              'undefined\n' + prompt_unix },
     // regression tests for https://github.com/nodejs/node/issues/3421
-    { client: client_unix, send: 'function x() {\r\n//\'\r\n }',
+    { client: client_unix, send: 'function x() {\n//\'\n }',
       expect: prompt_multiline + prompt_multiline +
-              'undefined\r\n' + prompt_unix },
-    { client: client_unix, send: 'function x() {\r\n//"\r\n }',
+              'undefined\n' + prompt_unix },
+    { client: client_unix, send: 'function x() {\n//"\n }',
       expect: prompt_multiline + prompt_multiline +
-              'undefined\r\n' + prompt_unix },
-    { client: client_unix, send: 'function x() {//\'\r\n }',
-      expect: prompt_multiline + 'undefined\r\n' + prompt_unix },
-    { client: client_unix, send: 'function x() {//"\r\n }',
-      expect: prompt_multiline + 'undefined\r\n' + prompt_unix },
-    { client: client_unix, send: 'function x() {\r\nvar i = "\'";\r\n }',
+              'undefined\n' + prompt_unix },
+    { client: client_unix, send: 'function x() {//\'\n }',
+      expect: prompt_multiline + 'undefined\n' + prompt_unix },
+    { client: client_unix, send: 'function x() {//"\n }',
+      expect: prompt_multiline + 'undefined\n' + prompt_unix },
+    { client: client_unix, send: 'function x() {\nvar i = "\'";\n }',
       expect: prompt_multiline + prompt_multiline +
-              'undefined\r\n' + prompt_unix },
+              'undefined\n' + prompt_unix },
     { client: client_unix, send: 'function x(/*optional*/) {}',
-      expect: 'undefined\r\n' + prompt_unix },
+      expect: 'undefined\n' + prompt_unix },
     { client: client_unix, send: 'function x(/* // 5 */) {}',
-      expect: 'undefined\r\n' + prompt_unix },
+      expect: 'undefined\n' + prompt_unix },
     { client: client_unix, send: '// /* 5 */',
-      expect: 'undefined\r\n' + prompt_unix },
+      expect: 'undefined\n' + prompt_unix },
     { client: client_unix, send: '"//"',
-      expect: '\'//\'\r\n' + prompt_unix },
+      expect: '\'//\'\n' + prompt_unix },
     { client: client_unix, send: '"data /*with*/ comment"',
-      expect: '\'data /*with*/ comment\'\r\n' + prompt_unix },
+      expect: '\'data /*with*/ comment\'\n' + prompt_unix },
     { client: client_unix, send: 'function x(/*fn\'s optional params*/) {}',
-      expect: 'undefined\r\n' + prompt_unix },
-    { client: client_unix, send: '/* \'\r\n"\r\n\'"\'\r\n*/',
-      expect: 'undefined\r\n' + prompt_unix },
+      expect: 'undefined\n' + prompt_unix },
+    { client: client_unix, send: '/* \'\n"\n\'"\'\n*/',
+      expect: 'undefined\n' + prompt_unix },
     // REPL should get a normal require() function, not one that allows
     // access to internal modules without the --expose_internals flag.
     { client: client_unix, send: 'require("internal/repl")',
       expect: /^Error: Cannot find module 'internal\/repl'/ },
     // REPL should handle quotes within regexp literal in multiline mode
-    { client: client_unix, send: "function x(s) {\r\nreturn s.replace(/'/,'');\r\n}",
+    { client: client_unix, send: "function x(s) {\nreturn s.replace(/'/,'');\n}",
       expect: prompt_multiline + prompt_multiline +
-            'undefined\r\n' + prompt_unix },
-    { client: client_unix, send: "function x(s) {\r\nreturn s.replace(/\'/,'');\r\n}",
+            'undefined\n' + prompt_unix },
+    { client: client_unix, send: "function x(s) {\nreturn s.replace(/\'/,'');\n}",
       expect: prompt_multiline + prompt_multiline +
-            'undefined\r\n' + prompt_unix },
-    { client: client_unix, send: 'function x(s) {\r\nreturn s.replace(/"/,"");\r\n}',
+            'undefined\n' + prompt_unix },
+    { client: client_unix, send: 'function x(s) {\nreturn s.replace(/"/,"");\n}',
       expect: prompt_multiline + prompt_multiline +
-            'undefined\r\n' + prompt_unix },
-    { client: client_unix, send: 'function x(s) {\r\nreturn s.replace(/.*/,"");\r\n}',
+            'undefined\n' + prompt_unix },
+    { client: client_unix, send: 'function x(s) {\nreturn s.replace(/.*/,"");\n}',
       expect: prompt_multiline + prompt_multiline +
-            'undefined\r\n' + prompt_unix },
+            'undefined\n' + prompt_unix },
     { client: client_unix, send: '{ var x = 4; }',
-      expect: 'undefined\r\n' + prompt_unix },
+      expect: 'undefined\n' + prompt_unix },
     // Illegal token is not recoverable outside string literal, RegExp literal,
     // or block comment. https://github.com/nodejs/node/issues/3611
     { client: client_unix, send: 'a = 3.5e',
       expect: /\bSyntaxError: Invalid or unexpected token/ },
     // Mitigate https://github.com/nodejs/node/issues/548
     { client: client_unix, send: 'function name(){ return "node"; };name()',
-      expect: "'node'\r\n" + prompt_unix },
+      expect: "'node'\n" + prompt_unix },
     { client: client_unix, send: 'function name(){ return "nodejs"; };name()',
-      expect: "'nodejs'\r\n" + prompt_unix },
+      expect: "'nodejs'\n" + prompt_unix },
     // Avoid emitting repl:line-number for SyntaxError
     { client: client_unix, send: 'a = 3.5e',
       expect: /^(?!repl)/ },
@@ -371,12 +366,12 @@ function tcp_test() {
         { client: client_tcp, send: '',
           expect: prompt_tcp },
         { client: client_tcp, send: 'invoke_me(333)',
-          expect: ('\'' + 'invoked 333' + '\'\r\n' + prompt_tcp) },
+          expect: ('\'' + 'invoked 333' + '\'\n' + prompt_tcp) },
         { client: client_tcp, send: 'a += 1',
-          expect: ('12346' + '\r\n' + prompt_tcp) },
+          expect: ('12346' + '\n' + prompt_tcp) },
         { client: client_tcp,
           send: 'require(' + JSON.stringify(moduleFilename) + ').number',
-          expect: ('42' + '\r\n' + prompt_tcp) }
+          expect: ('42' + '\n' + prompt_tcp) }
       ]);
     });
 
@@ -391,7 +386,7 @@ function tcp_test() {
         if (client_tcp.list && client_tcp.list.length > 0) {
           send_expect(client_tcp.list);
         } else {
-          console.error('End of TCP test.\r\n');
+          console.error('End of TCP test.\n');
           clean_up();
         }
       } else {
@@ -440,13 +435,13 @@ function unix_test() {
         { client: client_unix, send: '',
           expect: prompt_unix },
         { client: client_unix, send: 'message',
-          expect: ('\'' + message + '\'\r\n' + prompt_unix) },
+          expect: ('\'' + message + '\'\n' + prompt_unix) },
         { client: client_unix, send: 'invoke_me(987)',
-          expect: ('\'' + 'invoked 987' + '\'\r\n' + prompt_unix) },
+          expect: ('\'' + 'invoked 987' + '\'\n' + prompt_unix) },
         { client: client_unix, send: 'a = 12345',
-          expect: ('12345' + '\r\n' + prompt_unix) },
+          expect: ('12345' + '\n' + prompt_unix) },
         { client: client_unix, send: '{a:1}',
-          expect: ('{ a: 1 }' + '\r\n' + prompt_unix) }
+          expect: ('{ a: 1 }' + '\n' + prompt_unix) }
       ]);
     });
 
@@ -461,7 +456,7 @@ function unix_test() {
         if (client_unix.list && client_unix.list.length > 0) {
           send_expect(client_unix.list);
         } else {
-          console.error('End of Unix test, running Error test.\r\n');
+          console.error('End of Unix test, running Error test.\n');
           process.nextTick(error_test);
         }
       } else {
diff --git a/test/parallel/test-util-inspect-proxy.js b/test/parallel/test-util-inspect-proxy.js
index 8fc9087703..744bf23526 100644
--- a/test/parallel/test-util-inspect-proxy.js
+++ b/test/parallel/test-util-inspect-proxy.js
@@ -48,11 +48,11 @@ const expected2 = 'Proxy [ Proxy [ {}, {} ], {} ]';
 const expected3 = 'Proxy [ Proxy [ Proxy [ {}, {} ], {} ], Proxy [ {}, {} ] ]';
 const expected4 = 'Proxy [ Proxy [ {}, {} ], Proxy [ Proxy [ {}, {} ], {} ] ]';
 const expected5 = 'Proxy [ Proxy [ Proxy [ Proxy [Object], {} ],' +
-                  ' Proxy [ {}, {} ] ],\r\n  Proxy [ Proxy [ {}, {} ]' +
+                  ' Proxy [ {}, {} ] ],\n  Proxy [ Proxy [ {}, {} ]' +
                   ', Proxy [ Proxy [Object], {} ] ] ]';
 const expected6 = 'Proxy [ Proxy [ Proxy [ Proxy [Object], Proxy [Object]' +
-                  ' ],\r\n    Proxy [ Proxy [Object], Proxy [Object] ] ],\r\n' +
-                  '  Proxy [ Proxy [ Proxy [Object], Proxy [Object] ],\r\n' +
+                  ' ],\n    Proxy [ Proxy [Object], Proxy [Object] ] ],\n' +
+                  '  Proxy [ Proxy [ Proxy [Object], Proxy [Object] ],\n' +
                   '    Proxy [ Proxy [Object], Proxy [Object] ] ] ]';
 assert.strictEqual(util.inspect(proxy1, opts), expected1);
 assert.strictEqual(util.inspect(proxy2, opts), expected2);
diff --git a/test/parallel/test-util-inspect-simd.js b/test/parallel/test-util-inspect-simd.js
index 4c5d79568c..ec4ccc1875 100644
--- a/test/parallel/test-util-inspect-simd.js
+++ b/test/parallel/test-util-inspect-simd.js
@@ -17,10 +17,9 @@ assert.strictEqual(
 
 assert.strictEqual(
     inspect(SIMD.Bool8x16()),
-    'Bool8x16 [\r\n  false,\r\n  false,\r\n  false,\r\n  false,\r\n' +
-    '  false,\r\n  false,\r\n  false,\r\n  false,\r\n  false,\r\n' +
-    '  false,\r\n  false,\r\n  false,\r\n  false,\r\n  false,\r\n' +
-    '  false,\r\n  false ]');
+    'Bool8x16 [\n  false,\n  false,\n  false,\n  false,\n  false,\n' +
+    '  false,\n  false,\n  false,\n  false,\n  false,\n  false,\n' +
+    '  false,\n  false,\n  false,\n  false,\n  false ]');
 
 assert.strictEqual(
     inspect(SIMD.Bool32x4()),
diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index a9e547dc4c..d7c8462e36 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -11,12 +11,12 @@ assert.equal(util.inspect('hello'), "'hello'");
 assert.equal(util.inspect(function() {}), '[Function]');
 assert.equal(util.inspect(undefined), 'undefined');
 assert.equal(util.inspect(null), 'null');
-assert.equal(util.inspect(/foo(bar\r\n)?/gi), '/foo(bar\\r\\n)?/gi');
+assert.equal(util.inspect(/foo(bar\n)?/gi), '/foo(bar\\n)?/gi');
 assert.strictEqual(util.inspect(new Date('Sun, 14 Feb 2010 11:48:40 GMT')),
   new Date('2010-02-14T12:48:40+01:00').toISOString());
 assert.strictEqual(util.inspect(new Date('')), (new Date('')).toString());
 
-assert.equal(util.inspect('\r\n\u0001'), "'\\r\\n\\u0001'");
+assert.equal(util.inspect('\n\u0001'), "'\\n\\u0001'");
 
 assert.equal(util.inspect([]), '[]');
 assert.equal(util.inspect(Object.create([])), 'Array {}');
@@ -55,25 +55,25 @@ for (const showHidden of [true, false]) {
   const dv = new DataView(ab, 1, 2);
   assert.equal(util.inspect(ab, showHidden), 'ArrayBuffer { byteLength: 4 }');
   assert.equal(util.inspect(new DataView(ab, 1, 2), showHidden),
-               'DataView {\r\n' +
-               '  byteLength: 2,\r\n' +
-               '  byteOffset: 1,\r\n' +
+               'DataView {\n' +
+               '  byteLength: 2,\n' +
+               '  byteOffset: 1,\n' +
                '  buffer: ArrayBuffer { byteLength: 4 } }');
   assert.equal(util.inspect(ab, showHidden), 'ArrayBuffer { byteLength: 4 }');
   assert.equal(util.inspect(dv, showHidden),
-               'DataView {\r\n' +
-               '  byteLength: 2,\r\n' +
-               '  byteOffset: 1,\r\n' +
+               'DataView {\n' +
+               '  byteLength: 2,\n' +
+               '  byteOffset: 1,\n' +
                '  buffer: ArrayBuffer { byteLength: 4 } }');
   ab.x = 42;
   dv.y = 1337;
   assert.equal(util.inspect(ab, showHidden),
                'ArrayBuffer { byteLength: 4, x: 42 }');
   assert.equal(util.inspect(dv, showHidden),
-               'DataView {\r\n' +
-               '  byteLength: 2,\r\n' +
-               '  byteOffset: 1,\r\n' +
-               '  buffer: ArrayBuffer { byteLength: 4, x: 42 },\r\n' +
+               'DataView {\n' +
+               '  byteLength: 2,\n' +
+               '  byteOffset: 1,\n' +
+               '  buffer: ArrayBuffer { byteLength: 4, x: 42 },\n' +
                '  y: 1337 }');
 }
 
@@ -83,25 +83,25 @@ for (const showHidden of [true, false]) {
   const dv = vm.runInNewContext('new DataView(ab, 1, 2)', { ab: ab });
   assert.equal(util.inspect(ab, showHidden), 'ArrayBuffer { byteLength: 4 }');
   assert.equal(util.inspect(new DataView(ab, 1, 2), showHidden),
-               'DataView {\r\n' +
-               '  byteLength: 2,\r\n' +
-               '  byteOffset: 1,\r\n' +
+               'DataView {\n' +
+               '  byteLength: 2,\n' +
+               '  byteOffset: 1,\n' +
                '  buffer: ArrayBuffer { byteLength: 4 } }');
   assert.equal(util.inspect(ab, showHidden), 'ArrayBuffer { byteLength: 4 }');
   assert.equal(util.inspect(dv, showHidden),
-               'DataView {\r\n' +
-               '  byteLength: 2,\r\n' +
-               '  byteOffset: 1,\r\n' +
+               'DataView {\n' +
+               '  byteLength: 2,\n' +
+               '  byteOffset: 1,\n' +
                '  buffer: ArrayBuffer { byteLength: 4 } }');
   ab.x = 42;
   dv.y = 1337;
   assert.equal(util.inspect(ab, showHidden),
                'ArrayBuffer { byteLength: 4, x: 42 }');
   assert.equal(util.inspect(dv, showHidden),
-               'DataView {\r\n' +
-               '  byteLength: 2,\r\n' +
-               '  byteOffset: 1,\r\n' +
-               '  buffer: ArrayBuffer { byteLength: 4, x: 42 },\r\n' +
+               'DataView {\n' +
+               '  byteLength: 2,\n' +
+               '  byteOffset: 1,\n' +
+               '  buffer: ArrayBuffer { byteLength: 4, x: 42 },\n' +
                '  y: 1337 }');
 }
 
@@ -121,13 +121,13 @@ for (const showHidden of [true, false]) {
     array[0] = 65;
     array[1] = 97;
     assert.equal(util.inspect(array, true),
-                 `${constructor.name} [\r\n` +
-                 `  65,\r\n` +
-                 `  97,\r\n` +
-                 `  [BYTES_PER_ELEMENT]: ${constructor.BYTES_PER_ELEMENT}` +
-                 `,\r\n  [length]: ${length},\r\n` +
-                 `  [byteLength]: ${byteLength},\r\n` +
-                 `  [byteOffset]: 0,\r\n` +
+                 `${constructor.name} [\n` +
+                 `  65,\n` +
+                 `  97,\n` +
+                 `  [BYTES_PER_ELEMENT]: ${constructor.BYTES_PER_ELEMENT},\n` +
+                 `  [length]: ${length},\n` +
+                 `  [byteLength]: ${byteLength},\n` +
+                 `  [byteOffset]: 0,\n` +
                  `  [buffer]: ArrayBuffer { byteLength: ${byteLength} } ]`);
     assert.equal(util.inspect(array, false), `${constructor.name} [ 65, 97 ]`);
   });
@@ -153,13 +153,13 @@ for (const showHidden of [true, false]) {
     array[0] = 65;
     array[1] = 97;
     assert.equal(util.inspect(array, true),
-                 `${constructor.name} [\r\n` +
-                 `  65,\r\n` +
-                 `  97,\r\n` +
-                 `  [BYTES_PER_ELEMENT]: ${constructor.BYTES_PER_ELEMENT}` +
-                 `,\r\n  [length]: ${length},\r\n` +
-                 `  [byteLength]: ${byteLength},\r\n` +
-                 `  [byteOffset]: 0,\r\n` +
+                 `${constructor.name} [\n` +
+                 `  65,\n` +
+                 `  97,\n` +
+                 `  [BYTES_PER_ELEMENT]: ${constructor.BYTES_PER_ELEMENT},\n` +
+                 `  [length]: ${length},\n` +
+                 `  [byteLength]: ${byteLength},\n` +
+                 `  [byteOffset]: 0,\n` +
                  `  [buffer]: ArrayBuffer { byteLength: ${byteLength} } ]`);
     assert.equal(util.inspect(array, false), `${constructor.name} [ 65, 97 ]`);
   });
@@ -454,7 +454,7 @@ assert.doesNotThrow(function() {
 // util.inspect with "colors" option should produce as many lines as without it
 function test_lines(input) {
   var count_lines = function(str) {
-    return (str.match(/\r\n/g) || []).length;
+    return (str.match(/\n/g) || []).length;
   };
 
   var without_color = util.inspect(input);
@@ -585,7 +585,7 @@ assert.strictEqual(util.inspect(keys), 'SetIterator { 1, 3 }');
 // Assumes that the first numeric character is the start of an item.
 
 function checkAlignment(container) {
-  var lines = util.inspect(container).split('\r\n');
+  var lines = util.inspect(container).split('\n');
   var pos;
   lines.forEach(function(line) {
     var npos = line.search(/\d/);
@@ -728,7 +728,7 @@ checkAlignment(new Map(big_array.map(function(y) { return [y, null]; })));
 
   assert.strictEqual(oneLine, '{ foo: \'abc\', bar: \'xyz\' }');
   assert.strictEqual(oneLine, util.inspect(obj, {breakLength: breakpoint + 1}));
-  assert.strictEqual(twoLines, '{ foo: \'abc\',\r\n  bar: \'xyz\' }');
+  assert.strictEqual(twoLines, '{ foo: \'abc\',\n  bar: \'xyz\' }');
 }
 
 // util.inspect.defaultOptions tests
diff --git a/test/sequential/test-deprecation-flags.js b/test/sequential/test-deprecation-flags.js
index 0858e68585..e9f5ee673d 100644
--- a/test/sequential/test-deprecation-flags.js
+++ b/test/sequential/test-deprecation-flags.js
@@ -30,7 +30,7 @@ execFile(node, noDep, function(er, stdout, stderr) {
   console.error('--no-deprecation: silence deprecations');
   assert.equal(er, null);
   assert.equal(stdout, '');
-  assert.equal(stderr, 'DEBUG: This is deprecated\r\n');
+  assert.equal(stderr, 'DEBUG: This is deprecated\n');
   console.log('silent ok');
 });
 
@@ -38,7 +38,7 @@ execFile(node, traceDep, function(er, stdout, stderr) {
   console.error('--trace-deprecation: show stack');
   assert.equal(er, null);
   assert.equal(stdout, '');
-  var stack = stderr.trim().split('\r\n');
+  var stack = stderr.trim().split('\n');
   // just check the top and bottom.
   assert(/util.debug is deprecated. Use console.error instead./.test(stack[1]));
   assert(/DEBUG: This is deprecated/.test(stack[0]));