porffor 0.1.0

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/expected-metadata/test/async/asyncNegative_default.json

@@ -0,0 +1,22 @@
+{
+  "file": "test/async/asyncNegative.js",
+  "contents": "(The value of this property is over-sized, so it is validated independently.)",
+  "attrs": {
+    "description": "Async negative test",
+    "negative": {
+      "phase": "runtime",
+      "type": "RangeError"
+    },
+    "flags": {
+      "async": true
+    },
+    "includes": [
+      "assert.js",
+      "sta.js",
+      "doneprintHandle.js"
+    ]
+  },
+  "copyright": "",
+  "scenario": "default",
+  "insertionIndex": 564
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/expected-metadata/test/async/asyncNegative_strict_mode.json

@@ -0,0 +1,22 @@
+{
+  "file": "test/async/asyncNegative.js",
+  "contents": "(The value of this property is over-sized, so it is validated independently.)",
+  "attrs": {
+    "description": "Async negative test (Strict Mode)",
+    "negative": {
+      "phase": "runtime",
+      "type": "RangeError"
+    },
+    "flags": {
+      "async": true
+    },
+    "includes": [
+      "assert.js",
+      "sta.js",
+      "doneprintHandle.js"
+    ]
+  },
+  "copyright": "",
+  "scenario": "strict mode",
+  "insertionIndex": 578
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/expected-metadata/test/async/async_default.json

@@ -0,0 +1,18 @@
+{
+  "file": "test/async/async.js",
+  "contents": "(The value of this property is over-sized, so it is validated independently.)",
+  "attrs": {
+    "description": "Async test",
+    "flags": {
+      "async": true
+    },
+    "includes": [
+      "assert.js",
+      "sta.js",
+      "doneprintHandle.js"
+    ]
+  },
+  "copyright": "",
+  "scenario": "default",
+  "insertionIndex": 564
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/expected-metadata/test/async/async_strict_mode.json

@@ -0,0 +1,18 @@
+{
+  "file": "test/async/async.js",
+  "contents": "(The value of this property is over-sized, so it is validated independently.)",
+  "attrs": {
+    "description": "Async test (Strict Mode)",
+    "flags": {
+      "async": true
+    },
+    "includes": [
+      "assert.js",
+      "sta.js",
+      "doneprintHandle.js"
+    ]
+  },
+  "copyright": "",
+  "scenario": "strict mode",
+  "insertionIndex": 578
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/expected-metadata/test/bothStrict_default.json

@@ -0,0 +1,24 @@
+{
+  "file": "test/bothStrict.js",
+  "contents": "(The value of this property is over-sized, so it is validated independently.)",
+  "attrs": {
+    "description": "Should test in both modes",
+    "features": [
+      "var",
+      "try",
+      "if"
+    ],
+    "negative": {
+      "phase": "runtime",
+      "type": "ReferenceError"
+    },
+    "flags": {},
+    "includes": [
+      "assert.js",
+      "sta.js"
+    ]
+  },
+  "copyright": "",
+  "scenario": "default",
+  "insertionIndex": 439
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/expected-metadata/test/bothStrict_strict_mode.json

@@ -0,0 +1,24 @@
+{
+  "file": "test/bothStrict.js",
+  "contents": "(The value of this property is over-sized, so it is validated independently.)",
+  "attrs": {
+    "description": "Should test in both modes (Strict Mode)",
+    "features": [
+      "var",
+      "try",
+      "if"
+    ],
+    "negative": {
+      "phase": "runtime",
+      "type": "ReferenceError"
+    },
+    "flags": {},
+    "includes": [
+      "assert.js",
+      "sta.js"
+    ]
+  },
+  "copyright": "",
+  "scenario": "strict mode",
+  "insertionIndex": 453
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/expected-metadata/test/strict/no/noStrict_default.json

@@ -0,0 +1,17 @@
+{
+  "file": "test/strict/no/noStrict.js",
+  "contents": "(The value of this property is over-sized, so it is validated independently.)",
+  "attrs": {
+    "description": "Should not test in strict mode",
+    "flags": {
+      "noStrict": true
+    },
+    "includes": [
+      "assert.js",
+      "sta.js"
+    ]
+  },
+  "copyright": "",
+  "scenario": "default",
+  "insertionIndex": 439
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/expected-metadata/test/strict/no/rawNoStrict_default.json

@@ -0,0 +1,14 @@
+{
+  "file": "test/strict/no/rawNoStrict.js",
+  "contents": "(The value of this property is over-sized, so it is validated independently.)",
+  "attrs": {
+    "description": "Should not test in strict mode",
+    "flags": {
+      "raw": true
+    },
+    "includes": []
+  },
+  "copyright": "",
+  "scenario": "default",
+  "insertionIndex": -1
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/harness/assert.js

@@ -0,0 +1,17 @@
+// This is assert.js
+
+'It has some contents';
+
+/* that
+ *
+ * should
+
+ * not
+ */
+
+`be ${ "modified" }`;
+
+var including, trailing;
+whitespace: ;                    
+
+void "end of assert.js";

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/harness/doneprintHandle.js

@@ -0,0 +1,6 @@
+function $DONE(){
+  if(!arguments[0])
+    print('Test262:AsyncTestComplete');
+  else
+    print('Error: ' + arguments[0]);
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/harness/sta.js

@@ -0,0 +1,12 @@
+function Test262Error(message) {
+  this.message = message || "";
+}
+
+Test262Error.prototype.toString = function () {
+  return "Test262Error: " + this.message;
+};
+
+var $ERROR;
+$ERROR = function $ERROR(message) {
+  throw new Test262Error(message);
+};

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/test/async/async.js

@@ -0,0 +1,10 @@
+/*---
+description: Async test
+flags: [async]
+---*/
+
+var p = new Promise(function(resolve) {
+  resolve();
+});
+
+p.then($DONE, $DONE);

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/test/async/asyncNegative.js

@@ -0,0 +1,11 @@
+/*---
+description: Async negative test
+negative:
+  phase: runtime
+  type: RangeError
+flags: [async]
+---*/
+
+setTimeout(function() {
+  $DONE(new RangeError());
+}, 1000);

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/test/bothStrict.js

@@ -0,0 +1,15 @@
+/*---
+description: Should test in both modes
+features: [var, try, if]
+negative:
+  phase: runtime
+  type: ReferenceError
+---*/
+var strict;
+try { x = 1; strict = false;} catch(e) { strict = true }
+
+if(strict) {
+    y = 1;
+} else {
+    throw new ReferenceError();
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/test/error.js

@@ -0,0 +1,8 @@
+/*---
+description: Fails by calling $ERROR
+negative:
+  phase: runtime
+  type: Test262Error
+---*/
+
+$ERROR('failure message');

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/test/negative-empty.js

@@ -0,0 +1,6 @@
+/*---
+description: Should report the expected error indicated by the "negative" frontmatter
+negative:
+  phase: runtime
+  type: Test262Error
+---*/

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/test/strict/no/noStrict.js

@@ -0,0 +1,5 @@
+/*---
+description: Should not test in strict mode
+flags: [noStrict]
+---*/
+x = 5;

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/test/strict/no/rawNoStrict.js

@@ -0,0 +1,14 @@
+/*---
+description: Should not test in strict mode
+flags: [raw]
+---*/
+var seemsStrict;
+try {
+  x = 1;
+} catch (err) {
+  seemsStrict = err.constructor === ReferenceError;
+}
+
+if (seemsStrict) {
+  throw new Error('Script erroneously interpreted in strict mode.');
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/test/strict/rawStrict.js

@@ -0,0 +1,15 @@
+/*---
+description: Should not test in strict mode (but allow strict mode to be enabled)
+flags: [raw]
+---*/
+'use strict';
+var seemsStrict;
+try {
+  x = 1;
+} catch (err) {
+  seemsStrict = err.constructor === ReferenceError;
+}
+
+if (!seemsStrict) {
+  throw new Error('Script erroneously not interpreted in strict mode.');
+}

package/test262/node_modules/test262-stream/test/collateral/valid-with-paths/fake-test262/test/strict/strict.js

@@ -0,0 +1,9 @@
+/*---
+description: Should not test in sloppy mode
+flags: [onlyStrict]
+negative:
+  phase: runtime
+  type: ReferenceError
+---*/
+x = 5;
+$ERROR('Not in strict mode');

package/test262/node_modules/test262-stream/test/test.js

@@ -0,0 +1,319 @@
+'use strict';
+const fs = require('fs');
+const mkdirp = require('mkdirp');
+const path = require('path');
+const rimraf = require('rimraf');
+const tape = require('tape');
+
+const TestStream = require('..');
+const scenarios = /^(strict mode|default)$/;
+
+const RECORDING = !!process.env.RECORD;
+
+// Properties to exclude when validating metadata. The values are
+// inconsequential; they have been selected to aid in discoverability in the
+// programatically-generated "expectations" files.
+const blankOut = {
+  contents: '(The value of this property is over-sized, so it is validated independently.)'
+};
+
+function makeDataHandler(t, ids, fixtureDir) {
+  const test262Dir = path.join(fixtureDir, 'fake-test262');
+  const expectedContentDir = path.join(fixtureDir, 'expected-content');
+  const expectedMetadataDir = path.join(fixtureDir, 'expected-metadata');
+
+  if (RECORDING) {
+    rimraf.sync(expectedContentDir);
+    rimraf.sync(expectedMetadataDir);
+  }
+
+  return (test) => {
+
+    if (typeof test !== 'object' || test === null) {
+      t.ok(false, 'Emits object values');
+      return;
+    }
+
+    const actualContents = test.contents;
+    const actualMetadata = Object.assign({}, test, blankOut);
+
+    if (!fs.existsSync(path.join(test262Dir, test.file))) {
+      t.ok(false, 'Source file does not exist: ' + test.file);
+      return;
+    }
+
+    // `RegExp.prototype.test` acceptes `undefined`, so an explicit type
+    // check is necessary.
+    t.equal(typeof test.scenario, 'string', '`scenario` property is a string value');
+    t.ok(scenarios.test(test.scenario), '`scenario` property is a valid value');
+
+    const id = test.file.replace(/\.js$/, '_' + test.scenario.replace(' ', '_'));
+    const expectedContentFile = path.join(expectedContentDir, id) + '.js';
+    const expectedMetadataFile = path.join(expectedMetadataDir, id) + '.json';
+
+    t.not(ids.indexOf(id) === -1, 'Emits each test exactly once');
+    ids.push(id);
+
+    if (RECORDING) {
+      mkdirp.sync(path.dirname(expectedContentFile));
+      fs.writeFileSync(expectedContentFile, actualContents, 'utf-8');
+      mkdirp.sync(path.dirname(expectedMetadataFile));
+      fs.writeFileSync(expectedMetadataFile, JSON.stringify(actualMetadata, null, 2), 'utf-8');
+      return;
+    }
+
+    if (!fs.existsSync(expectedContentFile)) {
+      t.ok(false, 'Expected content file not found: ' + expectedContentFile);
+      return;
+    }
+
+    if (!fs.existsSync(expectedMetadataFile)) {
+      t.ok(false, 'Expected metadata file not found: ' + expectedMetadataFile);
+      return;
+    }
+
+    t.deepEqual(actualContents, fs.readFileSync(expectedContentFile, 'utf-8'));
+    t.deepEqual(actualMetadata, require(expectedMetadataFile));
+  };
+}
+
+tape('valid source directory', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'valid-default');
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'));
+  const ids = [];
+
+  stream.on('data', makeDataHandler(t, ids, fixtureDir));
+
+  stream.on('error', (error) => {
+    t.ok(error);
+    t.end(error);
+  });
+
+  stream.on('end', () => {
+    t.equal(ids.length, 16, 'Reports every available test');
+    t.end();
+  });
+});
+
+tape('valid source directory (with paths)', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'valid-with-paths');
+  const paths = ['test/bothStrict.js', 'test/strict/no', 'test/async'];
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'), { paths });
+  const ids = [];
+
+  stream.on('data', makeDataHandler(t, ids, fixtureDir));
+
+  stream.on('error', (error) => {
+    t.ok(error);
+    t.end(error);
+  });
+
+  stream.on('end', () => {
+    t.equal(ids.length, 8, 'Reports every available test');
+    t.end();
+  });
+});
+
+tape('valid source directory (with custom includes)', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'valid-with-includes');
+  const includesDir = path.join(fixtureDir, 'custom-includes');
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'), { includesDir });
+  const ids = [];
+
+  stream.on('data', makeDataHandler(t, ids, fixtureDir));
+
+  stream.on('error', (error) => {
+    t.ok(error);
+    t.end(error);
+  });
+
+  stream.on('end', () => {
+    t.equal(ids.length, 4, 'Reports every available test');
+    t.end();
+  });
+});
+
+tape('missing `assert.js`', t => {
+  const stream = new TestStream(path.join(__dirname, 'collateral', 'invalid-missing-harness'));
+
+  stream.on('data', () => {
+    t.end(new Error('Stream should not emit a `data` event'));
+  });
+
+  stream.on('end', () => {
+    t.end(new Error('Stream should not emit an `end` event'));
+  });
+
+  stream.on('error', (error) => {
+    t.ok(error, '`error` event should be published with an object');
+    t.end();
+  });
+});
+
+tape.skip('non-existent source directory', t => {
+  const stream = new TestStream(path.join(__dirname, 'collateral', 'this-directory-does-not-exist'));
+
+  stream.on('data', () => {
+    t.end(new Error('Stream should not emit a `data` event'));
+  });
+
+  stream.on('end', () => {
+    t.end(new Error('Stream should not emit an `end` event'));
+  });
+
+  stream.on('error', (error) => {
+    t.ok(error, '`error` event should be published with an object');
+    t.end();
+  });
+});
+
+tape('valid source directory (with a supported version)', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'valid-version-supported');
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'));
+  const ids = [];
+
+  stream.on('data', makeDataHandler(t, ids, fixtureDir));
+
+  stream.on('error', (error) => {
+    t.ok(error);
+    t.end(error);
+  });
+
+  stream.on('end', () => {
+    t.equal(ids.length, 1, 'Reports every available test');
+    t.end();
+  });
+});
+
+tape('invalid source directory (with an unsupported version)', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'invalid-version-unsupported');
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'));
+
+  stream.on('data', () => {
+    t.end(new Error('Stream should not emit a `data` event'));
+  });
+
+  stream.on('end', () => {
+    t.end(new Error('Stream should not emit an `end` event'));
+  });
+
+  stream.on('error', (error) => {
+    t.ok(error, '`error` event should be published with an object');
+    t.end();
+  });
+});
+
+tape('invalid source directory (accepting newer version)', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'valid-version-ignored');
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'), {
+    acceptVersion: '999.0.0'
+  });
+  const ids = [];
+
+  stream.on('data', makeDataHandler(t, ids, fixtureDir));
+
+  stream.on('error', (error) => {
+    t.ok(error);
+    t.end(error);
+  });
+
+  stream.on('end', () => {
+    t.equal(ids.length, 1, 'Reports every available test');
+    t.end();
+  });
+});
+
+tape('invalid source directory (with a version that differs from the "accepted" versoin)', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'invalid-version-other-accepted');
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'), {
+    acceptVersion: '3.0.1'
+  });
+
+  stream.on('data', () => {
+    t.end(new Error('Stream should not emit a `data` event'));
+  });
+
+  stream.on('end', () => {
+    t.end(new Error('Stream should not emit an `end` event'));
+  });
+
+  stream.on('error', (error) => {
+    t.ok(error, '`error` event should be published with an object');
+    t.end();
+  });
+});
+
+tape('omit runtime', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'valid-omit-runtime');
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'), {
+    omitRuntime: true
+  });
+  const ids = [];
+
+  stream.on('data', makeDataHandler(t, ids, fixtureDir));
+
+  stream.on('error', (error) => {
+    t.ok(error);
+    t.end(error);
+  });
+
+  stream.on('end', () => {
+    t.equal(ids.length, 16, 'Reports every available test');
+    t.end();
+  });
+});
+
+tape('completion detection when final files visited are not tests', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'valid-extra-files');
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'));
+  const ids = [];
+
+  global.mike = true;
+  stream.on('data', makeDataHandler(t, ids, fixtureDir));
+
+  stream.on('error', (error) => {
+    t.ok(error);
+    t.end(error);
+  });
+
+  stream.on('end', () => {
+    t.equal(ids.length, 2, 'Reports every available test');
+    t.end();
+  });
+});
+
+tape('valid source directory (with hashbang tests)', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'valid-with-hashbang');
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'));
+  const ids = [];
+
+  stream.on('data', makeDataHandler(t, ids, fixtureDir));
+
+  stream.on('error', (error) => {
+    t.ok(error);
+    t.end(error);
+  });
+
+  stream.on('end', () => {
+    t.equal(ids.length, 10, 'Reports every available test');
+    t.end();
+  });
+});
+
+tape('copyright and insertionIndex integrity', t => {
+  const fixtureDir = path.join(__dirname, 'collateral', 'valid-insertionindex-with-copyright');
+  const stream = new TestStream(path.join(fixtureDir, 'fake-test262'));
+  const ids = [];
+
+  stream.on('data', makeDataHandler(t, ids, fixtureDir));
+
+  stream.on('error', (error) => {
+    t.ok(error);
+    t.end(error);
+  });
+
+  stream.on('end', () => {
+    t.equal(ids.length, 3, 'Reports every available test');
+    t.end();
+  });
+});

package/test262/node_modules/to-regex-range/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.