refactor(Cypress): add nodemodules

node_modules/seed-random/.npmignore

@@ -0,0 +1,2 @@
+components
+build

node_modules/seed-random/.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - "0.10"

node_modules/seed-random/LICENSE

@@ -0,0 +1,50 @@
+LICENSE for modifications of JavaScript Library by Forbes Lindesay (MIT):
+
+Copyright (c) 2013 Forbes Lindesay
+
+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.
+
+LICENSE for original seedrandom javascript file (BSD):
+
+Copyright 2013 David Bau, all rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+  3. Neither the name of this module nor the names of its contributors may
+     be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

node_modules/seed-random/Readme.md

@@ -0,0 +1,44 @@
+# seed-random
+
+Generate random numbers with a seed, useful for reproducible tests
+
+
+[![build status](https://secure.travis-ci.org/ForbesLindesay/seed-random.png?branch=master)](http://travis-ci.org/ForbesLindesay/seed-random)
+[![Dependency Status](https://gemnasium.com/ForbesLindesay/seed-random.png)](https://gemnasium.com/ForbesLindesay/seed-random)
+[![NPM version](https://badge.fury.io/js/seed-random.png)](http://badge.fury.io/js/seed-random)
+
+## Installation
+
+    $ npm install seed-random
+
+## API
+
+```javascript
+var assert = require('assert');
+var seed = require('../');
+
+var trueRandomA = seed();
+var trueRandomB = seed();
+assert(trueRandomA() != trueRandomB());
+
+var fakeRandomA = seed('foo');
+var fakeRandomB = seed('foo');
+assert(fakeRandomA() == fakeRandomB());
+
+var fakeRandomC = seed('foo', {entropy: true});
+var fakeRandomD = seed('foo', {entropy: true});
+assert(fakeRandomC() != fakeRandomD());
+
+
+seed('foo', {global: true});//over-ride global Math.random
+var numA = Math.random();
+seed('foo', {global: true});
+var numB = Math.random();
+assert(numA == numB);//always true
+
+seed.resetGlobal();//reset to default Math.random
+```
+
+## License
+
+MIT

node_modules/seed-random/component.json

@@ -0,0 +1,13 @@
+{
+  "name": "seed-random",
+  "repo": "ForbesLindesay/seed-random",
+  "description": "Generate random numbers with a seed, useful for reproducible tests",
+  "version": "2.2.0",
+  "keywords": [],
+  "dependencies": {},
+  "development": {},
+  "license": "MIT",
+  "scripts": [
+    "index.js"
+  ]
+}

node_modules/seed-random/index.js

@@ -0,0 +1,173 @@
+'use strict';
+
+var width = 256;// each RC4 output is 0 <= x < 256
+var chunks = 6;// at least six RC4 outputs for each double
+var digits = 52;// there are 52 significant digits in a double
+var pool = [];// pool: entropy pool starts empty
+var GLOBAL = typeof global === 'undefined' ? window : global;
+
+//
+// The following constants are related to IEEE 754 limits.
+//
+var startdenom = Math.pow(width, chunks),
+    significance = Math.pow(2, digits),
+    overflow = significance * 2,
+    mask = width - 1;
+
+
+var oldRandom = Math.random;
+
+//
+// seedrandom()
+// This is the seedrandom function described above.
+//
+module.exports = function(seed, options) {
+  if (options && options.global === true) {
+    options.global = false;
+    Math.random = module.exports(seed, options);
+    options.global = true;
+    return Math.random;
+  }
+  var use_entropy = (options && options.entropy) || false;
+  var key = [];
+
+  // Flatten the seed string or build one from local entropy if needed.
+  var shortseed = mixkey(flatten(
+    use_entropy ? [seed, tostring(pool)] :
+    0 in arguments ? seed : autoseed(), 3), key);
+
+  // Use the seed to initialize an ARC4 generator.
+  var arc4 = new ARC4(key);
+
+  // Mix the randomness into accumulated entropy.
+  mixkey(tostring(arc4.S), pool);
+
+  // Override Math.random
+
+  // This function returns a random double in [0, 1) that contains
+  // randomness in every bit of the mantissa of the IEEE 754 value.
+
+  return function() {         // Closure to return a random double:
+    var n = arc4.g(chunks),             // Start with a numerator n < 2 ^ 48
+        d = startdenom,                 //   and denominator d = 2 ^ 48.
+        x = 0;                          //   and no 'extra last byte'.
+    while (n < significance) {          // Fill up all significant digits by
+      n = (n + x) * width;              //   shifting numerator and
+      d *= width;                       //   denominator and generating a
+      x = arc4.g(1);                    //   new least-significant-byte.
+    }
+    while (n >= overflow) {             // To avoid rounding up, before adding
+      n /= 2;                           //   last byte, shift everything
+      d /= 2;                           //   right using integer Math until
+      x >>>= 1;                         //   we have exactly the desired bits.
+    }
+    return (n + x) / d;                 // Form the number within [0, 1).
+  };
+};
+
+module.exports.resetGlobal = function () {
+  Math.random = oldRandom;
+};
+
+//
+// ARC4
+//
+// An ARC4 implementation.  The constructor takes a key in the form of
+// an array of at most (width) integers that should be 0 <= x < (width).
+//
+// The g(count) method returns a pseudorandom integer that concatenates
+// the next (count) outputs from ARC4.  Its return value is a number x
+// that is in the range 0 <= x < (width ^ count).
+//
+/** @constructor */
+function ARC4(key) {
+  var t, keylen = key.length,
+      me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];
+
+  // The empty key [] is treated as [0].
+  if (!keylen) { key = [keylen++]; }
+
+  // Set up S using the standard key scheduling algorithm.
+  while (i < width) {
+    s[i] = i++;
+  }
+  for (i = 0; i < width; i++) {
+    s[i] = s[j = mask & (j + key[i % keylen] + (t = s[i]))];
+    s[j] = t;
+  }
+
+  // The "g" method returns the next (count) outputs as one number.
+  (me.g = function(count) {
+    // Using instance members instead of closure state nearly doubles speed.
+    var t, r = 0,
+        i = me.i, j = me.j, s = me.S;
+    while (count--) {
+      t = s[i = mask & (i + 1)];
+      r = r * width + s[mask & ((s[i] = s[j = mask & (j + t)]) + (s[j] = t))];
+    }
+    me.i = i; me.j = j;
+    return r;
+    // For robust unpredictability discard an initial batch of values.
+    // See http://www.rsa.com/rsalabs/node.asp?id=2009
+  })(width);
+}
+
+//
+// flatten()
+// Converts an object tree to nested arrays of strings.
+//
+function flatten(obj, depth) {
+  var result = [], typ = (typeof obj)[0], prop;
+  if (depth && typ == 'o') {
+    for (prop in obj) {
+      try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
+    }
+  }
+  return (result.length ? result : typ == 's' ? obj : obj + '\0');
+}
+
+//
+// mixkey()
+// Mixes a string seed into a key that is an array of integers, and
+// returns a shortened string seed that is equivalent to the result key.
+//
+function mixkey(seed, key) {
+  var stringseed = seed + '', smear, j = 0;
+  while (j < stringseed.length) {
+    key[mask & j] =
+      mask & ((smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++));
+  }
+  return tostring(key);
+}
+
+//
+// autoseed()
+// Returns an object for autoseeding, using window.crypto if available.
+//
+/** @param {Uint8Array=} seed */
+function autoseed(seed) {
+  try {
+    GLOBAL.crypto.getRandomValues(seed = new Uint8Array(width));
+    return tostring(seed);
+  } catch (e) {
+    return [+new Date, GLOBAL, GLOBAL.navigator && GLOBAL.navigator.plugins,
+            GLOBAL.screen, tostring(pool)];
+  }
+}
+
+//
+// tostring()
+// Converts an array of charcodes to a string
+//
+function tostring(a) {
+  return String.fromCharCode.apply(0, a);
+}
+
+//
+// When seedrandom.js is loaded, we immediately mix a few bits
+// from the built-in RNG into the entropy pool.  Because we do
+// not want to intefere with determinstic PRNG state later,
+// seedrandom will not call Math.random on its own again after
+// initialization.
+//
+mixkey(Math.random(), pool);

node_modules/seed-random/package.json

@@ -0,0 +1,46 @@
+{
+  "_from": "seed-random@~2.2.0",
+  "_id": "seed-random@2.2.0",
+  "_inBundle": false,
+  "_integrity": "sha1-KpsZ4lCoFwmSMaW5mk2vgLf77VQ=",
+  "_location": "/seed-random",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "seed-random@~2.2.0",
+    "name": "seed-random",
+    "escapedName": "seed-random",
+    "rawSpec": "~2.2.0",
+    "saveSpec": null,
+    "fetchSpec": "~2.2.0"
+  },
+  "_requiredBy": [
+    "/knuth-shuffle-seeded"
+  ],
+  "_resolved": "https://registry.npmjs.org/seed-random/-/seed-random-2.2.0.tgz",
+  "_shasum": "2a9b19e250a817099231a5b99a4daf80b7fbed54",
+  "_spec": "seed-random@~2.2.0",
+  "_where": "/home/simon/Documents/lifen-autotest/node_modules/knuth-shuffle-seeded",
+  "author": {
+    "name": "ForbesLindesay"
+  },
+  "bugs": {
+    "url": "https://github.com/ForbesLindesay/seed-random/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Generate random numbers with a seed, useful for reproducible tests",
+  "homepage": "https://github.com/ForbesLindesay/seed-random#readme",
+  "license": "MIT",
+  "main": "index.js",
+  "name": "seed-random",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ForbesLindesay/seed-random.git"
+  },
+  "scripts": {
+    "test": "node test/index.js"
+  },
+  "version": "2.2.0"
+}

node_modules/seed-random/test/index.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var assert = require('assert');
+var seed = require('../');
+
+var trueRandomA = seed();
+var trueRandomB = seed();
+assert(trueRandomA() != trueRandomB());
+
+var fakeRandomA = seed('foo');
+var fakeRandomB = seed('foo');
+assert(fakeRandomA() == fakeRandomB());
+
+var fakeRandomC = seed('foo', {entropy: true});
+var fakeRandomD = seed('foo', {entropy: true});
+assert(fakeRandomC() != fakeRandomD());
+
+
+seed('foo', {global: true});//over-ride global Math.random
+var numA = Math.random();
+seed('foo', {global: true});
+var numB = Math.random();
+assert(numA == numB);//always true
+
+seed.resetGlobal();//reset to default Math.random
+
+console.log('All Tests Passed');