cssesc-source 0.1.0

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

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

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

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

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

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