cssesc-source 0.1.0

data/vendor/node_modules/istanbul/node_modules/fileset/node_modules/minimatch/test/brace-expand.js

@@ -0,0 +1,33 @@
+var tap = require("tap")
+  , minimatch = require("../")
+
+tap.test("brace expansion", function (t) {
+  // [ pattern, [expanded] ]
+  ; [ [ "a{b,c{d,e},{f,g}h}x{y,z}"
+      , [ "abxy"
+        , "abxz"
+        , "acdxy"
+        , "acdxz"
+        , "acexy"
+        , "acexz"
+        , "afhxy"
+        , "afhxz"
+        , "aghxy"
+        , "aghxz" ] ]
+    , [ "a{1..5}b"
+      , [ "a1b"
+        , "a2b"
+        , "a3b"
+        , "a4b"
+        , "a5b" ] ]
+    , [ "a{b}c", ["a{b}c"] ]
+  ].forEach(function (tc) {
+    var p = tc[0]
+      , expect = tc[1]
+    t.equivalent(minimatch.braceExpand(p), expect, p)
+  })
+  console.error("ending")
+  t.end()
+})
+
+

data/vendor/node_modules/istanbul/node_modules/fileset/node_modules/minimatch/test/caching.js

@@ -0,0 +1,14 @@
+var Minimatch = require("../minimatch.js").Minimatch
+var tap = require("tap")
+tap.test("cache test", function (t) {
+  var mm1 = new Minimatch("a?b")
+  var mm2 = new Minimatch("a?b")
+  t.equal(mm1, mm2, "should get the same object")
+  // the lru should drop it after 100 entries
+  for (var i = 0; i < 100; i ++) {
+    new Minimatch("a"+i)
+  }
+  mm2 = new Minimatch("a?b")
+  t.notEqual(mm1, mm2, "cache should have dropped")
+  t.end()
+})

data/vendor/node_modules/istanbul/node_modules/fileset/node_modules/minimatch/test/defaults.js

@@ -0,0 +1,274 @@
+// http://www.bashcookbook.com/bashinfo/source/bash-1.14.7/tests/glob-test
+//
+// TODO: Some of these tests do very bad things with backslashes, and will
+// most likely fail badly on windows.  They should probably be skipped.
+
+var tap = require("tap")
+  , globalBefore = Object.keys(global)
+  , mm = require("../")
+  , files = [ "a", "b", "c", "d", "abc"
+            , "abd", "abe", "bb", "bcd"
+            , "ca", "cb", "dd", "de"
+            , "bdir/", "bdir/cfile"]
+  , next = files.concat([ "a-b", "aXb"
+                        , ".x", ".y" ])
+
+tap.test("basic tests", function (t) {
+  var start = Date.now()
+
+  // [ pattern, [matches], MM opts, files, TAP opts]
+  ; [ "http://www.bashcookbook.com/bashinfo" +
+      "/source/bash-1.14.7/tests/glob-test"
+    , ["a*", ["a", "abc", "abd", "abe"]]
+    , ["X*", ["X*"], {nonull: true}]
+
+    // allow null glob expansion
+    , ["X*", []]
+
+    // isaacs: Slightly different than bash/sh/ksh
+    // \\* is not un-escaped to literal "*" in a failed match,
+    // but it does make it get treated as a literal star
+    , ["\\*", ["\\*"], {nonull: true}]
+    , ["\\**", ["\\**"], {nonull: true}]
+    , ["\\*\\*", ["\\*\\*"], {nonull: true}]
+
+    , ["b*/", ["bdir/"]]
+    , ["c*", ["c", "ca", "cb"]]
+    , ["**", files]
+
+    , ["\\.\\./*/", ["\\.\\./*/"], {nonull: true}]
+    , ["s/\\..*//", ["s/\\..*//"], {nonull: true}]
+
+    , "legendary larry crashes bashes"
+    , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"
+      , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\\1/"], {nonull: true}]
+    , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"
+      , ["/^root:/{s/^[^:]*:[^:]*:\([^:]*\).*$/\1/"], {nonull: true}]
+
+    , "character classes"
+    , ["[a-c]b*", ["abc", "abd", "abe", "bb", "cb"]]
+    , ["[a-y]*[^c]", ["abd", "abe", "bb", "bcd",
+       "bdir/", "ca", "cb", "dd", "de"]]
+    , ["a*[^c]", ["abd", "abe"]]
+    , function () { files.push("a-b", "aXb") }
+    , ["a[X-]b", ["a-b", "aXb"]]
+    , function () { files.push(".x", ".y") }
+    , ["[^a-c]*", ["d", "dd", "de"]]
+    , function () { files.push("a*b/", "a*b/ooo") }
+    , ["a\\*b/*", ["a*b/ooo"]]
+    , ["a\\*?/*", ["a*b/ooo"]]
+    , ["*\\\\!*", [], {null: true}, ["echo !7"]]
+    , ["*\\!*", ["echo !7"], null, ["echo !7"]]
+    , ["*.\\*", ["r.*"], null, ["r.*"]]
+    , ["a[b]c", ["abc"]]
+    , ["a[\\b]c", ["abc"]]
+    , ["a?c", ["abc"]]
+    , ["a\\*c", [], {null: true}, ["abc"]]
+    , ["", [""], { null: true }, [""]]
+
+    , "http://www.opensource.apple.com/source/bash/bash-23/" +
+      "bash/tests/glob-test"
+    , function () { files.push("man/", "man/man1/", "man/man1/bash.1") }
+    , ["*/man*/bash.*", ["man/man1/bash.1"]]
+    , ["man/man1/bash.1", ["man/man1/bash.1"]]
+    , ["a***c", ["abc"], null, ["abc"]]
+    , ["a*****?c", ["abc"], null, ["abc"]]
+    , ["?*****??", ["abc"], null, ["abc"]]
+    , ["*****??", ["abc"], null, ["abc"]]
+    , ["?*****?c", ["abc"], null, ["abc"]]
+    , ["?***?****c", ["abc"], null, ["abc"]]
+    , ["?***?****?", ["abc"], null, ["abc"]]
+    , ["?***?****", ["abc"], null, ["abc"]]
+    , ["*******c", ["abc"], null, ["abc"]]
+    , ["*******?", ["abc"], null, ["abc"]]
+    , ["a*cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+    , ["a**?**cd**?**??k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+    , ["a**?**cd**?**??k***", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+    , ["a**?**cd**?**??***k", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+    , ["a**?**cd**?**??***k**", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+    , ["a****c**?**??*****", ["abcdecdhjk"], null, ["abcdecdhjk"]]
+    , ["[-abc]", ["-"], null, ["-"]]
+    , ["[abc-]", ["-"], null, ["-"]]
+    , ["\\", ["\\"], null, ["\\"]]
+    , ["[\\\\]", ["\\"], null, ["\\"]]
+    , ["[[]", ["["], null, ["["]]
+    , ["[", ["["], null, ["["]]
+    , ["[*", ["[abc"], null, ["[abc"]]
+    , "a right bracket shall lose its special meaning and\n" +
+      "represent itself in a bracket expression if it occurs\n" +
+      "first in the list.  -- POSIX.2 2.8.3.2"
+    , ["[]]", ["]"], null, ["]"]]
+    , ["[]-]", ["]"], null, ["]"]]
+    , ["[a-\z]", ["p"], null, ["p"]]
+    , ["??**********?****?", [], { null: true }, ["abc"]]
+    , ["??**********?****c", [], { null: true }, ["abc"]]
+    , ["?************c****?****", [], { null: true }, ["abc"]]
+    , ["*c*?**", [], { null: true }, ["abc"]]
+    , ["a*****c*?**", [], { null: true }, ["abc"]]
+    , ["a********???*******", [], { null: true }, ["abc"]]
+    , ["[]", [], { null: true }, ["a"]]
+    , ["[abc", [], { null: true }, ["["]]
+
+    , "nocase tests"
+    , ["XYZ", ["xYz"], { nocase: true, null: true }
+      , ["xYz", "ABC", "IjK"]]
+    , ["ab*", ["ABC"], { nocase: true, null: true }
+      , ["xYz", "ABC", "IjK"]]
+    , ["[ia]?[ck]", ["ABC", "IjK"], { nocase: true, null: true }
+      , ["xYz", "ABC", "IjK"]]
+
+    // [ pattern, [matches], MM opts, files, TAP opts]
+    , "onestar/twostar"
+    , ["{/*,*}", [], {null: true}, ["/asdf/asdf/asdf"]]
+    , ["{/?,*}", ["/a", "bb"], {null: true}
+      , ["/a", "/b/b", "/a/b/c", "bb"]]
+
+    , "dots should not match unless requested"
+    , ["**", ["a/b"], {}, ["a/b", "a/.d", ".a/.d"]]
+
+    // .. and . can only match patterns starting with .,
+    // even when options.dot is set.
+    , function () {
+        files = ["a/./b", "a/../b", "a/c/b", "a/.d/b"]
+      }
+    , ["a/*/b", ["a/c/b", "a/.d/b"], {dot: true}]
+    , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: true}]
+    , ["a/*/b", ["a/c/b"], {dot:false}]
+    , ["a/.*/b", ["a/./b", "a/../b", "a/.d/b"], {dot: false}]
+
+
+    // this also tests that changing the options needs
+    // to change the cache key, even if the pattern is
+    // the same!
+    , ["**", ["a/b","a/.d",".a/.d"], { dot: true }
+      , [ ".a/.d", "a/.d", "a/b"]]
+
+    , "paren sets cannot contain slashes"
+    , ["*(a/b)", ["*(a/b)"], {nonull: true}, ["a/b"]]
+
+    // brace sets trump all else.
+    //
+    // invalid glob pattern.  fails on bash4 and bsdglob.
+    // however, in this implementation, it's easier just
+    // to do the intuitive thing, and let brace-expansion
+    // actually come before parsing any extglob patterns,
+    // like the documentation seems to say.
+    //
+    // XXX: if anyone complains about this, either fix it
+    // or tell them to grow up and stop complaining.
+    //
+    // bash/bsdglob says this:
+    // , ["*(a|{b),c)}", ["*(a|{b),c)}"], {}, ["a", "ab", "ac", "ad"]]
+    // but we do this instead:
+    , ["*(a|{b),c)}", ["a", "ab", "ac"], {}, ["a", "ab", "ac", "ad"]]
+
+    // test partial parsing in the presence of comment/negation chars
+    , ["[!a*", ["[!ab"], {}, ["[!ab", "[ab"]]
+    , ["[#a*", ["[#ab"], {}, ["[#ab", "[ab"]]
+
+    // like: {a,b|c\\,d\\\|e} except it's unclosed, so it has to be escaped.
+    , ["+(a|*\\|c\\\\|d\\\\\\|e\\\\\\\\|f\\\\\\\\\\|g"
+      , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g"]
+      , {}
+      , ["+(a|b\\|c\\\\|d\\\\|e\\\\\\\\|f\\\\\\\\|g", "a", "b\\c"]]
+
+
+    // crazy nested {,,} and *(||) tests.
+    , function () {
+        files = [ "a", "b", "c", "d"
+                , "ab", "ac", "ad"
+                , "bc", "cb"
+                , "bc,d", "c,db", "c,d"
+                , "d)", "(b|c", "*(b|c"
+                , "b|c", "b|cc", "cb|c"
+                , "x(a|b|c)", "x(a|c)"
+                , "(a|b|c)", "(a|c)"]
+      }
+    , ["*(a|{b,c})", ["a", "b", "c", "ab", "ac"]]
+    , ["{a,*(b|c,d)}", ["a","(b|c", "*(b|c", "d)"]]
+    // a
+    // *(b|c)
+    // *(b|d)
+    , ["{a,*(b|{c,d})}", ["a","b", "bc", "cb", "c", "d"]]
+    , ["*(a|{b|c,c})", ["a", "b", "c", "ab", "ac", "bc", "cb"]]
+
+
+    // test various flag settings.
+    , [ "*(a|{b|c,c})", ["x(a|b|c)", "x(a|c)", "(a|b|c)", "(a|c)"]
+      , { noext: true } ]
+    , ["a?b", ["x/y/acb", "acb/"], {matchBase: true}
+      , ["x/y/acb", "acb/", "acb/d/e", "x/y/acb/d"] ]
+    , ["#*", ["#a", "#b"], {nocomment: true}, ["#a", "#b", "c#d"]]
+
+
+    // begin channelling Boole and deMorgan...
+    , "negation tests"
+    , function () {
+        files = ["d", "e", "!ab", "!abc", "a!b", "\\!a"]
+      }
+
+    // anything that is NOT a* matches.
+    , ["!a*", ["\\!a", "d", "e", "!ab", "!abc"]]
+
+    // anything that IS !a* matches.
+    , ["!a*", ["!ab", "!abc"], {nonegate: true}]
+
+    // anything that IS a* matches
+    , ["!!a*", ["a!b"]]
+
+    // anything that is NOT !a* matches
+    , ["!\\!a*", ["a!b", "d", "e", "\\!a"]]
+
+    // negation nestled within a pattern
+    , function () {
+        files = [ "foo.js"
+                , "foo.bar"
+                // can't match this one without negative lookbehind.
+                , "foo.js.js"
+                , "blar.js"
+                , "foo."
+                , "boo.js.boo" ]
+      }
+    , ["*.!(js)", ["foo.bar", "foo.", "boo.js.boo"] ]
+
+    ].forEach(function (c) {
+      if (typeof c === "function") return c()
+      if (typeof c === "string") return t.comment(c)
+
+      var pattern = c[0]
+        , expect = c[1].sort(alpha)
+        , options = c[2] || {}
+        , f = c[3] || files
+        , tapOpts = c[4] || {}
+
+      // options.debug = true
+      var Class = mm.defaults(options).Minimatch
+      var m = new Class(pattern, {})
+      var r = m.makeRe()
+      tapOpts.re = String(r) || JSON.stringify(r)
+      tapOpts.files = JSON.stringify(f)
+      tapOpts.pattern = pattern
+      tapOpts.set = m.set
+      tapOpts.negated = m.negate
+
+      var actual = mm.match(f, pattern, options)
+      actual.sort(alpha)
+
+      t.equivalent( actual, expect
+                  , JSON.stringify(pattern) + " " + JSON.stringify(expect)
+                  , tapOpts )
+    })
+
+  t.comment("time=" + (Date.now() - start) + "ms")
+  t.end()
+})
+
+tap.test("global leak test", function (t) {
+  var globalAfter = Object.keys(global)
+  t.equivalent(globalAfter, globalBefore, "no new globals, please")
+  t.end()
+})
+
+function alpha (a, b) {
+  return a > b ? 1 : -1
+}

data/vendor/node_modules/istanbul/node_modules/fileset/node_modules/minimatch/test/extglob-ending-with-state-char.js

@@ -0,0 +1,8 @@
+var test = require('tap').test
+var minimatch = require('../')
+
+test('extglob ending with statechar', function(t) {
+  t.notOk(minimatch('ax', 'a?(b*)'))
+  t.ok(minimatch('ax', '?(a*|b)'))
+  t.end()
+})

data/vendor/node_modules/istanbul/node_modules/fileset/package.json

@@ -0,0 +1,34 @@
+{
+  "author": {
+    "name": "mklabs"
+  },
+  "name": "fileset",
+  "description": "Wrapper around miniglob / minimatch combo to allow multiple patterns matching and include-exclude ability",
+  "version": "0.1.5",
+  "homepage": "https://github.com/mklabs/node-fileset",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/mklabs/node-fileset.git"
+  },
+  "main": "./lib/fileset",
+  "scripts": {
+    "test": "node tests/test.js"
+  },
+  "dependencies": {
+    "minimatch": "0.x",
+    "glob": "3.x"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/mklabs/node-fileset/blob/master/LICENSE-MIT"
+    }
+  ],
+  "readme": "# node-fileset\n\nExposes a basic wrapper on top of\n[Glob](https://github.com/isaacs/node-glob) /\n[minimatch](https://github.com/isaacs/minimatch) combo both written by\n@isaacs. Glob now uses JavaScript instead of C++ bindings which makes it\nusable in Node.js 0.6.x and Windows platforms.\n\n[![Build Status](https://secure.travis-ci.org/mklabs/node-fileset.png)](http://travis-ci.org/mklabs/node-fileset)\n\nAdds multiples patterns matching and exlude ability. This is\nbasically just a sugar API syntax where you can specify a list of includes\nand optional exclude patterns. It works by setting up the necessary\nminiglob \"fileset\" and filtering out the results using minimatch.\n\n## Install\n\n    npm install fileset\n\n## Usage\n\nCan be used with callback or emitter style.\n\n* **include**: list of glob patterns `foo/**/*.js *.md src/lib/**/*`\n* **exclude**: *optional* list of glob patterns to filter include\n  results `foo/**/*.js *.md`\n* **callback**: *optional* function that gets called with an error if\n  something wrong happend, otherwise null with an array of results\n\nThe callback is optional since the fileset method return an instance of\nEventEmitter which emit different events you might use:\n\n* *match*: Every time a match is found, miniglob emits this event with\n  the pattern.\n* *include*: Emitted each time an include match is found.\n* *exclude*: Emitted each time an exclude match is found and filtered\n  out from the fileset.\n* *end*:  Emitted when the matching is finished with all the matches\n  found, optionally filtered by the exclude patterns.\n\n#### Callback\n\n```js\nvar fileset = require('fileset');\n\nfileset('**/*.js', '**.min.js', function(err, files) {\n  if (err) return console.error(err);\n\n  console.log('Files: ', files.length);\n  console.log(files);\n});\n```\n\n#### Event emitter\n\n```js\nvar fileset = require('fileset');\n\nfileset('**.coffee README.md *.json Cakefile **.js', 'node_modules/**')\n  .on('match', console.log.bind(console, 'error'))\n  .on('include', console.log.bind(console, 'includes'))\n  .on('exclude', console.log.bind(console, 'excludes'))\n  .on('end', console.log.bind(console, 'end'));\n```\n\n`fileset` returns an instance of EventEmitter, with an `includes` property\nwhich is the array of Fileset objects (inheriting from\n`miniglob.Miniglob`) that were used during the mathing process, should\nyou want to use them individually.\n\nCheck out the\n[tests](https://github.com/mklabs/node-fileset/tree/master/tests) for\nmore examples.\n\n## Tests\n\nRun `npm test`\n\n## Why\n\nMainly for a build tool with cake files, to provide me an easy way to get\na list of files by either using glob or path patterns, optionally\nallowing exclude patterns to filter out the results.\n\nAll the magic is happening in\n[Glob](https://github.com/isaacs/node-glob) and\n[minimatch](https://github.com/isaacs/minimatch). Check them out!\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/mklabs/node-fileset/issues"
+  },
+  "_id": "fileset@0.1.5",
+  "_from": "fileset@0.1.x"
+}

data/vendor/node_modules/istanbul/node_modules/fileset/tests/fixtures/an (odd) filename.js

@@ -0,0 +1 @@
+var odd = true;

data/vendor/node_modules/istanbul/node_modules/fileset/tests/helper.js

@@ -0,0 +1,61 @@
+
+var EventEmitter = require('events').EventEmitter,
+  assert = require('assert'),
+  tests = {};
+
+module.exports = test;
+test.run = run;
+
+// ## Test helpers
+
+function test(msg, handler) {
+  tests[msg] = handler;
+}
+
+function run() {
+  var specs = Object.keys(tests),
+    specsRemaining = specs.length;
+
+  specs.forEach(function(spec) {
+    var handler = tests[spec];
+
+    // grab the set of asserts for this spec
+    var shoulds = handler(),
+      keys = Object.keys(shoulds),
+      remaining = keys.length;
+
+    keys.forEach(function(should) {
+      var em = new EventEmitter(),
+        to = setTimeout(function() {
+          assert.fail('never ended');
+        }, 5000);
+
+      em
+        .on('error', function assertFail(err) { assert.fail(err) })
+        .on('end', function assertOk() {
+          clearTimeout(to);
+          shoulds[should].status = true;
+
+          // till we get to 0
+          if(!(--remaining)) {
+            console.log([
+              '',
+              '» ' + spec,
+              keys.map(function(k) { return '   » ' + k; }).join('\n'),
+              '',
+              '   Total: ' + keys.length,
+              '   Failed: ' + keys.map(function(item) { return shoulds[should].status; }).filter(function(status) { return !status; }).length,
+              ''
+            ].join('\n'));
+
+            if(!(--specsRemaining)) {
+              console.log('All done');
+            }
+
+          }
+        });
+
+      shoulds[should](em);
+    });
+  });
+}

data/vendor/node_modules/istanbul/node_modules/fileset/tests/test.js

@@ -0,0 +1,133 @@
+
+var EventEmitter = require('events').EventEmitter,
+  fileset = require('../'),
+  assert = require('assert'),
+  test = require('./helper');
+
+// Given a **.coffee pattern
+test('Given a **.md pattern', function() {
+
+  return {
+    'should return the list of matching file in this repo': function(em) {
+      fileset('*.md', function(err, results) {
+        if(err) return em.emit('error', err);
+        assert.ok(Array.isArray(results), 'should be an array');
+        assert.ok(results.length, 'should return at least one element');
+        assert.equal(results.length, 1, 'actually, should return only one');
+        em.emit('end');
+      });
+    }
+  }
+});
+
+test('Say we want the **.js files, but not those in node_modules', function() {
+
+  return {
+    'Should recursively walk the dir and return the matching list': function(em) {
+      fileset('**/*.js', 'node_modules/**', function(err, results) {
+        if(err) return em.emit('error', err);
+        assert.ok(Array.isArray(results), 'should be an array');
+        assert.equal(results.length, 4);
+        em.emit('end');
+      });
+    },
+
+    'Should support multiple paths at once': function(em) {
+      fileset('**/*.js *.md', 'node_modules/**', function(err, results) {
+        if(err) return em.emit('error', err);
+        assert.ok(Array.isArray(results), 'should be an array');
+        assert.equal(results.length, 5);
+
+        assert.deepEqual(results, [
+          'README.md',
+          'lib/fileset.js',
+          'tests/fixtures/an (odd) filename.js',
+          'tests/helper.js',
+          'tests/test.js'
+        ]);
+
+        em.emit('end');
+      });
+    },
+
+    'Should support multiple paths for excludes as well': function(em) {
+      fileset('**/*.js *.md', 'node_modules/** **.md tests/*.js', function(err, results) {
+        if(err) return em.emit('error', err);
+        assert.ok(Array.isArray(results), 'should be an array');
+        assert.equal(results.length, 2);
+
+        assert.deepEqual(results, [
+          'lib/fileset.js',
+          'tests/fixtures/an (odd) filename.js',
+        ]);
+
+        em.emit('end');
+      });
+    }
+  }
+});
+
+
+test('Testing out emmited events', function() {
+
+  // todos: the tests for match, include, exclude events, but seems like it's ok
+  return {
+    'Should recursively walk the dir and return the matching list': function(em) {
+      fileset('**/*.js', 'node_modules/**')
+        .on('error', em.emit.bind(em, 'error'))
+        .on('end', function(results) {
+          assert.ok(Array.isArray(results), 'should be an array');
+          assert.equal(results.length, 4);
+          em.emit('end');
+        });
+    },
+
+    'Should support multiple paths at once': function(em) {
+      fileset('**/*.js *.md', 'node_modules/**')
+        .on('error', em.emit.bind(em, 'error'))
+        .on('end', function(results) {
+          assert.ok(Array.isArray(results), 'should be an array');
+          assert.equal(results.length, 5);
+
+          assert.deepEqual(results, [
+            'README.md',
+            'lib/fileset.js',
+            'tests/fixtures/an (odd) filename.js',
+            'tests/helper.js',
+            'tests/test.js'
+          ]);
+
+          em.emit('end');
+        });
+    }
+  }
+});
+
+
+test('Testing patterns passed as arrays', function() {
+
+  return {
+    'Should match files passed as an array with odd filenames': function(em) {
+      fileset(['lib/*.js', 'tests/fixtures/an (odd) filename.js'], ['node_modules/**'])
+        .on('error', em.emit.bind(em, 'error'))
+        .on('end', function(results) {
+          assert.ok(Array.isArray(results), 'should be an array');
+          assert.equal(results.length, 2);
+
+          assert.deepEqual(results, [
+            'lib/fileset.js',
+            'tests/fixtures/an (odd) filename.js',
+          ]);
+
+          em.emit('end');
+        });
+    }
+  }
+
+});
+
+
+
+test.run();
+
+