cssesc-source 0.1.0 → 1.0.1

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

@@ -1,70 +0,0 @@
-/*jslint nomen: true */
-var helper = require('../helper'),
-    code,
-    verifier;
-
-/*jshint maxlen: 500 */
-module.exports = {
-    "with a simple expression": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0] > 0 && args[0] < 5;',
-                'output = x;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover line and one branch": function (test) {
-            verifier.verify(test, [ -1 ], false, { lines: { 1: 1, 2: 1 }, branches: { 1: [ 1, 0 ]}, functions: {}, statements: { '1': 1, '2': 1 } });
-            test.done();
-        },
-        "should cover line, both branches but return false": function (test) {
-            verifier.verify(test, [ 10 ], false, { lines: { 1: 1, 2: 1 }, branches: { 1: [ 1, 1 ]}, functions: {}, statements:  { '1': 1, '2': 1 } });
-            test.done();
-        },
-        "should cover line, both branches and return true": function (test) {
-            verifier.verify(test, [ 3 ], true, { lines: { 1: 1, 2: 1 }, branches: { 1: [ 1, 1 ]}, functions: {}, statements:  { '1': 1, '2': 1 } });
-            test.done();
-        }
-    },
-    "with a complex expression": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0] > 0 && (args[0] < 5 || args[0] > 10);',
-                'output = x;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover line and one branch": function (test) {
-            verifier.verify(test, [ -1 ], false, { lines: { 1: 1, 2: 1 }, branches: { 1: [ 1, 0, 0 ]}, functions: {}, statements: { '1': 1, '2': 1 } });
-            test.done();
-        },
-        "should cover line, both branches but return false": function (test) {
-            verifier.verify(test, [ 9 ], false, { lines: { 1: 1, 2: 1 }, branches: { 1: [ 1, 1, 1 ]}, functions: {}, statements: { '1': 1, '2': 1 } });
-            test.done();
-        },
-        "should cover line, both branches and return true": function (test) {
-            verifier.verify(test, [ 3 ], true, { lines: { 1: 1, 2: 1 }, branches: { 1: [ 1, 1, 0 ]}, functions: {}, statements: { '1': 1, '2': 1 } });
-            test.done();
-        }
-    },
-    "with an array expression with empty positions": {
-        setUp: function (cb) {
-            code = [
-                'var x = [, , args[0], ];',
-                'output = x.indexOf(args[0]) === x.length - 1;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should not barf in any way": function (test) {
-            verifier.verify(test, [ 5 ], true, { lines: { 1: 1, 2: 1 }, branches: {}, functions: {}, statements: { '1': 1, '2': 1 } });
-            test.done();
-        }
-    }
-};
-

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

@@ -1,206 +0,0 @@
-/*jslint nomen: true */
-var helper = require('../helper'),
-    code,
-    verifier;
-
-module.exports = {
-    "with a simple for": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0], i, j = -10;',
-                'for (i =0; i < x; i++) j = i;',
-                'output = j;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover loop exactly once": function (test) {
-            verifier.verify(test, [ 10 ], 9, {
-                lines: { 1: 1, 2: 10, 3: 1 },
-                branches: { },
-                functions: {},
-                statements: { '1': 1, '2': 1, '3': 10, '4': 1 }
-            });
-            test.done();
-        }
-    },
-    "with a simple for - declaring the loop variable in initializer": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0], j = -10;',
-                'for (var i =0; i < x; i++) j = i;',
-                'output = j;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover loop exactly once": function (test) {
-            verifier.verify(test, [ 10 ], 9, {
-                lines: { 1: 1, 2: 10, 3: 1 },
-                branches: { },
-                functions: {},
-                statements: { '1': 1, '2': 1, '3': 10, '4': 1 }
-            });
-            test.done();
-        }
-    },
-    "with a simple for - not having an initializer": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0], j = -10, i=0;',
-                'for (; i < x; i++) j = i;',
-                'output = j;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover loop exactly once": function (test) {
-            verifier.verify(test, [ 10 ], 9, {
-                lines: { 1: 1, 2: 10, 3: 1 },
-                branches: { },
-                functions: {},
-                statements: { '1': 1, '2': 1, '3': 10, '4': 1 }
-            });
-            test.done();
-        }
-    },
-    "with a simple for - statement on a different line": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0], i, j = -10;',
-                'for (i =0; i < x; i++)',
-                '   j = i;',
-                'output = j;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover loop one time": function (test) {
-            verifier.verify(test, [ 10 ], 9, {
-                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 ], -10, {
-                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 for in block": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0], i, j = -10;',
-                'for (i =0; i < x; i++) { j = i; }',
-                'output = j;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover multi-loop exactly once": function (test) {
-            verifier.verify(test, [ 10 ], 9, {
-                lines: { 1: 1, 2: 10, 3: 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 ], -10, {
-                lines: { 1: 1, 2: 1, 3: 1 },
-                branches: {},
-                functions: {},
-                statements: { '1': 1, '2': 1, '3': 0, '4': 1 }
-            });
-            test.done();
-        }
-    },
-    "with a labeled for": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0], i, j = -10;',
-                'outer:for (i =0; i < x; i++) { j = i; }',
-                'output = j;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover multi-loop exactly once": function (test) {
-            verifier.verify(test, [ 10 ], 9, {
-                lines: { 1: 1, 2: 10, 3: 1 },
-                branches: {},
-                functions: {},
-                statements: { '1': 1, '2': 1, '3': 1, '4': 10, '5': 1 }
-            });
-            test.done();
-        }
-    },
-    "with a nested labeled for": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0], i, j, k = 0;',
-                'outer:for (i = 0; i < x; i++)',
-                '   for (j=0; j < i ; j++) {',
-                '       if (j === 2) continue outer;',
-                '       k++;',
-                '   }',
-                'output = k;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover multi-loop exactly once": function (test) {
-            verifier.verify(test, [ 10 ], 17, {
-                lines: { '1': 1, '2': 1, '3': 10, '4': 24, '5': 17, '7': 1 },
-                branches: { '1': [ 7, 17 ] },
-                functions: {},
-                statements: { '1': 1, '2': 1, '3': 1, '4': 10, '5': 24, '6': 7, '7': 17, '8': 1 }
-            });
-            test.done();
-        }
-    },
-    "with a nested labeled for (label on different line)": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0], i, j, k = 0;',
-                'outer:',
-                'for (i = 0; i < x; i++)',
-                '   for (j=0; j < i ; j++) {',
-                '       if (j === 2) continue outer;',
-                '       k++;',
-                '   }',
-                'output = k;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover multi-loop exactly once": function (test) {
-            verifier.verify(test, [ 10 ], 17, {
-                lines: { '1': 1, '2': 1, '3': 1, '4': 10, '5': 24, '6': 17, '8': 1 },
-                branches: { '1': [ 7, 17 ] },
-                functions: {},
-                statements: { '1': 1, '2': 1, '3': 1, '4': 10, '5': 24, '6': 7, '7': 17, '8': 1 }
-            });
-            test.done();
-        }
-    }
-};
-

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

@@ -1,50 +0,0 @@
-/*jslint nomen: true */
-var helper = require('../helper'),
-    code,
-    verifier;
-
-/*jshint maxlen: 500 */
-module.exports = {
-    "with a simple for-in": {
-        setUp: function (cb) {
-            code = [
-                'var x = { a: args[0], b: args[1] }, k;',
-                'output = 0;',
-                'for (k in x) {',
-                '   if (x.hasOwnProperty(k) && x[k]) {',
-                '       output += x[k];',
-                '   }',
-                '}'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover loop exactly once": function (test) {
-            verifier.verify(test, [ 10, 0 ], 10, { lines: { 1: 1, 2: 1, 3: 1, 4: 2, 5: 1 }, branches: { 1: [1, 1], 2: [ 2, 2 ] }, functions: {}, statements: { 1: 1, 2: 1, 3: 1, 4: 2, 5: 1 } });
-            test.done();
-        }
-    },
-
-    "with a simple for-in declaring the loop initializer": {
-        setUp: function (cb) {
-            code = [
-                'var x = { a: args[0], b: args[1] };',
-                'output = 0;',
-                'for (var k in x) {',
-                '   if (x.hasOwnProperty(k) && x[k]) {',
-                '       output += x[k];',
-                '   }',
-                '}'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover loop exactly once": function (test) {
-            verifier.verify(test, [ 10, 0 ], 10, { lines: { 1: 1, 2: 1, 3: 1, 4: 2, 5: 1 }, branches: { 1: [1, 1], 2: [ 2, 2 ] }, functions: {}, statements: { 1: 1, 2: 1, 3: 1, 4: 2, 5: 1 } });
-            test.done();
-        }
-    }
-};
-

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

@@ -1,102 +0,0 @@
-/*jslint nomen: true */
-var helper = require('../helper'),
-    code,
-    verifier;
-
-/*jshint maxlen: 500 */
-module.exports = {
-    "with a simple function": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0];',
-                'function foo() {',
-                '   return 42;',
-                '}',
-                'output = x < 5 ? foo() : 15;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover line and function": function (test) {
-            verifier.verify(test, [ 2 ], 42, { lines: { 1: 1, 2: 1, 3: 1, 5: 1 }, branches: { 1: [1, 0 ] }, functions: { 1: 1 }, statements: { '1': 1, '2': 1, '3': 1, '4': 1 } });
-            test.done();
-        },
-
-        "should not cover function": function (test) {
-            verifier.verify(test, [ 10 ], 15, { lines: { 1: 1, 2: 1, 3: 0, 5: 1 }, branches: { 1: [ 0, 1 ]}, functions: { 1: 0 }, statements: { '1': 1, '2': 1, '3': 0, '4': 1 } });
-            test.done();
-        }
-    },
-
-    "with an anonymous function": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0];',
-                'output = x < 5 ? (function() { return 42; }()) : 15;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover line and function": function (test) {
-            verifier.verify(test, [ 2 ], 42, { lines: { 1: 1, 2: 1 }, branches: { 1: [1, 0 ] }, functions: { 1: 1 }, statements: { '1': 1, '2': 1, '3': 1 } });
-            test.done();
-        },
-
-        "should not cover function": function (test) {
-            verifier.verify(test, [ 10 ], 15, { lines: { 1: 1, 2: 1 }, branches: { 1: [ 0, 1 ]}, functions: { 1: 0 }, statements: { '1': 1, '2': 1, '3': 0 } });
-            test.done();
-        }
-    },
-
-    "with an anonymous function on newline": {
-        setUp: function (cb) {
-            code = [
-                'var x = args[0];',
-                'output = x < 5 ? ',
-                '   (function() { ',
-                '   return 42; ',
-                '}())',
-                ' : 15;'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should cover line and function": function (test) {
-            verifier.verify(test, [ 2 ], 42, { lines: { 1: 1, 2: 1, 4: 1 }, branches: { 1: [1, 0 ] }, functions: { 1: 1 }, statements: { 1: 1, 2: 1, 3: 1} });
-            test.done();
-        },
-
-        "should not cover function": function (test) {
-            verifier.verify(test, [ 10 ], 15, { lines: { 1: 1, 2: 1, 4: 0 }, branches: { 1: [ 0, 1 ]}, functions: { 1: 0 }, statements: { 1: 1, 2: 1, 3: 0 } });
-            test.done();
-        }
-    },
-
-    "with a function declared in an 'unreachable' place": {
-        setUp: function (cb) {
-            code = [
-                'function foo(x) {',
-                '   return bar(x);',
-                '   function bar(y) { return y * 2 }',
-                '}',
-                'output = args[0] < 2 ? 2: foo(args[0]);'
-            ];
-            verifier = helper.verifier(__filename, code);
-            cb();
-        },
-
-        "should not cover functions but should cover declarations": function (test) {
-            verifier.verify(test, [ 1 ], 2, { lines: { 1: 1, 2: 0, 3: 1, 5: 1 }, branches: { 1: [1, 0 ] }, functions: { 1: 0, 2: 0 }, statements: { 1: 1, 2: 0, 3: 1, 4: 0, 5: 1} });
-            test.done();
-        },
-
-        "should cover functions and declarations": function (test) {
-            verifier.verify(test, [ 10 ], 20, { lines: { 1: 1, 2: 1, 3: 1, 5: 1 }, branches: { 1: [ 0, 1 ]}, functions: { 1: 1, 2: 1 }, statements: { 1: 1, 2: 1, 3: 1, 4: 1, 5: 1 } });
-            test.done();
-        }
-    }
-};
-

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

@@ -1,393 +0,0 @@
-/*jslint nomen: true */
-var helper = require('../helper'),
-    code,
-    verifier;
-
-/*jshint maxlen: 500 */
-module.exports = {
-    "with a simple if": {
-        "as a statement": {
-            setUp: function (cb) {
-                code = [
-                    'output = -1;',
-                    'if (args[0] > args [1])',
-                    '   output = args[0];'
-                ];
-                verifier = helper.verifier(__filename, code);
-                cb(null);
-            },
-            "should cover then path": function (test) {
-                verifier.verify(test, [ 20, 10 ], 20, { lines: { 1: 1, 2: 1, 3: 1 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1 } });
-                test.done();
-            },
-            "should cover else path": function (test) {
-                verifier.verify(test, [ 10, 20 ], -1, { lines: { 1: 1, 2: 1, 3: 0 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0 } });
-                test.done();
-            }
-        },
-        "as a block": {
-            setUp: function (cb) {
-                code = [
-                    'output = -1;',
-                    'if (args[0] > args [1]) {',
-                    '   output = args[0];',
-                    '}'
-                ];
-                verifier = helper.verifier(__filename, code);
-                cb();
-            },
-            "should cover then path": function (test) {
-                verifier.verify(test, [ 20, 10 ], 20, { lines: { 1: 1, 2: 1, 3: 1 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1 } });
-                test.done();
-            },
-            "should cover else path": function (test) {
-                verifier.verify(test, [ 10, 20 ], -1, { lines: { 1: 1, 2: 1, 3: 0 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0 } });
-                test.done();
-            }
-        },
-        "on a single line": {
-            "as statement": {
-                setUp: function (cb) {
-                    code = [
-                        'output = -1;',
-                        'if (args[0] > args [1]) output = args[0];'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover then path": function (test) {
-                    verifier.verify(test, [ 20, 10 ], 20, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1 } });
-                    test.done();
-                },
-                "should cover else path": function (test) {
-                    verifier.verify(test, [ 10, 20 ], -1, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0 } });
-                    test.done();
-                }
-            },
-            "as block": {
-                setUp: function (cb) {
-                    code = [
-                        'output = -1;',
-                        'if (args[0] > args [1]) { output = args[0]; }'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover then path": function (test) {
-                    verifier.verify(test, [ 20, 10 ], 20, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1 } });
-                    test.done();
-                },
-                "should cover else path": function (test) {
-                    verifier.verify(test, [ 10, 20 ], -1, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0 } });
-                    test.done();
-                }
-            }
-        }
-    },
-    "with a simple if-else": {
-        "as a statement": {
-            setUp: function (cb) {
-                code = [
-                    'if (args[0] > args [1])',
-                    '   output = args[0];',
-                    'else',
-                    '   output = args[1];'
-                ];
-                verifier = helper.verifier(__filename, code);
-                cb(null);
-            },
-            "should cover then path": function (test) {
-                verifier.verify(test, [ 20, 10 ], 20, { lines: { 1: 1, 2: 1, 4: 0 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0 } });
-                test.done();
-            },
-            "should cover else path": function (test) {
-                verifier.verify(test, [ 10, 20 ], 20, { lines: { 1: 1, 2: 0, 4: 1 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1 } });
-                test.done();
-            }
-        },
-        "as a block": {
-            setUp: function (cb) {
-                code = [
-                    'if (args[0] > args [1]) {',
-                    '   output = args[0];',
-                    '} else {',
-                    '   output = args[1];',
-                    '}'
-                ];
-                verifier = helper.verifier(__filename, code);
-                cb();
-            },
-            "should cover then path": function (test) {
-                verifier.verify(test, [ 20, 10 ], 20, { lines: { 1: 1, 2: 1, 4: 0 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0 } });
-                test.done();
-            },
-            "should cover else path": function (test) {
-                verifier.verify(test, [ 10, 20 ], 20, { lines: { 1: 1, 2: 0, 4: 1 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1 } });
-                test.done();
-            }
-        },
-        "on a single line": {
-            "as statement": {
-                setUp: function (cb) {
-                    code = [
-                        'if (args[0] > args [1]) output = args[0]; else output = args[1];'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover then path": function (test) {
-                    verifier.verify(test, [ 20, 10 ], 20, { lines: { 1: 1 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0 } });
-                    test.done();
-                },
-                "should cover else path": function (test) {
-                    verifier.verify(test, [ 10, 20 ], 20, { lines: { 1: 1 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1 } });
-                    test.done();
-                }
-            },
-            "as block": {
-                setUp: function (cb) {
-                    code = [
-                        'if (args[0] > args [1]) { output = args[0]; } else { output = args[1]; }'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover then path": function (test) {
-                    verifier.verify(test, [ 20, 10 ], 20, { lines: { 1: 1 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0 } });
-                    test.done();
-                },
-                "should cover else path": function (test) {
-                    verifier.verify(test, [ 10, 20 ], 20, { lines: { 1: 1 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1 } });
-                    test.done();
-                }
-            },
-            "as mixed with then-block": {
-                setUp: function (cb) {
-                    code = [
-                        'if (args[0] > args [1]) { output = args[0]; } else output = args[1];'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover then path": function (test) {
-                    verifier.verify(test, [ 20, 10 ], 20, { lines: { 1: 1 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0 } });
-                    test.done();
-                },
-                "should cover else path": function (test) {
-                    verifier.verify(test, [ 10, 20 ], 20, { lines: { 1: 1 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1 } });
-                    test.done();
-                }
-            },
-            "as mixed with else-block": {
-                setUp: function (cb) {
-                    code = [
-                        'if (args[0] > args [1]) output = args[0]; else { output = args[1]; }'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover then path": function (test) {
-                    verifier.verify(test, [ 20, 10 ], 20, { lines: { 1: 1 }, branches: { '1': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0 } });
-                    test.done();
-                },
-                "should cover else path": function (test) {
-                    verifier.verify(test, [ 10, 20 ], 20, { lines: { 1: 1 }, branches: { '1': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1 } });
-                    test.done();
-                }
-            }
-        }
-    },
-    "with nested ifs": {
-        "without an else": {
-            "and no blocks": {
-                setUp: function (cb) {
-                    code = [
-                        'output = -1;',
-                        'if (args[0] > args[1]) if (args[1] > args[2]) output = args[2];'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover first else and nothing below": function (test) {
-                    verifier.verify(test, [ 10, 20, 15 ], -1, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0 } });
-                    test.done();
-                },
-                "should cover first then": function (test) {
-                    verifier.verify(test, [ 20, 10, 15 ], -1, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 1, 0 ], '2' : [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 0 } });
-                    test.done();
-                },
-                "should cover first then and second then": function (test) {
-                    verifier.verify(test, [ 20, 10, 5 ], 5, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 1, 0 ], '2' : [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 1 } });
-                    test.done();
-                }
-            },
-            "and blocks": {
-                setUp: function (cb) {
-                    code = [
-                        'output = -1;',
-                        'if (args[0] > args[1]) { if (args[1] > args[2]) { output = args[2]; } }'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover first else and nothing below": function (test) {
-                    verifier.verify(test, [ 10, 20, 15 ], -1, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0 } });
-                    test.done();
-                },
-                "should cover first then": function (test) {
-                    verifier.verify(test, [ 20, 10, 15 ], -1, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 1, 0 ], '2' : [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 0 } });
-                    test.done();
-                },
-                "should cover first then and second then": function (test) {
-                    verifier.verify(test, [ 20, 10, 5 ], 5, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 1, 0 ], '2' : [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 1 } });
-                    test.done();
-                }
-            }
-        },
-        "with elses": {
-            "and no blocks": {
-                setUp: function (cb) {
-                    code = [
-                        'output = -1;',
-                        'if (args[0] > args[1]) if (args[1] > args[2]) output = args[2]; else output = args[1];'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover first else and nothing below": function (test) {
-                    verifier.verify(test, [ 10, 20, 15 ], -1, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0, '5': 0 } });
-                    test.done();
-                },
-                "should cover first then": function (test) {
-                    verifier.verify(test, [ 20, 10, 15 ], 10, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 1, 0 ], '2' : [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 0, '5': 1 } });
-                    test.done();
-                },
-                "should cover first then and second then": function (test) {
-                    verifier.verify(test, [ 20, 10, 5 ], 5, { lines: { 1: 1, 2: 1 }, branches: { '1': [ 1, 0 ], '2' : [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 1, '5': 0 } });
-                    test.done();
-                }
-            },
-            "including else ifs with blocks": {
-                setUp: function (cb) {
-                    code = [
-                        'if (args[0] < args[1]) {',
-                        '    output = args[0];',
-                        '} else if (args[1] < args[2]) {',
-                        '    output = args[1];',
-                        '} else if (args[2] < args[3]) {',
-                        '    output = args[2];',
-                        '} else {',
-                        '    output = args[3];',
-                        '}'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover all else paths": function (test) {
-                    verifier.verify(test, [ 4, 3, 2, 1 ], 1, { lines: { 1: 1, 2: 0, 3: 1, 4: 0, 5: 1, 6: 0, 8: 1 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 1 ], '3': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1, '4': 0, '5': 1, '6': 0, '7': 1 } });
-                    test.done();
-                },
-                "should cover one then path": function (test) {
-                    verifier.verify(test, [ 4, 3, 1, 2 ], 1, { lines: { 1: 1, 2: 0, 3: 1, 4: 0, 5: 1, 6: 1, 8: 0 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 1 ], '3': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1, '4': 0, '5': 1, '6': 1, '7': 0 } });
-                    test.done();
-                },
-                "should cover upper then paths": function (test) {
-                    verifier.verify(test, [ 4, 2, 3, 1 ], 2, { lines: { 1: 1, 2: 0, 3: 1, 4: 1, 5: 0, 6: 0, 8: 0 }, branches: { '1': [ 0, 1 ], '2' : [ 1, 0 ], '3': [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1, '4': 1, '5': 0, '6': 0, '7': 0 } });
-                    test.done();
-                },
-                "should cover uppermost then paths": function (test) {
-                    verifier.verify(test, [ 1, 2, 3, 1 ], 1, { lines: { 1: 1, 2: 1, 3: 0, 4: 0, 5: 0, 6: 0, 8: 0 }, branches: { '1': [ 1, 0 ], '2' : [ 0, 0 ], '3': [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0 } });
-                    test.done();
-                }
-            },
-            "including else ifs without blocks": {
-                setUp: function (cb) {
-                    code = [
-                        'if (args[0] < args[1])',
-                        '    output = args[0];',
-                        'else if (args[1] < args[2])',
-                        '    output = args[1];',
-                        'else if (args[2] < args[3])',
-                        '    output = args[2];',
-                        'else',
-                        '    output = args[3];'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover all else paths": function (test) {
-                    verifier.verify(test, [ 4, 3, 2, 1 ], 1, { lines: { 1: 1, 2: 0, 3: 1, 4: 0, 5: 1, 6: 0, 8: 1 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 1 ], '3': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1, '4': 0, '5': 1, '6': 0, '7': 1 } });
-                    test.done();
-                },
-                "should cover one then path": function (test) {
-                    verifier.verify(test, [ 4, 3, 1, 2 ], 1, { lines: { 1: 1, 2: 0, 3: 1, 4: 0, 5: 1, 6: 1, 8: 0 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 1 ], '3': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1, '4': 0, '5': 1, '6': 1, '7': 0 } });
-                    test.done();
-                },
-                "should cover upper then paths": function (test) {
-                    verifier.verify(test, [ 4, 2, 3, 1 ], 2, { lines: { 1: 1, 2: 0, 3: 1, 4: 1, 5: 0, 6: 0, 8: 0 }, branches: { '1': [ 0, 1 ], '2' : [ 1, 0 ], '3': [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1, '4': 1, '5': 0, '6': 0, '7': 0 } });
-                    test.done();
-                },
-                "should cover uppermost then paths": function (test) {
-                    verifier.verify(test, [ 1, 2, 3, 1 ], 1, { lines: { 1: 1, 2: 1, 3: 0, 4: 0, 5: 0, 6: 0, 8: 0 }, branches: { '1': [ 1, 0 ], '2' : [ 0, 0 ], '3': [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0 } });
-                    test.done();
-                }
-            },
-            "including else ifs without blocks (compact)": {
-                setUp: function (cb) {
-                    code = [
-                        'if (args[0] < args[1]) output = args[0]; else if (args[1] < args[2]) output = args[1]; else if (args[2] < args[3]) output = args[2]; else output = args[3];'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover all else paths": function (test) {
-                    verifier.verify(test, [ 4, 3, 2, 1 ], 1, { lines: { 1: 1 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 1 ], '3': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1, '4': 0, '5': 1, '6': 0, '7': 1 } });
-                    test.done();
-                },
-                "should cover one then path": function (test) {
-                    verifier.verify(test, [ 4, 3, 1, 2 ], 1, { lines: { 1: 1 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 1 ], '3': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1, '4': 0, '5': 1, '6': 1, '7': 0 } });
-                    test.done();
-                },
-                "should cover upper then paths": function (test) {
-                    verifier.verify(test, [ 4, 2, 3, 1 ], 2, { lines: { 1: 1 }, branches: { '1': [ 0, 1 ], '2' : [ 1, 0 ], '3': [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 0, '3': 1, '4': 1, '5': 0, '6': 0, '7': 0 } });
-                    test.done();
-                },
-                "should cover uppermost then paths": function (test) {
-                    verifier.verify(test, [ 1, 2, 3, 1 ], 1, { lines: { 1: 1 }, branches: { '1': [ 1, 0 ], '2' : [ 0, 0 ], '3': [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0 } });
-                    test.done();
-                }
-            },
-            "including else ifs without blocks (modified)": {
-                setUp: function (cb) {
-                    code = [
-                        'output = args[3]; if (args[0] < args[1])',
-                        '    output = args[0];',
-                        'else if (args[1] < args[2])',
-                        '    output = args[1];',
-                        'else if (args[2] < args[3])',
-                        '    output = args[2];'
-                    ];
-                    verifier = helper.verifier(__filename, code);
-                    cb();
-                },
-                "should cover all else paths": function (test) {
-                    verifier.verify(test, [ 4, 3, 2, 1 ], 1, { lines: { 1: 1, 2: 0, 3: 1, 4: 0, 5: 1, 6: 0 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 1 ], '3': [ 0, 1 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 1, '5': 0, '6': 1, '7': 0 } });
-                    test.done();
-                },
-                "should cover one then path": function (test) {
-                    verifier.verify(test, [ 4, 3, 1, 2 ], 1, { lines: { 1: 1, 2: 0, 3: 1, 4: 0, 5: 1, 6: 1 }, branches: { '1': [ 0, 1 ], '2' : [ 0, 1 ], '3': [ 1, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 1, '5': 0, '6': 1, '7': 1 } });
-                    test.done();
-                },
-                "should cover upper then paths": function (test) {
-                    verifier.verify(test, [ 4, 2, 3, 1 ], 2, { lines: { 1: 1, 2: 0, 3: 1, 4: 1, 5: 0, 6: 0 }, branches: { '1': [ 0, 1 ], '2' : [ 1, 0 ], '3': [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 0, '4': 1, '5': 1, '6': 0, '7': 0 } });
-                    test.done();
-                },
-                "should cover uppermost then paths": function (test) {
-                    verifier.verify(test, [ 1, 2, 3, 1 ], 1, { lines: { 1: 1, 2: 1, 3: 0, 4: 0, 5: 0, 6: 0 }, branches: { '1': [ 1, 0 ], '2' : [ 0, 0 ], '3': [ 0, 0 ] }, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 0, '5': 0, '6': 0, '7': 0 } });
-                    test.done();
-                }
-            }
-        }
-    }
-};
-