sproutit-narwhal 0.1.106

data/tests/file/match.js

@@ -0,0 +1,102 @@
+
+var assert = require("test/assert");
+var file = require("file");
+var util = require("util");
+
+util.forEachApply([
+    ["", "", true],
+    ["a", "a", true],
+    ["?", "a", true],
+    ["?", "b", true],
+    ["?", "", false],
+    ["?", "ab", false],
+    ["??", "ab", true],
+    ["*", "", true],
+    ["*", "a", true],
+    ["*", "ab", true],
+    ["*.js", "ab", false],
+    ["*.js", "ab.js", true],
+    ["?git*", ".git", true],
+    ["?git*", ".gitignore", true],
+    ["*", "a/b", false],
+    ["/*", "", false],
+    ["/**", "", true],
+    ["[ab]", "a", true],
+    ["[ab]", "b", true],
+    ["[ab]", "c", false],
+    ["*.c{,pp,xx}", "a.c", true],
+    ["*.c{,pp,xx}", "a.cpp", true],
+    ["*.c{,pp,xx}", "a.cxx", true],
+    ["*.c{,pp,xx}", "a.h", false],
+    // ["a{b{c}}", "abc", true], // needs to go context free
+    // ["a{/b/{c}}", "a/b/c", true],
+    ["/a", "a", false],
+    ["/a", "/a", true],
+    ["...", ".", true],
+    [".../a", "./a", true],
+    [".../a", "../a", true],
+    [".../a", "../../a", true],
+    ["[*]", "*", true],
+    [".", "*", false],
+    ["?", "*", true],
+    ["$", "$", true],
+    ["^", "^", true],
+    [".", ".", true],
+    ["/**/d.js", "/a/b/c/d.js", true],
+    ["/b/**/d.js", "/a/b/c/d.js", false],
+    ["/a/**/b.js", "/a/b.js", true],
+    ["/**/...", "/", true],
+
+    // need ellipsis support for absolute paths ,
+    //   and ** interactions
+
+    // ["/a/b/c/...", "/a/b/c/", true],
+    // ["/a/b/c/...", "/a/b/", true],
+    // ["/a/b/c/...", "/a/", true],
+    // ["/a/b/c/...", "/", true],
+    // ["a/b/c/...", "../..", true],
+    // ["a/b/c/...", "a/b/c", true],
+    // ["a/b/c/...", "a/b/c/d", false],
+
+    // ["/prefix/**/postfix", "/prefix/a/postfix", true],
+    // ["/prefix/**/postfix", "/prefix/postfix", true],
+    // ["/prefix/**/postfix", "/prefix/a", false],
+    // ["/prefix/**/postfix", "/postfix", false],
+
+    // ["/prefix/.../postfix", "/prefix/postfix", true],
+    // ["/prefix/.../postfix", "/postfix", true],
+    // ["/prefix/.../postfix", "/prefix/a/postfix", false],
+    // ["/prefix/.../postfix", "/", false],
+
+    // ["/pre/**/in/.../post", "/pre/in/no/post", true],
+    // ["/pre/**/in/.../post", "/pre/in/post", true],
+    // ["/pre/**/in/.../post", "/pre/no/post", true],
+    // ["/pre/**/in/.../post", "/pre/post", true],
+    // ["/pre/**/in/.../post", "/post", true],
+
+    // ["/pre/**/in/.../post", "/pre/in/no", false],
+    // ["/pre/**/in/.../post", "/pre", false],
+    // ["/pre/**/in/.../post", "/no/post", false],
+    // ["/pre/**/in/.../post", "/", false],
+
+    // ["/pre/.../in/**/post", "/pre/in/post", true],
+    // ["/pre/.../in/**/post", "/pre/in/no/post", true],
+    // ["/pre/.../in/**/post", "/in/post", true],
+    // ["/pre/.../in/**/post", "/in/no/post", true],
+
+    // ["/pre/.../in/**/post", "/post", false],
+    // ["/pre/.../in/**/post", "/no/in/post", false],
+    // ["/pre/.../in/**/post", "/pre/in/no", false],
+    // ["/pre/.../in/**/post", "/in/no", false]
+
+], function (pattern, path, expected) {
+    exports['test ' + util.repr(arguments)] = function () {
+        //if (file.match(path, pattern) != expected)
+        //    print('pattern: ' + util.repr(file.pattern));
+        assert.eq(expected, file.match(path, pattern));
+    };
+});
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/global.js

@@ -0,0 +1,6 @@
+
+exports.testArray = require("./global/array");
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/global/array.js

@@ -0,0 +1,19 @@
+
+var assert = require('test/assert');
+
+exports.testIsArray = function () {
+    assert.isTrue(Array.isArray([]));
+};
+
+exports.testIsArrayNegativeArguments = function () {
+    var args = (function () {return arguments})();
+    assert.isFalse(Array.isArray(args));
+};
+
+exports.testIsArrayNegativeObject = function () {
+    assert.isFalse(Array.isArray({"length": 0}));
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/hashes.js

@@ -0,0 +1,94 @@
+
+var assert = require('test/assert');
+var struct = require('struct');
+var util = require('util');
+
+var raw = "Hello, World!";
+var md4 = require('md4');
+var md5 = require('md5');
+var sha = require('sha');
+var sha256 = require('sha256');
+var crc32 = require('crc32');
+
+exports.testMd4 = function () {
+    assert.eq(md4.hash("test hash").toString(16), "549089516e75bd13c41ff098fbb58d5e");
+    assert.eq(md4.hash("abc").toString(16), "a448017aaf21d8525fc10ae87aa6729d");
+};
+
+exports.testMd5 = function () {
+    assert.eq(md5.hash(raw).toString(16), "65a8e27d8879283831b664bd8b7f0ad4", 'md5');
+    assert.eq(md5.hash("message digest").toString(16), "f96b697d7cb7938d525a2f31aaf161d0");
+    assert.eq(md5.hash("abc").toString(16), "900150983cd24fb0d6963f7d28e17f72");
+};
+
+exports.testSha = function () {
+    assert.eq(sha.hash(raw).toString(16), "0a0a9f2a6772942557ab5355d76af442f8f65e01", 'sha1');
+    assert.eq(sha.hash("160-bit hash").toString(16), "90d925d853c3d35cd54070bb75280fefad9de9e7");
+};
+
+exports.testSha256 = function () {
+    assert.eq(sha256.hash(raw).toString(16), "dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f", 'sha256');
+};
+
+exports.testCrc32 = function () {
+    assert.eq(crc32.hash(raw), -(parseInt("ec4ac3d0", 16) + 1) ^ -1, 'crc32');
+};
+
+/*
+    http://pajhome.org.uk/crypt/md5/
+*/
+
+/*
+
+    Original text   Hello, World!
+    Original bytes  48:65:6c:6c:6f:2c:20:57:6f:72:6c:64:21 (length=13)
+    Adler32 1f9e046a
+    CRC32   ec4ac3d0
+    Haval   69329e93ccfd832bb1a4ee00d01344cf
+    MD2 1c8f1e6a94aaa7145210bf90bb52871a
+    MD4 94e3cb0fa9aa7a5ee3db74b79e915989
+    MD5 65a8e27d8879283831b664bd8b7f0ad4
+    RipeMD128   67f9fe75ca2886dc76ad00f7276bdeba
+    RipeMD160   527a6a4b9a6da75607546842e0e00105350b1aaf
+    SHA-1   0a0a9f2a6772942557ab5355d76af442f8f65e01
+    SHA-256 dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f
+    SHA-384 5485cc9b3365b4305dfb4e8337e0a598a574f8242bf17289e0dd6c20a3cd44a089de16ab4ab308f63e44b1170eb5f515
+    SHA-512 374d794a95cdcfd8b35993185fef9ba368f160d8daf432d08ba9f1ed1e5abe6cc69291e0fa2fe0006a52570ef18c19def4e617c33ce52ef0a6e5fbe318cb0387
+    Tiger   252a5047009cd0710a1aa60525daf73ea55cb90319a39242
+    Whirlpool   16c581089b6a6f356ae56e16a63a4c613eecd82a2a894b293f5ee45c37a31d09d7a8b60bfa7e414bd4a7166662cea882b5cf8c96b7d583fc610ad202591bcdb1
+
+    http://www.fileformat.info/tool/hash.htm?text=Hello%2C+World%21
+
+*/
+
+/* test the consistency attribute of each algorithm
+ * (always returns the same value for the same input) */
+
+var consistency = function (algorithm) {
+    return function () {
+        // the returned hash should be consistent for the same input.
+        var s1 = algorithm.hash("test");
+        var s2 = algorithm.hash("test");
+        if (s1.decodeToString) {
+            assert.eq(
+                s1.decodeToString(64),
+                s2.decodeToString(64)
+            );
+        }
+        assert.eq(s1, s2);
+    };
+};
+
+util.forEachApply([
+    [md4, 'Md4'],
+    [md5, 'Md5'],
+    [sha, 'Sha'],
+    [sha256, 'Sha256'],
+    [crc32, 'Crc32']
+], function (algorithm, name) {
+    exports['testConsistency' + name] = consistency(algorithm);
+});
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/html.js

@@ -0,0 +1,13 @@
+var assert = require("test/assert");
+
+var html = require("nitro/utils/html"),
+    escapeHTML = html.escapeHTML,
+    stripTags = html.stripTags;
+
+exports.testEscapeHTML = function() {
+    var str = '<p class="text">hello</p>';
+    assert.isEqual(escapeHTML(str), '&lt;p class="text"&gt;hello&lt;/p&gt;');
+}
+
+exports.testStripTags = function() {
+}

data/tests/io/stringio.js

@@ -0,0 +1,21 @@
+
+var assert = require("test/assert");
+var io = require("io");
+
+exports.testStringIODelimiter = function () {
+    var stringio = new io.StringIO("a\0b\0", "\0");
+    assert.eq(["a\0", "b\0"], stringio.readLines());
+};
+
+exports.testStringIODelimiterForEach = function () {
+    var stringio = new io.StringIO("a\0b\0", "\0");
+    var acc = [];
+    stringio.forEach(function (line) {
+        acc.push(line);
+    });
+    assert.eq(["a", "b"], acc);
+};
+
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));

data/tests/os/all-tests.js

@@ -0,0 +1,4 @@
+exports.testPopen = require("./popen");
+exports.testSystem = require("./system");
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));

data/tests/os/popen.js

@@ -0,0 +1,41 @@
+var assert = require("test/assert");
+var os = require("os");
+var io = require("io");
+
+exports.testArrayCommunicateStdout = function () {
+    var list = io.StringIO();
+    list.print("30");
+    list.print("4");
+    list.print("1000");
+    list.print("200");
+
+    var process = os.popen(["sort", "-n", "-"]);
+    var lines = [];
+    process.communicate(list).stdout.forEach(function (line) {
+        lines.push(line);
+    });
+
+    assert.eq(["4", "30", "200", "1000"], lines);
+};
+
+exports.testCommunicateStatus = function () {
+    assert.eq(255, os.popen("exit -1").communicate().status);
+    assert.eq(255, os.popen("exit -1").wait());
+};
+
+exports.testCommunicateStdout = function () {
+    assert.eq("hi\n", os.popen("echo hi").communicate().stdout.read());
+    assert.eq("hi\n", os.popen("cat").communicate("hi").stdout.read());
+};
+
+exports.testCommunicateStderr = function () {
+    assert.eq("hi\n", os.popen("echo hi >&2").communicate().stderr.read());
+};
+
+exports.testCommunicateStdin = function () {
+    assert.eq("", os.popen("exit 0").communicate("hi").stdin.read());
+};
+
+if (require.main === module.id)
+    os.exit(require("test/runner").run(exports));
+

data/tests/os/system.js

@@ -0,0 +1,22 @@
+var assert = require("test/assert");
+var os = require("os");
+
+// FIXME: these will probably fail on Windows
+var systemTests = [
+    ["true", 0],
+    ["false", 1],
+    ["exit 2", 2],
+    ["exit 255", 255],
+    ["exit 256", 0],
+    ["exit 257", 1]
+]
+
+systemTests.forEach(function(test) {
+    exports["test system('"+test[0]+"') == " + test[1]] = function() {
+        assert.eq(test[1], os.system(test[0]))
+    }
+});
+
+if (require.main === module.id)
+    os.exit(require("test/runner").run(exports));
+

data/tests/printf.js

@@ -0,0 +1,123 @@
+
+var assert = require("test/assert");
+var util = require('util');
+var format = require("printf");
+var sandboxing = require("sandbox");
+
+util.forEachApply([
+
+    [["%d", 10], "10"],
+    [["%d", 1.1], "1"],
+    [["%0d", 1.1], "1"],
+    [["%02d", 1.1], "01"],
+    [["%02.2d", 1.1], "01"],
+    [["%.2f", 1.1], "1.10"],
+    [["%05.2f", 1.1], "01.10"],
+    [["%06.2f", 1.1], "001.10"],
+    [["%06.1f", 1.1], "0001.1"],
+    [["%x", 255], "ff"],
+    [["%X", 255], "FF"],
+    [["%6x", 255], "    ff"],
+    [["%06x", 255], "0000ff"],
+    [["%6X", 255], "    FF"],
+    [["%06X", 255], "0000FF"],
+    [["%x", 0], "0"],
+    [["%o", 0755], "755"],
+
+    // distinguish u and d
+    [["%u", -1], "4294967295"],
+    [["%d", -1], "-1"],
+
+    // accept i in place of d
+    [["%i", 10], "10"],
+    [["%i", 1.1], "1"],
+    [["%0i", 1.1], "1"],
+    [["%02i", 1.1], "01"],
+    [["%02.2i", 1.1], "01"],
+    [["%i", -1], "-1"],
+
+    // accept u in place of d, for positives
+    [["%u", 10], "10"],
+    [["%u", 1.1], "1"],
+    [["%0u", 1.1], "1"],
+    [["%02u", 1.1], "01"],
+    [["%02.2u", 1.1], "01"],
+
+    // beyond spec
+    [["%b", 2], "10"],
+    [["%8b", 255], "11111111"],
+    [["%8b", -1], "11111111"],
+    [["%08b", 2], "00000010"],
+
+    // some unit tests from http://paste.factorcode.org/paste?id=4
+    [["%d", 10], "10"],
+    //[["%f", 123.456], "123.456"], // original
+    [["%f", 123.456], "123.456000"], // concurs with python
+    [["%01.2f", 123.10], "123.10"],
+    [["%.4f", 1.2345], "1.2345"],
+    [["%01.2f", 123.1], "123.10"],
+    //[["%.4f", 1.23456789], "1.2345"], // original
+    [["%.4f", 1.23456789], "1.2346"], // concurs with python
+    [["%6.2f", 1.23456789], "  1.23"],
+    //[["%e", 123400000], "1.234e+08"], // original
+    [["%e", 123400000], "1.234000e+08"], // concurs with python
+    [["%e", 123456700], "1.234567e+08"],
+    [["%.3e", 36252500], "3.625e+08"],
+    //[["%e", 0.0025], "2.5e-03"], // original
+    [["%e", 0.0025], "2.500000e-03"], // concurs with python
+    //[["%E", 0.0025], "2.5E-03"], // original
+    [["%E", 0.0025], "2.500000E-03"], // concurs with python
+    [["%x", 0xff], "ff"],
+    [["%X", 0xff], "FF"],
+    [["%0x", 0xf], "f"],
+    [["%0X", 0xf], "F"],
+    [["%02x", 0xf], "0f"],
+    [["%02X", 0xf], "0F"],
+    [["%04d-%02d-%02d", 2008, 9, 10], "2008-09-10"],
+    [["%s", "Hello, World!"], "Hello, World!"],
+    [["printf test", ], "printf test"],
+    [["char %c = 'a'", "a".charCodeAt()], "char a = 'a'"],
+    [["%02x", 0], "00"],
+    [["%02x", 0xff], "ff"],
+    //[["%d %s(s)%", 0, "message"], "0 message(s)"], // original, but redacted
+    [["%d %s(s)", 0, "message"], "0 message(s)"],
+    [["%d %s(s) with %%", 0, "message"], "0 message(s) with %"],
+    [["justif: \"%-10s\"", "left"], "justif: \"left      \""],
+    [["justif: \"%10s\"", "right"], "justif: \"     right\""],
+    [[" 3: %04d zero padded", 3], " 3: 0003 zero padded"],
+    [[" 3: %-4d left justif", 3], " 3: 3    left justif"],
+    [[" 3: %4d right justif", 3], " 3:    3 right justif"],
+    [[" -3: %04d zero padded", -3], " -3: -003 zero padded"],
+    [[" -3: %-4d left justif", -3], " -3: -3   left justif"],
+    [[" -3: %4d right justif", -3], " -3:   -3 right justif"],
+    [["There are %d monkeys in the %s", 10, "kitchen"], "There are 10 monkeys in the kitchen"],
+    [["%d", 10], "10"],
+    [["[%s]", "monkey"], "[monkey]"],
+    [["[%10s]", "monkey"], "[    monkey]"],
+    [["[%-10s]", "monkey"], "[monkey    ]"],
+    [["[%010s]", "monkey"], "[0000monkey]"],
+    //[["[%'#10s]", "monkey"], "[####monkey]"], // original
+    //[["[%#10s]", "monkey"], "[####monkey]"], // sensible
+    [["[%#10s]", "monkey"], "[    monkey]"], // concurs with python
+    [["[%10.10s]", "many monkeys"], "[many monke]"]
+], function (input, expected) {
+    exports['test ' + util.repr(input)] = function () {
+        var actual = format.sprintf.apply(null, input);
+        assert.eq(expected, actual);
+    };
+});
+
+/*
+exports.testPrintfB = function () {
+};
+
+exports.testPrintfO = function () {
+};
+
+exports.testPrintfU = function () {
+};
+*/
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+