sproutit-narwhal 0.1.106

data/tests/util/array/is-arguments.js

@@ -0,0 +1,29 @@
+
+var assert = require("test/assert");
+var util = require("util");
+
+exports.testArray = function () {
+    assert.isFalse(util.isArguments([]));
+    assert.isFalse(util.isArguments([1, 2, 3]));
+};
+
+exports.testArguments = function () {
+    assert.isTrue(util.isArguments(arguments));
+};
+
+exports.testArgumentsReturned = function () {
+    assert.isTrue(util.isArguments((function () {
+        return arguments;
+    })()));
+};
+
+exports.testNegativeDuckType = function () {
+    assert.isFalse(util.isArguments({
+        "length": 1,
+        "0": 1
+    }));
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/util/array/is-array-like.js

@@ -0,0 +1,29 @@
+
+var assert = require("test/assert");
+var util = require("util");
+
+exports.testArray = function () {
+    assert.isTrue(util.isArrayLike([]));
+    assert.isTrue(util.isArrayLike([1, 2, 3]));
+};
+
+exports.testArguments = function () {
+    assert.isTrue(util.isArrayLike(arguments));
+};
+
+exports.testArgumentsReturned = function () {
+    assert.isTrue(util.isArrayLike((function () {
+        return arguments;
+    })()));
+};
+
+exports.testNegativeDuckType = function () {
+    assert.isFalse(util.isArrayLike({
+        "length": 1,
+        "0": 1
+    }));
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/util/case.js

@@ -0,0 +1,9 @@
+
+var assert = require("test/assert");
+var util = require("util");
+
+/* upper, lower, camel, title, splitName, joinName */
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/util/collection.js

@@ -0,0 +1,104 @@
+
+var assert = require("test/assert");
+var util = require("util");
+
+/*
+exports.testKeys = function () {
+};
+
+exports.testValues = function () {
+};
+
+exports.testItems = function () {
+};
+
+exports.testLen = function () {
+};
+
+exports.testHas = function () {
+};
+
+*/
+
+exports.testGetObject = function () {
+    assert.eq(10, util.get({'a': 10}, 'a'));
+};
+
+exports.testGetObjectKeyError = function () {
+    assert.throwsError(function () {
+        util.get({'a': 10}, 'b');
+    });
+};
+
+exports.testGetObjectDefault = function () {
+    assert.eq(20, util.get({'a': 10}, 'b', 20));
+};
+
+exports.testGetNonPolymorphic = function () {
+    var foo = {"get": 10};
+    assert.eq(10, util.get(foo, "get"));
+};
+
+exports.testGetPolymorphic = function () {
+    var foo = Object.create({"get": function () {
+        return 10;
+    }});
+    assert.eq(10, util.get(foo, "get"));
+};
+
+exports.testGetArray = function () {
+    assert.eq(1, util.get([1,2,3], 0));
+};
+
+exports.testGetArrayKeyError = function () {
+    assert.throwsError(function () {
+        util.get([1,2,3], 4);
+    });
+};
+
+exports.testGetArrayDefault = function () {
+    assert.eq(3, util.get([1,2,3], 4, 3));
+};
+
+/*
+exports.testGetArrayNeg = function () {
+    assert.eq(3, util.get([1,2,3], -1));
+};
+*/
+
+exports.testGetString = function () {
+    assert.eq('a', util.get('abc', 0));
+    assert.eq('b', util.get('abc', 1));
+};
+
+/*
+
+exports.testGetStringNeg = function () {
+    assert.eq('c', util.get('abc', -1));
+};
+
+exports.testSet = function () {
+};
+
+exports.testGetset = function () {
+};
+
+exports.testDel = function () {
+};
+
+exports.testCut = function () {
+};
+
+exports.testPut = function () {
+};
+
+exports.testUpdate = function () {
+};
+
+exports.testComplete = function () {
+};
+*/
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/util/eq.js

@@ -0,0 +1,57 @@
+
+var assert = require("test/assert");
+var util = require("util");
+
+exports.testUndefined = function () {
+    assert.isTrue(util.eq(undefined, undefined));
+};
+
+exports.testNull = function () {
+    assert.isTrue(util.eq(null, null));
+};
+
+exports.testNumber = function () {
+    assert.isTrue(util.eq(1, 1));
+};
+
+exports.testNaN = function () {
+    assert.isFalse(util.eq(NaN, NaN));
+};
+
+exports.testObject = function () {
+    assert.isTrue(util.eq({"a": 10}, {"a": 10}));
+};
+
+exports.testObjectNegativePrototype = function () {
+    function Type() {};
+    Type.prototype.a = 10;
+    var object = new Type();
+    assert.isFalse(util.eq({"a": 10}, object));
+};
+
+exports.testArray = function () {
+    assert.isTrue(util.eq([1,2,3], [1,2,3]));
+};
+
+exports.testArguments = function () {
+    var args = (function () {return arguments})(1, 2, 3);
+    assert.isTrue(util.eq([1, 2, 3], args));
+};
+
+exports.testPolymorphic = function () {
+    function Type() {};
+    Type.prototype.eq = function () {
+        return true;
+    };
+    assert.isTrue(util.eq(new Type(), [1,2,3]));
+};
+
+exports.testCurry = function () {
+    assert.isTrue(util.eq()());
+    assert.isTrue(util.eq(10)(10));
+    assert.isFalse(util.eq(10)(20));
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/util/expand.js

@@ -0,0 +1,45 @@
+
+var assert = require("test/assert");
+var util = require("util");
+
+var expandOracle = function (line, tabLength, initial) {
+    if (!tabLength) tabLength = 4;
+    if (initial === undefined) initial = 0;
+    var at = initial;
+    var result = '';
+    for (var i = 0; i < line.length; i++) {
+        var c = line.charAt(i);
+        if (c == "\n") {
+            at = initial;
+            result += c;
+        } else if (c == "\r") {
+            result += c;
+        } else if (c == "\t") {
+            var next = (at & ~(tabLength - 1)) + tabLength;
+            result += util.mul(' ', next - at);
+            at = next;
+        } else {
+            at++;
+            result += c;
+        }
+    }
+    return result;
+};
+
+var inputs = [
+    "\t",
+    " \t",
+    "  \t",
+    "   \t",
+    "\t\t"
+];
+
+util.forEach(inputs, function (input) {
+    exports['test ' + util.repr(input)] = function () {
+        assert.eq(expandOracle(input), util.expand(input));
+    };
+});
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/util/object.js

@@ -0,0 +1,125 @@
+
+var assert = require("test/assert");
+var util = require("util");
+
+exports.testObject = function () {
+    assert.eq({"a": 10}, util.object({"a": 10}));
+};
+
+exports.testObjectNonInheritance = function () {
+    var Foo = function () {
+        this.a = 10;
+    };
+    Foo.prototype.bar = 10;
+    assert.eq({"a": 10}, util.object(new Foo()));
+};
+
+exports.testObjectArray = function () {
+    assert.eq({"a": 10, "b": 20}, util.object([["a", 10], ["b", 20]]));
+    assert.eq({"1": 10, "2": 20}, util.object([[1, 10], [2, 20]]));
+};
+
+exports.testObjectPolymorphism = function () {
+    var Foo = function () {
+    };
+    Foo.prototype.toObject = function () {
+        return {"a": 10};
+    };
+    assert.eq({"a": 10}, util.object(new Foo()));
+};
+
+exports.testObjectNonPolymorphism = function () {
+    assert.eq({"object": 10}, util.object({"object": 10}));
+};
+
+exports.testCopyShallow = function () {
+    var foo = {"a": 10};
+    var original = {"foo": foo};
+    var copy = util.copy(original);
+    assert.eq(original, copy);
+    assert.isFalse(util.is(original, copy));
+    assert.isTrue(util.is(original.foo, copy.foo));
+    foo.a = 20;
+    assert.eq(20, original.foo.a);
+    assert.eq(20, copy.foo.a);
+};
+
+exports.testDeepCopy = function () {
+    var foo = {"a": 10};
+    var original = {"foo": foo};
+    var copy = util.deepCopy(original);
+    assert.eq(original, copy);
+    assert.isFalse(util.is(original, copy));
+    assert.isFalse(util.is(original.foo, copy.foo));
+    foo.a = 20;
+    assert.eq(20, original.foo.a);
+    assert.eq(10, copy.foo.a);
+};
+
+exports.testEqCompleteness = function () {
+    assert.isFalse(util.object.eq({"a": 10, "b": 20}, {"b": 20}));
+    assert.isFalse(util.object.eq({"a": 10, "b": 20}, {"a": 10}));
+    assert.isFalse(util.object.eq({"a": 10, "b": 20}, {"a": 10, "b": 20, "c": 30}));
+};
+
+exports.testEqOrderAgnostic = function () {
+    assert.isTrue(util.object.eq({"a": 10, "b": 20}, {"b": 20, "a": 10}));
+};
+
+exports.testLen = function () {
+    assert.eq(0, util.len({}));
+    assert.eq(1, util.len({"a": 10}));
+    assert.eq(2, util.len({"a": 10, "b": 20}));
+    var Foo = function () {
+        // len not in prototype, therefore not used by util.len
+        this.len = function () {
+            return 0;
+        };
+        this.a = 10;
+    };
+    Foo.prototype.b = 20;
+    assert.eq(2, util.len(new Foo()));
+};
+
+exports.testHas = function () {
+    assert.isTrue(util.has({"a": 10}, "a"));
+    assert.isFalse(util.has({"b": 10}, "a"));
+};
+
+exports.testKeys = function () {
+    assert.eq(["a", "b"], util.keys({"a": 10, "b": 20}));
+    assert.eq(["b", "a"], util.keys({"b": 20, "a": 10}));
+    var Foo = function () {
+    };
+    Foo.prototype.c = 30;
+    assert.eq([], util.keys(new Foo()));
+};
+
+exports.testValues = function () {
+    assert.eq([10, 20], util.values({"a": 10, "b": 20}));
+    assert.eq([20, 10], util.values({"b": 20, "a": 10}));
+};
+
+exports.testItems = function () {
+    assert.eq([["a", 10], ["b", 20]], util.items({"a": 10, "b": 20}));
+    assert.eq([["b", 20], ["a", 10]], util.items({"b": 20, "a": 10}));
+};
+
+exports.testUpdate = function () {
+    var object = {"a": 10, "b": 20};
+    util.update(object, {"b": 30, "c": 40});
+    assert.eq({"a": 10, "b": 30, "c": 40}, object);
+};
+
+exports.testComplete = function () {
+    var object = {"a": 10, "b": 20};
+    util.complete(object, {"b": 30, "c": 40});
+    assert.eq({"a": 10, "b": 20, "c": 40}, object);
+};
+
+exports.testRepr = function () {
+    assert.eq('{"a": 10}', util.repr({"a": 10}));
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));

data/tests/util/operator.js

@@ -0,0 +1,25 @@
+
+var assert = require('test/assert');
+var util = require("util");
+
+exports.testNegative = function () {
+    var foo = {"repr": 10};
+    assert.eq('{"repr": 10}', util.repr(foo));
+};
+
+exports.testPositive = function () {
+    var Foo = function () {
+    };
+    Foo.prototype.repr = function () {
+        return "Foo()";
+    };
+    assert.eq("Foo()", util.repr(new Foo()));
+};
+
+exports.testCurry = function () {
+    var lt10 = util.lt(10);
+    assert.isTrue(lt10(5));
+};
+
+if (module.id == require.main)
+    require("os").exit(require("test/runner").run(exports));

data/tests/util/range.js

@@ -0,0 +1,19 @@
+
+var assert = require("test/assert");
+var util = require("util");
+
+exports.testRange1 = function () {
+    assert.eq([0, 1, 2], util.range(3));
+};
+
+exports.testRange2 = function () {
+    assert.eq([1, 2, 3], util.range(1, 4));
+};
+
+exports.testRange3 = function () {
+    assert.eq([2, 4, 6], util.range(2, 8, 2));
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+