Auto

node_modules/lazy/test/bucket.js

@@ -0,0 +1,37 @@
+var assert = require('assert');
+var Lazy = require('..');
+
+exports.bucket = function () {
+    var joined = false;
+    var lazy = new Lazy;
+    lazy.bucket('', function splitter (acc, x) {
+        var accx = acc + x;
+        var i = accx.indexOf('\n');
+        if (i >= 0) {
+            this(accx.slice(0, i));
+            return splitter.call(this, accx.slice(i + 1), '');
+        }
+        return accx;
+    }).join(function (lines) {
+        assert.deepEqual(lines, 'foo bar baz quux moo'.split(' '));
+        joined = true;
+    });
+    
+    setTimeout(function () {
+        lazy.emit('data', 'foo\nba');
+    }, 50);
+    setTimeout(function () {
+        lazy.emit('data', 'r');
+    }, 100);
+    setTimeout(function () {
+        lazy.emit('data', '\nbaz\nquux\nm');
+    }, 150);
+    setTimeout(function () {
+        lazy.emit('data', 'oo');
+    }, 200);
+    setTimeout(function () {
+        lazy.emit('data', '\nzoom');
+        lazy.emit('end');
+        assert.ok(joined);
+    }, 250);
+};

node_modules/lazy/test/complex.js

@@ -0,0 +1,52 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['complex'] = function () {
+    var lazy = new Lazy;
+    var data1 = [];
+    var data2 = [];
+    var data3 = [];
+    var joinExecuted = false;
+    lazy
+        .map(function (x) {
+            return 2*x;
+        })
+        .forEach(function (x) {
+            data1.push(x);
+        })
+        .map(function (x) {
+            return x/2;
+        })
+        .take(5)
+        .forEach(function (x) {
+            data2.push(x);
+        })
+        .filter(function (x) {
+            return x % 2 == 0;
+        })
+        .forEach(function (x) {
+            data3.push(x);
+        })
+        .join(function (xs) {
+            joinExecuted = true;
+            assert.deepEqual(xs, [0, 2, 4]);
+        });
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+    lazy.emit('end');
+
+    assert.deepEqual(data1, range(0,10).map(function (x) { return x*2 }));
+    assert.deepEqual(data2, range(0,5));
+    assert.deepEqual(data3, [0, 2, 4]);
+    assert.ok(joinExecuted);
+}
+

node_modules/lazy/test/custom.js

@@ -0,0 +1,32 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['custom event names'] = function () {
+    var lazy = new Lazy(null, { data : 'meow', pipe : 'all done' });
+    var data = [];
+    var executed = false;
+    lazy.take(10).join(function (xs) {
+        assert.deepEqual(xs, range(0,10));
+        executed = true;
+    });
+    
+    var allDone = 0;
+    lazy.on('all done', function () {
+        allDone ++;
+    });
+
+    range(0,20).forEach(function (x) {
+        lazy.emit('meow', x);
+    });
+
+    assert.ok(executed, 'join didn\'t execute');
+    assert.equal(allDone, 1);
+}
+

node_modules/lazy/test/em.js

@@ -0,0 +1,33 @@
+var assert = require('assert');
+var Lazy = require('..');
+var EventEmitter = require('events').EventEmitter;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports.em = function () {
+    var em = new EventEmitter;
+    var i = 0;
+    var iv = setInterval(function () {
+        em.emit('data', i++);
+    }, 10);
+    
+    var caughtDone = 0;
+    em.on('pipe', function () { caughtDone ++ });
+    
+    var joined = 0;
+    Lazy(em).take(10).join(function (xs) {
+        assert.deepEqual(xs, range(0, 10));
+        clearInterval(iv);
+        joined ++;
+    });
+    
+    setTimeout(function () {
+        assert.equal(joined, 1);
+        assert.equal(caughtDone, 1);
+    }, 500);
+}
+

node_modules/lazy/test/filter.js

@@ -0,0 +1,27 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['filter'] = function () {
+    var lazy = new Lazy;
+    var data = [];
+    var executed = false;
+    lazy.filter(function(x) { return x > 5 }).join(function (xs) {
+        assert.deepEqual(xs, [6,7,8,9]);
+        executed = true;
+    });
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+    lazy.emit('pipe');
+
+    assert.ok(executed, 'join didn\'t execute');
+}
+

node_modules/lazy/test/foldr.js

@@ -0,0 +1,26 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['foldr'] = function () {
+    var lazy = new Lazy;
+    var executed = 0;
+    lazy.foldr(function (x, acc) { return acc + x; }, 0, function (y) {
+        executed++;
+        assert.equal(y, 45);
+    })
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+    lazy.emit('end');
+
+    assert.equal(executed, 1, 'foldr failed to execute');
+}
+

node_modules/lazy/test/forEach.js

@@ -0,0 +1,31 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['forEach'] = function () {
+    var lazy = new Lazy;
+    var executed = false;
+    var data1 = [];
+    var data2 = [];
+    lazy
+        .forEach(function (x) {
+            data1.push(x);
+        })
+        .forEach(function (x) {
+            data2.push(x);
+        });
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+
+    assert.deepEqual(data1, range(0,10));
+    assert.deepEqual(data2, range(0,10));
+}
+

node_modules/lazy/test/head.js

@@ -0,0 +1,26 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['head'] = function () {
+    var lazy = new Lazy;
+    var data = [];
+    var executed = 0;
+    lazy.head(function (x) {
+        assert.equal(x, 0);
+        executed++;
+    })
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+
+    assert.equal(executed, 1, 'head executed too much');
+}
+

node_modules/lazy/test/join.js

@@ -0,0 +1,26 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['join'] = function () {
+    var lazy = new Lazy;
+    var data = [];
+    var executed = false;
+    lazy.take(10).join(function (xs) {
+        assert.deepEqual(xs, range(0,10));
+        executed = true;
+    });
+
+    range(0,20).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+
+    assert.ok(executed, 'join didn\'t execute');
+}
+

node_modules/lazy/test/lines.js

@@ -0,0 +1,89 @@
+var assert = require('assert');
+var Lazy = require('..');
+var EventEmitter = require('events').EventEmitter;
+
+exports['buffered lines'] = function () {
+    var lazy = Lazy();
+    var joined = false;
+    lazy.lines
+        .forEach(function (line) {
+            assert.ok(line instanceof Buffer);
+            assert.ok(!line.toString().match(/\n/));
+            assert.ok(line.length > 0);
+        })
+        .join(function (lines) {
+            assert.deepEqual(
+                lines.map(function (x) { return x.toString() }),
+                'foo bar baz quux moo'.split(' ')
+            );
+            joined = true;
+        });
+    ;
+    
+    setTimeout(function () {
+        lazy.push(new Buffer('foo\nbar'));
+        lazy.push(new Buffer('\nbaz\nquux\nmoo'));
+        lazy.push(new Buffer(''));
+        lazy.push(new Buffer('\ndoom'));
+        lazy.end();
+        assert.ok(joined);
+    }, 50);
+};
+
+exports['string lines'] = function () {
+    var lazy = Lazy();
+    var joined = false;
+    lazy.lines
+        .forEach(function (line) {
+            assert.ok(line instanceof Buffer);
+            assert.ok(!line.toString().match(/\n/));
+            assert.ok(line.length > 0);
+        })
+        .join(function (lines) {
+            assert.deepEqual(
+                lines.map(function (x) { return x.toString() }),
+                'foo bar baz quux moo'.split(' ')
+            );
+            joined = true;
+        });
+    ;
+    
+    setTimeout(function () {
+        lazy.push('foo\nbar');
+        lazy.push('\nbaz\nquux\nmoo');
+        lazy.push('');
+        lazy.push('\ndoom');
+        lazy.end();
+        assert.ok(joined);
+    }, 50);
+};
+
+exports.endStream = function () {
+    var to = setTimeout(function () {
+        assert.fail('never finished');
+    }, 2500);
+    
+    var em = new EventEmitter;
+    var i = 0;
+    var lines = [];
+    Lazy(em).lines.forEach(function (line) {
+        i ++;
+        lines.push(line);
+        if (i == 2) {
+            clearTimeout(to);
+            assert.eql(lines.map(String), [ 'foo', 'bar' ]);
+        }
+    });
+    
+    setTimeout(function () {
+        em.emit('data', 'fo');
+    }, 100);
+    
+    setTimeout(function () {
+        em.emit('data', 'o\nbar');
+    }, 150);
+    
+    setTimeout(function () {
+        em.emit('end');
+    }, 200);
+};

node_modules/lazy/test/map.js

@@ -0,0 +1,29 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['map'] = function () {
+    var lazy = new Lazy;
+    var executed = false;
+    var data = [];
+    lazy
+        .map(function (x) {
+            return 2*x;
+        })
+        .forEach(function (x) {
+            data.push(x);
+        });
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+
+    assert.deepEqual(data, range(0,10).map(function (x) { return x*2 }));
+}
+

node_modules/lazy/test/pipe.js

@@ -0,0 +1,38 @@
+var assert = require('assert');
+var Lazy = require('..');
+var EventEmitter = require('events').EventEmitter;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports.pipe = function () {
+    var em = new EventEmitter;
+    var i = 0;
+    var iv = setInterval(function () {
+        em.emit('data', i++);
+    }, 10);
+    
+    var caught = { pipe : 0, end : 0 };
+    em.on('pipe', function () {
+        caught.pipe ++;
+        setTimeout(em.emit.bind(em, 'end'), 50);
+    });
+    em.on('end', function () { caught.end ++ });
+    
+    var joined = 0;
+    Lazy(em).take(10).join(function (xs) {
+        assert.deepEqual(xs, range(0, 10));
+        clearInterval(iv);
+        joined ++;
+    });
+    
+    setTimeout(function () {
+        assert.equal(joined, 1);
+        assert.equal(caught.pipe, 1);
+        assert.equal(caught.end, 1);
+    }, 1000);
+}
+

node_modules/lazy/test/product.js

@@ -0,0 +1,26 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['product'] = function () {
+    var lazy = new Lazy;
+    var executed = 0;
+    lazy.product(function (y) {
+        executed++;
+        assert.equal(y, 1*2*3*4*5*6*7*8*9);
+    })
+
+    range(1,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+    lazy.emit('end');
+
+    assert.equal(executed, 1, 'product failed to execute');
+}
+

node_modules/lazy/test/range.js

@@ -0,0 +1,272 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j, s) {
+    var r = [];
+    var s = s || 1;
+    if (j > i) for (;i<j;i+=s) r.push(i);
+    else for(;i>j;i-=s) r.push(i);
+    return r;
+}
+
+exports['infinite range'] = function () {
+    var joinExecuted = false;
+    Lazy.range('10..').take(10).join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(10, 20));
+        assert.equal(xs.length, 10);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['infinite range half-open'] = function () {
+    var joinExecuted = false;
+    Lazy.range('(10..').take(10).join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(11, 21));
+        assert.equal(xs.length, 10);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range i'] = function () {
+    var joinExecuted = false;
+    Lazy.range(10).join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(0, 10));
+        assert.equal(xs.length, 10);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range i,j (i<j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range(-10, 10).join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(-10, 10));
+        assert.equal(xs.length, 20);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range i,j,s (i<j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range(-10, 10, 2).join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(-10, 10, 2));
+        assert.equal(xs.length, 10);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range i,j,s (i>j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range(10, 0, 2).join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(10, 0, 2));
+        assert.equal(xs.length, 5);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range i,j (i>j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range(10, -8).join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(10, -8));
+        assert.equal(xs.length, 18);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range i..j (i<j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('5..50').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(5, 50));
+        assert.equal(xs.length, 45);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range i..j (i>j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('50..44').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(50, 44));
+        assert.equal(xs.length, 6);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range i,next..j (i<j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('1,1.1..4').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(1,4,0.1));
+        assert.equal(xs.length, 30);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range i,next..j (i>j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('4,3.9..1').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(4,1,0.1));
+        assert.equal(xs.length, 30);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range [i..j] (i<j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('[1..10]').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(1,11));
+        assert.equal(xs.length, 10);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range [i..j] (i>j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('[10..1]').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(10,0));
+        assert.equal(xs.length, 10);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range [i..j) (i<j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('[1..10)').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(1,10));
+        assert.equal(xs.length, 9);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range [i..j) (i>j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('[10..1)').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(10,1));
+        assert.equal(xs.length, 9);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range (i..j] (i<j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('(1..10]').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(2,11));
+        assert.equal(xs.length, 9);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range (i..j] (i>j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('(10..1]').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(9,0));
+        assert.equal(xs.length, 9);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range (i..j) (i<j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('(1..10)').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(2,10));
+        assert.equal(xs.length, 8);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range (i..j) (i>j)'] = function () {
+    var joinExecuted = false;
+    Lazy.range('(10..1)').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(9,1));
+        assert.equal(xs.length, 8);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+
+exports['range [i,step..j]'] = function () {
+    var joinExecuted = false;
+    Lazy.range('[5,10..50]').join(function (xs) {
+        joinExecuted = true;
+        assert.deepEqual(xs, range(5,51,5));
+        assert.equal(xs.length, 10);
+    });
+
+    setTimeout(function () {
+        assert.ok(joinExecuted, 'join didn\'t execute');
+    }, 2000);
+}
+

node_modules/lazy/test/skip.js

@@ -0,0 +1,27 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['skip'] = function () {
+    var lazy = new Lazy;
+    var data = [];
+    var executed = 0;
+    lazy.skip(6).join(function (xs) {
+        assert.deepEqual(xs, range(6,10));
+        executed++;
+    });
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+    lazy.emit('end');
+
+    assert.equal(executed, 1, 'join executed incorrectly');
+}
+

node_modules/lazy/test/sum.js

@@ -0,0 +1,26 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['sum'] = function () {
+    var lazy = new Lazy;
+    var executed = 0;
+    lazy.sum(function (y) {
+        executed++;
+        assert.equal(y, 45);
+    })
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+    lazy.emit('end');
+
+    assert.equal(executed, 1, 'sum failed to execute');
+}
+

node_modules/lazy/test/tail.js

@@ -0,0 +1,27 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['tail'] = function () {
+    var lazy = new Lazy;
+    var data = [];
+    var executed = false;
+    lazy.tail().join(function (xs) {
+        assert.deepEqual(xs, range(1,10));
+        executed = true;
+    });
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+    lazy.emit('end');
+
+    assert.ok(executed, 'join didn\'t execute');
+}
+

node_modules/lazy/test/take.js

@@ -0,0 +1,26 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['take'] = function () {
+    var lazy = new Lazy;
+    var data = [];
+    var executed = 0;
+    lazy.take(6).join(function (xs) {
+        assert.deepEqual(xs, range(0,6));
+        executed++;
+    });
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+
+    assert.equal(executed, 1, 'join executed incorrectly');
+}
+

node_modules/lazy/test/takeWhile.js

@@ -0,0 +1,26 @@
+var assert = require('assert');
+var Lazy = require('..');
+var expresso = expresso;
+
+function range(i, j) {
+    var r = [];
+    for (;i<j;i++) r.push(i);
+    return r;
+}
+
+exports['takeWhile'] = function () {
+    var lazy = new Lazy;
+    var data = [];
+    var executed = false;
+    lazy.takeWhile(function (x) { return x < 5 }).join(function (xs) {
+        assert.deepEqual(xs, range(0,5));
+        executed = true;
+    });
+
+    range(0,10).forEach(function (x) {
+        lazy.emit('data', x);
+    });
+
+    assert.ok(executed, 'join didn\'t execute');
+}
+