cssesc-source 0.1.0

data/vendor/node_modules/istanbul/test/instrumentation/test-while.js

@@ -0,0 +1,104 @@
+/*jslint nomen: true */
+var helper = require('../helper'),
+    code,
+    verifier;
+
+/*jshint maxlen: 500 */
+module.exports = {
+    "with a simple while": {
+        setUp: function (cb) {
+            code = [
+                'var x = args[0], i=0;',
+                'while (i < x) i++;',
+                'output = i;'
+            ];
+            verifier = helper.verifier(__filename, code);
+            cb();
+        },
+
+        "should cover loop exactly once": function (test) {
+            verifier.verify(test, [ 1 ], 1, { lines: { 1: 1, 2: 1, 3: 1 }, branches: {}, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 1 } });
+            test.done();
+        },
+        "should cover loop multiple times": function (test) {
+            verifier.verify(test, [ 10 ], 10, { lines: { 1: 1, 2: 10, 3: 1 }, branches: {}, functions: {}, statements: { '1': 1, '2': 1, '3': 10, '4': 1 } });
+            test.done();
+        }
+    },
+    "with a simple while - statement on a different line": {
+        setUp: function (cb) {
+            code = [
+                'var x = args[0], i=0;',
+                'while (i < x)',
+                '   i++;',
+                'output = i;'
+            ];
+            verifier = helper.verifier(__filename, code);
+            cb();
+        },
+
+        "should cover loop one time": function (test) {
+            verifier.verify(test, [ 10 ], 10, { lines: { 1: 1, 2: 1, 3: 10, 4: 1 }, branches: {}, functions: {}, statements: { '1': 1, '2': 1, '3': 10, '4': 1 } });
+            test.done();
+        },
+
+        "should not cover loop at all": function (test) {
+            verifier.verify(test, [ -1 ], 0, { lines: { 1: 1, 2: 1, 3: 0, 4: 1 }, branches: {}, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 1 } });
+            test.done();
+        }
+    },
+    "with a simple while in block": {
+        setUp: function (cb) {
+            code = [
+                'var x = args[0], i=0;',
+                'while (i < x) { i++; }',
+                'output = i;'
+            ];
+            verifier = helper.verifier(__filename, code);
+            cb();
+        },
+
+        "should cover multi-loop exactly once": function (test) {
+            verifier.verify(test, [ 10 ], 10, { lines: { 1: 1, 2: 10, 3: 1 }, branches: {}, functions: {}, statements: { '1': 1, '2': 1, '3': 10, '4': 1 } });
+            test.done();
+        }
+    },
+    "with a labeled while": {
+        setUp: function (cb) {
+            code = [
+                'var x = args[0], i=0, j=0, output = 0;',
+                'outer:',
+                '   while (i++ < x) {',
+                '       j =0;',
+                '       while (j++ < i) {',
+                '           output++;',
+                '           if (j === 2) continue outer;',
+                '       }',
+                '   }'
+            ];
+            verifier = helper.verifier(__filename, code);
+            cb();
+        },
+
+        "should provide line/branch coverage when all branches exercised": function (test) {
+            verifier.verify(test, [ 10 ], 19, {
+                lines: { '1': 1, '2': 1, '3': 1, '4': 10, '5': 10, '6': 19, '7': 19 },
+                branches: { '1': [ 9, 10 ] },
+                functions: {},
+                statements: { '1': 1, '2': 1, '3': 1, '4': 10, '5': 10, '6': 19, '7': 19, '8': 9 }
+            });
+            test.done();
+        },
+
+        "should provide line/branch coverage when nothing exercised": function (test) {
+            verifier.verify(test, [ -1 ], 0, {
+                lines: { '1': 1, '2': 1, '3': 1, '4': 0, '5': 0, '6': 0, '7': 0 },
+                branches: { '1': [ 0, 0 ] },
+                functions: {},
+                statements: { '1': 1, '2': 1, '3': 1, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0 }
+            });
+            test.done();
+        }
+    }
+};
+

data/vendor/node_modules/istanbul/test/loader.js

@@ -0,0 +1,38 @@
+/*jslint nomen: true, regexp: true */
+var path = require('path'),
+    fs = require('fs');
+
+require('../lib/register-plugins');
+
+function loadDirTests(dir, pat) {
+    var files = fs.readdirSync(path.resolve(__dirname, dir))
+        .filter(function (f) {
+            //return f.indexOf('browser') > 0;
+            return pat.exec(f) && f.indexOf('.js') > 0 && f.indexOf('client.js') < 0 && f !== 'server.js';
+        })
+        .map(function (f) { return path.resolve(__dirname, dir, f).substring(process.cwd().length); });
+    return files;
+}
+
+function runTests(pat, reporter, opts, callback) {
+    var files,
+        files2,
+        files3,
+        files4;
+
+    pat = pat || /(.*)+\.js$/;
+    if (typeof pat === 'string') { pat = new RegExp(pat); }
+    files = loadDirTests('instrumentation', pat);
+    files2 = loadDirTests('other', pat);
+    files3 = loadDirTests('cli', pat);
+    files4 = loadDirTests('browser', pat);
+    files.push.apply(files, files2);
+    files.push.apply(files, files3);
+    files.push.apply(files, files4);
+    reporter.run(files, opts, callback);
+}
+
+module.exports = {
+    runTests: runTests
+};
+

data/vendor/node_modules/istanbul/test/other/data-complete-copy/baz.js

@@ -0,0 +1,3 @@
+module.exports = {
+    baz: function () { return 'baz'; }
+};

data/vendor/node_modules/istanbul/test/other/data-complete-copy/fixture.xml

@@ -0,0 +1 @@
+<xml />

data/vendor/node_modules/istanbul/test/other/data-complete-copy/foo.js

@@ -0,0 +1,4 @@
+module.exports = {
+    foo: function () { return 'foo'; }
+};
+

data/vendor/node_modules/istanbul/test/other/data-complete-copy/myfile2

@@ -0,0 +1 @@
+some content

data/vendor/node_modules/istanbul/test/other/data-complete-copy/subdir/x.css

@@ -0,0 +1,3 @@
+body {
+    font-family: verdana;
+}

data/vendor/node_modules/istanbul/test/other/data/baz.js

@@ -0,0 +1,3 @@
+module.exports = {
+    baz: function () { return 'baz'; }
+};

data/vendor/node_modules/istanbul/test/other/data/foo.js

@@ -0,0 +1,4 @@
+module.exports = {
+    foo: function () { return 'foo'; }
+};
+

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

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

data/vendor/node_modules/istanbul/test/other/data/matcher/general/node_modules/mod-file.js

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

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

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

data/vendor/node_modules/istanbul/test/other/data/matcher/node_modules/dep/mod-file.js

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

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

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

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

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

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

@@ -0,0 +1,85 @@
+var Collector = require('../../lib/collector'),
+    utils = require('../../lib/object-utils'),
+    coverageObj,
+    coverageObj2,
+    collector;
+
+module.exports = {
+    "tearDown": function (cb) { collector.dispose(); cb(); },
+    "with a single coverage object": {
+        setUp: function (cb) {
+            var loc = { start: { line: 1, column: 5 }, end: { line: 1, column: 10 } };
+            coverageObj = {
+                foo: {
+                    statementMap: { 1: loc, 2: loc, 3: loc },
+                    s: { 1: 0, 2: 3, 3: 5 },
+                    b: { 1: [5, 7], 2: [3, 0], 3: [0, 5] },
+                    f: { 1: 4, 2: 0, 3: 1},
+                    path: 'foo'
+                },
+                bar: {
+                    statementMap: { 1: loc, 2: loc, 3: loc, 4: loc },
+                    s: { 1: 0, 2: 0, 3: 17, 4: 3 },
+                    b: { 1: [ 0, 8, 9 ], 2: [4, 1], 3: [0, 5] },
+                    f: { 1: 7, 2: 78, 3: 9, 4: 0 },
+                    path: 'bar'
+                }
+            };
+            collector = new Collector();
+            cb();
+        },
+        "collector should not molest any stats": function (test) {
+            collector.add(JSON.parse(JSON.stringify(coverageObj)));
+            utils.addDerivedInfo(coverageObj);
+            test.deepEqual(['foo', 'bar'], collector.files());
+            test.deepEqual(coverageObj, collector.getFinalCoverage());
+            test.deepEqual(coverageObj.foo, collector.fileCoverageFor('foo'));
+            test.deepEqual(coverageObj.bar, collector.fileCoverageFor('bar'));
+            test.done();
+        }
+    },
+    "with multiple coverage objects": {
+        setUp: function (cb) {
+            var loc = { start: { line: 1, column: 5 }, end: { line: 1, column: 10 } };
+            coverageObj = {
+                foo: {
+                    s: { 1: 0, 2: 3, 3: 5 },
+                    statementMap: { 1: loc, 2: loc, 3: loc },
+                    b: { 1: [5, 7], 2: [3, 0], 3: [0, 5] },
+                    f: { 1: 4, 2: 0, 3: 1},
+                    path: 'foo'
+                },
+                bar: {
+                    s: { 1: 0, 2: 0, 3: 17, 4: 3 },
+                    statementMap: { 1: loc, 2: loc, 3: loc, 4: loc },
+                    b: { 1: [ 0, 8, 9 ], 2: [4, 1], 3: [0, 5] },
+                    f: { 1: 7, 2: 78, 3: 9, 4: 0 },
+                    path: 'bar'
+                }
+            };
+            coverageObj2 = {
+                foo: {
+                    s: { 1: 1, 2: 5, 3: 88 },
+                    statementMap: { 1: loc, 2: loc, 3: loc },
+                    b: { 1: [0, 9], 2: [5, 6], 3: [55, 8] },
+                    f: { 1: 0, 2: 0, 3: 9 },
+                    path: 'foo'
+                }
+            };
+            collector = new Collector();
+            cb();
+        },
+        "collector should merge foo coverage": function (test) {
+            var mergedFoo = utils.mergeFileCoverage(coverageObj.foo, coverageObj2.foo),
+                mergedFinal = { foo: mergedFoo, bar: coverageObj.bar };
+            collector.add(JSON.parse(JSON.stringify(coverageObj)));
+            collector.add(JSON.parse(JSON.stringify(coverageObj2)));
+            utils.addDerivedInfo(mergedFinal);
+            test.deepEqual(['foo', 'bar'], collector.files());
+            test.deepEqual(mergedFinal, collector.getFinalCoverage());
+            test.deepEqual(mergedFinal.foo, collector.fileCoverageFor('foo'));
+            test.deepEqual(mergedFinal.bar, collector.fileCoverageFor('bar'));
+            test.done();
+        }
+    }
+};

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

@@ -0,0 +1,35 @@
+var Command = require('../../lib/command');
+
+module.exports = {
+    "should return command list": function (test) {
+        var cmdList = Command.getCommandList();
+        test.ok(cmdList.length > 0);
+        cmdList.forEach(function (name) {
+            var command = Command.create(name);
+            test.ok(command.synopsis && command.synopsis());
+            test.ok(command.usage && typeof command.usage === 'function');
+            command.usage();
+            test.ok(command.run && typeof command.run === 'function');
+        });
+        test.done();
+    },
+    "should run help for all commands without any barfs": function (test) {
+        var cmdList = Command.getCommandList(),
+            help = Command.create('help'),
+            handler = function (err) { test.ok(!err); };
+        help.run([], handler);
+        help.run(['foobar'], handler);
+        help.run(['foobar', 'foobar', 'foobar'], handler);
+        cmdList.forEach(function (name) {
+            if (name !== 'help') {
+                help.run([ name ], handler);
+            }
+        });
+        test.done();
+    },
+    "should throw on non-existent command": function (test) {
+        test.throws(function () { Command.create('nonexistent-command'); },
+            /existent/);
+        test.done();
+    }
+};

data/vendor/node_modules/istanbul/test/other/test-file-writer.js

@@ -0,0 +1,71 @@
+/*jslint nomen: true */
+
+var path = require('path'),
+    fs = require('fs'),
+    mkdirp = require('mkdirp'),
+    rimraf = require('rimraf'),
+    FileWriter = require('../../lib/util/file-writer'),
+    outputDir = path.resolve(__dirname, 'output'),
+    FOO = path.resolve(outputDir, 'foo-written.js'),
+    writer,
+    MAX_FILES = 1000,
+    LINES = [ 'This is line 1', 'This is line 2', 'This is line 3' ];
+
+function testContents(test) {
+    test.equal(LINES.join('\n') + '\n', fs.readFileSync(FOO, 'utf8'));
+    test.done();
+}
+
+function fileNames() {
+    var i,
+        ret = [];
+    for (i = 0; i < MAX_FILES; i += 1) {
+        ret.push(path.resolve(outputDir, 'file' + i + '.txt'));
+    }
+    return ret;
+}
+
+function testAllFiles(test) {
+    var files = fileNames();
+    files.forEach(function (file) {
+        test.equal(file + '\n', fs.readFileSync(file, 'utf8'));
+    });
+    test.done();
+}
+
+function battery(sync) {
+    return {
+        setUp: function (cb) {
+            mkdirp.sync(outputDir);
+            writer = new FileWriter(sync);
+            cb();
+        },
+        tearDown: function (cb) {
+            writer = null;
+            rimraf.sync(outputDir);
+            cb();
+        },
+        "should write file in callback mode": function (test) {
+            writer.on('done', testContents.bind(null, test));
+            writer.writeFile(FOO, function (w) {
+                LINES.forEach(function (line) { w.println(line); });
+            });
+            writer.done();
+        },
+        "should write 1000 files": function (test) {
+            var files = fileNames();
+            writer.on('done', testAllFiles.bind(null, test));
+            files.forEach(function (file) {
+                writer.writeFile(file, function (w) {
+                    w.println(file);
+                });
+            });
+            writer.done();
+        }
+    };
+}
+
+module.exports = {
+    "when in sync mode": battery(true),
+    "when in async mode": battery(false)
+};

data/vendor/node_modules/istanbul/test/other/test-help-formatter.js

@@ -0,0 +1,31 @@
+var formatOption = require('../../lib/util/help-formatter').formatOption,
+    THRESHOLD = 20;
+
+module.exports = {
+    "should format small option + text on a single line": function (test) {
+        var formatted = formatOption('-f', 'specify force override of defaults');
+        console.log(formatted);
+        test.ok(formatted.indexOf('\n') < 0);
+        test.done();
+    },
+    "should format small option + big text on multiple lines": function (test) {
+        var formatted = formatOption('-f', 'an option whose description should exceed the length of a line if we have done our job well');
+        console.log(formatted);
+        test.ok(formatted.indexOf('\n') > THRESHOLD);
+        test.done();
+    },
+    "should format long option + small text on multiple lines": function (test) {
+        var formatted = formatOption('--[no]force', 'specify force override of defaults');
+        console.log(formatted);
+        test.ok(formatted.indexOf('\n') < THRESHOLD);
+        test.ok(formatted.lastIndexOf('\n') < THRESHOLD);
+        test.done();
+    },
+    "should format long option + big text on 3 lines": function (test) {
+        var formatted = formatOption('--[no]force', 'an option whose description should exceed the length of a line if we have done our job well');
+        console.log(formatted);
+        test.ok(formatted.indexOf('\n') < THRESHOLD);
+        test.ok(formatted.lastIndexOf('\n') > THRESHOLD);
+        test.done();
+    }
+};

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

@@ -0,0 +1,87 @@
+/*jslint nomen: true */
+var hook = require('../../lib/hook'),
+    currentHook,
+    matcher = function (file) { return file.indexOf('foo.js') > 0; },
+    transformer = function () { return 'module.exports.bar = function () { return "bar"; };'; },
+    transformer2 = function () { return 'module.exports.blah = function () { return "blah"; };'; },
+    badTransformer = function () { throw "Boo!"; },
+    scriptTransformer = function () { return '(function () { return 42; }());'; };
+
+module.exports = {
+    "when require is hooked": {
+        setUp: function (cb) {
+            currentHook = require('module')._extensions['.js'];
+            hook.hookRequire(matcher, transformer, { verbose: true });
+            cb();
+        },
+        tearDown: function (cb) {
+            hook.unloadRequireCache(matcher);
+            require('module')._extensions['.js'] = currentHook;
+            cb();
+        },
+
+        "foo should be transformed": function (test) {
+            var foo = require('./data/foo');
+            test.ok(foo.bar);
+            test.equals('bar', foo.bar());
+            test.done();
+        },
+
+        "but baz should be skipped": function (test) {
+            var foo = require('./data/baz');
+            test.ok(foo.baz);
+            test.equals('baz', foo.baz());
+            test.done();
+        },
+
+        "postLoadHook should be called": function (test) {
+            var called = null,
+                opts = { postLoadHook: function (file) { called = file; }},
+                foo;
+
+            hook.unhookRequire();
+            hook.hookRequire(matcher, transformer, opts);
+            foo = require('./data/foo');
+            test.ok(called.match(/foo\.js/));
+            test.done();
+        },
+
+        "and cache should be un- and reloaded": function (test) {
+            hook.unhookRequire();
+            hook.hookRequire(matcher, transformer2);
+            var foo = require('./data/foo');
+            test.ok(foo.blah);
+            test.equals('blah', foo.blah());
+            test.done();
+        },
+
+        "bad transformer should return original code": function (test) {
+            hook.unhookRequire();
+            hook.hookRequire(matcher, badTransformer);
+            var foo = require('./data/foo');
+            test.ok(foo.foo);
+            test.equals('foo', foo.foo());
+            test.done();
+        }
+    },
+    "when createScript is hooked": {
+        setUp: function (cb) {
+            currentHook = require('vm').createScript;
+            cb();
+        },
+        tearDown: function (cb) {
+            require('vm').createScript = currentHook;
+            cb();
+        },
+        "foo should be transformed (without any options)": function (test) {
+            var s;
+            hook.hookCreateScript(matcher, scriptTransformer);
+            s = require('vm').createScript('(function () { return 10; }());', '/bar/foo.js');
+            test.equals(42, s.runInThisContext());
+            hook.unhookCreateScript();
+            s = require('vm').createScript('(function () { return 10; }());', '/bar/foo.js');
+            test.equals(10, s.runInThisContext());
+            test.done();
+        }
+    }
+};