cssesc-source 0.1.0

data/vendor/node_modules/istanbul/test/cli/test-lots-of-files.js

@@ -0,0 +1,87 @@
+/*jslint nomen: true */
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    rimraf = require('rimraf'),
+    mkdirp = require('mkdirp'),
+    COMMAND = 'report',
+    COVER_COMMAND = 'cover',
+    outputDir = path.resolve(__dirname, 'output'),
+    helper = require('../cli-helper'),
+    existsSync = fs.existsSync || path.existsSync,
+    run = helper.runCommand.bind(null, COMMAND),
+    runCover = helper.runCommand.bind(null, COVER_COMMAND),
+    MAX_FILES = 1000;
+
+function fileFor(i) {
+    return 'f' + i + '.js';
+}
+
+function createCode() {
+    var i,
+        libDir = path.resolve(outputDir, 'lib'),
+        code;
+
+    mkdirp.sync(libDir);
+
+    for (i = 0; i < MAX_FILES; i += 1) {
+        code = 'module.exports = function () { return "hello-' + i + '"; };\n';
+        fs.writeFileSync(path.resolve(libDir, fileFor(i)), code, 'utf8');
+    }
+}
+
+function createTest() {
+    var i,
+        testDir = path.resolve(outputDir, 'test'),
+        code = 'var assert = require("assert");\n';
+
+    mkdirp.sync(testDir);
+
+    for (i = 0; i < MAX_FILES; i += 1) {
+        code += 'assert.equal("hello-' + i + '", require("../lib/' + fileFor(i) + '")());\n';
+    }
+    fs.writeFileSync(path.resolve(testDir, 'test.js'), code, 'utf8');
+}
+
+module.exports = {
+    setUp: function (cb) {
+        helper.resetOpts();
+        helper.setOpts({ cwd: outputDir });
+        mkdirp.sync(outputDir);
+        cb();
+    },
+    tearDown: function (cb) {
+        rimraf.sync(outputDir);
+        cb();
+    },
+
+    'should report correctly with 1000 code files': function (test) {
+        var coverageDir = path.resolve(outputDir, 'coverage'),
+            lcovFile = path.resolve(coverageDir, 'lcov.info'),
+            lcovDir = path.resolve(coverageDir, 'lcov-report'),
+            jsonFile = path.resolve(coverageDir, 'coverage.json');
+        createCode();
+        createTest();
+        runCover([ 'test/test.js' ], function (results) {
+            test.ok(results.succeeded());
+            test.ok(existsSync(lcovFile));
+            test.ok(existsSync(lcovDir));
+            test.ok(existsSync(jsonFile));
+            var obj = JSON.parse(fs.readFileSync(jsonFile, 'utf8'));
+            test.equal(MAX_FILES, Object.keys(obj).length);
+            rimraf.sync(lcovDir);
+            fs.unlinkSync(lcovFile);
+            run([], function (results) {
+                test.ok(results.succeeded());
+                test.ok(existsSync(lcovFile));
+                test.ok(existsSync(lcovDir));
+                test.ok(existsSync(jsonFile));
+                test.ok(fs.readdirSync(path.resolve(lcovDir, 'lib')).length >= MAX_FILES);
+                test.done();
+            });
+        });
+    }
+};
+
+
+

data/vendor/node_modules/istanbul/test/cli/test-none-report.js

@@ -0,0 +1,17 @@
+/*jslint nomen: true */
+var Reporter = require('../../lib/report/none'),
+    Report = require('../../lib/report');
+
+module.exports = {
+    "should be a noop without any failures": function (test) {
+        var reporter = new Reporter();
+        test.doesNotThrow(function () { reporter.writeReport(); });
+        test.done();
+    },
+    "should throw when Base report class writeMethod called": function (test) {
+        var r = new Report();
+        test.throws(function () { r.writeReport(); }, /must be overridden/);
+        test.done();
+    }
+};
+

data/vendor/node_modules/istanbul/test/cli/test-report-command.js

@@ -0,0 +1,65 @@
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    rimraf = require('rimraf'),
+    mkdirp = require('mkdirp'),
+    COMMAND = 'report',
+    COVER_COMMAND = 'cover',
+    DIR = path.resolve(__dirname, 'sample-project'),
+    OUTPUT_DIR = path.resolve(DIR, 'coverage'),
+    helper = require('../cli-helper'),
+    existsSync = fs.existsSync || path.existsSync,
+    run = helper.runCommand.bind(null, COMMAND),
+    runCover = helper.runCommand.bind(null, COVER_COMMAND);
+
+module.exports = {
+    setUp: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        mkdirp.sync(OUTPUT_DIR);
+        helper.resetOpts();
+        runCover([ 'test/run.js', '--report', 'none' ], function (/* results */) {
+            cb();
+        });
+    },
+    tearDown: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        cb();
+    },
+    "should run reports consuming coverage file with lcov default": function (test) {
+        test.ok(existsSync(path.resolve(OUTPUT_DIR, 'coverage.json')));
+        run([], function (results) {
+            test.ok(results.succeeded());
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'lcov.info')));
+            test.ok(fs.readFileSync(path.resolve(OUTPUT_DIR, 'lcov.info'), 'utf8') !== '');
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'lcov-report')));
+            test.done();
+        });
+    },
+    "should run reports with specific format": function (test) {
+        test.ok(existsSync(path.resolve(OUTPUT_DIR, 'coverage.json')));
+        run(['--report', 'html'], function (results) {
+            test.ok(results.succeeded());
+            test.ok(!existsSync(path.resolve(OUTPUT_DIR, 'lcov.info')));
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'index.html')));
+            test.done();
+        });
+    },
+    "should barf on invalid format": function (test) {
+        test.ok(existsSync(path.resolve(OUTPUT_DIR, 'coverage.json')));
+        run([ '--report', 'gcov' ], function (results) {
+            test.ok(!results.succeeded());
+            test.ok(!existsSync(path.resolve(OUTPUT_DIR, 'lcov.info')));
+            test.ok(results.grepError(/Invalid report format/));
+            test.done();
+        });
+    },
+    "should respect input pattern": function (test) {
+        test.ok(existsSync(path.resolve(OUTPUT_DIR, 'coverage.json')));
+        run([ '--report', 'lcovonly', '**/foobar.json' ], function (results) {
+            test.ok(results.succeeded());
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'lcov.info')));
+            test.equal('', fs.readFileSync(path.resolve(OUTPUT_DIR, 'lcov.info'), 'utf8'));
+            test.done();
+        });
+    }
+};

data/vendor/node_modules/istanbul/test/cli/test-teamcity-report.js

@@ -0,0 +1,54 @@
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    rimraf = require('rimraf'),
+    mkdirp = require('mkdirp'),
+    helper = require('../cli-helper'),
+    DIR = path.resolve(__dirname, 'sample-project'),
+    OUTPUT_DIR = path.resolve(DIR, 'coverage'),
+    COVER_COMMAND = 'cover',
+    runCover = helper.runCommand.bind(null, COVER_COMMAND),
+    Reporter = require('../../lib/report/teamcity'),
+    Collector = require('../../lib/collector'),
+    existsSync = fs.existsSync || path.existsSync;
+
+module.exports = {
+    setUp: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        mkdirp.sync(OUTPUT_DIR);
+        helper.resetOpts();
+        runCover([ 'test/run.js', '--report', 'none' ], function (/* results */) {
+            cb();
+        });
+    },
+    tearDown: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        cb();
+    },
+    "should produce teamcity service messages": function (test) {
+        var file = path.resolve(OUTPUT_DIR, 'coverage.json'),
+            outFile = path.resolve(OUTPUT_DIR, 'teamcity.txt'),
+            reporter = new Reporter({ dir: OUTPUT_DIR, file: "teamcity.txt" }),
+            obj,
+            reportLines,
+            collector = new Collector();
+
+        obj = JSON.parse(fs.readFileSync(file, 'utf8'));
+        collector.add(obj);
+        reporter.writeReport(collector, true);
+        test.ok(existsSync(outFile));
+        reportLines = fs.readFileSync(outFile, 'utf8');
+
+        test.ok(reportLines.indexOf('Code Coverage Summary') > 0);
+        test.ok(reportLines.indexOf('CodeCoverageB') > 0);
+        test.ok(reportLines.indexOf('CodeCoverageAbsMCovered') > 0);
+        test.ok(reportLines.indexOf('CodeCoverageAbsMTotal') > 0);
+        test.ok(reportLines.indexOf('CodeCoverageM') > 0);
+        test.ok(reportLines.indexOf('CodeCoverageAbsLCovered') > 0);
+        test.ok(reportLines.indexOf('CodeCoverageAbsLTotal') > 0);
+        test.ok(reportLines.indexOf('CodeCoverageL') > 0);
+
+        test.done();
+    }
+};
+

data/vendor/node_modules/istanbul/test/cli/test-test-command.js

@@ -0,0 +1,43 @@
+/*jslint nomen: true */
+var path = require('path'),
+    fs = require('fs'),
+    rimraf = require('rimraf'),
+    mkdirp = require('mkdirp'),
+    COMMAND = 'test',
+    DIR = path.resolve(__dirname, 'sample-project'),
+    OUTPUT_DIR = path.resolve(DIR, 'coverage'),
+    helper = require('../cli-helper'),
+    existsSync = fs.existsSync || path.existsSync,
+    run = helper.runCommand.bind(null, COMMAND);
+
+module.exports = {
+    setUp: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        mkdirp.sync(OUTPUT_DIR);
+        helper.resetOpts();
+        cb();
+    },
+    tearDown: function (cb) {
+        rimraf.sync(OUTPUT_DIR);
+        cb();
+    },
+    "should skip coverage when npm coverage is disabled": function (test) {
+        run([ 'test/run.js' ], { npm_config_coverage: '' }, function (results) {
+            test.ok(results.succeeded());
+            test.ok(!existsSync(path.resolve(OUTPUT_DIR, 'lcov.info')));
+            test.ok(!existsSync(path.resolve(OUTPUT_DIR, 'lcov-report')));
+            test.ok(!existsSync(path.resolve(OUTPUT_DIR, 'coverage.json')));
+            test.done();
+        });
+    },
+    "should run coverage when npm coverage is enabled": function (test) {
+        helper.setOpts({ lazyHook : true });
+        run([ 'test/run.js' ], { npm_config_coverage: '1' }, function (results) {
+            test.ok(results.succeeded());
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'lcov.info')));
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'lcov-report')));
+            test.ok(existsSync(path.resolve(OUTPUT_DIR, 'coverage.json')));
+            test.done();
+        });
+    }
+};

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

@@ -0,0 +1,19 @@
+/*jslint nomen:true*/
+var path = require('path'),
+    buildDir = path.resolve(__dirname, '..', 'build');
+
+module.exports = {
+    setSelfCover: function (flag) {
+        process.env.SELF_COVER = flag ? 1 : '';
+    },
+    isSelfCover: function () {
+        return process.env.SELF_COVER;
+    },
+    getBuildDir: function () {
+        return buildDir;
+    },
+    getCoverageDir: function () {
+        return path.resolve(buildDir, 'coverage');
+    }
+};
+

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

@@ -0,0 +1,122 @@
+/*jslint nomen: true */
+var Instrumenter = require('../lib/instrumenter'),
+    vm = require('vm'),
+    NO_OP = function () {},
+    utils = require('../lib/object-utils');
+
+
+function Verifier(opts) {
+    this.file = opts.file;
+    this.fn = opts.fn;
+    this.code = opts.code;
+    this.generatedCode = opts.generatedCode;
+    this.err = opts.err;
+    this.debug = opts.debug;
+    this.coverageVariable = opts.coverageVariable || '__coverage__';
+}
+
+function pad(str, len) {
+    var blanks = '                                             ';
+    if (str.length >= len) {
+        return str;
+    }
+    return blanks.substring(0, len - str.length) + str;
+}
+
+function annotatedCode(code) {
+    var line = 0,
+        annotated = code.map(function (str) { line += 1; return pad(line, 6) + ': ' + str; });
+    return annotated.join('\n');
+}
+
+Verifier.prototype = {
+
+    verify: function (test, args, expectedOutput, expectedCoverage) {
+
+        if (this.err) {
+            test.ok(false, "Cannot call verify when errors present");
+            return;
+        } else if (this.fn === NO_OP) {
+            test.ok(false, "Cannot call verify for noop");
+            return;
+        }
+        var actualOutput = this.fn(args),
+            fullCov = global[this.coverageVariable],
+            cov = fullCov[Object.keys(fullCov)[0]];
+
+        utils.addDerivedInfo(global[this.coverageVariable]);
+        test.ok(cov && typeof cov === 'object', 'No coverage found for [' + this.file + ']');
+        test.deepEqual(expectedOutput, actualOutput, 'Output mismatch');
+        test.deepEqual(expectedCoverage.lines, cov.l, 'Line coverage mismatch');
+        test.deepEqual(expectedCoverage.functions, cov.f, 'Function coverage mismatch');
+        test.deepEqual(expectedCoverage.branches, cov.b, 'Branch coverage mismatch');
+        test.deepEqual(expectedCoverage.statements, cov.s, 'Statement coverage mismatch');
+    },
+
+    getCoverage: function () {
+        return global[this.coverageVariable];
+    },
+
+    verifyError: function (test) {
+        test.ok(this.err && typeof this.err === 'object', 'Error should be an object');
+    },
+
+    verifyNoError: function (test) {
+        test.ok(!(this.err && typeof this.err === 'object'), 'Error should not be present');
+    }
+};
+
+function setup(file, codeArray, opts) {
+
+    opts = opts || {};
+    opts.file = file;
+    opts.debug = opts.debug || process.env.DEBUG;
+
+    var expectError = opts.expectError,
+        //exercise the case where RE substitutions for the preamble have $ signs
+        coverageVariable = typeof opts.coverageVariable === 'undefined' ? '$$coverage$$' : opts.coverageVariable,
+        ps = opts.embedSource || false,
+        verifier,
+        cover = new Instrumenter({
+            debug: opts.debug,
+            walkDebug: opts.walkDebug,
+            noAutoWrap: opts.noAutoWrap,
+            coverageVariable: coverageVariable,
+            embedSource: ps
+        }),
+        args = [ codeArray.join("\n")],
+        callback = function (err, generated) {
+            if (err) {
+                if (expectError) {
+                    verifier = new Verifier({ debug: opts.debug, file: file, fn: NO_OP, code: codeArray });
+                } else {
+                    console.error(err);
+                    console.error(err.stack);
+                    verifier = new Verifier({ debug: opts.debug, file: file, err: err, code: codeArray });
+                }
+                return;
+            }
+            var wrappedCode = '(function (args) { var output;\n' + generated + '\nreturn output;\n})',
+                fn;
+            global[coverageVariable] = undefined;
+            fn = vm.runInThisContext(wrappedCode, __filename);
+            verifier = new Verifier({ debug: opts.debug, file: file, fn: fn, code: codeArray,
+                generatedCode: generated, coverageVariable: coverageVariable });
+            if (opts.debug) {
+                console.log('================== Original ============================================');
+                console.log(annotatedCode(codeArray));
+                console.log('================== Generated ===========================================');
+                console.log(generated);
+                console.log('========================================================================');
+            }
+        };
+
+    if (file) { args.push(file); }
+    args.push(callback);
+    delete opts.expectError;
+    cover.instrument.apply(cover, args);
+
+    return verifier;
+}
+
+exports.verifier = setup;

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

@@ -0,0 +1,53 @@
+/*jslint nomen: true */
+var helper = require('../helper'),
+    code,
+    verifier;
+
+/*jshint maxlen: 500 */
+module.exports = {
+    "with a simple do-while": {
+        setUp: function (cb) {
+            code = [
+                'var x = args[0], i=0;',
+                'do { i++; } while (i < x);',
+                'output = i;'
+            ];
+            verifier = helper.verifier(__filename, code);
+            cb();
+        },
+
+        "should provide correct line coverage": function (test) {
+            verifier.verify(test, [ 10 ], 10, { lines: { 1: 1, 2: 10, 3: 1 }, branches: {}, functions: {}, statements: { '1': 1, '2': 1, '3': 10, '4': 1 } });
+            test.done();
+        },
+
+        "should cover single-entry into while": function (test) {
+            verifier.verify(test, [ -1 ], 1, { lines: { 1: 1, 2: 1, 3: 1 }, branches: {}, functions: {}, statements: { '1': 1, '2': 1, '3': 1, '4': 1 } });
+            test.done();
+        }
+    },
+    "with a block do-while on separate line": {
+        setUp: function (cb) {
+            code = [
+                'var x = args[0], i=0;',
+                'do { ',
+                '   i++; ',
+                '} while (i < x);',
+                'output = i;'
+            ];
+            verifier = helper.verifier(__filename, code);
+            cb();
+        },
+
+        "should provide correct line coverage": function (test) {
+            verifier.verify(test, [ 10 ], 10, { lines: { 1: 1, 2: 1, 3: 10, 5: 1 }, branches: {}, functions: {}, statements: { '1': 1, '2': 1, '3': 10, '4': 1 } });
+            test.done();
+        },
+
+        "should cover single-entry into while": function (test) {
+            verifier.verify(test, [ -1 ], 1, { lines: { 1: 1, 2: 1, 3: 1, 5: 1 }, branches: {}, functions: {}, statements:  { '1': 1, '2': 1, '3': 1, '4': 1 } });
+            test.done();
+        }
+    }
+};
+