sproutit-narwhal 0.1.106

data/tests/commonjs/bytestring-encodings-tests.js

@@ -0,0 +1,89 @@
+var assert = require("test/assert");
+
+var Binary = require("binary").Binary,
+    ByteString = require("binary").ByteString,
+    ByteArray = require("binary").ByteArray;
+
+exports.testByteStringConstructorEncodings = function() {
+    // ByteString(string, charset)
+    // Convert a string. The ByteString will contain string encoded with charset.
+    var testString = "hello world";
+    var b4 = new ByteString(testString, "ASCII");
+    assert.isEqual(testString.length, b4.length, "6543");
+    b4.length = 123;
+    assert.isEqual(testString.length, b4.length, "asdf");
+    assert.isEqual(testString.charCodeAt(0), b4.get(0), "234");
+    assert.isEqual(testString.charCodeAt(testString.length-1), b4.get(testString.length-1), "zxcv");
+};
+
+exports.testToByteStringConstructorUnicode = function() {
+    var testString = "I ♥ JS";
+    var b = new ByteString(testString, "UTF-8");
+    
+    assert.isEqual(8, b.length, "length");
+    
+    assert.isEqual(0x49, b.get(0), "expected I");
+    assert.isEqual(0x20, b.get(1), "expected [space]");
+    assert.isEqual(0xE2, b.get(2), "expected heart byte 1");
+    assert.isEqual(0x99, b.get(3), "expected heart byte 1");
+    assert.isEqual(0xA5, b.get(4), "expected heart byte 1");
+    assert.isEqual(0x20, b.get(5), "expected [space]");
+    assert.isEqual(0x4A, b.get(6), "expected J");
+    assert.isEqual(0x53, b.get(7), "expected S");
+}
+
+exports.testToByteArrayEncodings = function() {
+    var testString = "I ♥ JS";
+    assert.isEqual(testString, new ByteString(testString, "UTF-8").toByteArray("UTF-8", "UTF-16").decodeToString("UTF-16"));
+};
+
+exports.testToByteStringEncodings = function() {
+    var testString = "I ♥ JS";
+    assert.isEqual(testString, new ByteString(testString, "UTF-8").toByteString("UTF-8", "UTF-16").decodeToString("UTF-16"));
+};
+
+exports.testToArrayEncodings = function() {
+    var a1;
+    
+    a1 = new ByteString("\u0024\u00A2\u20AC", "UTF-8").toArray("UTF-8");
+    assert.isEqual(3, a1.length);
+    assert.isEqual(0x24, a1[0]);
+    assert.isEqual(0xA2, a1[1]);
+    assert.isEqual(0x20AC, a1[2]);
+    
+    a1 = new ByteString("\u0024\u00A2\u20AC", "UTF-16").toArray("UTF-16");
+    assert.isEqual(3, a1.length);
+    assert.isEqual(0x24, a1[0]);
+    assert.isEqual(0xA2, a1[1]);
+    assert.isEqual(0x20AC, a1[2]);
+};
+
+exports.testDecodeToString = function() {
+    assert.isEqual("hello world", new ByteString("hello world", "US-ASCII").decodeToString("US-ASCII"));
+    
+    assert.isEqual("I ♥ JS", new ByteString("I ♥ JS", "UTF-8").decodeToString("UTF-8"));
+    
+    assert.isEqual("\u0024", new ByteString([0x24]).decodeToString("UTF-8"));
+    assert.isEqual("\u00A2", new ByteString([0xC2,0xA2]).decodeToString("UTF-8"));
+    assert.isEqual("\u20AC", new ByteString([0xE2,0x82,0xAC]).decodeToString("UTF-8"));
+    // FIXME:
+    //assert.isEqual("\u10ABCD", (new ByteString([0xF4,0x8A,0xAF,0x8D])).decodeToString("UTF-8"));
+    
+    assert.isEqual("\u0024", new ByteString("\u0024", "UTF-8").decodeToString("UTF-8"));
+    assert.isEqual("\u00A2", new ByteString("\u00A2", "UTF-8").decodeToString("UTF-8"));
+    assert.isEqual("\u20AC", new ByteString("\u20AC", "UTF-8").decodeToString("UTF-8"));
+    assert.isEqual("\u10ABCD", new ByteString("\u10ABCD", "UTF-8").decodeToString("UTF-8"));
+    
+    assert.isEqual("\u0024", new ByteString("\u0024", "UTF-16").decodeToString("UTF-16"));
+    assert.isEqual("\u00A2", new ByteString("\u00A2", "UTF-16").decodeToString("UTF-16"));
+    assert.isEqual("\u20AC", new ByteString("\u20AC", "UTF-16").decodeToString("UTF-16"));
+    assert.isEqual("\u10ABCD", new ByteString("\u10ABCD", "UTF-16").decodeToString("UTF-16"));
+};
+
+exports.testStringToByteString = function() {
+    assert.isEqual("hello world", "hello world".toByteString("US-ASCII").decodeToString("US-ASCII"));
+    assert.isEqual("I ♥ JS", "I ♥ JS".toByteString("UTF-8").decodeToString("UTF-8"));
+};
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));

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

data/tests/commonjs/es5/all-tests.js

@@ -0,0 +1,3 @@
+exports.testFunctionBind = require("./bind");
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));

data/tests/commonjs/es5/bind.js

@@ -0,0 +1,29 @@
+
+var assert = require("test/assert");
+
+exports.testThis = function () {
+    var foo = function (y) {
+        return this.x + y;
+    };
+    assert.eq(20, foo.bind({x:10})(10));
+};
+
+exports.testPartial = function () {
+    var foo = function (y) {
+        return this.x + y;
+    };
+    assert.eq(20, foo.bind({x:10}, 10)());
+};
+
+exports.testConstructor = function () {
+    var Foo = function (x, y) {
+        this.a = x + y;
+    };
+    assert.eq(30, new (Foo.bind())(10, 20).a);
+    assert.eq(30, new (Foo.bind(10))(20).a);
+    assert.eq(30, new (Foo.bind(10, 20))().a);
+};
+
+if (require.main == module.id)
+    require("os").exit(require("test/runner").run(exports));
+

data/tests/commonjs/file-tests.js

@@ -0,0 +1,315 @@
+
+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";
+        if (fs.exists(path)) fs.remove(path);
+        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, 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.testLittlePathOpenWriteRead1 = 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.testWriteReadNewlineNotEnforced = function() {
+    try {
+        var path = "testWriteReadNewlineNotEnforced.txt";
+        var content = "testWriteReadNewlineNotEnforced.txt";
+        fs.write(path, content);
+        assert.is(content, fs.read(path));
+    } 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.testOverwriteFile = function() {
+    var path = "testOverwriteFile.txt";
+    var a = "hello world";
+    var b = "hello";
+    try {
+        fs.write(path, a);
+        assert.is(a, fs.read(path));
+        assert.is(a.length, fs.size(path));
+        fs.write(path, b);
+        assert.is(b, fs.read(path));
+        assert.is(b.length, fs.size(path));
+    } finally {
+        if (fs.isFile(path))
+            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\n").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\n").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 () {
+    var testString = "testCopy";
+    try {
+        fs.path("testCopyA.txt").write(testString).move("testCopyB.txt");
+        assert.isFalse(fs.exists("testCopyA.txt"));
+        assert.isTrue(fs.exists("testCopyB.txt"));
+        assert.is(fs.size("testCopyB.txt"), testString.length);
+    } 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.testsMkdir = function () {
+    try {
+        fs.mkdir('testMkdir');
+        assert.isTrue(fs.exists('testMkdir'));
+        assert.isTrue(fs.isDirectory('testMkdir'));
+        assert.isFalse(fs.isFile('testMkdir'));
+    } finally {
+        fs.rmtree('testMkdir');
+    }
+};
+
+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.testsMtime = function () {
+    try {
+        fs.mkdir('testsMtime');
+        
+        // add/subtract 1 second to account for lower precision of mtime
+        var before = new Date().getTime() - 1000;
+        fs.path('testsMtime', 'A.txt').touch();
+        var after = new Date().getTime() + 1000;
+        
+        var mtime = fs.path('testsMtime', 'A.txt').mtime().getTime();
+        
+        assert.isTrue(before <= mtime, "Expected " + before + " <= " + mtime);
+        assert.isTrue(mtime <= after, "Expected " + mtime + " <= " + after);
+    } finally {
+        fs.rmtree('testsMtime');
+    }
+};
+
+exports.testEmptyStringIsDirectory = function() {
+    assert.isTrue(fs.isDirectory(""), "'' should be a directory");
+}
+exports.testDotIsDirectory = function() {
+    assert.isTrue(fs.isDirectory("."), "'.' should be a directory");
+}
+exports.testCwdIsDirectory = function() {
+    assert.isTrue(fs.isDirectory(fs.cwd()), fs.cwd() + " should be a directory");
+}
+exports.testIsNotDirectory = function() {
+    assert.isFalse(fs.isDirectory("hopefully-not-a-directory"), "'hopefully-not-a-directory' shouldn't be a directory");
+}
+
+exports.testCwd = function() {
+    assert.eq(system.env["PWD"], fs.cwd(), "Ensure the PWD environment variable is set!");
+}
+
+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));
+