diff --git a/index.js b/index.js
index 4964516..e0d9b0f 100644
--- a/index.js
+++ b/index.js
@@ -596,10 +596,9 @@ function processParams (params, layer, called, req, res, done) {
 
     paramIndex = 0
     key = keys[i++]
-    name = key.name
-    paramVal = req.params[name]
-    paramCallbacks = params[name]
-    paramCalled = called[name]
+    paramVal = req.params[key]
+    paramCallbacks = params[key]
+    paramCalled = called[key]
 
     if (paramVal === undefined || !paramCallbacks) {
       return param()
@@ -609,13 +608,13 @@ function processParams (params, layer, called, req, res, done) {
     if (paramCalled && (paramCalled.match === paramVal ||
       (paramCalled.error && paramCalled.error !== 'route'))) {
       // restore value
-      req.params[name] = paramCalled.value
+      req.params[key] = paramCalled.value
 
       // next param
       return param(paramCalled.error)
     }
 
-    called[name] = paramCalled = {
+    called[key] = paramCalled = {
       error: null,
       match: paramVal,
       value: paramVal
@@ -629,7 +628,7 @@ function processParams (params, layer, called, req, res, done) {
     var fn = paramCallbacks[paramIndex++]
 
     // store updated value
-    paramCalled.value = req.params[key.name]
+    paramCalled.value = req.params[key]
 
     if (err) {
       // store error
@@ -641,7 +640,7 @@ function processParams (params, layer, called, req, res, done) {
     if (!fn) return param()
 
     try {
-      var ret = fn(req, res, paramCallback, paramVal, key.name)
+      var ret = fn(req, res, paramCallback, paramVal, key)
       if (isPromise(ret)) {
         ret.then(null, function (error) {
           paramCallback(error || new Error('Rejected promise'))
diff --git a/lib/layer.js b/lib/layer.js
index 73f7d69..e335599 100644
--- a/lib/layer.js
+++ b/lib/layer.js
@@ -20,7 +20,6 @@ var pathRegexp = require('path-to-regexp')
  * @private
  */
 
-var hasOwnProperty = Object.prototype.hasOwnProperty
 var TRAILING_SLASH_REGEXP = /\/+$/
 
 /**
@@ -41,10 +40,27 @@ function Layer (path, options, fn) {
   this.name = fn.name || '<anonymous>'
   this.params = undefined
   this.path = undefined
-  this.regexp = pathRegexp((opts.strict ? path : loosen(path)), this.keys, opts)
-
-  // set fast path flags
-  this.regexp._slash = path === '/' && opts.end === false
+  this.slash = path === '/' && opts.end === false
+
+  var matchers = []
+
+  function addMatcher (_path) {
+    var matcher = pathRegexp.match((opts.strict ? _path : loosen(_path)), {
+      sensitive: opts.sensitive,
+      end: opts.end,
+      trailing: !opts.strict,
+      decode: decodeParam
+    })
+    matchers.push(matcher)
+  }
+  if (Array.isArray(path)) {
+    for (var p of path) {
+      addMatcher(p)
+    }
+  } else {
+    addMatcher(path)
+  }
+  this.matchers = matchers
 }
 
 /**
@@ -123,17 +139,20 @@ Layer.prototype.handleRequest = function handleRequest (req, res, next) {
 
 Layer.prototype.match = function match (path) {
   var match
-
   if (path != null) {
     // fast path non-ending match for / (any path matches)
-    if (this.regexp._slash) {
+    if (this.slash) {
       this.params = {}
       this.path = ''
       return true
     }
 
-    // match the path
-    match = this.regexp.exec(path)
+    var i = 0;
+    while (!match && i < this.matchers.length) {
+      // match the path
+      match = this.matchers[i](path)
+      i++;
+    }
   }
 
   if (!match) {
@@ -143,22 +162,9 @@ Layer.prototype.match = function match (path) {
   }
 
   // store values
-  this.params = {}
-  this.path = match[0]
-
-  // iterate matches
-  var keys = this.keys
-  var params = this.params
-
-  for (var i = 1; i < match.length; i++) {
-    var key = keys[i - 1]
-    var prop = key.name
-    var val = decodeParam(match[i])
-
-    if (val !== undefined || !(hasOwnProperty.call(params, prop))) {
-      params[prop] = val
-    }
-  }
+  this.params = match.params
+  this.path = match.path
+  this.keys = Object.keys(match.params)
 
   return true
 }
@@ -192,7 +198,7 @@ function decodeParam (val) {
  * Loosens the given path for path-to-regexp matching.
  */
 function loosen (path) {
-  if (path instanceof RegExp) {
+  if (path instanceof RegExp || path === '/') {
     return path
   }
 
diff --git a/package.json b/package.json
index 1016e69..70e51ab 100644
--- a/package.json
+++ b/package.json
@@ -29,6 +29,7 @@
     "finalhandler": "1.2.0",
     "mocha": "10.2.0",
     "nyc": "15.1.0",
+    "run-series": "^1.1.9",
     "safe-buffer": "5.2.1",
     "supertest": "6.3.3"
   },
@@ -46,6 +47,7 @@
   "scripts": {
     "lint": "eslint .",
     "test": "mocha --reporter spec --bail --check-leaks test/",
+    "test:debug": "mocha --reporter spec --bail --check-leaks test/ --inspect --inspect-brk",
     "test-ci": "nyc --reporter=lcov --reporter=text npm test",
     "test-cov": "nyc --reporter=text npm test",
     "version": "node scripts/version-history.js && git add HISTORY.md"
diff --git a/test/param.js b/test/param.js
index e2ca379..2374e9b 100644
--- a/test/param.js
+++ b/test/param.js
@@ -1,5 +1,6 @@
 
 var after = require('after')
+var series = require('run-series')
 var Router = require('..')
 var utils = require('./support/utils')
 
@@ -300,7 +301,6 @@ describe('Router', function () {
 
     describe('next("route")', function () {
       it('should cause route with param to be skipped', function (done) {
-        var cb = after(3, done)
         var router = new Router()
         var server = createServer(router)
 
@@ -326,17 +326,23 @@ describe('Router', function () {
           res.end('cannot get a new user')
         })
 
-        request(server)
-          .get('/user/2')
-          .expect(200, 'get user 2', cb)
-
-        request(server)
-          .get('/user/bob')
-          .expect(404, cb)
-
-        request(server)
-          .get('/user/new')
-          .expect(400, 'cannot get a new user', cb)
+        series([
+          function (cb) {
+            request(server)
+              .get('/user/2')
+              .expect(200, 'get user 2', cb)
+          },
+          function (cb) {
+            request(server)
+              .get('/user/bob')
+              .expect(404, cb)
+          },
+          function (cb) {
+            request(server)
+              .get('/user/new')
+              .expect(400, 'cannot get a new user', cb)
+          }
+        ], done)
       })
 
       it('should invoke fn if path value differs', function (done) {
diff --git a/test/req.params.js b/test/req.params.js
index 4a0e01b..9210e8c 100644
--- a/test/req.params.js
+++ b/test/req.params.js
@@ -124,46 +124,6 @@ describe('req.params', function () {
         .expect('x-params-1', '{"foo":"buzz"}')
         .expect(200, '{"foo":"bar"}', done)
     })
-
-    describe('with numeric properties in req.params', function () {
-      it('should merge numeric properties by offsetting', function (done) {
-        var router = Router({ mergeParams: true })
-        var server = createServer(function (req, res, next) {
-          req.params = { 0: 'foo', 1: 'bar' }
-
-          router(req, res, function (err) {
-            if (err) return next(err)
-            sawParams(req, res)
-          })
-        })
-
-        router.get('/(.*)', hitParams(1))
-
-        request(server)
-          .get('/buzz')
-          .expect('x-params-1', '{"0":"foo","1":"bar","2":"buzz"}')
-          .expect(200, '{"0":"foo","1":"bar"}', done)
-      })
-
-      it('should merge with same numeric properties', function (done) {
-        var router = Router({ mergeParams: true })
-        var server = createServer(function (req, res, next) {
-          req.params = { 0: 'foo' }
-
-          router(req, res, function (err) {
-            if (err) return next(err)
-            sawParams(req, res)
-          })
-        })
-
-        router.get('/(.*)', hitParams(1))
-
-        request(server)
-          .get('/bar')
-          .expect('x-params-1', '{"0":"foo","1":"bar"}')
-          .expect(200, '{"0":"foo"}', done)
-      })
-    })
   })
 })
 
diff --git a/test/route.js b/test/route.js
index fcd6f8b..d90d46f 100644
--- a/test/route.js
+++ b/test/route.js
@@ -2,6 +2,7 @@
 var after = require('after')
 var Buffer = require('safe-buffer').Buffer
 var methods = require('methods')
+var series = require('run-series')
 var Router = require('..')
 var utils = require('./support/utils')
 
@@ -25,7 +26,6 @@ describe('Router', function () {
     })
 
     it('should respond to multiple methods', function (done) {
-      var cb = after(3, done)
       var router = new Router()
       var route = router.route('/foo')
       var server = createServer(router)
@@ -33,17 +33,23 @@ describe('Router', function () {
       route.get(saw)
       route.post(saw)
 
-      request(server)
-        .get('/foo')
-        .expect(200, 'saw GET /foo', cb)
-
-      request(server)
-        .post('/foo')
-        .expect(200, 'saw POST /foo', cb)
-
-      request(server)
-        .put('/foo')
-        .expect(404, cb)
+      series([
+        function (cb) {
+          request(server)
+            .get('/foo')
+            .expect(200, 'saw GET /foo', cb)
+        },
+        function (cb) {
+          request(server)
+            .post('/foo')
+            .expect(200, 'saw POST /foo', cb)
+        },
+        function (cb) {
+          request(server)
+            .put('/foo')
+            .expect(404, cb)
+        }
+      ], done)
     })
 
     it('should route without method', function (done) {
@@ -169,24 +175,29 @@ describe('Router', function () {
       })
 
       it('should respond to all methods', function (done) {
-        var cb = after(3, done)
         var router = new Router()
         var route = router.route('/foo')
         var server = createServer(router)
 
         route.all(saw)
 
-        request(server)
-          .get('/foo')
-          .expect(200, 'saw GET /foo', cb)
-
-        request(server)
-          .post('/foo')
-          .expect(200, 'saw POST /foo', cb)
-
-        request(server)
-          .put('/foo')
-          .expect(200, 'saw PUT /foo', cb)
+        series([
+          function (cb) {
+            request(server)
+              .get('/foo')
+              .expect(200, 'saw GET /foo', cb)
+          },
+          function (cb) {
+            request(server)
+              .post('/foo')
+              .expect(200, 'saw POST /foo', cb)
+          },
+          function (cb) {
+            request(server)
+              .put('/foo')
+              .expect(200, 'saw PUT /foo', cb)
+          }
+        ], done)
       })
 
       it('should accept multiple arguments', function (done) {
@@ -694,23 +705,6 @@ describe('Router', function () {
             .expect(200, { foo: 'fizz', bar: 'buzz' }, done)
         })
 
-        it('should work following a partial capture group', function (done) {
-          var cb = after(2, done)
-          var router = new Router()
-          var route = router.route('/user(s?)/:user/:op')
-          var server = createServer(router)
-
-          route.all(sendParams)
-
-          request(server)
-            .get('/user/tj/edit')
-            .expect(200, { 0: '', user: 'tj', op: 'edit' }, cb)
-
-          request(server)
-            .get('/users/tj/edit')
-            .expect(200, { 0: 's', user: 'tj', op: 'edit' }, cb)
-        })
-
         it('should work inside literal paranthesis', function (done) {
           var router = new Router()
           var route = router.route('/:user\\(:op\\)')
@@ -724,85 +718,105 @@ describe('Router', function () {
         })
 
         it('should work within arrays', function (done) {
-          var cb = after(2, done)
           var router = new Router()
-          var route = router.route(['/user/:user/poke', '/user/:user/pokes'])
+          var route = router.route([
+            '/user/:user/poke',
+            '/user/:user/pokes'
+          ])
           var server = createServer(router)
 
           route.all(sendParams)
 
-          request(server)
-            .get('/user/tj/poke')
-            .expect(200, { user: 'tj' }, cb)
-
-          request(server)
-            .get('/user/tj/pokes')
-            .expect(200, { user: 'tj' }, cb)
+          series([
+            function (cb) {
+              request(server)
+                .get('/user/tj/poke')
+                .expect(200, { user: 'tj' }, cb)
+            },
+            function (cb) {
+              request(server)
+                .get('/user/tj/pokes')
+                .expect(200, { user: 'tj' }, cb)
+            }
+          ], done)
         })
       })
 
-      describe('using ":name?"', function () {
+      describe('using "{:name}"', function () {
         it('should name an optional parameter', function (done) {
-          var cb = after(2, done)
           var router = new Router()
-          var route = router.route('/:foo?')
+          var route = router.route('{/:foo}')
           var server = createServer(router)
 
           route.all(sendParams)
 
-          request(server)
-            .get('/bar')
-            .expect(200, { foo: 'bar' }, cb)
-
-          request(server)
-            .get('/')
-            .expect(200, {}, cb)
+          series([
+            function (cb) {
+              request(server)
+                .get('/bar')
+                .expect(200, { foo: 'bar' }, cb)
+            },
+            function (cb) {
+              request(server)
+                .get('/')
+                .expect(200, {}, cb)
+            }
+          ], done)
         })
 
         it('should work in any segment', function (done) {
-          var cb = after(2, done)
           var router = new Router()
-          var route = router.route('/user/:foo?/delete')
+          var route = router.route('/user{/:foo}/delete')
           var server = createServer(router)
 
           route.all(sendParams)
 
-          request(server)
-            .get('/user/bar/delete')
-            .expect(200, { foo: 'bar' }, cb)
-
-          request(server)
-            .get('/user/delete')
-            .expect(200, {}, cb)
+          series([
+            function (cb) {
+              request(server)
+                .get('/user/bar/delete')
+                .expect(200, { foo: 'bar' }, cb)
+            },
+            function (cb) {
+              request(server)
+                .get('/user/delete')
+                .expect(200, {}, cb)
+            }
+          ], done)
         })
       })
 
-      describe('using ":name*"', function () {
+      describe('using "*name"', function () {
         it('should name a zero-or-more repeated parameter', function (done) {
-          var cb = after(3, done)
           var router = new Router()
-          var route = router.route('/:foo*')
+          var route = router.route('{/*foo}')
           var server = createServer(router)
 
           route.all(sendParams)
 
-          request(server)
-            .get('/')
-            .expect(200, {}, cb)
-
-          request(server)
-            .get('/bar')
-            .expect(200, { foo: 'bar' }, cb)
-
-          request(server)
-            .get('/fizz/buzz')
-            .expect(200, { foo: 'fizz/buzz' }, cb)
+          series([
+            function (cb) {
+              request(server)
+                .get('/')
+                .expect(200, {}, cb)
+            },
+            function (cb) {
+              request(server)
+                .get('/bar')
+                .expect(200, { foo: [ 'bar' ] }, cb)
+            },
+            function (cb) {
+              request(server)
+                .get('/fizz/buzz')
+                .expect(200, { foo: [ 'fizz', 'buzz' ] }, cb)
+            }
+          ], done)
         })
 
         it('should work in any segment', function (done) {
           var cb = after(3, done)
           var router = new Router()
-          var route = router.route('/user/:foo*/delete')
+          var route = router.route('/user{/*foo}/delete')
           var server = createServer(router)
 
           route.all(sendParams)
@@ -813,114 +827,11 @@ describe('Router', function () {
 
           request(server)
             .get('/user/bar/delete')
-            .expect(200, { foo: 'bar' }, cb)
-
-          request(server)
-            .get('/user/fizz/buzz/delete')
-            .expect(200, { foo: 'fizz/buzz' }, cb)
-        })
-      })
-
-      describe('using ":name+"', function () {
-        it('should name a one-or-more repeated parameter', function (done) {
-          var cb = after(3, done)
-          var router = new Router()
-          var route = router.route('/:foo+')
-          var server = createServer(router)
-
-          route.all(sendParams)
-
-          request(server)
-            .get('/')
-            .expect(404, cb)
-
-          request(server)
-            .get('/bar')
-            .expect(200, { foo: 'bar' }, cb)
-
-          request(server)
-            .get('/fizz/buzz')
-            .expect(200, { foo: 'fizz/buzz' }, cb)
-        })
-
-        it('should work in any segment', function (done) {
-          var cb = after(3, done)
-          var router = new Router()
-          var route = router.route('/user/:foo+/delete')
-          var server = createServer(router)
-
-          route.all(sendParams)
-
-          request(server)
-            .get('/user/delete')
-            .expect(404, cb)
-
-          request(server)
-            .get('/user/bar/delete')
-            .expect(200, { foo: 'bar' }, cb)
+            .expect(200, { foo: [ 'bar' ] }, cb)
 
           request(server)
             .get('/user/fizz/buzz/delete')
-            .expect(200, { foo: 'fizz/buzz' }, cb)
-        })
-      })
-
-      describe('using ":name(regexp)"', function () {
-        it('should limit capture group to regexp match', function (done) {
-          var cb = after(2, done)
-          var router = new Router()
-          var route = router.route('/:foo([0-9]+)')
-          var server = createServer(router)
-
-          route.all(sendParams)
-
-          request(server)
-            .get('/foo')
-            .expect(404, cb)
-
-          request(server)
-            .get('/42')
-            .expect(200, { foo: '42' }, cb)
-        })
-      })
-
-      describe('using "(regexp)"', function () {
-        it('should add capture group using regexp', function (done) {
-          var cb = after(2, done)
-          var router = new Router()
-          var route = router.route('/page_([0-9]+)')
-          var server = createServer(router)
-
-          route.all(sendParams)
-
-          request(server)
-            .get('/page_foo')
-            .expect(404, cb)
-
-          request(server)
-            .get('/page_42')
-            .expect(200, { 0: '42' }, cb)
-        })
-
-        it('should treat regexp as literal regexp', function (done) {
-          var cb = after(3, done)
-          var router = new Router()
-          var route = router.route('/([a-z]+:n[0-9]+)')
-          var server = createServer(router)
-
-          route.all(sendParams)
-
-          request(server)
-            .get('/foo:bar')
-            .expect(404, cb)
-
-          request(server)
-            .get('/foo:n')
-            .expect(404, cb)
-
-          request(server)
-            .get('/foo:n42')
-            .expect(200, { 0: 'foo:n42' }, cb)
+            .expect(200, { foo: [ 'fizz', 'buzz' ] }, cb)
         })
       })
     })
diff --git a/test/router.js b/test/router.js
index 7af8186..ed8fb26 100644
--- a/test/router.js
+++ b/test/router.js
@@ -2,6 +2,7 @@
 var after = require('after')
 var Buffer = require('safe-buffer').Buffer
 var methods = require('methods')
+var series = require('run-series')
 var Router = require('..')
 var utils = require('./support/utils')
 
@@ -44,26 +45,27 @@ describe('Router', function () {
     })
 
     it('should respond to all methods', function (done) {
-      var cb = after(methods.length, done)
       var router = new Router()
       var server = createServer(router)
       router.all('/', helloWorld)
 
-      methods.forEach(function (method) {
+      series(methods.map(function (method) {
         if (method === 'connect') {
           // CONNECT is tricky and supertest doesn't support it
-          return cb()
+          return function (cb) { cb() }
         }
 
-        var body = method !== 'head'
-          ? shouldHaveBody(Buffer.from('hello, world'))
-          : shouldNotHaveBody()
+        return function (cb) {
+          var body = method !== 'head'
+            ? shouldHaveBody(Buffer.from('hello, world'))
+            : shouldNotHaveBody()
 
-        request(server)[method]('/')
-          .expect(200)
-          .expect(body)
-          .end(cb)
-      })
+          request(server)[method]('/')
+            .expect(200)
+            .expect(body)
+            .end(cb)
+        }
+      }), done)
     })
 
     it('should support array of paths', function (done) {
@@ -73,61 +75,53 @@ describe('Router', function () {
 
       router.all(['/foo', '/bar'], saw)
 
-      request(server)
-        .get('/')
-        .expect(404, cb)
-
-      request(server)
-        .get('/foo')
-        .expect(200, 'saw GET /foo', cb)
-
-      request(server)
-        .get('/bar')
-        .expect(200, 'saw GET /bar', cb)
-    })
-
-    it('should support regexp path', function (done) {
-      var cb = after(3, done)
-      var router = new Router()
-      var server = createServer(router)
-
-      router.all(/^\/[a-z]oo$/, saw)
-
-      request(server)
-        .get('/')
-        .expect(404, cb)
-
-      request(server)
-        .get('/foo')
-        .expect(200, 'saw GET /foo', cb)
-
-      request(server)
-        .get('/zoo')
-        .expect(200, 'saw GET /zoo', cb)
+      series([
+        function (cb) {
+          request(server)
+            .get('/')
+            .expect(404, cb)
+        },
+        function (cb) {
+          request(server)
+            .get('/foo')
+            .expect(200, 'saw GET /foo', cb)
+        },
+        function (cb) {
+          request(server)
+            .get('/bar')
+            .expect(200, 'saw GET /bar', cb)
+        }
+      ], done)
     })
 
     it('should support parameterized path', function (done) {
-      var cb = after(4, done)
       var router = new Router()
       var server = createServer(router)
 
       router.all('/:thing', saw)
 
-      request(server)
-        .get('/')
-        .expect(404, cb)
-
-      request(server)
-        .get('/foo')
-        .expect(200, 'saw GET /foo', cb)
-
-      request(server)
-        .get('/bar')
-        .expect(200, 'saw GET /bar', cb)
-
-      request(server)
-        .get('/foo/bar')
-        .expect(404, cb)
+      series([
+        function (cb) {
+          request(server)
+            .get('/')
+            .expect(404, cb)
+        },
+        function (cb) {
+          request(server)
+            .get('/foo')
+            .expect(200, 'saw GET /foo', cb)
+        },
+        function (cb) {
+          request(server)
+            .get('/bar')
+            .expect(200, 'saw GET /bar', cb)
+        },
+        function (cb) {
+          request(server)
+            .get('/foo/bar')
+            .expect(404, cb)
+        },
+      ], done)
     })
 
     it('should not stack overflow with many registered routes', function (done) {
@@ -206,23 +200,29 @@ describe('Router', function () {
       })
 
       it('should match paths case-sensitively when true', function (done) {
-        var cb = after(3, done)
         var router = new Router({ caseSensitive: true })
         var server = createServer(router)
 
         router.all('/foo/bar', saw)
 
-        request(server)
-          .get('/foo/bar')
-          .expect(200, 'saw GET /foo/bar', cb)
+        series([
+          function (cb) {
+            request(server)
+              .get('/foo/bar')
+              .expect(200, 'saw GET /foo/bar', cb)
+          },
+          function (cb) {
+            request(server)
+              .get('/FOO/bar')
+              .expect(404, cb)
+          },
+          function (cb) {
+            request(server)
+              .get('/FOO/BAR')
+              .expect(404, cb)
+          }
+        ], done);
 
-        request(server)
-          .get('/FOO/bar')
-          .expect(404, cb)
-
-        request(server)
-          .get('/FOO/BAR')
-          .expect(404, cb)
       })
     })
 
@@ -260,19 +260,23 @@ describe('Router', function () {
       })
 
       it('should not accept optional trailing slashes when true', function (done) {
-        var cb = after(2, done)
         var router = new Router({ strict: true })
         var server = createServer(router)
 
         router.all('/foo', saw)
 
-        request(server)
-          .get('/foo')
-          .expect(200, 'saw GET /foo', cb)
-
-        request(server)
-          .get('/foo/')
-          .expect(404, cb)
+        series([
+          function (cb) {
+            request(server)
+              .get('/foo')
+              .expect(200, 'saw GET /foo', cb)
+          },
+          function (cb) {
+            request(server)
+              .get('/foo/')
+              .expect(404, cb)
+          }
+        ], done)
       })
     })
   })
@@ -311,83 +315,69 @@ describe('Router', function () {
       })
 
       it('should support array of paths', function (done) {
-        var cb = after(3, done)
         var router = new Router()
         var server = createServer(router)
 
         router[method](['/foo', '/bar'], createHitHandle(1), helloWorld)
 
-        request(server)[method]('/')
-          .expect(404)
-          .expect(shouldNotHitHandle(1))
-          .end(cb)
-
-        request(server)[method]('/foo')
-          .expect(200)
-          .expect(shouldHitHandle(1))
-          .expect(body)
-          .end(cb)
-
-        request(server)[method]('/bar')
-          .expect(200)
-          .expect(shouldHitHandle(1))
-          .expect(body)
-          .end(cb)
-      })
-
-      it('should support regexp path', function (done) {
-        var cb = after(3, done)
-        var router = new Router()
-        var server = createServer(router)
-
-        router[method](/^\/[a-z]oo$/, createHitHandle(1), helloWorld)
-
-        request(server)[method]('/')
-          .expect(404)
-          .expect(shouldNotHitHandle(1))
-          .end(cb)
-
-        request(server)[method]('/foo')
-          .expect(200)
-          .expect(shouldHitHandle(1))
-          .expect(body)
-          .end(cb)
-
-        request(server)[method]('/zoo')
-          .expect(200)
-          .expect(shouldHitHandle(1))
-          .expect(body)
-          .end(cb)
+        series([
+          function (cb) {
+            request(server)[method]('/')
+              .expect(404)
+              .expect(shouldNotHitHandle(1))
+              .end(cb)
+          },
+          function (cb) {
+            request(server)[method]('/foo')
+              .expect(200)
+              .expect(shouldHitHandle(1))
+              .expect(body)
+              .end(cb)
+          },
+          function (cb) {
+            request(server)[method]('/bar')
+              .expect(200)
+              .expect(shouldHitHandle(1))
+              .expect(body)
+              .end(cb)
+          }
+        ], done)
       })
 
       it('should support parameterized path', function (done) {
-        var cb = after(4, done)
         var router = new Router()
         var server = createServer(router)
 
         router[method]('/:thing', createHitHandle(1), helloWorld)
 
-        request(server)[method]('/')
-          .expect(404)
-          .expect(shouldNotHitHandle(1))
-          .end(cb)
-
-        request(server)[method]('/foo')
-          .expect(200)
-          .expect(shouldHitHandle(1))
-          .expect(body)
-          .end(cb)
-
-        request(server)[method]('/bar')
-          .expect(200)
-          .expect(shouldHitHandle(1))
-          .expect(body)
-          .end(cb)
-
-        request(server)[method]('/foo/bar')
-          .expect(404)
-          .expect(shouldNotHitHandle(1))
-          .end(cb)
+        series([
+          function (cb) {
+            request(server)[method]('/')
+              .expect(404)
+              .expect(shouldNotHitHandle(1))
+              .end(cb)
+          },
+          function (cb) {
+            request(server)[method]('/foo')
+              .expect(200)
+              .expect(shouldHitHandle(1))
+              .expect(body)
+              .end(cb)
+          },
+          function (cb) {
+            request(server)[method]('/bar')
+              .expect(200)
+              .expect(shouldHitHandle(1))
+              .expect(body)
+              .end(cb)
+          },
+          function (cb) {
+            request(server)[method]('/foo/bar')
+              .expect(404)
+              .expect(shouldNotHitHandle(1))
+              .end(cb)
+          }
+        ], done)
       })
 
       it('should accept multiple arguments', function (done) {
@@ -477,27 +467,33 @@ describe('Router', function () {
     })
 
     it('should invoke function for all requests', function (done) {
-      var cb = after(4, done)
       var router = new Router()
       var server = createServer(router)
 
       router.use(saw)
 
-      request(server)
-        .get('/')
-        .expect(200, 'saw GET /', cb)
-
-      request(server)
-        .put('/')
-        .expect(200, 'saw PUT /', cb)
-
-      request(server)
-        .post('/foo')
-        .expect(200, 'saw POST /foo', cb)
-
-      rawrequest(server)
-        .options('*')
-        .expect(200, 'saw OPTIONS *', cb)
+      series([
+        function (cb) {
+          request(server)
+            .get('/')
+            .expect(200, 'saw GET /', cb)
+        },
+        function (cb) {
+          request(server)
+            .put('/')
+            .expect(200, 'saw PUT /', cb)
+        },
+        function (cb) {
+          request(server)
+            .post('/foo')
+            .expect(200, 'saw POST /foo', cb)
+        },
+        function (cb) {
+          rawrequest(server)
+            .options('*')
+            .expect(200, 'saw OPTIONS *', cb)
+        },
+      ], done)
     })
 
     it('should not invoke for blank URLs', function (done) {
@@ -929,73 +925,34 @@ describe('Router', function () {
         .expect(200, 'saw GET /', cb)
     })
 
-    it('should support regexp path', function (done) {
-      var cb = after(5, done)
-      var router = new Router()
-      var server = createServer(router)
-
-      router.use(/^\/[a-z]oo/, saw)
-
-      request(server)
-        .get('/')
-        .expect(404, cb)
-
-      request(server)
-        .get('/foo')
-        .expect(200, 'saw GET /', cb)
-
-      request(server)
-        .get('/fooo')
-        .expect(404, cb)
-
-      request(server)
-        .get('/zoo/bear')
-        .expect(200, 'saw GET /bear', cb)
-
-      request(server)
-        .get('/get/zoo')
-        .expect(404, cb)
-    })
-
-    it('should ensure regexp matches path prefix', function (done) {
-      var router = new Router()
-      var server = createServer(router)
-
-      router.use(/\/api.*/, createHitHandle(1))
-      router.use(/api/, createHitHandle(2))
-      router.use(/\/test/, createHitHandle(3))
-      router.use(helloWorld)
-
-      request(server)
-        .get('/test/api/1234')
-        .expect(shouldNotHitHandle(1))
-        .expect(shouldNotHitHandle(2))
-        .expect(shouldHitHandle(3))
-        .expect(200, done)
-    })
-
     it('should support parameterized path', function (done) {
-      var cb = after(4, done)
       var router = new Router()
       var server = createServer(router)
 
       router.use('/:thing', saw)
 
-      request(server)
-        .get('/')
-        .expect(404, cb)
-
-      request(server)
-        .get('/foo')
-        .expect(200, 'saw GET /', cb)
-
-      request(server)
-        .get('/bar')
-        .expect(200, 'saw GET /', cb)
-
-      request(server)
-        .get('/foo/bar')
-        .expect(200, 'saw GET /bar', cb)
+      series([
+        function (cb) {
+          request(server)
+            .get('/')
+            .expect(404, cb)
+        },
+        function (cb) {
+          request(server)
+            .get('/foo')
+            .expect(200, 'saw GET /', cb)
+        },
+        function (cb) {
+          request(server)
+            .get('/bar')
+            .expect(200, 'saw GET /', cb)
+        },
+        function (cb) {
+          request(server)
+            .get('/foo/bar')
+            .expect(200, 'saw GET /bar', cb)
+        }
+      ], done)
     })
 
     it('should accept multiple arguments', function (done) {
@@ -1053,23 +1010,29 @@ describe('Router', function () {
       })
 
       it('should match paths case-sensitively when true', function (done) {
-        var cb = after(3, done)
         var router = new Router({ caseSensitive: true })
         var server = createServer(router)
 
         router.use('/foo', saw)
 
-        request(server)
-          .get('/foo/bar')
-          .expect(200, 'saw GET /bar', cb)
-
-        request(server)
-          .get('/FOO/bar')
-          .expect(404, cb)
-
-        request(server)
-          .get('/FOO/BAR')
-          .expect(404, cb)
+        series([
+          function (cb) {
+            request(server)
+              .get('/foo/bar')
+              .expect(200, 'saw GET /bar', cb)
+          },
+          function (cb) {
+            request(server)
+              .get('/FOO/bar')
+              .expect(404, cb)
+          },
+          function (cb) {
+            request(server)
+              .get('/FOO/BAR')
+              .expect(404, cb)
+
+          },
+        ], done)
       })
     })