cssesc-source 0.1.0 → 1.0.1

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

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

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

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

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

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

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

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

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