Depenancy upgrades and movign to dep. (#8630)

7 files changed, 0 insertions, 3559 deletions

diff --git a/vendor/github.com/gorilla/mux/bench_test.go b/vendor/github.com/gorilla/mux/bench_test.go
deleted file mode 100644
index 522156dcc..000000000
--- a/vendor/github.com/gorilla/mux/bench_test.go
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2012 The Gorilla Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package mux
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func BenchmarkMux(b *testing.B) {
-	router := new(Router)
-	handler := func(w http.ResponseWriter, r *http.Request) {}
-	router.HandleFunc("/v1/{v1}", handler)
-
-	request, _ := http.NewRequest("GET", "/v1/anything", nil)
-	for i := 0; i < b.N; i++ {
-		router.ServeHTTP(nil, request)
-	}
-}
-
-func BenchmarkMuxAlternativeInRegexp(b *testing.B) {
-	router := new(Router)
-	handler := func(w http.ResponseWriter, r *http.Request) {}
-	router.HandleFunc("/v1/{v1:(?:a|b)}", handler)
-
-	requestA, _ := http.NewRequest("GET", "/v1/a", nil)
-	requestB, _ := http.NewRequest("GET", "/v1/b", nil)
-	for i := 0; i < b.N; i++ {
-		router.ServeHTTP(nil, requestA)
-		router.ServeHTTP(nil, requestB)
-	}
-}
-
-func BenchmarkManyPathVariables(b *testing.B) {
-	router := new(Router)
-	handler := func(w http.ResponseWriter, r *http.Request) {}
-	router.HandleFunc("/v1/{v1}/{v2}/{v3}/{v4}/{v5}", handler)
-
-	matchingRequest, _ := http.NewRequest("GET", "/v1/1/2/3/4/5", nil)
-	notMatchingRequest, _ := http.NewRequest("GET", "/v1/1/2/3/4", nil)
-	recorder := httptest.NewRecorder()
-	for i := 0; i < b.N; i++ {
-		router.ServeHTTP(nil, matchingRequest)
-		router.ServeHTTP(recorder, notMatchingRequest)
-	}
-}
diff --git a/vendor/github.com/gorilla/mux/context_gorilla_test.go b/vendor/github.com/gorilla/mux/context_gorilla_test.go
deleted file mode 100644
index ffaf384c0..000000000
--- a/vendor/github.com/gorilla/mux/context_gorilla_test.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// +build !go1.7
-
-package mux
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/gorilla/context"
-)
-
-// Tests that the context is cleared or not cleared properly depending on
-// the configuration of the router
-func TestKeepContext(t *testing.T) {
-	func1 := func(w http.ResponseWriter, r *http.Request) {}
-
-	r := NewRouter()
-	r.HandleFunc("/", func1).Name("func1")
-
-	req, _ := http.NewRequest("GET", "http://localhost/", nil)
-	context.Set(req, "t", 1)
-
-	res := new(http.ResponseWriter)
-	r.ServeHTTP(*res, req)
-
-	if _, ok := context.GetOk(req, "t"); ok {
-		t.Error("Context should have been cleared at end of request")
-	}
-
-	r.KeepContext = true
-
-	req, _ = http.NewRequest("GET", "http://localhost/", nil)
-	context.Set(req, "t", 1)
-
-	r.ServeHTTP(*res, req)
-	if _, ok := context.GetOk(req, "t"); !ok {
-		t.Error("Context should NOT have been cleared at end of request")
-	}
-
-}
diff --git a/vendor/github.com/gorilla/mux/context_native_test.go b/vendor/github.com/gorilla/mux/context_native_test.go
deleted file mode 100644
index c150edf01..000000000
--- a/vendor/github.com/gorilla/mux/context_native_test.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// +build go1.7
-
-package mux
-
-import (
-	"context"
-	"net/http"
-	"testing"
-	"time"
-)
-
-func TestNativeContextMiddleware(t *testing.T) {
-	withTimeout := func(h http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			ctx, cancel := context.WithTimeout(r.Context(), time.Minute)
-			defer cancel()
-			h.ServeHTTP(w, r.WithContext(ctx))
-		})
-	}
-
-	r := NewRouter()
-	r.Handle("/path/{foo}", withTimeout(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		vars := Vars(r)
-		if vars["foo"] != "bar" {
-			t.Fatal("Expected foo var to be set")
-		}
-	})))
-
-	rec := NewRecorder()
-	req := newRequest("GET", "/path/bar")
-	r.ServeHTTP(rec, req)
-}
diff --git a/vendor/github.com/gorilla/mux/example_route_test.go b/vendor/github.com/gorilla/mux/example_route_test.go
deleted file mode 100644
index 112557071..000000000
--- a/vendor/github.com/gorilla/mux/example_route_test.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package mux_test
-
-import (
-	"fmt"
-	"net/http"
-
-	"github.com/gorilla/mux"
-)
-
-// This example demonstrates setting a regular expression matcher for
-// the header value. A plain word will match any value that contains a
-// matching substring as if the pattern was wrapped with `.*`.
-func ExampleRoute_HeadersRegexp() {
-	r := mux.NewRouter()
-	route := r.NewRoute().HeadersRegexp("Accept", "html")
-
-	req1, _ := http.NewRequest("GET", "example.com", nil)
-	req1.Header.Add("Accept", "text/plain")
-	req1.Header.Add("Accept", "text/html")
-
-	req2, _ := http.NewRequest("GET", "example.com", nil)
-	req2.Header.Set("Accept", "application/xhtml+xml")
-
-	matchInfo := &mux.RouteMatch{}
-	fmt.Printf("Match: %v %q\n", route.Match(req1, matchInfo), req1.Header["Accept"])
-	fmt.Printf("Match: %v %q\n", route.Match(req2, matchInfo), req2.Header["Accept"])
-	// Output:
-	// Match: true ["text/plain" "text/html"]
-	// Match: true ["application/xhtml+xml"]
-}
-
-// This example demonstrates setting a strict regular expression matcher
-// for the header value. Using the start and end of string anchors, the
-// value must be an exact match.
-func ExampleRoute_HeadersRegexp_exactMatch() {
-	r := mux.NewRouter()
-	route := r.NewRoute().HeadersRegexp("Origin", "^https://example.co$")
-
-	yes, _ := http.NewRequest("GET", "example.co", nil)
-	yes.Header.Set("Origin", "https://example.co")
-
-	no, _ := http.NewRequest("GET", "example.co.uk", nil)
-	no.Header.Set("Origin", "https://example.co.uk")
-
-	matchInfo := &mux.RouteMatch{}
-	fmt.Printf("Match: %v %q\n", route.Match(yes, matchInfo), yes.Header["Origin"])
-	fmt.Printf("Match: %v %q\n", route.Match(no, matchInfo), no.Header["Origin"])
-	// Output:
-	// Match: true ["https://example.co"]
-	// Match: false ["https://example.co.uk"]
-}
diff --git a/vendor/github.com/gorilla/mux/middleware_test.go b/vendor/github.com/gorilla/mux/middleware_test.go
deleted file mode 100644
index 93947e8cb..000000000
--- a/vendor/github.com/gorilla/mux/middleware_test.go
+++ /dev/null
@@ -1,336 +0,0 @@
-package mux
-
-import (
-	"bytes"
-	"net/http"
-	"testing"
-)
-
-type testMiddleware struct {
-	timesCalled uint
-}
-
-func (tm *testMiddleware) Middleware(h http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		tm.timesCalled++
-		h.ServeHTTP(w, r)
-	})
-}
-
-func dummyHandler(w http.ResponseWriter, r *http.Request) {}
-
-func TestMiddlewareAdd(t *testing.T) {
-	router := NewRouter()
-	router.HandleFunc("/", dummyHandler).Methods("GET")
-
-	mw := &testMiddleware{}
-
-	router.useInterface(mw)
-	if len(router.middlewares) != 1 || router.middlewares[0] != mw {
-		t.Fatal("Middleware was not added correctly")
-	}
-
-	router.Use(mw.Middleware)
-	if len(router.middlewares) != 2 {
-		t.Fatal("MiddlewareFunc method was not added correctly")
-	}
-
-	banalMw := func(handler http.Handler) http.Handler {
-		return handler
-	}
-	router.Use(banalMw)
-	if len(router.middlewares) != 3 {
-		t.Fatal("MiddlewareFunc method was not added correctly")
-	}
-}
-
-func TestMiddleware(t *testing.T) {
-	router := NewRouter()
-	router.HandleFunc("/", dummyHandler).Methods("GET")
-
-	mw := &testMiddleware{}
-	router.useInterface(mw)
-
-	rw := NewRecorder()
-	req := newRequest("GET", "/")
-
-	// Test regular middleware call
-	router.ServeHTTP(rw, req)
-	if mw.timesCalled != 1 {
-		t.Fatalf("Expected %d calls, but got only %d", 1, mw.timesCalled)
-	}
-
-	// Middleware should not be called for 404
-	req = newRequest("GET", "/not/found")
-	router.ServeHTTP(rw, req)
-	if mw.timesCalled != 1 {
-		t.Fatalf("Expected %d calls, but got only %d", 1, mw.timesCalled)
-	}
-
-	// Middleware should not be called if there is a method mismatch
-	req = newRequest("POST", "/")
-	router.ServeHTTP(rw, req)
-	if mw.timesCalled != 1 {
-		t.Fatalf("Expected %d calls, but got only %d", 1, mw.timesCalled)
-	}
-
-	// Add the middleware again as function
-	router.Use(mw.Middleware)
-	req = newRequest("GET", "/")
-	router.ServeHTTP(rw, req)
-	if mw.timesCalled != 3 {
-		t.Fatalf("Expected %d calls, but got only %d", 3, mw.timesCalled)
-	}
-
-}
-
-func TestMiddlewareSubrouter(t *testing.T) {
-	router := NewRouter()
-	router.HandleFunc("/", dummyHandler).Methods("GET")
-
-	subrouter := router.PathPrefix("/sub").Subrouter()
-	subrouter.HandleFunc("/x", dummyHandler).Methods("GET")
-
-	mw := &testMiddleware{}
-	subrouter.useInterface(mw)
-
-	rw := NewRecorder()
-	req := newRequest("GET", "/")
-
-	router.ServeHTTP(rw, req)
-	if mw.timesCalled != 0 {
-		t.Fatalf("Expected %d calls, but got only %d", 0, mw.timesCalled)
-	}
-
-	req = newRequest("GET", "/sub/")
-	router.ServeHTTP(rw, req)
-	if mw.timesCalled != 0 {
-		t.Fatalf("Expected %d calls, but got only %d", 0, mw.timesCalled)
-	}
-
-	req = newRequest("GET", "/sub/x")
-	router.ServeHTTP(rw, req)
-	if mw.timesCalled != 1 {
-		t.Fatalf("Expected %d calls, but got only %d", 1, mw.timesCalled)
-	}
-
-	req = newRequest("GET", "/sub/not/found")
-	router.ServeHTTP(rw, req)
-	if mw.timesCalled != 1 {
-		t.Fatalf("Expected %d calls, but got only %d", 1, mw.timesCalled)
-	}
-
-	router.useInterface(mw)
-
-	req = newRequest("GET", "/")
-	router.ServeHTTP(rw, req)
-	if mw.timesCalled != 2 {
-		t.Fatalf("Expected %d calls, but got only %d", 2, mw.timesCalled)
-	}
-
-	req = newRequest("GET", "/sub/x")
-	router.ServeHTTP(rw, req)
-	if mw.timesCalled != 4 {
-		t.Fatalf("Expected %d calls, but got only %d", 4, mw.timesCalled)
-	}
-}
-
-func TestMiddlewareExecution(t *testing.T) {
-	mwStr := []byte("Middleware\n")
-	handlerStr := []byte("Logic\n")
-
-	router := NewRouter()
-	router.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
-		w.Write(handlerStr)
-	})
-
-	rw := NewRecorder()
-	req := newRequest("GET", "/")
-
-	// Test handler-only call
-	router.ServeHTTP(rw, req)
-
-	if bytes.Compare(rw.Body.Bytes(), handlerStr) != 0 {
-		t.Fatal("Handler response is not what it should be")
-	}
-
-	// Test middleware call
-	rw = NewRecorder()
-
-	router.Use(func(h http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Write(mwStr)
-			h.ServeHTTP(w, r)
-		})
-	})
-
-	router.ServeHTTP(rw, req)
-	if bytes.Compare(rw.Body.Bytes(), append(mwStr, handlerStr...)) != 0 {
-		t.Fatal("Middleware + handler response is not what it should be")
-	}
-}
-
-func TestMiddlewareNotFound(t *testing.T) {
-	mwStr := []byte("Middleware\n")
-	handlerStr := []byte("Logic\n")
-
-	router := NewRouter()
-	router.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
-		w.Write(handlerStr)
-	})
-	router.Use(func(h http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Write(mwStr)
-			h.ServeHTTP(w, r)
-		})
-	})
-
-	// Test not found call with default handler
-	rw := NewRecorder()
-	req := newRequest("GET", "/notfound")
-
-	router.ServeHTTP(rw, req)
-	if bytes.Contains(rw.Body.Bytes(), mwStr) {
-		t.Fatal("Middleware was called for a 404")
-	}
-
-	// Test not found call with custom handler
-	rw = NewRecorder()
-	req = newRequest("GET", "/notfound")
-
-	router.NotFoundHandler = http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
-		rw.Write([]byte("Custom 404 handler"))
-	})
-	router.ServeHTTP(rw, req)
-
-	if bytes.Contains(rw.Body.Bytes(), mwStr) {
-		t.Fatal("Middleware was called for a custom 404")
-	}
-}
-
-func TestMiddlewareMethodMismatch(t *testing.T) {
-	mwStr := []byte("Middleware\n")
-	handlerStr := []byte("Logic\n")
-
-	router := NewRouter()
-	router.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
-		w.Write(handlerStr)
-	}).Methods("GET")
-
-	router.Use(func(h http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Write(mwStr)
-			h.ServeHTTP(w, r)
-		})
-	})
-
-	// Test method mismatch
-	rw := NewRecorder()
-	req := newRequest("POST", "/")
-
-	router.ServeHTTP(rw, req)
-	if bytes.Contains(rw.Body.Bytes(), mwStr) {
-		t.Fatal("Middleware was called for a method mismatch")
-	}
-
-	// Test not found call
-	rw = NewRecorder()
-	req = newRequest("POST", "/")
-
-	router.MethodNotAllowedHandler = http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
-		rw.Write([]byte("Method not allowed"))
-	})
-	router.ServeHTTP(rw, req)
-
-	if bytes.Contains(rw.Body.Bytes(), mwStr) {
-		t.Fatal("Middleware was called for a method mismatch")
-	}
-}
-
-func TestMiddlewareNotFoundSubrouter(t *testing.T) {
-	mwStr := []byte("Middleware\n")
-	handlerStr := []byte("Logic\n")
-
-	router := NewRouter()
-	router.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
-		w.Write(handlerStr)
-	})
-
-	subrouter := router.PathPrefix("/sub/").Subrouter()
-	subrouter.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
-		w.Write(handlerStr)
-	})
-
-	router.Use(func(h http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Write(mwStr)
-			h.ServeHTTP(w, r)
-		})
-	})
-
-	// Test not found call for default handler
-	rw := NewRecorder()
-	req := newRequest("GET", "/sub/notfound")
-
-	router.ServeHTTP(rw, req)
-	if bytes.Contains(rw.Body.Bytes(), mwStr) {
-		t.Fatal("Middleware was called for a 404")
-	}
-
-	// Test not found call with custom handler
-	rw = NewRecorder()
-	req = newRequest("GET", "/sub/notfound")
-
-	subrouter.NotFoundHandler = http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
-		rw.Write([]byte("Custom 404 handler"))
-	})
-	router.ServeHTTP(rw, req)
-
-	if bytes.Contains(rw.Body.Bytes(), mwStr) {
-		t.Fatal("Middleware was called for a custom 404")
-	}
-}
-
-func TestMiddlewareMethodMismatchSubrouter(t *testing.T) {
-	mwStr := []byte("Middleware\n")
-	handlerStr := []byte("Logic\n")
-
-	router := NewRouter()
-	router.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
-		w.Write(handlerStr)
-	})
-
-	subrouter := router.PathPrefix("/sub/").Subrouter()
-	subrouter.HandleFunc("/", func(w http.ResponseWriter, e *http.Request) {
-		w.Write(handlerStr)
-	}).Methods("GET")
-
-	router.Use(func(h http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Write(mwStr)
-			h.ServeHTTP(w, r)
-		})
-	})
-
-	// Test method mismatch without custom handler
-	rw := NewRecorder()
-	req := newRequest("POST", "/sub/")
-
-	router.ServeHTTP(rw, req)
-	if bytes.Contains(rw.Body.Bytes(), mwStr) {
-		t.Fatal("Middleware was called for a method mismatch")
-	}
-
-	// Test method mismatch with custom handler
-	rw = NewRecorder()
-	req = newRequest("POST", "/sub/")
-
-	router.MethodNotAllowedHandler = http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
-		rw.Write([]byte("Method not allowed"))
-	})
-	router.ServeHTTP(rw, req)
-
-	if bytes.Contains(rw.Body.Bytes(), mwStr) {
-		t.Fatal("Middleware was called for a method mismatch")
-	}
-}
diff --git a/vendor/github.com/gorilla/mux/mux_test.go b/vendor/github.com/gorilla/mux/mux_test.go
deleted file mode 100644
index 9e93c9830..000000000
--- a/vendor/github.com/gorilla/mux/mux_test.go
+++ /dev/null
@@ -1,2347 +0,0 @@
-// Copyright 2012 The Gorilla Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package mux
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/url"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func (r *Route) GoString() string {
-	matchers := make([]string, len(r.matchers))
-	for i, m := range r.matchers {
-		matchers[i] = fmt.Sprintf("%#v", m)
-	}
-	return fmt.Sprintf("&Route{matchers:[]matcher{%s}}", strings.Join(matchers, ", "))
-}
-
-func (r *routeRegexp) GoString() string {
-	return fmt.Sprintf("&routeRegexp{template: %q, regexpType: %v, options: %v, regexp: regexp.MustCompile(%q), reverse: %q, varsN: %v, varsR: %v", r.template, r.regexpType, r.options, r.regexp.String(), r.reverse, r.varsN, r.varsR)
-}
-
-type routeTest struct {
-	title           string            // title of the test
-	route           *Route            // the route being tested
-	request         *http.Request     // a request to test the route
-	vars            map[string]string // the expected vars of the match
-	scheme          string            // the expected scheme of the built URL
-	host            string            // the expected host of the built URL
-	path            string            // the expected path of the built URL
-	query           string            // the expected query string of the built URL
-	pathTemplate    string            // the expected path template of the route
-	hostTemplate    string            // the expected host template of the route
-	queriesTemplate string            // the expected query template of the route
-	methods         []string          // the expected route methods
-	pathRegexp      string            // the expected path regexp
-	queriesRegexp   string            // the expected query regexp
-	shouldMatch     bool              // whether the request is expected to match the route at all
-	shouldRedirect  bool              // whether the request should result in a redirect
-}
-
-func TestHost(t *testing.T) {
-	// newRequestHost a new request with a method, url, and host header
-	newRequestHost := func(method, url, host string) *http.Request {
-		req, err := http.NewRequest(method, url, nil)
-		if err != nil {
-			panic(err)
-		}
-		req.Host = host
-		return req
-	}
-
-	tests := []routeTest{
-		{
-			title:       "Host route match",
-			route:       new(Route).Host("aaa.bbb.ccc"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:        map[string]string{},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host route, wrong host in request URL",
-			route:       new(Route).Host("aaa.bbb.ccc"),
-			request:     newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:        map[string]string{},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: false,
-		},
-		{
-			title:       "Host route with port, match",
-			route:       new(Route).Host("aaa.bbb.ccc:1234"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc:1234/111/222/333"),
-			vars:        map[string]string{},
-			host:        "aaa.bbb.ccc:1234",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host route with port, wrong port in request URL",
-			route:       new(Route).Host("aaa.bbb.ccc:1234"),
-			request:     newRequest("GET", "http://aaa.bbb.ccc:9999/111/222/333"),
-			vars:        map[string]string{},
-			host:        "aaa.bbb.ccc:1234",
-			path:        "",
-			shouldMatch: false,
-		},
-		{
-			title:       "Host route, match with host in request header",
-			route:       new(Route).Host("aaa.bbb.ccc"),
-			request:     newRequestHost("GET", "/111/222/333", "aaa.bbb.ccc"),
-			vars:        map[string]string{},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Host route, wrong host in request header",
-			route:       new(Route).Host("aaa.bbb.ccc"),
-			request:     newRequestHost("GET", "/111/222/333", "aaa.222.ccc"),
-			vars:        map[string]string{},
-			host:        "aaa.bbb.ccc",
-			path:        "",
-			shouldMatch: false,
-		},
-		// BUG {new(Route).Host("aaa.bbb.ccc:1234"), newRequestHost("GET", "/111/222/333", "aaa.bbb.ccc:1234"), map[string]string{}, "aaa.bbb.ccc:1234", "", true},
-		{
-			title:       "Host route with port, wrong host in request header",
-			route:       new(Route).Host("aaa.bbb.ccc:1234"),
-			request:     newRequestHost("GET", "/111/222/333", "aaa.bbb.ccc:9999"),
-			vars:        map[string]string{},
-			host:        "aaa.bbb.ccc:1234",
-			path:        "",
-			shouldMatch: false,
-		},
-		{
-			title:        "Host route with pattern, match",
-			route:        new(Route).Host("aaa.{v1:[a-z]{3}}.ccc"),
-			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{"v1": "bbb"},
-			host:         "aaa.bbb.ccc",
-			path:         "",
-			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Host route with pattern, additional capturing group, match",
-			route:        new(Route).Host("aaa.{v1:[a-z]{2}(?:b|c)}.ccc"),
-			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{"v1": "bbb"},
-			host:         "aaa.bbb.ccc",
-			path:         "",
-			hostTemplate: `aaa.{v1:[a-z]{2}(?:b|c)}.ccc`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Host route with pattern, wrong host in request URL",
-			route:        new(Route).Host("aaa.{v1:[a-z]{3}}.ccc"),
-			request:      newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:         map[string]string{"v1": "bbb"},
-			host:         "aaa.bbb.ccc",
-			path:         "",
-			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc`,
-			shouldMatch:  false,
-		},
-		{
-			title:        "Host route with multiple patterns, match",
-			route:        new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}"),
-			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc"},
-			host:         "aaa.bbb.ccc",
-			path:         "",
-			hostTemplate: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Host route with multiple patterns, wrong host in request URL",
-			route:        new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}"),
-			request:      newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:         map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc"},
-			host:         "aaa.bbb.ccc",
-			path:         "",
-			hostTemplate: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
-			shouldMatch:  false,
-		},
-		{
-			title:        "Host route with hyphenated name and pattern, match",
-			route:        new(Route).Host("aaa.{v-1:[a-z]{3}}.ccc"),
-			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{"v-1": "bbb"},
-			host:         "aaa.bbb.ccc",
-			path:         "",
-			hostTemplate: `aaa.{v-1:[a-z]{3}}.ccc`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Host route with hyphenated name and pattern, additional capturing group, match",
-			route:        new(Route).Host("aaa.{v-1:[a-z]{2}(?:b|c)}.ccc"),
-			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{"v-1": "bbb"},
-			host:         "aaa.bbb.ccc",
-			path:         "",
-			hostTemplate: `aaa.{v-1:[a-z]{2}(?:b|c)}.ccc`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Host route with multiple hyphenated names and patterns, match",
-			route:        new(Route).Host("{v-1:[a-z]{3}}.{v-2:[a-z]{3}}.{v-3:[a-z]{3}}"),
-			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{"v-1": "aaa", "v-2": "bbb", "v-3": "ccc"},
-			host:         "aaa.bbb.ccc",
-			path:         "",
-			hostTemplate: `{v-1:[a-z]{3}}.{v-2:[a-z]{3}}.{v-3:[a-z]{3}}`,
-			shouldMatch:  true,
-		},
-	}
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-	}
-}
-
-func TestPath(t *testing.T) {
-	tests := []routeTest{
-		{
-			title:       "Path route, match",
-			route:       new(Route).Path("/111/222/333"),
-			request:     newRequest("GET", "http://localhost/111/222/333"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "/111/222/333",
-			shouldMatch: true,
-		},
-		{
-			title:       "Path route, match with trailing slash in request and path",
-			route:       new(Route).Path("/111/"),
-			request:     newRequest("GET", "http://localhost/111/"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "/111/",
-			shouldMatch: true,
-		},
-		{
-			title:        "Path route, do not match with trailing slash in path",
-			route:        new(Route).Path("/111/"),
-			request:      newRequest("GET", "http://localhost/111"),
-			vars:         map[string]string{},
-			host:         "",
-			path:         "/111",
-			pathTemplate: `/111/`,
-			pathRegexp:   `^/111/$`,
-			shouldMatch:  false,
-		},
-		{
-			title:        "Path route, do not match with trailing slash in request",
-			route:        new(Route).Path("/111"),
-			request:      newRequest("GET", "http://localhost/111/"),
-			vars:         map[string]string{},
-			host:         "",
-			path:         "/111/",
-			pathTemplate: `/111`,
-			shouldMatch:  false,
-		},
-		{
-			title:        "Path route, match root with no host",
-			route:        new(Route).Path("/"),
-			request:      newRequest("GET", "/"),
-			vars:         map[string]string{},
-			host:         "",
-			path:         "/",
-			pathTemplate: `/`,
-			pathRegexp:   `^/$`,
-			shouldMatch:  true,
-		},
-		{
-			title: "Path route, match root with no host, App Engine format",
-			route: new(Route).Path("/"),
-			request: func() *http.Request {
-				r := newRequest("GET", "http://localhost/")
-				r.RequestURI = "/"
-				return r
-			}(),
-			vars:         map[string]string{},
-			host:         "",
-			path:         "/",
-			pathTemplate: `/`,
-			shouldMatch:  true,
-		},
-		{
-			title:       "Path route, wrong path in request in request URL",
-			route:       new(Route).Path("/111/222/333"),
-			request:     newRequest("GET", "http://localhost/1/2/3"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "/111/222/333",
-			shouldMatch: false,
-		},
-		{
-			title:        "Path route with pattern, match",
-			route:        new(Route).Path("/111/{v1:[0-9]{3}}/333"),
-			request:      newRequest("GET", "http://localhost/111/222/333"),
-			vars:         map[string]string{"v1": "222"},
-			host:         "",
-			path:         "/111/222/333",
-			pathTemplate: `/111/{v1:[0-9]{3}}/333`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with pattern, URL in request does not match",
-			route:        new(Route).Path("/111/{v1:[0-9]{3}}/333"),
-			request:      newRequest("GET", "http://localhost/111/aaa/333"),
-			vars:         map[string]string{"v1": "222"},
-			host:         "",
-			path:         "/111/222/333",
-			pathTemplate: `/111/{v1:[0-9]{3}}/333`,
-			pathRegexp:   `^/111/(?P<v0>[0-9]{3})/333$`,
-			shouldMatch:  false,
-		},
-		{
-			title:        "Path route with multiple patterns, match",
-			route:        new(Route).Path("/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}"),
-			request:      newRequest("GET", "http://localhost/111/222/333"),
-			vars:         map[string]string{"v1": "111", "v2": "222", "v3": "333"},
-			host:         "",
-			path:         "/111/222/333",
-			pathTemplate: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}`,
-			pathRegexp:   `^/(?P<v0>[0-9]{3})/(?P<v1>[0-9]{3})/(?P<v2>[0-9]{3})$`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with multiple patterns, URL in request does not match",
-			route:        new(Route).Path("/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}"),
-			request:      newRequest("GET", "http://localhost/111/aaa/333"),
-			vars:         map[string]string{"v1": "111", "v2": "222", "v3": "333"},
-			host:         "",
-			path:         "/111/222/333",
-			pathTemplate: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}/{v3:[0-9]{3}}`,
-			pathRegexp:   `^/(?P<v0>[0-9]{3})/(?P<v1>[0-9]{3})/(?P<v2>[0-9]{3})$`,
-			shouldMatch:  false,
-		},
-		{
-			title:        "Path route with multiple patterns with pipe, match",
-			route:        new(Route).Path("/{category:a|(?:b/c)}/{product}/{id:[0-9]+}"),
-			request:      newRequest("GET", "http://localhost/a/product_name/1"),
-			vars:         map[string]string{"category": "a", "product": "product_name", "id": "1"},
-			host:         "",
-			path:         "/a/product_name/1",
-			pathTemplate: `/{category:a|(?:b/c)}/{product}/{id:[0-9]+}`,
-			pathRegexp:   `^/(?P<v0>a|(?:b/c))/(?P<v1>[^/]+)/(?P<v2>[0-9]+)$`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with hyphenated name and pattern, match",
-			route:        new(Route).Path("/111/{v-1:[0-9]{3}}/333"),
-			request:      newRequest("GET", "http://localhost/111/222/333"),
-			vars:         map[string]string{"v-1": "222"},
-			host:         "",
-			path:         "/111/222/333",
-			pathTemplate: `/111/{v-1:[0-9]{3}}/333`,
-			pathRegexp:   `^/111/(?P<v0>[0-9]{3})/333$`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with multiple hyphenated names and patterns, match",
-			route:        new(Route).Path("/{v-1:[0-9]{3}}/{v-2:[0-9]{3}}/{v-3:[0-9]{3}}"),
-			request:      newRequest("GET", "http://localhost/111/222/333"),
-			vars:         map[string]string{"v-1": "111", "v-2": "222", "v-3": "333"},
-			host:         "",
-			path:         "/111/222/333",
-			pathTemplate: `/{v-1:[0-9]{3}}/{v-2:[0-9]{3}}/{v-3:[0-9]{3}}`,
-			pathRegexp:   `^/(?P<v0>[0-9]{3})/(?P<v1>[0-9]{3})/(?P<v2>[0-9]{3})$`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with multiple hyphenated names and patterns with pipe, match",
-			route:        new(Route).Path("/{product-category:a|(?:b/c)}/{product-name}/{product-id:[0-9]+}"),
-			request:      newRequest("GET", "http://localhost/a/product_name/1"),
-			vars:         map[string]string{"product-category": "a", "product-name": "product_name", "product-id": "1"},
-			host:         "",
-			path:         "/a/product_name/1",
-			pathTemplate: `/{product-category:a|(?:b/c)}/{product-name}/{product-id:[0-9]+}`,
-			pathRegexp:   `^/(?P<v0>a|(?:b/c))/(?P<v1>[^/]+)/(?P<v2>[0-9]+)$`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with multiple hyphenated names and patterns with pipe and case insensitive, match",
-			route:        new(Route).Path("/{type:(?i:daily|mini|variety)}-{date:\\d{4,4}-\\d{2,2}-\\d{2,2}}"),
-			request:      newRequest("GET", "http://localhost/daily-2016-01-01"),
-			vars:         map[string]string{"type": "daily", "date": "2016-01-01"},
-			host:         "",
-			path:         "/daily-2016-01-01",
-			pathTemplate: `/{type:(?i:daily|mini|variety)}-{date:\d{4,4}-\d{2,2}-\d{2,2}}`,
-			pathRegexp:   `^/(?P<v0>(?i:daily|mini|variety))-(?P<v1>\d{4,4}-\d{2,2}-\d{2,2})$`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with empty match right after other match",
-			route:        new(Route).Path(`/{v1:[0-9]*}{v2:[a-z]*}/{v3:[0-9]*}`),
-			request:      newRequest("GET", "http://localhost/111/222"),
-			vars:         map[string]string{"v1": "111", "v2": "", "v3": "222"},
-			host:         "",
-			path:         "/111/222",
-			pathTemplate: `/{v1:[0-9]*}{v2:[a-z]*}/{v3:[0-9]*}`,
-			pathRegexp:   `^/(?P<v0>[0-9]*)(?P<v1>[a-z]*)/(?P<v2>[0-9]*)$`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with single pattern with pipe, match",
-			route:        new(Route).Path("/{category:a|b/c}"),
-			request:      newRequest("GET", "http://localhost/a"),
-			vars:         map[string]string{"category": "a"},
-			host:         "",
-			path:         "/a",
-			pathTemplate: `/{category:a|b/c}`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with single pattern with pipe, match",
-			route:        new(Route).Path("/{category:a|b/c}"),
-			request:      newRequest("GET", "http://localhost/b/c"),
-			vars:         map[string]string{"category": "b/c"},
-			host:         "",
-			path:         "/b/c",
-			pathTemplate: `/{category:a|b/c}`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with multiple patterns with pipe, match",
-			route:        new(Route).Path("/{category:a|b/c}/{product}/{id:[0-9]+}"),
-			request:      newRequest("GET", "http://localhost/a/product_name/1"),
-			vars:         map[string]string{"category": "a", "product": "product_name", "id": "1"},
-			host:         "",
-			path:         "/a/product_name/1",
-			pathTemplate: `/{category:a|b/c}/{product}/{id:[0-9]+}`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Path route with multiple patterns with pipe, match",
-			route:        new(Route).Path("/{category:a|b/c}/{product}/{id:[0-9]+}"),
-			request:      newRequest("GET", "http://localhost/b/c/product_name/1"),
-			vars:         map[string]string{"category": "b/c", "product": "product_name", "id": "1"},
-			host:         "",
-			path:         "/b/c/product_name/1",
-			pathTemplate: `/{category:a|b/c}/{product}/{id:[0-9]+}`,
-			shouldMatch:  true,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-		testUseEscapedRoute(t, test)
-		testRegexp(t, test)
-	}
-}
-
-func TestPathPrefix(t *testing.T) {
-	tests := []routeTest{
-		{
-			title:       "PathPrefix route, match",
-			route:       new(Route).PathPrefix("/111"),
-			request:     newRequest("GET", "http://localhost/111/222/333"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "/111",
-			shouldMatch: true,
-		},
-		{
-			title:       "PathPrefix route, match substring",
-			route:       new(Route).PathPrefix("/1"),
-			request:     newRequest("GET", "http://localhost/111/222/333"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "/1",
-			shouldMatch: true,
-		},
-		{
-			title:       "PathPrefix route, URL prefix in request does not match",
-			route:       new(Route).PathPrefix("/111"),
-			request:     newRequest("GET", "http://localhost/1/2/3"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "/111",
-			shouldMatch: false,
-		},
-		{
-			title:        "PathPrefix route with pattern, match",
-			route:        new(Route).PathPrefix("/111/{v1:[0-9]{3}}"),
-			request:      newRequest("GET", "http://localhost/111/222/333"),
-			vars:         map[string]string{"v1": "222"},
-			host:         "",
-			path:         "/111/222",
-			pathTemplate: `/111/{v1:[0-9]{3}}`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "PathPrefix route with pattern, URL prefix in request does not match",
-			route:        new(Route).PathPrefix("/111/{v1:[0-9]{3}}"),
-			request:      newRequest("GET", "http://localhost/111/aaa/333"),
-			vars:         map[string]string{"v1": "222"},
-			host:         "",
-			path:         "/111/222",
-			pathTemplate: `/111/{v1:[0-9]{3}}`,
-			shouldMatch:  false,
-		},
-		{
-			title:        "PathPrefix route with multiple patterns, match",
-			route:        new(Route).PathPrefix("/{v1:[0-9]{3}}/{v2:[0-9]{3}}"),
-			request:      newRequest("GET", "http://localhost/111/222/333"),
-			vars:         map[string]string{"v1": "111", "v2": "222"},
-			host:         "",
-			path:         "/111/222",
-			pathTemplate: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "PathPrefix route with multiple patterns, URL prefix in request does not match",
-			route:        new(Route).PathPrefix("/{v1:[0-9]{3}}/{v2:[0-9]{3}}"),
-			request:      newRequest("GET", "http://localhost/111/aaa/333"),
-			vars:         map[string]string{"v1": "111", "v2": "222"},
-			host:         "",
-			path:         "/111/222",
-			pathTemplate: `/{v1:[0-9]{3}}/{v2:[0-9]{3}}`,
-			shouldMatch:  false,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-		testUseEscapedRoute(t, test)
-	}
-}
-
-func TestSchemeHostPath(t *testing.T) {
-	tests := []routeTest{
-		{
-			title:        "Host and Path route, match",
-			route:        new(Route).Host("aaa.bbb.ccc").Path("/111/222/333"),
-			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{},
-			scheme:       "http",
-			host:         "aaa.bbb.ccc",
-			path:         "/111/222/333",
-			pathTemplate: `/111/222/333`,
-			hostTemplate: `aaa.bbb.ccc`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Scheme, Host, and Path route, match",
-			route:        new(Route).Schemes("https").Host("aaa.bbb.ccc").Path("/111/222/333"),
-			request:      newRequest("GET", "https://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{},
-			scheme:       "https",
-			host:         "aaa.bbb.ccc",
-			path:         "/111/222/333",
-			pathTemplate: `/111/222/333`,
-			hostTemplate: `aaa.bbb.ccc`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Host and Path route, wrong host in request URL",
-			route:        new(Route).Host("aaa.bbb.ccc").Path("/111/222/333"),
-			request:      newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:         map[string]string{},
-			scheme:       "http",
-			host:         "aaa.bbb.ccc",
-			path:         "/111/222/333",
-			pathTemplate: `/111/222/333`,
-			hostTemplate: `aaa.bbb.ccc`,
-			shouldMatch:  false,
-		},
-		{
-			title:        "Host and Path route with pattern, match",
-			route:        new(Route).Host("aaa.{v1:[a-z]{3}}.ccc").Path("/111/{v2:[0-9]{3}}/333"),
-			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{"v1": "bbb", "v2": "222"},
-			scheme:       "http",
-			host:         "aaa.bbb.ccc",
-			path:         "/111/222/333",
-			pathTemplate: `/111/{v2:[0-9]{3}}/333`,
-			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Scheme, Host, and Path route with host and path patterns, match",
-			route:        new(Route).Schemes("ftp", "ssss").Host("aaa.{v1:[a-z]{3}}.ccc").Path("/111/{v2:[0-9]{3}}/333"),
-			request:      newRequest("GET", "ssss://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{"v1": "bbb", "v2": "222"},
-			scheme:       "ftp",
-			host:         "aaa.bbb.ccc",
-			path:         "/111/222/333",
-			pathTemplate: `/111/{v2:[0-9]{3}}/333`,
-			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Host and Path route with pattern, URL in request does not match",
-			route:        new(Route).Host("aaa.{v1:[a-z]{3}}.ccc").Path("/111/{v2:[0-9]{3}}/333"),
-			request:      newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:         map[string]string{"v1": "bbb", "v2": "222"},
-			scheme:       "http",
-			host:         "aaa.bbb.ccc",
-			path:         "/111/222/333",
-			pathTemplate: `/111/{v2:[0-9]{3}}/333`,
-			hostTemplate: `aaa.{v1:[a-z]{3}}.ccc`,
-			shouldMatch:  false,
-		},
-		{
-			title:        "Host and Path route with multiple patterns, match",
-			route:        new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}").Path("/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}"),
-			request:      newRequest("GET", "http://aaa.bbb.ccc/111/222/333"),
-			vars:         map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc", "v4": "111", "v5": "222", "v6": "333"},
-			scheme:       "http",
-			host:         "aaa.bbb.ccc",
-			path:         "/111/222/333",
-			pathTemplate: `/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}`,
-			hostTemplate: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Host and Path route with multiple patterns, URL in request does not match",
-			route:        new(Route).Host("{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}").Path("/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}"),
-			request:      newRequest("GET", "http://aaa.222.ccc/111/222/333"),
-			vars:         map[string]string{"v1": "aaa", "v2": "bbb", "v3": "ccc", "v4": "111", "v5": "222", "v6": "333"},
-			scheme:       "http",
-			host:         "aaa.bbb.ccc",
-			path:         "/111/222/333",
-			pathTemplate: `/{v4:[0-9]{3}}/{v5:[0-9]{3}}/{v6:[0-9]{3}}`,
-			hostTemplate: `{v1:[a-z]{3}}.{v2:[a-z]{3}}.{v3:[a-z]{3}}`,
-			shouldMatch:  false,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-		testUseEscapedRoute(t, test)
-	}
-}
-
-func TestHeaders(t *testing.T) {
-	// newRequestHeaders creates a new request with a method, url, and headers
-	newRequestHeaders := func(method, url string, headers map[string]string) *http.Request {
-		req, err := http.NewRequest(method, url, nil)
-		if err != nil {
-			panic(err)
-		}
-		for k, v := range headers {
-			req.Header.Add(k, v)
-		}
-		return req
-	}
-
-	tests := []routeTest{
-		{
-			title:       "Headers route, match",
-			route:       new(Route).Headers("foo", "bar", "baz", "ding"),
-			request:     newRequestHeaders("GET", "http://localhost", map[string]string{"foo": "bar", "baz": "ding"}),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "Headers route, bad header values",
-			route:       new(Route).Headers("foo", "bar", "baz", "ding"),
-			request:     newRequestHeaders("GET", "http://localhost", map[string]string{"foo": "bar", "baz": "dong"}),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			shouldMatch: false,
-		},
-		{
-			title:       "Headers route, regex header values to match",
-			route:       new(Route).Headers("foo", "ba[zr]"),
-			request:     newRequestHeaders("GET", "http://localhost", map[string]string{"foo": "bar"}),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			shouldMatch: false,
-		},
-		{
-			title:       "Headers route, regex header values to match",
-			route:       new(Route).HeadersRegexp("foo", "ba[zr]"),
-			request:     newRequestHeaders("GET", "http://localhost", map[string]string{"foo": "baz"}),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			shouldMatch: true,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-	}
-}
-
-func TestMethods(t *testing.T) {
-	tests := []routeTest{
-		{
-			title:       "Methods route, match GET",
-			route:       new(Route).Methods("GET", "POST"),
-			request:     newRequest("GET", "http://localhost"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			methods:     []string{"GET", "POST"},
-			shouldMatch: true,
-		},
-		{
-			title:       "Methods route, match POST",
-			route:       new(Route).Methods("GET", "POST"),
-			request:     newRequest("POST", "http://localhost"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			methods:     []string{"GET", "POST"},
-			shouldMatch: true,
-		},
-		{
-			title:       "Methods route, bad method",
-			route:       new(Route).Methods("GET", "POST"),
-			request:     newRequest("PUT", "http://localhost"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			methods:     []string{"GET", "POST"},
-			shouldMatch: false,
-		},
-		{
-			title:       "Route without methods",
-			route:       new(Route),
-			request:     newRequest("PUT", "http://localhost"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			methods:     []string{},
-			shouldMatch: true,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-		testMethods(t, test)
-	}
-}
-
-func TestQueries(t *testing.T) {
-	tests := []routeTest{
-		{
-			title:           "Queries route, match",
-			route:           new(Route).Queries("foo", "bar", "baz", "ding"),
-			request:         newRequest("GET", "http://localhost?foo=bar&baz=ding"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			query:           "foo=bar&baz=ding",
-			queriesTemplate: "foo=bar,baz=ding",
-			queriesRegexp:   "^foo=bar$,^baz=ding$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route, match with a query string",
-			route:           new(Route).Host("www.example.com").Path("/api").Queries("foo", "bar", "baz", "ding"),
-			request:         newRequest("GET", "http://www.example.com/api?foo=bar&baz=ding"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			query:           "foo=bar&baz=ding",
-			pathTemplate:    `/api`,
-			hostTemplate:    `www.example.com`,
-			queriesTemplate: "foo=bar,baz=ding",
-			queriesRegexp:   "^foo=bar$,^baz=ding$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route, match with a query string out of order",
-			route:           new(Route).Host("www.example.com").Path("/api").Queries("foo", "bar", "baz", "ding"),
-			request:         newRequest("GET", "http://www.example.com/api?baz=ding&foo=bar"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			query:           "foo=bar&baz=ding",
-			pathTemplate:    `/api`,
-			hostTemplate:    `www.example.com`,
-			queriesTemplate: "foo=bar,baz=ding",
-			queriesRegexp:   "^foo=bar$,^baz=ding$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route, bad query",
-			route:           new(Route).Queries("foo", "bar", "baz", "ding"),
-			request:         newRequest("GET", "http://localhost?foo=bar&baz=dong"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			queriesTemplate: "foo=bar,baz=ding",
-			queriesRegexp:   "^foo=bar$,^baz=ding$",
-			shouldMatch:     false,
-		},
-		{
-			title:           "Queries route with pattern, match",
-			route:           new(Route).Queries("foo", "{v1}"),
-			request:         newRequest("GET", "http://localhost?foo=bar"),
-			vars:            map[string]string{"v1": "bar"},
-			host:            "",
-			path:            "",
-			query:           "foo=bar",
-			queriesTemplate: "foo={v1}",
-			queriesRegexp:   "^foo=(?P<v0>.*)$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with multiple patterns, match",
-			route:           new(Route).Queries("foo", "{v1}", "baz", "{v2}"),
-			request:         newRequest("GET", "http://localhost?foo=bar&baz=ding"),
-			vars:            map[string]string{"v1": "bar", "v2": "ding"},
-			host:            "",
-			path:            "",
-			query:           "foo=bar&baz=ding",
-			queriesTemplate: "foo={v1},baz={v2}",
-			queriesRegexp:   "^foo=(?P<v0>.*)$,^baz=(?P<v0>.*)$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with regexp pattern, match",
-			route:           new(Route).Queries("foo", "{v1:[0-9]+}"),
-			request:         newRequest("GET", "http://localhost?foo=10"),
-			vars:            map[string]string{"v1": "10"},
-			host:            "",
-			path:            "",
-			query:           "foo=10",
-			queriesTemplate: "foo={v1:[0-9]+}",
-			queriesRegexp:   "^foo=(?P<v0>[0-9]+)$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with regexp pattern, regexp does not match",
-			route:           new(Route).Queries("foo", "{v1:[0-9]+}"),
-			request:         newRequest("GET", "http://localhost?foo=a"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			queriesTemplate: "foo={v1:[0-9]+}",
-			queriesRegexp:   "^foo=(?P<v0>[0-9]+)$",
-			shouldMatch:     false,
-		},
-		{
-			title:           "Queries route with regexp pattern with quantifier, match",
-			route:           new(Route).Queries("foo", "{v1:[0-9]{1}}"),
-			request:         newRequest("GET", "http://localhost?foo=1"),
-			vars:            map[string]string{"v1": "1"},
-			host:            "",
-			path:            "",
-			query:           "foo=1",
-			queriesTemplate: "foo={v1:[0-9]{1}}",
-			queriesRegexp:   "^foo=(?P<v0>[0-9]{1})$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with regexp pattern with quantifier, additional variable in query string, match",
-			route:           new(Route).Queries("foo", "{v1:[0-9]{1}}"),
-			request:         newRequest("GET", "http://localhost?bar=2&foo=1"),
-			vars:            map[string]string{"v1": "1"},
-			host:            "",
-			path:            "",
-			query:           "foo=1",
-			queriesTemplate: "foo={v1:[0-9]{1}}",
-			queriesRegexp:   "^foo=(?P<v0>[0-9]{1})$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with regexp pattern with quantifier, regexp does not match",
-			route:           new(Route).Queries("foo", "{v1:[0-9]{1}}"),
-			request:         newRequest("GET", "http://localhost?foo=12"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			queriesTemplate: "foo={v1:[0-9]{1}}",
-			queriesRegexp:   "^foo=(?P<v0>[0-9]{1})$",
-			shouldMatch:     false,
-		},
-		{
-			title:           "Queries route with regexp pattern with quantifier, additional capturing group",
-			route:           new(Route).Queries("foo", "{v1:[0-9]{1}(?:a|b)}"),
-			request:         newRequest("GET", "http://localhost?foo=1a"),
-			vars:            map[string]string{"v1": "1a"},
-			host:            "",
-			path:            "",
-			query:           "foo=1a",
-			queriesTemplate: "foo={v1:[0-9]{1}(?:a|b)}",
-			queriesRegexp:   "^foo=(?P<v0>[0-9]{1}(?:a|b))$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with regexp pattern with quantifier, additional variable in query string, regexp does not match",
-			route:           new(Route).Queries("foo", "{v1:[0-9]{1}}"),
-			request:         newRequest("GET", "http://localhost?foo=12"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			queriesTemplate: "foo={v1:[0-9]{1}}",
-			queriesRegexp:   "^foo=(?P<v0>[0-9]{1})$",
-			shouldMatch:     false,
-		},
-		{
-			title:           "Queries route with hyphenated name, match",
-			route:           new(Route).Queries("foo", "{v-1}"),
-			request:         newRequest("GET", "http://localhost?foo=bar"),
-			vars:            map[string]string{"v-1": "bar"},
-			host:            "",
-			path:            "",
-			query:           "foo=bar",
-			queriesTemplate: "foo={v-1}",
-			queriesRegexp:   "^foo=(?P<v0>.*)$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with multiple hyphenated names, match",
-			route:           new(Route).Queries("foo", "{v-1}", "baz", "{v-2}"),
-			request:         newRequest("GET", "http://localhost?foo=bar&baz=ding"),
-			vars:            map[string]string{"v-1": "bar", "v-2": "ding"},
-			host:            "",
-			path:            "",
-			query:           "foo=bar&baz=ding",
-			queriesTemplate: "foo={v-1},baz={v-2}",
-			queriesRegexp:   "^foo=(?P<v0>.*)$,^baz=(?P<v0>.*)$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with hyphenate name and pattern, match",
-			route:           new(Route).Queries("foo", "{v-1:[0-9]+}"),
-			request:         newRequest("GET", "http://localhost?foo=10"),
-			vars:            map[string]string{"v-1": "10"},
-			host:            "",
-			path:            "",
-			query:           "foo=10",
-			queriesTemplate: "foo={v-1:[0-9]+}",
-			queriesRegexp:   "^foo=(?P<v0>[0-9]+)$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with hyphenated name and pattern with quantifier, additional capturing group",
-			route:           new(Route).Queries("foo", "{v-1:[0-9]{1}(?:a|b)}"),
-			request:         newRequest("GET", "http://localhost?foo=1a"),
-			vars:            map[string]string{"v-1": "1a"},
-			host:            "",
-			path:            "",
-			query:           "foo=1a",
-			queriesTemplate: "foo={v-1:[0-9]{1}(?:a|b)}",
-			queriesRegexp:   "^foo=(?P<v0>[0-9]{1}(?:a|b))$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with empty value, should match",
-			route:           new(Route).Queries("foo", ""),
-			request:         newRequest("GET", "http://localhost?foo=bar"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			query:           "foo=",
-			queriesTemplate: "foo=",
-			queriesRegexp:   "^foo=.*$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with empty value and no parameter in request, should not match",
-			route:           new(Route).Queries("foo", ""),
-			request:         newRequest("GET", "http://localhost"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			queriesTemplate: "foo=",
-			queriesRegexp:   "^foo=.*$",
-			shouldMatch:     false,
-		},
-		{
-			title:           "Queries route with empty value and empty parameter in request, should match",
-			route:           new(Route).Queries("foo", ""),
-			request:         newRequest("GET", "http://localhost?foo="),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			query:           "foo=",
-			queriesTemplate: "foo=",
-			queriesRegexp:   "^foo=.*$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route with overlapping value, should not match",
-			route:           new(Route).Queries("foo", "bar"),
-			request:         newRequest("GET", "http://localhost?foo=barfoo"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			queriesTemplate: "foo=bar",
-			queriesRegexp:   "^foo=bar$",
-			shouldMatch:     false,
-		},
-		{
-			title:           "Queries route with no parameter in request, should not match",
-			route:           new(Route).Queries("foo", "{bar}"),
-			request:         newRequest("GET", "http://localhost"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			queriesTemplate: "foo={bar}",
-			queriesRegexp:   "^foo=(?P<v0>.*)$",
-			shouldMatch:     false,
-		},
-		{
-			title:           "Queries route with empty parameter in request, should match",
-			route:           new(Route).Queries("foo", "{bar}"),
-			request:         newRequest("GET", "http://localhost?foo="),
-			vars:            map[string]string{"foo": ""},
-			host:            "",
-			path:            "",
-			query:           "foo=",
-			queriesTemplate: "foo={bar}",
-			queriesRegexp:   "^foo=(?P<v0>.*)$",
-			shouldMatch:     true,
-		},
-		{
-			title:           "Queries route, bad submatch",
-			route:           new(Route).Queries("foo", "bar", "baz", "ding"),
-			request:         newRequest("GET", "http://localhost?fffoo=bar&baz=dingggg"),
-			vars:            map[string]string{},
-			host:            "",
-			path:            "",
-			queriesTemplate: "foo=bar,baz=ding",
-			queriesRegexp:   "^foo=bar$,^baz=ding$",
-			shouldMatch:     false,
-		},
-		{
-			title:           "Queries route with pattern, match, escaped value",
-			route:           new(Route).Queries("foo", "{v1}"),
-			request:         newRequest("GET", "http://localhost?foo=%25bar%26%20%2F%3D%3F"),
-			vars:            map[string]string{"v1": "%bar& /=?"},
-			host:            "",
-			path:            "",
-			query:           "foo=%25bar%26+%2F%3D%3F",
-			queriesTemplate: "foo={v1}",
-			queriesRegexp:   "^foo=(?P<v0>.*)$",
-			shouldMatch:     true,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-		testQueriesTemplates(t, test)
-		testUseEscapedRoute(t, test)
-		testQueriesRegexp(t, test)
-	}
-}
-
-func TestSchemes(t *testing.T) {
-	tests := []routeTest{
-		// Schemes
-		{
-			title:       "Schemes route, default scheme, match http, build http",
-			route:       new(Route).Host("localhost"),
-			request:     newRequest("GET", "http://localhost"),
-			scheme:      "http",
-			host:        "localhost",
-			shouldMatch: true,
-		},
-		{
-			title:       "Schemes route, match https, build https",
-			route:       new(Route).Schemes("https", "ftp").Host("localhost"),
-			request:     newRequest("GET", "https://localhost"),
-			scheme:      "https",
-			host:        "localhost",
-			shouldMatch: true,
-		},
-		{
-			title:       "Schemes route, match ftp, build https",
-			route:       new(Route).Schemes("https", "ftp").Host("localhost"),
-			request:     newRequest("GET", "ftp://localhost"),
-			scheme:      "https",
-			host:        "localhost",
-			shouldMatch: true,
-		},
-		{
-			title:       "Schemes route, match ftp, build ftp",
-			route:       new(Route).Schemes("ftp", "https").Host("localhost"),
-			request:     newRequest("GET", "ftp://localhost"),
-			scheme:      "ftp",
-			host:        "localhost",
-			shouldMatch: true,
-		},
-		{
-			title:       "Schemes route, bad scheme",
-			route:       new(Route).Schemes("https", "ftp").Host("localhost"),
-			request:     newRequest("GET", "http://localhost"),
-			scheme:      "https",
-			host:        "localhost",
-			shouldMatch: false,
-		},
-	}
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-	}
-}
-
-func TestMatcherFunc(t *testing.T) {
-	m := func(r *http.Request, m *RouteMatch) bool {
-		if r.URL.Host == "aaa.bbb.ccc" {
-			return true
-		}
-		return false
-	}
-
-	tests := []routeTest{
-		{
-			title:       "MatchFunc route, match",
-			route:       new(Route).MatcherFunc(m),
-			request:     newRequest("GET", "http://aaa.bbb.ccc"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			shouldMatch: true,
-		},
-		{
-			title:       "MatchFunc route, non-match",
-			route:       new(Route).MatcherFunc(m),
-			request:     newRequest("GET", "http://aaa.222.ccc"),
-			vars:        map[string]string{},
-			host:        "",
-			path:        "",
-			shouldMatch: false,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-	}
-}
-
-func TestBuildVarsFunc(t *testing.T) {
-	tests := []routeTest{
-		{
-			title: "BuildVarsFunc set on route",
-			route: new(Route).Path(`/111/{v1:\d}{v2:.*}`).BuildVarsFunc(func(vars map[string]string) map[string]string {
-				vars["v1"] = "3"
-				vars["v2"] = "a"
-				return vars
-			}),
-			request:      newRequest("GET", "http://localhost/111/2"),
-			path:         "/111/3a",
-			pathTemplate: `/111/{v1:\d}{v2:.*}`,
-			shouldMatch:  true,
-		},
-		{
-			title: "BuildVarsFunc set on route and parent route",
-			route: new(Route).PathPrefix(`/{v1:\d}`).BuildVarsFunc(func(vars map[string]string) map[string]string {
-				vars["v1"] = "2"
-				return vars
-			}).Subrouter().Path(`/{v2:\w}`).BuildVarsFunc(func(vars map[string]string) map[string]string {
-				vars["v2"] = "b"
-				return vars
-			}),
-			request:      newRequest("GET", "http://localhost/1/a"),
-			path:         "/2/b",
-			pathTemplate: `/{v1:\d}/{v2:\w}`,
-			shouldMatch:  true,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-	}
-}
-
-func TestSubRouter(t *testing.T) {
-	subrouter1 := new(Route).Host("{v1:[a-z]+}.google.com").Subrouter()
-	subrouter2 := new(Route).PathPrefix("/foo/{v1}").Subrouter()
-	subrouter3 := new(Route).PathPrefix("/foo").Subrouter()
-	subrouter4 := new(Route).PathPrefix("/foo/bar").Subrouter()
-	subrouter5 := new(Route).PathPrefix("/{category}").Subrouter()
-
-	tests := []routeTest{
-		{
-			route:        subrouter1.Path("/{v2:[a-z]+}"),
-			request:      newRequest("GET", "http://aaa.google.com/bbb"),
-			vars:         map[string]string{"v1": "aaa", "v2": "bbb"},
-			host:         "aaa.google.com",
-			path:         "/bbb",
-			pathTemplate: `/{v2:[a-z]+}`,
-			hostTemplate: `{v1:[a-z]+}.google.com`,
-			shouldMatch:  true,
-		},
-		{
-			route:        subrouter1.Path("/{v2:[a-z]+}"),
-			request:      newRequest("GET", "http://111.google.com/111"),
-			vars:         map[string]string{"v1": "aaa", "v2": "bbb"},
-			host:         "aaa.google.com",
-			path:         "/bbb",
-			pathTemplate: `/{v2:[a-z]+}`,
-			hostTemplate: `{v1:[a-z]+}.google.com`,
-			shouldMatch:  false,
-		},
-		{
-			route:        subrouter2.Path("/baz/{v2}"),
-			request:      newRequest("GET", "http://localhost/foo/bar/baz/ding"),
-			vars:         map[string]string{"v1": "bar", "v2": "ding"},
-			host:         "",
-			path:         "/foo/bar/baz/ding",
-			pathTemplate: `/foo/{v1}/baz/{v2}`,
-			shouldMatch:  true,
-		},
-		{
-			route:        subrouter2.Path("/baz/{v2}"),
-			request:      newRequest("GET", "http://localhost/foo/bar"),
-			vars:         map[string]string{"v1": "bar", "v2": "ding"},
-			host:         "",
-			path:         "/foo/bar/baz/ding",
-			pathTemplate: `/foo/{v1}/baz/{v2}`,
-			shouldMatch:  false,
-		},
-		{
-			route:        subrouter3.Path("/"),
-			request:      newRequest("GET", "http://localhost/foo/"),
-			vars:         map[string]string{},
-			host:         "",
-			path:         "/foo/",
-			pathTemplate: `/foo/`,
-			shouldMatch:  true,
-		},
-		{
-			route:        subrouter3.Path(""),
-			request:      newRequest("GET", "http://localhost/foo"),
-			vars:         map[string]string{},
-			host:         "",
-			path:         "/foo",
-			pathTemplate: `/foo`,
-			shouldMatch:  true,
-		},
-
-		{
-			route:        subrouter4.Path("/"),
-			request:      newRequest("GET", "http://localhost/foo/bar/"),
-			vars:         map[string]string{},
-			host:         "",
-			path:         "/foo/bar/",
-			pathTemplate: `/foo/bar/`,
-			shouldMatch:  true,
-		},
-		{
-			route:        subrouter4.Path(""),
-			request:      newRequest("GET", "http://localhost/foo/bar"),
-			vars:         map[string]string{},
-			host:         "",
-			path:         "/foo/bar",
-			pathTemplate: `/foo/bar`,
-			shouldMatch:  true,
-		},
-		{
-			route:        subrouter5.Path("/"),
-			request:      newRequest("GET", "http://localhost/baz/"),
-			vars:         map[string]string{"category": "baz"},
-			host:         "",
-			path:         "/baz/",
-			pathTemplate: `/{category}/`,
-			shouldMatch:  true,
-		},
-		{
-			route:        subrouter5.Path(""),
-			request:      newRequest("GET", "http://localhost/baz"),
-			vars:         map[string]string{"category": "baz"},
-			host:         "",
-			path:         "/baz",
-			pathTemplate: `/{category}`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Build with scheme on parent router",
-			route:        new(Route).Schemes("ftp").Host("google.com").Subrouter().Path("/"),
-			request:      newRequest("GET", "ftp://google.com/"),
-			scheme:       "ftp",
-			host:         "google.com",
-			path:         "/",
-			pathTemplate: `/`,
-			hostTemplate: `google.com`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Prefer scheme on child route when building URLs",
-			route:        new(Route).Schemes("https", "ftp").Host("google.com").Subrouter().Schemes("ftp").Path("/"),
-			request:      newRequest("GET", "ftp://google.com/"),
-			scheme:       "ftp",
-			host:         "google.com",
-			path:         "/",
-			pathTemplate: `/`,
-			hostTemplate: `google.com`,
-			shouldMatch:  true,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-		testUseEscapedRoute(t, test)
-	}
-}
-
-func TestNamedRoutes(t *testing.T) {
-	r1 := NewRouter()
-	r1.NewRoute().Name("a")
-	r1.NewRoute().Name("b")
-	r1.NewRoute().Name("c")
-
-	r2 := r1.NewRoute().Subrouter()
-	r2.NewRoute().Name("d")
-	r2.NewRoute().Name("e")
-	r2.NewRoute().Name("f")
-
-	r3 := r2.NewRoute().Subrouter()
-	r3.NewRoute().Name("g")
-	r3.NewRoute().Name("h")
-	r3.NewRoute().Name("i")
-
-	if r1.namedRoutes == nil || len(r1.namedRoutes) != 9 {
-		t.Errorf("Expected 9 named routes, got %v", r1.namedRoutes)
-	} else if r1.Get("i") == nil {
-		t.Errorf("Subroute name not registered")
-	}
-}
-
-func TestStrictSlash(t *testing.T) {
-	r := NewRouter()
-	r.StrictSlash(true)
-
-	tests := []routeTest{
-		{
-			title:          "Redirect path without slash",
-			route:          r.NewRoute().Path("/111/"),
-			request:        newRequest("GET", "http://localhost/111"),
-			vars:           map[string]string{},
-			host:           "",
-			path:           "/111/",
-			shouldMatch:    true,
-			shouldRedirect: true,
-		},
-		{
-			title:          "Do not redirect path with slash",
-			route:          r.NewRoute().Path("/111/"),
-			request:        newRequest("GET", "http://localhost/111/"),
-			vars:           map[string]string{},
-			host:           "",
-			path:           "/111/",
-			shouldMatch:    true,
-			shouldRedirect: false,
-		},
-		{
-			title:          "Redirect path with slash",
-			route:          r.NewRoute().Path("/111"),
-			request:        newRequest("GET", "http://localhost/111/"),
-			vars:           map[string]string{},
-			host:           "",
-			path:           "/111",
-			shouldMatch:    true,
-			shouldRedirect: true,
-		},
-		{
-			title:          "Do not redirect path without slash",
-			route:          r.NewRoute().Path("/111"),
-			request:        newRequest("GET", "http://localhost/111"),
-			vars:           map[string]string{},
-			host:           "",
-			path:           "/111",
-			shouldMatch:    true,
-			shouldRedirect: false,
-		},
-		{
-			title:          "Propagate StrictSlash to subrouters",
-			route:          r.NewRoute().PathPrefix("/static/").Subrouter().Path("/images/"),
-			request:        newRequest("GET", "http://localhost/static/images"),
-			vars:           map[string]string{},
-			host:           "",
-			path:           "/static/images/",
-			shouldMatch:    true,
-			shouldRedirect: true,
-		},
-		{
-			title:          "Ignore StrictSlash for path prefix",
-			route:          r.NewRoute().PathPrefix("/static/"),
-			request:        newRequest("GET", "http://localhost/static/logo.png"),
-			vars:           map[string]string{},
-			host:           "",
-			path:           "/static/",
-			shouldMatch:    true,
-			shouldRedirect: false,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-		testUseEscapedRoute(t, test)
-	}
-}
-
-func TestUseEncodedPath(t *testing.T) {
-	r := NewRouter()
-	r.UseEncodedPath()
-
-	tests := []routeTest{
-		{
-			title:        "Router with useEncodedPath, URL with encoded slash does match",
-			route:        r.NewRoute().Path("/v1/{v1}/v2"),
-			request:      newRequest("GET", "http://localhost/v1/1%2F2/v2"),
-			vars:         map[string]string{"v1": "1%2F2"},
-			host:         "",
-			path:         "/v1/1%2F2/v2",
-			pathTemplate: `/v1/{v1}/v2`,
-			shouldMatch:  true,
-		},
-		{
-			title:        "Router with useEncodedPath, URL with encoded slash doesn't match",
-			route:        r.NewRoute().Path("/v1/1/2/v2"),
-			request:      newRequest("GET", "http://localhost/v1/1%2F2/v2"),
-			vars:         map[string]string{"v1": "1%2F2"},
-			host:         "",
-			path:         "/v1/1%2F2/v2",
-			pathTemplate: `/v1/1/2/v2`,
-			shouldMatch:  false,
-		},
-	}
-
-	for _, test := range tests {
-		testRoute(t, test)
-		testTemplate(t, test)
-	}
-}
-
-func TestWalkSingleDepth(t *testing.T) {
-	r0 := NewRouter()
-	r1 := NewRouter()
-	r2 := NewRouter()
-
-	r0.Path("/g")
-	r0.Path("/o")
-	r0.Path("/d").Handler(r1)
-	r0.Path("/r").Handler(r2)
-	r0.Path("/a")
-
-	r1.Path("/z")
-	r1.Path("/i")
-	r1.Path("/l")
-	r1.Path("/l")
-
-	r2.Path("/i")
-	r2.Path("/l")
-	r2.Path("/l")
-
-	paths := []string{"g", "o", "r", "i", "l", "l", "a"}
-	depths := []int{0, 0, 0, 1, 1, 1, 0}
-	i := 0
-	err := r0.Walk(func(route *Route, router *Router, ancestors []*Route) error {
-		matcher := route.matchers[0].(*routeRegexp)
-		if matcher.template == "/d" {
-			return SkipRouter
-		}
-		if len(ancestors) != depths[i] {
-			t.Errorf(`Expected depth of %d at i = %d; got "%d"`, depths[i], i, len(ancestors))
-		}
-		if matcher.template != "/"+paths[i] {
-			t.Errorf(`Expected "/%s" at i = %d; got "%s"`, paths[i], i, matcher.template)
-		}
-		i++
-		return nil
-	})
-	if err != nil {
-		panic(err)
-	}
-	if i != len(paths) {
-		t.Errorf("Expected %d routes, found %d", len(paths), i)
-	}
-}
-
-func TestWalkNested(t *testing.T) {
-	router := NewRouter()
-
-	g := router.Path("/g").Subrouter()
-	o := g.PathPrefix("/o").Subrouter()
-	r := o.PathPrefix("/r").Subrouter()
-	i := r.PathPrefix("/i").Subrouter()
-	l1 := i.PathPrefix("/l").Subrouter()
-	l2 := l1.PathPrefix("/l").Subrouter()
-	l2.Path("/a")
-
-	testCases := []struct {
-		path      string
-		ancestors []*Route
-	}{
-		{"/g", []*Route{}},
-		{"/g/o", []*Route{g.parent.(*Route)}},
-		{"/g/o/r", []*Route{g.parent.(*Route), o.parent.(*Route)}},
-		{"/g/o/r/i", []*Route{g.parent.(*Route), o.parent.(*Route), r.parent.(*Route)}},
-		{"/g/o/r/i/l", []*Route{g.parent.(*Route), o.parent.(*Route), r.parent.(*Route), i.parent.(*Route)}},
-		{"/g/o/r/i/l/l", []*Route{g.parent.(*Route), o.parent.(*Route), r.parent.(*Route), i.parent.(*Route), l1.parent.(*Route)}},
-		{"/g/o/r/i/l/l/a", []*Route{g.parent.(*Route), o.parent.(*Route), r.parent.(*Route), i.parent.(*Route), l1.parent.(*Route), l2.parent.(*Route)}},
-	}
-
-	idx := 0
-	err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error {
-		path := testCases[idx].path
-		tpl := route.regexp.path.template
-		if tpl != path {
-			t.Errorf(`Expected %s got %s`, path, tpl)
-		}
-		currWantAncestors := testCases[idx].ancestors
-		if !reflect.DeepEqual(currWantAncestors, ancestors) {
-			t.Errorf(`Expected %+v got %+v`, currWantAncestors, ancestors)
-		}
-		idx++
-		return nil
-	})
-	if err != nil {
-		panic(err)
-	}
-	if idx != len(testCases) {
-		t.Errorf("Expected %d routes, found %d", len(testCases), idx)
-	}
-}
-
-func TestWalkSubrouters(t *testing.T) {
-	router := NewRouter()
-
-	g := router.Path("/g").Subrouter()
-	o := g.PathPrefix("/o").Subrouter()
-	o.Methods("GET")
-	o.Methods("PUT")
-
-	// all 4 routes should be matched, but final 2 routes do not have path templates
-	paths := []string{"/g", "/g/o", "", ""}
-	idx := 0
-	err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error {
-		path := paths[idx]
-		tpl, _ := route.GetPathTemplate()
-		if tpl != path {
-			t.Errorf(`Expected %s got %s`, path, tpl)
-		}
-		idx++
-		return nil
-	})
-	if err != nil {
-		panic(err)
-	}
-	if idx != len(paths) {
-		t.Errorf("Expected %d routes, found %d", len(paths), idx)
-	}
-}
-
-func TestWalkErrorRoute(t *testing.T) {
-	router := NewRouter()
-	router.Path("/g")
-	expectedError := errors.New("error")
-	err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error {
-		return expectedError
-	})
-	if err != expectedError {
-		t.Errorf("Expected %v routes, found %v", expectedError, err)
-	}
-}
-
-func TestWalkErrorMatcher(t *testing.T) {
-	router := NewRouter()
-	expectedError := router.Path("/g").Subrouter().Path("").GetError()
-	err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error {
-		return route.GetError()
-	})
-	if err != expectedError {
-		t.Errorf("Expected %v routes, found %v", expectedError, err)
-	}
-}
-
-func TestWalkErrorHandler(t *testing.T) {
-	handler := NewRouter()
-	expectedError := handler.Path("/path").Subrouter().Path("").GetError()
-	router := NewRouter()
-	router.Path("/g").Handler(handler)
-	err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error {
-		return route.GetError()
-	})
-	if err != expectedError {
-		t.Errorf("Expected %v routes, found %v", expectedError, err)
-	}
-}
-
-func TestSubrouterErrorHandling(t *testing.T) {
-	superRouterCalled := false
-	subRouterCalled := false
-
-	router := NewRouter()
-	router.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		superRouterCalled = true
-	})
-	subRouter := router.PathPrefix("/bign8").Subrouter()
-	subRouter.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		subRouterCalled = true
-	})
-
-	req, _ := http.NewRequest("GET", "http://localhost/bign8/was/here", nil)
-	router.ServeHTTP(NewRecorder(), req)
-
-	if superRouterCalled {
-		t.Error("Super router 404 handler called when sub-router 404 handler is available.")
-	}
-	if !subRouterCalled {
-		t.Error("Sub-router 404 handler was not called.")
-	}
-}
-
-// See: https://github.com/gorilla/mux/issues/200
-func TestPanicOnCapturingGroups(t *testing.T) {
-	defer func() {
-		if recover() == nil {
-			t.Errorf("(Test that capturing groups now fail fast) Expected panic, however test completed successfully.\n")
-		}
-	}()
-	NewRouter().NewRoute().Path("/{type:(promo|special)}/{promoId}.json")
-}
-
-// ----------------------------------------------------------------------------
-// Helpers
-// ----------------------------------------------------------------------------
-
-func getRouteTemplate(route *Route) string {
-	host, err := route.GetHostTemplate()
-	if err != nil {
-		host = "none"
-	}
-	path, err := route.GetPathTemplate()
-	if err != nil {
-		path = "none"
-	}
-	return fmt.Sprintf("Host: %v, Path: %v", host, path)
-}
-
-func testRoute(t *testing.T, test routeTest) {
-	request := test.request
-	route := test.route
-	vars := test.vars
-	shouldMatch := test.shouldMatch
-	query := test.query
-	shouldRedirect := test.shouldRedirect
-	uri := url.URL{
-		Scheme: test.scheme,
-		Host:   test.host,
-		Path:   test.path,
-	}
-	if uri.Scheme == "" {
-		uri.Scheme = "http"
-	}
-
-	var match RouteMatch
-	ok := route.Match(request, &match)
-	if ok != shouldMatch {
-		msg := "Should match"
-		if !shouldMatch {
-			msg = "Should not match"
-		}
-		t.Errorf("(%v) %v:\nRoute: %#v\nRequest: %#v\nVars: %v\n", test.title, msg, route, request, vars)
-		return
-	}
-	if shouldMatch {
-		if vars != nil && !stringMapEqual(vars, match.Vars) {
-			t.Errorf("(%v) Vars not equal: expected %v, got %v", test.title, vars, match.Vars)
-			return
-		}
-		if test.scheme != "" {
-			u, err := route.URL(mapToPairs(match.Vars)...)
-			if err != nil {
-				t.Fatalf("(%v) URL error: %v -- %v", test.title, err, getRouteTemplate(route))
-			}
-			if uri.Scheme != u.Scheme {
-				t.Errorf("(%v) URLScheme not equal: expected %v, got %v", test.title, uri.Scheme, u.Scheme)
-				return
-			}
-		}
-		if test.host != "" {
-			u, err := test.route.URLHost(mapToPairs(match.Vars)...)
-			if err != nil {
-				t.Fatalf("(%v) URLHost error: %v -- %v", test.title, err, getRouteTemplate(route))
-			}
-			if uri.Scheme != u.Scheme {
-				t.Errorf("(%v) URLHost scheme not equal: expected %v, got %v -- %v", test.title, uri.Scheme, u.Scheme, getRouteTemplate(route))
-				return
-			}
-			if uri.Host != u.Host {
-				t.Errorf("(%v) URLHost host not equal: expected %v, got %v -- %v", test.title, uri.Host, u.Host, getRouteTemplate(route))
-				return
-			}
-		}
-		if test.path != "" {
-			u, err := route.URLPath(mapToPairs(match.Vars)...)
-			if err != nil {
-				t.Fatalf("(%v) URLPath error: %v -- %v", test.title, err, getRouteTemplate(route))
-			}
-			if uri.Path != u.Path {
-				t.Errorf("(%v) URLPath not equal: expected %v, got %v -- %v", test.title, uri.Path, u.Path, getRouteTemplate(route))
-				return
-			}
-		}
-		if test.host != "" && test.path != "" {
-			u, err := route.URL(mapToPairs(match.Vars)...)
-			if err != nil {
-				t.Fatalf("(%v) URL error: %v -- %v", test.title, err, getRouteTemplate(route))
-			}
-			if expected, got := uri.String(), u.String(); expected != got {
-				t.Errorf("(%v) URL not equal: expected %v, got %v -- %v", test.title, expected, got, getRouteTemplate(route))
-				return
-			}
-		}
-		if query != "" {
-			u, _ := route.URL(mapToPairs(match.Vars)...)
-			if query != u.RawQuery {
-				t.Errorf("(%v) URL query not equal: expected %v, got %v", test.title, query, u.RawQuery)
-				return
-			}
-		}
-		if shouldRedirect && match.Handler == nil {
-			t.Errorf("(%v) Did not redirect", test.title)
-			return
-		}
-		if !shouldRedirect && match.Handler != nil {
-			t.Errorf("(%v) Unexpected redirect", test.title)
-			return
-		}
-	}
-}
-
-func testUseEscapedRoute(t *testing.T, test routeTest) {
-	test.route.useEncodedPath = true
-	testRoute(t, test)
-}
-
-func testTemplate(t *testing.T, test routeTest) {
-	route := test.route
-	pathTemplate := test.pathTemplate
-	if len(pathTemplate) == 0 {
-		pathTemplate = test.path
-	}
-	hostTemplate := test.hostTemplate
-	if len(hostTemplate) == 0 {
-		hostTemplate = test.host
-	}
-
-	routePathTemplate, pathErr := route.GetPathTemplate()
-	if pathErr == nil && routePathTemplate != pathTemplate {
-		t.Errorf("(%v) GetPathTemplate not equal: expected %v, got %v", test.title, pathTemplate, routePathTemplate)
-	}
-
-	routeHostTemplate, hostErr := route.GetHostTemplate()
-	if hostErr == nil && routeHostTemplate != hostTemplate {
-		t.Errorf("(%v) GetHostTemplate not equal: expected %v, got %v", test.title, hostTemplate, routeHostTemplate)
-	}
-}
-
-func testMethods(t *testing.T, test routeTest) {
-	route := test.route
-	methods, _ := route.GetMethods()
-	if strings.Join(methods, ",") != strings.Join(test.methods, ",") {
-		t.Errorf("(%v) GetMethods not equal: expected %v, got %v", test.title, test.methods, methods)
-	}
-}
-
-func testRegexp(t *testing.T, test routeTest) {
-	route := test.route
-	routePathRegexp, regexpErr := route.GetPathRegexp()
-	if test.pathRegexp != "" && regexpErr == nil && routePathRegexp != test.pathRegexp {
-		t.Errorf("(%v) GetPathRegexp not equal: expected %v, got %v", test.title, test.pathRegexp, routePathRegexp)
-	}
-}
-
-func testQueriesRegexp(t *testing.T, test routeTest) {
-	route := test.route
-	queries, queriesErr := route.GetQueriesRegexp()
-	gotQueries := strings.Join(queries, ",")
-	if test.queriesRegexp != "" && queriesErr == nil && gotQueries != test.queriesRegexp {
-		t.Errorf("(%v) GetQueriesRegexp not equal: expected %v, got %v", test.title, test.queriesRegexp, gotQueries)
-	}
-}
-
-func testQueriesTemplates(t *testing.T, test routeTest) {
-	route := test.route
-	queries, queriesErr := route.GetQueriesTemplates()
-	gotQueries := strings.Join(queries, ",")
-	if test.queriesTemplate != "" && queriesErr == nil && gotQueries != test.queriesTemplate {
-		t.Errorf("(%v) GetQueriesTemplates not equal: expected %v, got %v", test.title, test.queriesTemplate, gotQueries)
-	}
-}
-
-type TestA301ResponseWriter struct {
-	hh     http.Header
-	status int
-}
-
-func (ho *TestA301ResponseWriter) Header() http.Header {
-	return http.Header(ho.hh)
-}
-
-func (ho *TestA301ResponseWriter) Write(b []byte) (int, error) {
-	return 0, nil
-}
-
-func (ho *TestA301ResponseWriter) WriteHeader(code int) {
-	ho.status = code
-}
-
-func Test301Redirect(t *testing.T) {
-	m := make(http.Header)
-
-	func1 := func(w http.ResponseWriter, r *http.Request) {}
-	func2 := func(w http.ResponseWriter, r *http.Request) {}
-
-	r := NewRouter()
-	r.HandleFunc("/api/", func2).Name("func2")
-	r.HandleFunc("/", func1).Name("func1")
-
-	req, _ := http.NewRequest("GET", "http://localhost//api/?abc=def", nil)
-
-	res := TestA301ResponseWriter{
-		hh:     m,
-		status: 0,
-	}
-	r.ServeHTTP(&res, req)
-
-	if "http://localhost/api/?abc=def" != res.hh["Location"][0] {
-		t.Errorf("Should have complete URL with query string")
-	}
-}
-
-func TestSkipClean(t *testing.T) {
-	func1 := func(w http.ResponseWriter, r *http.Request) {}
-	func2 := func(w http.ResponseWriter, r *http.Request) {}
-
-	r := NewRouter()
-	r.SkipClean(true)
-	r.HandleFunc("/api/", func2).Name("func2")
-	r.HandleFunc("/", func1).Name("func1")
-
-	req, _ := http.NewRequest("GET", "http://localhost//api/?abc=def", nil)
-	res := NewRecorder()
-	r.ServeHTTP(res, req)
-
-	if len(res.HeaderMap["Location"]) != 0 {
-		t.Errorf("Shouldn't redirect since skip clean is disabled")
-	}
-}
-
-// https://plus.google.com/101022900381697718949/posts/eWy6DjFJ6uW
-func TestSubrouterHeader(t *testing.T) {
-	expected := "func1 response"
-	func1 := func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprint(w, expected)
-	}
-	func2 := func(http.ResponseWriter, *http.Request) {}
-
-	r := NewRouter()
-	s := r.Headers("SomeSpecialHeader", "").Subrouter()
-	s.HandleFunc("/", func1).Name("func1")
-	r.HandleFunc("/", func2).Name("func2")
-
-	req, _ := http.NewRequest("GET", "http://localhost/", nil)
-	req.Header.Add("SomeSpecialHeader", "foo")
-	match := new(RouteMatch)
-	matched := r.Match(req, match)
-	if !matched {
-		t.Errorf("Should match request")
-	}
-	if match.Route.GetName() != "func1" {
-		t.Errorf("Expecting func1 handler, got %s", match.Route.GetName())
-	}
-	resp := NewRecorder()
-	match.Handler.ServeHTTP(resp, req)
-	if resp.Body.String() != expected {
-		t.Errorf("Expecting %q", expected)
-	}
-}
-
-func TestNoMatchMethodErrorHandler(t *testing.T) {
-	func1 := func(w http.ResponseWriter, r *http.Request) {}
-
-	r := NewRouter()
-	r.HandleFunc("/", func1).Methods("GET", "POST")
-
-	req, _ := http.NewRequest("PUT", "http://localhost/", nil)
-	match := new(RouteMatch)
-	matched := r.Match(req, match)
-
-	if matched {
-		t.Error("Should not have matched route for methods")
-	}
-
-	if match.MatchErr != ErrMethodMismatch {
-		t.Error("Should get ErrMethodMismatch error")
-	}
-
-	resp := NewRecorder()
-	r.ServeHTTP(resp, req)
-	if resp.Code != 405 {
-		t.Errorf("Expecting code %v", 405)
-	}
-
-	// Add matching route
-	r.HandleFunc("/", func1).Methods("PUT")
-
-	match = new(RouteMatch)
-	matched = r.Match(req, match)
-
-	if !matched {
-		t.Error("Should have matched route for methods")
-	}
-
-	if match.MatchErr != nil {
-		t.Error("Should not have any matching error. Found:", match.MatchErr)
-	}
-}
-
-func TestErrMatchNotFound(t *testing.T) {
-	emptyHandler := func(w http.ResponseWriter, r *http.Request) {}
-
-	r := NewRouter()
-	r.HandleFunc("/", emptyHandler)
-	s := r.PathPrefix("/sub/").Subrouter()
-	s.HandleFunc("/", emptyHandler)
-
-	// Regular 404 not found
-	req, _ := http.NewRequest("GET", "/sub/whatever", nil)
-	match := new(RouteMatch)
-	matched := r.Match(req, match)
-
-	if matched {
-		t.Errorf("Subrouter should not have matched that, got %v", match.Route)
-	}
-	// Even without a custom handler, MatchErr is set to ErrNotFound
-	if match.MatchErr != ErrNotFound {
-		t.Errorf("Expected ErrNotFound MatchErr, but was %v", match.MatchErr)
-	}
-
-	// Now lets add a 404 handler to subrouter
-	s.NotFoundHandler = http.NotFoundHandler()
-	req, _ = http.NewRequest("GET", "/sub/whatever", nil)
-
-	// Test the subrouter first
-	match = new(RouteMatch)
-	matched = s.Match(req, match)
-	// Now we should get a match
-	if !matched {
-		t.Errorf("Subrouter should have matched %s", req.RequestURI)
-	}
-	// But MatchErr should be set to ErrNotFound anyway
-	if match.MatchErr != ErrNotFound {
-		t.Errorf("Expected ErrNotFound MatchErr, but was %v", match.MatchErr)
-	}
-
-	// Now test the parent (MatchErr should propagate)
-	match = new(RouteMatch)
-	matched = r.Match(req, match)
-
-	// Now we should get a match
-	if !matched {
-		t.Errorf("Router should have matched %s via subrouter", req.RequestURI)
-	}
-	// But MatchErr should be set to ErrNotFound anyway
-	if match.MatchErr != ErrNotFound {
-		t.Errorf("Expected ErrNotFound MatchErr, but was %v", match.MatchErr)
-	}
-}
-
-// methodsSubrouterTest models the data necessary for testing handler
-// matching for subrouters created after HTTP methods matcher registration.
-type methodsSubrouterTest struct {
-	title    string
-	wantCode int
-	router   *Router
-	// method is the input into the request and expected response
-	method string
-	// input request path
-	path string
-	// redirectTo is the expected location path for strict-slash matches
-	redirectTo string
-}
-
-// methodHandler writes the method string in response.
-func methodHandler(method string) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		w.Write([]byte(method))
-	}
-}
-
-// TestMethodsSubrouterCatchall matches handlers for subrouters where a
-// catchall handler is set for a mis-matching method.
-func TestMethodsSubrouterCatchall(t *testing.T) {
-	t.Parallel()
-
-	router := NewRouter()
-	router.Methods("PATCH").Subrouter().PathPrefix("/").HandlerFunc(methodHandler("PUT"))
-	router.Methods("GET").Subrouter().HandleFunc("/foo", methodHandler("GET"))
-	router.Methods("POST").Subrouter().HandleFunc("/foo", methodHandler("POST"))
-	router.Methods("DELETE").Subrouter().HandleFunc("/foo", methodHandler("DELETE"))
-
-	tests := []methodsSubrouterTest{
-		{
-			title:    "match GET handler",
-			router:   router,
-			path:     "http://localhost/foo",
-			method:   "GET",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match POST handler",
-			router:   router,
-			method:   "POST",
-			path:     "http://localhost/foo",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match DELETE handler",
-			router:   router,
-			method:   "DELETE",
-			path:     "http://localhost/foo",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "disallow PUT method",
-			router:   router,
-			method:   "PUT",
-			path:     "http://localhost/foo",
-			wantCode: http.StatusMethodNotAllowed,
-		},
-	}
-
-	for _, test := range tests {
-		testMethodsSubrouter(t, test)
-	}
-}
-
-// TestMethodsSubrouterStrictSlash matches handlers on subrouters with
-// strict-slash matchers.
-func TestMethodsSubrouterStrictSlash(t *testing.T) {
-	t.Parallel()
-
-	router := NewRouter()
-	sub := router.PathPrefix("/").Subrouter()
-	sub.StrictSlash(true).Path("/foo").Methods("GET").Subrouter().HandleFunc("", methodHandler("GET"))
-	sub.StrictSlash(true).Path("/foo/").Methods("PUT").Subrouter().HandleFunc("/", methodHandler("PUT"))
-	sub.StrictSlash(true).Path("/foo/").Methods("POST").Subrouter().HandleFunc("/", methodHandler("POST"))
-
-	tests := []methodsSubrouterTest{
-		{
-			title:    "match POST handler",
-			router:   router,
-			method:   "POST",
-			path:     "http://localhost/foo/",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match GET handler",
-			router:   router,
-			method:   "GET",
-			path:     "http://localhost/foo",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:      "match POST handler, redirect strict-slash",
-			router:     router,
-			method:     "POST",
-			path:       "http://localhost/foo",
-			redirectTo: "http://localhost/foo/",
-			wantCode:   http.StatusMovedPermanently,
-		},
-		{
-			title:      "match GET handler, redirect strict-slash",
-			router:     router,
-			method:     "GET",
-			path:       "http://localhost/foo/",
-			redirectTo: "http://localhost/foo",
-			wantCode:   http.StatusMovedPermanently,
-		},
-		{
-			title:    "disallow DELETE method",
-			router:   router,
-			method:   "DELETE",
-			path:     "http://localhost/foo",
-			wantCode: http.StatusMethodNotAllowed,
-		},
-	}
-
-	for _, test := range tests {
-		testMethodsSubrouter(t, test)
-	}
-}
-
-// TestMethodsSubrouterPathPrefix matches handlers on subrouters created
-// on a router with a path prefix matcher and method matcher.
-func TestMethodsSubrouterPathPrefix(t *testing.T) {
-	t.Parallel()
-
-	router := NewRouter()
-	router.PathPrefix("/1").Methods("POST").Subrouter().HandleFunc("/2", methodHandler("POST"))
-	router.PathPrefix("/1").Methods("DELETE").Subrouter().HandleFunc("/2", methodHandler("DELETE"))
-	router.PathPrefix("/1").Methods("PUT").Subrouter().HandleFunc("/2", methodHandler("PUT"))
-	router.PathPrefix("/1").Methods("POST").Subrouter().HandleFunc("/2", methodHandler("POST2"))
-
-	tests := []methodsSubrouterTest{
-		{
-			title:    "match first POST handler",
-			router:   router,
-			method:   "POST",
-			path:     "http://localhost/1/2",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match DELETE handler",
-			router:   router,
-			method:   "DELETE",
-			path:     "http://localhost/1/2",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match PUT handler",
-			router:   router,
-			method:   "PUT",
-			path:     "http://localhost/1/2",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "disallow PATCH method",
-			router:   router,
-			method:   "PATCH",
-			path:     "http://localhost/1/2",
-			wantCode: http.StatusMethodNotAllowed,
-		},
-	}
-
-	for _, test := range tests {
-		testMethodsSubrouter(t, test)
-	}
-}
-
-// TestMethodsSubrouterSubrouter matches handlers on subrouters produced
-// from method matchers registered on a root subrouter.
-func TestMethodsSubrouterSubrouter(t *testing.T) {
-	t.Parallel()
-
-	router := NewRouter()
-	sub := router.PathPrefix("/1").Subrouter()
-	sub.Methods("POST").Subrouter().HandleFunc("/2", methodHandler("POST"))
-	sub.Methods("GET").Subrouter().HandleFunc("/2", methodHandler("GET"))
-	sub.Methods("PATCH").Subrouter().HandleFunc("/2", methodHandler("PATCH"))
-	sub.HandleFunc("/2", methodHandler("PUT")).Subrouter().Methods("PUT")
-	sub.HandleFunc("/2", methodHandler("POST2")).Subrouter().Methods("POST")
-
-	tests := []methodsSubrouterTest{
-		{
-			title:    "match first POST handler",
-			router:   router,
-			method:   "POST",
-			path:     "http://localhost/1/2",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match GET handler",
-			router:   router,
-			method:   "GET",
-			path:     "http://localhost/1/2",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match PATCH handler",
-			router:   router,
-			method:   "PATCH",
-			path:     "http://localhost/1/2",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match PUT handler",
-			router:   router,
-			method:   "PUT",
-			path:     "http://localhost/1/2",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "disallow DELETE method",
-			router:   router,
-			method:   "DELETE",
-			path:     "http://localhost/1/2",
-			wantCode: http.StatusMethodNotAllowed,
-		},
-	}
-
-	for _, test := range tests {
-		testMethodsSubrouter(t, test)
-	}
-}
-
-// TestMethodsSubrouterPathVariable matches handlers on matching paths
-// with path variables in them.
-func TestMethodsSubrouterPathVariable(t *testing.T) {
-	t.Parallel()
-
-	router := NewRouter()
-	router.Methods("GET").Subrouter().HandleFunc("/foo", methodHandler("GET"))
-	router.Methods("POST").Subrouter().HandleFunc("/{any}", methodHandler("POST"))
-	router.Methods("DELETE").Subrouter().HandleFunc("/1/{any}", methodHandler("DELETE"))
-	router.Methods("PUT").Subrouter().HandleFunc("/1/{any}", methodHandler("PUT"))
-
-	tests := []methodsSubrouterTest{
-		{
-			title:    "match GET handler",
-			router:   router,
-			method:   "GET",
-			path:     "http://localhost/foo",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match POST handler",
-			router:   router,
-			method:   "POST",
-			path:     "http://localhost/foo",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match DELETE handler",
-			router:   router,
-			method:   "DELETE",
-			path:     "http://localhost/1/foo",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "match PUT handler",
-			router:   router,
-			method:   "PUT",
-			path:     "http://localhost/1/foo",
-			wantCode: http.StatusOK,
-		},
-		{
-			title:    "disallow PATCH method",
-			router:   router,
-			method:   "PATCH",
-			path:     "http://localhost/1/foo",
-			wantCode: http.StatusMethodNotAllowed,
-		},
-	}
-
-	for _, test := range tests {
-		testMethodsSubrouter(t, test)
-	}
-}
-
-// testMethodsSubrouter runs an individual methodsSubrouterTest.
-func testMethodsSubrouter(t *testing.T, test methodsSubrouterTest) {
-	// Execute request
-	req, _ := http.NewRequest(test.method, test.path, nil)
-	resp := NewRecorder()
-	test.router.ServeHTTP(resp, req)
-
-	switch test.wantCode {
-	case http.StatusMethodNotAllowed:
-		if resp.Code != http.StatusMethodNotAllowed {
-			t.Errorf(`(%s) Expected "405 Method Not Allowed", but got %d code`, test.title, resp.Code)
-		} else if matchedMethod := resp.Body.String(); matchedMethod != "" {
-			t.Errorf(`(%s) Expected "405 Method Not Allowed", but %q handler was called`, test.title, matchedMethod)
-		}
-
-	case http.StatusMovedPermanently:
-		if gotLocation := resp.HeaderMap.Get("Location"); gotLocation != test.redirectTo {
-			t.Errorf("(%s) Expected %q route-match to redirect to %q, but got %q", test.title, test.method, test.redirectTo, gotLocation)
-		}
-
-	case http.StatusOK:
-		if matchedMethod := resp.Body.String(); matchedMethod != test.method {
-			t.Errorf("(%s) Expected %q handler to be called, but %q handler was called", test.title, test.method, matchedMethod)
-		}
-
-	default:
-		expectedCodes := []int{http.StatusMethodNotAllowed, http.StatusMovedPermanently, http.StatusOK}
-		t.Errorf("(%s) Expected wantCode to be one of: %v, but got %d", test.title, expectedCodes, test.wantCode)
-	}
-}
-
-// mapToPairs converts a string map to a slice of string pairs
-func mapToPairs(m map[string]string) []string {
-	var i int
-	p := make([]string, len(m)*2)
-	for k, v := range m {
-		p[i] = k
-		p[i+1] = v
-		i += 2
-	}
-	return p
-}
-
-// stringMapEqual checks the equality of two string maps
-func stringMapEqual(m1, m2 map[string]string) bool {
-	nil1 := m1 == nil
-	nil2 := m2 == nil
-	if nil1 != nil2 || len(m1) != len(m2) {
-		return false
-	}
-	for k, v := range m1 {
-		if v != m2[k] {
-			return false
-		}
-	}
-	return true
-}
-
-// newRequest is a helper function to create a new request with a method and url.
-// The request returned is a 'server' request as opposed to a 'client' one through
-// simulated write onto the wire and read off of the wire.
-// The differences between requests are detailed in the net/http package.
-func newRequest(method, url string) *http.Request {
-	req, err := http.NewRequest(method, url, nil)
-	if err != nil {
-		panic(err)
-	}
-	// extract the escaped original host+path from url
-	// http://localhost/path/here?v=1#frag -> //localhost/path/here
-	opaque := ""
-	if i := len(req.URL.Scheme); i > 0 {
-		opaque = url[i+1:]
-	}
-
-	if i := strings.LastIndex(opaque, "?"); i > -1 {
-		opaque = opaque[:i]
-	}
-	if i := strings.LastIndex(opaque, "#"); i > -1 {
-		opaque = opaque[:i]
-	}
-
-	// Escaped host+path workaround as detailed in https://golang.org/pkg/net/url/#URL
-	// for < 1.5 client side workaround
-	req.URL.Opaque = opaque
-
-	// Simulate writing to wire
-	var buff bytes.Buffer
-	req.Write(&buff)
-	ioreader := bufio.NewReader(&buff)
-
-	// Parse request off of 'wire'
-	req, err = http.ReadRequest(ioreader)
-	if err != nil {
-		panic(err)
-	}
-	return req
-}
diff --git a/vendor/github.com/gorilla/mux/old_test.go b/vendor/github.com/gorilla/mux/old_test.go
deleted file mode 100644
index b228983c4..000000000
--- a/vendor/github.com/gorilla/mux/old_test.go
+++ /dev/null
@@ -1,704 +0,0 @@
-// Old tests ported to Go1. This is a mess. Want to drop it one day.
-
-// Copyright 2011 Gorilla Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package mux
-
-import (
-	"bytes"
-	"net/http"
-	"testing"
-)
-
-// ----------------------------------------------------------------------------
-// ResponseRecorder
-// ----------------------------------------------------------------------------
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// ResponseRecorder is an implementation of http.ResponseWriter that
-// records its mutations for later inspection in tests.
-type ResponseRecorder struct {
-	Code      int           // the HTTP response code from WriteHeader
-	HeaderMap http.Header   // the HTTP response headers
-	Body      *bytes.Buffer // if non-nil, the bytes.Buffer to append written data to
-	Flushed   bool
-}
-
-// NewRecorder returns an initialized ResponseRecorder.
-func NewRecorder() *ResponseRecorder {
-	return &ResponseRecorder{
-		HeaderMap: make(http.Header),
-		Body:      new(bytes.Buffer),
-	}
-}
-
-// Header returns the response headers.
-func (rw *ResponseRecorder) Header() http.Header {
-	return rw.HeaderMap
-}
-
-// Write always succeeds and writes to rw.Body, if not nil.
-func (rw *ResponseRecorder) Write(buf []byte) (int, error) {
-	if rw.Body != nil {
-		rw.Body.Write(buf)
-	}
-	if rw.Code == 0 {
-		rw.Code = http.StatusOK
-	}
-	return len(buf), nil
-}
-
-// WriteHeader sets rw.Code.
-func (rw *ResponseRecorder) WriteHeader(code int) {
-	rw.Code = code
-}
-
-// Flush sets rw.Flushed to true.
-func (rw *ResponseRecorder) Flush() {
-	rw.Flushed = true
-}
-
-// ----------------------------------------------------------------------------
-
-func TestRouteMatchers(t *testing.T) {
-	var scheme, host, path, query, method string
-	var headers map[string]string
-	var resultVars map[bool]map[string]string
-
-	router := NewRouter()
-	router.NewRoute().Host("{var1}.google.com").
-		Path("/{var2:[a-z]+}/{var3:[0-9]+}").
-		Queries("foo", "bar").
-		Methods("GET").
-		Schemes("https").
-		Headers("x-requested-with", "XMLHttpRequest")
-	router.NewRoute().Host("www.{var4}.com").
-		PathPrefix("/foo/{var5:[a-z]+}/{var6:[0-9]+}").
-		Queries("baz", "ding").
-		Methods("POST").
-		Schemes("http").
-		Headers("Content-Type", "application/json")
-
-	reset := func() {
-		// Everything match.
-		scheme = "https"
-		host = "www.google.com"
-		path = "/product/42"
-		query = "?foo=bar"
-		method = "GET"
-		headers = map[string]string{"X-Requested-With": "XMLHttpRequest"}
-		resultVars = map[bool]map[string]string{
-			true:  {"var1": "www", "var2": "product", "var3": "42"},
-			false: {},
-		}
-	}
-
-	reset2 := func() {
-		// Everything match.
-		scheme = "http"
-		host = "www.google.com"
-		path = "/foo/product/42/path/that/is/ignored"
-		query = "?baz=ding"
-		method = "POST"
-		headers = map[string]string{"Content-Type": "application/json"}
-		resultVars = map[bool]map[string]string{
-			true:  {"var4": "google", "var5": "product", "var6": "42"},
-			false: {},
-		}
-	}
-
-	match := func(shouldMatch bool) {
-		url := scheme + "://" + host + path + query
-		request, _ := http.NewRequest(method, url, nil)
-		for key, value := range headers {
-			request.Header.Add(key, value)
-		}
-
-		var routeMatch RouteMatch
-		matched := router.Match(request, &routeMatch)
-		if matched != shouldMatch {
-			t.Errorf("Expected: %v\nGot: %v\nRequest: %v %v", shouldMatch, matched, request.Method, url)
-		}
-
-		if matched {
-			currentRoute := routeMatch.Route
-			if currentRoute == nil {
-				t.Errorf("Expected a current route.")
-			}
-			vars := routeMatch.Vars
-			expectedVars := resultVars[shouldMatch]
-			if len(vars) != len(expectedVars) {
-				t.Errorf("Expected vars: %v Got: %v.", expectedVars, vars)
-			}
-			for name, value := range vars {
-				if expectedVars[name] != value {
-					t.Errorf("Expected vars: %v Got: %v.", expectedVars, vars)
-				}
-			}
-		}
-	}
-
-	// 1st route --------------------------------------------------------------
-
-	// Everything match.
-	reset()
-	match(true)
-
-	// Scheme doesn't match.
-	reset()
-	scheme = "http"
-	match(false)
-
-	// Host doesn't match.
-	reset()
-	host = "www.mygoogle.com"
-	match(false)
-
-	// Path doesn't match.
-	reset()
-	path = "/product/notdigits"
-	match(false)
-
-	// Query doesn't match.
-	reset()
-	query = "?foo=baz"
-	match(false)
-
-	// Method doesn't match.
-	reset()
-	method = "POST"
-	match(false)
-
-	// Header doesn't match.
-	reset()
-	headers = map[string]string{}
-	match(false)
-
-	// Everything match, again.
-	reset()
-	match(true)
-
-	// 2nd route --------------------------------------------------------------
-	// Everything match.
-	reset2()
-	match(true)
-
-	// Scheme doesn't match.
-	reset2()
-	scheme = "https"
-	match(false)
-
-	// Host doesn't match.
-	reset2()
-	host = "sub.google.com"
-	match(false)
-
-	// Path doesn't match.
-	reset2()
-	path = "/bar/product/42"
-	match(false)
-
-	// Query doesn't match.
-	reset2()
-	query = "?foo=baz"
-	match(false)
-
-	// Method doesn't match.
-	reset2()
-	method = "GET"
-	match(false)
-
-	// Header doesn't match.
-	reset2()
-	headers = map[string]string{}
-	match(false)
-
-	// Everything match, again.
-	reset2()
-	match(true)
-}
-
-type headerMatcherTest struct {
-	matcher headerMatcher
-	headers map[string]string
-	result  bool
-}
-
-var headerMatcherTests = []headerMatcherTest{
-	{
-		matcher: headerMatcher(map[string]string{"x-requested-with": "XMLHttpRequest"}),
-		headers: map[string]string{"X-Requested-With": "XMLHttpRequest"},
-		result:  true,
-	},
-	{
-		matcher: headerMatcher(map[string]string{"x-requested-with": ""}),
-		headers: map[string]string{"X-Requested-With": "anything"},
-		result:  true,
-	},
-	{
-		matcher: headerMatcher(map[string]string{"x-requested-with": "XMLHttpRequest"}),
-		headers: map[string]string{},
-		result:  false,
-	},
-}
-
-type hostMatcherTest struct {
-	matcher *Route
-	url     string
-	vars    map[string]string
-	result  bool
-}
-
-var hostMatcherTests = []hostMatcherTest{
-	{
-		matcher: NewRouter().NewRoute().Host("{foo:[a-z][a-z][a-z]}.{bar:[a-z][a-z][a-z]}.{baz:[a-z][a-z][a-z]}"),
-		url:     "http://abc.def.ghi/",
-		vars:    map[string]string{"foo": "abc", "bar": "def", "baz": "ghi"},
-		result:  true,
-	},
-	{
-		matcher: NewRouter().NewRoute().Host("{foo:[a-z][a-z][a-z]}.{bar:[a-z][a-z][a-z]}.{baz:[a-z][a-z][a-z]}"),
-		url:     "http://a.b.c/",
-		vars:    map[string]string{"foo": "abc", "bar": "def", "baz": "ghi"},
-		result:  false,
-	},
-}
-
-type methodMatcherTest struct {
-	matcher methodMatcher
-	method  string
-	result  bool
-}
-
-var methodMatcherTests = []methodMatcherTest{
-	{
-		matcher: methodMatcher([]string{"GET", "POST", "PUT"}),
-		method:  "GET",
-		result:  true,
-	},
-	{
-		matcher: methodMatcher([]string{"GET", "POST", "PUT"}),
-		method:  "POST",
-		result:  true,
-	},
-	{
-		matcher: methodMatcher([]string{"GET", "POST", "PUT"}),
-		method:  "PUT",
-		result:  true,
-	},
-	{
-		matcher: methodMatcher([]string{"GET", "POST", "PUT"}),
-		method:  "DELETE",
-		result:  false,
-	},
-}
-
-type pathMatcherTest struct {
-	matcher *Route
-	url     string
-	vars    map[string]string
-	result  bool
-}
-
-var pathMatcherTests = []pathMatcherTest{
-	{
-		matcher: NewRouter().NewRoute().Path("/{foo:[0-9][0-9][0-9]}/{bar:[0-9][0-9][0-9]}/{baz:[0-9][0-9][0-9]}"),
-		url:     "http://localhost:8080/123/456/789",
-		vars:    map[string]string{"foo": "123", "bar": "456", "baz": "789"},
-		result:  true,
-	},
-	{
-		matcher: NewRouter().NewRoute().Path("/{foo:[0-9][0-9][0-9]}/{bar:[0-9][0-9][0-9]}/{baz:[0-9][0-9][0-9]}"),
-		url:     "http://localhost:8080/1/2/3",
-		vars:    map[string]string{"foo": "123", "bar": "456", "baz": "789"},
-		result:  false,
-	},
-}
-
-type schemeMatcherTest struct {
-	matcher schemeMatcher
-	url     string
-	result  bool
-}
-
-var schemeMatcherTests = []schemeMatcherTest{
-	{
-		matcher: schemeMatcher([]string{"http", "https"}),
-		url:     "http://localhost:8080/",
-		result:  true,
-	},
-	{
-		matcher: schemeMatcher([]string{"http", "https"}),
-		url:     "https://localhost:8080/",
-		result:  true,
-	},
-	{
-		matcher: schemeMatcher([]string{"https"}),
-		url:     "http://localhost:8080/",
-		result:  false,
-	},
-	{
-		matcher: schemeMatcher([]string{"http"}),
-		url:     "https://localhost:8080/",
-		result:  false,
-	},
-}
-
-type urlBuildingTest struct {
-	route *Route
-	vars  []string
-	url   string
-}
-
-var urlBuildingTests = []urlBuildingTest{
-	{
-		route: new(Route).Host("foo.domain.com"),
-		vars:  []string{},
-		url:   "http://foo.domain.com",
-	},
-	{
-		route: new(Route).Host("{subdomain}.domain.com"),
-		vars:  []string{"subdomain", "bar"},
-		url:   "http://bar.domain.com",
-	},
-	{
-		route: new(Route).Host("foo.domain.com").Path("/articles"),
-		vars:  []string{},
-		url:   "http://foo.domain.com/articles",
-	},
-	{
-		route: new(Route).Path("/articles"),
-		vars:  []string{},
-		url:   "/articles",
-	},
-	{
-		route: new(Route).Path("/articles/{category}/{id:[0-9]+}"),
-		vars:  []string{"category", "technology", "id", "42"},
-		url:   "/articles/technology/42",
-	},
-	{
-		route: new(Route).Host("{subdomain}.domain.com").Path("/articles/{category}/{id:[0-9]+}"),
-		vars:  []string{"subdomain", "foo", "category", "technology", "id", "42"},
-		url:   "http://foo.domain.com/articles/technology/42",
-	},
-}
-
-func TestHeaderMatcher(t *testing.T) {
-	for _, v := range headerMatcherTests {
-		request, _ := http.NewRequest("GET", "http://localhost:8080/", nil)
-		for key, value := range v.headers {
-			request.Header.Add(key, value)
-		}
-		var routeMatch RouteMatch
-		result := v.matcher.Match(request, &routeMatch)
-		if result != v.result {
-			if v.result {
-				t.Errorf("%#v: should match %v.", v.matcher, request.Header)
-			} else {
-				t.Errorf("%#v: should not match %v.", v.matcher, request.Header)
-			}
-		}
-	}
-}
-
-func TestHostMatcher(t *testing.T) {
-	for _, v := range hostMatcherTests {
-		request, _ := http.NewRequest("GET", v.url, nil)
-		var routeMatch RouteMatch
-		result := v.matcher.Match(request, &routeMatch)
-		vars := routeMatch.Vars
-		if result != v.result {
-			if v.result {
-				t.Errorf("%#v: should match %v.", v.matcher, v.url)
-			} else {
-				t.Errorf("%#v: should not match %v.", v.matcher, v.url)
-			}
-		}
-		if result {
-			if len(vars) != len(v.vars) {
-				t.Errorf("%#v: vars length should be %v, got %v.", v.matcher, len(v.vars), len(vars))
-			}
-			for name, value := range vars {
-				if v.vars[name] != value {
-					t.Errorf("%#v: expected value %v for key %v, got %v.", v.matcher, v.vars[name], name, value)
-				}
-			}
-		} else {
-			if len(vars) != 0 {
-				t.Errorf("%#v: vars length should be 0, got %v.", v.matcher, len(vars))
-			}
-		}
-	}
-}
-
-func TestMethodMatcher(t *testing.T) {
-	for _, v := range methodMatcherTests {
-		request, _ := http.NewRequest(v.method, "http://localhost:8080/", nil)
-		var routeMatch RouteMatch
-		result := v.matcher.Match(request, &routeMatch)
-		if result != v.result {
-			if v.result {
-				t.Errorf("%#v: should match %v.", v.matcher, v.method)
-			} else {
-				t.Errorf("%#v: should not match %v.", v.matcher, v.method)
-			}
-		}
-	}
-}
-
-func TestPathMatcher(t *testing.T) {
-	for _, v := range pathMatcherTests {
-		request, _ := http.NewRequest("GET", v.url, nil)
-		var routeMatch RouteMatch
-		result := v.matcher.Match(request, &routeMatch)
-		vars := routeMatch.Vars
-		if result != v.result {
-			if v.result {
-				t.Errorf("%#v: should match %v.", v.matcher, v.url)
-			} else {
-				t.Errorf("%#v: should not match %v.", v.matcher, v.url)
-			}
-		}
-		if result {
-			if len(vars) != len(v.vars) {
-				t.Errorf("%#v: vars length should be %v, got %v.", v.matcher, len(v.vars), len(vars))
-			}
-			for name, value := range vars {
-				if v.vars[name] != value {
-					t.Errorf("%#v: expected value %v for key %v, got %v.", v.matcher, v.vars[name], name, value)
-				}
-			}
-		} else {
-			if len(vars) != 0 {
-				t.Errorf("%#v: vars length should be 0, got %v.", v.matcher, len(vars))
-			}
-		}
-	}
-}
-
-func TestSchemeMatcher(t *testing.T) {
-	for _, v := range schemeMatcherTests {
-		request, _ := http.NewRequest("GET", v.url, nil)
-		var routeMatch RouteMatch
-		result := v.matcher.Match(request, &routeMatch)
-		if result != v.result {
-			if v.result {
-				t.Errorf("%#v: should match %v.", v.matcher, v.url)
-			} else {
-				t.Errorf("%#v: should not match %v.", v.matcher, v.url)
-			}
-		}
-	}
-}
-
-func TestUrlBuilding(t *testing.T) {
-
-	for _, v := range urlBuildingTests {
-		u, _ := v.route.URL(v.vars...)
-		url := u.String()
-		if url != v.url {
-			t.Errorf("expected %v, got %v", v.url, url)
-			/*
-				reversePath := ""
-				reverseHost := ""
-				if v.route.pathTemplate != nil {
-						reversePath = v.route.pathTemplate.Reverse
-				}
-				if v.route.hostTemplate != nil {
-						reverseHost = v.route.hostTemplate.Reverse
-				}
-
-				t.Errorf("%#v:\nexpected: %q\ngot: %q\nreverse path: %q\nreverse host: %q", v.route, v.url, url, reversePath, reverseHost)
-			*/
-		}
-	}
-
-	ArticleHandler := func(w http.ResponseWriter, r *http.Request) {
-	}
-
-	router := NewRouter()
-	router.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler).Name("article")
-
-	url, _ := router.Get("article").URL("category", "technology", "id", "42")
-	expected := "/articles/technology/42"
-	if url.String() != expected {
-		t.Errorf("Expected %v, got %v", expected, url.String())
-	}
-}
-
-func TestMatchedRouteName(t *testing.T) {
-	routeName := "stock"
-	router := NewRouter()
-	route := router.NewRoute().Path("/products/").Name(routeName)
-
-	url := "http://www.example.com/products/"
-	request, _ := http.NewRequest("GET", url, nil)
-	var rv RouteMatch
-	ok := router.Match(request, &rv)
-
-	if !ok || rv.Route != route {
-		t.Errorf("Expected same route, got %+v.", rv.Route)
-	}
-
-	retName := rv.Route.GetName()
-	if retName != routeName {
-		t.Errorf("Expected %q, got %q.", routeName, retName)
-	}
-}
-
-func TestSubRouting(t *testing.T) {
-	// Example from docs.
-	router := NewRouter()
-	subrouter := router.NewRoute().Host("www.example.com").Subrouter()
-	route := subrouter.NewRoute().Path("/products/").Name("products")
-
-	url := "http://www.example.com/products/"
-	request, _ := http.NewRequest("GET", url, nil)
-	var rv RouteMatch
-	ok := router.Match(request, &rv)
-
-	if !ok || rv.Route != route {
-		t.Errorf("Expected same route, got %+v.", rv.Route)
-	}
-
-	u, _ := router.Get("products").URL()
-	builtURL := u.String()
-	// Yay, subroute aware of the domain when building!
-	if builtURL != url {
-		t.Errorf("Expected %q, got %q.", url, builtURL)
-	}
-}
-
-func TestVariableNames(t *testing.T) {
-	route := new(Route).Host("{arg1}.domain.com").Path("/{arg1}/{arg2:[0-9]+}")
-	if route.err == nil {
-		t.Errorf("Expected error for duplicated variable names")
-	}
-}
-
-func TestRedirectSlash(t *testing.T) {
-	var route *Route
-	var routeMatch RouteMatch
-	r := NewRouter()
-
-	r.StrictSlash(false)
-	route = r.NewRoute()
-	if route.strictSlash != false {
-		t.Errorf("Expected false redirectSlash.")
-	}
-
-	r.StrictSlash(true)
-	route = r.NewRoute()
-	if route.strictSlash != true {
-		t.Errorf("Expected true redirectSlash.")
-	}
-
-	route = new(Route)
-	route.strictSlash = true
-	route.Path("/{arg1}/{arg2:[0-9]+}/")
-	request, _ := http.NewRequest("GET", "http://localhost/foo/123", nil)
-	routeMatch = RouteMatch{}
-	_ = route.Match(request, &routeMatch)
-	vars := routeMatch.Vars
-	if vars["arg1"] != "foo" {
-		t.Errorf("Expected foo.")
-	}
-	if vars["arg2"] != "123" {
-		t.Errorf("Expected 123.")
-	}
-	rsp := NewRecorder()
-	routeMatch.Handler.ServeHTTP(rsp, request)
-	if rsp.HeaderMap.Get("Location") != "http://localhost/foo/123/" {
-		t.Errorf("Expected redirect header.")
-	}
-
-	route = new(Route)
-	route.strictSlash = true
-	route.Path("/{arg1}/{arg2:[0-9]+}")
-	request, _ = http.NewRequest("GET", "http://localhost/foo/123/", nil)
-	routeMatch = RouteMatch{}
-	_ = route.Match(request, &routeMatch)
-	vars = routeMatch.Vars
-	if vars["arg1"] != "foo" {
-		t.Errorf("Expected foo.")
-	}
-	if vars["arg2"] != "123" {
-		t.Errorf("Expected 123.")
-	}
-	rsp = NewRecorder()
-	routeMatch.Handler.ServeHTTP(rsp, request)
-	if rsp.HeaderMap.Get("Location") != "http://localhost/foo/123" {
-		t.Errorf("Expected redirect header.")
-	}
-}
-
-// Test for the new regexp library, still not available in stable Go.
-func TestNewRegexp(t *testing.T) {
-	var p *routeRegexp
-	var matches []string
-
-	tests := map[string]map[string][]string{
-		"/{foo:a{2}}": {
-			"/a":    nil,
-			"/aa":   {"aa"},
-			"/aaa":  nil,
-			"/aaaa": nil,
-		},
-		"/{foo:a{2,}}": {
-			"/a":    nil,
-			"/aa":   {"aa"},
-			"/aaa":  {"aaa"},
-			"/aaaa": {"aaaa"},
-		},
-		"/{foo:a{2,3}}": {
-			"/a":    nil,
-			"/aa":   {"aa"},
-			"/aaa":  {"aaa"},
-			"/aaaa": nil,
-		},
-		"/{foo:[a-z]{3}}/{bar:[a-z]{2}}": {
-			"/a":       nil,
-			"/ab":      nil,
-			"/abc":     nil,
-			"/abcd":    nil,
-			"/abc/ab":  {"abc", "ab"},
-			"/abc/abc": nil,
-			"/abcd/ab": nil,
-		},
-		`/{foo:\w{3,}}/{bar:\d{2,}}`: {
-			"/a":        nil,
-			"/ab":       nil,
-			"/abc":      nil,
-			"/abc/1":    nil,
-			"/abc/12":   {"abc", "12"},
-			"/abcd/12":  {"abcd", "12"},
-			"/abcd/123": {"abcd", "123"},
-		},
-	}
-
-	for pattern, paths := range tests {
-		p, _ = newRouteRegexp(pattern, regexpTypePath, routeRegexpOptions{})
-		for path, result := range paths {
-			matches = p.regexp.FindStringSubmatch(path)
-			if result == nil {
-				if matches != nil {
-					t.Errorf("%v should not match %v.", pattern, path)
-				}
-			} else {
-				if len(matches) != len(result)+1 {
-					t.Errorf("Expected %v matches, got %v.", len(result)+1, len(matches))
-				} else {
-					for k, v := range result {
-						if matches[k+1] != v {
-							t.Errorf("Expected %v, got %v.", v, matches[k+1])
-						}
-					}
-				}
-			}
-		}
-	}
-}