sproutit-narwhal 0.1.106

data/tests/query-string.js

@@ -0,0 +1,87 @@
+var QueryString = require("querystring");
+var assert = require("test/assert");
+
+
+exports.testUnescape = function() {
+    assert.isEqual("fo<o>bar", QueryString.unescape("fo%3Co%3Ebar"));
+    assert.isEqual("a space", QueryString.unescape("a%20space"));
+    assert.isEqual("a+space", QueryString.unescape("a+space"));
+    assert.isEqual("a+space", QueryString.unescape("a+space", false));
+    assert.isEqual("a space", QueryString.unescape("a+space", true));
+    assert.isEqual("q1!2\"'w$5&7/z8)?\\", QueryString.unescape("q1%212%22%27w%245%267%2Fz8%29%3F%5C"));
+}
+
+// [ wonkyQS, canonicalQS, obj ]
+var qsTestCases = [
+    ["foo=bar",  "foo=bar", {"foo" : "bar"}],
+    ["foo=bar&foo=quux", "foo%5B%5D=bar&foo%5B%5D=quux", {"foo" : ["bar", "quux"]}],
+    ["foo=1&bar=2", "foo=1&bar=2", {"foo" : 1, "bar" : 2}],
+    ["my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F", "my%20weird%20field=q1!2%22'w%245%267%2Fz8)%3F", {"my weird field" : "q1!2\"'w$5&7/z8)?" }],
+    ["foo%3Dbaz=bar", "foo%3Dbaz=bar", {"foo=baz" : "bar"}],
+    ["foo=baz=bar", "foo=baz%3Dbar", {"foo" : "baz=bar"}],
+    ["str=foo&arr[]=1&arr[]=2&arr[]=3&obj[a]=bar&obj[b][]=4&obj[b][]=5&obj[b][]=6&obj[b][]=&obj[c][]=4&obj[c][]=5&obj[c][][somestr]=baz&obj[objobj][objobjstr]=blerg&somenull=&undef=", "str=foo&arr%5B%5D=1&arr%5B%5D=2&arr%5B%5D=3&obj%5Ba%5D=bar&obj%5Bb%5D%5B%5D=4&obj%5Bb%5D%5B%5D=5&obj%5Bb%5D%5B%5D=6&obj%5Bb%5D%5B%5D=&obj%5Bc%5D%5B%5D=4&obj%5Bc%5D%5B%5D=5&obj%5Bc%5D%5B%5D%5Bsomestr%5D=baz&obj%5Bobjobj%5D%5Bobjobjstr%5D=blerg&somenull=&undef=", {
+        "str":"foo",
+        "arr":[1,2,3],
+        "obj":{
+            "a":"bar",
+            "b":[4,5,6,""],
+            "c":[4,5,{"somestr":"baz"}],
+            "objobj":{"objobjstr":"blerg"}
+        },
+        "somenull":"",
+        "undef":""
+    }],
+    ["foo[bar][bla]=baz&foo[bar][bla]=blo", "foo%5Bbar%5D%5Bbla%5D%5B%5D=baz&foo%5Bbar%5D%5Bbla%5D%5B%5D=blo", {"foo":{"bar":{"bla":["baz","blo"]}}}],
+    ["foo[bar][][bla]=baz&foo[bar][][bla]=blo", "foo%5Bbar%5D%5B%5D%5Bbla%5D=baz&foo%5Bbar%5D%5B%5D%5Bbla%5D=blo", {"foo":{"bar":[{"bla":"baz"},{"bla":"blo"}]}}],
+    ["foo[bar][bla][]=baz&foo[bar][bla][]=blo", "foo%5Bbar%5D%5Bbla%5D%5B%5D=baz&foo%5Bbar%5D%5Bbla%5D%5B%5D=blo", {"foo":{"bar":{"bla":["baz","blo"]}}}],
+    [" foo = bar ", "foo=bar", {"foo":"bar"}]
+];
+var qsColonTestCases = [
+    ["foo:bar", "foo:bar", {"foo":"bar"}],
+    ["foo:bar;foo:quux", "foo%5B%5D:bar;foo%5B%5D:quux", {"foo" : ["bar", "quux"]}],
+    ["foo:1&bar:2;baz:quux", "foo:1%26bar%3A2;baz:quux", {"foo":"1&bar:2", "baz":"quux"}],
+    ["foo%3Abaz:bar", "foo%3Abaz:bar", {"foo:baz":"bar"}],
+    ["foo:baz:bar", "foo:baz%3Abar", {"foo":"baz:bar"}]
+];
+
+var extendedFunction = function () {};
+extendedFunction.prototype = {a:"b"};
+var qsWeirdObjects = [ //{
+    [ {regexp:/./g}, "regexp=", {"regexp":""} ],
+    [ {regexp: new RegExp(".", "g")}, "regexp=", {"regexp":""} ],
+    [ {fn:function () {}}, "fn=", {"fn":""}],
+    [ {fn:new Function("")}, "fn=", {"fn":""} ],
+    [ {math:Math}, "math=", {"math":""} ],
+    [ {e:extendedFunction}, "e=", {"e":""} ],
+    [ {d:new Date()}, "d=", {"d":""} ],
+    [ {d:Date}, "d=", {"d":""} ],
+    [ {f:new Boolean(false), t:new Boolean(true)}, "f=0&t=1", {"f":0, "t":1} ],
+    [ {f:false, t:true}, "f=0&t=1", {"f":0, "t":1} ],
+]; //}
+
+exports.testParseQuery = function() {
+    qsTestCases.forEach(function (testCase) {
+        assert.isSame(testCase[2], QueryString.parseQuery(testCase[0]));
+    });
+    qsColonTestCases.forEach(function (testCase) {
+        assert.isSame(testCase[2], QueryString.parseQuery(testCase[0], ";", ":"))
+    });
+    qsWeirdObjects.forEach(function (testCase) {
+        assert.isSame(testCase[2], QueryString.parseQuery(testCase[1]));
+    });
+}
+/*
+exports.testToQueryString = function () {
+    qsTestCases.forEach(function (testCase) {
+        assert.isSame(testCase[1], QueryString.toQueryString(testCase[2]));
+    });
+    qsColonTestCases.forEach(function (testCase) {
+        assert.isSame(testCase[1], QueryString.toQueryString(testCase[2], ";", ":"));
+    });
+    qsWeirdObjects.forEach(function (testCase) {
+        assert.isSame(testCase[1], QueryString.toQueryString(testCase[0]));
+    });
+};
+*/
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));

data/tests/sandbox/byte-io.js

@@ -0,0 +1,20 @@
+
+var fs = require('file');
+var file = fs.open(fs.resolve(module.path, 'utf-8.js'), 'rb');
+var content = file.read();
+print(typeof content);
+print(content.length);
+print('');
+
+var file = fs.open(fs.resolve(module.path, 'utf-8.js'), 'rt', {'charset': 'utf-8'});
+var content = file.read();
+print(typeof content);
+print(content.length);
+print('');
+
+var file = fs.open(fs.resolve(module.path, 'utf-8.js'), 'r');
+var content = file.read();
+print(typeof content);
+print(content.length);
+print('');
+

data/tests/sandbox/fileName.js

@@ -0,0 +1,3 @@
+
+print(module.path);
+

data/tests/sandbox/reload.js

@@ -0,0 +1,79 @@
+
+var util = require("util");
+var assert = require("test/assert");
+var args = require("args");
+var sandboxing = require("sandbox");
+var os = require("os");
+
+exports.test = function () {
+
+    var accumulator = [];
+    var subprint = function (text) {
+        accumulator.push(text);
+    };
+
+    var supersandbox = sandboxing.Sandbox({
+        'loader': require.loader,
+        'print': subprint
+    });
+
+    var path = system.fs.path(module.path).resolve('./foo.js');
+    var id = path.toString();
+    var subsandboxing = supersandbox('sandbox');
+
+    var subloader = subsandboxing.Loader({
+        'paths': require.loader.paths,
+        'debug': true
+    });
+
+    var sandbox1 = subsandboxing.Sandbox({
+        'loader': subloader,
+        'print': subprint
+    });
+
+    path.touch();
+    os.sleep(1);
+    assert.eq(0, accumulator.length);
+
+    sandbox1(id);
+    // must be loaded
+    assert.eq(1, accumulator.length, '1.1');
+
+    sandbox1(id);
+    // must be cached
+    assert.eq(1, accumulator.length, '1.2');
+
+    var sandbox2 = subsandboxing.Sandbox({
+        'loader': subloader,
+        'print': subprint
+    });
+
+    sandbox2(id);
+    // must still be cached in the loader
+    assert.eq(1, accumulator.length, '2.1');
+    path.touch();
+    os.sleep(1);
+    // still cached, although it has changed
+    assert.eq(1, accumulator.length, '2.2');
+    sandbox2(id);
+    // still cached, although it has changed
+    assert.eq(1, accumulator.length, '2.3');
+
+    var sandbox3 = subsandboxing.Sandbox({
+        'loader': subloader,
+        'print': subprint
+    });
+
+    assert.eq(1, accumulator.length, '3.1');
+    // cached, but changed
+    sandbox3(id);
+    // reloaded
+    assert.eq(2, accumulator.length, '3.2');
+    sandbox3(id);
+    assert.eq(2, accumulator.length, '3.3');
+
+}
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/string.js

@@ -0,0 +1,35 @@
+var assert = require("test/assert");
+
+exports.testSqueze = function() {
+    assert.isEqual("", "".squeeze());
+    assert.isEqual("ok", "ok".squeeze());
+    assert.isEqual("it works", "it  works".squeeze());
+    assert.isEqual("start", "ssstart".squeeze());
+    assert.isEqual("end\n", "end\n\n\n".squeeze());
+};
+
+exports.testChomp = function() {
+    assert.isEqual("hello", "hello".chomp());
+    assert.isEqual("hello", "hello\n".chomp());
+    assert.isEqual("hello", "hello\r\n".chomp());
+    assert.isEqual("hello", "hello\n\r".chomp()); // FIXME: should fail!!! (== hello\n)
+    assert.isEqual("hello", "hello\r".chomp());
+    assert.isEqual("hello \n there", "hello \n there".chomp());
+    assert.isEqual("he", "hello".chomp("llo"));
+};
+
+exports.testBegins = function() {
+    assert.isTrue("Hello".begins("H"));
+    assert.isTrue("Hello".begins("Hell"));
+    assert.isTrue("Hello".begins("Hello"));
+};
+
+exports.testEnds = function() {
+    assert.isTrue("Hello".ends("o"));
+    assert.isTrue("Hello".ends("llo"));
+    assert.isTrue("Hello".ends("Hello"));
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/uri.js

@@ -0,0 +1,41 @@
+var assert = require("test/assert");
+var util = require("util");
+
+var uri = require("uri");
+var URI = uri.URI;
+
+exports.testConstructor = function() {
+    var uri = new URI("http://www.narwhaljs.org/blog/categories?id=news");
+
+    assert.isEqual("http", uri.scheme);
+    assert.isEqual("www.narwhaljs.org", uri.authority);
+    assert.isEqual("/blog/categories", uri.path);
+    assert.isEqual("id=news", uri.query);
+    assert.isNull(uri.fragment);
+}
+
+exports.testToString = function() {
+    var uri = new URI("http://www.narwhaljs.org/blog/categories?id=news");
+    assert.isEqual("http://www.narwhaljs.org/blog/categories?id=news", uri.toString());
+}
+
+util.forEachApply([
+    ["/foo/bar/baz", "/foo/bar/quux", "quux"],
+    ["/foo/bar/baz", "/foo/bar/quux/asdf", "quux/asdf"],
+    ["/foo/bar/baz", "/foo/bar/quux/baz", "quux/baz"],
+    ["/foo/bar/baz", "/foo/quux/baz", "../quux/baz"]
+], function (from, to, expected) {
+    exports[
+        'testRelative ' +
+        'from: ' + util.repr(from) + ' ' +
+        'to: ' + util.repr(to) + ' ' +
+        'is: ' + util.repr(expected)
+    ] = function () {
+        var actual = uri.relative(from, to);
+        assert.eq(expected, actual);
+    };
+});
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/util/all-tests.js

@@ -0,0 +1,79 @@
+
+var assert = require("test/assert");
+var util = require("util");
+
+exports.testOperator = require("./operator");
+exports.testObject = require("./object");
+exports.testArray = require("./array");
+exports.testCollection = require("./collection");
+exports.testString = require("./string");
+exports.testRange = require("./range");
+exports.testCase = require("./case");
+exports.testUnique = require("./unique");
+
+exports.testNo = function () {
+    assert.isTrue(util.no(undefined));
+    assert.isTrue(util.no(null));
+    assert.isFalse(util.no(0));
+    assert.isFalse(util.no(false));
+};
+
+exports.testApply = function () {
+    // XXX
+};
+
+exports.testCopyUndefined = function () {
+    assert.eq(undefined, util.copy(undefined));
+};
+
+exports.testCopyNull = function () {
+    assert.eq(null, util.copy(null));
+};
+
+exports.testCopyNumber = function () {
+    assert.eq(1, util.copy(1));
+};
+
+exports.testCopyDate = function () {
+    var date = new Date();
+    assert.eq(date, util.copy(date));
+};
+
+/*
+exports.testDeepCopy = function () {
+};
+*/
+
+exports.testRepr = require("./repr");
+
+/*
+exports.testIs = function () {
+};
+
+*/
+
+exports.testEq = require("./eq");
+
+/*
+exports.testNe = function () {
+};
+
+exports.testLt = function () {
+};
+
+exports.testGt = function () {
+};
+
+exports.testLe = function () {
+};
+
+exports.testGe = function () {
+};
+
+exports.testCompare = function () {
+};
+*/
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/util/array.js

@@ -0,0 +1,207 @@
+
+var assert = require("test/assert");
+var util = require("util");
+
+exports.testArray = function () {
+    assert.eq([1,2,3], util.array([1,2,3]));
+};
+
+exports.testArrayShallow = function () {
+    var foo = {"a": 10};
+    var copy = util.array([foo]);
+    assert.eq([{"a": 10}], copy);
+    foo.a = 20;
+    assert.eq([{"a": 20}], copy);
+};
+
+exports.testArrayObject = function () {
+    assert.eq([["a", 10], ["b", 20]], util.array({"a": 10, "b": 20}));
+};
+
+exports.testArrayPolymorphicToArray = function () {
+    var Type = function () {
+    };
+    Type.prototype.toArray = function () {
+        return [1];
+    };
+    assert.eq([1], util.array(new Type()));
+};
+
+exports.testArrayPolymorphicToArrayNegative = function () {
+    var toArray = function () {};
+    assert.eq([["toArray", toArray]], util.array({
+        "toArray": toArray
+    }));
+};
+
+exports.testArrayPolymorphicForEach = function () {
+    var Type = function () {
+    };
+    Type.prototype.forEach = function (block) {
+        block(1);
+    };
+    assert.eq([1], util.array(new Type()));
+};
+
+exports.testArrayPolymorphicForEachNegative = function () {
+    var forEach = function () {};
+    assert.eq([["forEach", forEach]], util.array({
+        "forEach": forEach
+    }));
+};
+
+exports.testIsArguments = require("./array/is-arguments");
+exports.testIsArrayLike = require("./array/is-array-like");
+
+exports.testCopyShallow = function () {
+    var foo = {"a": 10};
+    var copy = util.copy([foo]);
+    assert.eq([{"a": 10}], copy);
+    foo.a = 20;
+    assert.eq([{"a": 20}], copy);
+};
+
+exports.testDeepCopy = function () {
+    var foo = {"a": 10};
+    var original = [foo];
+    var copy = util.deepCopy(original);
+    assert.eq([{"a": 10}], copy);
+    foo.a = 20;
+    assert.eq([{"a": 20}], original);
+    assert.eq([{"a": 10}], copy);
+};
+
+exports.testLen = function () {
+    assert.eq(0, util.len([]));
+    assert.eq(1, util.len([0]));
+    assert.eq(2, util.len([0, 1]));
+};
+
+exports.testLenLiar = function () {
+    assert.eq(1, util.len({'length': 10}));
+    assert.eq(10, util.array.len({'length': 10}));
+};
+
+exports.testHasPositive = function () {
+    assert.isTrue(util.has([1,2,3], 2));
+};
+
+exports.testHasNegative = function () {
+    assert.isFalse(util.has([1,2,3], 4));
+};
+
+exports.testPut = function () {
+    var original = [1, 2, 3];
+    util.put(original, 0, 0);
+    assert.eq([0, 1, 2, 3], original);
+};
+
+exports.testDel = function () {
+    var original = [1, 2, 3];
+    util.del(original, 1);
+    assert.eq([1, 3], original);
+};
+
+exports.testDelRange = function () {
+    var original = [1, 2, 3, 4];
+    util.del(original, 1, 3);
+    assert.eq([1, 4], original);
+};
+
+exports.testEq = function () {
+    var foo = {}, bar = {}, baz = {};
+    assert.isTrue(util.eq([foo, bar, baz], [foo, bar, baz]));
+    assert.isTrue(util.eq([baz, bar, foo], [foo, bar, baz]));
+};
+
+exports.testLt = function () {
+    assert.isTrue(util.lt([10, 10, 0], [10, 10, 1]));
+};
+
+exports.testLtRagged = function () {
+    assert.isTrue(util.lt([10, 10], [10, 10, 10]));
+};
+
+exports.testLtLexicographic = function () {
+    assert.isTrue(util.lt(['1'], ['10']));
+};
+
+exports.testRepr = function () {
+    assert.eq('[1, 2, 3]', util.repr([1,2,3]));
+    assert.eq('["1"]', util.repr(["1"]));
+};
+
+/*
+exports.testForEach = function () {
+};
+
+exports.testForEachApply = function () {
+};
+*/
+
+exports.testForEachApplyPolymorphicForEach = function () {
+    var Type = function () {
+    };
+    Type.prototype.forEach = function (block) {
+        block([1]);
+    };
+    var collect = [];
+    util.forEachApply(new Type(), function (n) {
+        collect.push(n);
+    });
+    assert.eq([1], collect);
+};
+
+/*
+exports.testMap = function () {
+};
+
+exports.testMapApply = function () {
+};
+
+exports.testEvery = function () {
+};
+
+exports.testSome = function () {
+};
+
+exports.testAll = function () {
+};
+
+exports.testAny = function () {
+};
+
+exports.testReduce = function () {
+};
+
+exports.testReduceRight = function () {
+};
+*/
+
+exports.testZip = function () {
+    assert.eq([[1,"a"],[2,"b"]], util.zip([1,2], "abc"));
+};
+
+/*
+exports.testTranspose = function () {
+};
+
+exports.testEnumerate = function () {
+};
+
+exports.testRange = function () {
+};
+
+exports.testBy = function () {
+};
+
+exports.testSort = function () {
+};
+
+exports.testSorted = function () {
+};
+*/
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+