sproutit-narwhal 0.1.106

data/tests/all-tests.js

@@ -0,0 +1,17 @@
+
+exports.testString = require("./string");
+exports.testURI = require("./uri");
+exports.testQS = require("./query-string");
+exports.testHashes = require("./hashes");
+exports.testOS = require("./os/all-tests");
+exports.testFile = require("./file/all-tests");
+exports.testUtil = require("./util/all-tests");
+exports.testArgs = require("./args");
+
+exports.testGlobal = require("./global");
+
+exports.testCommonjs = require("./commonjs/all-tests");
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/args.js

@@ -0,0 +1,31 @@
+
+var util = require('util');
+var args = require('args');
+var assert = require('test/assert');
+
+// subclass Parser to prevent it from assertively
+// exiting the test suite
+var Parser = exports.Parser = function () {
+    args.Parser.apply(this, arguments);
+};
+Parser.prototype = Object.create(args.Parser.prototype);
+Parser.prototype.constructor = Parser;
+Parser.prototype.exit = function () {
+    throw new Exit();
+};
+Parser.prototype.print = function () {
+    if (system.debug)
+        args.Parser.prototype.print.apply(this, arguments);
+};
+var Exit = exports.Exit = function () {
+    Error.apply(this, arguments);
+};
+Exit.prototype = Object.create(Error.prototype);
+
+exports.testOptions = require("./args/options");
+exports.testDomain = require("./args/domain");
+exports.testShifting = require("./args/shifting");
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/args/domain.js

@@ -0,0 +1,215 @@
+
+var util = require('util');
+var args = require('args');
+var assert = require('test/assert');
+var test = require('../args');
+
+exports.testCommand = function () {
+    var parser = new test.Parser();
+    var options = parser.parse(['command']);
+    assert.eq('command', options.command);
+};
+
+exports.testNoOptionNameError = function () {
+    var parser = new test.Parser();
+    assert.throwsError(function () {
+        parser.option();
+    }, args.ConfigurationError);
+};
+
+exports.testOptionNameShort = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o');
+    assert.eq('o', option.getName());
+};
+
+exports.testOptionNameLong = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o', '--option');
+    assert.eq('option', option.getName());
+};
+
+exports.testOptionNameDisplay = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o', 'option');
+    assert.eq('option', option.getName());
+};
+
+exports.testOptionSet = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').set();
+    var options = parser.parse(['command', '-o', 'value']);
+    assert.eq('command', options.command);
+    assert.eq('value', options.o);
+    assert.eq([], options.args);
+};
+
+exports.testOptionSetNotEnoughArgs = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').set();
+    assert.throwsError(function () {
+        parser.parse(['command', '-o']);
+    });
+};
+
+exports.testOptionSetTrue = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').set(true);
+    var options = parser.parse(['command', '-o']);
+    assert.eq('command', options.command);
+    assert.eq(true, options.o);
+    assert.eq([], options.args);
+};
+
+exports.testOptionNumber = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').number();
+    var options = parser.parse(['command', '-o', '1.1']);
+    assert.eq(1.1, options.o);
+    var options = parser.parse(['command', '-o', '-1.1']);
+    assert.eq(-1.1, options.o);
+};
+
+exports.testOptionNumberError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').number();
+    assert.throwsError(function () {
+        var options = parser.parse(['command', '-o', 'TEXT']);
+    }, test.Exit);
+};
+
+exports.testOptionInteger = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').integer();
+    var options = parser.parse(['command', '-o', '1']);
+    assert.eq(1, options.o);
+    var options = parser.parse(['command', '-o', '-1']);
+    assert.eq(-1, options.o);
+};
+
+exports.testOptionIntegerDomainRationalError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').integer();
+    assert.throwsError(function () {
+        var options = parser.parse(['command', '-o', '1.1']);
+    }, test.Exit);
+};
+
+exports.testOptionIntegerDomainParseError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').integer();
+    assert.throwsError(function () {
+        var options = parser.parse(['command', '-o', 'TEXT']);
+    }, test.Exit);
+};
+
+exports.testOptionNatural = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').natural();
+    var options = parser.parse(['command', '-o', '1']);
+    assert.eq(1, options.o);
+};
+
+exports.testOptionNaturalDomainPositiveError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').natural();
+    assert.throwsError(function () {
+        var options = parser.parse(['command', '-o', '-1']);
+    }, test.Exit);
+};
+
+exports.testOptionNaturalDomainRationalError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').natural();
+    assert.throwsError(function () {
+        var options = parser.parse(['command', '-o', '1.1']);
+    }, test.Exit);
+};
+
+exports.testOptionNaturalParseError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').natural();
+    assert.throwsError(function () {
+        var options = parser.parse(['command', '-o', 'TEXT']);
+    }, test.Exit);
+};
+
+exports.testOptionOct = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').oct();
+    var options = parser.parse(['command', '-o', '755']);
+    assert.eq(0755, options.o);
+};
+
+exports.testOptionOctError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').oct();
+    assert.throwsError(function () {
+        var options = parser.parse(['command', '-o', 'TEXT']);
+    }, test.Exit);
+};
+
+exports.testOptionHex = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').hex();
+    var options = parser.parse(['command', '-o', 'ff']);
+    assert.eq(0xFF, options.o);
+};
+
+exports.testOptionHexError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').hex();
+    assert.throwsError(function () {
+        var options = parser.parse(['command', '-o', 'TEXT']);
+    }, test.Exit);
+};
+
+exports.testOptionNatural = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').natural();
+    var options = parser.parse(['command', '-o', '1']);
+    assert.eq(1, options.o);
+};
+
+exports.testOptionNaturalDomainError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').natural();
+    assert.throwsError(function () {
+        parser.parse(['command', '-o', '-1']);
+    });
+};
+
+exports.testOptionNaturalParseError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').natural();
+    assert.throwsError(function () {
+        parser.parse(['command', '-o', 'TEST']);
+    });
+};
+
+exports.testOptionWhole = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').whole();
+    var options = parser.parse(['command', '-o', '1']);
+    assert.eq(1, options.o);
+};
+
+exports.testOptionWholeDomainError = function () {
+    var parser = new test.Parser();
+    var option = parser.option('-o').whole();
+    assert.throwsError(function () {
+        parser.parse(['command', '-o', '0']);
+    }, Error);
+};
+
+exports.testNoActionForOptionError = function () {
+    var parser = new test.Parser();
+    parser.option('-o');
+    assert.throwsError(function () {
+        parser.parse(['command', '-o']);
+    }, args.ConfigurationError);
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/args/options.js

@@ -0,0 +1,36 @@
+var args = require('args');
+var assert = require("test/assert");
+var test = require("../args");
+
+exports.testBasis = function () {
+    var parser = new test.Parser();
+    var options = parser.parse([]);
+    assert.eq(["args"], Object.keys(options));
+};
+
+exports.testShortOptionSetUnnamed = function () {
+    var parser = new test.Parser();
+    parser.option('-o').set();
+    var options = parser.parse(['c', '-o', 'a']);
+    assert.eq("a", options.o);
+    assert.eq(["args", "command", "o"], Object.keys(options));
+};
+
+exports.testLongOptionSetUnnamed = function () {
+    var parser = new test.Parser();
+    parser.option('-o', '--option').set();
+    var options = parser.parse(['c', '--option', 'a']);
+    assert.eq("a", options.option);
+    assert.eq(["args", "command", "option"], Object.keys(options));
+};
+
+exports.testLongOptionSet = function () {
+    var parser = new test.Parser();
+    parser.option('-o', '--option', 'option').set();
+    var options = parser.parse(['c', '--option', 'a']);
+    assert.eq("a", options.option);
+    assert.eq(["args", "command", "option"], Object.keys(options));
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));

data/tests/args/shifting.js

@@ -0,0 +1,92 @@
+
+var args = require('args');
+var assert = require("test/assert");
+var test = require("../args");
+
+function Parser() {
+    var parser = new test.Parser();
+    parser.option('-s', '--set').set();
+    parser.option('-f', '--flag').set(true);
+    parser.option('-2', '--two')
+        .action(function (options, name, a, b) {
+            options[name] = [a, b];
+        });
+    return parser;
+};
+
+exports.testSetShort = function () {
+    var parser = Parser();
+    var options = parser.parse(['command', '-s', 'value']);
+    assert.eq('value', options.set);
+    assert.eq([], options.args);
+};
+
+exports.testSetShortMerged = function () {
+    var parser = Parser();
+    var options = parser.parse(['command', '-svalue']);
+    assert.eq('value', options.set);
+    assert.eq([], options.args);
+};
+
+exports.testFlagSetShortMerged = function () {
+    var parser = Parser();
+    var options = parser.parse(['command', '-fsvalue']);
+    assert.eq(true, options.flag);
+    assert.eq('value', options.set);
+    assert.eq([], options.args);
+};
+
+exports.testFlagSetShortMergedRemainder = function () {
+    var parser = Parser();
+    var options = parser.parse(['command', '-fsvalue', 'hi']);
+    assert.eq('command', options.command);
+    assert.eq(true, options.flag);
+    assert.eq('value', options.set);
+    assert.eq(['hi'], options.args);
+};
+
+exports.testTwoShort = function () {
+    var parser = Parser();
+    var options = parser.parse(['command', '-2', 'a', 'b', 'c']);
+    assert.eq(['a', 'b'], options.two);
+    assert.eq(['c'], options.args);
+};
+
+exports.testTwoShortMerged = function () {
+    var parser = Parser();
+    var options = parser.parse(['command', '-2a', 'b', 'c']);
+    assert.eq(['a', 'b'], options.two);
+    assert.eq(['c'], options.args);
+};
+
+exports.testSetLong = function () {
+    var parser = Parser();
+    var options = parser.parse(['command', '--set', 'value']);
+    assert.eq('value', options.set);
+    assert.eq([], options.args);
+};
+
+exports.testSetLongMerged = function () {
+    var parser = Parser();
+    var options = parser.parse(['command', '--set=value']);
+    assert.eq('value', options.set);
+    assert.eq([], options.args);
+};
+
+exports.testHaltOptions = function () {
+    var parser = Parser();
+    var options = parser.parse(['command', '--', '-svalue']);
+    assert.eq(undefined, options.set);
+    assert.eq(['-svalue'], options.args);
+};
+
+exports.testNoSuchOption = function () {
+    var parser = Parser();
+    assert.throwsError(function () {
+        parser.parse(['command', '--no-such-option']);
+    }, test.Exit)
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/args/validation.js

@@ -0,0 +1,31 @@
+
+var util = require('util');
+var args = require('args');
+var assert = require('test/assert');
+var test = require('../args');
+
+exports.testValidateMultiple = function () {
+    var parser = new test.Parser();
+    parser.option('-o')
+        .action(function (options, name, value) {
+        })
+        .validate(function (value) {
+        })
+};
+
+exports.testValidatorChain = function () {
+    var parser = new test.Parser();
+    parser.option('-o')
+        .action(function (options, name, value) {
+        })
+        .validate(function (value) {
+            return value;
+        })
+        .validate(function (value) {
+            return value;
+        })
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/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));
+