Auto

node_modules/deck/test/normalize.js

@@ -0,0 +1,20 @@
+var deck = require('deck');
+var assert = require('assert');
+var eql = assert.deepEqual;
+
+exports.normalize = function () {
+    eql(
+        deck.normalize({ a : 1, b : 3, c : 4 }),
+        { a : 0.125, b : 0.375, c : 0.5 }
+    );
+    
+    var t = 0.1 + 0.2 + 0.05;
+    eql(
+        deck.normalize({ a : 0.1, b : 0.2, c : 0.05 }),
+        { a : 0.1 / t, b : 0.2 / t, c : 0.05 / t }
+    );
+    
+    assert.throws(function () {
+        deck.normalize({ a : 0.1, b : 0.2, c : [] });
+    });
+};

node_modules/deck/test/pick.js

@@ -0,0 +1,69 @@
+var deck = require('deck');
+var assert = require('assert');
+var eql = assert.deepEqual;
+
+function picker (fn) {
+    var xs = [0,1,2,3,4,5,6,7,8,9];
+    var counts = {};
+    var loops = 50000;
+    
+    for (var i = 0; i < loops; i++) {
+        var x = fn(xs);
+        counts[x] = (counts[x] || 0) + 1;
+    }
+    eql(Object.keys(counts).sort(), xs);
+    eql(xs, [0,1,2,3,4,5,6,7,8,9], 'shuffle mutated its argument');
+    
+    xs.forEach(function (x) {
+        assert.ok(
+            counts[x] * xs.length >= loops * 0.95
+        );
+        
+        assert.ok(
+            counts[x] * xs.length <= loops * 1.05
+        );
+    });
+}
+
+exports.pick = function () {
+    picker(deck.pick);
+};
+
+exports.pickObj = function () {
+    picker(function (xs) {
+        return deck(xs).pick()
+    });
+};
+
+exports.weightedPick = function () {
+    var counts = {};
+    var weights = { a : 2, b : 10, c : 1 };
+    var total = 2 + 10 + 1;
+    var loops = 50000;
+    
+    for (var i = 0; i < loops; i++) {
+        var x = deck.pick(weights);
+        counts[x] = (counts[x] || 0) + 1;
+    }
+    
+    eql(Object.keys(counts).sort(), [ 'a', 'b', 'c' ]);
+    
+    Object.keys(weights).forEach(function (key) {
+        assert.ok(
+            counts[key] / weights[key] * total >= loops * 0.95
+        );
+        
+        assert.ok(
+            counts[key] / weights[key] * total <= loops * 1.05
+        );
+    });
+    
+    assert.throws(function () {
+        deck.pick({ a : 5, b : 2, c : /moo/ });
+    });
+};
+ 
+exports.pickEmpty = function () {
+    assert.ok(deck.pick([]) === undefined);
+    assert.ok(deck.pick({}) === undefined);
+};

node_modules/deck/test/shuffle.js

@@ -0,0 +1,71 @@
+var deck = require('deck');
+var assert = require('assert');
+
+function shuffler (fn) {
+    var xs = [0,1,2,3,4,5,6,7,8,9];
+    var xs_ = fn(xs);
+    assert.eql(xs, [0,1,2,3,4,5,6,7,8,9], 'shuffle mutated its argument');
+    assert.eql(xs.length, 10);
+    assert.ok(xs.every(function (x) {
+        return xs_.indexOf(x) >= 0
+    }));
+}
+
+exports.shuffle = function () {
+    shuffler(deck.shuffle);
+};
+
+exports.quick = function () {
+    var xs = [];
+    for (var i = 0; i < 1e5; i++) xs.push(Math.random());
+    
+    var t0 = Date.now();
+    var xs_ = deck.shuffle(xs);
+    var elapsed = Date.now() - t0;
+    assert.ok(elapsed < 200);
+    assert.equal(xs.length, 1e5);
+};
+
+exports.shuffleObj = function () {
+    shuffler(function (xs) {
+        return deck(xs).shuffle()
+    });
+};
+
+exports.weightedShuffle = function () {
+    assert.eql(deck.shuffle({ a : 1000, b : 0.01 }), [ 'a', 'b' ]);
+    
+    var weights = { a : 3, b : 1, c : 10 };
+    var total = 3 + 1 + 10;
+    var loops = 5000;
+    
+    var counts = {};
+    for (var i = 0; i < loops; i++) {
+        var x = deck.shuffle(weights).join('');
+        counts[x] = (counts[x] || 0) + 1;
+    }
+    
+    function margins (key) {
+        var keys = key.split('');
+        var expected = key.split('').reduce(function (p, x) {
+            var p_ = p * weights[x] / keys.reduce(function (acc, k) {
+                return acc + weights[k];
+            }, 0);
+            keys.shift();
+            return p_;
+        }, loops);
+        assert.ok(counts[key] >= 0.95 * expected);
+        assert.ok(counts[key] <= 1.05 * expected);
+    }
+    
+    Object.keys(counts).every(margins);
+    
+    assert.throws(function () {
+        deck.shuffle({ a : 1, b : 'x', c : 5 });
+    });
+};
+
+exports.shuffleEmpty = function () {
+    assert.eql(deck.shuffle([]), []);
+    assert.eql(deck.shuffle({}), []);
+};