Replace godep with dep

vendor/github.com/kylelemons/godebug/.travis.yml

@@ -0,0 +1,6 @@
+language: go
+
+go:
+  - 1.7
+  - 1.8
+  - tip

vendor/github.com/kylelemons/godebug/README.md

@@ -0,0 +1,64 @@
+Pretty Printing for Go
+======================
+
+[![godebug build status][ciimg]][ci]
+
+Have you ever wanted to get a pretty-printed version of a Go data structure,
+complete with indentation?  I have found this especially useful in unit tests
+and in debugging my code, and thus godebug was born!
+
+[ciimg]: https://travis-ci.org/kylelemons/godebug.svg?branch=master
+[ci]:    https://travis-ci.org/kylelemons/godebug
+
+Quick Examples
+--------------
+
+By default, pretty will write out a very compact representation of a data structure.
+From the [Print example][printex]:
+
+```
+{Name:     "Spaceship Heart of Gold",
+ Crew:     {Arthur Dent:       "Along for the Ride",
+            Ford Prefect:      "A Hoopy Frood",
+            Trillian:          "Human",
+            Zaphod Beeblebrox: "Galactic President"},
+ Androids: 1,
+ Stolen:   true}
+```
+
+It can also produce a much more verbose, one-item-per-line representation suitable for
+[computing diffs][diffex].  See the documentation for more examples and customization.
+
+[printex]: https://godoc.org/github.com/kylelemons/godebug/pretty#example-Print
+[diffex]:  https://godoc.org/github.com/kylelemons/godebug/pretty#example-Compare
+
+Documentation
+-------------
+
+Documentation for this package is available at [godoc.org][doc]:
+
+ * Pretty: [![godoc for godebug/pretty][prettyimg]][prettydoc]
+ * Diff:   [![godoc for godebug/diff][diffimg]][diffdoc]
+
+[doc]:       https://godoc.org/
+[prettyimg]: https://godoc.org/github.com/kylelemons/godebug/pretty?status.png
+[prettydoc]: https://godoc.org/github.com/kylelemons/godebug/pretty
+[diffimg]:   https://godoc.org/github.com/kylelemons/godebug/diff?status.png
+[diffdoc]:   https://godoc.org/github.com/kylelemons/godebug/diff
+
+Installation
+------------
+
+These packages are available via `go get`:
+
+```bash
+$ go get -u github.com/kylelemons/godebug/{pretty,diff}
+```
+
+Other Packages
+--------------
+
+If `godebug/pretty` is not granular enough, I highly recommend
+checking out [go-spew][spew].
+
+[spew]: http://godoc.org/github.com/davecgh/go-spew/spew

vendor/github.com/kylelemons/godebug/diff/diff_test.go

@@ -0,0 +1,166 @@
+// Copyright 2013 Google Inc.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package diff
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestDiff(t *testing.T) {
+	tests := []struct {
+		desc   string
+		A, B   []string
+		chunks []Chunk
+	}{
+		{
+			desc: "nil",
+		},
+		{
+			desc: "empty",
+			A:    []string{},
+			B:    []string{},
+		},
+		{
+			desc: "same",
+			A:    []string{"foo"},
+			B:    []string{"foo"},
+		},
+		{
+			desc: "a empty",
+			A:    []string{},
+		},
+		{
+			desc: "b empty",
+			B:    []string{},
+		},
+		{
+			desc: "b nil",
+			A:    []string{"foo"},
+			chunks: []Chunk{
+				0: {Deleted: []string{"foo"}},
+			},
+		},
+		{
+			desc: "a nil",
+			B:    []string{"foo"},
+			chunks: []Chunk{
+				0: {Added: []string{"foo"}},
+			},
+		},
+		{
+			desc: "start with change",
+			A:    []string{"a", "b", "c"},
+			B:    []string{"A", "b", "c"},
+			chunks: []Chunk{
+				0: {Deleted: []string{"a"}},
+				1: {Added: []string{"A"}, Equal: []string{"b", "c"}},
+			},
+		},
+		{
+			desc: "constitution",
+			A: []string{
+				"We the People of the United States, in Order to form a more perfect Union,",
+				"establish Justice, insure domestic Tranquility, provide for the common defence,",
+				"and secure the Blessings of Liberty to ourselves",
+				"and our Posterity, do ordain and establish this Constitution for the United",
+				"States of America.",
+			},
+			B: []string{
+				"We the People of the United States, in Order to form a more perfect Union,",
+				"establish Justice, insure domestic Tranquility, provide for the common defence,",
+				"promote the general Welfare, and secure the Blessings of Liberty to ourselves",
+				"and our Posterity, do ordain and establish this Constitution for the United",
+				"States of America.",
+			},
+			chunks: []Chunk{
+				0: {
+					Equal: []string{
+						"We the People of the United States, in Order to form a more perfect Union,",
+						"establish Justice, insure domestic Tranquility, provide for the common defence,",
+					},
+				},
+				1: {
+					Deleted: []string{
+						"and secure the Blessings of Liberty to ourselves",
+					},
+				},
+				2: {
+					Added: []string{
+						"promote the general Welfare, and secure the Blessings of Liberty to ourselves",
+					},
+					Equal: []string{
+						"and our Posterity, do ordain and establish this Constitution for the United",
+						"States of America.",
+					},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.desc, func(t *testing.T) {
+			got := DiffChunks(test.A, test.B)
+			if got, want := len(got), len(test.chunks); got != want {
+				t.Errorf("edit distance = %v, want %v", got-1, want-1)
+				return
+			}
+			for i := range got {
+				got, want := got[i], test.chunks[i]
+				if got, want := got.Added, want.Added; !reflect.DeepEqual(got, want) {
+					t.Errorf("chunks[%d]: Added = %v, want %v", i, got, want)
+				}
+				if got, want := got.Deleted, want.Deleted; !reflect.DeepEqual(got, want) {
+					t.Errorf("chunks[%d]: Deleted = %v, want %v", i, got, want)
+				}
+				if got, want := got.Equal, want.Equal; !reflect.DeepEqual(got, want) {
+					t.Errorf("chunks[%d]: Equal = %v, want %v", i, got, want)
+				}
+			}
+		})
+	}
+}
+
+func ExampleDiff() {
+	constitution := strings.TrimSpace(`
+We the People of the United States, in Order to form a more perfect Union,
+establish Justice, insure domestic Tranquility, provide for the common defence,
+promote the general Welfare, and secure the Blessings of Liberty to ourselves
+and our Posterity, do ordain and establish this Constitution for the United
+States of America.
+`)
+
+	got := strings.TrimSpace(`
+:wq
+We the People of the United States, in Order to form a more perfect Union,
+establish Justice, insure domestic Tranquility, provide for the common defence,
+and secure the Blessings of Liberty to ourselves
+and our Posterity, do ordain and establish this Constitution for the United
+States of America.
+`)
+
+	fmt.Println(Diff(got, constitution))
+
+	// Output:
+	// -:wq
+	//  We the People of the United States, in Order to form a more perfect Union,
+	//  establish Justice, insure domestic Tranquility, provide for the common defence,
+	// -and secure the Blessings of Liberty to ourselves
+	// +promote the general Welfare, and secure the Blessings of Liberty to ourselves
+	//  and our Posterity, do ordain and establish this Constitution for the United
+	//  States of America.
+}

vendor/github.com/kylelemons/godebug/pretty/examples_test.go

@@ -0,0 +1,310 @@
+// Copyright 2013 Google Inc.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pretty_test
+
+import (
+	"fmt"
+	"net"
+	"reflect"
+
+	"github.com/kylelemons/godebug/pretty"
+)
+
+func ExampleConfig_Sprint() {
+	type Pair [2]int
+	type Map struct {
+		Name      string
+		Players   map[string]Pair
+		Obstacles map[Pair]string
+	}
+
+	m := Map{
+		Name: "Rock Creek",
+		Players: map[string]Pair{
+			"player1": {1, 3},
+			"player2": {0, -1},
+		},
+		Obstacles: map[Pair]string{
+			Pair{0, 0}: "rock",
+			Pair{2, 1}: "pond",
+			Pair{1, 1}: "stream",
+			Pair{0, 1}: "stream",
+		},
+	}
+
+	// Specific output formats
+	compact := &pretty.Config{
+		Compact: true,
+	}
+	diffable := &pretty.Config{
+		Diffable: true,
+	}
+
+	// Print out a summary
+	fmt.Printf("Players: %s\n", compact.Sprint(m.Players))
+
+	// Print diffable output
+	fmt.Printf("Map State:\n%s", diffable.Sprint(m))
+
+	// Output:
+	// Players: {player1:[1,3],player2:[0,-1]}
+	// Map State:
+	// {
+	//  Name: "Rock Creek",
+	//  Players: {
+	//   player1: [
+	//    1,
+	//    3,
+	//   ],
+	//   player2: [
+	//    0,
+	//    -1,
+	//   ],
+	//  },
+	//  Obstacles: {
+	//   [0,0]: "rock",
+	//   [0,1]: "stream",
+	//   [1,1]: "stream",
+	//   [2,1]: "pond",
+	//  },
+	// }
+}
+
+func ExampleConfig_fmtFormatter() {
+	pretty.DefaultFormatter[reflect.TypeOf(&net.IPNet{})] = fmt.Sprint
+	pretty.DefaultFormatter[reflect.TypeOf(net.HardwareAddr{})] = fmt.Sprint
+	pretty.Print(&net.IPNet{
+		IP:   net.IPv4(192, 168, 1, 100),
+		Mask: net.CIDRMask(24, 32),
+	})
+	pretty.Print(net.HardwareAddr{1, 2, 3, 4, 5, 6})
+
+	// Output:
+	// 192.168.1.100/24
+	// 01:02:03:04:05:06
+}
+
+func ExampleConfig_customFormatter() {
+	pretty.DefaultFormatter[reflect.TypeOf(&net.IPNet{})] = func(n *net.IPNet) string {
+		return fmt.Sprintf("CIDR=%s", n)
+	}
+	pretty.Print(&net.IPNet{
+		IP:   net.IPv4(192, 168, 1, 100),
+		Mask: net.CIDRMask(24, 32),
+	})
+
+	// Output:
+	// CIDR=192.168.1.100/24
+}
+
+func ExamplePrint() {
+	type ShipManifest struct {
+		Name     string
+		Crew     map[string]string
+		Androids int
+		Stolen   bool
+	}
+
+	manifest := &ShipManifest{
+		Name: "Spaceship Heart of Gold",
+		Crew: map[string]string{
+			"Zaphod Beeblebrox": "Galactic President",
+			"Trillian":          "Human",
+			"Ford Prefect":      "A Hoopy Frood",
+			"Arthur Dent":       "Along for the Ride",
+		},
+		Androids: 1,
+		Stolen:   true,
+	}
+
+	pretty.Print(manifest)
+
+	// Output:
+	// {Name:     "Spaceship Heart of Gold",
+	//  Crew:     {Arthur Dent:       "Along for the Ride",
+	//             Ford Prefect:      "A Hoopy Frood",
+	//             Trillian:          "Human",
+	//             Zaphod Beeblebrox: "Galactic President"},
+	//  Androids: 1,
+	//  Stolen:   true}
+}
+
+var t = struct {
+	Errorf func(string, ...interface{})
+}{
+	Errorf: func(format string, args ...interface{}) {
+		fmt.Println(fmt.Sprintf(format, args...) + "\n")
+	},
+}
+
+func ExampleCompare_testing() {
+	// Code under test:
+
+	type ShipManifest struct {
+		Name     string
+		Crew     map[string]string
+		Androids int
+		Stolen   bool
+	}
+
+	// AddCrew tries to add the given crewmember to the manifest.
+	AddCrew := func(m *ShipManifest, name, title string) {
+		if m.Crew == nil {
+			m.Crew = make(map[string]string)
+		}
+		m.Crew[title] = name
+	}
+
+	// Test function:
+	tests := []struct {
+		desc        string
+		before      *ShipManifest
+		name, title string
+		after       *ShipManifest
+	}{
+		{
+			desc:   "add first",
+			before: &ShipManifest{},
+			name:   "Zaphod Beeblebrox",
+			title:  "Galactic President",
+			after: &ShipManifest{
+				Crew: map[string]string{
+					"Zaphod Beeblebrox": "Galactic President",
+				},
+			},
+		},
+		{
+			desc: "add another",
+			before: &ShipManifest{
+				Crew: map[string]string{
+					"Zaphod Beeblebrox": "Galactic President",
+				},
+			},
+			name:  "Trillian",
+			title: "Human",
+			after: &ShipManifest{
+				Crew: map[string]string{
+					"Zaphod Beeblebrox": "Galactic President",
+					"Trillian":          "Human",
+				},
+			},
+		},
+		{
+			desc: "overwrite",
+			before: &ShipManifest{
+				Crew: map[string]string{
+					"Zaphod Beeblebrox": "Galactic President",
+				},
+			},
+			name:  "Zaphod Beeblebrox",
+			title: "Just this guy, you know?",
+			after: &ShipManifest{
+				Crew: map[string]string{
+					"Zaphod Beeblebrox": "Just this guy, you know?",
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		AddCrew(test.before, test.name, test.title)
+		if diff := pretty.Compare(test.before, test.after); diff != "" {
+			t.Errorf("%s: post-AddCrew diff: (-got +want)\n%s", test.desc, diff)
+		}
+	}
+
+	// Output:
+	// add first: post-AddCrew diff: (-got +want)
+	//  {
+	//   Name: "",
+	//   Crew: {
+	// -  Galactic President: "Zaphod Beeblebrox",
+	// +  Zaphod Beeblebrox: "Galactic President",
+	//   },
+	//   Androids: 0,
+	//   Stolen: false,
+	//  }
+	//
+	// add another: post-AddCrew diff: (-got +want)
+	//  {
+	//   Name: "",
+	//   Crew: {
+	// -  Human: "Trillian",
+	// +  Trillian: "Human",
+	//    Zaphod Beeblebrox: "Galactic President",
+	//   },
+	//   Androids: 0,
+	//   Stolen: false,
+	//  }
+	//
+	// overwrite: post-AddCrew diff: (-got +want)
+	//  {
+	//   Name: "",
+	//   Crew: {
+	// -  Just this guy, you know?: "Zaphod Beeblebrox",
+	// -  Zaphod Beeblebrox: "Galactic President",
+	// +  Zaphod Beeblebrox: "Just this guy, you know?",
+	//   },
+	//   Androids: 0,
+	//   Stolen: false,
+	//  }
+}
+
+func ExampleCompare_debugging() {
+	type ShipManifest struct {
+		Name     string
+		Crew     map[string]string
+		Androids int
+		Stolen   bool
+	}
+
+	reported := &ShipManifest{
+		Name: "Spaceship Heart of Gold",
+		Crew: map[string]string{
+			"Zaphod Beeblebrox": "Galactic President",
+			"Trillian":          "Human",
+			"Ford Prefect":      "A Hoopy Frood",
+			"Arthur Dent":       "Along for the Ride",
+		},
+		Androids: 1,
+		Stolen:   true,
+	}
+
+	expected := &ShipManifest{
+		Name: "Spaceship Heart of Gold",
+		Crew: map[string]string{
+			"Trillian":      "Human",
+			"Rowan Artosok": "Captain",
+		},
+		Androids: 1,
+		Stolen:   false,
+	}
+
+	fmt.Println(pretty.Compare(reported, expected))
+	// Output:
+	//  {
+	//   Name: "Spaceship Heart of Gold",
+	//   Crew: {
+	// -  Arthur Dent: "Along for the Ride",
+	// -  Ford Prefect: "A Hoopy Frood",
+	// +  Rowan Artosok: "Captain",
+	//    Trillian: "Human",
+	// -  Zaphod Beeblebrox: "Galactic President",
+	//   },
+	//   Androids: 1,
+	// - Stolen: true,
+	// + Stolen: false,
+	//  }
+}

vendor/github.com/kylelemons/godebug/pretty/public.go

@@ -134,19 +134,20 @@ func (cfg *Config) Fprint(w io.Writer, vals ...interface{}) (n int64, err error)
 }
 
 // Compare returns a string containing a line-by-line unified diff of the
-// values in got and want, using the CompareConfig.
+// values in a and b, using the CompareConfig.
 //
-// Each line in the output is prefixed with '+', '-', or ' ' to indicate if it
-// should be added to, removed from, or is correct for the "got" value with
-// respect to the "want" value.
-func Compare(got, want interface{}) string {
-	return CompareConfig.Compare(got, want)
+// Each line in the output is prefixed with '+', '-', or ' ' to indicate which
+// side it's from. Lines from the a side are marked with '-', lines from the
+// b side are marked with '+' and lines that are the same on both sides are
+// marked with ' '.
+func Compare(a, b interface{}) string {
+	return CompareConfig.Compare(a, b)
 }
 
 // Compare returns a string containing a line-by-line unified diff of the
 // values in got and want according to the cfg.
-func (cfg *Config) Compare(got, want interface{}) string {
+func (cfg *Config) Compare(a, b interface{}) string {
 	diffCfg := *cfg
 	diffCfg.Diffable = true
-	return diff.Diff(cfg.Sprint(got), cfg.Sprint(want))
+	return diff.Diff(cfg.Sprint(a), cfg.Sprint(b))
 }

vendor/github.com/kylelemons/godebug/pretty/public_test.go

@@ -0,0 +1,128 @@
+// Copyright 2013 Google Inc.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pretty
+
+import (
+	"testing"
+)
+
+func TestDiff(t *testing.T) {
+	type example struct {
+		Name    string
+		Age     int
+		Friends []string
+	}
+
+	tests := []struct {
+		desc      string
+		got, want interface{}
+		diff      string
+	}{
+		{
+			desc: "basic struct",
+			got: example{
+				Name: "Zaphd",
+				Age:  42,
+				Friends: []string{
+					"Ford Prefect",
+					"Trillian",
+					"Marvin",
+				},
+			},
+			want: example{
+				Name: "Zaphod",
+				Age:  42,
+				Friends: []string{
+					"Ford Prefect",
+					"Trillian",
+				},
+			},
+			diff: ` {
+- Name: "Zaphd",
++ Name: "Zaphod",
+  Age: 42,
+  Friends: [
+   "Ford Prefect",
+   "Trillian",
+-  "Marvin",
+  ],
+ }`,
+		},
+	}
+
+	for _, test := range tests {
+		if got, want := Compare(test.got, test.want), test.diff; got != want {
+			t.Errorf("%s:", test.desc)
+			t.Errorf("  got:  %q", got)
+			t.Errorf("  want: %q", want)
+		}
+	}
+}
+
+func TestSkipZeroFields(t *testing.T) {
+	type example struct {
+		Name    string
+		Species string
+		Age     int
+		Friends []string
+	}
+
+	tests := []struct {
+		desc      string
+		got, want interface{}
+		diff      string
+	}{
+		{
+			desc: "basic struct",
+			got: example{
+				Name:    "Zaphd",
+				Species: "Betelgeusian",
+				Age:     42,
+			},
+			want: example{
+				Name:    "Zaphod",
+				Species: "Betelgeusian",
+				Age:     42,
+				Friends: []string{
+					"Ford Prefect",
+					"Trillian",
+					"",
+				},
+			},
+			diff: ` {
+- Name: "Zaphd",
++ Name: "Zaphod",
+  Species: "Betelgeusian",
+  Age: 42,
++ Friends: [
++  "Ford Prefect",
++  "Trillian",
++  "",
++ ],
+ }`,
+		},
+	}
+
+	cfg := *CompareConfig
+	cfg.SkipZeroFields = true
+
+	for _, test := range tests {
+		if got, want := cfg.Compare(test.got, test.want), test.diff; got != want {
+			t.Errorf("%s:", test.desc)
+			t.Errorf("  got:  %q", got)
+			t.Errorf("  want: %q", want)
+		}
+	}
+}

vendor/github.com/kylelemons/godebug/pretty/reflect_test.go

@@ -0,0 +1,236 @@
+// Copyright 2013 Google Inc.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pretty
+
+import (
+	"fmt"
+	"net"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestVal2nodeDefault(t *testing.T) {
+	err := fmt.Errorf("err")
+	var errNil error
+
+	tests := []struct {
+		desc string
+		raw  interface{}
+		want node
+	}{
+		{
+			desc: "nil",
+			raw:  nil,
+			want: rawVal("nil"),
+		},
+		{
+			desc: "nil ptr",
+			raw:  (*int)(nil),
+			want: rawVal("nil"),
+		},
+		{
+			desc: "nil slice",
+			raw:  []string(nil),
+			want: list{},
+		},
+		{
+			desc: "nil map",
+			raw:  map[string]string(nil),
+			want: keyvals{},
+		},
+		{
+			desc: "string",
+			raw:  "zaphod",
+			want: stringVal("zaphod"),
+		},
+		{
+			desc: "slice",
+			raw:  []string{"a", "b"},
+			want: list{stringVal("a"), stringVal("b")},
+		},
+		{
+			desc: "map",
+			raw: map[string]string{
+				"zaphod": "beeblebrox",
+				"ford":   "prefect",
+			},
+			want: keyvals{
+				{"ford", stringVal("prefect")},
+				{"zaphod", stringVal("beeblebrox")},
+			},
+		},
+		{
+			desc: "map of [2]int",
+			raw: map[[2]int]string{
+				[2]int{-1, 2}: "school",
+				[2]int{0, 0}:  "origin",
+				[2]int{1, 3}:  "home",
+			},
+			want: keyvals{
+				{"[-1,2]", stringVal("school")},
+				{"[0,0]", stringVal("origin")},
+				{"[1,3]", stringVal("home")},
+			},
+		},
+		{
+			desc: "struct",
+			raw:  struct{ Zaphod, Ford string }{"beeblebrox", "prefect"},
+			want: keyvals{
+				{"Zaphod", stringVal("beeblebrox")},
+				{"Ford", stringVal("prefect")},
+			},
+		},
+		{
+			desc: "int",
+			raw:  3,
+			want: rawVal("3"),
+		},
+		{
+			desc: "time.Time",
+			raw:  time.Unix(1257894000, 0).UTC(),
+			want: rawVal("2009-11-10 23:00:00 +0000 UTC"),
+		},
+		{
+			desc: "net.IP",
+			raw:  net.IPv4(127, 0, 0, 1),
+			want: rawVal("127.0.0.1"),
+		},
+		{
+			desc: "error",
+			raw:  &err,
+			want: rawVal("err"),
+		},
+		{
+			desc: "nil error",
+			raw:  &errNil,
+			want: rawVal("<nil>"),
+		},
+	}
+
+	for _, test := range tests {
+		if got, want := DefaultConfig.val2node(reflect.ValueOf(test.raw)), test.want; !reflect.DeepEqual(got, want) {
+			t.Errorf("%s: got %#v, want %#v", test.desc, got, want)
+		}
+	}
+}
+
+func TestVal2node(t *testing.T) {
+	tests := []struct {
+		desc string
+		raw  interface{}
+		cfg  *Config
+		want node
+	}{
+		{
+			desc: "struct default",
+			raw:  struct{ Zaphod, Ford, foo string }{"beeblebrox", "prefect", "BAD"},
+			cfg:  DefaultConfig,
+			want: keyvals{
+				{"Zaphod", stringVal("beeblebrox")},
+				{"Ford", stringVal("prefect")},
+			},
+		},
+		{
+			desc: "struct w/ IncludeUnexported",
+			raw:  struct{ Zaphod, Ford, foo string }{"beeblebrox", "prefect", "GOOD"},
+			cfg: &Config{
+				IncludeUnexported: true,
+			},
+			want: keyvals{
+				{"Zaphod", stringVal("beeblebrox")},
+				{"Ford", stringVal("prefect")},
+				{"foo", stringVal("GOOD")},
+			},
+		},
+		{
+			desc: "time default",
+			raw:  struct{ Date time.Time }{time.Unix(1234567890, 0).UTC()},
+			cfg:  DefaultConfig,
+			want: keyvals{
+				{"Date", rawVal("2009-02-13 23:31:30 +0000 UTC")},
+			},
+		},
+		{
+			desc: "time w/ nil Formatter",
+			raw:  struct{ Date time.Time }{time.Unix(1234567890, 0).UTC()},
+			cfg: &Config{
+				PrintStringers: true,
+				Formatter: map[reflect.Type]interface{}{
+					reflect.TypeOf(time.Time{}): nil,
+				},
+			},
+			want: keyvals{
+				{"Date", keyvals{}},
+			},
+		},
+		{
+			desc: "time w/ PrintTextMarshalers",
+			raw:  struct{ Date time.Time }{time.Unix(1234567890, 0).UTC()},
+			cfg: &Config{
+				PrintTextMarshalers: true,
+			},
+			want: keyvals{
+				{"Date", stringVal("2009-02-13T23:31:30Z")},
+			},
+		},
+		{
+			desc: "time w/ PrintStringers",
+			raw:  struct{ Date time.Time }{time.Unix(1234567890, 0).UTC()},
+			cfg: &Config{
+				PrintStringers: true,
+			},
+			want: keyvals{
+				{"Date", stringVal("2009-02-13 23:31:30 +0000 UTC")},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		if got, want := test.cfg.val2node(reflect.ValueOf(test.raw)), test.want; !reflect.DeepEqual(got, want) {
+			t.Errorf("%s: got %#v, want %#v", test.desc, got, want)
+		}
+	}
+}
+
+func BenchmarkVal2node(b *testing.B) {
+	benchmarks := []struct {
+		desc string
+		cfg  *Config
+		raw  interface{}
+	}{
+		{
+			desc: "struct",
+			cfg:  DefaultConfig,
+			raw:  struct{ Zaphod, Ford string }{"beeblebrox", "prefect"}},
+		{
+			desc: "map",
+			cfg:  DefaultConfig,
+			raw: map[[2]int]string{
+				[2]int{-1, 2}: "school",
+				[2]int{0, 0}:  "origin",
+				[2]int{1, 3}:  "home",
+			},
+		},
+	}
+
+	for _, bench := range benchmarks {
+		b.Run(bench.desc, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				bench.cfg.val2node(reflect.ValueOf(bench.raw))
+			}
+		})
+	}
+}

vendor/github.com/kylelemons/godebug/pretty/structure_test.go

@@ -0,0 +1,316 @@
+// Copyright 2013 Google Inc.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pretty
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestWriteTo(t *testing.T) {
+	tests := []struct {
+		desc string
+		node node
+
+		// All strings have a leading newline trimmed before comparison:
+		normal   string
+		diffable string
+	}{
+		{
+			desc:     "string",
+			node:     stringVal("zaphod"),
+			normal:   `"zaphod"`,
+			diffable: `"zaphod"`,
+		},
+		{
+			desc:     "raw",
+			node:     rawVal("42"),
+			normal:   `42`,
+			diffable: `42`,
+		},
+		{
+			desc: "keyvals",
+			node: keyvals{
+				{"name", stringVal("zaphod")},
+				{"age", rawVal("42")},
+			},
+			normal: `
+{name: "zaphod",
+ age:  42}`,
+			diffable: `
+{
+ name: "zaphod",
+ age: 42,
+}`,
+		},
+		{
+			desc: "empty list",
+			node: list{},
+			normal: `
+[]`,
+			diffable: `
+[
+]`,
+		},
+		{
+			desc: "empty nested list",
+			node: list{list{}},
+			normal: `
+[[]]`,
+			diffable: `
+[
+ [
+ ],
+]`,
+		},
+		{
+			desc: "list",
+			node: list{
+				stringVal("zaphod"),
+				rawVal("42"),
+			},
+			normal: `
+["zaphod",
+ 42]`,
+			diffable: `
+[
+ "zaphod",
+ 42,
+]`,
+		},
+		{
+			desc: "empty keyvals",
+			node: keyvals{},
+			normal: `
+{}`,
+			diffable: `
+{
+}`,
+		},
+		{
+			desc: "empty nested keyvals",
+			node: keyvals{{"k", keyvals{}}},
+			normal: `
+{k: {}}`,
+			diffable: `
+{
+ k: {
+ },
+}`,
+		},
+		{
+			desc: "nested",
+			node: list{
+				stringVal("first"),
+				list{rawVal("1"), rawVal("2"), rawVal("3")},
+				keyvals{
+					{"trillian", keyvals{
+						{"race", stringVal("human")},
+						{"age", rawVal("36")},
+					}},
+					{"zaphod", keyvals{
+						{"occupation", stringVal("president of the galaxy")},
+						{"features", stringVal("two heads")},
+					}},
+				},
+				keyvals{},
+			},
+			normal: `
+["first",
+ [1,
+  2,
+  3],
+ {trillian: {race: "human",
+             age:  36},
+  zaphod:   {occupation: "president of the galaxy",
+             features:   "two heads"}},
+ {}]`,
+			diffable: `
+[
+ "first",
+ [
+  1,
+  2,
+  3,
+ ],
+ {
+  trillian: {
+   race: "human",
+   age: 36,
+  },
+  zaphod: {
+   occupation: "president of the galaxy",
+   features: "two heads",
+  },
+ },
+ {
+ },
+]`,
+		},
+	}
+
+	for _, test := range tests {
+		// For readability, we have a newline that won't be there in the output
+		test.normal = strings.TrimPrefix(test.normal, "\n")
+		test.diffable = strings.TrimPrefix(test.diffable, "\n")
+
+		buf := new(bytes.Buffer)
+		test.node.WriteTo(buf, "", &Config{})
+		if got, want := buf.String(), test.normal; got != want {
+			t.Errorf("%s: normal rendendered incorrectly\ngot:\n%s\nwant:\n%s", test.desc, got, want)
+		}
+		buf.Reset()
+		test.node.WriteTo(buf, "", &Config{Diffable: true})
+		if got, want := buf.String(), test.diffable; got != want {
+			t.Errorf("%s: diffable rendendered incorrectly\ngot:\n%s\nwant:\n%s", test.desc, got, want)
+		}
+	}
+}
+
+func TestCompactString(t *testing.T) {
+	tests := []struct {
+		node
+		compact string
+	}{
+		{
+			stringVal("abc"),
+			"abc",
+		},
+		{
+			rawVal("2"),
+			"2",
+		},
+		{
+			list{
+				rawVal("2"),
+				rawVal("3"),
+			},
+			"[2,3]",
+		},
+		{
+			keyvals{
+				{"name", stringVal("zaphod")},
+				{"age", rawVal("42")},
+			},
+			`{name:"zaphod",age:42}`,
+		},
+		{
+			list{
+				list{
+					rawVal("0"),
+					rawVal("1"),
+					rawVal("2"),
+					rawVal("3"),
+				},
+				list{
+					rawVal("1"),
+					rawVal("2"),
+					rawVal("3"),
+					rawVal("0"),
+				},
+				list{
+					rawVal("2"),
+					rawVal("3"),
+					rawVal("0"),
+					rawVal("1"),
+				},
+			},
+			`[[0,1,2,3],[1,2,3,0],[2,3,0,1]]`,
+		},
+	}
+
+	for _, test := range tests {
+		if got, want := compactString(test.node), test.compact; got != want {
+			t.Errorf("%#v: compact = %q, want %q", test.node, got, want)
+		}
+	}
+}
+
+func TestShortList(t *testing.T) {
+	cfg := &Config{
+		ShortList: 16,
+	}
+
+	tests := []struct {
+		node
+		want string
+	}{
+		{
+			list{
+				list{
+					rawVal("0"),
+					rawVal("1"),
+					rawVal("2"),
+					rawVal("3"),
+				},
+				list{
+					rawVal("1"),
+					rawVal("2"),
+					rawVal("3"),
+					rawVal("0"),
+				},
+				list{
+					rawVal("2"),
+					rawVal("3"),
+					rawVal("0"),
+					rawVal("1"),
+				},
+			},
+			`[[0,1,2,3],
+ [1,2,3,0],
+ [2,3,0,1]]`,
+		},
+	}
+
+	for _, test := range tests {
+		buf := new(bytes.Buffer)
+		test.node.WriteTo(buf, "", cfg)
+		if got, want := buf.String(), test.want; got != want {
+			t.Errorf("%#v: got:\n%s\nwant:\n%s", test.node, got, want)
+		}
+	}
+}
+
+var benchNode = keyvals{
+	{"list", list{
+		rawVal("0"),
+		rawVal("1"),
+		rawVal("2"),
+		rawVal("3"),
+	}},
+	{"keyvals", keyvals{
+		{"a", stringVal("b")},
+		{"c", stringVal("e")},
+		{"d", stringVal("f")},
+	}},
+}
+
+func benchOpts(b *testing.B, cfg *Config) {
+	buf := new(bytes.Buffer)
+	benchNode.WriteTo(buf, "", cfg)
+	b.SetBytes(int64(buf.Len()))
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		buf.Reset()
+		benchNode.WriteTo(buf, "", cfg)
+	}
+}
+
+func BenchmarkWriteDefault(b *testing.B)   { benchOpts(b, DefaultConfig) }
+func BenchmarkWriteShortList(b *testing.B) { benchOpts(b, &Config{ShortList: 16}) }
+func BenchmarkWriteCompact(b *testing.B)   { benchOpts(b, &Config{Compact: true}) }
+func BenchmarkWriteDiffable(b *testing.B)  { benchOpts(b, &Config{Diffable: true}) }