moved tests to separate files

7 files changed, 441 insertions, 436 deletions

diff --git a/lib/internal/createTester.js b/lib/internal/createTester.js
index 0e9e750..282ef87 100644
--- a/lib/internal/createTester.js
+++ b/lib/internal/createTester.js
@@ -7,7 +7,7 @@ export default function _createTester(eachfn, check, getResult) {
                 if (err) {
                     cb(err);
                 } else {
-                    cb(null, getResult(false, void 0));
+                    cb(null, getResult(false));
                 }
             }
         }
diff --git a/mocha_test/detect.js b/mocha_test/detect.js
new file mode 100644
index 0000000..e1eec79
--- /dev/null
+++ b/mocha_test/detect.js
@@ -0,0 +1,123 @@
+var async = require('../lib');
+var expect = require('chai').expect;
+
+describe("detect", function () {
+
+    function detectIterator(call_order, x, callback) {
+        setTimeout(function(){
+            call_order.push(x);
+            callback(null, x == 2);
+        }, x*25);
+    }
+
+    it('detect', function(done){
+        var call_order = [];
+        async.detect([3,2,1], detectIterator.bind(this, call_order), function(err, result){
+            call_order.push('callback');
+            expect(err).to.equal(null);
+            expect(result).to.equal(2);
+        });
+        setTimeout(function(){
+            expect(call_order).to.eql([1,2,'callback',3]);
+            done();
+        }, 100);
+    });
+
+    it('detect - mulitple matches', function(done){
+        var call_order = [];
+        async.detect([3,2,2,1,2], detectIterator.bind(this, call_order), function(err, result){
+            call_order.push('callback');
+            expect(err).to.equal(null);
+            expect(result).to.equal(2);
+        });
+        setTimeout(function(){
+            expect(call_order).to.eql([1,2,'callback',2,2,3]);
+            done();
+        }, 100);
+    });
+
+    it('detect error', function(done){
+        async.detect([3,2,1], function(x, callback) {
+            setTimeout(function(){callback('error');}, 0);
+        }, function(err, result){
+            expect(err).to.equal('error');
+            expect(result).to.not.exist;
+            done();
+        });
+    });
+
+    it('detectSeries', function(done){
+        var call_order = [];
+        async.detectSeries([3,2,1], detectIterator.bind(this, call_order), function(err, result){
+            call_order.push('callback');
+            expect(err).to.equal(null);
+            expect(result).to.equal(2);
+        });
+        setTimeout(function(){
+            expect(call_order).to.eql([3,2,'callback']);
+            done();
+        }, 200);
+    });
+
+    it('detectSeries - multiple matches', function(done){
+        var call_order = [];
+        async.detectSeries([3,2,2,1,2], detectIterator.bind(this, call_order), function(err, result){
+            call_order.push('callback');
+            expect(err).to.equal(null);
+            expect(result).to.equal(2);
+        });
+        setTimeout(function(){
+            expect(call_order).to.eql([3,2,'callback']);
+            done();
+        }, 200);
+    });
+
+    it('detectSeries - ensure stop', function (done) {
+        async.detectSeries([1, 2, 3, 4, 5], function (num, cb) {
+            if (num > 3) throw new Error("detectSeries did not stop iterating");
+            cb(null, num === 3);
+        }, function (err, result) {
+            expect(err).to.equal(null);
+            expect(result).to.equal(3);
+            done();
+        });
+    });
+
+    it('detectLimit', function(done){
+        var call_order = [];
+        async.detectLimit([3, 2, 1], 2, detectIterator.bind(this, call_order), function(err, result) {
+            call_order.push('callback');
+            expect(err).to.equal(null);
+            expect(result).to.equal(2);
+        });
+        setTimeout(function() {
+            expect(call_order).to.eql([2, 'callback', 3]);
+            done();
+        }, 100);
+    });
+
+    it('detectLimit - multiple matches', function(done){
+        var call_order = [];
+        async.detectLimit([3,2,2,1,2], 2, detectIterator.bind(this, call_order), function(err, result){
+            call_order.push('callback');
+            expect(err).to.equal(null);
+            expect(result).to.equal(2);
+        });
+        setTimeout(function(){
+            expect(call_order).to.eql([2, 'callback', 3]);
+            done();
+        }, 100);
+    });
+
+    it('detectLimit - ensure stop', function (done) {
+        async.detectLimit([1, 2, 3, 4, 5], 2, function (num, cb) {
+            if (num > 4) throw new Error("detectLimit did not stop iterating");
+            cb(null, num === 3);
+        }, function (err, result) {
+            expect(err).to.equal(null);
+            expect(result).to.equal(3);
+            done();
+        });
+    });
+
+});
diff --git a/mocha_test/every.js b/mocha_test/every.js
new file mode 100644
index 0000000..2f562ce
--- /dev/null
+++ b/mocha_test/every.js
@@ -0,0 +1,90 @@
+var async = require('../lib');
+var expect = require('chai').expect;
+
+describe("every", function () {
+
+    it('everyLimit true', function(done){
+        async.everyLimit([3,1,2], 1, function(x, callback){
+            setTimeout(function(){callback(null, x >= 1);}, 0);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.equal(true);
+            done();
+        });
+    });
+
+    it('everyLimit false', function(done){
+        async.everyLimit([3,1,2], 2, function(x, callback){
+            setTimeout(function(){callback(null, x === 2);}, 0);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.equal(false);
+            done();
+        });
+    });
+
+    it('everyLimit short-circuit', function(done){
+        var calls = 0;
+        async.everyLimit([3,1,2], 1, function(x, callback){
+            calls++;
+            callback(null, x === 1);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.equal(false);
+            expect(calls).to.equal(1);
+            done();
+        });
+    });
+
+
+    it('true', function(done){
+        async.every([1,2,3], function(x, callback){
+            setTimeout(function(){callback(null, true);}, 0);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.equal(true);
+            done();
+        });
+    });
+
+    it('false', function(done){
+        async.every([1,2,3], function(x, callback){
+            setTimeout(function(){callback(null, x % 2);}, 0);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.equal(false);
+            done();
+        });
+    });
+
+    it('early return', function(done){
+        var call_order = [];
+        async.every([1,2,3], function(x, callback){
+            setTimeout(function(){
+                call_order.push(x);
+                callback(null, x === 1);
+            }, x*25);
+        }, function(){
+            call_order.push('callback');
+        });
+        setTimeout(function(){
+            expect(call_order).to.eql([1,2,'callback',3]);
+            done();
+        }, 100);
+    });
+
+    it('error', function(done){
+        async.every([1,2,3], function(x, callback){
+            setTimeout(function(){callback('error');}, 0);
+        }, function(err, result){
+            expect(err).to.equal('error');
+            expect(result).to.not.exist;
+            done();
+        });
+    });
+
+    it('all alias', function(){
+        expect(async.all).to.equal(async.every);
+    });
+
+});
diff --git a/mocha_test/filter.js b/mocha_test/filter.js
new file mode 100644
index 0000000..58f9a0b
--- /dev/null
+++ b/mocha_test/filter.js
@@ -0,0 +1,132 @@
+var async = require('../lib');
+var expect = require('chai').expect;
+
+function filterIterator(x, callback) {
+    setTimeout(function(){
+        callback(null, x % 2);
+    }, x*25);
+}
+
+function testLimit(arr, limitFunc, limit, iter, done) {
+    var args = [];
+
+    limitFunc(arr, limit, function(x) {
+        args.push(x);
+        iter.apply(this, arguments);
+    }, function() {
+        expect(args).to.eql(arr);
+        done.apply(this, arguments);
+    });
+}
+
+describe("filter", function () {
+
+    it('filter', function(done){
+        async.filter([3,1,2], filterIterator, function(err, results){
+            expect(err).to.equal(null);
+            expect(results).to.eql([3,1]);
+            done();
+        });
+    });
+
+    it('filter original untouched', function(done){
+        var a = [3,1,2];
+        async.filter(a, function(x, callback){
+            callback(null, x % 2);
+        }, function(err, results){
+            expect(err).to.equal(null);
+            expect(results).to.eql([3,1]);
+            expect(a).to.eql([3,1,2]);
+            done();
+        });
+    });
+
+    it('filter error', function(done){
+        async.filter([3,1,2], function(x, callback){
+            callback('error');
+        } , function(err, results){
+            expect(err).to.equal('error');
+            expect(results).to.not.exist;
+            done();
+        });
+    });
+
+    it('filterSeries', function(done){
+        async.filterSeries([3,1,2], filterIterator, function(err, results){
+            expect(err).to.equal(null);
+            expect(results).to.eql([3,1]);
+            done();
+        });
+    });
+
+    it('select alias', function(){
+        expect(async.select).to.equal(async.filter);
+    });
+
+    it('selectSeries alias', function(){
+        expect(async.selectSeries).to.equal(async.filterSeries);
+    });
+
+    it('filterLimit', function(done) {
+        testLimit([5, 4, 3, 2, 1], async.filterLimit, 2, function(v, next) {
+            next(null, v % 2);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.eql([5, 3, 1]);
+            done();
+        });
+    });
+
+});
+
+describe("reject", function () {
+
+    it('reject', function(done){
+        async.reject([3,1,2], filterIterator, function(err, results){
+            expect(err).to.equal(null);
+            expect(results).to.eql([2]);
+            done();
+        });
+    });
+
+    it('reject original untouched', function(done){
+        var a = [3,1,2];
+        async.reject(a, function(x, callback){
+            callback(null, x % 2);
+        }, function(err, results){
+            expect(err).to.equal(null);
+            expect(results).to.eql([2]);
+            expect(a).to.eql([3,1,2]);
+            done();
+        });
+    });
+
+    it('reject error', function(done){
+        async.reject([3,1,2], function(x, callback){
+            callback('error');
+        } , function(err, results){
+            expect(err).to.equal('error');
+            expect(results).to.not.exist;
+            done();
+        });
+    });
+
+    it('rejectSeries', function(done){
+        async.rejectSeries([3,1,2], filterIterator, function(err, results){
+            expect(err).to.equal(null);
+            expect(results).to.eql([2]);
+            done();
+        });
+    });
+
+    it('rejectLimit', function(done) {
+        testLimit([5, 4, 3, 2, 1], async.rejectLimit, 2, function(v, next) {
+            next(null, v % 2);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.eql([4, 2]);
+            done();
+        });
+    });
+
+});
diff --git a/mocha_test/mocha.opts b/mocha_test/mocha.opts
new file mode 100644
index 0000000..f39ac0a
--- /dev/null
+++ b/mocha_test/mocha.opts
@@ -0,0 +1,4 @@
+--compilers js:babel-core/register
+--recursive
+--growl
+--ui bdd
diff --git a/mocha_test/some.js b/mocha_test/some.js
new file mode 100644
index 0000000..8bdcb6b
--- /dev/null
+++ b/mocha_test/some.js
@@ -0,0 +1,91 @@
+var async = require('../lib');
+var expect = require('chai').expect;
+
+describe("some", function () {
+
+    it('some true', function(done){
+        async.some([3,1,2], function(x, callback){
+            setTimeout(function(){callback(null, x === 1);}, 0);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.equal(true);
+            done();
+        });
+    });
+
+    it('some false', function(done){
+        async.some([3,1,2], function(x, callback){
+            setTimeout(function(){callback(null, x === 10);}, 0);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.equal(false);
+            done();
+        });
+    });
+
+    it('some early return', function(done){
+        var call_order = [];
+        async.some([1,2,3], function(x, callback){
+            setTimeout(function(){
+                call_order.push(x);
+                callback(null, x === 1);
+            }, x*25);
+        }, function(){
+            call_order.push('callback');
+        });
+        setTimeout(function(){
+            expect(call_order).to.eql([1,'callback',2,3]);
+            done();
+        }, 100);
+    });
+
+    it('some error', function(done){
+        async.some([3,1,2], function(x, callback){
+            setTimeout(function(){callback('error');}, 0);
+        }, function(err, result){
+            expect(err).to.equal('error');
+            expect(result).to.not.exist;
+            done();
+        });
+    });
+
+    it('someLimit true', function(done){
+        async.someLimit([3,1,2], 2, function(x, callback){
+            setTimeout(function(){callback(null, x === 2);}, 0);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.equal(true);
+            done();
+        });
+    });
+
+    it('someLimit false', function(done){
+        async.someLimit([3,1,2], 2, function(x, callback){
+            setTimeout(function(){callback(null, x === 10);}, 0);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.equal(false);
+            done();
+        });
+    });
+
+
+    it('someLimit short-circuit', function(done){
+        var calls = 0;
+        async.someLimit([3,1,2], 1, function(x, callback){
+            calls++;
+            callback(null, x === 1);
+        }, function(err, result){
+            expect(err).to.equal(null);
+            expect(result).to.equal(true);
+            expect(calls).to.equal(2);
+            done();
+        });
+    });
+
+    it('any alias', function(){
+        expect(async.any).to.equal(async.some);
+    });
+
+
+});
diff --git a/test/test-async.js b/test/test-async.js
index 20bf43f..c8a1c7c 100755
--- a/test/test-async.js
+++ b/test/test-async.js
@@ -37,19 +37,6 @@ function mapIterator(call_order, x, callback) {
     }, x*25);
 }
 
-function filterIterator(x, callback) {
-    setTimeout(function(){
-        callback(null, x % 2);
-    }, x*25);
-}
-
-function detectIterator(call_order, x, callback) {
-    setTimeout(function(){
-        call_order.push(x);
-        callback(null, x == 2);
-    }, x*25);
-}
-
 function eachNoCallbackIterator(test, x, callback) {
     test.equal(x, 1);
     callback();
@@ -2160,428 +2147,6 @@ exports['transform error'] = function(test){
     });
 };
 
-exports['filter'] = function(test){
-    async.filter([3,1,2], filterIterator, function(err, results){
-        test.equals(err, null);
-        test.same(results, [3,1]);
-        test.done();
-    });
-};
-
-exports['filter original untouched'] = function(test){
-    var a = [3,1,2];
-    async.filter(a, function(x, callback){
-        callback(null, x % 2);
-    }, function(err, results){
-        test.equals(err, null);
-        test.same(results, [3,1]);
-        test.same(a, [3,1,2]);
-        test.done();
-    });
-};
-
-exports['filter error'] = function(test){
-    async.filter([3,1,2], function(x, callback){
-        callback('error');
-    } , function(err, results){
-        test.equals(err, 'error');
-        test.equals(results, null);
-        test.done();
-    });
-};
-
-exports['filterSeries'] = function(test){
-    async.filterSeries([3,1,2], filterIterator, function(err, results){
-        test.equals(err, null);
-        test.same(results, [3,1]);
-        test.done();
-    });
-};
-
-exports['select alias'] = function(test){
-    test.equals(async.select, async.filter);
-    test.done();
-};
-
-exports['selectSeries alias'] = function(test){
-    test.equals(async.selectSeries, async.filterSeries);
-    test.done();
-};
-
-exports['reject'] = function(test){
-    test.expect(2);
-    async.reject([3,1,2], filterIterator, function(err, results){
-        test.equals(err, null);
-        test.same(results, [2]);
-        test.done();
-    });
-};
-
-exports['reject original untouched'] = function(test){
-    test.expect(3);
-    var a = [3,1,2];
-    async.reject(a, function(x, callback){
-        callback(null, x % 2);
-    }, function(err, results){
-        test.equals(err, null);
-        test.same(results, [2]);
-        test.same(a, [3,1,2]);
-        test.done();
-    });
-};
-
-exports['reject error'] = function(test){
-    test.expect(2);
-    async.reject([3,1,2], function(x, callback){
-        callback('error');
-    } , function(err, results){
-        test.equals(err, 'error');
-        test.equals(results, null);
-        test.done();
-    });
-};
-
-exports['rejectSeries'] = function(test){
-    test.expect(2);
-    async.rejectSeries([3,1,2], filterIterator, function(err, results){
-        test.equals(err, null);
-        test.same(results, [2]);
-        test.done();
-    });
-};
-
-function testLimit(test, arr, limitFunc, limit, iter, done) {
-    var args = [];
-
-    limitFunc(arr, limit, function(x) {
-        args.push(x);
-        iter.apply(this, arguments);
-    }, function() {
-        test.same(args, arr);
-        if (done) done.apply(this, arguments);
-        else test.done();
-    });
-}
-
-exports['rejectLimit'] = function(test) {
-    test.expect(3);
-    testLimit(test, [5, 4, 3, 2, 1], async.rejectLimit, 2, function(v, next) {
-        next(null, v % 2);
-    }, function(err, result){
-        test.equals(err, null);
-        test.same(result, [4, 2]);
-        test.done();
-    });
-};
-
-exports['filterLimit'] = function(test) {
-    test.expect(3);
-    testLimit(test, [5, 4, 3, 2, 1], async.filterLimit, 2, function(v, next) {
-        next(null, v % 2);
-    }, function(err, result){
-        test.equals(err, null);
-        test.same(result, [5, 3, 1]);
-        test.done();
-    });
-};
-
-exports['some true'] = function(test){
-    test.expect(2);
-    async.some([3,1,2], function(x, callback){
-        setTimeout(function(){callback(null, x === 1);}, 0);
-    }, function(err, result){
-        test.equals(err, null);
-        test.equals(result, true);
-        test.done();
-    });
-};
-
-exports['some false'] = function(test){
-    test.expect(2);
-    async.some([3,1,2], function(x, callback){
-        setTimeout(function(){callback(null, x === 10);}, 0);
-    }, function(err, result){
-        test.equals(err, null);
-        test.equals(result, false);
-        test.done();
-    });
-};
-
-exports['some early return'] = function(test){
-    test.expect(1);
-    var call_order = [];
-    async.some([1,2,3], function(x, callback){
-        setTimeout(function(){
-            call_order.push(x);
-            callback(null, x === 1);
-        }, x*25);
-    }, function(){
-        call_order.push('callback');
-    });
-    setTimeout(function(){
-        test.same(call_order, [1,'callback',2,3]);
-        test.done();
-    }, 100);
-};
-
-exports['some error'] = function(test){
-    test.expect(2);
-    async.some([3,1,2], function(x, callback){
-        setTimeout(function(){callback('error');}, 0);
-    }, function(err, result){
-        test.equals(err, 'error');
-        test.equals(result, null);
-        test.done();
-    });
-};
-
-exports['someLimit true'] = function(test){
-    async.someLimit([3,1,2], 2, function(x, callback){
-        setTimeout(function(){callback(null, x === 2);}, 0);
-    }, function(err, result){
-        test.equals(err, null);
-        test.equals(result, true);
-        test.done();
-    });
-};
-
-exports['someLimit false'] = function(test){
-    async.someLimit([3,1,2], 2, function(x, callback){
-        setTimeout(function(){callback(null, x === 10);}, 0);
-    }, function(err, result){
-        test.equals(err, null);
-        test.equals(result, false);
-        test.done();
-    });
-};
-
-exports['every true'] = function(test){
-    async.everyLimit([3,1,2], 1, function(x, callback){
-        setTimeout(function(){callback(null, x > 1);}, 0);
-    }, function(err, result){
-        test.equals(err, null);
-        test.equals(result, true);
-        test.done();
-    });
-};
-
-exports['everyLimit false'] = function(test){
-    async.everyLimit([3,1,2], 2, function(x, callback){
-        setTimeout(function(){callback(null, x === 2);}, 0);
-    }, function(err, result){
-        test.equals(err, null);
-        test.equals(result, false);
-        test.done();
-    });
-};
-
-exports['everyLimit short-circuit'] = function(test){
-    test.expect(3);
-    var calls = 0;
-    async.everyLimit([3,1,2], 1, function(x, callback){
-        calls++;
-        callback(null, x === 1);
-    }, function(err, result){
-        test.equals(err, null);
-        test.equals(result, false);
-        test.equals(calls, 1);
-        test.done();
-    });
-};
-
-
-exports['someLimit short-circuit'] = function(test){
-    test.expect(3);
-    var calls = 0;
-    async.someLimit([3,1,2], 1, function(x, callback){
-        calls++;
-        callback(null, x === 1);
-    }, function(err, result){
-        test.equals(err, null);
-        test.equals(result, true);
-        test.equals(calls, 2);
-        test.done();
-    });
-};
-
-exports['any alias'] = function(test){
-    test.equals(async.any, async.some);
-    test.done();
-};
-
-exports['every true'] = function(test){
-    test.expect(2);
-    async.every([1,2,3], function(x, callback){
-        setTimeout(function(){callback(null, true);}, 0);
-    }, function(err, result){
-        test.equals(err, null);
-        test.equals(result, true);
-        test.done();
-    });
-};
-
-exports['every false'] = function(test){
-    test.expect(2);
-    async.every([1,2,3], function(x, callback){
-        setTimeout(function(){callback(null, x % 2);}, 0);
-    }, function(err, result){
-        test.equals(err, null);
-        test.equals(result, false);
-        test.done();
-    });
-};
-
-exports['every early return'] = function(test){
-    test.expect(1);
-    var call_order = [];
-    async.every([1,2,3], function(x, callback){
-        setTimeout(function(){
-            call_order.push(x);
-            callback(null, x === 1);
-        }, x*25);
-    }, function(){
-        call_order.push('callback');
-    });
-    setTimeout(function(){
-        test.same(call_order, [1,2,'callback',3]);
-        test.done();
-    }, 100);
-};
-
-exports['every error'] = function(test){
-    async.every([1,2,3], function(x, callback){
-        setTimeout(function(){callback('error');}, 0);
-    }, function(err, result){
-        test.equals(err, 'error');
-        test.equals(result, null);
-        test.done();
-    });
-};
-
-exports['all alias'] = function(test){
-    test.equals(async.all, async.every);
-    test.done();
-};
-
-exports['detect'] = function(test){
-    test.expect(3);
-    var call_order = [];
-    async.detect([3,2,1], detectIterator.bind(this, call_order), function(err, result){
-        call_order.push('callback');
-        test.equals(err, null);
-        test.equals(result, 2);
-    });
-    setTimeout(function(){
-        test.same(call_order, [1,2,'callback',3]);
-        test.done();
-    }, 100);
-};
-
-exports['detect - mulitple matches'] = function(test){
-    test.expect(3);
-    var call_order = [];
-    async.detect([3,2,2,1,2], detectIterator.bind(this, call_order), function(err, result){
-        call_order.push('callback');
-        test.equals(err, null);
-        test.equals(result, 2);
-    });
-    setTimeout(function(){
-        test.same(call_order, [1,2,'callback',2,2,3]);
-        test.done();
-    }, 100);
-};
-
-exports['detect error'] = function(test){
-    test.expect(2);
-    async.detect([3,2,1], function(x, callback) {
-        setTimeout(function(){callback('error');}, 0);
-    }, function(err, result){
-        test.equals(err, 'error');
-        test.equals(result, null);
-        test.done();
-    });
-};
-
-exports['detectSeries'] = function(test){
-    test.expect(3);
-    var call_order = [];
-    async.detectSeries([3,2,1], detectIterator.bind(this, call_order), function(err, result){
-        call_order.push('callback');
-        test.equals(err, null);
-        test.equals(result, 2);
-    });
-    setTimeout(function(){
-        test.same(call_order, [3,2,'callback']);
-        test.done();
-    }, 200);
-};
-
-exports['detectSeries - multiple matches'] = function(test){
-    test.expect(3);
-    var call_order = [];
-    async.detectSeries([3,2,2,1,2], detectIterator.bind(this, call_order), function(err, result){
-        call_order.push('callback');
-        test.equals(err, null);
-        test.equals(result, 2);
-    });
-    setTimeout(function(){
-        test.same(call_order, [3,2,'callback']);
-        test.done();
-    }, 200);
-};
-
-exports['detectSeries - ensure stop'] = function (test) {
-    test.expect(2);
-    async.detectSeries([1, 2, 3, 4, 5], function (num, cb) {
-        if (num > 3) throw new Error("detectSeries did not stop iterating");
-        cb(null, num === 3);
-    }, function (err, result) {
-        test.equals(err, null);
-        test.equals(result, 3);
-        test.done();
-    });
-};
-
-exports['detectLimit'] = function(test){
-    test.expect(3);
-    var call_order = [];
-    async.detectLimit([3, 2, 1], 2, detectIterator.bind(this, call_order), function(err, result) {
-        call_order.push('callback');
-        test.equals(err, null);
-        test.equals(result, 2);
-    });
-    setTimeout(function() {
-        test.same(call_order, [2, 'callback', 3]);
-        test.done();
-    }, 100);
-};
-
-exports['detectLimit - multiple matches'] = function(test){
-    test.expect(3);
-    var call_order = [];
-    async.detectLimit([3,2,2,1,2], 2, detectIterator.bind(this, call_order), function(err, result){
-        call_order.push('callback');
-        test.equals(err, null);
-        test.equals(result, 2);
-    });
-    setTimeout(function(){
-        test.same(call_order, [2, 'callback', 3]);
-        test.done();
-    }, 100);
-};
-
-exports['detectLimit - ensure stop'] = function (test) {
-    test.expect(2);
-    async.detectLimit([1, 2, 3, 4, 5], 2, function (num, cb) {
-        if (num > 4) throw new Error("detectLimit did not stop iterating");
-        cb(null, num === 3);
-    }, function (err, result) {
-        test.equals(err, null);
-        test.equals(result, 3);
-        test.done();
-    });
-};
-
 exports['sortBy'] = function(test){
     test.expect(2);