test: test `util` rather than `common`

test-sys.js tests common.inspect() (which is test-specific code) and not
sys (which, although deprecated, should still be tested).

This commit moves the tests to the not-deprecated util and adds a test
to check that deprecated sys and util are the same.

PR-URL: https://github.com/nodejs/node/pull/3256
Reviewed-By: Evan Lucas <evanlucas@me.com>

diff --git a/test/parallel/test-sys.js b/test/parallel/test-sys.js
index 9367e55c687f2fbfe4f86e05b8c9614f40321274..add692d7367f8c25c23a95da74af42fda320bde3 100644 (file)
--- a/test/parallel/test-sys.js
+++ b/test/parallel/test-sys.js
@@ -1,109 +1,7 @@
 'use strict';
-var common = require('../common');
+require('../common');
 var assert = require('assert');
+var sys = require('sys');
+var util = require('util');
 
-assert.equal('0', common.inspect(0));
-assert.equal('1', common.inspect(1));
-assert.equal('false', common.inspect(false));
-assert.equal("''", common.inspect(''));
-assert.equal("'hello'", common.inspect('hello'));
-assert.equal('[Function]', common.inspect(function() {}));
-assert.equal('undefined', common.inspect(undefined));
-assert.equal('null', common.inspect(null));
-assert.equal('/foo(bar\\n)?/gi', common.inspect(/foo(bar\n)?/gi));
-assert.equal(new Date('2010-02-14T12:48:40+01:00').toString(),
-             common.inspect(new Date('Sun, 14 Feb 2010 11:48:40 GMT')));
-
-assert.equal("'\\n\\u0001'", common.inspect('\n\u0001'));
-
-assert.equal('[]', common.inspect([]));
-assert.equal('Array {}', common.inspect(Object.create([])));
-assert.equal('[ 1, 2 ]', common.inspect([1, 2]));
-assert.equal('[ 1, [ 2, 3 ] ]', common.inspect([1, [2, 3]]));
-
-assert.equal('{}', common.inspect({}));
-assert.equal('{ a: 1 }', common.inspect({a: 1}));
-assert.equal('{ a: [Function] }', common.inspect({a: function() {}}));
-assert.equal('{ a: 1, b: 2 }', common.inspect({a: 1, b: 2}));
-assert.equal('{ a: {} }', common.inspect({'a': {}}));
-assert.equal('{ a: { b: 2 } }', common.inspect({'a': {'b': 2}}));
-assert.equal('{ a: { b: { c: [Object] } } }',
-             common.inspect({'a': {'b': { 'c': { 'd': 2 }}}}));
-assert.equal('{ a: { b: { c: { d: 2 } } } }',
-             common.inspect({'a': {'b': { 'c': { 'd': 2 }}}}, false, null));
-assert.equal('[ 1, 2, 3, [length]: 3 ]', common.inspect([1, 2, 3], true));
-assert.equal('{ a: [Object] }',
-             common.inspect({'a': {'b': { 'c': 2}}}, false, 0));
-assert.equal('{ a: { b: [Object] } }',
-             common.inspect({'a': {'b': { 'c': 2}}}, false, 1));
-assert.equal('{ visible: 1 }',
-    common.inspect(Object.create({},
-    {visible: {value: 1, enumerable: true}, hidden: {value: 2}}))
-);
-
-// Due to the hash seed randomization it's not deterministic the order that
-// the following ways this hash is displayed.
-// See http://codereview.chromium.org/9124004/
-
-var out = common.inspect(Object.create({},
-    {visible: {value: 1, enumerable: true}, hidden: {value: 2}}), true);
-if (out !== '{ [hidden]: 2, visible: 1 }' &&
-    out !== '{ visible: 1, [hidden]: 2 }') {
-  assert.ok(false);
-}
-
-
-// Objects without prototype
-var out = common.inspect(Object.create(null,
-    { name: {value: 'Tim', enumerable: true},
-      hidden: {value: 'secret'}}), true);
-if (out !== "{ [hidden]: 'secret', name: 'Tim' }" &&
-    out !== "{ name: 'Tim', [hidden]: 'secret' }") {
-  assert(false);
-}
-
-
-assert.equal('{ name: \'Tim\' }',
-    common.inspect(Object.create(null,
-                                 {name: {value: 'Tim', enumerable: true},
-                                   hidden: {value: 'secret'}}))
-);
-
-
-// Dynamic properties
-assert.equal('{ readonly: [Getter] }',
-             common.inspect({get readonly() {}}));
-
-assert.equal('{ readwrite: [Getter/Setter] }',
-             common.inspect({get readwrite() {}, set readwrite(val) {}}));
-
-assert.equal('{ writeonly: [Setter] }',
-             common.inspect({set writeonly(val) {}}));
-
-var value = {};
-value['a'] = value;
-assert.equal('{ a: [Circular] }', common.inspect(value));
-
-// Array with dynamic properties
-value = [1, 2, 3];
-value.__defineGetter__('growingLength', function() {
-  this.push(true); return this.length;
-});
-assert.equal('[ 1, 2, 3, growingLength: [Getter] ]', common.inspect(value));
-
-// Function with properties
-value = function() {};
-value.aprop = 42;
-assert.equal('{ [Function] aprop: 42 }', common.inspect(value));
-
-// Regular expressions with properties
-value = /123/ig;
-value.aprop = 42;
-assert.equal('{ /123/gi aprop: 42 }', common.inspect(value));
-
-// Dates with properties
-value = new Date('Sun, 14 Feb 2010 11:48:40 GMT');
-value.aprop = 42;
-assert.equal('{ Sun, 14 Feb 2010 11:48:40 GMT aprop: 42 }',
-             common.inspect(value)
-);
+assert.strictEqual(sys, util);

diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index a706f495992c03ba2ee4b8b7938a6a4109bec0c7..444c0168a42fa74bdfa510ec1cf9a8946208ad2d 100644 (file)
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -3,6 +3,111 @@ var common = require('../common');
 var assert = require('assert');
 var util = require('util');
 
+assert.equal(util.inspect(1), '1');
+assert.equal(util.inspect(false), 'false');
+assert.equal(util.inspect(''), "''");
+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\n)?/gi), '/foo(bar\\n)?/gi');
+assert.equal(util.inspect(new Date('Sun, 14 Feb 2010 11:48:40 GMT')),
+  new Date('2010-02-14T12:48:40+01:00').toString());
+
+assert.equal(util.inspect('\n\u0001'), "'\\n\\u0001'");
+
+assert.equal(util.inspect([]), '[]');
+assert.equal(util.inspect(Object.create([])), 'Array {}');
+assert.equal(util.inspect([1, 2]), '[ 1, 2 ]');
+assert.equal(util.inspect([1, [2, 3]]), '[ 1, [ 2, 3 ] ]');
+
+assert.equal(util.inspect({}), '{}');
+assert.equal(util.inspect({a: 1}), '{ a: 1 }');
+assert.equal(util.inspect({a: function() {}}), '{ a: [Function] }');
+assert.equal(util.inspect({a: 1, b: 2}), '{ a: 1, b: 2 }');
+assert.equal(util.inspect({'a': {}}), '{ a: {} }');
+assert.equal(util.inspect({'a': {'b': 2}}), '{ a: { b: 2 } }');
+assert.equal(util.inspect({'a': {'b': { 'c': { 'd': 2 }}}}),
+  '{ a: { b: { c: [Object] } } }');
+assert.equal(util.inspect({'a': {'b': { 'c': { 'd': 2 }}}}, false, null),
+  '{ a: { b: { c: { d: 2 } } } }');
+assert.equal(util.inspect([1, 2, 3], true), '[ 1, 2, 3, [length]: 3 ]');
+assert.equal(util.inspect({'a': {'b': { 'c': 2}}}, false, 0),
+  '{ a: [Object] }');
+assert.equal(util.inspect({'a': {'b': { 'c': 2}}}, false, 1),
+  '{ a: { b: [Object] } }');
+assert.equal(util.inspect(Object.create({},
+  {visible: {value: 1, enumerable: true}, hidden: {value: 2}})),
+  '{ visible: 1 }'
+);
+
+// Due to the hash seed randomization it's not deterministic the order that
+// the following ways this hash is displayed.
+// See http://codereview.chromium.org/9124004/
+
+var out = util.inspect(Object.create({},
+    {visible: {value: 1, enumerable: true}, hidden: {value: 2}}), true);
+if (out !== '{ [hidden]: 2, visible: 1 }' &&
+    out !== '{ visible: 1, [hidden]: 2 }') {
+  assert.ok(false);
+}
+
+
+// Objects without prototype
+var out = util.inspect(Object.create(null,
+    { name: {value: 'Tim', enumerable: true},
+      hidden: {value: 'secret'}}), true);
+if (out !== "{ [hidden]: 'secret', name: 'Tim' }" &&
+    out !== "{ name: 'Tim', [hidden]: 'secret' }") {
+  assert(false);
+}
+
+
+assert.equal(
+  util.inspect(Object.create(null,
+    {name: {value: 'Tim', enumerable: true},
+      hidden: {value: 'secret'}})),
+  '{ name: \'Tim\' }'
+);
+
+
+// Dynamic properties
+assert.equal(util.inspect({get readonly() {}}),
+  '{ readonly: [Getter] }');
+
+assert.equal(util.inspect({get readwrite() {}, set readwrite(val) {}}),
+  '{ readwrite: [Getter/Setter] }');
+
+assert.equal(util.inspect({set writeonly(val) {}}),
+  '{ writeonly: [Setter] }');
+
+var value = {};
+value['a'] = value;
+assert.equal(util.inspect(value), '{ a: [Circular] }');
+
+// Array with dynamic properties
+value = [1, 2, 3];
+value.__defineGetter__('growingLength', function() {
+  this.push(true); return this.length;
+});
+assert.equal(util.inspect(value), '[ 1, 2, 3, growingLength: [Getter] ]');
+
+// Function with properties
+value = function() {};
+value.aprop = 42;
+assert.equal(util.inspect(value), '{ [Function] aprop: 42 }');
+
+// Regular expressions with properties
+value = /123/ig;
+value.aprop = 42;
+assert.equal(util.inspect(value), '{ /123/gi aprop: 42 }');
+
+// Dates with properties
+value = new Date('Sun, 14 Feb 2010 11:48:40 GMT');
+value.aprop = 42;
+assert.equal(util.inspect(value), '{ Sun, 14 Feb 2010 11:48:40 GMT aprop: 42 }'
+);
+
 // test the internal isDate implementation
 var Date2 = require('vm').runInNewContext('Date');
 var d = new Date2();