Merge pull request #807 from harshavardhana/migrate

Migrate to golang1.5 release with GO15VENDOREXPERIMENT=1 enabled

.travis.yml

@@ -10,7 +10,7 @@ before_install:
 - cd ..
 sudo: false
 go:
-- 1.4.2
+- 1.5
 notifications:
   slack:
     secure: K9tsn5MvrCAxuEZTxn+m3Kq1K2NG2xMEJFSv/sTp+RQBW7TslPHzv859GsIvrm8mU1y1btOU9RlOzqrRUczI5cJpE8IL1oljPZbXrIXgetE0kbsw0Wpy99g27UQ2VGp933WDu8tfj7zU4cZv+BI0RltNLwqYO6GWXmcWP0IueCU=

CONTRIBUTING.md

@@ -53,7 +53,9 @@ Building Libraries
 * If you have additional dependencies for ``Minio``, ``Minio`` manages its depedencies using [govendor](https://github.com/kardianos/govendor)
     - Run `go get foo/bar`
     - Edit your code to import foo/bar
-    - Run `govendor add foo/bar` from top-level directory
+    - export GO15VENDOREXPERIMENT=1
+    - Run `govendor remove +vendor` from top-level directory
+    - Run `govendor add +external` from top-level directory
 
 * When you're ready to create a pull request, be sure to:
     - Have test cases for the new code. If you have questions about how to do it, please ask in your pull request.

Dockerfile

@@ -3,7 +3,7 @@ FROM ubuntu:14.04
 
 MAINTAINER Minio Community
 
-ENV GOLANG_TARBALL go1.4.2.linux-amd64.tar.gz
+ENV GOLANG_TARBALL go1.5.linux-amd64.tar.gz
 
 ENV GOROOT /usr/local/go/
 ENV GOPATH /go-workspace

INSTALLGO.md

@@ -7,15 +7,15 @@ This installation document assumes Ubuntu 14.04+ on x86-64 platform.
 $ sudo apt-get install git build-essential yasm
 ```
 
-##### Install Go 1.4+
+##### Install Go 1.5+
 
-Download Go 1.4+ from [https://golang.org/dl/](https://golang.org/dl/).
+Download Go 1.5+ from [https://golang.org/dl/](https://golang.org/dl/).
 
 ```sh
-$ wget https://storage.googleapis.com/golang/go1.4.linux-amd64.tar.gz
+$ wget https://storage.googleapis.com/golang/go1.5.linux-amd64.tar.gz
 $ mkdir -p ${HOME}/bin/
 $ mkdir -p ${HOME}/go/
-$ tar -C ${HOME}/bin/ -xzf go1.4.linux-amd64.tar.gz
+$ tar -C ${HOME}/bin/ -xzf go1.5.linux-amd64.tar.gz
 ```
 ##### Setup GOROOT and GOPATH
 
@@ -42,7 +42,7 @@ $ ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/maste
 $ brew install git python yasm
 ```
 
-##### Install Go 1.4+
+##### Install Go 1.5+
 
 Install golang binaries using `brew`
 

Makefile

@@ -17,33 +17,34 @@ verifiers: getdeps vet fmt lint cyclo
 
 vet:
 	@echo "Running $@:"
-	@go vet .
+	@GO15VENDOREXPERIMENT=1 go vet .
-	@go vet github.com/minio/minio/pkg...
+	@GO15VENDOREXPERIMENT=1 go vet github.com/minio/minio/pkg...
+
 fmt:
 	@echo "Running $@:"
-	@gofmt -s -l *.go
+	@GO15VENDOREXPERIMENT=1 gofmt -s -l *.go
-	@gofmt -s -l pkg
+	@GO15VENDOREXPERIMENT=1 gofmt -s -l pkg
 
 lint:
 	@echo "Running $@:"
-	@golint .
+	@GO15VENDOREXPERIMENT=1 golint .
-	@golint pkg
+	@GO15VENDOREXPERIMENT=1 golint pkg
 
 cyclo:
 	@echo "Running $@:"
-	@gocyclo -over 25 .
+	@GO15VENDOREXPERIMENT=1 gocyclo -over 25 .
 
 build: getdeps verifiers
 	@echo "Installing minio:"
-	@go generate ./...
+	@GO15VENDOREXPERIMENT=1 go generate ./...
-	@go test -race github.com/minio/minio/pkg...
+	@GO15VENDOREXPERIMENT=1 go test -race github.com/minio/minio/pkg...
 
 gomake-all: build
-	@go install github.com/minio/minio
+	@GO15VENDOREXPERIMENT=1 go install github.com/minio/minio
 
 release: genversion
 	@echo "Installing minio for new version.go:"
-	@go install github.com/minio/minio
+	@GO15VENDOREXPERIMENT=1 go install github.com/minio/minio
 
 genversion:
 	@echo "Generating new minio version.go"

buildscripts/checkdeps.sh

@@ -24,7 +24,7 @@ _init() {
     CLANG_VERSION="3.5"
     YASM_VERSION="1.2.0"
     GIT_VERSION="1.0"
-    GO_VERSION="1.4"
+    GO_VERSION="1.5"
     OSX_VERSION="10.8"
     UNAME=$(uname -sm)
 
@@ -173,7 +173,7 @@ is_supported_arch() {
 check_deps() {
     check_version "$(env go version 2>/dev/null | sed 's/^.* go\([0-9.]*\).*$/\1/')" "${GO_VERSION}"
     if [ $? -ge 2 ]; then
-        MISSING="${MISSING} golang(1.4)"
+        MISSING="${MISSING} golang(1.5)"
     fi
 
     check_version "$(env git --version 2>/dev/null | sed -e 's/^.* \([0-9.\].*\).*$/\1/' -e 's/^\([0-9.\]*\).*/\1/g')" "${GIT_VERSION}"

commands.go

@@ -16,7 +16,7 @@
 
 package main
 
-import "github.com/minio/minio/internal/github.com/minio/cli"
+import "github.com/minio/cli"
 
 // Collection of minio commands currently supported are
 var commands = []cli.Command{}

controller-main.go

@@ -17,7 +17,7 @@
 package main
 
 import (
-	"github.com/minio/minio/internal/github.com/minio/cli"
+	"github.com/minio/cli"
 	"github.com/minio/minio/pkg/controller"
 )
 

donut-main.go

@@ -20,7 +20,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/minio/minio/internal/github.com/minio/cli"
+	"github.com/minio/cli"
 	"github.com/minio/minio/pkg/donut"
 )
 

flags.go

@@ -16,7 +16,7 @@
 
 package main
 
-import "github.com/minio/minio/internal/github.com/minio/cli"
+import "github.com/minio/cli"
 
 // Collection of minio flags currently supported
 var flags = []cli.Flag{}

main.go

@@ -25,8 +25,8 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/minio/minio/internal/github.com/dustin/go-humanize"
+	"github.com/dustin/go-humanize"
-	"github.com/minio/minio/internal/github.com/minio/cli"
+	"github.com/minio/cli"
 )
 
 var globalDebugFlag = false

pkg/auth/auth_test.go

@@ -19,8 +19,8 @@ package auth_test
 import (
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
 	"github.com/minio/minio/pkg/auth"
+	. "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) { TestingT(t) }

pkg/controller/client.go

@@ -20,7 +20,7 @@ import (
 	"encoding/json"
 	"net/http"
 
-	jsonrpc "github.com/minio/minio/internal/github.com/gorilla/rpc/v2/json"
+	jsonrpc "github.com/gorilla/rpc/v2/json"
 	"github.com/minio/minio/pkg/auth"
 	"github.com/minio/minio/pkg/probe"
 	"github.com/minio/minio/pkg/server/rpc"

pkg/controller/rpc.go

@@ -20,7 +20,7 @@ import (
 	"bytes"
 	"net/http"
 
-	"github.com/minio/minio/internal/github.com/gorilla/rpc/v2/json"
+	"github.com/gorilla/rpc/v2/json"
 	"github.com/minio/minio/pkg/probe"
 )
 

pkg/cpu/cpu_test.go

@@ -23,8 +23,8 @@ import (
 	"strings"
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
 	"github.com/minio/minio/pkg/cpu"
+	. "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) { TestingT(t) }

pkg/crypto/md5/md5_test.go

@@ -5,8 +5,8 @@ import (
 	"encoding/hex"
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
 	"github.com/minio/minio/pkg/crypto/md5"
+	. "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) { TestingT(t) }

pkg/donut/cache/data/data_test.go

@@ -19,7 +19,7 @@ package data
 import (
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
+	. "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) { TestingT(t) }

pkg/donut/cache/metadata/metadata_test.go

@@ -19,7 +19,7 @@ package metadata
 import (
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
+	. "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) { TestingT(t) }

pkg/donut/disk/disk_test.go

@@ -22,7 +22,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
+	. "gopkg.in/check.v1"
 )
 
 func TestDisk(t *testing.T) { TestingT(t) }

pkg/donut/donut-v1_test.go

@@ -27,7 +27,7 @@ import (
 	"strconv"
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
+	. "gopkg.in/check.v1"
 )
 
 func TestDonut(t *testing.T) { TestingT(t) }

pkg/donut/donut-v2_test.go

@@ -26,7 +26,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
+	. "gopkg.in/check.v1"
 )
 
 func TestCache(t *testing.T) { TestingT(t) }

pkg/erasure/INSTALLGO.md

@@ -7,15 +7,15 @@ This installation document assumes Ubuntu 14.04+ on x86-64 platform.
 $ sudo apt-get install git build-essential yasm
 ```
 
-##### Install Go 1.4+
+##### Install Go 1.5+
 
-Download Go 1.4+ from [https://golang.org/dl/](https://golang.org/dl/).
+Download Go 1.5+ from [https://golang.org/dl/](https://golang.org/dl/).
 
 ```sh
-$ wget https://storage.googleapis.com/golang/go1.4.linux-amd64.tar.gz
+$ wget https://storage.googleapis.com/golang/go1.5.linux-amd64.tar.gz
 $ mkdir -p ${HOME}/bin/
 $ mkdir -p ${HOME}/go/
-$ tar -C ${HOME}/bin/ -xzf go1.4.linux-amd64.tar.gz
+$ tar -C ${HOME}/bin/ -xzf go1.5.linux-amd64.tar.gz
 ```
 ##### Setup GOROOT and GOPATH
 
@@ -42,7 +42,7 @@ $ ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/maste
 $ brew install git python yasm
 ```
 
-##### Install Go 1.4+
+##### Install Go 1.5+
 
 Install golang binaries using `brew`
 

pkg/erasure/cauchy_test.go

@@ -20,7 +20,7 @@ import (
 	"bytes"
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
+	. "gopkg.in/check.v1"
 )
 
 type MySuite struct{}

pkg/erasure/vandermonde_test.go

@@ -19,7 +19,7 @@ package erasure
 import (
 	"bytes"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
+	. "gopkg.in/check.v1"
 )
 
 func corruptChunks(chunks [][]byte, errorIndex []int) [][]byte {

pkg/probe/probe.go

@@ -26,7 +26,7 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/minio/minio/internal/github.com/dustin/go-humanize"
+	"github.com/dustin/go-humanize"
 )
 
 // GetSysInfo returns useful system statistics.

pkg/probe/probe_test.go

@@ -19,8 +19,8 @@ import (
 	"os"
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
 	"github.com/minio/minio/pkg/probe"
+	. "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) { TestingT(t) }

pkg/quick/quick.go

@@ -28,7 +28,7 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/minio/minio/internal/github.com/fatih/structs"
+	"github.com/fatih/structs"
 	"github.com/minio/minio/pkg/probe"
 )
 

pkg/quick/quick_test.go

@@ -22,8 +22,8 @@ import (
 	"os"
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
 	"github.com/minio/minio/pkg/quick"
+	. "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) { TestingT(t) }

pkg/server/api/bucket-handlers.go

@@ -19,7 +19,7 @@ package api
 import (
 	"net/http"
 
-	"github.com/minio/minio/internal/github.com/gorilla/mux"
+	"github.com/gorilla/mux"
 	"github.com/minio/minio/pkg/donut"
 	"github.com/minio/minio/pkg/probe"
 	"github.com/minio/minio/pkg/utils/log"

pkg/server/api/object-handlers.go

@@ -20,7 +20,7 @@ import (
 	"net/http"
 	"strconv"
 
-	"github.com/minio/minio/internal/github.com/gorilla/mux"
+	"github.com/gorilla/mux"
 	"github.com/minio/minio/pkg/donut"
 	"github.com/minio/minio/pkg/probe"
 	"github.com/minio/minio/pkg/utils/log"

pkg/server/api_donut_cache_test.go

@@ -27,9 +27,9 @@ import (
 	"net/http"
 	"net/http/httptest"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
 	"github.com/minio/minio/pkg/donut"
 	"github.com/minio/minio/pkg/server/api"
+	. "gopkg.in/check.v1"
 )
 
 type MyAPIDonutCacheSuite struct {

pkg/server/api_donut_test.go

@@ -28,9 +28,9 @@ import (
 	"net/http"
 	"net/http/httptest"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
 	"github.com/minio/minio/pkg/donut"
 	"github.com/minio/minio/pkg/server/api"
+	. "gopkg.in/check.v1"
 )
 
 type MyAPIDonutSuite struct {

pkg/server/api_signature_v4_test.go

@@ -28,10 +28,10 @@ import (
 	"net/http"
 	"net/http/httptest"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
 	"github.com/minio/minio/pkg/auth"
 	"github.com/minio/minio/pkg/donut"
 	"github.com/minio/minio/pkg/server/api"
+	. "gopkg.in/check.v1"
 )
 
 type MyAPISignatureV4Suite struct {

pkg/server/minhttp/http.go

@@ -31,7 +31,7 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/minio/minio/internal/github.com/facebookgo/httpdown"
+	"github.com/facebookgo/httpdown"
 	"github.com/minio/minio/pkg/probe"
 )
 

pkg/server/router.go

@@ -19,7 +19,7 @@ package server
 import (
 	"net/http"
 
-	router "github.com/minio/minio/internal/github.com/gorilla/mux"
+	router "github.com/gorilla/mux"
 	"github.com/minio/minio/pkg/server/api"
 	"github.com/minio/minio/pkg/server/rpc"
 )

pkg/server/rpc/server.go

@@ -19,8 +19,8 @@ package rpc
 import (
 	"net/http"
 
-	"github.com/minio/minio/internal/github.com/gorilla/rpc/v2"
+	"github.com/gorilla/rpc/v2"
-	"github.com/minio/minio/internal/github.com/gorilla/rpc/v2/json"
+	"github.com/gorilla/rpc/v2/json"
 )
 
 // Server rpc server container

pkg/server/rpc_test.go

@@ -20,10 +20,10 @@ import (
 	"net/http"
 	"net/http/httptest"
 
-	jsonrpc "github.com/minio/minio/internal/github.com/gorilla/rpc/v2/json"
+	jsonrpc "github.com/gorilla/rpc/v2/json"
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
 	"github.com/minio/minio/pkg/controller"
 	"github.com/minio/minio/pkg/server/rpc"
+	. "gopkg.in/check.v1"
 )
 
 type MyRPCSuite struct{}

pkg/server/signature-v4_test.go

@@ -32,7 +32,7 @@ import (
 	"time"
 	"unicode/utf8"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
+	. "gopkg.in/check.v1"
 )
 
 // Hook up gocheck into the "go test" runner.

pkg/utils/atomic/atomic_test.go

@@ -22,7 +22,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	. "github.com/minio/minio/internal/gopkg.in/check.v1"
+	. "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) { TestingT(t) }

server-main.go

@@ -17,7 +17,7 @@
 package main
 
 import (
-	"github.com/minio/minio/internal/github.com/minio/cli"
+	"github.com/minio/cli"
 	"github.com/minio/minio/pkg/server"
 	"github.com/minio/minio/pkg/server/api"
 )

vendor.json

@@ -1,81 +1,81 @@
 {
 	"comment": "",
-	"ignore": "test",
+	"ignore": "",
 	"package": [
 		{
 			"canonical": "github.com/dustin/go-humanize",
 			"comment": "",
-			"local": "github.com/dustin/go-humanize",
+			"local": "vendor/github.com/dustin/go-humanize",
 			"revision": "1c212aae1d02984808182b98b0da7a3e07e4c770",
 			"revisionTime": "2015-08-09T13:14:05-07:00"
 		},
 		{
 			"canonical": "github.com/facebookgo/clock",
 			"comment": "",
-			"local": "github.com/facebookgo/clock",
+			"local": "vendor/github.com/facebookgo/clock",
 			"revision": "600d898af40aa09a7a93ecb9265d87b0504b6f03",
 			"revisionTime": "2015-04-09T18:09:13-07:00"
 		},
 		{
 			"canonical": "github.com/facebookgo/httpdown",
 			"comment": "",
-			"local": "github.com/facebookgo/httpdown",
+			"local": "vendor/github.com/facebookgo/httpdown",
 			"revision": "9229879964ff32fc4e42c7ba6b4745efce39023c",
 			"revisionTime": "2015-08-07T22:21:07Z"
 		},
 		{
 			"canonical": "github.com/facebookgo/stats",
 			"comment": "",
-			"local": "github.com/facebookgo/stats",
+			"local": "vendor/github.com/facebookgo/stats",
 			"revision": "31fb71caf5a4f04c9f8bb3fa8e7c2597ba6eb50a",
 			"revisionTime": "2015-06-12T18:29:15Z"
 		},
 		{
 			"canonical": "github.com/fatih/structs",
 			"comment": "",
-			"local": "github.com/fatih/structs",
+			"local": "vendor/github.com/fatih/structs",
 			"revision": "a9f7daa9c2729e97450c2da2feda19130a367d8f",
 			"revisionTime": "2015-05-26T09:43:52+03:00"
 		},
 		{
 			"canonical": "github.com/gorilla/context",
 			"comment": "",
-			"local": "github.com/gorilla/context",
+			"local": "vendor/github.com/gorilla/context",
 			"revision": "215affda49addc4c8ef7e2534915df2c8c35c6cd",
 			"revisionTime": "2014-12-17T08:02:51-08:00"
 		},
 		{
 			"canonical": "github.com/gorilla/mux",
 			"comment": "",
-			"local": "github.com/gorilla/mux",
+			"local": "vendor/github.com/gorilla/mux",
 			"revision": "5112c33f3a6ef694c1e5784b68981f08b3f0327c",
 			"revisionTime": "2015-08-11T22:16:22-07:00"
 		},
 		{
 			"canonical": "github.com/gorilla/rpc/v2",
 			"comment": "",
-			"local": "github.com/gorilla/rpc/v2",
+			"local": "vendor/github.com/gorilla/rpc/v2",
 			"revision": "74aa4b5cceca1188df2c7128f7ede4c92893701e",
 			"revisionTime": "2015-08-09T21:43:58-07:00"
 		},
 		{
 			"canonical": "github.com/gorilla/rpc/v2/json",
 			"comment": "",
-			"local": "github.com/gorilla/rpc/v2/json",
+			"local": "vendor/github.com/gorilla/rpc/v2/json",
 			"revision": "74aa4b5cceca1188df2c7128f7ede4c92893701e",
 			"revisionTime": "2015-08-09T21:43:58-07:00"
 		},
 		{
 			"canonical": "github.com/minio/cli",
 			"comment": "",
-			"local": "github.com/minio/cli",
+			"local": "vendor/github.com/minio/cli",
-			"revision": "9280cbaadcdd26d50b5ae85123682e37944701de",
+			"revision": "ee386baecc113eef2b8945df429120a5aec319ef",
-			"revisionTime": "2015-07-24T23:32:06-07:00"
+			"revisionTime": "2015-08-19T11:23:55-07:00"
 		},
 		{
 			"canonical": "gopkg.in/check.v1",
 			"comment": "",
-			"local": "gopkg.in/check.v1",
+			"local": "vendor/gopkg.in/check.v1",
 			"revision": "11d3bc7aa68e238947792f30573146a3231fc0f1",
 			"revisionTime": "2015-07-29T10:04:31+02:00"
 		}

vendor/github.com/dustin/go-humanize/bigbytes_test.go

@@ -0,0 +1,219 @@
+package humanize
+
+import (
+	"math/big"
+	"testing"
+)
+
+func TestBigByteParsing(t *testing.T) {
+	tests := []struct {
+		in  string
+		exp uint64
+	}{
+		{"42", 42},
+		{"42MB", 42000000},
+		{"42MiB", 44040192},
+		{"42mb", 42000000},
+		{"42mib", 44040192},
+		{"42MIB", 44040192},
+		{"42 MB", 42000000},
+		{"42 MiB", 44040192},
+		{"42 mb", 42000000},
+		{"42 mib", 44040192},
+		{"42 MIB", 44040192},
+		{"42.5MB", 42500000},
+		{"42.5MiB", 44564480},
+		{"42.5 MB", 42500000},
+		{"42.5 MiB", 44564480},
+		// No need to say B
+		{"42M", 42000000},
+		{"42Mi", 44040192},
+		{"42m", 42000000},
+		{"42mi", 44040192},
+		{"42MI", 44040192},
+		{"42 M", 42000000},
+		{"42 Mi", 44040192},
+		{"42 m", 42000000},
+		{"42 mi", 44040192},
+		{"42 MI", 44040192},
+		{"42.5M", 42500000},
+		{"42.5Mi", 44564480},
+		{"42.5 M", 42500000},
+		{"42.5 Mi", 44564480},
+		// Large testing, breaks when too much larger than
+		// this.
+		{"12.5 EB", uint64(12.5 * float64(EByte))},
+		{"12.5 E", uint64(12.5 * float64(EByte))},
+		{"12.5 EiB", uint64(12.5 * float64(EiByte))},
+	}
+
+	for _, p := range tests {
+		got, err := ParseBigBytes(p.in)
+		if err != nil {
+			t.Errorf("Couldn't parse %v: %v", p.in, err)
+		} else {
+			if got.Uint64() != p.exp {
+				t.Errorf("Expected %v for %v, got %v",
+					p.exp, p.in, got)
+			}
+		}
+	}
+}
+
+func TestBigByteErrors(t *testing.T) {
+	got, err := ParseBigBytes("84 JB")
+	if err == nil {
+		t.Errorf("Expected error, got %v", got)
+	}
+	got, err = ParseBigBytes("")
+	if err == nil {
+		t.Errorf("Expected error parsing nothing")
+	}
+}
+
+func bbyte(in uint64) string {
+	return BigBytes((&big.Int{}).SetUint64(in))
+}
+
+func bibyte(in uint64) string {
+	return BigIBytes((&big.Int{}).SetUint64(in))
+}
+
+func TestBigBytes(t *testing.T) {
+	testList{
+		{"bytes(0)", bbyte(0), "0B"},
+		{"bytes(1)", bbyte(1), "1B"},
+		{"bytes(803)", bbyte(803), "803B"},
+		{"bytes(999)", bbyte(999), "999B"},
+
+		{"bytes(1024)", bbyte(1024), "1.0kB"},
+		{"bytes(1MB - 1)", bbyte(MByte - Byte), "1000kB"},
+
+		{"bytes(1MB)", bbyte(1024 * 1024), "1.0MB"},
+		{"bytes(1GB - 1K)", bbyte(GByte - KByte), "1000MB"},
+
+		{"bytes(1GB)", bbyte(GByte), "1.0GB"},
+		{"bytes(1TB - 1M)", bbyte(TByte - MByte), "1000GB"},
+
+		{"bytes(1TB)", bbyte(TByte), "1.0TB"},
+		{"bytes(1PB - 1T)", bbyte(PByte - TByte), "999TB"},
+
+		{"bytes(1PB)", bbyte(PByte), "1.0PB"},
+		{"bytes(1PB - 1T)", bbyte(EByte - PByte), "999PB"},
+
+		{"bytes(1EB)", bbyte(EByte), "1.0EB"},
+		// Overflows.
+		// {"bytes(1EB - 1P)", Bytes((KByte*EByte)-PByte), "1023EB"},
+
+		{"bytes(0)", bibyte(0), "0B"},
+		{"bytes(1)", bibyte(1), "1B"},
+		{"bytes(803)", bibyte(803), "803B"},
+		{"bytes(1023)", bibyte(1023), "1023B"},
+
+		{"bytes(1024)", bibyte(1024), "1.0KiB"},
+		{"bytes(1MB - 1)", bibyte(MiByte - IByte), "1024KiB"},
+
+		{"bytes(1MB)", bibyte(1024 * 1024), "1.0MiB"},
+		{"bytes(1GB - 1K)", bibyte(GiByte - KiByte), "1024MiB"},
+
+		{"bytes(1GB)", bibyte(GiByte), "1.0GiB"},
+		{"bytes(1TB - 1M)", bibyte(TiByte - MiByte), "1024GiB"},
+
+		{"bytes(1TB)", bibyte(TiByte), "1.0TiB"},
+		{"bytes(1PB - 1T)", bibyte(PiByte - TiByte), "1023TiB"},
+
+		{"bytes(1PB)", bibyte(PiByte), "1.0PiB"},
+		{"bytes(1PB - 1T)", bibyte(EiByte - PiByte), "1023PiB"},
+
+		{"bytes(1EiB)", bibyte(EiByte), "1.0EiB"},
+		// Overflows.
+		// {"bytes(1EB - 1P)", bibyte((KIByte*EIByte)-PiByte), "1023EB"},
+
+		{"bytes(5.5GiB)", bibyte(5.5 * GiByte), "5.5GiB"},
+
+		{"bytes(5.5GB)", bbyte(5.5 * GByte), "5.5GB"},
+	}.validate(t)
+}
+
+func TestVeryBigBytes(t *testing.T) {
+	b, _ := (&big.Int{}).SetString("15347691069326346944512", 10)
+	s := BigBytes(b)
+	if s != "15ZB" {
+		t.Errorf("Expected 15ZB, got %v", s)
+	}
+	s = BigIBytes(b)
+	if s != "13ZiB" {
+		t.Errorf("Expected 13ZiB, got %v", s)
+	}
+
+	b, _ = (&big.Int{}).SetString("15716035654990179271180288", 10)
+	s = BigBytes(b)
+	if s != "16YB" {
+		t.Errorf("Expected 16YB, got %v", s)
+	}
+	s = BigIBytes(b)
+	if s != "13YiB" {
+		t.Errorf("Expected 13YiB, got %v", s)
+	}
+}
+
+func TestVeryVeryBigBytes(t *testing.T) {
+	b, _ := (&big.Int{}).SetString("16093220510709943573688614912", 10)
+	s := BigBytes(b)
+	if s != "16093YB" {
+		t.Errorf("Expected 16093YB, got %v", s)
+	}
+	s = BigIBytes(b)
+	if s != "13312YiB" {
+		t.Errorf("Expected 13312YiB, got %v", s)
+	}
+}
+
+func TestParseVeryBig(t *testing.T) {
+	tests := []struct {
+		in  string
+		out string
+	}{
+		{"16ZB", "16000000000000000000000"},
+		{"16ZiB", "18889465931478580854784"},
+		{"16.5ZB", "16500000000000000000000"},
+		{"16.5ZiB", "19479761741837286506496"},
+		{"16Z", "16000000000000000000000"},
+		{"16Zi", "18889465931478580854784"},
+		{"16.5Z", "16500000000000000000000"},
+		{"16.5Zi", "19479761741837286506496"},
+
+		{"16YB", "16000000000000000000000000"},
+		{"16YiB", "19342813113834066795298816"},
+		{"16.5YB", "16500000000000000000000000"},
+		{"16.5YiB", "19947276023641381382651904"},
+		{"16Y", "16000000000000000000000000"},
+		{"16Yi", "19342813113834066795298816"},
+		{"16.5Y", "16500000000000000000000000"},
+		{"16.5Yi", "19947276023641381382651904"},
+	}
+
+	for _, test := range tests {
+		x, err := ParseBigBytes(test.in)
+		if err != nil {
+			t.Errorf("Error parsing %q: %v", test.in, err)
+			continue
+		}
+
+		if x.String() != test.out {
+			t.Errorf("Expected %q for %q, got %v", test.out, test.in, x)
+		}
+	}
+}
+
+func BenchmarkParseBigBytes(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		ParseBigBytes("16.5Z")
+	}
+}
+
+func BenchmarkBigBytes(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		bibyte(16.5 * GByte)
+	}
+}

vendor/github.com/dustin/go-humanize/bytes_test.go

@@ -0,0 +1,144 @@
+package humanize
+
+import (
+	"testing"
+)
+
+func TestByteParsing(t *testing.T) {
+	tests := []struct {
+		in  string
+		exp uint64
+	}{
+		{"42", 42},
+		{"42MB", 42000000},
+		{"42MiB", 44040192},
+		{"42mb", 42000000},
+		{"42mib", 44040192},
+		{"42MIB", 44040192},
+		{"42 MB", 42000000},
+		{"42 MiB", 44040192},
+		{"42 mb", 42000000},
+		{"42 mib", 44040192},
+		{"42 MIB", 44040192},
+		{"42.5MB", 42500000},
+		{"42.5MiB", 44564480},
+		{"42.5 MB", 42500000},
+		{"42.5 MiB", 44564480},
+		// No need to say B
+		{"42M", 42000000},
+		{"42Mi", 44040192},
+		{"42m", 42000000},
+		{"42mi", 44040192},
+		{"42MI", 44040192},
+		{"42 M", 42000000},
+		{"42 Mi", 44040192},
+		{"42 m", 42000000},
+		{"42 mi", 44040192},
+		{"42 MI", 44040192},
+		{"42.5M", 42500000},
+		{"42.5Mi", 44564480},
+		{"42.5 M", 42500000},
+		{"42.5 Mi", 44564480},
+		// Large testing, breaks when too much larger than
+		// this.
+		{"12.5 EB", uint64(12.5 * float64(EByte))},
+		{"12.5 E", uint64(12.5 * float64(EByte))},
+		{"12.5 EiB", uint64(12.5 * float64(EiByte))},
+	}
+
+	for _, p := range tests {
+		got, err := ParseBytes(p.in)
+		if err != nil {
+			t.Errorf("Couldn't parse %v: %v", p.in, err)
+		}
+		if got != p.exp {
+			t.Errorf("Expected %v for %v, got %v",
+				p.exp, p.in, got)
+		}
+	}
+}
+
+func TestByteErrors(t *testing.T) {
+	got, err := ParseBytes("84 JB")
+	if err == nil {
+		t.Errorf("Expected error, got %v", got)
+	}
+	got, err = ParseBytes("")
+	if err == nil {
+		t.Errorf("Expected error parsing nothing")
+	}
+	got, err = ParseBytes("16 EiB")
+	if err == nil {
+		t.Errorf("Expected error, got %v", got)
+	}
+}
+
+func TestBytes(t *testing.T) {
+	testList{
+		{"bytes(0)", Bytes(0), "0B"},
+		{"bytes(1)", Bytes(1), "1B"},
+		{"bytes(803)", Bytes(803), "803B"},
+		{"bytes(999)", Bytes(999), "999B"},
+
+		{"bytes(1024)", Bytes(1024), "1.0kB"},
+		{"bytes(9999)", Bytes(9999), "10kB"},
+		{"bytes(1MB - 1)", Bytes(MByte - Byte), "1000kB"},
+
+		{"bytes(1MB)", Bytes(1024 * 1024), "1.0MB"},
+		{"bytes(1GB - 1K)", Bytes(GByte - KByte), "1000MB"},
+
+		{"bytes(1GB)", Bytes(GByte), "1.0GB"},
+		{"bytes(1TB - 1M)", Bytes(TByte - MByte), "1000GB"},
+		{"bytes(10MB)", Bytes(9999 * 1000), "10MB"},
+
+		{"bytes(1TB)", Bytes(TByte), "1.0TB"},
+		{"bytes(1PB - 1T)", Bytes(PByte - TByte), "999TB"},
+
+		{"bytes(1PB)", Bytes(PByte), "1.0PB"},
+		{"bytes(1PB - 1T)", Bytes(EByte - PByte), "999PB"},
+
+		{"bytes(1EB)", Bytes(EByte), "1.0EB"},
+		// Overflows.
+		// {"bytes(1EB - 1P)", Bytes((KByte*EByte)-PByte), "1023EB"},
+
+		{"bytes(0)", IBytes(0), "0B"},
+		{"bytes(1)", IBytes(1), "1B"},
+		{"bytes(803)", IBytes(803), "803B"},
+		{"bytes(1023)", IBytes(1023), "1023B"},
+
+		{"bytes(1024)", IBytes(1024), "1.0KiB"},
+		{"bytes(1MB - 1)", IBytes(MiByte - IByte), "1024KiB"},
+
+		{"bytes(1MB)", IBytes(1024 * 1024), "1.0MiB"},
+		{"bytes(1GB - 1K)", IBytes(GiByte - KiByte), "1024MiB"},
+
+		{"bytes(1GB)", IBytes(GiByte), "1.0GiB"},
+		{"bytes(1TB - 1M)", IBytes(TiByte - MiByte), "1024GiB"},
+
+		{"bytes(1TB)", IBytes(TiByte), "1.0TiB"},
+		{"bytes(1PB - 1T)", IBytes(PiByte - TiByte), "1023TiB"},
+
+		{"bytes(1PB)", IBytes(PiByte), "1.0PiB"},
+		{"bytes(1PB - 1T)", IBytes(EiByte - PiByte), "1023PiB"},
+
+		{"bytes(1EiB)", IBytes(EiByte), "1.0EiB"},
+		// Overflows.
+		// {"bytes(1EB - 1P)", IBytes((KIByte*EIByte)-PiByte), "1023EB"},
+
+		{"bytes(5.5GiB)", IBytes(5.5 * GiByte), "5.5GiB"},
+
+		{"bytes(5.5GB)", Bytes(5.5 * GByte), "5.5GB"},
+	}.validate(t)
+}
+
+func BenchmarkParseBytes(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		ParseBytes("16.5GB")
+	}
+}
+
+func BenchmarkBytes(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Bytes(16.5 * GByte)
+	}
+}

vendor/github.com/dustin/go-humanize/comma_test.go

@@ -0,0 +1,134 @@
+package humanize
+
+import (
+	"math"
+	"math/big"
+	"testing"
+)
+
+func TestCommas(t *testing.T) {
+	testList{
+		{"0", Comma(0), "0"},
+		{"10", Comma(10), "10"},
+		{"100", Comma(100), "100"},
+		{"1,000", Comma(1000), "1,000"},
+		{"10,000", Comma(10000), "10,000"},
+		{"100,000", Comma(100000), "100,000"},
+		{"10,000,000", Comma(10000000), "10,000,000"},
+		{"10,100,000", Comma(10100000), "10,100,000"},
+		{"10,010,000", Comma(10010000), "10,010,000"},
+		{"10,001,000", Comma(10001000), "10,001,000"},
+		{"123,456,789", Comma(123456789), "123,456,789"},
+		{"maxint", Comma(9.223372e+18), "9,223,372,000,000,000,000"},
+		{"minint", Comma(-9.223372e+18), "-9,223,372,000,000,000,000"},
+		{"-123,456,789", Comma(-123456789), "-123,456,789"},
+		{"-10,100,000", Comma(-10100000), "-10,100,000"},
+		{"-10,010,000", Comma(-10010000), "-10,010,000"},
+		{"-10,001,000", Comma(-10001000), "-10,001,000"},
+		{"-10,000,000", Comma(-10000000), "-10,000,000"},
+		{"-100,000", Comma(-100000), "-100,000"},
+		{"-10,000", Comma(-10000), "-10,000"},
+		{"-1,000", Comma(-1000), "-1,000"},
+		{"-100", Comma(-100), "-100"},
+		{"-10", Comma(-10), "-10"},
+	}.validate(t)
+}
+
+func TestCommafs(t *testing.T) {
+	testList{
+		{"0", Commaf(0), "0"},
+		{"10.11", Commaf(10.11), "10.11"},
+		{"100", Commaf(100), "100"},
+		{"1,000", Commaf(1000), "1,000"},
+		{"10,000", Commaf(10000), "10,000"},
+		{"100,000", Commaf(100000), "100,000"},
+		{"834,142.32", Commaf(834142.32), "834,142.32"},
+		{"10,000,000", Commaf(10000000), "10,000,000"},
+		{"10,100,000", Commaf(10100000), "10,100,000"},
+		{"10,010,000", Commaf(10010000), "10,010,000"},
+		{"10,001,000", Commaf(10001000), "10,001,000"},
+		{"123,456,789", Commaf(123456789), "123,456,789"},
+		{"maxf64", Commaf(math.MaxFloat64), "179,769,313,486,231,570,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000"},
+		{"minf64", Commaf(math.SmallestNonzeroFloat64), "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005"},
+		{"-123,456,789", Commaf(-123456789), "-123,456,789"},
+		{"-10,100,000", Commaf(-10100000), "-10,100,000"},
+		{"-10,010,000", Commaf(-10010000), "-10,010,000"},
+		{"-10,001,000", Commaf(-10001000), "-10,001,000"},
+		{"-10,000,000", Commaf(-10000000), "-10,000,000"},
+		{"-100,000", Commaf(-100000), "-100,000"},
+		{"-10,000", Commaf(-10000), "-10,000"},
+		{"-1,000", Commaf(-1000), "-1,000"},
+		{"-100.11", Commaf(-100.11), "-100.11"},
+		{"-10", Commaf(-10), "-10"},
+	}.validate(t)
+}
+
+func BenchmarkCommas(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Comma(1234567890)
+	}
+}
+
+func BenchmarkCommaf(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Commaf(1234567890.83584)
+	}
+}
+
+func BenchmarkBigCommas(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		BigComma(big.NewInt(1234567890))
+	}
+}
+
+func bigComma(i int64) string {
+	return BigComma(big.NewInt(i))
+}
+
+func TestBigCommas(t *testing.T) {
+	testList{
+		{"0", bigComma(0), "0"},
+		{"10", bigComma(10), "10"},
+		{"100", bigComma(100), "100"},
+		{"1,000", bigComma(1000), "1,000"},
+		{"10,000", bigComma(10000), "10,000"},
+		{"100,000", bigComma(100000), "100,000"},
+		{"10,000,000", bigComma(10000000), "10,000,000"},
+		{"10,100,000", bigComma(10100000), "10,100,000"},
+		{"10,010,000", bigComma(10010000), "10,010,000"},
+		{"10,001,000", bigComma(10001000), "10,001,000"},
+		{"123,456,789", bigComma(123456789), "123,456,789"},
+		{"maxint", bigComma(9.223372e+18), "9,223,372,000,000,000,000"},
+		{"minint", bigComma(-9.223372e+18), "-9,223,372,000,000,000,000"},
+		{"-123,456,789", bigComma(-123456789), "-123,456,789"},
+		{"-10,100,000", bigComma(-10100000), "-10,100,000"},
+		{"-10,010,000", bigComma(-10010000), "-10,010,000"},
+		{"-10,001,000", bigComma(-10001000), "-10,001,000"},
+		{"-10,000,000", bigComma(-10000000), "-10,000,000"},
+		{"-100,000", bigComma(-100000), "-100,000"},
+		{"-10,000", bigComma(-10000), "-10,000"},
+		{"-1,000", bigComma(-1000), "-1,000"},
+		{"-100", bigComma(-100), "-100"},
+		{"-10", bigComma(-10), "-10"},
+	}.validate(t)
+}
+
+func TestVeryBigCommas(t *testing.T) {
+	tests := []struct{ in, exp string }{
+		{
+			"84889279597249724975972597249849757294578485",
+			"84,889,279,597,249,724,975,972,597,249,849,757,294,578,485",
+		},
+		{
+			"-84889279597249724975972597249849757294578485",
+			"-84,889,279,597,249,724,975,972,597,249,849,757,294,578,485",
+		},
+	}
+	for _, test := range tests {
+		n, _ := (&big.Int{}).SetString(test.in, 10)
+		got := BigComma(n)
+		if test.exp != got {
+			t.Errorf("Expected %q, got %q", test.exp, got)
+		}
+	}
+}

vendor/github.com/dustin/go-humanize/common_test.go

@@ -0,0 +1,18 @@
+package humanize
+
+import (
+	"testing"
+)
+
+type testList []struct {
+	name, got, exp string
+}
+
+func (tl testList) validate(t *testing.T) {
+	for _, test := range tl {
+		if test.got != test.exp {
+			t.Errorf("On %v, expected '%v', but got '%v'",
+				test.name, test.exp, test.got)
+		}
+	}
+}

vendor/github.com/dustin/go-humanize/ftoa_test.go

@@ -0,0 +1,55 @@
+package humanize
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"testing"
+)
+
+func TestFtoa(t *testing.T) {
+	testList{
+		{"200", Ftoa(200), "200"},
+		{"2", Ftoa(2), "2"},
+		{"2.2", Ftoa(2.2), "2.2"},
+		{"2.02", Ftoa(2.02), "2.02"},
+		{"200.02", Ftoa(200.02), "200.02"},
+	}.validate(t)
+}
+
+func BenchmarkFtoaRegexTrailing(b *testing.B) {
+	trailingZerosRegex := regexp.MustCompile(`\.?0+$`)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		trailingZerosRegex.ReplaceAllString("2.00000", "")
+		trailingZerosRegex.ReplaceAllString("2.0000", "")
+		trailingZerosRegex.ReplaceAllString("2.000", "")
+		trailingZerosRegex.ReplaceAllString("2.00", "")
+		trailingZerosRegex.ReplaceAllString("2.0", "")
+		trailingZerosRegex.ReplaceAllString("2", "")
+	}
+}
+
+func BenchmarkFtoaFunc(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		stripTrailingZeros("2.00000")
+		stripTrailingZeros("2.0000")
+		stripTrailingZeros("2.000")
+		stripTrailingZeros("2.00")
+		stripTrailingZeros("2.0")
+		stripTrailingZeros("2")
+	}
+}
+
+func BenchmarkFmtF(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		fmt.Sprintf("%f", 2.03584)
+	}
+}
+
+func BenchmarkStrconvF(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		strconv.FormatFloat(2.03584, 'f', 6, 64)
+	}
+}

vendor/github.com/dustin/go-humanize/number_test.go

@@ -0,0 +1,78 @@
+package humanize
+
+import (
+	"math"
+	"testing"
+)
+
+type TestStruct struct {
+	name      string
+	format    string
+	num       float64
+	formatted string
+}
+
+func TestFormatFloat(t *testing.T) {
+	tests := []TestStruct{
+		{"default", "", 12345.6789, "12,345.68"},
+		{"#", "#", 12345.6789, "12345.678900000"},
+		{"#.", "#.", 12345.6789, "12346"},
+		{"#,#", "#,#", 12345.6789, "12345,7"},
+		{"#,##", "#,##", 12345.6789, "12345,68"},
+		{"#,###", "#,###", 12345.6789, "12345,679"},
+		{"#,###.", "#,###.", 12345.6789, "12,346"},
+		{"#,###.##", "#,###.##", 12345.6789, "12,345.68"},
+		{"#,###.###", "#,###.###", 12345.6789, "12,345.679"},
+		{"#,###.####", "#,###.####", 12345.6789, "12,345.6789"},
+		{"#.###,######", "#.###,######", 12345.6789, "12.345,678900"},
+		{"#\u202f###,##", "#\u202f###,##", 12345.6789, "12 345,68"},
+
+		// special cases
+		{"NaN", "#", math.NaN(), "NaN"},
+		{"+Inf", "#", math.Inf(1), "Infinity"},
+		{"-Inf", "#", math.Inf(-1), "-Infinity"},
+		{"signStr <= -0.000000001", "", -0.000000002, "-0.00"},
+		{"signStr = 0", "", 0, "0.00"},
+		{"Format directive must start with +", "+000", 12345.6789, "+12345.678900000"},
+	}
+
+	for _, test := range tests {
+		got := FormatFloat(test.format, test.num)
+		if got != test.formatted {
+			t.Errorf("On %v (%v, %v), got %v, wanted %v",
+				test.name, test.format, test.num, got, test.formatted)
+		}
+	}
+	// Test a single integer
+	got := FormatInteger("#", 12345)
+	if got != "12345.000000000" {
+		t.Errorf("On %v (%v, %v), got %v, wanted %v",
+			"integerTest", "#", 12345, got, "12345.000000000")
+	}
+	// Test the things that could panic
+	panictests := []TestStruct{
+		{"RenderFloat(): invalid positive sign directive", "-", 12345.6789, "12,345.68"},
+		{"RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers", "0.01", 12345.6789, "12,345.68"},
+	}
+	for _, test := range panictests {
+		didPanic := false
+		var message interface{}
+		func() {
+
+			defer func() {
+				if message = recover(); message != nil {
+					didPanic = true
+				}
+			}()
+
+			// call the target function
+			_ = FormatFloat(test.format, test.num)
+
+		}()
+		if didPanic != true {
+			t.Errorf("On %v, should have panic and did not.",
+				test.name)
+		}
+	}
+
+}

vendor/github.com/dustin/go-humanize/ordinals_test.go

@@ -0,0 +1,22 @@
+package humanize
+
+import (
+	"testing"
+)
+
+func TestOrdinals(t *testing.T) {
+	testList{
+		{"0", Ordinal(0), "0th"},
+		{"1", Ordinal(1), "1st"},
+		{"2", Ordinal(2), "2nd"},
+		{"3", Ordinal(3), "3rd"},
+		{"4", Ordinal(4), "4th"},
+		{"10", Ordinal(10), "10th"},
+		{"11", Ordinal(11), "11th"},
+		{"12", Ordinal(12), "12th"},
+		{"13", Ordinal(13), "13th"},
+		{"101", Ordinal(101), "101st"},
+		{"102", Ordinal(102), "102nd"},
+		{"103", Ordinal(103), "103rd"},
+	}.validate(t)
+}

vendor/github.com/dustin/go-humanize/si_test.go

@@ -0,0 +1,98 @@
+package humanize
+
+import (
+	"math"
+	"testing"
+)
+
+func TestSI(t *testing.T) {
+	tests := []struct {
+		name      string
+		num       float64
+		formatted string
+	}{
+		{"e-24", 1e-24, "1yF"},
+		{"e-21", 1e-21, "1zF"},
+		{"e-18", 1e-18, "1aF"},
+		{"e-15", 1e-15, "1fF"},
+		{"e-12", 1e-12, "1pF"},
+		{"e-12", 2.2345e-12, "2.2345pF"},
+		{"e-12", 2.23e-12, "2.23pF"},
+		{"e-11", 2.23e-11, "22.3pF"},
+		{"e-10", 2.2e-10, "220pF"},
+		{"e-9", 2.2e-9, "2.2nF"},
+		{"e-8", 2.2e-8, "22nF"},
+		{"e-7", 2.2e-7, "220nF"},
+		{"e-6", 2.2e-6, "2.2µF"},
+		{"e-6", 1e-6, "1µF"},
+		{"e-5", 2.2e-5, "22µF"},
+		{"e-4", 2.2e-4, "220µF"},
+		{"e-3", 2.2e-3, "2.2mF"},
+		{"e-2", 2.2e-2, "22mF"},
+		{"e-1", 2.2e-1, "220mF"},
+		{"e+0", 2.2e-0, "2.2F"},
+		{"e+0", 2.2, "2.2F"},
+		{"e+1", 2.2e+1, "22F"},
+		{"0", 0, "0F"},
+		{"e+1", 22, "22F"},
+		{"e+2", 2.2e+2, "220F"},
+		{"e+2", 220, "220F"},
+		{"e+3", 2.2e+3, "2.2kF"},
+		{"e+3", 2200, "2.2kF"},
+		{"e+4", 2.2e+4, "22kF"},
+		{"e+4", 22000, "22kF"},
+		{"e+5", 2.2e+5, "220kF"},
+		{"e+6", 2.2e+6, "2.2MF"},
+		{"e+6", 1e+6, "1MF"},
+		{"e+7", 2.2e+7, "22MF"},
+		{"e+8", 2.2e+8, "220MF"},
+		{"e+9", 2.2e+9, "2.2GF"},
+		{"e+10", 2.2e+10, "22GF"},
+		{"e+11", 2.2e+11, "220GF"},
+		{"e+12", 2.2e+12, "2.2TF"},
+		{"e+15", 2.2e+15, "2.2PF"},
+		{"e+18", 2.2e+18, "2.2EF"},
+		{"e+21", 2.2e+21, "2.2ZF"},
+		{"e+24", 2.2e+24, "2.2YF"},
+
+		// special case
+		{"1F", 1000 * 1000, "1MF"},
+		{"1F", 1e6, "1MF"},
+	}
+
+	for _, test := range tests {
+		got := SI(test.num, "F")
+		if got != test.formatted {
+			t.Errorf("On %v (%v), got %v, wanted %v",
+				test.name, test.num, got, test.formatted)
+		}
+
+		gotf, gotu, err := ParseSI(test.formatted)
+		if err != nil {
+			t.Errorf("Error parsing %v (%v): %v", test.name, test.formatted, err)
+			continue
+		}
+
+		if math.Abs(1-(gotf/test.num)) > 0.01 {
+			t.Errorf("On %v (%v), got %v, wanted %v (±%v)",
+				test.name, test.formatted, gotf, test.num,
+				math.Abs(1-(gotf/test.num)))
+		}
+		if gotu != "F" {
+			t.Errorf("On %v (%v), expected unit F, got %v",
+				test.name, test.formatted, gotu)
+		}
+	}
+
+	// Parse error
+	gotf, gotu, err := ParseSI("x1.21JW") // 1.21 jigga whats
+	if err == nil {
+		t.Errorf("Expected error on x1.21JW, got %v %v", gotf, gotu)
+	}
+}
+
+func BenchmarkParseSI(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		ParseSI("2.2346ZB")
+	}
+}

vendor/github.com/dustin/go-humanize/times_test.go

@@ -0,0 +1,71 @@
+package humanize
+
+import (
+	"math"
+	"testing"
+	"time"
+)
+
+func TestPast(t *testing.T) {
+	now := time.Now().Unix()
+	testList{
+		{"now", Time(time.Unix(now, 0)), "now"},
+		{"1 second ago", Time(time.Unix(now-1, 0)), "1 second ago"},
+		{"12 seconds ago", Time(time.Unix(now-12, 0)), "12 seconds ago"},
+		{"30 seconds ago", Time(time.Unix(now-30, 0)), "30 seconds ago"},
+		{"45 seconds ago", Time(time.Unix(now-45, 0)), "45 seconds ago"},
+		{"1 minute ago", Time(time.Unix(now-63, 0)), "1 minute ago"},
+		{"15 minutes ago", Time(time.Unix(now-15*Minute, 0)), "15 minutes ago"},
+		{"1 hour ago", Time(time.Unix(now-63*Minute, 0)), "1 hour ago"},
+		{"2 hours ago", Time(time.Unix(now-2*Hour, 0)), "2 hours ago"},
+		{"21 hours ago", Time(time.Unix(now-21*Hour, 0)), "21 hours ago"},
+		{"1 day ago", Time(time.Unix(now-26*Hour, 0)), "1 day ago"},
+		{"2 days ago", Time(time.Unix(now-49*Hour, 0)), "2 days ago"},
+		{"3 days ago", Time(time.Unix(now-3*Day, 0)), "3 days ago"},
+		{"1 week ago (1)", Time(time.Unix(now-7*Day, 0)), "1 week ago"},
+		{"1 week ago (2)", Time(time.Unix(now-12*Day, 0)), "1 week ago"},
+		{"2 weeks ago", Time(time.Unix(now-15*Day, 0)), "2 weeks ago"},
+		{"1 month ago", Time(time.Unix(now-39*Day, 0)), "1 month ago"},
+		{"3 months ago", Time(time.Unix(now-99*Day, 0)), "3 months ago"},
+		{"1 year ago (1)", Time(time.Unix(now-365*Day, 0)), "1 year ago"},
+		{"1 year ago (1)", Time(time.Unix(now-400*Day, 0)), "1 year ago"},
+		{"2 years ago (1)", Time(time.Unix(now-548*Day, 0)), "2 years ago"},
+		{"2 years ago (2)", Time(time.Unix(now-725*Day, 0)), "2 years ago"},
+		{"2 years ago (3)", Time(time.Unix(now-800*Day, 0)), "2 years ago"},
+		{"3 years ago", Time(time.Unix(now-3*Year, 0)), "3 years ago"},
+		{"long ago", Time(time.Unix(now-LongTime, 0)), "a long while ago"},
+	}.validate(t)
+}
+
+func TestFuture(t *testing.T) {
+	now := time.Now().Unix()
+	testList{
+		{"now", Time(time.Unix(now, 0)), "now"},
+		{"1 second from now", Time(time.Unix(now+1, 0)), "1 second from now"},
+		{"12 seconds from now", Time(time.Unix(now+12, 0)), "12 seconds from now"},
+		{"30 seconds from now", Time(time.Unix(now+30, 0)), "30 seconds from now"},
+		{"45 seconds from now", Time(time.Unix(now+45, 0)), "45 seconds from now"},
+		{"15 minutes from now", Time(time.Unix(now+15*Minute, 0)), "15 minutes from now"},
+		{"2 hours from now", Time(time.Unix(now+2*Hour, 0)), "2 hours from now"},
+		{"21 hours from now", Time(time.Unix(now+21*Hour, 0)), "21 hours from now"},
+		{"1 day from now", Time(time.Unix(now+26*Hour, 0)), "1 day from now"},
+		{"2 days from now", Time(time.Unix(now+49*Hour, 0)), "2 days from now"},
+		{"3 days from now", Time(time.Unix(now+3*Day, 0)), "3 days from now"},
+		{"1 week from now (1)", Time(time.Unix(now+7*Day, 0)), "1 week from now"},
+		{"1 week from now (2)", Time(time.Unix(now+12*Day, 0)), "1 week from now"},
+		{"2 weeks from now", Time(time.Unix(now+15*Day, 0)), "2 weeks from now"},
+		{"1 month from now", Time(time.Unix(now+30*Day, 0)), "1 month from now"},
+		{"1 year from now", Time(time.Unix(now+365*Day, 0)), "1 year from now"},
+		{"2 years from now", Time(time.Unix(now+2*Year, 0)), "2 years from now"},
+		{"a while from now", Time(time.Unix(now+LongTime, 0)), "a long while from now"},
+	}.validate(t)
+}
+
+func TestRange(t *testing.T) {
+	start := time.Time{}
+	end := time.Unix(math.MaxInt64, math.MaxInt64)
+	x := RelTime(start, end, "ago", "from now")
+	if x != "a long while from now" {
+		t.Errorf("Expected a long while from now, got %q", x)
+	}
+}

vendor/github.com/facebookgo/clock/clock_test.go

@@ -0,0 +1,536 @@
+package clock_test
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/facebookgo/clock"
+)
+
+// Ensure that the clock's After channel sends at the correct time.
+func TestClock_After(t *testing.T) {
+	var ok bool
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		ok = true
+	}()
+	go func() {
+		time.Sleep(30 * time.Millisecond)
+		t.Fatal("too late")
+	}()
+	gosched()
+
+	<-clock.New().After(20 * time.Millisecond)
+	if !ok {
+		t.Fatal("too early")
+	}
+}
+
+// Ensure that the clock's AfterFunc executes at the correct time.
+func TestClock_AfterFunc(t *testing.T) {
+	var ok bool
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		ok = true
+	}()
+	go func() {
+		time.Sleep(30 * time.Millisecond)
+		t.Fatal("too late")
+	}()
+	gosched()
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	clock.New().AfterFunc(20*time.Millisecond, func() {
+		wg.Done()
+	})
+	wg.Wait()
+	if !ok {
+		t.Fatal("too early")
+	}
+}
+
+// Ensure that the clock's time matches the standary library.
+func TestClock_Now(t *testing.T) {
+	a := time.Now().Round(time.Second)
+	b := clock.New().Now().Round(time.Second)
+	if !a.Equal(b) {
+		t.Errorf("not equal: %s != %s", a, b)
+	}
+}
+
+// Ensure that the clock sleeps for the appropriate amount of time.
+func TestClock_Sleep(t *testing.T) {
+	var ok bool
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		ok = true
+	}()
+	go func() {
+		time.Sleep(30 * time.Millisecond)
+		t.Fatal("too late")
+	}()
+	gosched()
+
+	clock.New().Sleep(20 * time.Millisecond)
+	if !ok {
+		t.Fatal("too early")
+	}
+}
+
+// Ensure that the clock ticks correctly.
+func TestClock_Tick(t *testing.T) {
+	var ok bool
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		ok = true
+	}()
+	go func() {
+		time.Sleep(50 * time.Millisecond)
+		t.Fatal("too late")
+	}()
+	gosched()
+
+	c := clock.New().Tick(20 * time.Millisecond)
+	<-c
+	<-c
+	if !ok {
+		t.Fatal("too early")
+	}
+}
+
+// Ensure that the clock's ticker ticks correctly.
+func TestClock_Ticker(t *testing.T) {
+	var ok bool
+	go func() {
+		time.Sleep(100 * time.Millisecond)
+		ok = true
+	}()
+	go func() {
+		time.Sleep(200 * time.Millisecond)
+		t.Fatal("too late")
+	}()
+	gosched()
+
+	ticker := clock.New().Ticker(50 * time.Millisecond)
+	<-ticker.C
+	<-ticker.C
+	if !ok {
+		t.Fatal("too early")
+	}
+}
+
+// Ensure that the clock's ticker can stop correctly.
+func TestClock_Ticker_Stp(t *testing.T) {
+	var ok bool
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		ok = true
+	}()
+	gosched()
+
+	ticker := clock.New().Ticker(20 * time.Millisecond)
+	<-ticker.C
+	ticker.Stop()
+	select {
+	case <-ticker.C:
+		t.Fatal("unexpected send")
+	case <-time.After(30 * time.Millisecond):
+	}
+}
+
+// Ensure that the clock's timer waits correctly.
+func TestClock_Timer(t *testing.T) {
+	var ok bool
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		ok = true
+	}()
+	go func() {
+		time.Sleep(30 * time.Millisecond)
+		t.Fatal("too late")
+	}()
+	gosched()
+
+	timer := clock.New().Timer(20 * time.Millisecond)
+	<-timer.C
+	if !ok {
+		t.Fatal("too early")
+	}
+}
+
+// Ensure that the clock's timer can be stopped.
+func TestClock_Timer_Stop(t *testing.T) {
+	var ok bool
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		ok = true
+	}()
+
+	timer := clock.New().Timer(20 * time.Millisecond)
+	timer.Stop()
+	select {
+	case <-timer.C:
+		t.Fatal("unexpected send")
+	case <-time.After(30 * time.Millisecond):
+	}
+}
+
+// Ensure that the mock's After channel sends at the correct time.
+func TestMock_After(t *testing.T) {
+	var ok int32
+	clock := clock.NewMock()
+
+	// Create a channel to execute after 10 mock seconds.
+	ch := clock.After(10 * time.Second)
+	go func(ch <-chan time.Time) {
+		<-ch
+		atomic.StoreInt32(&ok, 1)
+	}(ch)
+
+	// Move clock forward to just before the time.
+	clock.Add(9 * time.Second)
+	if atomic.LoadInt32(&ok) == 1 {
+		t.Fatal("too early")
+	}
+
+	// Move clock forward to the after channel's time.
+	clock.Add(1 * time.Second)
+	if atomic.LoadInt32(&ok) == 0 {
+		t.Fatal("too late")
+	}
+}
+
+// Ensure that the mock's AfterFunc executes at the correct time.
+func TestMock_AfterFunc(t *testing.T) {
+	var ok int32
+	clock := clock.NewMock()
+
+	// Execute function after duration.
+	clock.AfterFunc(10*time.Second, func() {
+		atomic.StoreInt32(&ok, 1)
+	})
+
+	// Move clock forward to just before the time.
+	clock.Add(9 * time.Second)
+	if atomic.LoadInt32(&ok) == 1 {
+		t.Fatal("too early")
+	}
+
+	// Move clock forward to the after channel's time.
+	clock.Add(1 * time.Second)
+	if atomic.LoadInt32(&ok) == 0 {
+		t.Fatal("too late")
+	}
+}
+
+// Ensure that the mock's AfterFunc doesn't execute if stopped.
+func TestMock_AfterFunc_Stop(t *testing.T) {
+	// Execute function after duration.
+	clock := clock.NewMock()
+	timer := clock.AfterFunc(10*time.Second, func() {
+		t.Fatal("unexpected function execution")
+	})
+	gosched()
+
+	// Stop timer & move clock forward.
+	timer.Stop()
+	clock.Add(10 * time.Second)
+	gosched()
+}
+
+// Ensure that the mock's current time can be changed.
+func TestMock_Now(t *testing.T) {
+	clock := clock.NewMock()
+	if now := clock.Now(); !now.Equal(time.Unix(0, 0)) {
+		t.Fatalf("expected epoch, got: ", now)
+	}
+
+	// Add 10 seconds and check the time.
+	clock.Add(10 * time.Second)
+	if now := clock.Now(); !now.Equal(time.Unix(10, 0)) {
+		t.Fatalf("expected epoch, got: ", now)
+	}
+}
+
+// Ensure that the mock can sleep for the correct time.
+func TestMock_Sleep(t *testing.T) {
+	var ok int32
+	clock := clock.NewMock()
+
+	// Create a channel to execute after 10 mock seconds.
+	go func() {
+		clock.Sleep(10 * time.Second)
+		atomic.StoreInt32(&ok, 1)
+	}()
+	gosched()
+
+	// Move clock forward to just before the sleep duration.
+	clock.Add(9 * time.Second)
+	if atomic.LoadInt32(&ok) == 1 {
+		t.Fatal("too early")
+	}
+
+	// Move clock forward to the after the sleep duration.
+	clock.Add(1 * time.Second)
+	if atomic.LoadInt32(&ok) == 0 {
+		t.Fatal("too late")
+	}
+}
+
+// Ensure that the mock's Tick channel sends at the correct time.
+func TestMock_Tick(t *testing.T) {
+	var n int32
+	clock := clock.NewMock()
+
+	// Create a channel to increment every 10 seconds.
+	go func() {
+		tick := clock.Tick(10 * time.Second)
+		for {
+			<-tick
+			atomic.AddInt32(&n, 1)
+		}
+	}()
+	gosched()
+
+	// Move clock forward to just before the first tick.
+	clock.Add(9 * time.Second)
+	if atomic.LoadInt32(&n) != 0 {
+		t.Fatalf("expected 0, got %d", n)
+	}
+
+	// Move clock forward to the start of the first tick.
+	clock.Add(1 * time.Second)
+	if atomic.LoadInt32(&n) != 1 {
+		t.Fatalf("expected 1, got %d", n)
+	}
+
+	// Move clock forward over several ticks.
+	clock.Add(30 * time.Second)
+	if atomic.LoadInt32(&n) != 4 {
+		t.Fatalf("expected 4, got %d", n)
+	}
+}
+
+// Ensure that the mock's Ticker channel sends at the correct time.
+func TestMock_Ticker(t *testing.T) {
+	var n int32
+	clock := clock.NewMock()
+
+	// Create a channel to increment every microsecond.
+	go func() {
+		ticker := clock.Ticker(1 * time.Microsecond)
+		for {
+			<-ticker.C
+			atomic.AddInt32(&n, 1)
+		}
+	}()
+	gosched()
+
+	// Move clock forward.
+	clock.Add(10 * time.Microsecond)
+	if atomic.LoadInt32(&n) != 10 {
+		t.Fatalf("unexpected: %d", n)
+	}
+}
+
+// Ensure that the mock's Ticker channel won't block if not read from.
+func TestMock_Ticker_Overflow(t *testing.T) {
+	clock := clock.NewMock()
+	ticker := clock.Ticker(1 * time.Microsecond)
+	clock.Add(10 * time.Microsecond)
+	ticker.Stop()
+}
+
+// Ensure that the mock's Ticker can be stopped.
+func TestMock_Ticker_Stop(t *testing.T) {
+	var n int32
+	clock := clock.NewMock()
+
+	// Create a channel to increment every second.
+	ticker := clock.Ticker(1 * time.Second)
+	go func() {
+		for {
+			<-ticker.C
+			atomic.AddInt32(&n, 1)
+		}
+	}()
+	gosched()
+
+	// Move clock forward.
+	clock.Add(5 * time.Second)
+	if atomic.LoadInt32(&n) != 5 {
+		t.Fatalf("expected 5, got: %d", n)
+	}
+
+	ticker.Stop()
+
+	// Move clock forward again.
+	clock.Add(5 * time.Second)
+	if atomic.LoadInt32(&n) != 5 {
+		t.Fatalf("still expected 5, got: %d", n)
+	}
+}
+
+// Ensure that multiple tickers can be used together.
+func TestMock_Ticker_Multi(t *testing.T) {
+	var n int32
+	clock := clock.NewMock()
+
+	go func() {
+		a := clock.Ticker(1 * time.Microsecond)
+		b := clock.Ticker(3 * time.Microsecond)
+
+		for {
+			select {
+			case <-a.C:
+				atomic.AddInt32(&n, 1)
+			case <-b.C:
+				atomic.AddInt32(&n, 100)
+			}
+		}
+	}()
+	gosched()
+
+	// Move clock forward.
+	clock.Add(10 * time.Microsecond)
+	gosched()
+	if atomic.LoadInt32(&n) != 310 {
+		t.Fatalf("unexpected: %d", n)
+	}
+}
+
+func ExampleMock_After() {
+	// Create a new mock clock.
+	clock := clock.NewMock()
+	count := 0
+
+	// Create a channel to execute after 10 mock seconds.
+	go func() {
+		<-clock.After(10 * time.Second)
+		count = 100
+	}()
+	runtime.Gosched()
+
+	// Print the starting value.
+	fmt.Printf("%s: %d\n", clock.Now().UTC(), count)
+
+	// Move the clock forward 5 seconds and print the value again.
+	clock.Add(5 * time.Second)
+	fmt.Printf("%s: %d\n", clock.Now().UTC(), count)
+
+	// Move the clock forward 5 seconds to the tick time and check the value.
+	clock.Add(5 * time.Second)
+	fmt.Printf("%s: %d\n", clock.Now().UTC(), count)
+
+	// Output:
+	// 1970-01-01 00:00:00 +0000 UTC: 0
+	// 1970-01-01 00:00:05 +0000 UTC: 0
+	// 1970-01-01 00:00:10 +0000 UTC: 100
+}
+
+func ExampleMock_AfterFunc() {
+	// Create a new mock clock.
+	clock := clock.NewMock()
+	count := 0
+
+	// Execute a function after 10 mock seconds.
+	clock.AfterFunc(10*time.Second, func() {
+		count = 100
+	})
+	runtime.Gosched()
+
+	// Print the starting value.
+	fmt.Printf("%s: %d\n", clock.Now().UTC(), count)
+
+	// Move the clock forward 10 seconds and print the new value.
+	clock.Add(10 * time.Second)
+	fmt.Printf("%s: %d\n", clock.Now().UTC(), count)
+
+	// Output:
+	// 1970-01-01 00:00:00 +0000 UTC: 0
+	// 1970-01-01 00:00:10 +0000 UTC: 100
+}
+
+func ExampleMock_Sleep() {
+	// Create a new mock clock.
+	clock := clock.NewMock()
+	count := 0
+
+	// Execute a function after 10 mock seconds.
+	go func() {
+		clock.Sleep(10 * time.Second)
+		count = 100
+	}()
+	runtime.Gosched()
+
+	// Print the starting value.
+	fmt.Printf("%s: %d\n", clock.Now().UTC(), count)
+
+	// Move the clock forward 10 seconds and print the new value.
+	clock.Add(10 * time.Second)
+	fmt.Printf("%s: %d\n", clock.Now().UTC(), count)
+
+	// Output:
+	// 1970-01-01 00:00:00 +0000 UTC: 0
+	// 1970-01-01 00:00:10 +0000 UTC: 100
+}
+
+func ExampleMock_Ticker() {
+	// Create a new mock clock.
+	clock := clock.NewMock()
+	count := 0
+
+	// Increment count every mock second.
+	go func() {
+		ticker := clock.Ticker(1 * time.Second)
+		for {
+			<-ticker.C
+			count++
+		}
+	}()
+	runtime.Gosched()
+
+	// Move the clock forward 10 seconds and print the new value.
+	clock.Add(10 * time.Second)
+	fmt.Printf("Count is %d after 10 seconds\n", count)
+
+	// Move the clock forward 5 more seconds and print the new value.
+	clock.Add(5 * time.Second)
+	fmt.Printf("Count is %d after 15 seconds\n", count)
+
+	// Output:
+	// Count is 10 after 10 seconds
+	// Count is 15 after 15 seconds
+}
+
+func ExampleMock_Timer() {
+	// Create a new mock clock.
+	clock := clock.NewMock()
+	count := 0
+
+	// Increment count after a mock second.
+	go func() {
+		timer := clock.Timer(1 * time.Second)
+		<-timer.C
+		count++
+	}()
+	runtime.Gosched()
+
+	// Move the clock forward 10 seconds and print the new value.
+	clock.Add(10 * time.Second)
+	fmt.Printf("Count is %d after 10 seconds\n", count)
+
+	// Output:
+	// Count is 1 after 10 seconds
+}
+
+func warn(v ...interface{})              { fmt.Fprintln(os.Stderr, v...) }
+func warnf(msg string, v ...interface{}) { fmt.Fprintf(os.Stderr, msg+"\n", v...) }
+
+func gosched() { time.Sleep(1 * time.Millisecond) }

vendor/github.com/facebookgo/httpdown/httpdown.go

@@ -14,8 +14,8 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/minio/minio/internal/github.com/facebookgo/clock"
+	"github.com/facebookgo/clock"
-	"github.com/minio/minio/internal/github.com/facebookgo/stats"
+	"github.com/facebookgo/stats"
 )
 
 const (

vendor/github.com/facebookgo/httpdown/httpdown_test.go

@@ -0,0 +1,677 @@
+package httpdown_test
+
+import (
+	"bytes"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"os"
+	"regexp"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/facebookgo/clock"
+	"github.com/facebookgo/ensure"
+	"github.com/facebookgo/freeport"
+	"github.com/facebookgo/httpdown"
+	"github.com/facebookgo/stats"
+)
+
+type onCloseListener struct {
+	net.Listener
+	mutex   sync.Mutex
+	onClose chan struct{}
+}
+
+func (o *onCloseListener) Close() error {
+	// Listener is closed twice, once by Grace, and once by the http library, so
+	// we guard against a double close of the chan.
+	defer func() {
+		o.mutex.Lock()
+		defer o.mutex.Unlock()
+		if o.onClose != nil {
+			close(o.onClose)
+			o.onClose = nil
+		}
+	}()
+	return o.Listener.Close()
+}
+
+func NewOnCloseListener(l net.Listener) (net.Listener, chan struct{}) {
+	c := make(chan struct{})
+	return &onCloseListener{Listener: l, onClose: c}, c
+}
+
+type closeErrListener struct {
+	net.Listener
+	err error
+}
+
+func (c *closeErrListener) Close() error {
+	c.Listener.Close()
+	return c.err
+}
+
+type acceptErrListener struct {
+	net.Listener
+	err chan error
+}
+
+func (c *acceptErrListener) Accept() (net.Conn, error) {
+	return nil, <-c.err
+}
+
+type closeErrConn struct {
+	net.Conn
+	unblockClose chan chan struct{}
+}
+
+func (c *closeErrConn) Close() error {
+	ch := <-c.unblockClose
+
+	// Close gets called multiple times, but only the first one gets this ch
+	if ch != nil {
+		defer close(ch)
+	}
+
+	return c.Conn.Close()
+}
+
+type closeErrConnListener struct {
+	net.Listener
+	unblockClose chan chan struct{}
+}
+
+func (l *closeErrConnListener) Accept() (net.Conn, error) {
+	c, err := l.Listener.Accept()
+	if err != nil {
+		return c, err
+	}
+	return &closeErrConn{Conn: c, unblockClose: l.unblockClose}, nil
+}
+
+func TestHTTPStopWithNoRequest(t *testing.T) {
+	t.Parallel()
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+
+	statsDone := make(chan struct{}, 2)
+	hc := &stats.HookClient{
+		BumpSumHook: func(key string, val float64) {
+			if key == "serve" && val == 1 {
+				statsDone <- struct{}{}
+			}
+			if key == "stop" && val == 1 {
+				statsDone <- struct{}{}
+			}
+		},
+	}
+
+	server := &http.Server{}
+	down := &httpdown.HTTP{Stats: hc}
+	s := down.Serve(server, listener)
+	ensure.Nil(t, s.Stop())
+	<-statsDone
+	<-statsDone
+}
+
+func TestHTTPStopWithFinishedRequest(t *testing.T) {
+	t.Parallel()
+	hello := []byte("hello")
+	fin := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(fin)
+		w.Write(hello)
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, hello)
+	ensure.Nil(t, res.Body.Close())
+
+	// At this point the request is finished, and the connection should be alive
+	// but idle (because we have keep alive enabled by default in our Transport).
+	ensure.Nil(t, s.Stop())
+	<-fin
+
+	ensure.Nil(t, s.Wait())
+}
+
+func TestHTTPStopWithActiveRequest(t *testing.T) {
+	t.Parallel()
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.WriteHeader(200)
+		for i := 0; i < count; i++ {
+			w.Write(hello)
+		}
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, bytes.Repeat(hello, count))
+	ensure.Nil(t, res.Body.Close())
+	<-finOkHandler
+	<-finStop
+}
+
+func TestNewRequestAfterStop(t *testing.T) {
+	t.Parallel()
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	unblockOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.WriteHeader(200)
+		const diff = 500
+		for i := 0; i < count-diff; i++ {
+			w.Write(hello)
+		}
+		<-unblockOkHandler
+		for i := 0; i < diff; i++ {
+			w.Write(hello)
+		}
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	listener, onClose := NewOnCloseListener(listener)
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	// Wait until the listener is closed.
+	<-onClose
+
+	// Now the next request should not be able to connect as the listener is
+	// now closed.
+	_, err = client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+
+	// We should just get "connection refused" here, but sometimes, very rarely,
+	// we get a "connection reset" instead. Unclear why this happens.
+	ensure.Err(t, err, regexp.MustCompile("(connection refused|connection reset by peer)$"))
+
+	// Unblock the handler and ensure we finish writing the rest of the body
+	// successfully.
+	close(unblockOkHandler)
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, bytes.Repeat(hello, count))
+	ensure.Nil(t, res.Body.Close())
+	<-finOkHandler
+	<-finStop
+}
+
+func TestHTTPListenerCloseError(t *testing.T) {
+	t.Parallel()
+	expectedError := errors.New("foo")
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	listener = &closeErrListener{Listener: listener, err: expectedError}
+	ensure.Nil(t, err)
+	server := &http.Server{}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	ensure.DeepEqual(t, s.Stop(), expectedError)
+}
+
+func TestHTTPServeError(t *testing.T) {
+	t.Parallel()
+	expectedError := errors.New("foo")
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	errChan := make(chan error)
+	listener = &acceptErrListener{Listener: listener, err: errChan}
+	ensure.Nil(t, err)
+	server := &http.Server{}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	errChan <- expectedError
+	ensure.DeepEqual(t, s.Wait(), expectedError)
+	ensure.Nil(t, s.Stop())
+}
+
+func TestHTTPWithinStopTimeout(t *testing.T) {
+	t.Parallel()
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.WriteHeader(200)
+		w.Write(hello)
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{StopTimeout: time.Minute}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, hello)
+	ensure.Nil(t, res.Body.Close())
+	<-finOkHandler
+	<-finStop
+}
+
+func TestHTTPStopTimeoutMissed(t *testing.T) {
+	t.Parallel()
+
+	klock := clock.NewMock()
+
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	unblockOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.Header().Set("Content-Length", fmt.Sprint(len(hello)*count))
+		w.WriteHeader(200)
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+		<-unblockOkHandler
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{
+		StopTimeout: time.Minute,
+		Clock:       klock,
+	}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	klock.Wait(clock.Calls{After: 1}) // wait for Stop to call After
+	klock.Add(down.StopTimeout)
+
+	_, err = ioutil.ReadAll(res.Body)
+	ensure.Err(t, err, regexp.MustCompile("^unexpected EOF$"))
+	ensure.Nil(t, res.Body.Close())
+	close(unblockOkHandler)
+	<-finOkHandler
+	<-finStop
+}
+
+func TestHTTPKillTimeout(t *testing.T) {
+	t.Parallel()
+
+	klock := clock.NewMock()
+
+	statsDone := make(chan struct{}, 1)
+	hc := &stats.HookClient{
+		BumpSumHook: func(key string, val float64) {
+			if key == "kill" && val == 1 {
+				statsDone <- struct{}{}
+			}
+		},
+	}
+
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	unblockOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.Header().Set("Content-Length", fmt.Sprint(len(hello)*count))
+		w.WriteHeader(200)
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+		<-unblockOkHandler
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{
+		StopTimeout: time.Minute,
+		KillTimeout: time.Minute,
+		Stats:       hc,
+		Clock:       klock,
+	}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	klock.Wait(clock.Calls{After: 1}) // wait for Stop to call After
+	klock.Add(down.StopTimeout)
+
+	_, err = ioutil.ReadAll(res.Body)
+	ensure.Err(t, err, regexp.MustCompile("^unexpected EOF$"))
+	ensure.Nil(t, res.Body.Close())
+	close(unblockOkHandler)
+	<-finOkHandler
+	<-finStop
+	<-statsDone
+}
+
+func TestHTTPKillTimeoutMissed(t *testing.T) {
+	t.Parallel()
+
+	klock := clock.NewMock()
+
+	statsDone := make(chan struct{}, 1)
+	hc := &stats.HookClient{
+		BumpSumHook: func(key string, val float64) {
+			if key == "kill.timeout" && val == 1 {
+				statsDone <- struct{}{}
+			}
+		},
+	}
+
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	unblockOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.Header().Set("Content-Length", fmt.Sprint(len(hello)*count))
+		w.WriteHeader(200)
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+		<-unblockOkHandler
+		for i := 0; i < count/2; i++ {
+			w.Write(hello)
+		}
+	}
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	unblockConnClose := make(chan chan struct{}, 1)
+	listener = &closeErrConnListener{
+		Listener:     listener,
+		unblockClose: unblockConnClose,
+	}
+
+	server := &http.Server{Handler: http.HandlerFunc(okHandler)}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{
+		StopTimeout: time.Minute,
+		KillTimeout: time.Minute,
+		Stats:       hc,
+		Clock:       klock,
+	}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+
+	// Start the Stop process.
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	klock.Wait(clock.Calls{After: 1}) // wait for Stop to call After
+	klock.Add(down.StopTimeout)       // trigger stop timeout
+	klock.Wait(clock.Calls{After: 2}) // wait for Kill to call After
+	klock.Add(down.KillTimeout)       // trigger kill timeout
+
+	// We hit both the StopTimeout & the KillTimeout.
+	<-finStop
+
+	// Then we unblock the Close, so we get an unexpected EOF since we close
+	// before we finish writing the response.
+	connCloseDone := make(chan struct{})
+	unblockConnClose <- connCloseDone
+	<-connCloseDone
+	close(unblockConnClose)
+
+	// Then we unblock the handler which tries to write the rest of the data.
+	close(unblockOkHandler)
+
+	_, err = ioutil.ReadAll(res.Body)
+	ensure.Err(t, err, regexp.MustCompile("^unexpected EOF$"))
+	ensure.Nil(t, res.Body.Close())
+	<-finOkHandler
+	<-statsDone
+}
+
+func TestDoubleStop(t *testing.T) {
+	t.Parallel()
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	ensure.Nil(t, s.Stop())
+	ensure.Nil(t, s.Stop())
+}
+
+func TestExistingConnState(t *testing.T) {
+	t.Parallel()
+	hello := []byte("hello")
+	fin := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(fin)
+		w.Write(hello)
+	}
+
+	var called int32
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	ensure.Nil(t, err)
+	server := &http.Server{
+		Handler: http.HandlerFunc(okHandler),
+		ConnState: func(c net.Conn, s http.ConnState) {
+			atomic.AddInt32(&called, 1)
+		},
+	}
+	transport := &http.Transport{}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{}
+	s := down.Serve(server, listener)
+	res, err := client.Get(fmt.Sprintf("http://%s/", listener.Addr().String()))
+	ensure.Nil(t, err)
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, hello)
+	ensure.Nil(t, res.Body.Close())
+
+	ensure.Nil(t, s.Stop())
+	<-fin
+
+	ensure.True(t, atomic.LoadInt32(&called) > 0)
+}
+
+func TestHTTPDefaultListenError(t *testing.T) {
+	if os.Getuid() == 0 {
+		t.Skip("cant run this test as root")
+	}
+
+	statsDone := make(chan struct{}, 1)
+	hc := &stats.HookClient{
+		BumpSumHook: func(key string, val float64) {
+			if key == "listen.error" && val == 1 {
+				statsDone <- struct{}{}
+			}
+		},
+	}
+
+	t.Parallel()
+	down := &httpdown.HTTP{Stats: hc}
+	_, err := down.ListenAndServe(&http.Server{})
+	ensure.Err(t, err, regexp.MustCompile("listen tcp :80: bind: permission denied"))
+	<-statsDone
+}
+
+func TestHTTPSDefaultListenError(t *testing.T) {
+	if os.Getuid() == 0 {
+		t.Skip("cant run this test as root")
+	}
+	t.Parallel()
+
+	cert, err := tls.X509KeyPair(localhostCert, localhostKey)
+	if err != nil {
+		t.Fatalf("error loading cert: %v", err)
+	}
+
+	down := &httpdown.HTTP{}
+	_, err = down.ListenAndServe(&http.Server{
+		TLSConfig: &tls.Config{
+			NextProtos:   []string{"http/1.1"},
+			Certificates: []tls.Certificate{cert},
+		},
+	})
+	ensure.Err(t, err, regexp.MustCompile("listen tcp :443: bind: permission denied"))
+}
+
+func TestTLS(t *testing.T) {
+	t.Parallel()
+	port, err := freeport.Get()
+	ensure.Nil(t, err)
+
+	cert, err := tls.X509KeyPair(localhostCert, localhostKey)
+	if err != nil {
+		t.Fatalf("error loading cert: %v", err)
+	}
+	const count = 10000
+	hello := []byte("hello")
+	finOkHandler := make(chan struct{})
+	okHandler := func(w http.ResponseWriter, r *http.Request) {
+		defer close(finOkHandler)
+		w.WriteHeader(200)
+		for i := 0; i < count; i++ {
+			w.Write(hello)
+		}
+	}
+
+	server := &http.Server{
+		Addr:    fmt.Sprintf("0.0.0.0:%d", port),
+		Handler: http.HandlerFunc(okHandler),
+		TLSConfig: &tls.Config{
+			NextProtos:   []string{"http/1.1"},
+			Certificates: []tls.Certificate{cert},
+		},
+	}
+	transport := &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true,
+		},
+	}
+	client := &http.Client{Transport: transport}
+	down := &httpdown.HTTP{}
+	s, err := down.ListenAndServe(server)
+	ensure.Nil(t, err)
+	res, err := client.Get(fmt.Sprintf("https://%s/", server.Addr))
+	ensure.Nil(t, err)
+
+	finStop := make(chan struct{})
+	go func() {
+		defer close(finStop)
+		ensure.Nil(t, s.Stop())
+	}()
+
+	actualBody, err := ioutil.ReadAll(res.Body)
+	ensure.Nil(t, err)
+	ensure.DeepEqual(t, actualBody, bytes.Repeat(hello, count))
+	ensure.Nil(t, res.Body.Close())
+	<-finOkHandler
+	<-finStop
+}
+
+// localhostCert is a PEM-encoded TLS cert with SAN IPs
+// "127.0.0.1" and "[::1]", expiring at the last second of 2049 (the end
+// of ASN.1 time).
+// generated from src/pkg/crypto/tls:
+// go run generate_cert.go  --rsa-bits 512 --host 127.0.0.1,::1,example.com --ca --start-date "Jan 1 00:00:00 1970" --duration=1000000h
+var localhostCert = []byte(`-----BEGIN CERTIFICATE-----
+MIIBdzCCASOgAwIBAgIBADALBgkqhkiG9w0BAQUwEjEQMA4GA1UEChMHQWNtZSBD
+bzAeFw03MDAxMDEwMDAwMDBaFw00OTEyMzEyMzU5NTlaMBIxEDAOBgNVBAoTB0Fj
+bWUgQ28wWjALBgkqhkiG9w0BAQEDSwAwSAJBALyCfqwwip8BvTKgVKGdmjZTU8DD
+ndR+WALmFPIRqn89bOU3s30olKiqYEju/SFoEvMyFRT/TWEhXHDaufThqaMCAwEA
+AaNoMGYwDgYDVR0PAQH/BAQDAgCkMBMGA1UdJQQMMAoGCCsGAQUFBwMBMA8GA1Ud
+EwEB/wQFMAMBAf8wLgYDVR0RBCcwJYILZXhhbXBsZS5jb22HBH8AAAGHEAAAAAAA
+AAAAAAAAAAAAAAEwCwYJKoZIhvcNAQEFA0EAr/09uy108p51rheIOSnz4zgduyTl
+M+4AmRo8/U1twEZLgfAGG/GZjREv2y4mCEUIM3HebCAqlA5jpRg76Rf8jw==
+-----END CERTIFICATE-----`)
+
+// localhostKey is the private key for localhostCert.
+var localhostKey = []byte(`-----BEGIN RSA PRIVATE KEY-----
+MIIBOQIBAAJBALyCfqwwip8BvTKgVKGdmjZTU8DDndR+WALmFPIRqn89bOU3s30o
+lKiqYEju/SFoEvMyFRT/TWEhXHDaufThqaMCAwEAAQJAPXuWUxTV8XyAt8VhNQER
+LgzJcUKb9JVsoS1nwXgPksXnPDKnL9ax8VERrdNr+nZbj2Q9cDSXBUovfdtehcdP
+qQIhAO48ZsPylbTrmtjDEKiHT2Ik04rLotZYS2U873J6I7WlAiEAypDjYxXyafv/
+Yo1pm9onwcetQKMW8CS3AjuV9Axzj6cCIEx2Il19fEMG4zny0WPlmbrcKvD/DpJQ
+4FHrzsYlIVTpAiAas7S1uAvneqd0l02HlN9OxQKKlbUNXNme+rnOnOGS2wIgS0jW
+zl1jvrOSJeP1PpAHohWz6LOhEr8uvltWkN6x3vE=
+-----END RSA PRIVATE KEY-----`)

vendor/github.com/facebookgo/stats/stats_test.go

@@ -0,0 +1,77 @@
+package stats_test
+
+import (
+	"testing"
+
+	"github.com/facebookgo/ensure"
+	"github.com/facebookgo/stats"
+)
+
+// Ensure calling End works even when a BumpTimeHook isn't provided.
+func TestHookClientBumpTime(t *testing.T) {
+	(&stats.HookClient{}).BumpTime("foo").End()
+}
+
+func TestPrefixClient(t *testing.T) {
+	const (
+		prefix1      = "prefix1"
+		prefix2      = "prefix2"
+		avgKey       = "avg"
+		avgVal       = float64(1)
+		sumKey       = "sum"
+		sumVal       = float64(2)
+		histogramKey = "histogram"
+		histogramVal = float64(3)
+		timeKey      = "time"
+	)
+
+	var keys []string
+	hc := &stats.HookClient{
+		BumpAvgHook: func(key string, val float64) {
+			keys = append(keys, key)
+			ensure.DeepEqual(t, val, avgVal)
+		},
+		BumpSumHook: func(key string, val float64) {
+			keys = append(keys, key)
+			ensure.DeepEqual(t, val, sumVal)
+		},
+		BumpHistogramHook: func(key string, val float64) {
+			keys = append(keys, key)
+			ensure.DeepEqual(t, val, histogramVal)
+		},
+		BumpTimeHook: func(key string) interface {
+			End()
+		} {
+			return multiEnderTest{
+				EndHook: func() {
+					keys = append(keys, key)
+				},
+			}
+		},
+	}
+
+	pc := stats.PrefixClient([]string{prefix1, prefix2}, hc)
+	pc.BumpAvg(avgKey, avgVal)
+	pc.BumpSum(sumKey, sumVal)
+	pc.BumpHistogram(histogramKey, histogramVal)
+	pc.BumpTime(timeKey).End()
+
+	ensure.SameElements(t, keys, []string{
+		prefix1 + avgKey,
+		prefix1 + sumKey,
+		prefix1 + histogramKey,
+		prefix1 + timeKey,
+		prefix2 + avgKey,
+		prefix2 + sumKey,
+		prefix2 + histogramKey,
+		prefix2 + timeKey,
+	})
+}
+
+type multiEnderTest struct {
+	EndHook func()
+}
+
+func (e multiEnderTest) End() {
+	e.EndHook()
+}

vendor/github.com/fatih/structs/field_test.go

@@ -0,0 +1,324 @@
+package structs
+
+import (
+	"reflect"
+	"testing"
+)
+
+// A test struct that defines all cases
+type Foo struct {
+	A    string
+	B    int    `structs:"y"`
+	C    bool   `json:"c"`
+	d    string // not exported
+	E    *Baz
+	x    string `xml:"x"` // not exported, with tag
+	Y    []string
+	Z    map[string]interface{}
+	*Bar // embedded
+}
+
+type Baz struct {
+	A string
+	B int
+}
+
+type Bar struct {
+	E string
+	F int
+	g []string
+}
+
+func newStruct() *Struct {
+	b := &Bar{
+		E: "example",
+		F: 2,
+		g: []string{"zeynep", "fatih"},
+	}
+
+	// B and x is not initialized for testing
+	f := &Foo{
+		A: "gopher",
+		C: true,
+		d: "small",
+		E: nil,
+		Y: []string{"example"},
+		Z: nil,
+	}
+	f.Bar = b
+
+	return New(f)
+}
+
+func TestField_Set(t *testing.T) {
+	s := newStruct()
+
+	f := s.Field("A")
+	err := f.Set("fatih")
+	if err != nil {
+		t.Error(err)
+	}
+
+	if f.Value().(string) != "fatih" {
+		t.Errorf("Setted value is wrong: %s want: %s", f.Value().(string), "fatih")
+	}
+
+	f = s.Field("Y")
+	err = f.Set([]string{"override", "with", "this"})
+	if err != nil {
+		t.Error(err)
+	}
+
+	sliceLen := len(f.Value().([]string))
+	if sliceLen != 3 {
+		t.Errorf("Setted values slice length is wrong: %d, want: %d", sliceLen, 3)
+	}
+
+	f = s.Field("C")
+	err = f.Set(false)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if f.Value().(bool) {
+		t.Errorf("Setted value is wrong: %s want: %s", f.Value().(bool), false)
+	}
+
+	// let's pass a different type
+	f = s.Field("A")
+	err = f.Set(123) // Field A is of type string, but we are going to pass an integer
+	if err == nil {
+		t.Error("Setting a field's value with a different type than the field's type should return an error")
+	}
+
+	// old value should be still there :)
+	if f.Value().(string) != "fatih" {
+		t.Errorf("Setted value is wrong: %s want: %s", f.Value().(string), "fatih")
+	}
+
+	// let's access an unexported field, which should give an error
+	f = s.Field("d")
+	err = f.Set("large")
+	if err != errNotExported {
+		t.Error(err)
+	}
+
+	// let's set a pointer to struct
+	b := &Bar{
+		E: "gopher",
+		F: 2,
+	}
+
+	f = s.Field("Bar")
+	err = f.Set(b)
+	if err != nil {
+		t.Error(err)
+	}
+
+	baz := &Baz{
+		A: "helloWorld",
+		B: 42,
+	}
+
+	f = s.Field("E")
+	err = f.Set(baz)
+	if err != nil {
+		t.Error(err)
+	}
+
+	ba := s.Field("E").Value().(*Baz)
+
+	if ba.A != "helloWorld" {
+		t.Errorf("could not set baz. Got: %s Want: helloWorld", ba.A)
+	}
+}
+
+func TestField(t *testing.T) {
+	s := newStruct()
+
+	defer func() {
+		err := recover()
+		if err == nil {
+			t.Error("Retrieveing a non existing field from the struct should panic")
+		}
+	}()
+
+	_ = s.Field("no-field")
+}
+
+func TestField_Kind(t *testing.T) {
+	s := newStruct()
+
+	f := s.Field("A")
+	if f.Kind() != reflect.String {
+		t.Errorf("Field A has wrong kind: %s want: %s", f.Kind(), reflect.String)
+	}
+
+	f = s.Field("B")
+	if f.Kind() != reflect.Int {
+		t.Errorf("Field B has wrong kind: %s want: %s", f.Kind(), reflect.Int)
+	}
+
+	// unexported
+	f = s.Field("d")
+	if f.Kind() != reflect.String {
+		t.Errorf("Field d has wrong kind: %s want: %s", f.Kind(), reflect.String)
+	}
+}
+
+func TestField_Tag(t *testing.T) {
+	s := newStruct()
+
+	v := s.Field("B").Tag("json")
+	if v != "" {
+		t.Errorf("Field's tag value of a non existing tag should return empty, got: %s", v)
+	}
+
+	v = s.Field("C").Tag("json")
+	if v != "c" {
+		t.Errorf("Field's tag value of the existing field C should return 'c', got: %s", v)
+	}
+
+	v = s.Field("d").Tag("json")
+	if v != "" {
+		t.Errorf("Field's tag value of a non exported field should return empty, got: %s", v)
+	}
+
+	v = s.Field("x").Tag("xml")
+	if v != "x" {
+		t.Errorf("Field's tag value of a non exported field with a tag should return 'x', got: %s", v)
+	}
+
+	v = s.Field("A").Tag("json")
+	if v != "" {
+		t.Errorf("Field's tag value of a existing field without a tag should return empty, got: %s", v)
+	}
+}
+
+func TestField_Value(t *testing.T) {
+	s := newStruct()
+
+	v := s.Field("A").Value()
+	val, ok := v.(string)
+	if !ok {
+		t.Errorf("Field's value of a A should be string")
+	}
+
+	if val != "gopher" {
+		t.Errorf("Field's value of a existing tag should return 'gopher', got: %s", val)
+	}
+
+	defer func() {
+		err := recover()
+		if err == nil {
+			t.Error("Value of a non exported field from the field should panic")
+		}
+	}()
+
+	// should panic
+	_ = s.Field("d").Value()
+}
+
+func TestField_IsEmbedded(t *testing.T) {
+	s := newStruct()
+
+	if !s.Field("Bar").IsEmbedded() {
+		t.Errorf("Fields 'Bar' field is an embedded field")
+	}
+
+	if s.Field("d").IsEmbedded() {
+		t.Errorf("Fields 'd' field is not an embedded field")
+	}
+}
+
+func TestField_IsExported(t *testing.T) {
+	s := newStruct()
+
+	if !s.Field("Bar").IsExported() {
+		t.Errorf("Fields 'Bar' field is an exported field")
+	}
+
+	if !s.Field("A").IsExported() {
+		t.Errorf("Fields 'A' field is an exported field")
+	}
+
+	if s.Field("d").IsExported() {
+		t.Errorf("Fields 'd' field is not an exported field")
+	}
+}
+
+func TestField_IsZero(t *testing.T) {
+	s := newStruct()
+
+	if s.Field("A").IsZero() {
+		t.Errorf("Fields 'A' field is an initialized field")
+	}
+
+	if !s.Field("B").IsZero() {
+		t.Errorf("Fields 'B' field is not an initialized field")
+	}
+}
+
+func TestField_Name(t *testing.T) {
+	s := newStruct()
+
+	if s.Field("A").Name() != "A" {
+		t.Errorf("Fields 'A' field should have the name 'A'")
+	}
+}
+
+func TestField_Field(t *testing.T) {
+	s := newStruct()
+
+	e := s.Field("Bar").Field("E")
+
+	val, ok := e.Value().(string)
+	if !ok {
+		t.Error("The value of the field 'e' inside 'Bar' struct should be string")
+	}
+
+	if val != "example" {
+		t.Errorf("The value of 'e' should be 'example, got: %s", val)
+	}
+
+	defer func() {
+		err := recover()
+		if err == nil {
+			t.Error("Field of a non existing nested struct should panic")
+		}
+	}()
+
+	_ = s.Field("Bar").Field("e")
+}
+
+func TestField_Fields(t *testing.T) {
+	s := newStruct()
+	fields := s.Field("Bar").Fields()
+
+	if len(fields) != 3 {
+		t.Errorf("We expect 3 fields in embedded struct, was: %d", len(fields))
+	}
+}
+
+func TestField_FieldOk(t *testing.T) {
+	s := newStruct()
+
+	b, ok := s.FieldOk("Bar")
+	if !ok {
+		t.Error("The field 'Bar' should exists.")
+	}
+
+	e, ok := b.FieldOk("E")
+	if !ok {
+		t.Error("The field 'E' should exists.")
+	}
+
+	val, ok := e.Value().(string)
+	if !ok {
+		t.Error("The value of the field 'e' inside 'Bar' struct should be string")
+	}
+
+	if val != "example" {
+		t.Errorf("The value of 'e' should be 'example, got: %s", val)
+	}
+}

vendor/github.com/fatih/structs/structs_example_test.go

@@ -0,0 +1,351 @@
+package structs
+
+import (
+	"fmt"
+	"time"
+)
+
+func ExampleNew() {
+	type Server struct {
+		Name    string
+		ID      int32
+		Enabled bool
+	}
+
+	server := &Server{
+		Name:    "Arslan",
+		ID:      123456,
+		Enabled: true,
+	}
+
+	s := New(server)
+
+	fmt.Printf("Name        : %v\n", s.Name())
+	fmt.Printf("Values      : %v\n", s.Values())
+	fmt.Printf("Value of ID : %v\n", s.Field("ID").Value())
+	// Output:
+	// Name        : Server
+	// Values      : [Arslan 123456 true]
+	// Value of ID : 123456
+
+}
+
+func ExampleMap() {
+	type Server struct {
+		Name    string
+		ID      int32
+		Enabled bool
+	}
+
+	s := &Server{
+		Name:    "Arslan",
+		ID:      123456,
+		Enabled: true,
+	}
+
+	m := Map(s)
+
+	fmt.Printf("%#v\n", m["Name"])
+	fmt.Printf("%#v\n", m["ID"])
+	fmt.Printf("%#v\n", m["Enabled"])
+	// Output:
+	// "Arslan"
+	// 123456
+	// true
+
+}
+
+func ExampleMap_tags() {
+	// Custom tags can change the map keys instead of using the fields name
+	type Server struct {
+		Name    string `structs:"server_name"`
+		ID      int32  `structs:"server_id"`
+		Enabled bool   `structs:"enabled"`
+	}
+
+	s := &Server{
+		Name: "Zeynep",
+		ID:   789012,
+	}
+
+	m := Map(s)
+
+	// access them by the custom tags defined above
+	fmt.Printf("%#v\n", m["server_name"])
+	fmt.Printf("%#v\n", m["server_id"])
+	fmt.Printf("%#v\n", m["enabled"])
+	// Output:
+	// "Zeynep"
+	// 789012
+	// false
+
+}
+
+func ExampleMap_nested() {
+	// By default field with struct types are processed too. We can stop
+	// processing them via "omitnested" tag option.
+	type Server struct {
+		Name string    `structs:"server_name"`
+		ID   int32     `structs:"server_id"`
+		Time time.Time `structs:"time,omitnested"` // do not convert to map[string]interface{}
+	}
+
+	const shortForm = "2006-Jan-02"
+	t, _ := time.Parse("2006-Jan-02", "2013-Feb-03")
+
+	s := &Server{
+		Name: "Zeynep",
+		ID:   789012,
+		Time: t,
+	}
+
+	m := Map(s)
+
+	// access them by the custom tags defined above
+	fmt.Printf("%v\n", m["server_name"])
+	fmt.Printf("%v\n", m["server_id"])
+	fmt.Printf("%v\n", m["time"].(time.Time))
+	// Output:
+	// Zeynep
+	// 789012
+	// 2013-02-03 00:00:00 +0000 UTC
+}
+
+func ExampleMap_omitEmpty() {
+	// By default field with struct types of zero values are processed too. We
+	// can stop processing them via "omitempty" tag option.
+	type Server struct {
+		Name     string `structs:",omitempty"`
+		ID       int32  `structs:"server_id,omitempty"`
+		Location string
+	}
+
+	// Only add location
+	s := &Server{
+		Location: "Tokyo",
+	}
+
+	m := Map(s)
+
+	// map contains only the Location field
+	fmt.Printf("%v\n", m)
+	// Output:
+	// map[Location:Tokyo]
+}
+
+func ExampleValues() {
+	type Server struct {
+		Name    string
+		ID      int32
+		Enabled bool
+	}
+
+	s := &Server{
+		Name:    "Fatih",
+		ID:      135790,
+		Enabled: false,
+	}
+
+	m := Values(s)
+
+	fmt.Printf("Values: %+v\n", m)
+	// Output:
+	// Values: [Fatih 135790 false]
+}
+
+func ExampleValues_omitEmpty() {
+	// By default field with struct types of zero values are processed too. We
+	// can stop processing them via "omitempty" tag option.
+	type Server struct {
+		Name     string `structs:",omitempty"`
+		ID       int32  `structs:"server_id,omitempty"`
+		Location string
+	}
+
+	// Only add location
+	s := &Server{
+		Location: "Ankara",
+	}
+
+	m := Values(s)
+
+	// values contains only the Location field
+	fmt.Printf("Values: %+v\n", m)
+	// Output:
+	// Values: [Ankara]
+}
+
+func ExampleValues_tags() {
+	type Location struct {
+		City    string
+		Country string
+	}
+
+	type Server struct {
+		Name     string
+		ID       int32
+		Enabled  bool
+		Location Location `structs:"-"` // values from location are not included anymore
+	}
+
+	s := &Server{
+		Name:     "Fatih",
+		ID:       135790,
+		Enabled:  false,
+		Location: Location{City: "Ankara", Country: "Turkey"},
+	}
+
+	// Let get all values from the struct s. Note that we don't include values
+	// from the Location field
+	m := Values(s)
+
+	fmt.Printf("Values: %+v\n", m)
+	// Output:
+	// Values: [Fatih 135790 false]
+}
+
+func ExampleFields() {
+	type Access struct {
+		Name         string
+		LastAccessed time.Time
+		Number       int
+	}
+
+	s := &Access{
+		Name:         "Fatih",
+		LastAccessed: time.Now(),
+		Number:       1234567,
+	}
+
+	fields := Fields(s)
+
+	for i, field := range fields {
+		fmt.Printf("[%d] %+v\n", i, field.Name())
+	}
+
+	// Output:
+	// [0] Name
+	// [1] LastAccessed
+	// [2] Number
+}
+
+func ExampleFields_nested() {
+	type Person struct {
+		Name   string
+		Number int
+	}
+
+	type Access struct {
+		Person        Person
+		HasPermission bool
+		LastAccessed  time.Time
+	}
+
+	s := &Access{
+		Person:        Person{Name: "fatih", Number: 1234567},
+		LastAccessed:  time.Now(),
+		HasPermission: true,
+	}
+
+	// Let's get all fields from the struct s.
+	fields := Fields(s)
+
+	for _, field := range fields {
+		if field.Name() == "Person" {
+			fmt.Printf("Access.Person.Name: %+v\n", field.Field("Name").Value())
+		}
+	}
+
+	// Output:
+	// Access.Person.Name: fatih
+}
+
+func ExampleField() {
+	type Person struct {
+		Name   string
+		Number int
+	}
+
+	type Access struct {
+		Person        Person
+		HasPermission bool
+		LastAccessed  time.Time
+	}
+
+	access := &Access{
+		Person:        Person{Name: "fatih", Number: 1234567},
+		LastAccessed:  time.Now(),
+		HasPermission: true,
+	}
+
+	// Create a new Struct type
+	s := New(access)
+
+	// Get the Field type for "Person" field
+	p := s.Field("Person")
+
+	// Get the underlying "Name field" and print the value of it
+	name := p.Field("Name")
+
+	fmt.Printf("Value of Person.Access.Name: %+v\n", name.Value())
+
+	// Output:
+	// Value of Person.Access.Name: fatih
+
+}
+
+func ExampleIsZero() {
+	type Server struct {
+		Name    string
+		ID      int32
+		Enabled bool
+	}
+
+	// Nothing is initalized
+	a := &Server{}
+	isZeroA := IsZero(a)
+
+	// Name and Enabled is initialized, but not ID
+	b := &Server{
+		Name:    "Golang",
+		Enabled: true,
+	}
+	isZeroB := IsZero(b)
+
+	fmt.Printf("%#v\n", isZeroA)
+	fmt.Printf("%#v\n", isZeroB)
+	// Output:
+	// true
+	// false
+}
+
+func ExampleHasZero() {
+	// Let's define an Access struct. Note that the "Enabled" field is not
+	// going to be checked because we added the "structs" tag to the field.
+	type Access struct {
+		Name         string
+		LastAccessed time.Time
+		Number       int
+		Enabled      bool `structs:"-"`
+	}
+
+	// Name and Number is not initialized.
+	a := &Access{
+		LastAccessed: time.Now(),
+	}
+	hasZeroA := HasZero(a)
+
+	// Name and Number is initialized.
+	b := &Access{
+		Name:         "Fatih",
+		LastAccessed: time.Now(),
+		Number:       12345,
+	}
+	hasZeroB := HasZero(b)
+
+	fmt.Printf("%#v\n", hasZeroA)
+	fmt.Printf("%#v\n", hasZeroB)
+	// Output:
+	// true
+	// false
+}

vendor/github.com/fatih/structs/structs_test.go

@@ -0,0 +1,898 @@
+package structs
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestMapNonStruct(t *testing.T) {
+	foo := []string{"foo"}
+
+	defer func() {
+		err := recover()
+		if err == nil {
+			t.Error("Passing a non struct into Map should panic")
+		}
+	}()
+
+	// this should panic. We are going to recover and and test it
+	_ = Map(foo)
+}
+
+func TestStructIndexes(t *testing.T) {
+	type C struct {
+		something int
+		Props     map[string]interface{}
+	}
+
+	defer func() {
+		err := recover()
+		if err != nil {
+			fmt.Printf("err %+v\n", err)
+			t.Error("Using mixed indexes should not panic")
+		}
+	}()
+
+	// They should not panic
+	_ = Map(&C{})
+	_ = Fields(&C{})
+	_ = Values(&C{})
+	_ = IsZero(&C{})
+	_ = HasZero(&C{})
+}
+
+func TestMap(t *testing.T) {
+	var T = struct {
+		A string
+		B int
+		C bool
+	}{
+		A: "a-value",
+		B: 2,
+		C: true,
+	}
+
+	a := Map(T)
+
+	if typ := reflect.TypeOf(a).Kind(); typ != reflect.Map {
+		t.Errorf("Map should return a map type, got: %v", typ)
+	}
+
+	// we have three fields
+	if len(a) != 3 {
+		t.Errorf("Map should return a map of len 3, got: %d", len(a))
+	}
+
+	inMap := func(val interface{}) bool {
+		for _, v := range a {
+			if reflect.DeepEqual(v, val) {
+				return true
+			}
+		}
+
+		return false
+	}
+
+	for _, val := range []interface{}{"a-value", 2, true} {
+		if !inMap(val) {
+			t.Errorf("Map should have the value %v", val)
+		}
+	}
+
+}
+
+func TestMap_Tag(t *testing.T) {
+	var T = struct {
+		A string `structs:"x"`
+		B int    `structs:"y"`
+		C bool   `structs:"z"`
+	}{
+		A: "a-value",
+		B: 2,
+		C: true,
+	}
+
+	a := Map(T)
+
+	inMap := func(key interface{}) bool {
+		for k := range a {
+			if reflect.DeepEqual(k, key) {
+				return true
+			}
+		}
+		return false
+	}
+
+	for _, key := range []string{"x", "y", "z"} {
+		if !inMap(key) {
+			t.Errorf("Map should have the key %v", key)
+		}
+	}
+
+}
+
+func TestMap_CustomTag(t *testing.T) {
+	var T = struct {
+		A string `json:"x"`
+		B int    `json:"y"`
+		C bool   `json:"z"`
+		D struct {
+			E string `json:"jkl"`
+		} `json:"nested"`
+	}{
+		A: "a-value",
+		B: 2,
+		C: true,
+	}
+	T.D.E = "e-value"
+
+	s := New(T)
+	s.TagName = "json"
+
+	a := s.Map()
+
+	inMap := func(key interface{}) bool {
+		for k := range a {
+			if reflect.DeepEqual(k, key) {
+				return true
+			}
+		}
+		return false
+	}
+
+	for _, key := range []string{"x", "y", "z"} {
+		if !inMap(key) {
+			t.Errorf("Map should have the key %v", key)
+		}
+	}
+
+	nested, ok := a["nested"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("Map should contain the D field that is tagged as 'nested'")
+	}
+
+	e, ok := nested["jkl"].(string)
+	if !ok {
+		t.Fatalf("Map should contain the D.E field that is tagged as 'jkl'")
+	}
+
+	if e != "e-value" {
+		t.Errorf("D.E field should be equal to 'e-value', got: '%v'", e)
+	}
+
+}
+
+func TestMap_MultipleCustomTag(t *testing.T) {
+	var A = struct {
+		X string `aa:"ax"`
+	}{"a_value"}
+
+	aStruct := New(A)
+	aStruct.TagName = "aa"
+
+	var B = struct {
+		X string `bb:"bx"`
+	}{"b_value"}
+
+	bStruct := New(B)
+	bStruct.TagName = "bb"
+
+	a, b := aStruct.Map(), bStruct.Map()
+	if !reflect.DeepEqual(a, map[string]interface{}{"ax": "a_value"}) {
+		t.Error("Map should have field ax with value a_value")
+	}
+
+	if !reflect.DeepEqual(b, map[string]interface{}{"bx": "b_value"}) {
+		t.Error("Map should have field bx with value b_value")
+	}
+}
+
+func TestMap_OmitEmpty(t *testing.T) {
+	type A struct {
+		Name  string
+		Value string    `structs:",omitempty"`
+		Time  time.Time `structs:",omitempty"`
+	}
+	a := A{}
+
+	m := Map(a)
+
+	_, ok := m["Value"].(map[string]interface{})
+	if ok {
+		t.Error("Map should not contain the Value field that is tagged as omitempty")
+	}
+
+	_, ok = m["Time"].(map[string]interface{})
+	if ok {
+		t.Error("Map should not contain the Time field that is tagged as omitempty")
+	}
+}
+
+func TestMap_OmitNested(t *testing.T) {
+	type A struct {
+		Name  string
+		Value string
+		Time  time.Time `structs:",omitnested"`
+	}
+	a := A{Time: time.Now()}
+
+	type B struct {
+		Desc string
+		A    A
+	}
+	b := &B{A: a}
+
+	m := Map(b)
+
+	in, ok := m["A"].(map[string]interface{})
+	if !ok {
+		t.Error("Map nested structs is not available in the map")
+	}
+
+	// should not happen
+	if _, ok := in["Time"].(map[string]interface{}); ok {
+		t.Error("Map nested struct should omit recursiving parsing of Time")
+	}
+
+	if _, ok := in["Time"].(time.Time); !ok {
+		t.Error("Map nested struct should stop parsing of Time at is current value")
+	}
+}
+
+func TestMap_Nested(t *testing.T) {
+	type A struct {
+		Name string
+	}
+	a := &A{Name: "example"}
+
+	type B struct {
+		A *A
+	}
+	b := &B{A: a}
+
+	m := Map(b)
+
+	if typ := reflect.TypeOf(m).Kind(); typ != reflect.Map {
+		t.Errorf("Map should return a map type, got: %v", typ)
+	}
+
+	in, ok := m["A"].(map[string]interface{})
+	if !ok {
+		t.Error("Map nested structs is not available in the map")
+	}
+
+	if name := in["Name"].(string); name != "example" {
+		t.Errorf("Map nested struct's name field should give example, got: %s", name)
+	}
+}
+
+func TestMap_Anonymous(t *testing.T) {
+	type A struct {
+		Name string
+	}
+	a := &A{Name: "example"}
+
+	type B struct {
+		*A
+	}
+	b := &B{}
+	b.A = a
+
+	m := Map(b)
+
+	if typ := reflect.TypeOf(m).Kind(); typ != reflect.Map {
+		t.Errorf("Map should return a map type, got: %v", typ)
+	}
+
+	in, ok := m["A"].(map[string]interface{})
+	if !ok {
+		t.Error("Embedded structs is not available in the map")
+	}
+
+	if name := in["Name"].(string); name != "example" {
+		t.Errorf("Embedded A struct's Name field should give example, got: %s", name)
+	}
+}
+
+func TestStruct(t *testing.T) {
+	var T = struct{}{}
+
+	if !IsStruct(T) {
+		t.Errorf("T should be a struct, got: %T", T)
+	}
+
+	if !IsStruct(&T) {
+		t.Errorf("T should be a struct, got: %T", T)
+	}
+
+}
+
+func TestValues(t *testing.T) {
+	var T = struct {
+		A string
+		B int
+		C bool
+	}{
+		A: "a-value",
+		B: 2,
+		C: true,
+	}
+
+	s := Values(T)
+
+	if typ := reflect.TypeOf(s).Kind(); typ != reflect.Slice {
+		t.Errorf("Values should return a slice type, got: %v", typ)
+	}
+
+	inSlice := func(val interface{}) bool {
+		for _, v := range s {
+			if reflect.DeepEqual(v, val) {
+				return true
+			}
+		}
+		return false
+	}
+
+	for _, val := range []interface{}{"a-value", 2, true} {
+		if !inSlice(val) {
+			t.Errorf("Values should have the value %v", val)
+		}
+	}
+}
+
+func TestValues_OmitEmpty(t *testing.T) {
+	type A struct {
+		Name  string
+		Value int `structs:",omitempty"`
+	}
+
+	a := A{Name: "example"}
+	s := Values(a)
+
+	if len(s) != 1 {
+		t.Errorf("Values of omitted empty fields should be not counted")
+	}
+
+	if s[0].(string) != "example" {
+		t.Errorf("Values of omitted empty fields should left the value example")
+	}
+}
+
+func TestValues_OmitNested(t *testing.T) {
+	type A struct {
+		Name  string
+		Value int
+	}
+
+	a := A{
+		Name:  "example",
+		Value: 123,
+	}
+
+	type B struct {
+		A A `structs:",omitnested"`
+		C int
+	}
+	b := &B{A: a, C: 123}
+
+	s := Values(b)
+
+	if len(s) != 2 {
+		t.Errorf("Values of omitted nested struct should be not counted")
+	}
+
+	inSlice := func(val interface{}) bool {
+		for _, v := range s {
+			if reflect.DeepEqual(v, val) {
+				return true
+			}
+		}
+		return false
+	}
+
+	for _, val := range []interface{}{123, a} {
+		if !inSlice(val) {
+			t.Errorf("Values should have the value %v", val)
+		}
+	}
+}
+
+func TestValues_Nested(t *testing.T) {
+	type A struct {
+		Name string
+	}
+	a := A{Name: "example"}
+
+	type B struct {
+		A A
+		C int
+	}
+	b := &B{A: a, C: 123}
+
+	s := Values(b)
+
+	inSlice := func(val interface{}) bool {
+		for _, v := range s {
+			if reflect.DeepEqual(v, val) {
+				return true
+			}
+		}
+		return false
+	}
+
+	for _, val := range []interface{}{"example", 123} {
+		if !inSlice(val) {
+			t.Errorf("Values should have the value %v", val)
+		}
+	}
+}
+
+func TestValues_Anonymous(t *testing.T) {
+	type A struct {
+		Name string
+	}
+	a := A{Name: "example"}
+
+	type B struct {
+		A
+		C int
+	}
+	b := &B{C: 123}
+	b.A = a
+
+	s := Values(b)
+
+	inSlice := func(val interface{}) bool {
+		for _, v := range s {
+			if reflect.DeepEqual(v, val) {
+				return true
+			}
+		}
+		return false
+	}
+
+	for _, val := range []interface{}{"example", 123} {
+		if !inSlice(val) {
+			t.Errorf("Values should have the value %v", val)
+		}
+	}
+}
+
+func TestNames(t *testing.T) {
+	var T = struct {
+		A string
+		B int
+		C bool
+	}{
+		A: "a-value",
+		B: 2,
+		C: true,
+	}
+
+	s := Names(T)
+
+	if len(s) != 3 {
+		t.Errorf("Names should return a slice of len 3, got: %d", len(s))
+	}
+
+	inSlice := func(val string) bool {
+		for _, v := range s {
+			if reflect.DeepEqual(v, val) {
+				return true
+			}
+		}
+		return false
+	}
+
+	for _, val := range []string{"A", "B", "C"} {
+		if !inSlice(val) {
+			t.Errorf("Names should have the value %v", val)
+		}
+	}
+}
+
+func TestFields(t *testing.T) {
+	var T = struct {
+		A string
+		B int
+		C bool
+	}{
+		A: "a-value",
+		B: 2,
+		C: true,
+	}
+
+	s := Fields(T)
+
+	if len(s) != 3 {
+		t.Errorf("Fields should return a slice of len 3, got: %d", len(s))
+	}
+
+	inSlice := func(val string) bool {
+		for _, v := range s {
+			if reflect.DeepEqual(v.Name(), val) {
+				return true
+			}
+		}
+		return false
+	}
+
+	for _, val := range []string{"A", "B", "C"} {
+		if !inSlice(val) {
+			t.Errorf("Fields should have the value %v", val)
+		}
+	}
+}
+
+func TestFields_OmitNested(t *testing.T) {
+	type A struct {
+		Name    string
+		Enabled bool
+	}
+	a := A{Name: "example"}
+
+	type B struct {
+		A      A
+		C      int
+		Value  string `structs:"-"`
+		Number int
+	}
+	b := &B{A: a, C: 123}
+
+	s := Fields(b)
+
+	if len(s) != 3 {
+		t.Errorf("Fields should omit nested struct. Expecting 2 got: %d", len(s))
+	}
+
+	inSlice := func(val interface{}) bool {
+		for _, v := range s {
+			if reflect.DeepEqual(v.Name(), val) {
+				return true
+			}
+		}
+		return false
+	}
+
+	for _, val := range []interface{}{"A", "C"} {
+		if !inSlice(val) {
+			t.Errorf("Fields should have the value %v", val)
+		}
+	}
+}
+
+func TestFields_Anonymous(t *testing.T) {
+	type A struct {
+		Name string
+	}
+	a := A{Name: "example"}
+
+	type B struct {
+		A
+		C int
+	}
+	b := &B{C: 123}
+	b.A = a
+
+	s := Fields(b)
+
+	inSlice := func(val interface{}) bool {
+		for _, v := range s {
+			if reflect.DeepEqual(v.Name(), val) {
+				return true
+			}
+		}
+		return false
+	}
+
+	for _, val := range []interface{}{"A", "C"} {
+		if !inSlice(val) {
+			t.Errorf("Fields should have the value %v", val)
+		}
+	}
+}
+
+func TestIsZero(t *testing.T) {
+	var T = struct {
+		A string
+		B int
+		C bool `structs:"-"`
+		D []string
+	}{}
+
+	ok := IsZero(T)
+	if !ok {
+		t.Error("IsZero should return true because none of the fields are initialized.")
+	}
+
+	var X = struct {
+		A string
+		F *bool
+	}{
+		A: "a-value",
+	}
+
+	ok = IsZero(X)
+	if ok {
+		t.Error("IsZero should return false because A is initialized")
+	}
+
+	var Y = struct {
+		A string
+		B int
+	}{
+		A: "a-value",
+		B: 123,
+	}
+
+	ok = IsZero(Y)
+	if ok {
+		t.Error("IsZero should return false because A and B is initialized")
+	}
+}
+
+func TestIsZero_OmitNested(t *testing.T) {
+	type A struct {
+		Name string
+		D    string
+	}
+	a := A{Name: "example"}
+
+	type B struct {
+		A A `structs:",omitnested"`
+		C int
+	}
+	b := &B{A: a, C: 123}
+
+	ok := IsZero(b)
+	if ok {
+		t.Error("IsZero should return false because A, B and C are initialized")
+	}
+
+	aZero := A{}
+	bZero := &B{A: aZero}
+
+	ok = IsZero(bZero)
+	if !ok {
+		t.Error("IsZero should return true because neither A nor B is initialized")
+	}
+
+}
+
+func TestIsZero_Nested(t *testing.T) {
+	type A struct {
+		Name string
+		D    string
+	}
+	a := A{Name: "example"}
+
+	type B struct {
+		A A
+		C int
+	}
+	b := &B{A: a, C: 123}
+
+	ok := IsZero(b)
+	if ok {
+		t.Error("IsZero should return false because A, B and C are initialized")
+	}
+
+	aZero := A{}
+	bZero := &B{A: aZero}
+
+	ok = IsZero(bZero)
+	if !ok {
+		t.Error("IsZero should return true because neither A nor B is initialized")
+	}
+
+}
+
+func TestIsZero_Anonymous(t *testing.T) {
+	type A struct {
+		Name string
+		D    string
+	}
+	a := A{Name: "example"}
+
+	type B struct {
+		A
+		C int
+	}
+	b := &B{C: 123}
+	b.A = a
+
+	ok := IsZero(b)
+	if ok {
+		t.Error("IsZero should return false because A, B and C are initialized")
+	}
+
+	aZero := A{}
+	bZero := &B{}
+	bZero.A = aZero
+
+	ok = IsZero(bZero)
+	if !ok {
+		t.Error("IsZero should return true because neither A nor B is initialized")
+	}
+}
+
+func TestHasZero(t *testing.T) {
+	var T = struct {
+		A string
+		B int
+		C bool `structs:"-"`
+		D []string
+	}{
+		A: "a-value",
+		B: 2,
+	}
+
+	ok := HasZero(T)
+	if !ok {
+		t.Error("HasZero should return true because A and B are initialized.")
+	}
+
+	var X = struct {
+		A string
+		F *bool
+	}{
+		A: "a-value",
+	}
+
+	ok = HasZero(X)
+	if !ok {
+		t.Error("HasZero should return true because A is initialized")
+	}
+
+	var Y = struct {
+		A string
+		B int
+	}{
+		A: "a-value",
+		B: 123,
+	}
+
+	ok = HasZero(Y)
+	if ok {
+		t.Error("HasZero should return false because A and B is initialized")
+	}
+}
+
+func TestHasZero_OmitNested(t *testing.T) {
+	type A struct {
+		Name string
+		D    string
+	}
+	a := A{Name: "example"}
+
+	type B struct {
+		A A `structs:",omitnested"`
+		C int
+	}
+	b := &B{A: a, C: 123}
+
+	// Because the Field A inside B is omitted  HasZero should return false
+	// because it will stop iterating deeper andnot going to lookup for D
+	ok := HasZero(b)
+	if ok {
+		t.Error("HasZero should return false because A and C are initialized")
+	}
+}
+
+func TestHasZero_Nested(t *testing.T) {
+	type A struct {
+		Name string
+		D    string
+	}
+	a := A{Name: "example"}
+
+	type B struct {
+		A A
+		C int
+	}
+	b := &B{A: a, C: 123}
+
+	ok := HasZero(b)
+	if !ok {
+		t.Error("HasZero should return true because D is not initialized")
+	}
+}
+
+func TestHasZero_Anonymous(t *testing.T) {
+	type A struct {
+		Name string
+		D    string
+	}
+	a := A{Name: "example"}
+
+	type B struct {
+		A
+		C int
+	}
+	b := &B{C: 123}
+	b.A = a
+
+	ok := HasZero(b)
+	if !ok {
+		t.Error("HasZero should return false because D is not initialized")
+	}
+}
+
+func TestName(t *testing.T) {
+	type Foo struct {
+		A string
+		B bool
+	}
+	f := &Foo{}
+
+	n := Name(f)
+	if n != "Foo" {
+		t.Errorf("Name should return Foo, got: %s", n)
+	}
+
+	unnamed := struct{ Name string }{Name: "Cihangir"}
+	m := Name(unnamed)
+	if m != "" {
+		t.Errorf("Name should return empty string for unnamed struct, got: %s", n)
+	}
+
+	defer func() {
+		err := recover()
+		if err == nil {
+			t.Error("Name should panic if a non struct is passed")
+		}
+	}()
+
+	Name([]string{})
+}
+
+func TestNestedNilPointer(t *testing.T) {
+	type Collar struct {
+		Engraving string
+	}
+
+	type Dog struct {
+		Name   string
+		Collar *Collar
+	}
+
+	type Person struct {
+		Name string
+		Dog  *Dog
+	}
+
+	person := &Person{
+		Name: "John",
+	}
+
+	personWithDog := &Person{
+		Name: "Ron",
+		Dog: &Dog{
+			Name: "Rover",
+		},
+	}
+
+	personWithDogWithCollar := &Person{
+		Name: "Kon",
+		Dog: &Dog{
+			Name: "Ruffles",
+			Collar: &Collar{
+				Engraving: "If lost, call Kon",
+			},
+		},
+	}
+
+	defer func() {
+		err := recover()
+		if err != nil {
+			fmt.Printf("err %+v\n", err)
+			t.Error("Internal nil pointer should not panic")
+		}
+	}()
+
+	_ = Map(person)                  // Panics
+	_ = Map(personWithDog)           // Panics
+	_ = Map(personWithDogWithCollar) // Doesn't panic
+}

vendor/github.com/fatih/structs/tags_test.go

@@ -0,0 +1,46 @@
+package structs
+
+import "testing"
+
+func TestParseTag_Name(t *testing.T) {
+	tags := []struct {
+		tag string
+		has bool
+	}{
+		{"", false},
+		{"name", true},
+		{"name,opt", true},
+		{"name , opt, opt2", false}, // has a single whitespace
+		{", opt, opt2", false},
+	}
+
+	for _, tag := range tags {
+		name, _ := parseTag(tag.tag)
+
+		if (name != "name") && tag.has {
+			t.Errorf("Parse tag should return name: %#v", tag)
+		}
+	}
+}
+
+func TestParseTag_Opts(t *testing.T) {
+	tags := []struct {
+		opts string
+		has  bool
+	}{
+		{"name", false},
+		{"name,opt", true},
+		{"name , opt, opt2", false}, // has a single whitespace
+		{",opt, opt2", true},
+		{", opt3, opt4", false},
+	}
+
+	// search for "opt"
+	for _, tag := range tags {
+		_, opts := parseTag(tag.opts)
+
+		if opts.Has("opt") != tag.has {
+			t.Errorf("Tag opts should have opt: %#v", tag)
+		}
+	}
+}

vendor/github.com/gorilla/context/context_test.go

@@ -0,0 +1,161 @@
+// 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 context
+
+import (
+	"net/http"
+	"testing"
+)
+
+type keyType int
+
+const (
+	key1 keyType = iota
+	key2
+)
+
+func TestContext(t *testing.T) {
+	assertEqual := func(val interface{}, exp interface{}) {
+		if val != exp {
+			t.Errorf("Expected %v, got %v.", exp, val)
+		}
+	}
+
+	r, _ := http.NewRequest("GET", "http://localhost:8080/", nil)
+	emptyR, _ := http.NewRequest("GET", "http://localhost:8080/", nil)
+
+	// Get()
+	assertEqual(Get(r, key1), nil)
+
+	// Set()
+	Set(r, key1, "1")
+	assertEqual(Get(r, key1), "1")
+	assertEqual(len(data[r]), 1)
+
+	Set(r, key2, "2")
+	assertEqual(Get(r, key2), "2")
+	assertEqual(len(data[r]), 2)
+
+	//GetOk
+	value, ok := GetOk(r, key1)
+	assertEqual(value, "1")
+	assertEqual(ok, true)
+
+	value, ok = GetOk(r, "not exists")
+	assertEqual(value, nil)
+	assertEqual(ok, false)
+
+	Set(r, "nil value", nil)
+	value, ok = GetOk(r, "nil value")
+	assertEqual(value, nil)
+	assertEqual(ok, true)
+
+	// GetAll()
+	values := GetAll(r)
+	assertEqual(len(values), 3)
+
+	// GetAll() for empty request
+	values = GetAll(emptyR)
+	if values != nil {
+		t.Error("GetAll didn't return nil value for invalid request")
+	}
+
+	// GetAllOk()
+	values, ok = GetAllOk(r)
+	assertEqual(len(values), 3)
+	assertEqual(ok, true)
+
+	// GetAllOk() for empty request
+	values, ok = GetAllOk(emptyR)
+	assertEqual(value, nil)
+	assertEqual(ok, false)
+
+	// Delete()
+	Delete(r, key1)
+	assertEqual(Get(r, key1), nil)
+	assertEqual(len(data[r]), 2)
+
+	Delete(r, key2)
+	assertEqual(Get(r, key2), nil)
+	assertEqual(len(data[r]), 1)
+
+	// Clear()
+	Clear(r)
+	assertEqual(len(data), 0)
+}
+
+func parallelReader(r *http.Request, key string, iterations int, wait, done chan struct{}) {
+	<-wait
+	for i := 0; i < iterations; i++ {
+		Get(r, key)
+	}
+	done <- struct{}{}
+
+}
+
+func parallelWriter(r *http.Request, key, value string, iterations int, wait, done chan struct{}) {
+	<-wait
+	for i := 0; i < iterations; i++ {
+		Set(r, key, value)
+	}
+	done <- struct{}{}
+
+}
+
+func benchmarkMutex(b *testing.B, numReaders, numWriters, iterations int) {
+
+	b.StopTimer()
+	r, _ := http.NewRequest("GET", "http://localhost:8080/", nil)
+	done := make(chan struct{})
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		wait := make(chan struct{})
+
+		for i := 0; i < numReaders; i++ {
+			go parallelReader(r, "test", iterations, wait, done)
+		}
+
+		for i := 0; i < numWriters; i++ {
+			go parallelWriter(r, "test", "123", iterations, wait, done)
+		}
+
+		close(wait)
+
+		for i := 0; i < numReaders+numWriters; i++ {
+			<-done
+		}
+
+	}
+
+}
+
+func BenchmarkMutexSameReadWrite1(b *testing.B) {
+	benchmarkMutex(b, 1, 1, 32)
+}
+func BenchmarkMutexSameReadWrite2(b *testing.B) {
+	benchmarkMutex(b, 2, 2, 32)
+}
+func BenchmarkMutexSameReadWrite4(b *testing.B) {
+	benchmarkMutex(b, 4, 4, 32)
+}
+func BenchmarkMutex1(b *testing.B) {
+	benchmarkMutex(b, 2, 8, 32)
+}
+func BenchmarkMutex2(b *testing.B) {
+	benchmarkMutex(b, 16, 4, 64)
+}
+func BenchmarkMutex3(b *testing.B) {
+	benchmarkMutex(b, 1, 2, 128)
+}
+func BenchmarkMutex4(b *testing.B) {
+	benchmarkMutex(b, 128, 32, 256)
+}
+func BenchmarkMutex5(b *testing.B) {
+	benchmarkMutex(b, 1024, 2048, 64)
+}
+func BenchmarkMutex6(b *testing.B) {
+	benchmarkMutex(b, 2048, 1024, 512)
+}

vendor/github.com/gorilla/mux/bench_test.go

@@ -0,0 +1,21 @@
+// 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"
+	"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)
+	}
+}

vendor/github.com/gorilla/mux/mux.go

@@ -11,7 +11,7 @@ import (
 	"path"
 	"regexp"
 
-	"github.com/minio/minio/internal/github.com/gorilla/context"
+	"github.com/gorilla/context"
 )
 
 // NewRouter returns a new router instance.

vendor/github.com/gorilla/mux/old_test.go

@@ -0,0 +1,714 @@
+// 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),
+	}
+}
+
+// DefaultRemoteAddr is the default remote address to return in RemoteAddr if
+// an explicit DefaultRemoteAddr isn't set on ResponseRecorder.
+const DefaultRemoteAddr = "1.2.3.4"
+
+// 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 {
+			// Need better messages. :)
+			if matched {
+				t.Errorf("Should match.")
+			} else {
+				t.Errorf("Should not match.")
+			}
+		}
+
+		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.domain.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.domain.com").Subrouter()
+	route := subrouter.NewRoute().Path("/products/").Name("products")
+
+	url := "http://www.domain.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, false, false, false, false)
+		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])
+						}
+					}
+				}
+			}
+		}
+	}
+}