test: improve code in test-console-instance

* use common.mustCall to validate functions executions
* use common.fail to check test fail
* improve error validations
* remove unnecessary assertions
* use arrow functions

PR-URL: #10813
Reviewed-By: James M Snell <[email protected]>
Reviewed-By: Luigi Pinca <[email protected]>
Reviewed-By: Colin Ihrig <[email protected]>

test/parallel/test-console-instance.js

@@ -1,71 +1,59 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const Stream = require('stream');
 const Console = require('console').Console;
-let called = false;
 
 const out = new Stream();
 const err = new Stream();
 
 // ensure the Console instance doesn't write to the
 // process' "stdout" or "stderr" streams
-process.stdout.write = process.stderr.write = function() {
-  throw new Error('write() should not be called!');
-};
+process.stdout.write = process.stderr.write = common.fail;
 
 // make sure that the "Console" function exists
 assert.strictEqual('function', typeof Console);
 
 // make sure that the Console constructor throws
 // when not given a writable stream instance
-assert.throws(function() {
+assert.throws(() => {
   new Console();
-}, /Console expects a writable stream/);
+}, /^TypeError: Console expects a writable stream instance$/);
 
 // Console constructor should throw if stderr exists but is not writable
-assert.throws(function() {
-  out.write = function() {};
+assert.throws(() => {
+  out.write = () => {};
   err.write = undefined;
   new Console(out, err);
-}, /Console expects writable stream instances/);
+}, /^TypeError: Console expects writable stream instances$/);
 
-out.write = err.write = function(d) {};
+out.write = err.write = (d) => {};
 
 const c = new Console(out, err);
 
-out.write = err.write = function(d) {
+out.write = err.write = common.mustCall((d) => {
   assert.strictEqual(d, 'test\n');
-  called = true;
-};
+}, 2);
 
-assert(!called);
 c.log('test');
-assert(called);
-
-called = false;
 c.error('test');
-assert(called);
 
-out.write = function(d) {
+out.write = common.mustCall((d) => {
   assert.strictEqual('{ foo: 1 }\n', d);
-  called = true;
-};
+});
 
-called = false;
 c.dir({ foo: 1 });
-assert(called);
 
 // ensure that the console functions are bound to the console instance
-called = 0;
-out.write = function(d) {
+let called = 0;
+out.write = common.mustCall((d) => {
   called++;
-  assert.strictEqual(d, called + ' ' + (called - 1) + ' [ 1, 2, 3 ]\n');
-};
+  assert.strictEqual(d, `${called} ${called - 1} [ 1, 2, 3 ]\n`);
+}, 3);
+
 [1, 2, 3].forEach(c.log);
-assert.strictEqual(3, called);
 
 // Console() detects if it is called without `new` keyword
-assert.doesNotThrow(function() {
+assert.doesNotThrow(() => {
   Console(out, err);
 });