cssesc-source 0.1.0

data/vendor/node_modules/istanbul/test/other/test-index-xface.js

@@ -0,0 +1,17 @@
+var main = require('../../index');
+
+
+module.exports = {
+    "xface": function (test) {
+        [ 'Instrumenter', 'Store', 'Collector', 'Report', '_yuiLoadHook'].forEach(function (key) {
+            test.ok(main[key] && typeof main[key] === 'function', key + ' was not exported as a function!');
+        });
+        [ 'hook', 'utils' ].forEach(function (key) {
+            test.ok(main[key] && typeof main[key] === 'object', key + ' was not exported as an object!');
+        });
+        [ 'assetsDir'].forEach(function (key) {
+            test.ok(main[key] && typeof main[key] === 'string', key + ' was not exported as a string!');
+        });
+        test.done();
+    }
+};

data/vendor/node_modules/istanbul/test/other/test-input-error.js

@@ -0,0 +1,10 @@
+var inputError = require('../../lib/util/input-error');
+
+module.exports = {
+    "should produce an Error object distinguishable from unexpected errors": function (test) {
+        var e = inputError.create('bad user!');
+        test.equal('bad user!', e.message);
+        test.ok(e.inputError);
+        test.done();
+    }
+};

data/vendor/node_modules/istanbul/test/other/test-insertion-text.js

@@ -0,0 +1,102 @@
+/*jslint nomen: true */
+var InsertionText = require('../../lib/util/insertion-text'),
+    it;
+
+module.exports = {
+    "with a regular insertion text": {
+        setUp: function (cb) {
+            it = new InsertionText("hello world");
+            cb();
+        },
+        "should be able to span hello": function (test) {
+            it.insertAt(0, '<span class="h">');
+            it.insertAt(5, '</span>');
+            test.equals(it.toString(), '<span class="h">hello</span> world');
+            test.done();
+        },
+        "should be able to span world": function (test) {
+            it.insertAt(6, '<span class="w">');
+            it.insertAt(11, '</span>');
+            test.equals(it.toString(), 'hello <span class="w">world</span>');
+            test.done();
+        },
+        "should be able to nest spans around hello (improperly)": function (test) {
+            it.insertAt(0, '<span class="h">');
+            it.insertAt(5, '</span>');
+            it.insertAt(0, '<div class="w">');
+            it.insertAt(5, '</div>');
+            test.equals(it.toString(), '<span class="h"><div class="w">hello</span></div> world');
+            test.done();
+        },
+        "should be able to nest spans around hello (properly)": function (test) {
+            it.insertAt(0, '<span class="w">', true);
+            it.insertAt(5, '</span>');
+            it.insertAt(0, '<div class="h">', true);
+            it.insertAt(5, '</div>');
+            test.equals(it.toString(), '<div class="h"><span class="w">hello</span></div> world');
+            test.done();
+        },
+        "should be able to use syntactic sugar for wrapping text": function (test) {
+            it.wrap(0, '<span class="h">', 5, '</span>');
+            it.wrap(0, '<div class="w">', 5, '</div>');
+            test.equals(it.toString(), '<div class="w"><span class="h">hello</span></div> world');
+            test.done();
+        },
+        "should be able to chain calls for wrapping text": function (test) {
+            it.wrap(0, '<span class="h">', 5, '</span>').
+                wrap(0, '<div class="w">', 5, '</div>');
+            test.equals(it.toString(), '<div class="w"><span class="h">hello</span></div> world');
+            test.done();
+        },
+        "should be able to insert text between two insertions": function (test) {
+            it.wrap(0, '<span class="h">', 5, '</span>').
+                insertAt(3, "w");
+            test.equals(it.toString(), '<span class="h">helwlo</span> world');
+            test.done();
+        },
+        "should prepend on negative insertion index": function (test) {
+            it.insertAt(-3, "XXX");
+            test.equals(it.toString(), 'XXXhello world');
+            test.done();
+        },
+        "should append on out-of-bounds insertion index": function (test) {
+            it.insertAt(100, "XXX");
+            test.equals(it.toString(), 'hello worldXXX');
+            test.done();
+        },
+        "should wrap entire line correctly": function (test) {
+            it.wrapLine('<span>', '</span>');
+            test.equals(it.toString(), '<span>hello world</span>');
+            test.done();
+        },
+        "should be able to consume blanks in an individual call": function (test) {
+            it = new InsertionText("  hello world  ");
+            it.wrap(2, '<span>', 13, '</span>', true);
+            test.equals(it.toString(), '<span>  hello world  </span>');
+            test.done();
+        }
+    },
+    "with a blank consuming insertion text and input with spaces on either end": {
+        setUp: function (cb) {
+            it = new InsertionText("    hello world    ", true);
+            cb();
+        },
+        "spanning first word should consume leading spaces": function (test) {
+            it.wrap(4, '<span class="h">', 9, '</span>');
+            test.equals(it.toString(), '<span class="h">    hello</span> world    ');
+            test.done();
+        },
+        "spanning second word should consume trailing spaces": function (test) {
+            it.wrap(10, '<span class="h">', 15, '</span>');
+            test.equals(it.toString(), '    hello <span class="h">world    </span>');
+            test.done();
+        },
+        "should be able to suppress blank consumption in an individual call": function (test) {
+            it = new InsertionText("  hello world  ");
+            it.wrap(2, '<span>', 13, '</span>', false);
+            test.equals(it.toString(), '  <span>hello world</span>  ');
+            test.done();
+        }
+    }
+};
+

data/vendor/node_modules/istanbul/test/other/test-matcher.js

@@ -0,0 +1,93 @@
+/*jslint nomen: true */
+var path = require('path'),
+    fileset = require('fileset'),
+    root = path.resolve(__dirname, 'data', 'matcher'),
+    src = '../../lib/util/file-matcher.js',
+    fileMatcher = require(src),
+    allFiles;
+
+module.exports = {
+    setUp: function (cb) {
+        if (!allFiles) {
+            fileset('**/*.js', '', { cwd: root}, function (err, files) {
+                allFiles = files.map(function (file) { return path.resolve(root, file); });
+                cb();
+            });
+        } else {
+            cb();
+        }
+    },
+    "should return all files except those under node_modules by default": function (test) {
+        fileMatcher.filesFor(function (err, files) {
+            test.ok(!err);
+            allFiles.forEach(function (file) {
+                var matcher = function (f) { return f === file; },
+                    shouldMatch = file.indexOf('file.js') < 0;
+                if (shouldMatch) {
+                    test.ok(files.filter(matcher).length, 'Should match [' + file + '] but did not');
+                } else {
+                    test.ok(!files.filter(matcher).length, 'Should NOT match [' + file + '] but did');
+                }
+            });
+            test.done();
+        });
+    },
+    "should return relative filenames when requested": function (test) {
+        fileMatcher.filesFor({ root: root, relative: true }, function (err, files) {
+            test.ok(!err);
+            allFiles.forEach(function (file) {
+                var matcher = function (f) { return path.resolve(root, f) === file; },
+                    shouldMatch = file.indexOf('file.js') < 0;
+                if (shouldMatch) {
+                    test.ok(files.filter(matcher).length, 'Should match [' + file + '] but did not');
+                } else {
+                    test.ok(!files.filter(matcher).length, 'Should NOT match [' + file + '] but did');
+                }
+            });
+            test.done();
+        });
+    },
+    "should match stuff under cwd": function (test) {
+        fileMatcher.matcherFor(function (err, matchFn) {
+            test.ok(!err);
+            test.ok(matchFn(path.resolve(__dirname, src)), 'should match itself');
+            test.done();
+        });
+    },
+    "should match stuff under cwd overriding relative opts passed in": function (test) {
+        fileMatcher.matcherFor({ relative: true }, function (err, matchFn) {
+            test.ok(!err);
+            test.ok(matchFn(path.resolve(__dirname, src)), 'should match itself');
+            test.done();
+        });
+    },
+    "should ignore node_modules": function (test) {
+        fileMatcher.matcherFor({ root: root }, function (err, matchFn) {
+            test.ok(!err);
+            allFiles.forEach(function (file) {
+                var shouldMatch = file.indexOf('file.js') < 0;
+                if (shouldMatch) {
+                    test.ok(matchFn(file), 'Should match [' + file + '] but did not');
+                } else {
+                    test.ok(!matchFn(file), 'Should NOT match [' + file + '] but did');
+                }
+            });
+            test.done();
+        });
+    },
+    "should match stuff with explicit includes and excludes": function (test) {
+        fileMatcher.matcherFor({ root: root, includes: [ '**/general/**/*.js' ], excludes: [ '**/general.js' ] }, function (err, matchFn) {
+            test.ok(!err);
+            allFiles.forEach(function (file) {
+                if (file.indexOf('/general/') < 0) { return; }
+                var shouldMatch = file.indexOf('file.js') >= 0;
+                if (shouldMatch) {
+                    test.ok(matchFn(file), 'Should match [' + file + '] but did not');
+                } else {
+                    test.ok(!matchFn(file), 'Should NOT match [' + file + '] but did');
+                }
+            });
+            test.done();
+        });
+    }
+};

data/vendor/node_modules/istanbul/test/other/test-object-utils.js

@@ -0,0 +1,201 @@
+/*jslint nomen: true */
+var utils = require('../../lib/object-utils'),
+    it,
+    it2,
+    it3;
+
+module.exports = {
+    "with some coverage info": {
+        setUp: function (cb) {
+            it = {
+                foo: {
+                    s: {
+                        1: 1,
+                        2: 2,
+                        3: 3,
+                        4: 4
+                    },
+                    statementMap: {
+                        1: { start: { line: 1, column: 1}, end: { line: 1, column: 10 }},
+                        2: { start: { line: 2, column: 1}, end: { line: 1, column: 9 }},
+                        3: { start: { line: 2, column: 10 }, end: { line: 2, column: 20 }},
+                        4: { start: { line: 7, column: 0 }, end: { line: 40, column: 10 }}
+                    }
+                }
+            };
+            cb();
+        },
+        "should add/ remove derived coverage correctly": function (test) {
+            utils.addDerivedInfo(it);
+            var l = it.foo.l;
+            test.ok(l);
+            test.equals(3, Object.keys(l).length);
+            test.equals(1, l[1]);
+            test.equals(3, l[2]);
+            test.equals(4, l[7]);
+            l[7] = 0;
+            utils.addDerivedInfo(it);
+            test.equals(0, it.foo.l[7]); //does not change
+            utils.removeDerivedInfo(it);
+            test.ok(!it.foo.l);
+            test.done();
+        }
+    },
+    "with full coverage info": {
+        setUp: function (cb) {
+            it = {
+                foo: {
+                    s: {
+                        1: 1,
+                        2: 2,
+                        3: 3,
+                        4: 4,
+                        5: 0
+                    },
+                    statementMap: {
+                        1: { start: { line: 1, column: 1}, end: { line: 1, column: 10 }},
+                        2: { start: { line: 2, column: 1}, end: { line: 1, column: 9 }},
+                        3: { start: { line: 2, column: 10 }, end: { line: 2, column: 20 }},
+                        4: { start: { line: 7, column: 0 }, end: { line: 40, column: 10 }},
+                        5: { start: { line: 41, column: 0 }, end: { line: 42, column: 10 }}
+                    },
+                    f: {
+                        1: 10,
+                        2: 0
+                    },
+                    fnMap: {
+                        1: { name: 'foo', line: 1 },
+                        2: { name: 'anonymous_1', line: 7 }
+                    },
+                    b: {
+                        1: [ 10, 0, 2],
+                        2: [ 0, 0]
+                    },
+                    branchMap: {
+                        1: { line: 2, type: 'switch', locations: [ ] },
+                        2: { line: 3, type: 'if', locations: [ ] }
+                    }
+                }
+            };
+            it2 = it;
+            it3 = {
+                foo: {
+                    s: {
+                        1: 2,
+                        2: 1,
+                        3: 78,
+                        4: 99,
+                        5: 0
+                    },
+                    statementMap: {
+                        1: { start: { line: 1, column: 1}, end: { line: 1, column: 10 }},
+                        2: { start: { line: 2, column: 1}, end: { line: 1, column: 9 }},
+                        3: { start: { line: 2, column: 10 }, end: { line: 2, column: 20 }},
+                        4: { start: { line: 7, column: 0 }, end: { line: 40, column: 10 }},
+                        5: { start: { line: 41, column: 0 }, end: { line: 42, column: 10 }}
+                    },
+                    f: {
+                        1: 9,
+                        2: 1
+                    },
+                    fnMap: {
+                        1: { name: 'foo', line: 1 },
+                        2: { name: 'anonymous_1', line: 7 }
+                    },
+                    b: {
+                        1: [ 0, 1, 1],
+                        2: [ 3, 0]
+                    },
+                    branchMap: {
+                        1: { line: 2, type: 'switch', locations: [ ] },
+                        2: { line: 3, type: 'if', locations: [ ] }
+                    }
+                }
+            };
+            cb();
+        },
+        "should calculate correct summary": function (test) {
+            var ret = utils.summarizeFileCoverage(it.foo);
+            test.deepEqual({ total: 4, covered: 3, pct: 75 }, ret.lines);
+            test.deepEqual({ total: 5, covered: 4, pct: 80 }, ret.statements);
+            test.deepEqual({ total: 2, covered: 1, pct: 50 }, ret.functions);
+            test.deepEqual({ total: 5, covered: 2, pct: 40 }, ret.branches);
+            test.done();
+        },
+        "should return a pct of 100 when nothing is available": function (test) {
+            it.foo.b = {};
+            var ret = utils.summarizeFileCoverage(it.foo);
+            test.deepEqual({ total: 4, covered: 3, pct: 75 }, ret.lines);
+            test.deepEqual({ total: 5, covered: 4, pct: 80 }, ret.statements);
+            test.deepEqual({ total: 2, covered: 1, pct: 50 }, ret.functions);
+            test.deepEqual({ total: 0, covered: 0, pct: 100 }, ret.branches);
+            test.done();
+        },
+        "should merge summary correctly": function (test) {
+            var s1 = utils.summarizeFileCoverage(it.foo),
+                s2 = utils.summarizeFileCoverage(it2.foo),
+                ret = utils.mergeSummaryObjects(s1, s2);
+            test.deepEqual({ total: 8, covered: 6, pct: 75 }, ret.lines);
+            test.deepEqual({ total: 10, covered: 8, pct: 80 }, ret.statements);
+            test.deepEqual({ total: 4, covered: 2, pct: 50 }, ret.functions);
+            test.deepEqual({ total: 10, covered: 4, pct: 40 }, ret.branches);
+            test.done();
+        },
+        "should merge summary correctly in one call": function (test) {
+            var coverage = { foo: it.foo, 'bar': it2.foo },
+                ret = utils.summarizeCoverage(coverage);
+            test.deepEqual({ total: 8, covered: 6, pct: 75 }, ret.lines);
+            test.deepEqual({ total: 10, covered: 8, pct: 80 }, ret.statements);
+            test.deepEqual({ total: 4, covered: 2, pct: 50 }, ret.functions);
+            test.deepEqual({ total: 10, covered: 4, pct: 40 }, ret.branches);
+            test.done();
+        },
+        "can merge with a blank object in first position": function (test) {
+            var s1 = null,
+                s2 = utils.summarizeFileCoverage(it2.foo),
+                ret = utils.mergeSummaryObjects(s1, s2);
+            test.deepEqual({ total: 4, covered: 3, pct: 75 }, ret.lines);
+            test.deepEqual({ total: 5, covered: 4, pct: 80 }, ret.statements);
+            test.deepEqual({ total: 2, covered: 1, pct: 50 }, ret.functions);
+            test.deepEqual({ total: 5, covered: 2, pct: 40 }, ret.branches);
+            test.done();
+        },
+        "can merge with a blank object in second position": function (test) {
+            var s1 = utils.summarizeFileCoverage(it2.foo),
+                s2 = null,
+                ret = utils.mergeSummaryObjects(s1, s2);
+            test.deepEqual({ total: 4, covered: 3, pct: 75 }, ret.lines);
+            test.deepEqual({ total: 5, covered: 4, pct: 80 }, ret.statements);
+            test.deepEqual({ total: 2, covered: 1, pct: 50 }, ret.functions);
+            test.deepEqual({ total: 5, covered: 2, pct: 40 }, ret.branches);
+            test.done();
+        },
+        "can turn it into a YUI coverage object": function (test) {
+            var ret = utils.toYUICoverage(it);
+            test.deepEqual({ '1': 1, '2': 3, '7': 4, '41': 0 }, ret.foo.lines);
+            test.deepEqual({ 'foo:1': 10, 'anonymous_1:7': 0 }, ret.foo.functions);
+            test.equal(3, ret.foo.calledLines);
+            test.equal(4, ret.foo.coveredLines);
+            test.equal(1, ret.foo.calledFunctions);
+            test.equal(2, ret.foo.coveredFunctions);
+            test.done();
+        },
+        "merge two like coverage objects for the same file correctly": function (test) {
+            var base = JSON.parse(JSON.stringify(it.foo)),
+                ret = utils.mergeFileCoverage(base, it3.foo),
+                foo = it.foo;
+            foo.s[1] += 2;
+            foo.s[2] += 1;
+            foo.s[3] += 78;
+            foo.s[4] += 99;
+            foo.f[1] += 9;
+            foo.f[2] += 1;
+            foo.b[1][1] += 1;
+            foo.b[1][2] += 1;
+            foo.b[2][0] += 3;
+
+            test.deepEqual(ret, foo);
+            test.done();
+        }
+    }
+};

data/vendor/node_modules/istanbul/test/other/test-store.js

@@ -0,0 +1,129 @@
+/*jslint nomen: true */
+var Store = require('../../lib/store'),
+    path = require('path'),
+    fs = require('fs'),
+    util = require('util'),
+    foo = path.resolve(__dirname, 'data', 'foo.js'),
+    baz = path.resolve(__dirname, 'data', 'baz.js'),
+    anon = path.resolve(__dirname, 'data', 'does_not_exist.js'),
+    fooContents = fs.readFileSync(foo, 'utf8'),
+    bazContents = fs.readFileSync(baz, 'utf8');
+
+module.exports = {
+    "fslookup store should work correctly": function (test) {
+        var store = Store.create('fslookup');
+
+        store.set(foo, 'content');
+        test.ok(store.hasKey(foo));
+        test.ok(store.hasKey(baz));
+        test.ok(!store.hasKey(anon));
+        test.equal(0, store.keys().length);
+
+        test.equals(fooContents, store.get(foo));
+        test.equals(bazContents, store.get(baz));
+        test.throws(function () {
+            store.get(anon);
+        });
+        test.throws(function () {
+            store.set(anon, 'foo');
+        }, Error, /non-existent/);
+        test.done();
+    },
+
+    "tmp store should work as expected": function (test) {
+        var store = Store.create('tmp');
+
+        test.equal(0, store.keys().length);
+        store.set(foo, 'content');
+        test.ok(store.hasKey(foo));
+        test.ok(!store.hasKey(baz));
+        test.equal(1, store.keys().length);
+        store.set(baz, 'baz content');
+        test.equal(2, store.keys().length);
+
+        test.equals('content', store.get(foo));
+        test.equals('baz content', store.get(baz));
+        test.throws(function () {
+            store.get(anon);
+        });
+        store.dispose();
+        test.ok(!store.hasKey(foo));
+        test.equal(0, store.keys().length);
+        test.done();
+    },
+
+    "memory store should work as expected": function (test) {
+        var store = Store.create('memory');
+
+        test.equal(0, store.keys().length);
+        store.set(foo, 'content');
+        test.ok(store.hasKey(foo));
+        test.ok(!store.hasKey(baz));
+        test.equal(1, store.keys().length);
+        store.set(baz, 'baz content');
+        test.equal(2, store.keys().length);
+
+        test.equals('content', store.get(foo));
+        test.equals('baz content', store.get(baz));
+        test.throws(function () {
+            store.get(anon);
+        });
+        store.dispose();
+        test.ok(!store.hasKey(foo));
+        test.equal(0, store.keys().length);
+        test.done();
+    },
+
+    "should be able to register a new store": function (test) {
+        function NStore() {
+        }
+        NStore.prototype = {
+            set: function (/* file, content */) { return 'x'; }
+        };
+        NStore.TYPE = 'nstore';
+
+        Store.register(NStore);
+        var store = Store.create('nstore');
+        test.ok(store);
+        test.equals('x', store.set('foo', 'bar'));
+        test.done();
+    },
+
+    "should not be able to register an invalid store": function (test) {
+        function NStore() {}
+        test.throws(function () {
+            Store.register(NStore);
+        },
+            /TYPE/);
+        test.done();
+    },
+
+    "invalid store should not be created": function (test) {
+        test.throws(
+            function () { Store.create('foo'); },
+            /Invalid store \[foo\], allowed values are /
+        );
+        test.done();
+    },
+
+    "should require overriding of all overrideables": function (test) {
+        function NStore() {}
+        NStore.TYPE = 'nstore';
+        util.inherits(NStore, Store);
+        Store.register(NStore);
+
+        var store = Store.create('nstore'),
+            asserter = function (fn) {
+                test.throws(function () {
+                    fn();
+                },
+                    /must be overridden/);
+            };
+        asserter(function () { store.set('foo', 'bar'); });
+        asserter(function () { store.get('foo'); });
+        asserter(function () { store.hasKey('foo'); });
+        asserter(function () { store.keys(); });
+        test.doesNotThrow(function () { store.dispose(); });
+        test.done();
+    }
+};