cssesc-source 0.1.0

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

@@ -0,0 +1,35 @@
+/*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

@@ -0,0 +1,182 @@
+/*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

@@ -0,0 +1,121 @@
+/*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

@@ -0,0 +1,155 @@
+/*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();
+            }
+        }
+    }
+};
+