diff options
Diffstat (limited to 'utils/tests')
60 files changed, 1502 insertions, 0 deletions
diff --git a/utils/tests/all-tests.js b/utils/tests/all-tests.js new file mode 100755 index 0000000..2486f64 --- /dev/null +++ b/utils/tests/all-tests.js @@ -0,0 +1,12 @@ +exports.testSandbox = require("./iojs/program"); +exports.testString = require("./string-tests"); +exports.testURI = require("./uri-tests"); +exports.testCodecs = require("./codecs"); +exports.testOS = require("./os/all-tests"); +exports.testFile = require("./file/all-tests"); +exports.testUtil = require("./util/all-tests"); + +exports.testServerJS = require("./serverjs/all-tests"); + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); diff --git a/utils/tests/base64.js b/utils/tests/base64.js new file mode 100755 index 0000000..09bcd34 --- /dev/null +++ b/utils/tests/base64.js @@ -0,0 +1,23 @@ + +var base64 = require('base64.js'); +var binary = require('binary'); +var assert = require('test/assert.js'); + +var raw = "Once upon a time, in a far away land.\n"; +var encoded = 'T25jZSB1cG9uIGEgdGltZSwgaW4gYSBmYXIgYXdheSBsYW5kLgo='; + +exports.testEncode = function () { + assert.eq(base64.encode(raw), encoded, 'encoded'); +}; + +exports.testDecode = function () { + assert.eq(base64.decode(encoded), raw, 'decoded'); +}; + +exports.testEncodeDecode = function () { + assert.eq(base64.decode(base64.encode(raw)), raw, 'encode decode identity'); +}; + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); + diff --git a/utils/tests/codecs.js b/utils/tests/codecs.js new file mode 100755 index 0000000..c43c723 --- /dev/null +++ b/utils/tests/codecs.js @@ -0,0 +1,65 @@ + +var assert = require('test/assert'); +var struct = require('struct'); + +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 + +*/ + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); + diff --git a/utils/tests/file/all-tests.js b/utils/tests/file/all-tests.js new file mode 100755 index 0000000..4730ec7 --- /dev/null +++ b/utils/tests/file/all-tests.js @@ -0,0 +1,31 @@ +var assert = require("test/assert"); +var fs = require("file"); + +exports.testRmtreeDoesNotFollowSymlinks = function () { + var here = fs.path(module.path).dirname(); + if (here.join('foo').exists()) + here.join('foo').rmtree(); + try { + here.join('foo', 'bar').mkdirs(); + here.join('foo', 'bar').symlink(here.join('foo', 'baz')); + here.join('foo', 'baz').rmtree(); + assert.isTrue(here.join('foo', 'bar').exists()); + } finally { + here.join('foo').rmtree(); + } +}; + +exports.testGlobStar = function () { +}; + +exports.testGlobQuestion = function () { +}; + +exports.testGlobStarStar = function () { +}; + +exports.testGlobDotDotDot = function () { +}; + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); diff --git a/utils/tests/iojs/absolute/b.js b/utils/tests/iojs/absolute/b.js new file mode 100755 index 0000000..da5bf4f --- /dev/null +++ b/utils/tests/iojs/absolute/b.js @@ -0,0 +1 @@ +exports.foo = function() {}; diff --git a/utils/tests/iojs/absolute/program.js b/utils/tests/iojs/absolute/program.js new file mode 100755 index 0000000..149d40f --- /dev/null +++ b/utils/tests/iojs/absolute/program.js @@ -0,0 +1,5 @@ +var test = require('test'); +var a = require('submodule/a'); +var b = require('b'); +test.assert(a.foo().foo === b.foo, 'require works with absolute identifiers'); +print('DONE', 'info'); diff --git a/utils/tests/iojs/absolute/submodule/a.js b/utils/tests/iojs/absolute/submodule/a.js new file mode 100755 index 0000000..bc138b8 --- /dev/null +++ b/utils/tests/iojs/absolute/submodule/a.js @@ -0,0 +1,3 @@ +exports.foo = function () { + return require('b'); +}; diff --git a/utils/tests/iojs/absolute/test.js b/utils/tests/iojs/absolute/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/absolute/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/iojs/config.js b/utils/tests/iojs/config.js new file mode 100755 index 0000000..e52293e --- /dev/null +++ b/utils/tests/iojs/config.js @@ -0,0 +1,11 @@ +(function (env) { + try { + var sandbox = require('chiron/sandbox').sandbox; + var base = require('chiron/base'); + var log = base.List(); + sandbox('test/iojs/program', {print: log.push}); + return [200, {'Content-type': 'text/plain'}, log.eachIter(base.add("\n"))]; + } catch (exception) { + return [500, {'Content-type': 'text/plain'}, [''+(exception.message || exception)]]; + } +}); diff --git a/utils/tests/iojs/cyclic/a.js b/utils/tests/iojs/cyclic/a.js new file mode 100755 index 0000000..e0188fa --- /dev/null +++ b/utils/tests/iojs/cyclic/a.js @@ -0,0 +1,4 @@ +exports.a = function () { + return b; +}; +var b = require('b'); diff --git a/utils/tests/iojs/cyclic/b.js b/utils/tests/iojs/cyclic/b.js new file mode 100755 index 0000000..873a305 --- /dev/null +++ b/utils/tests/iojs/cyclic/b.js @@ -0,0 +1,4 @@ +var a = require('a'); +exports.b = function () { + return a; +}; diff --git a/utils/tests/iojs/cyclic/program.js b/utils/tests/iojs/cyclic/program.js new file mode 100755 index 0000000..93c0330 --- /dev/null +++ b/utils/tests/iojs/cyclic/program.js @@ -0,0 +1,10 @@ +var test = require('test'); +var a = require('a'); +var b = require('b'); + +test.assert(a.a, 'a exists'); +test.assert(b.b, 'b exists') +test.assert(a.a().b === b.b, 'a gets b'); +test.assert(b.b().a === a.a, 'b gets a'); + +print('DONE', 'info'); diff --git a/utils/tests/iojs/cyclic/test.js b/utils/tests/iojs/cyclic/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/cyclic/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/iojs/determinism/program.js b/utils/tests/iojs/determinism/program.js new file mode 100755 index 0000000..8ae9461 --- /dev/null +++ b/utils/tests/iojs/determinism/program.js @@ -0,0 +1,3 @@ +var test = require('test'); +require('submodule/a'); +print('DONE', 'info'); diff --git a/utils/tests/iojs/determinism/submodule/a.js b/utils/tests/iojs/determinism/submodule/a.js new file mode 100755 index 0000000..0221574 --- /dev/null +++ b/utils/tests/iojs/determinism/submodule/a.js @@ -0,0 +1,8 @@ +var pass = false; +var test = require('test'); +try { + require('a'); +} catch (exception) { + pass = true; +} +test.assert(pass, 'require does not fall back to relative modules when absolutes are not available.') diff --git a/utils/tests/iojs/determinism/submodule/b.js b/utils/tests/iojs/determinism/submodule/b.js new file mode 100755 index 0000000..139597f --- /dev/null +++ b/utils/tests/iojs/determinism/submodule/b.js @@ -0,0 +1,2 @@ + + diff --git a/utils/tests/iojs/determinism/test.js b/utils/tests/iojs/determinism/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/determinism/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/iojs/exactExports/a.js b/utils/tests/iojs/exactExports/a.js new file mode 100755 index 0000000..99c929e --- /dev/null +++ b/utils/tests/iojs/exactExports/a.js @@ -0,0 +1,3 @@ +exports.program = function () { + return require('program'); +}; diff --git a/utils/tests/iojs/exactExports/program.js b/utils/tests/iojs/exactExports/program.js new file mode 100755 index 0000000..e678431 --- /dev/null +++ b/utils/tests/iojs/exactExports/program.js @@ -0,0 +1,4 @@ +var test = require('test'); +var a = require('a'); +test.assert(a.program() === exports, 'exact exports'); +print('DONE', 'info'); diff --git a/utils/tests/iojs/exactExports/test.js b/utils/tests/iojs/exactExports/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/exactExports/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/iojs/hasOwnProperty/hasOwnProperty.js b/utils/tests/iojs/hasOwnProperty/hasOwnProperty.js new file mode 100755 index 0000000..e69de29 --- /dev/null +++ b/utils/tests/iojs/hasOwnProperty/hasOwnProperty.js diff --git a/utils/tests/iojs/hasOwnProperty/program.js b/utils/tests/iojs/hasOwnProperty/program.js new file mode 100755 index 0000000..c574163 --- /dev/null +++ b/utils/tests/iojs/hasOwnProperty/program.js @@ -0,0 +1,3 @@ +var hasOwnProperty = require('hasOwnProperty'); +var toString = require('toString'); +print('DONE', 'info'); diff --git a/utils/tests/iojs/hasOwnProperty/test.js b/utils/tests/iojs/hasOwnProperty/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/hasOwnProperty/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/iojs/hasOwnProperty/toString.js b/utils/tests/iojs/hasOwnProperty/toString.js new file mode 100755 index 0000000..e69de29 --- /dev/null +++ b/utils/tests/iojs/hasOwnProperty/toString.js diff --git a/utils/tests/iojs/method/a.js b/utils/tests/iojs/method/a.js new file mode 100755 index 0000000..69c48af --- /dev/null +++ b/utils/tests/iojs/method/a.js @@ -0,0 +1,12 @@ +exports.foo = function () { + return this; +}; +exports.set = function (x) { + this.x = x; +}; +exports.get = function () { + return this.x; +}; +exports.getClosed = function () { + return exports.x; +}; diff --git a/utils/tests/iojs/method/program.js b/utils/tests/iojs/method/program.js new file mode 100755 index 0000000..611a109 --- /dev/null +++ b/utils/tests/iojs/method/program.js @@ -0,0 +1,8 @@ +var test = require('test'); +var a = require('a'); +var foo = a.foo; +test.assert(a.foo() == a, 'calling a module member'); +test.assert(foo() == (function (){return this})(), 'members not implicitly bound'); +a.set(10); +test.assert(a.get() == 10, 'get and set') +print('DONE', 'info'); diff --git a/utils/tests/iojs/method/test.js b/utils/tests/iojs/method/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/method/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/iojs/missing/program.js b/utils/tests/iojs/missing/program.js new file mode 100755 index 0000000..f8fd6f0 --- /dev/null +++ b/utils/tests/iojs/missing/program.js @@ -0,0 +1,8 @@ +var test = require('test'); +try { + require('bogus'); + print('FAIL require throws error when module missing', 'fail'); +} catch (exception) { + print('PASS require throws error when module missing', 'pass'); +} +print('DONE', 'info'); diff --git a/utils/tests/iojs/missing/test.js b/utils/tests/iojs/missing/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/missing/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/iojs/monkeys/a.js b/utils/tests/iojs/monkeys/a.js new file mode 100755 index 0000000..a949e1d --- /dev/null +++ b/utils/tests/iojs/monkeys/a.js @@ -0,0 +1 @@ +require('program').monkey = 10; diff --git a/utils/tests/iojs/monkeys/program.js b/utils/tests/iojs/monkeys/program.js new file mode 100755 index 0000000..af50d47 --- /dev/null +++ b/utils/tests/iojs/monkeys/program.js @@ -0,0 +1,4 @@ +var a = require('a'); +var test = require('test'); +test.assert(exports.monkey == 10, 'monkeys permitted'); +print('DONE', 'info'); diff --git a/utils/tests/iojs/monkeys/test.js b/utils/tests/iojs/monkeys/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/monkeys/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/iojs/nested/a/b/c/d.js b/utils/tests/iojs/nested/a/b/c/d.js new file mode 100755 index 0000000..69fd282 --- /dev/null +++ b/utils/tests/iojs/nested/a/b/c/d.js @@ -0,0 +1,3 @@ +exports.foo = function () { + return 1; +}; diff --git a/utils/tests/iojs/nested/program.js b/utils/tests/iojs/nested/program.js new file mode 100755 index 0000000..54bfbe7 --- /dev/null +++ b/utils/tests/iojs/nested/program.js @@ -0,0 +1,3 @@ +var test = require('test'); +test.assert(require('a/b/c/d').foo() == 1, 'nested module identifier'); +print('DONE', 'info'); diff --git a/utils/tests/iojs/nested/test.js b/utils/tests/iojs/nested/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/nested/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/iojs/program.js b/utils/tests/iojs/program.js new file mode 100755 index 0000000..7e64b91 --- /dev/null +++ b/utils/tests/iojs/program.js @@ -0,0 +1,47 @@ +#!/usr/bin/env narwhal + +var assert = require('test/assert'); +var sandbox = require('sandbox').sandbox; +var fs = require('file'); + +[ + 'absolute', + 'cyclic', + 'exactExports', + 'hasOwnProperty', + 'method', + 'missing', + 'monkeys', + 'nested', + 'relative', + 'transitive', + 'determinism' +].forEach(function (testName) { + exports['test ' + testName] = function () { + var prefix = fs.path(module.id).resolve(testName).join(''); + var done; + + var print = function (message) { + assert.isFalse(/^FAIL/.test(message)); + if (/^ERROR/.test(message)) + throw new Error(message); + if (/^DONE/.test(message)) + done = true; + }; + + sandbox( + 'program', + system, + { + prefix: prefix, + loader: require.loader, + print: print + } + ); + assert.isTrue(done, 'done'); + }; +}); + +if (module.id == require.main) + require('os').exit(require('test/runner').run(exports)); + diff --git a/utils/tests/iojs/relative/program.js b/utils/tests/iojs/relative/program.js new file mode 100755 index 0000000..c7ed6e9 --- /dev/null +++ b/utils/tests/iojs/relative/program.js @@ -0,0 +1,5 @@ +var test = require('test'); +var a = require('submodule/a'); +var b = require('submodule/b'); +test.assert(a.foo == b.foo, 'a and b share foo through a relative require'); +print('DONE', 'info'); diff --git a/utils/tests/iojs/relative/submodule/a.js b/utils/tests/iojs/relative/submodule/a.js new file mode 100755 index 0000000..42e4ca0 --- /dev/null +++ b/utils/tests/iojs/relative/submodule/a.js @@ -0,0 +1 @@ +exports.foo = require('./b').foo; diff --git a/utils/tests/iojs/relative/submodule/b.js b/utils/tests/iojs/relative/submodule/b.js new file mode 100755 index 0000000..9042c16 --- /dev/null +++ b/utils/tests/iojs/relative/submodule/b.js @@ -0,0 +1,2 @@ +exports.foo = function () { +}; diff --git a/utils/tests/iojs/relative/test.js b/utils/tests/iojs/relative/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/relative/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/iojs/transitive/a.js b/utils/tests/iojs/transitive/a.js new file mode 100755 index 0000000..4df7bb8 --- /dev/null +++ b/utils/tests/iojs/transitive/a.js @@ -0,0 +1 @@ +exports.foo = require('b').foo; diff --git a/utils/tests/iojs/transitive/b.js b/utils/tests/iojs/transitive/b.js new file mode 100755 index 0000000..30ea70d --- /dev/null +++ b/utils/tests/iojs/transitive/b.js @@ -0,0 +1 @@ +exports.foo = require('c').foo; diff --git a/utils/tests/iojs/transitive/c.js b/utils/tests/iojs/transitive/c.js new file mode 100755 index 0000000..69fd282 --- /dev/null +++ b/utils/tests/iojs/transitive/c.js @@ -0,0 +1,3 @@ +exports.foo = function () { + return 1; +}; diff --git a/utils/tests/iojs/transitive/program.js b/utils/tests/iojs/transitive/program.js new file mode 100755 index 0000000..165f7ad --- /dev/null +++ b/utils/tests/iojs/transitive/program.js @@ -0,0 +1,3 @@ +var test = require('test'); +test.assert(require('a').foo() == 1, 'transitive'); +print('DONE', 'info'); diff --git a/utils/tests/iojs/transitive/test.js b/utils/tests/iojs/transitive/test.js new file mode 100755 index 0000000..a690a2d --- /dev/null +++ b/utils/tests/iojs/transitive/test.js @@ -0,0 +1,9 @@ + +exports.assert = function (guard, message) { + if (guard) { + print('PASS ' + message, 'pass'); + } else { + print('FAIL ' + message, 'fail'); + } +}; + diff --git a/utils/tests/os/all-tests.js b/utils/tests/os/all-tests.js new file mode 100755 index 0000000..f99df4b --- /dev/null +++ b/utils/tests/os/all-tests.js @@ -0,0 +1,3 @@ +exports.testPopen = require("./popen"); +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); diff --git a/utils/tests/os/popen.js b/utils/tests/os/popen.js new file mode 100755 index 0000000..d9c08f0 --- /dev/null +++ b/utils/tests/os/popen.js @@ -0,0 +1,23 @@ +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.isSame(lines, ["4", "30", "200", "1000"]); +}; + +if (require.main === module.id) + os.exit(require("test/runner").run(exports)); + diff --git a/utils/tests/sandbox/byte-io.js b/utils/tests/sandbox/byte-io.js new file mode 100755 index 0000000..dc22fec --- /dev/null +++ b/utils/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(''); + diff --git a/utils/tests/sandbox/fileName.js b/utils/tests/sandbox/fileName.js new file mode 100755 index 0000000..452bb2f --- /dev/null +++ b/utils/tests/sandbox/fileName.js @@ -0,0 +1,3 @@ + +print(module.path); + diff --git a/utils/tests/serverjs/all-tests.js b/utils/tests/serverjs/all-tests.js new file mode 100755 index 0000000..789f47e --- /dev/null +++ b/utils/tests/serverjs/all-tests.js @@ -0,0 +1,9 @@ +exports.testFile = require("./file-tests"); +exports.testModules = require("./module-tests"); +exports.testByteArray = require("./bytearray-tests"); +exports.testByteString = require("./bytestring-tests"); +exports.testByteArrayEncodings = require("./bytearray-encodings-tests"); +exports.testByteStringEncodings = require("./bytestring-encodings-tests"); + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); diff --git a/utils/tests/serverjs/bytearray-tests.js b/utils/tests/serverjs/bytearray-tests.js new file mode 100755 index 0000000..6d165d0 --- /dev/null +++ b/utils/tests/serverjs/bytearray-tests.js @@ -0,0 +1,273 @@ +var assert = require("test/assert"); + +var Binary = require("binary").Binary, + ByteString = require("binary").ByteString, + ByteArray = require("binary").ByteArray; + +exports.testByteArrayConstructor = function() { + var testArray = [1,2,3,4], + b; + + // ByteArray() + // New, empty ByteArray. + b = new ByteArray(); + //assert.isTrue(b instanceof Binary, "not instanceof Binary"); + assert.isTrue(b instanceof ByteArray, "not instanceof ByteArray"); + assert.isEqual(0, b.length); + b.length = 123; + assert.isEqual(123, b.length); + assert.isEqual(0, b.get(4)); + + // ByteArray(length) + // New ByteArray filled with length zero bytes. + b = new ByteArray(10); + assert.isEqual(10, b.length); + for (var i = 0; i < 10; i++) + assert.isEqual(0, b.get(i)); + assert.isNaN(b.get(10)); + b.length = 234; + assert.isEqual(234, b.length); + assert.isEqual(0, b.get(10)); + assert.isEqual(0, b.get(233)); + assert.isNaN(b.get(234)); + + // ByteArray(byteString) + // Copy contents of byteString. + b = new ByteArray(new ByteString(testArray)); + assert.isEqual(testArray.length, b.length); + b.length = 345; + assert.isEqual(345, b.length); + assert.isEqual(1, b.get(0)); + assert.isEqual(4, b.get(3)); + assert.isEqual(0, b.get(4)); + + // ByteArray(byteArray) + // Copy byteArray. + b = new ByteArray(new ByteArray(testArray)); + assert.isEqual(testArray.length, b.length); + b.length = 456; + assert.isEqual(456, b.length); + assert.isEqual(1, b.get(0)); + assert.isEqual(4, b.get(3)); + assert.isEqual(0, b.get(4)); + + // ByteArray(arrayOfBytes) + // Use numbers in arrayOfBytes as contents. + // Throws an exception if any element is outside the range 0...255 (TODO). + b = new ByteArray(testArray); + assert.isEqual(testArray.length, b.length); + b.length = 567; + assert.isEqual(567, b.length); + assert.isEqual(1, b.get(0)); + assert.isEqual(4, b.get(3)); + assert.isEqual(0, b.get(4)); +}; + +exports.testByteArrayResizing = function() { + var b1 = new ByteArray([0,1,2,3,4,5,6]); + assert.isEqual(7, b1.length); + assert.isNaN(b1.get(7)); + + b1.length = 10; + assert.isEqual(10, b1.length, "Length should change to 10"); + assert.isEqual(5, b1.get(5)); + assert.isEqual(0, b1.get(7)); + + b1.length = 3; + assert.isEqual(3, b1.length, "Length should change to 10"); + assert.isEqual(0, b1.get(0)); + assert.isNaN(b1.get(4)); + + b1.length = 9; + assert.isEqual(9, b1.length, "Length should change to 9"); + assert.isEqual(0, b1.get(0)); + assert.isEqual(0, b1.get(4)); +}; + +exports.testToByteArray = function() { + var b1 = new ByteArray([1,2,3]), + b2 = b1.toByteArray(); + + assert.isTrue(b2 instanceof ByteArray, "not instanceof ByteArray"); + assert.isEqual(b1.length, b2.length); + assert.isEqual(b1.get(0), b2.get(0)); + assert.isEqual(b1.get(2), b2.get(2)); + + assert.isEqual(1, b1.get(0)); + assert.isEqual(1, b2.get(0)); + + b1.set(0, 10); + + assert.isEqual(10, b1.get(0)); + assert.isEqual(1, b2.get(0)); +}; + +exports.testToByteString = function() { + var b1 = new ByteArray([1,2,3]), + b2 = b1.toByteString(); + + assert.isEqual(b1.length, b2.length); + assert.isEqual(b1.get(0), b2.get(0)); + assert.isEqual(b1.get(2), b2.get(2)); + + assert.isEqual(1, b1.get(0)); + assert.isEqual(1, b2.get(0)); + + b1.set(0, 10); + + assert.isEqual(10, b1.get(0)); + assert.isEqual(1, b2.get(0)); +}; + +exports.testToArray = function() { + var testArray = [0,1,254,255], + b1 = new ByteArray(testArray), + a1 = b1.toArray(); + + assert.isEqual(testArray.length, a1.length); + for (var i = 0; i < testArray.length; i++) + assert.isEqual(testArray[i], a1[i]); +}; + +exports.testToString = function() { + // the format of the resulting string isn't specified, but it shouldn't be the decoded string + // TODO: is this an ok test? + + var testString = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"+ + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + testArray = []; + for (var i = 0; i < 128; i++) testArray.push(65); + + var resultString = new ByteArray(testArray).toString(); + + assert.isTrue(resultString.length < 100); + assert.isTrue(resultString !== testString); +}; + +exports.testIndexOf = function() { + var b1 = new ByteArray([0,1,2,3,4,5,0,1,2,3,4,5]); + + assert.isEqual(-1, b1.indexOf(-1)); + + assert.isEqual(0, b1.indexOf(0)); + assert.isEqual(5, b1.indexOf(5)); + assert.isEqual(-1, b1.indexOf(12)); + + assert.isEqual(6, b1.indexOf(0, 6)); + assert.isEqual(11, b1.indexOf(5, 6)); + assert.isEqual(-1, b1.indexOf(12, 6)); + + assert.isEqual(0, b1.indexOf(0, 0, 3)); + assert.isEqual(-1, b1.indexOf(5, 0, 3)); + assert.isEqual(-1, b1.indexOf(12, 0, 3)); +}; + +exports.testLastIndexOf = function() { + var b1 = new ByteArray([0,1,2,3,4,5,0,1,2,3,4,5]); + + assert.isEqual(-1, b1.lastIndexOf(-1)); + + assert.isEqual(6, b1.lastIndexOf(0)); + assert.isEqual(11, b1.lastIndexOf(5)); + assert.isEqual(-1, b1.lastIndexOf(12)); + + assert.isEqual(0, b1.lastIndexOf(0, 0, 6)); + assert.isEqual(5, b1.lastIndexOf(5, 0, 6)); + assert.isEqual(-1, b1.lastIndexOf(12, 0, 6)); + + assert.isEqual(6, b1.lastIndexOf(0, 6, 9)); + assert.isEqual(-1, b1.lastIndexOf(5, 6, 9)); + assert.isEqual(-1, b1.lastIndexOf(12, 6, 9)); +}; + +exports.testByteArrayReverse = function() { + var testArray = [0,1,2,3,4,5,6]; + + var b1 = new ByteArray(testArray), + b2 = b1.reverse(); + + assert.isEqual(b1, b2); + assert.isEqual(b1.length, b2.length); + for (var i = 0; i < testArray.length; i++) + assert.isEqual(testArray[i], b2.get(testArray.length-i-1)); + + testArray = [0,1,2,3,4,5,6,7]; + + b1 = new ByteArray(testArray); + b2 = b1.reverse(); + + assert.isEqual(b1, b2); + assert.isEqual(b1.length, b2.length); + for (var i = 0; i < testArray.length; i++) + assert.isEqual(testArray[i], b2.get(testArray.length-i-1)); +}; + +exports.testByteArraySort = function() { + var testArray = []; + for (var i = 0; i < 1000; i++) + testArray.push(Math.floor(Math.random()*256)); + + var a = new ByteArray(testArray); + a.sort(); + + for (var i = 1; i < a.length; i++) + assert.isTrue(a.get(i-1) <= a.get(i), "index="+i+"("+a.get(i-1)+","+a.get(i)+")"); +}; + +exports.testByteArraySortCustom = function() { + var testArray = []; + for (var i = 0; i < 1000; i++) + testArray.push(Math.floor(Math.random()*256)); + + var a = new ByteArray(testArray); + a.sort(function(o1, o2) { return o2-o1; }); + + for (var i = 1; i < a.length; i++) + assert.isTrue(a.get(i-1) >= a.get(i), "index="+i+"("+a.get(i-1)+","+a.get(i)+")"); +}; + +exports.testSplit = function() { + var b1 = new ByteArray([0,1,2,3,4,5]), a1; + + a1 = b1.split([]); + assert.isEqual(1, a1.length); + assert.isTrue(a1[0] instanceof ByteArray); + assert.isEqual(6, a1[0].length); + assert.isEqual(0, a1[0].get(0)); + assert.isEqual(5, a1[0].get(5)); + + a1 = b1.split([2]); + assert.isEqual(2, a1.length); + assert.isTrue(a1[0] instanceof ByteArray); + assert.isEqual(2, a1[0].length); + assert.isEqual(0, a1[0].get(0)); + assert.isEqual(1, a1[0].get(1)); + assert.isEqual(3, a1[1].length); + assert.isEqual(3, a1[1].get(0)); + assert.isEqual(5, a1[1].get(2)); + + a1 = b1.split([2], { includeDelimiter : true }); + assert.isEqual(3, a1.length); + assert.isTrue(a1[0] instanceof ByteArray); + assert.isEqual(2, a1[0].length); + assert.isEqual(0, a1[0].get(0)); + assert.isEqual(1, a1[0].get(1)); + assert.isEqual(1, a1[1].length); + assert.isEqual(2, a1[1].get(0)); + assert.isEqual(3, a1[2].length); + assert.isEqual(3, a1[2].get(0)); + assert.isEqual(5, a1[2].get(2)); + + a1 = b1.split(new ByteString([2,3])); + assert.isEqual(2, a1.length); + assert.isTrue(a1[0] instanceof ByteArray); + assert.isEqual(2, a1[0].length); + assert.isEqual(0, a1[0].get(0)); + assert.isEqual(1, a1[0].get(1)); + assert.isEqual(2, a1[1].length); + assert.isEqual(4, a1[1].get(0)); + assert.isEqual(5, a1[1].get(1)); +}; + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); diff --git a/utils/tests/serverjs/bytestring-tests.js b/utils/tests/serverjs/bytestring-tests.js new file mode 100755 index 0000000..b62db2c --- /dev/null +++ b/utils/tests/serverjs/bytestring-tests.js @@ -0,0 +1,263 @@ +var assert = require("test/assert"); + +var Binary = require("binary").Binary, + ByteString = require("binary").ByteString, + ByteArray = require("binary").ByteArray; + +exports.testByteStringConstructor = function() { + var testArray = [1,2,3,4]; + + // ByteString() + // Construct an empty byte string. + var b1 = new ByteString(); + //assert.isTrue(b1 instanceof Binary, "not instanceof Binary"); + assert.isTrue(b1 instanceof ByteString, "not instanceof ByteString"); + assert.isEqual(0, b1.length); + b1.length = 123; + assert.isEqual(0, b1.length); + + // ByteString(byteString) + // Copies byteString. + var b2 = new ByteString(new ByteString(testArray)); + assert.isEqual(testArray.length, b2.length); + b2.length = 123; + assert.isEqual(testArray.length, b2.length); + assert.isEqual(1, b2.get(0)); + assert.isEqual(4, b2.get(3)); + + // ByteString(byteArray) + // Use the contents of byteArray. + var b2 = new ByteString(new ByteArray(testArray)); + assert.isEqual(testArray.length, b2.length); + b2.length = 123; + assert.isEqual(testArray.length, b2.length); + assert.isEqual(1, b2.get(0)); + assert.isEqual(4, b2.get(3)); + + // ByteString(arrayOfNumbers) + // Use the numbers in arrayOfNumbers as the bytes. + // If any element is outside the range 0...255, an exception (TODO) is thrown. + var b3 = new ByteString(testArray); + assert.isEqual(testArray.length, b3.length); + b3.length = 123; + assert.isEqual(testArray.length, b3.length); + assert.isEqual(1, b3.get(0)); + assert.isEqual(4, b3.get(3)); +}; + +//exports.testByteStringJoin = function() { +//} + +exports.testToByteArray = function() { + var b1 = new ByteString([1,2,3]), + b2 = b1.toByteArray(); + + assert.isTrue(b2 instanceof ByteArray, "not instanceof ByteArray"); + assert.isEqual(b1.length, b2.length); + assert.isEqual(b1.get(0), b2.get(0)); + assert.isEqual(b1.get(2), b2.get(2)); +}; + +exports.testToByteString = function() { + var b1 = new ByteString([1,2,3]), + b2 = b1.toByteString(); + + assert.isEqual(b1.length, b2.length); + assert.isEqual(b1.get(0), b2.get(0)); + assert.isEqual(b1.get(2), b2.get(2)); +}; + +exports.testToArray = function() { + var testArray = [0,1,254,255], + b1 = new ByteString(testArray), + a1 = b1.toArray(); + + assert.isEqual(testArray.length, a1.length); + for (var i = 0; i < testArray.length; i++) + assert.isEqual(testArray[i], a1[i]); +}; + +exports.testToString = function() { + // the format of the resulting string isn't specified, but it shouldn't be the decoded string + // TODO: is this an ok test? + + var testString = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"+ + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + testArray = []; + for (var i = 0; i < 128; i++) testArray.push(65); + + var resultString = new ByteString(testArray).toString(); + + assert.isTrue(resultString.length < 100); + assert.isTrue(resultString !== testString); +}; + +exports.testIndexOf = function() { + var b1 = new ByteString([0,1,2,3,4,5,0,1,2,3,4,5]); + + assert.isEqual(-1, b1.indexOf(-1)); + + assert.isEqual(0, b1.indexOf(0)); + assert.isEqual(5, b1.indexOf(5)); + assert.isEqual(-1, b1.indexOf(12)); + + assert.isEqual(6, b1.indexOf(0, 6)); + assert.isEqual(11, b1.indexOf(5, 6)); + assert.isEqual(-1, b1.indexOf(12, 6)); + + assert.isEqual(0, b1.indexOf(0, 0, 3)); + assert.isEqual(-1, b1.indexOf(5, 0, 3)); + assert.isEqual(-1, b1.indexOf(12, 0, 3)); +}; + +exports.testLastIndexOf = function() { + var b1 = new ByteString([0,1,2,3,4,5,0,1,2,3,4,5]); + + assert.isEqual(-1, b1.lastIndexOf(-1)); + + assert.isEqual(6, b1.lastIndexOf(0)); + assert.isEqual(11, b1.lastIndexOf(5)); + assert.isEqual(-1, b1.lastIndexOf(12)); + + assert.isEqual(0, b1.lastIndexOf(0, 0, 6)); + assert.isEqual(5, b1.lastIndexOf(5, 0, 6)); + assert.isEqual(-1, b1.lastIndexOf(12, 0, 6)); + + assert.isEqual(6, b1.lastIndexOf(0, 6, 9)); + assert.isEqual(-1, b1.lastIndexOf(5, 6, 9)); + assert.isEqual(-1, b1.lastIndexOf(12, 6, 9)); +}; + +exports.testCharCodeAt = function() { + var b1 = new ByteString([0,1,2,3,4,255]); + + assert.isTrue(isNaN(b1.charCodeAt(-1))); + assert.isEqual(0, b1.charCodeAt(0)); + assert.isEqual(255, b1.charCodeAt(5)); + assert.isTrue(isNaN(b1.charCodeAt(6))); +}; + +// identical to charCodeAt, test anyway? +exports.testGet = function() { + var b1 = new ByteString([0,1,2,3,4,255]); + + assert.isTrue(isNaN(b1.get(-1))); + assert.isEqual(0, b1.get(0)); + assert.isEqual(255, b1.get(5)); + assert.isTrue(isNaN(b1.get(6))); +}; + +exports.testByteAt = function() { + var b1 = new ByteString([0,1,2,3,4,255]), b2; + + b2 = b1.byteAt(-1); + assert.isEqual(0, b2.length); + b2 = b1.byteAt(0); + assert.isEqual(1, b2.length); + assert.isEqual(0, b2.get(0)); + b2 = b1.byteAt(5); + assert.isEqual(1, b2.length); + assert.isEqual(255, b2.get(0)); + b2 = b1.byteAt(6); + assert.isEqual(0, b2.length); +}; + +// identical to byteAt, test anyway? +exports.testCharAt = function() { + var b1 = new ByteString([0,1,2,3,4,255]), b2; + + b2 = b1.charAt(-1); + assert.isEqual(0, b2.length); + b2 = b1.charAt(0); + assert.isEqual(1, b2.length); + assert.isEqual(0, b2.get(0)); + b2 = b1.charAt(5); + assert.isEqual(1, b2.length); + assert.isEqual(255, b2.get(0)); + b2 = b1.charAt(6); + assert.isEqual(0, b2.length); +}; + +exports.testSplit = function() { + var b1 = new ByteString([0,1,2,3,4,5]), a1; + + a1 = b1.split([]); + assert.isEqual(1, a1.length); + assert.isTrue(a1[0] instanceof ByteString); + assert.isEqual(6, a1[0].length); + assert.isEqual(0, a1[0].get(0)); + assert.isEqual(5, a1[0].get(5)); + + a1 = b1.split([2]); + assert.isEqual(2, a1.length); + assert.isTrue(a1[0] instanceof ByteString); + assert.isEqual(2, a1[0].length); + assert.isEqual(0, a1[0].get(0)); + assert.isEqual(1, a1[0].get(1)); + assert.isEqual(3, a1[1].length); + assert.isEqual(3, a1[1].get(0)); + assert.isEqual(5, a1[1].get(2)); + + a1 = b1.split([2], { includeDelimiter : true }); + assert.isEqual(3, a1.length); + assert.isTrue(a1[0] instanceof ByteString); + assert.isEqual(2, a1[0].length); + assert.isEqual(0, a1[0].get(0)); + assert.isEqual(1, a1[0].get(1)); + assert.isEqual(1, a1[1].length); + assert.isEqual(2, a1[1].get(0)); + assert.isEqual(3, a1[2].length); + assert.isEqual(3, a1[2].get(0)); + assert.isEqual(5, a1[2].get(2)); + + a1 = b1.split(new ByteString([2,3])); + assert.isEqual(2, a1.length); + assert.isTrue(a1[0] instanceof ByteString); + assert.isEqual(2, a1[0].length); + assert.isEqual(0, a1[0].get(0)); + assert.isEqual(1, a1[0].get(1)); + assert.isEqual(2, a1[1].length); + assert.isEqual(4, a1[1].get(0)); + assert.isEqual(5, a1[1].get(1)); +}; + +exports.testSlice = function() { + var b1 = new ByteString([0,1,2,3,4,5]), b2; + + b2 = b1.slice(); + assert.isEqual(6, b2.length); + assert.isEqual(0, b2.get(0)); + assert.isEqual(5, b2.get(5)); + + b2 = b1.slice(0); + assert.isEqual(6, b2.length); + assert.isEqual(0, b2.get(0)); + assert.isEqual(5, b2.get(5)); + + b2 = b1.slice(1, 4); + assert.isEqual(3, b2.length); + assert.isEqual(1, b2.get(0)); + assert.isEqual(3, b2.get(2)); + + b2 = b1.slice(0, -1); + assert.isEqual(5, b2.length); + assert.isEqual(0, b2.get(0)); + assert.isEqual(4, b2.get(4)); + + b2 = b1.slice(-3, -1); + assert.isEqual(2, b2.length); + assert.isEqual(3, b2.get(0)); + assert.isEqual(4, b2.get(1)); + + b2 = b1.slice(9, 10); + assert.isEqual(0, b2.length); +}; + +exports.testByteStringNewless = function () { + assert.isEqual(1, ByteString([0]).length); + assert.isEqual(2, ByteString([0, 1], 0, 2).length); +}; + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); + diff --git a/utils/tests/serverjs/file-tests.js b/utils/tests/serverjs/file-tests.js new file mode 100755 index 0000000..0db6ac2 --- /dev/null +++ b/utils/tests/serverjs/file-tests.js @@ -0,0 +1,237 @@ + +var assert = require("test/assert"); +var fs = require("file"); +var binary = require('binary'); + +exports.testWriteRead = function() { + try { + var path = "testWriteRead.txt"; + var content = "testWriteRead.txt\n"; + fs.write(path, content); + assert.is(content, fs.read(path)); + } finally { + fs.remove(path); + } +}; + +exports.testOpenWriteReadWrongMode = function () { + var path = "testOpenWriteReadWrongMode.txt"; + var content = "testOpenWriteReadWrongMode.txt\n"; + assert.throwsError(function () { + fs.open(path).write(content).flush().close(); + fs.remove(path); + }); +}; + +exports.testOpenWriteFlushRead = function () { + try { + var path = "testOpenWriteRead.txt"; + var content = "testOpenWriteRead.txt\n"; + fs.open(path, 'w').write(content).flush().close(); + assert.is(content, fs.open(path).read()); + } finally { + fs.remove(path); + } +}; + +exports.testOpenWriteRead = function () { + try { + var path = "testOpenWriteRead.txt"; + var content = "testOpenWriteRead.txt\n"; + fs.open(path, 'w').write(content); + assert.is("", fs.open(path).read()); + } finally { + fs.remove(path); + } +}; + +exports.testOpenWriteReadFlushOnClose = function () { + try { + var path = "testOpenWriteRead.txt"; + var content = "testOpenWriteRead.txt\n"; + fs.open(path, 'w').write(content).close(); + assert.is(content, fs.open(path).read()); + } finally { + fs.remove(path); + } +}; + +exports.testPathWriteRead = function () { + try { + var path = "testOpenWriteRead.txt"; + var content = "testOpenWriteRead.txt\n"; + fs.path(path).write(content); + assert.is(content, fs.path(path).read()); + } finally { + fs.remove(path); + } +}; + +exports.testNewPathWriteRead = function () { + try { + var path = "testNewPathWriteRead.txt"; + var content = "testNewPathWriteRead.txt\n"; + new fs.Path(path).write(content); + assert.is(content, new fs.Path(path).read()); + } finally { + fs.remove(path); + } +}; + +exports.testBigPathOpenWriteRead = function () { + try { + var path = "testBigPathWriteRead.txt"; + var content = "testBigPathWriteRead.txt\n"; + fs.Path(path).write(content); + assert.is(content, fs.Path(path).read()); + } finally { + fs.remove(path); + } +}; + +exports.testLittlePathOpenWriteRead = function () { + var path = "testLittlePathWriteRead.txt"; + var content = "testLittlePathWriteRead.txt\n"; + assert.throwsError(function () { + fs.path(path).open().write(content).flush().close(); + fs.remove(path); + }); +}; + +exports.testLittlePathOpenWriteRead = function () { + try { + var path = "testLittlePathOpenWriteRead.txt"; + var content = "testLittlePathOpenWriteRead.txt\n"; + fs.path(path).open('w').write(content).flush().close(); + assert.is(content, fs.path(path).open().read()); + } finally { + fs.remove(path); + } +}; + +exports.testWriteReadNewlineEnforced = function() { + try { + var path = "testWriteReadNewlineEnforced.txt"; + var content = "testWriteReadNewlineEnforced.txt"; + fs.write(path, content); + assert.is(content + "\n", fs.read(path)); + } finally { + fs.remove(path); + } +}; + +exports.testWriteReadBinaryWrongMode = function () { + var path = "testWriteReadBinaryModeWrongMode.txt"; + var content = "\0\0\0".toByteString("ascii"); + assert.throwsError(function () { + fs.path(path).open('b').write(content).flush().close(); + fs.remove(path); + }); +}; + +exports.testWriteReadBinary = function () { + try { + var path = "testWriteReadBinary.txt"; + var content = "aaa".toByteString("ascii"); + fs.path(path).open('wb').write(content).flush().close(); + assert.eq(content, fs.path(path).open('b').read()); + } finally { + fs.remove(path); + } +}; + +exports.testWriteReadBinaryNulls = function () { + try { + var path = "testWriteReadBinaryNulls.txt"; + var content = "\0\0\0".toByteString("ascii"); + fs.path(path).open('wb').write(content).flush().close(); + assert.eq(content, fs.path(path).open('b').read()); + } finally { + fs.remove(path); + } +}; + +exports.testPrintRead = function () { + try { + var path = "testPrintRead.txt"; + fs.path(path).open('w').print("hello").print("world"); + assert.is("hello\nworld\n", fs.path(path).open().read()); + } finally { + fs.remove(path); + } +}; + +exports.testCopy = function () { + try { + fs.path("testCopyA.txt").write("testCopy").copy("testCopyB.txt"); + assert.is("testCopy\n", fs.read("testCopyB.txt")); + } finally { + fs.remove("testCopyA.txt"); + fs.remove("testCopyB.txt"); + } +}; + +exports.testCopyChain = function () { + try { + fs.path("testCopyA.txt").write("testCopy").copy("testCopyB.txt").copy("testCopyC.txt"); + assert.is("testCopy\n", fs.read("testCopyC.txt")); + } finally { + fs.remove("testCopyA.txt"); + fs.remove("testCopyB.txt"); + fs.remove("testCopyC.txt"); + } +}; + +exports.testMoveExists = function () { + try { + fs.path("testCopyA.txt").write("testCopy").move("testCopyB.txt"); + assert.isFalse(fs.exists("testCopyA.txt")); + assert.isTrue(fs.exists("testCopyB.txt")); + } finally { + if (fs.exists("testCopyA.txt")) + fs.remove("testCopyA.txt"); + if (fs.exists("testCopyB.txt")) + fs.remove("testCopyB.txt"); + } +}; + +exports.testsExists = function () { + assert.isTrue(fs.exists(module.path)); + assert.isTrue(fs.path(module.path).exists()); +}; + +exports.testsIsFile = function () { + assert.isTrue(fs.isFile(module.path)); + assert.isTrue(fs.path(module.path).isFile()); +}; + +exports.testsIsDirectoryDirname = function () { + assert.isTrue(fs.path(module.path).dirname().isDirectory()); +}; + +exports.testsIsDirectoryResolve = function () { + assert.isTrue(fs.path(module.path).resolve('.').isDirectory()); +}; + +exports.testsRenameList = function () { + try { + fs.mkdir('testsRename'); + fs.path('testsRename', 'A.txt').touch(); + assert.eq(fs.path('testsRename').list(), ['A.txt']); + fs.path('testsRename', 'A.txt').rename('B.txt'); + assert.eq(fs.path('testsRename').list(), ['B.txt']); + } finally { + fs.rmtree('testsRename'); + } +}; + +exports.testIterator = require('./file/iterator'); +exports.testExtension = require('./file/extension'); +exports.testResolve = require('./file/resolve'); +exports.testNormal = require('./file/normal'); +exports.testDirname = require('./file/dirname'); +exports.testIsAbsolute = require('./file/is-absolute'); + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); + diff --git a/utils/tests/serverjs/file/extension.js b/utils/tests/serverjs/file/extension.js new file mode 100755 index 0000000..00e5959 --- /dev/null +++ b/utils/tests/serverjs/file/extension.js @@ -0,0 +1,45 @@ + +var util = require('util'); +var assert = require('test/assert'); +var fs = require('file'); + +util.forEachApply([ + ['', ''], + ['.', ''], + ['..', ''], + ['.a', ''], + ['..a', ''], + ['.a.b', '.b'], + ['a.b', '.b'], + ['a.b.c', '.c'], + ['/', ''], + ['/.', ''], + ['/..', ''], + ['/..a', ''], + ['/.a.b', '.b'], + ['/a.b', '.b'], + ['/a.b.c', '.c'], + ['foo/', ''], + ['foo/.', ''], + ['foo/..', ''], + ['foo/..a', ''], + ['foo/.a.b', '.b'], + ['foo/a.b', '.b'], + ['foo/a.b.c', '.c'], + ['/foo/', ''], + ['/foo/.', ''], + ['/foo/..', ''], + ['/foo/..a', ''], + ['/foo/.a.b', '.b'], + ['/foo/a.b', '.b'], + ['/foo/a.b.c', '.c'] +], function (path, expected) { + exports['test ' + util.repr(path)] = function () { + var actual = fs.extension(path); + assert.eq(expected, actual, util.repr(path)); + }; +}); + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); + diff --git a/utils/tests/serverjs/file/iterator.js b/utils/tests/serverjs/file/iterator.js new file mode 100755 index 0000000..603bb51 --- /dev/null +++ b/utils/tests/serverjs/file/iterator.js @@ -0,0 +1,101 @@ + +var assert = require("test/assert"); +var fs = require("file"); + +/* a decorator that passes a path object corresponding + to the test name and removes any files created + therein afterward */ +var Test = function (block) { + var args = arguments; + var exported = function () { + for (var name in exports) { + if (exports[name] === exported) { + try { + var path = fs.path( + fs.resolve(module.path, '.'), + name + ); + block(path); + } finally { + if (path.exists()) + path.rmtree(); + } + } + } + }; + return exported; +}; + +exports.testPrintReadLine = Test(function (path) { + var stream = path.open('w'); + stream.print('hello'); + stream.print('world'); + stream.close(); + stream = path.open('r'); + assert.is('hello\n', stream.readLine()); + assert.is('world\n', stream.readLine()); + assert.is('', stream.readLine()); +}); + +exports.testPrintReadLineChain = Test(function (path) { + var stream = path.open('w'); + stream.print('hello').print('world'); + stream.close(); + stream = path.open('r'); + assert.is('hello\n', stream.readLine()); + assert.is('world\n', stream.readLine()); + assert.is('', stream.readLine()); +}); + +exports.testReadLines = Test(function (path) { + var stream = path.open('w'); + stream.print('hello').print('world'); + stream.close(); + stream = path.open('r'); + assert.eq(['hello\n', 'world\n'], stream.readLines()); +}); + +exports.testForEach = Test(function (path) { + var output = path.open('w'); + var input = path.open('r'); + output.print('1'); + output.print('1'); + var count = 0; + input.forEach(function (line) { + assert.eq('1', line); + count++; + }); + assert.eq(2, count); + output.print('2').print('2'); + input.forEach(function (line) { + assert.eq('2', line); + count++; + }); + assert.eq(4, count); + output.close(); + input.close(); +}); + +exports.testNext = Test(function (path) { + path.open('w').print('1').print('2').close(); + var iterator = path.open(); + assert.is('1', iterator.next()); + assert.is('2', iterator.next()); + assert.throwsError(function () { + iterator.next(); + }); +}); + +exports.testIterator = Test(function (path) { + path.open('w').print('1').print('2').close(); + var iterator = path.open().iterator(); + assert.is('1', iterator.next()); + assert.is('2', iterator.next()); + assert.throwsError(function () { + iterator.next(); + }); +}); + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); + diff --git a/utils/tests/serverjs/file/normal.js b/utils/tests/serverjs/file/normal.js new file mode 100755 index 0000000..8314b1d --- /dev/null +++ b/utils/tests/serverjs/file/normal.js @@ -0,0 +1,27 @@ + +var util = require('util'); +var assert = require('test/assert'); +var fs = require('file'); + +util.forEachApply([ + ['', ''], + ['.', ''], + ['./', ''], + ['../', '../'], + ['../a', '../a'], + ['../a/', '../a/'], + ['a/..', ''], + ['a/../', ''], + ['a/../b', 'b'], + ['a/../b/', 'b/'], +], function (path, expected) { + exports['test ' + util.repr(path)] = function () { + var result = ''; + var actual = fs.normal(path); + assert.eq(expected, actual, util.repr(path)); + }; +}); + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); + diff --git a/utils/tests/serverjs/file/resolve.js b/utils/tests/serverjs/file/resolve.js new file mode 100755 index 0000000..dbd33f0 --- /dev/null +++ b/utils/tests/serverjs/file/resolve.js @@ -0,0 +1,44 @@ + +var system = require('system'); +var util = require('util'); +var assert = require('test/assert'); +var fs = require('file'); + +util.forEachApply([ + [['/'], '/'], + [['/a'], '/a'], + [['/a/'], '/a/'], + [['/a', '/b'], '/b'], + [['/a', '/b/'], '/b/'], + [['/', 'a'], '/a'], + [['/', 'a/'], '/a/'], + [['/a', 'a'], '/a'], + [['/a', 'a/'], '/a/'], + [['/a/', 'a'], '/a/a'], + [['/a/', 'a/'], '/a/a/'], + [['..'], '../'], + [['..', 'a'], '../a'], + [['..', 'a/'], '../a/'], + [['.'], ''], + [['.', 'a'], 'a'], + [['.', 'a/'], 'a/'], + [['a', '.'], ''], + [['a', '.', 'a'], 'a'], + [['a', '.', 'a/'], 'a/'], + [['a', '..'], '../'], + [['a', '..', 'a'], '../a'], + [['a', '..', 'a/'], '../a/'], + [['a/', '..'], ''], + [['a/', '..', 'a'], 'a'], + [['a/', '..', 'a/'], 'a/'], + [['a/b', ''], 'a/b'], +], function (parts, expected) { + exports['test ' + util.repr(parts)] = function () { + var result = ''; + var actual = fs.resolve.apply(null, parts); + assert.eq(expected, actual, util.repr(parts)); + }; +}); + +if (require.main === module.id) + require("os").exit(require("test/runner").run(exports)); diff --git a/utils/tests/serverjs/module-tests.js b/utils/tests/serverjs/module-tests.js new file mode 100755 index 0000000..449351b --- /dev/null +++ b/utils/tests/serverjs/module-tests.js @@ -0,0 +1,9 @@ +var assert = require("test/assert"); + +exports.testModuleCharsetIsUtf8 = function () { + assert.isEqual( + 1, "♥".length, + 'unicode characters should have length of 1' + ); +}; + diff --git a/utils/tests/string-tests.js b/utils/tests/string-tests.js new file mode 100755 index 0000000..d337f07 --- /dev/null +++ b/utils/tests/string-tests.js @@ -0,0 +1,34 @@ +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)); diff --git a/utils/tests/uri-tests.js b/utils/tests/uri-tests.js new file mode 100755 index 0000000..b8f9978 --- /dev/null +++ b/utils/tests/uri-tests.js @@ -0,0 +1,18 @@ +var assert = require("test/assert"); + +var URI = require("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()); +} |