cssesc-source 0.1.0 → 1.0.1

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

@@ -1,35 +0,0 @@
-/*jslint nomen: true */
-var Instrumenter = require('../../lib/instrumenter'),
-    esprima = require('esprima'),
-    instrumenter;
-
-module.exports = {
-    "missing type attributes": {
-        setUp: function (cb) {
-            instrumenter = new Instrumenter();
-            cb();
-        },
-        "barfs when a type attr is missing for a general node": function (test) {
-            var ast = esprima.parse('var foo = 1;', { loc: true });
-            delete ast.body[0].type;
-            try {
-                instrumenter.instrumentASTSync(ast);
-                test.fail('instrumentation succeeded when it should not have');
-            } catch (ex) {
-                //ok
-            }
-            test.done();
-        },
-        "but succeeds when a property node in an AST does not have the type attr": function (test) {
-            var ast = esprima.parse('var foo = { a: 1 };', { loc: true });
-            delete ast.body[0].declarations[0].init.properties[0].type;
-            try {
-                instrumenter.instrumentASTSync(ast);
-            } catch (ex) {
-                test.fail('instrumentation should have succeeded but did not');
-            }
-            test.done();
-        }
-    }
-};
-

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

@@ -1,182 +0,0 @@
-/*jslint nomen: true */
-var helper = require('../helper'),
-    Instrumenter = require('../../lib/instrumenter'),
-    code,
-    verifier;
-
-module.exports = {
-    "with a simple statement": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0] > 5 ? args[0] : "undef";',
-                'output = x;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover line and one branch": function (test) {
-            verifier.verify(test, [ 10 ], 10, { lines: { 1: 1, 2: 1 }, branches: { 1: [1, 0 ]}, functions: {}, statements: { 1: 1, 2: 1 } });
-            test.done();
-        },
-        "should cover line and other branch": function (test) {
-            verifier.verify(test, [ 1 ], "undef", { lines: { 1: 1, 2: 1 }, branches: { 1: [ 0, 1 ]}, functions: {}, statements: { 1: 1, 2: 1 } });
-            test.done();
-        }
-    },
-    "with no filename": {
-        setUp: function (cb) {
-            code = [
-                'output = args[0];'
-            ];
-            verifier = helper.verifier(null, code, { debug: true, walkDebug: true });
-            cb();
-        },
-        "should not barf in setup": function (test) {
-            verifier.verify(test, [ 1 ], 1, { lines: { 1: 1 }, branches: {}, functions: {}, statements: { 1: 1 } });
-            test.done();
-        }
-    },
-    "with a windows style file path": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0] > 5 ? args[0] : "undef";',
-                'output = x;'
-            ];
-            verifier = helper.verifier("c:\\a\\b\\c\\d\\e.js", code);
-            cb();
-        },
-        "should have correct key in coverage variable": function (test) {
-            verifier.verify(test, [ 1 ], "undef", { lines: { 1: 1, 2: 1 }, branches: { 1: [ 0, 1 ]}, functions: {}, statements: { 1: 1, 2: 1 } });
-            var coverage = verifier.getCoverage(),
-                key = Object.keys(coverage)[0];
-            test.equals("c:\\a\\b\\c\\d\\e.js", key);
-            test.done();
-        }
-
-    },
-    "with junk code": {
-        setUp: function (cb) {
-            code = [
-                'output = args[0] : 1 : 2;'
-            ];
-            verifier = helper.verifier(null, code, { debug: true, walkDebug: true });
-            cb();
-        },
-        "should have verification errors": function (test) {
-            verifier.verifyError(test);
-            test.done();
-        }
-    },
-    "with code that is not a string": {
-        "should have verification errors": function (test) {
-            test.throws(function () {
-                var instrumenter = new Instrumenter();
-                instrumenter.instrumentSync({}, 'foo.js');
-            }, Error, 'Code must be a string');
-            test.done();
-        }
-    },
-    "with shebang code": {
-        setUp: function (cb) {
-            code = [
-                '#!/usr/bin/env node',
-                'var x = args[0] > 5 ? args[0] : "undef";',
-                'output = x;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover line and one branch": function (test) {
-            verifier.verify(test, [ 10 ], 10, { lines: { 2: 1, 3: 1 }, branches: { 1: [1, 0 ]}, functions: {}, statements: { 1: 1, 2: 1 } });
-            test.done();
-        },
-        "should cover line and other branch": function (test) {
-            verifier.verify(test, [ 1 ], "undef", { lines: { 2: 1, 3: 1 }, branches: { 1: [ 0, 1 ]}, functions: {}, statements: { 1: 1, 2: 1 } });
-            test.done();
-        }
-    },
-    "with source code packed in": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0] > 5 ? args[0] : "undef";',
-                'output = x;'
-            ];
-            verifier = helper.verifier(__filename, code, { embedSource: true, coverageVariable: null });
-            cb();
-        },
-        "coverage should have code packed in": function (test) {
-            verifier.verifyNoError(test);
-            verifier.verify(test, [ 10 ], 10, { lines: { 1: 1, 2: 1 }, branches: { 1: [1, 0 ]}, functions: {}, statements: { 1: 1, 2: 1 } });
-            var cov = verifier.getCoverage(),
-                fileCov = cov[Object.keys(cov)[0]];
-            test.ok(fileCov.code.length > 1);
-            test.ok(fileCov.code[1] === 'output = x;');
-            test.done();
-        },
-        "code packed in does not have \\r characters": function (test) {
-            code = [
-                'var x = args[0] > 5 ? args[0] : "undef";\r',
-                'output = x;\r'
-            ];
-            verifier = helper.verifier(__filename + '2', code, { embedSource: true, coverageVariable: null });
-            verifier.verifyNoError(test);
-            verifier.verify(test, [ 10 ], 10, { lines: { 1: 1, 2: 1 }, branches: { 1: [1, 0 ]}, functions: {}, statements: { 1: 1, 2: 1 } });
-            var cov = verifier.getCoverage(),
-                fileCov = cov[Object.keys(cov)[0]];
-            test.ok(fileCov.code.length > 1);
-            test.ok(fileCov.code[1] === 'output = x;');
-            test.done();
-        }
-    },
-    "with code having a return statement on mainline": {
-        setUp: function (cb) {
-            code = [
-                'return 10;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should pass coverage": function (test) {
-            verifier.verifyNoError(test);
-            test.done();
-        }
-    },
-    "with code having a return statement on mainline and no autowrap": {
-        setUp: function (cb) {
-            code = [
-                'return 10;'
-            ];
-            verifier = helper.verifier(__filename, code, { noAutoWrap: true });
-            cb();
-        },
-
-        "should fail coverage": function (test) {
-            verifier.verifyError(test);
-            test.done();
-        }
-    },
-    "with no mainline returns and no autowrap": {
-        setUp: function (cb) {
-            code = [
-                '#!/usr/bin/env node',
-                'var x = args[0] > 5 ? args[0] : "undef";',
-                'output = x;'
-            ];
-            verifier = helper.verifier(__filename, code, { noAutoWrap: true });
-            cb();
-        },
-
-        "should cover line and one branch": function (test) {
-            verifier.verify(test, [ 10 ], 10, { lines: { 2: 1, 3: 1 }, branches: { 1: [1, 0 ]}, functions: {}, statements: { 1: 1, 2: 1 } });
-            test.done();
-        },
-        "should cover line and other branch": function (test) {
-            verifier.verify(test, [ 1 ], "undef", { lines: { 2: 1, 3: 1 }, branches: { 1: [ 0, 1 ]}, functions: {}, statements: { 1: 1, 2: 1 } });
-            test.done();
-        }
-    }
-};
-

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

@@ -1,121 +0,0 @@
-/*jslint nomen: true */
-var helper = require('../helper'),
-    code,
-    verifier;
-
-module.exports = {
-    "with a function expression that uses strict": {
-        setUp: function (cb) {
-            code = [
-                '(function () {',
-                '    "use strict";',
-                '    var x = Object.freeze({ foo: 1 });',
-                '    try {',
-                '        x.foo = 2;',
-                '        output = "fail";',
-                '    } catch (ex) {',
-                '        output = "pass";',
-                '    }',
-                '}());'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover one statement less": function (test) {
-            verifier.verify(test, [], "pass", {
-                statements: { 1: 1, 2: 1, 3: 1, 4: 1, 5: 0, 6: 1 },
-                lines: { 1: 1, 3: 1, 4: 1, 5: 1, 6: 0, 8: 1 },
-                branches: {},
-                functions: { 1: 1}
-            });
-            test.done();
-        }
-    },
-    "with a function declaration that uses strict": {
-        setUp: function (cb) {
-            code = [
-                'function foo() {',
-                '    "use strict";',
-                '    var x = Object.freeze({ foo: 1 });',
-                '    try {',
-                '        x.foo = 2;',
-                '        output = "fail";',
-                '    } catch (ex) {',
-                '        output = "pass";',
-                '    }',
-                '}',
-                'foo();'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover one statement less": function (test) {
-            verifier.verify(test, [], "pass", {
-                statements: { 1: 1, 2: 1, 3: 1, 4: 1, 5: 0, 6: 1, 7: 1 },
-                lines: { 1: 1, 3: 1, 4: 1, 5: 1, 6: 0, 8: 1, 11: 1 },
-                branches: {},
-                functions: { 1: 1}
-            });
-            test.done();
-        }
-    },
-    "with a function declaration that looks like strict but is not": {
-        setUp: function (cb) {
-            code = [
-                'function foo() {',
-                '    1;',
-                '    "use strict";',
-                '    var x = Object.freeze({ foo: 1 });',
-                '    try {',
-                '        x.foo = 2;',
-                '        output = "fail";',
-                '    } catch (ex) {',
-                '        output = "pass";',
-                '    }',
-                '}',
-                'foo();'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover all statements as usual": function (test) {
-            verifier.verify(test, [], "fail", {
-                statements: { 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 0, 9: 1 },
-                lines: { 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 9: 0, 12: 1 },
-                branches: {},
-                functions: { 1: 1}
-            });
-            test.done();
-        }
-    },
-    "with a file-level strict declaration": {
-        setUp: function (cb) {
-            code = [
-                '    "use strict";',
-                '    var x = Object.freeze({ foo: 1 });',
-                '    try {',
-                '        x.foo = 2;',
-                '        output = "fail";',
-                '    } catch (ex) {',
-                '        output = "pass";',
-                '    }'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should not change behavor (this is a bug!)": function (test) {
-            verifier.verify(test, [], "fail", {
-                statements: { 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 0 },
-                lines: { 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 7: 0 },
-                branches: {},
-                functions: {}
-            });
-            test.done();
-        }
-    }
-};
-

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

@@ -1,155 +0,0 @@
-/*jslint nomen: true */
-var helper = require('../helper'),
-    code,
-    verifier;
-
-/*jshint maxlen: 500 */
-module.exports = {
-    "with an empty switch": {
-        setUp: function (cb) {
-            code = [
-                'output = "unknown";',
-                'switch (args[0]) {',
-                '}'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb(null);
-        },
-        "should not barf in any way": function (test) {
-            verifier.verify(test, [ "1" ], "unknown", { lines: { 1: 1, 2: 1 }, branches: {}, functions: {}, statements: { 1: 1, 2: 1 } });
-            test.done();
-        }
-    },
-    "with a simple switch": {
-        "and 2 cases without a default": {
-            setUp: function (cb) {
-                code = [
-                    'output = "unknown";',
-                    'switch (args[0]) {',
-                    '   case "1": output = "one"; break;',
-                    '   case "2": output = "two"; break;',
-                    '}'
-                ];
-                verifier = helper.verifier(__filename, code);
-                cb(null);
-            },
-            "should cover one path": function (test) {
-                verifier.verify(test, [ "1" ], "one", { lines: { 1: 1, 2: 1, 3: 1, 4: 0 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { 1: 1, 2: 1, 3: 1, 4: 1, 5: 0, 6: 0 } });
-                test.done();
-            },
-            "should cover two path": function (test) {
-                verifier.verify(test, [ "2" ], "two", { lines: { 1: 1, 2: 1, 3: 0, 4: 1 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { 1: 1, 2: 1, 3: 0, 4: 0, 5: 1, 6: 1 } });
-                test.done();
-            },
-            "should cover unknown path": function (test) {
-                verifier.verify(test, [ "3" ], "unknown", { lines: { 1: 1, 2: 1, 3: 0, 4: 0 }, branches: { '1': [ 0, 0 ] }, functions: {}, statements: { 1: 1, 2: 1, 3: 0, 4: 0, 5: 0, 6: 0 } });
-                test.done();
-            }
-        },
-        "and 2 cases with a default": {
-            setUp: function (cb) {
-                code = [
-                    'output = "unknown";',
-                    'switch (args[0]) {',
-                    '   case "1": output = "one"; break;',
-                    '   case "2": output = "two"; break;',
-                    '   default: output = "three";',
-                    '}'
-                ];
-                verifier = helper.verifier(__filename, code);
-                cb(null);
-            },
-            "should cover one path": function (test) {
-                verifier.verify(test, [ "1" ], "one", { lines: { 1: 1, 2: 1, 3: 1, 4: 0, 5: 0 }, branches: { '1': [ 1, 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 1, '5': 0, '6': 0, '7': 0 } });
-                test.done();
-            },
-            "should cover two path": function (test) {
-                verifier.verify(test, [ "2" ], "two", { lines: { 1: 1, 2: 1, 3: 0, 4: 1, 5: 0 }, branches: { '1': [ 0, 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0, '5': 1, '6': 1, '7': 0 } });
-                test.done();
-            },
-            "should cover unknown path": function (test) {
-                verifier.verify(test, [ "4" ], "three", { lines: { 1: 1, 2: 1, 3: 0, 4: 0, 5: 1 }, branches: { '1': [ 0, 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0, '5': 0, '6': 0, '7': 1 } });
-                test.done();
-            }
-        },
-        "and 2 cases with a default everything squeezed on one line": {
-            setUp: function (cb) {
-                code = [
-                    'output = "unknown";',
-                    'switch (args[0]) {' +
-                        '   case "1": output = "one"; break;' +
-                        '   case "2": output = "two"; break;' +
-                        '   default: output = "three";' +
-                        '}'
-                ];
-                verifier = helper.verifier(__filename, code);
-                cb(null);
-            },
-            "should cover one path": function (test) {
-                verifier.verify(test, [ "1" ], "one", { lines: { 1: 1, 2: 1 }, branches: { '1': [ 1, 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 1, '5': 0, '6': 0, '7': 0 } });
-                test.done();
-            },
-            "should cover two path": function (test) {
-                verifier.verify(test, [ "2" ], "two", { lines: { 1: 1, 2: 1 }, branches: { '1': [ 0, 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0, '5': 1, '6': 1, '7': 0 } });
-                test.done();
-            },
-            "should cover unknown path": function (test) {
-                verifier.verify(test, [ "4" ], "three", { lines: { 1: 1, 2: 1  }, branches: { '1': [ 0, 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0, '5': 0, '6': 0, '7': 1 } });
-                test.done();
-            }
-        },
-        "and 2 cases with a default and fall-thru": {
-            setUp: function (cb) {
-                code = [
-                    'output = "";',
-                    'switch (args[0]) {',
-                    '   case "1": output += "one";',
-                    '   case "2": output += "two";',
-                    '   default: output += "three";',
-                    '}'
-                ];
-                verifier = helper.verifier(__filename, code);
-                cb(null);
-            },
-            "should cover one path": function (test) {
-                verifier.verify(test, [ "1" ], "onetwothree", { lines: { 1: 1, 2: 1, 3: 1, 4: 1, 5: 1 }, branches: { '1': [ 1, 1, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 1, '5': 1 } });
-                test.done();
-            },
-            "should cover two path": function (test) {
-                verifier.verify(test, [ "2" ], "twothree", { lines: { 1: 1, 2: 1, 3: 0, 4: 1, 5: 1 }, branches: { '1': [ 0, 1, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 1, '5': 1 } });
-                test.done();
-            },
-            "should cover unknown path": function (test) {
-                verifier.verify(test, [ "4" ], "three", { lines: { 1: 1, 2: 1, 3: 0, 4: 0, 5: 1 }, branches: { '1': [ 0, 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0, '5': 1 } });
-                test.done();
-            }
-        },
-        "and 2 cases with a default and fall-thru all on one line": {
-            setUp: function (cb) {
-                code = [
-                    'output = "";',
-                    'switch (args[0]) {' +
-                        '   case "1": output += "one";' +
-                        '   case "2": output += "two";' +
-                        '   default: output += "three";' +
-                        '}'
-                ];
-                verifier = helper.verifier(__filename, code);
-                cb(null);
-            },
-            "should cover one path": function (test) {
-                verifier.verify(test, [ "1" ], "onetwothree", { lines: { 1: 1, 2: 1 }, branches: { '1': [ 1, 1, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 1, '5': 1 } });
-                test.done();
-            },
-            "should cover two path": function (test) {
-                verifier.verify(test, [ "2" ], "twothree", { lines: { 1: 1, 2: 1 }, branches: { '1': [ 0, 1, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 1, '5': 1 } });
-                test.done();
-            },
-            "should cover unknown path": function (test) {
-                verifier.verify(test, [ "4" ], "three", { lines: { 1: 1, 2: 1 }, branches: { '1': [ 0, 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0, '5': 1 } });
-                test.done();
-            }
-        }
-    }
-};
-