sproutit-narwhal 0.1.106

data/tests/commonjs/modules/cyclic/test.js

@@ -0,0 +1,9 @@
+
+exports.assert = function (guard, message) {
+    if (guard) {
+        print('PASS ' + message, 'pass');
+    } else {
+        print('FAIL ' + message, 'fail');
+    }
+};
+

data/tests/commonjs/modules/determinism/program.js

@@ -0,0 +1,3 @@
+var test = require('test');
+require('submodule/a');
+print('DONE', 'info');

data/tests/commonjs/modules/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.')

data/tests/commonjs/modules/determinism/submodule/b.js

@@ -0,0 +1,2 @@
+
+

data/tests/commonjs/modules/determinism/test.js

@@ -0,0 +1,9 @@
+
+exports.assert = function (guard, message) {
+    if (guard) {
+        print('PASS ' + message, 'pass');
+    } else {
+        print('FAIL ' + message, 'fail');
+    }
+};
+

data/tests/commonjs/modules/exactExports/a.js

@@ -0,0 +1,3 @@
+exports.program = function () {
+    return require('program');
+};

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

data/tests/commonjs/modules/exactExports/test.js

@@ -0,0 +1,9 @@
+
+exports.assert = function (guard, message) {
+    if (guard) {
+        print('PASS ' + message, 'pass');
+    } else {
+        print('FAIL ' + message, 'fail');
+    }
+};
+

data/tests/commonjs/modules/hasOwnProperty/program.js

@@ -0,0 +1,3 @@
+var hasOwnProperty = require('hasOwnProperty');
+var toString = require('toString');
+print('DONE', 'info');

data/tests/commonjs/modules/hasOwnProperty/test.js

@@ -0,0 +1,9 @@
+
+exports.assert = function (guard, message) {
+    if (guard) {
+        print('PASS ' + message, 'pass');
+    } else {
+        print('FAIL ' + message, 'fail');
+    }
+};
+

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

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

data/tests/commonjs/modules/method/test.js

@@ -0,0 +1,9 @@
+
+exports.assert = function (guard, message) {
+    if (guard) {
+        print('PASS ' + message, 'pass');
+    } else {
+        print('FAIL ' + message, 'fail');
+    }
+};
+

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

data/tests/commonjs/modules/missing/test.js

@@ -0,0 +1,9 @@
+
+exports.assert = function (guard, message) {
+    if (guard) {
+        print('PASS ' + message, 'pass');
+    } else {
+        print('FAIL ' + message, 'fail');
+    }
+};
+

data/tests/commonjs/modules/monkeys/a.js

@@ -0,0 +1 @@
+require('program').monkey = 10;

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

data/tests/commonjs/modules/monkeys/test.js

@@ -0,0 +1,9 @@
+
+exports.assert = function (guard, message) {
+    if (guard) {
+        print('PASS ' + message, 'pass');
+    } else {
+        print('FAIL ' + message, 'fail');
+    }
+};
+

data/tests/commonjs/modules/nested/a/b/c/d.js

@@ -0,0 +1,3 @@
+exports.foo = function () {
+    return 1;
+};

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

data/tests/commonjs/modules/nested/test.js

@@ -0,0 +1,9 @@
+
+exports.assert = function (guard, message) {
+    if (guard) {
+        print('PASS ' + message, 'pass');
+    } else {
+        print('FAIL ' + message, 'fail');
+    }
+};
+

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

data/tests/commonjs/modules/relative/submodule/a.js

@@ -0,0 +1 @@
+exports.foo = require('./b').foo;

data/tests/commonjs/modules/relative/submodule/b.js

@@ -0,0 +1,2 @@
+exports.foo = function () {
+};

data/tests/commonjs/modules/relative/test.js

@@ -0,0 +1,9 @@
+
+exports.assert = function (guard, message) {
+    if (guard) {
+        print('PASS ' + message, 'pass');
+    } else {
+        print('FAIL ' + message, 'fail');
+    }
+};
+

data/tests/commonjs/modules/transitive/a.js

@@ -0,0 +1 @@
+exports.foo = require('b').foo;

data/tests/commonjs/modules/transitive/b.js

@@ -0,0 +1 @@
+exports.foo = require('c').foo;

data/tests/commonjs/modules/transitive/c.js

@@ -0,0 +1,3 @@
+exports.foo = function () {
+    return 1;
+};

data/tests/commonjs/modules/transitive/program.js

@@ -0,0 +1,3 @@
+var test = require('test');
+test.assert(require('a').foo() == 1, 'transitive');
+print('DONE', 'info');

data/tests/commonjs/modules/transitive/test.js

@@ -0,0 +1,9 @@
+
+exports.assert = function (guard, message) {
+    if (guard) {
+        print('PASS ' + message, 'pass');
+    } else {
+        print('FAIL ' + message, 'fail');
+    }
+};
+

data/tests/file/all-tests.js

@@ -0,0 +1,61 @@
+var assert = require("test/assert");
+var fs = require("file");
+
+exports.testIsLink = function () {
+    
+    var here = fs.path(module.path).dirname().join("_test");
+    if (here.exists()) {
+        here.rmtree();
+    }
+    here.mkdirs();
+    try {
+        var dir1 = here.join("dir1");
+        dir1.mkdirs();
+        var dir2 = here.join("dir2");
+        dir2.mkdirs();
+        dir2.join("file2").touch();
+
+        dir2.symlink(dir1.join("linkToDir2"));
+
+        assert.isFalse(dir2.isLink());
+        assert.isTrue(dir1.join("linkToDir2").isLink());
+
+        dir2.join("file2").symlink(dir1.join("linkToFile1"));
+
+        assert.isFalse(dir2.join("file2").isLink());
+        assert.isTrue(dir1.join("linkToFile1").isLink());
+    } finally {
+        here.rmtree();
+    }
+}
+
+exports.testRmtreeDoesNotFollowSymlinks = function () {
+    var here = fs.path(module.path).dirname().join("_test");
+    if (here.exists()) {
+        here.rmtree();
+    }
+    here.mkdirs();
+    try {
+        var dir1 = here.join("dir1");
+        dir1.mkdirs();
+        var dir2 = here.join("dir2");
+        dir2.mkdirs();
+        dir2.symlink(dir1.join("linkToDir2"));
+        dir2.join("file2").touch();
+
+        dir1.rmtree();
+
+        assert.isFalse(dir1.exists());
+        assert.isTrue(dir2.exists());
+        assert.isTrue(dir2.join("file2").exists());
+    } finally {
+        here.rmtree();
+    }
+};
+
+exports.testFileFNMatch = require("./fnmatch");
+exports.testFileMatch = require("./match");
+exports.testFileMatch = require("./glob");
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));

data/tests/file/fnmatch.js

@@ -0,0 +1,102 @@
+var assert = require("test/assert");
+var fs = require("file");
+var util = require("util");
+
+var tests = [
+    [true,  'cat',          'cat'],
+    [false, 'cat',          'category'],
+    
+    //[false, 'c{at,ub}s',    'cats'],
+    //[false, 'c{at,ub}s',    'cubs'],
+    [true, 'c{at,ub}s',    'cats'],
+    [true, 'c{at,ub}s',    'cubs'],
+    [false, 'c{at,ub}s',    'cat'],
+    
+    [true,  'c?t',          'cat'],
+    [false, 'c\\?t',        'cat'],
+    [false, 'c??t',         'cat'],
+    [true,  'c*',           'cats'],
+    [true,  'c/*/t',        'c/a/b/c/t'],
+    [true,  'c\at',         'cat'],
+    [false, 'c\\at',        'cat', fs.FNM_NOESCAPE],
+    
+    [true,  'a?b',          'a/b'],
+    [false, 'a?b',          'a/b', fs.FNM_PATHNAME],
+    
+    [false, '*',            '.profile'],
+    [false, '.*',           'profile'],
+    [true,  '.*',           '.profile'],
+    [true,  '*',            '.profile', fs.FNM_PERIOD],
+    
+    [true,  '*',            'dave/.profile'],
+    [true,  '*',            'dave/.profile', fs.FNM_PERIOD],
+    [true,  '*',            'dave/profile'],
+    [false, '*',            'dave/profile', fs.FNM_PATHNAME],
+    [false, '*',            'dave/.profile', fs.FNM_PATHNAME],
+    [true,  '*/*',          'dave/profile', fs.FNM_PATHNAME],
+    [false, '*/*',          'dave/.profile', fs.FNM_PATHNAME],
+    [true,  '*/*',          'dave/.profile', fs.FNM_PATHNAME | fs.FNM_PERIOD],
+
+    [true,  'ca[a-z]',      'cat'],
+    [false, '[a-z]',        'D'],
+    [true,  '[^a-z]',       'D'],
+    [false, '[A-Z]',        'd'],
+    [true,  '[^A-Z]',       'd'],
+    [true,  '[a-z]',        'D', fs.FNM_CASEFOLD],
+    [true,  '[A-Z]',        'd', fs.FNM_CASEFOLD],
+    [false, '/ca[s][s-t]/rul[a-b]/[z]he/[x-Z]orld', '/cats/rule/the/World'],
+    [true,  '/ca[t][s-t]/rul[a-e]/[t]he/[A-Z]orld', '/cats/rule/the/World'],
+
+    [false, 'cat',          'CAT'],
+    [true,  'cat',          'CAT', fs.FNM_CASEFOLD],
+
+    [false, 'ca[!t]',       'cat'],
+    [false, 'ca[^t]',       'cat'],
+
+    [false, '?',            '/', fs.FNM_PATHNAME],
+    [false, '*',            '/', fs.FNM_PATHNAME],
+
+    [true,  '\\?',          '?'],
+    [false, '\\?',          'a'],
+    [true,  '\\*',          '*'],
+    [false, '\\*',          'a'],
+    [true,  '\\a',          'a'],
+    [true,  'this\\b',      'thisb'],
+    [true,  '\\a',          '\\a', fs.FNM_NOESCAPE],
+    [false, '\\a',          'a', fs.FNM_NOESCAPE],
+    [false, '\\[foo\\]\\[bar\\]', '[foo][bar]', fs.FNM_NOESCAPE],
+    [true,  '\\[foo\\]\\[bar\\]', '[foo][bar]'],
+    [true,  '[\\?]',        '?'],
+    [true,  '[\\*]',        '*'],
+
+    [false, '**/*.j',       'main.j'],
+    [false, '**/*.j',       './main.j'],
+    [true,  '**/*.j',       'lib/main.j'],
+    [true,  '**.j',         'main.j'],
+    [false, '**.j',         './main.j'],
+    [true,  '**.j',         'lib/main.j'],
+    [true,  '*',            'dave/.profile'],
+
+    [true,  '**/*.j',       'main.j', fs.FNM_PATHNAME],
+    [true,  '**/*.j',       'one/two/three/main.j', fs.FNM_PATHNAME],
+    [false, '**/*.j',       './main.j', fs.FNM_PATHNAME],
+
+    [true,  '**/*.j',       './main.j', fs.FNM_PATHNAME|fs.FNM_DOTMATCH],
+    [true,  '**/*.j',       'one/two/.main.j', fs.FNM_PATHNAME|fs.FNM_DOTMATCH],
+    [true,  '**/best/*',    'lib/my/best/song.j'],
+
+    [false, '**/foo',       'a/.b/c/foo', fs.FNM_PATHNAME],
+    [true,  '**/foo',       'a/b/c/foo', fs.FNM_PATHNAME],
+    [true,  '**/foo',       '/a/b/c/foo', fs.FNM_PATHNAME],
+    [true,  '**/foo',       'a/.b/c/foo', fs.FNM_PATHNAME|fs.FNM_PERIOD]
+];
+
+tests.forEach(function(test, n) {
+    exports["test "+util.repr(test)] = function() {
+        assert.eq(test[0], fs.fnmatch.apply(fs, test.slice(1)),
+                  "expect '"+test[1]+"' "+(test[0] ? "matches" : "doesn't match" )+" '"+test[2]+"'");
+    }
+});
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));

data/tests/file/glob.js

@@ -0,0 +1,466 @@
+var FILE = require("file"),
+    assert = require("test/assert");
+
+// note: need doubled \\ to properly escape in JS
+
+// from RubySpec
+function create_mock_dirs(mock_dir) {
+    mock_dir = FILE.path(mock_dir);
+    var files = [
+        ".dotfile",
+        ".dotsubdir/.dotfile",
+        ".dotsubdir/nondotfile",
+
+        "deeply/.dotfile",
+        "deeply/nested/.dotfile.ext",
+        "deeply/nested/directory/structure/.ext",
+        "deeply/nested/directory/structure/bar",
+        "deeply/nested/directory/structure/baz",
+        "deeply/nested/directory/structure/file_one",
+        "deeply/nested/directory/structure/file_one.ext",
+        "deeply/nested/directory/structure/foo",
+        "deeply/nondotfile",
+
+        "file_one.ext",
+        "file_two.ext",
+
+        "dir_filename_ordering",
+        "dir/filename_ordering",
+
+        "nondotfile",
+
+        "subdir_one/.dotfile",
+        "subdir_one/nondotfile",
+        "subdir_two/nondotfile",
+        "subdir_two/nondotfile.ext",
+
+        "special/+",
+
+        "special/^",
+        "special/$",
+
+        "special/(",
+        "special/)",
+        "special/[",
+        "special/]",
+        "special/{",
+        "special/}",
+        
+        // these three (and corresponding tests) aren't valid on Windows
+        "special/*",
+        "special/?",
+        "special/|"
+    ];
+    
+    files.forEach(function(file) {
+        var file = mock_dir.join(file);
+        
+        file.dirname().mkdirs();
+        file.touch();
+    });
+}
+
+function mockDirs(test) {
+    try {
+        create_mock_dirs("testGlob");
+        test(FILE.path("testGlob"));
+    } finally {
+        FILE.rmtree("testGlob")
+    }
+}
+
+var expected_paths = [
+    ".",
+    "..",
+    ".dotfile",
+    ".dotsubdir",
+    "deeply",
+    "dir",
+    "dir_filename_ordering",
+    "file_one.ext",
+    "file_two.ext",
+    "nondotfile",
+    "special",
+    "subdir_one",
+    "subdir_two"
+];
+
+exports["tests matches both dot and non-dotfiles with '*' and option File::FNM_DOTMATCH"] = function() {
+    var expected = [
+        ".",
+        "..",
+        ".dotfile",
+        ".dotsubdir",
+        "deeply",
+        "dir",
+        "dir_filename_ordering",
+        "file_one.ext",
+        "file_two.ext",
+        "nondotfile",
+        "special",
+        "subdir_one",
+        "subdir_two"
+    ];
+    
+    mockDirs(function(dir) {
+        assert.eq(expected, dir.glob("*", FILE.FNM_DOTMATCH).sort());
+    });
+}
+
+exports["tests matches files with any beginning with '*<non-special characters>' and option File::FNM_DOTMATCH"] = function() {
+    var expected = [".dotfile", "nondotfile"];
+    
+    mockDirs(function(dir) {
+        assert.eq(expected, dir.glob("*file", FILE.FNM_DOTMATCH).sort());
+    });
+}
+
+exports["tests matches any files in the current directory with '**' and option File::FNM_DOTMATCH"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(expected_paths, dir.glob("**", FILE.FNM_DOTMATCH).sort());
+    });
+}
+
+exports["tests recursively matches any subdirectories except './' or '../' with '**/' and option File::FNM_DOTMATCH"] = function() {
+    var expected = [
+        ".dotsubdir/",
+        "deeply/",
+        "deeply/nested/",
+        "deeply/nested/directory/",
+        "deeply/nested/directory/structure/",
+        "dir/",
+        "special/",
+        "subdir_one/",
+        "subdir_two/"
+    ];
+    
+    mockDirs(function(dir) {
+        assert.eq(expected, dir.glob("**/", FILE.FNM_DOTMATCH).sort());
+    });
+}
+
+exports["tests matches the literal character '\\' with option File::FNM_NOESCAPE"] = function() {
+    FILE.mkdirs('foo?bar');
+    try {
+        assert.eq(["foo?bar"], FILE.glob('foo?bar', FILE.FNM_NOESCAPE));
+        assert.eq([], FILE.glob('foo\\?bar', FILE.FNM_NOESCAPE));
+    } finally {
+        FILE.rmdir('foo?bar');
+    }
+
+    FILE.mkdir('foo\\?bar');
+    try {
+        assert.eq(["foo\\?bar"], FILE.glob('foo\\?bar', FILE.FNM_NOESCAPE));
+    } finally {
+        FILE.rmdir('foo\\?bar');
+    }
+}
+
+exports["tests returns nil for directories current user has no permission to read"] = function() {
+    FILE.mkdirs('no_permission');
+    FILE.chmod('no_permission', 0);
+
+    try {
+        assert.eq(null, FILE.glob('no_permission/*'));
+    } finally {
+        FILE.rmdir('no_permission')
+    }
+}
+
+// exports["tests converts patterns with to_str"] = function() {
+//   obj = mock('file_one.ext')
+//   obj.should_receive(:to_str).and_return('file_one.ext')
+// 
+//   Dir.send(@method, obj).should == %w[file_one.ext]
+// }
+
+exports["tests matches non-dotfiles with '*'"] = function() {
+    var expected = [
+        "deeply",
+        "dir",
+        "dir_filename_ordering",
+        "file_one.ext",
+        "file_two.ext",
+        "nondotfile",
+        "special",
+        "subdir_one",
+        "subdir_two"
+    ];
+    
+    mockDirs(function(dir) {
+        assert.eq(expected, dir.glob("**").sort());
+    });
+}
+
+exports["tests returns empty array when empty pattern provided"] = function() {
+    mockDirs(function(dir) {
+        assert.eq([], dir.glob("").sort());
+    });
+}
+
+exports["tests matches regexp special +"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/+'], dir.glob('special/+').sort());
+    });
+}
+
+exports["tests matches regexp special *"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/*'], dir.glob("special/\\*").sort());
+    });
+}
+
+exports["tests matches regexp special ?"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/?'], dir.glob("special/\\?").sort());
+    });
+}
+
+exports["tests matches regexp special |"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/|'], dir.glob("special/|").sort());
+    });
+}
+
+exports["tests matches regexp special ^"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/^'], dir.glob("special/^").sort());
+    });
+}
+
+exports["tests matches regexp special $"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/$'], dir.glob("special/$").sort());
+    });
+}
+
+exports["tests matches regexp special ("] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/('], dir.glob("special/(").sort());
+    });
+}
+
+exports["tests matches regexp special )"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/)'], dir.glob("special/)").sort());
+    });
+}
+
+exports["tests matches regexp special ["] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/['], dir.glob("special/\\[").sort());
+    });
+}
+
+exports["tests matches regexp special ]"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/]'], dir.glob('special/]').sort());
+    });
+}
+
+exports["tests matches regexp special {"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/{'], dir.glob("special/\\{").sort());
+    });
+}
+
+exports["tests matches regexp special }"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['special/}'], dir.glob("special/\\}").sort());
+    });
+}
+
+exports["tests matches dotfiles with '.*'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['.','..','.dotfile','.dotsubdir'], dir.glob('.*').sort());
+    });
+}
+
+exports["tests matches non-dotfiles with '*<non-special characters>'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['nondotfile'], dir.glob('*file').sort());
+    });
+}
+
+exports["tests matches dotfiles with '.*<non-special characters>'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['.dotfile'], dir.glob('.*file').sort());
+    });
+}
+
+exports["tests matches files with any ending with '<non-special characters>*'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['file_one.ext','file_two.ext'], dir.glob('file*').sort());
+    });
+}
+
+exports["tests matches files with any middle with '<non-special characters>*<non-special characters>'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['subdir_one'], dir.glob('sub*_one').sort());
+    });
+}
+
+exports["tests matches files with multiple '*' special characters"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['dir_filename_ordering','nondotfile','file_one.ext','file_two.ext'].sort(), dir.glob('*fi*e*').sort());
+    });
+}
+
+exports["tests matches non-dotfiles in the current directory with '**'"] = function() {
+    var expected = [
+        "deeply",
+        "dir",
+        "dir_filename_ordering",
+        "file_one.ext",
+        "file_two.ext",
+        "nondotfile",
+        "special",
+        "subdir_one",
+        "subdir_two"
+    ];
+
+    mockDirs(function(dir) {
+        assert.eq(expected, dir.glob('**').sort());
+    });
+}
+
+exports["tests matches dotfiles in the current directory with '.**'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['.','..','.dotfile','.dotsubdir'], dir.glob('.**').sort());
+    });
+}
+
+exports["tests recursively matches any nondot subdirectories with '**/'"] = function() {
+    var expected = [
+        "deeply/",
+        "deeply/nested/",
+        "deeply/nested/directory/",
+        "deeply/nested/directory/structure/",
+        "dir/",
+        "special/",
+        "subdir_one/",
+        "subdir_two/"
+    ]
+    mockDirs(function(dir) {
+        assert.eq(expected, dir.glob('**/').sort());
+    });
+}
+
+exports["tests recursively matches any subdirectories including ./ and ../ with '.**/'"] = function() {
+    mockDirs(function(dir) {
+        var dir = dir.join("subdir_one");
+        assert.eq(['./','../'], dir.glob('.**/').sort());
+    });
+}
+
+exports["tests matches a single character except leading '.' with '?'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['subdir_one'], dir.glob('?ubdir_one').sort());
+    });
+}
+
+exports["tests accepts multiple '?' characters in a pattern"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['subdir_one','subdir_two'], dir.glob('subdir_???').sort());
+    });
+}
+
+exports["tests matches any characters in a set with '[<characters>]'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['subdir_one'], dir.glob('[stfu]ubdir_one').sort());
+    });
+}
+
+exports["tests matches any characters in a range with '[<character>-<character>]'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['subdir_one'], dir.glob('[a-zA-Z]ubdir_one').sort());
+    });
+}
+
+exports["tests matches any characters except those in a set with '[^<characters>]'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['subdir_one'], dir.glob('[^wtf]ubdir_one').sort());
+    });
+}
+
+exports["tests matches any characters except those in a range with '[^<character>-<character]'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(['subdir_one'], dir.glob('[^0-9]ubdir_one').sort());
+    });
+}
+
+exports["tests matches any one of the strings in a set with '{<string>,<other>,...}'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(["subdir_one", "subdir_two"], dir.glob('subdir_{one,two,three}').sort());
+    });
+}
+
+exports["tests accepts string sets with empty strings with {<string>,,<other>}"] = function() {
+    var expected = [
+        "deeply/nested/directory/structure/file_one.ext",
+        "deeply/nested/directory/structure/file_one"
+    ].sort();
+    
+    mockDirs(function(dir) {
+        assert.eq(expected, dir.glob('deeply/nested/directory/structure/file_one{.ext,}').sort());
+    });
+}
+
+exports["tests matches dot or non-dotfiles with '{,.}*'"] = function() {
+    mockDirs(function(dir) {
+        assert.eq(expected_paths, dir.glob('{,.}*').sort());
+    });
+}
+
+exports["tests matches special characters by escaping with a backslash with '\\<character>'"] = function() {
+    mockDirs(function(dir) {
+        dir.join('foo^bar').mkdir();
+        assert.eq(["foo^bar"], dir.glob('foo?bar'));
+        assert.eq([], dir.glob('foo\\?bar'));
+        assert.eq(["nondotfile"], dir.glob('nond\\otfile'));
+    });
+}
+
+exports["tests recursively matches directories with '**/<characters>'"] = function() {
+    var expected = [
+        "deeply/nested/directory/structure/file_one",
+        "deeply/nested/directory/structure/file_one.ext",
+        "deeply/nondotfile",
+    
+        "dir/filename_ordering",
+        "dir_filename_ordering",
+    
+        "file_one.ext",
+        "file_two.ext",
+    
+        "nondotfile",
+    
+        "subdir_one/nondotfile",
+        "subdir_two/nondotfile",
+        "subdir_two/nondotfile.ext"
+    ]
+    
+    mockDirs(function(dir) {
+        assert.eq(expected, dir.glob('**/*fil?{,.}*').sort());
+    });
+}
+
+exports["tests '**/*.ext'"] = function() {
+    // FIXME: exclude .dotfile?
+    var expected = [
+        "deeply/nested/.dotfile.ext",
+        "deeply/nested/directory/structure/.ext",
+        "deeply/nested/directory/structure/file_one.ext",
+        "file_one.ext",
+        "file_two.ext",
+        "subdir_two/nondotfile.ext"
+    ]
+    
+    mockDirs(function(dir) {
+        assert.eq(expected, dir.glob('**/*.ext').sort());
+    });
+}
+
+if (require.main === module.id)
+    require("os").exit(require("test/runner").run(exports));
+