Depenancy upgrades and movign to dep. (#8630)

7 files changed, 12 insertions, 2840 deletions

diff --git a/vendor/github.com/mitchellh/go-homedir/homedir_test.go b/vendor/github.com/mitchellh/go-homedir/homedir_test.go
deleted file mode 100644
index e4054e72a..000000000
--- a/vendor/github.com/mitchellh/go-homedir/homedir_test.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package homedir
-
-import (
-	"os"
-	"os/user"
-	"path/filepath"
-	"testing"
-)
-
-func patchEnv(key, value string) func() {
-	bck := os.Getenv(key)
-	deferFunc := func() {
-		os.Setenv(key, bck)
-	}
-
-	os.Setenv(key, value)
-	return deferFunc
-}
-
-func BenchmarkDir(b *testing.B) {
-	// We do this for any "warmups"
-	for i := 0; i < 10; i++ {
-		Dir()
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Dir()
-	}
-}
-
-func TestDir(t *testing.T) {
-	u, err := user.Current()
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	dir, err := Dir()
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if u.HomeDir != dir {
-		t.Fatalf("%#v != %#v", u.HomeDir, dir)
-	}
-}
-
-func TestExpand(t *testing.T) {
-	u, err := user.Current()
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	cases := []struct {
-		Input  string
-		Output string
-		Err    bool
-	}{
-		{
-			"/foo",
-			"/foo",
-			false,
-		},
-
-		{
-			"~/foo",
-			filepath.Join(u.HomeDir, "foo"),
-			false,
-		},
-
-		{
-			"",
-			"",
-			false,
-		},
-
-		{
-			"~",
-			u.HomeDir,
-			false,
-		},
-
-		{
-			"~foo/foo",
-			"",
-			true,
-		},
-	}
-
-	for _, tc := range cases {
-		actual, err := Expand(tc.Input)
-		if (err != nil) != tc.Err {
-			t.Fatalf("Input: %#v\n\nErr: %s", tc.Input, err)
-		}
-
-		if actual != tc.Output {
-			t.Fatalf("Input: %#v\n\nOutput: %#v", tc.Input, actual)
-		}
-	}
-
-	DisableCache = true
-	defer func() { DisableCache = false }()
-	defer patchEnv("HOME", "/custom/path/")()
-	expected := filepath.Join("/", "custom", "path", "foo/bar")
-	actual, err := Expand("~/foo/bar")
-
-	if err != nil {
-		t.Errorf("No error is expected, got: %v", err)
-	} else if actual != expected {
-		t.Errorf("Expected: %v; actual: %v", expected, actual)
-	}
-}
diff --git a/vendor/github.com/mitchellh/mapstructure/decode_hooks_test.go b/vendor/github.com/mitchellh/mapstructure/decode_hooks_test.go
deleted file mode 100644
index a81728e74..000000000
--- a/vendor/github.com/mitchellh/mapstructure/decode_hooks_test.go
+++ /dev/null
@@ -1,259 +0,0 @@
-package mapstructure
-
-import (
-	"errors"
-	"reflect"
-	"testing"
-	"time"
-)
-
-func TestComposeDecodeHookFunc(t *testing.T) {
-	f1 := func(
-		f reflect.Kind,
-		t reflect.Kind,
-		data interface{}) (interface{}, error) {
-		return data.(string) + "foo", nil
-	}
-
-	f2 := func(
-		f reflect.Kind,
-		t reflect.Kind,
-		data interface{}) (interface{}, error) {
-		return data.(string) + "bar", nil
-	}
-
-	f := ComposeDecodeHookFunc(f1, f2)
-
-	result, err := DecodeHookExec(
-		f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), "")
-	if err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-	if result.(string) != "foobar" {
-		t.Fatalf("bad: %#v", result)
-	}
-}
-
-func TestComposeDecodeHookFunc_err(t *testing.T) {
-	f1 := func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error) {
-		return nil, errors.New("foo")
-	}
-
-	f2 := func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error) {
-		panic("NOPE")
-	}
-
-	f := ComposeDecodeHookFunc(f1, f2)
-
-	_, err := DecodeHookExec(
-		f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), 42)
-	if err.Error() != "foo" {
-		t.Fatalf("bad: %s", err)
-	}
-}
-
-func TestComposeDecodeHookFunc_kinds(t *testing.T) {
-	var f2From reflect.Kind
-
-	f1 := func(
-		f reflect.Kind,
-		t reflect.Kind,
-		data interface{}) (interface{}, error) {
-		return int(42), nil
-	}
-
-	f2 := func(
-		f reflect.Kind,
-		t reflect.Kind,
-		data interface{}) (interface{}, error) {
-		f2From = f
-		return data, nil
-	}
-
-	f := ComposeDecodeHookFunc(f1, f2)
-
-	_, err := DecodeHookExec(
-		f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), "")
-	if err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-	if f2From != reflect.Int {
-		t.Fatalf("bad: %#v", f2From)
-	}
-}
-
-func TestStringToSliceHookFunc(t *testing.T) {
-	f := StringToSliceHookFunc(",")
-
-	strType := reflect.TypeOf("")
-	sliceType := reflect.TypeOf([]byte(""))
-	cases := []struct {
-		f, t   reflect.Type
-		data   interface{}
-		result interface{}
-		err    bool
-	}{
-		{sliceType, sliceType, 42, 42, false},
-		{strType, strType, 42, 42, false},
-		{
-			strType,
-			sliceType,
-			"foo,bar,baz",
-			[]string{"foo", "bar", "baz"},
-			false,
-		},
-		{
-			strType,
-			sliceType,
-			"",
-			[]string{},
-			false,
-		},
-	}
-
-	for i, tc := range cases {
-		actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
-		if tc.err != (err != nil) {
-			t.Fatalf("case %d: expected err %#v", i, tc.err)
-		}
-		if !reflect.DeepEqual(actual, tc.result) {
-			t.Fatalf(
-				"case %d: expected %#v, got %#v",
-				i, tc.result, actual)
-		}
-	}
-}
-
-func TestStringToTimeDurationHookFunc(t *testing.T) {
-	f := StringToTimeDurationHookFunc()
-
-	strType := reflect.TypeOf("")
-	timeType := reflect.TypeOf(time.Duration(5))
-	cases := []struct {
-		f, t   reflect.Type
-		data   interface{}
-		result interface{}
-		err    bool
-	}{
-		{strType, timeType, "5s", 5 * time.Second, false},
-		{strType, timeType, "5", time.Duration(0), true},
-		{strType, strType, "5", "5", false},
-	}
-
-	for i, tc := range cases {
-		actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
-		if tc.err != (err != nil) {
-			t.Fatalf("case %d: expected err %#v", i, tc.err)
-		}
-		if !reflect.DeepEqual(actual, tc.result) {
-			t.Fatalf(
-				"case %d: expected %#v, got %#v",
-				i, tc.result, actual)
-		}
-	}
-}
-
-func TestStringToTimeHookFunc(t *testing.T) {
-	strType := reflect.TypeOf("")
-	timeType := reflect.TypeOf(time.Time{})
-	cases := []struct {
-		f, t   reflect.Type
-		layout string
-		data   interface{}
-		result interface{}
-		err    bool
-	}{
-		{strType, timeType, time.RFC3339, "2006-01-02T15:04:05Z",
-			time.Date(2006, 1, 2, 15, 4, 5, 0, time.UTC), false},
-		{strType, timeType, time.RFC3339, "5", time.Time{}, true},
-		{strType, strType, time.RFC3339, "5", "5", false},
-	}
-
-	for i, tc := range cases {
-		f := StringToTimeHookFunc(tc.layout)
-		actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
-		if tc.err != (err != nil) {
-			t.Fatalf("case %d: expected err %#v", i, tc.err)
-		}
-		if !reflect.DeepEqual(actual, tc.result) {
-			t.Fatalf(
-				"case %d: expected %#v, got %#v",
-				i, tc.result, actual)
-		}
-	}
-}
-
-func TestWeaklyTypedHook(t *testing.T) {
-	var f DecodeHookFunc = WeaklyTypedHook
-
-	boolType := reflect.TypeOf(true)
-	strType := reflect.TypeOf("")
-	sliceType := reflect.TypeOf([]byte(""))
-	cases := []struct {
-		f, t   reflect.Type
-		data   interface{}
-		result interface{}
-		err    bool
-	}{
-		// TO STRING
-		{
-			boolType,
-			strType,
-			false,
-			"0",
-			false,
-		},
-
-		{
-			boolType,
-			strType,
-			true,
-			"1",
-			false,
-		},
-
-		{
-			reflect.TypeOf(float32(1)),
-			strType,
-			float32(7),
-			"7",
-			false,
-		},
-
-		{
-			reflect.TypeOf(int(1)),
-			strType,
-			int(7),
-			"7",
-			false,
-		},
-
-		{
-			sliceType,
-			strType,
-			[]uint8("foo"),
-			"foo",
-			false,
-		},
-
-		{
-			reflect.TypeOf(uint(1)),
-			strType,
-			uint(7),
-			"7",
-			false,
-		},
-	}
-
-	for i, tc := range cases {
-		actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
-		if tc.err != (err != nil) {
-			t.Fatalf("case %d: expected err %#v", i, tc.err)
-		}
-		if !reflect.DeepEqual(actual, tc.result) {
-			t.Fatalf(
-				"case %d: expected %#v, got %#v",
-				i, tc.result, actual)
-		}
-	}
-}
diff --git a/vendor/github.com/mitchellh/mapstructure/mapstructure.go b/vendor/github.com/mitchellh/mapstructure/mapstructure.go
index 65977b654..aaf12a295 100644
--- a/vendor/github.com/mitchellh/mapstructure/mapstructure.go
+++ b/vendor/github.com/mitchellh/mapstructure/mapstructure.go
@@ -225,7 +225,15 @@ func (d *Decoder) Decode(input interface{}) error {
 // Decodes an unknown data type into a specific reflection value.
 func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) error {
 	if input == nil {
-		// If the input is nil, then we don't set anything.
+		// If the data is nil, then we don't set anything, unless ZeroFields is set
+		// to true.
+		if d.config.ZeroFields {
+			outVal.Set(reflect.Zero(outVal.Type()))
+
+			if d.config.Metadata != nil && name != "" {
+				d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
+			}
+		}
 		return nil
 	}
 
@@ -234,6 +242,9 @@ func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) e
 		// If the input value is invalid, then we just set the value
 		// to be the zero value.
 		outVal.Set(reflect.Zero(outVal.Type()))
+		if d.config.Metadata != nil && name != "" {
+			d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
+		}
 		return nil
 	}
 
diff --git a/vendor/github.com/mitchellh/mapstructure/mapstructure_benchmark_test.go b/vendor/github.com/mitchellh/mapstructure/mapstructure_benchmark_test.go
deleted file mode 100644
index 41d2a41f7..000000000
--- a/vendor/github.com/mitchellh/mapstructure/mapstructure_benchmark_test.go
+++ /dev/null
@@ -1,279 +0,0 @@
-package mapstructure
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-func Benchmark_Decode(b *testing.B) {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-		Extra  map[string]string
-	}
-
-	input := map[string]interface{}{
-		"name":   "Mitchell",
-		"age":    91,
-		"emails": []string{"one", "two", "three"},
-		"extra": map[string]string{
-			"twitter": "mitchellh",
-		},
-	}
-
-	var result Person
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-// decodeViaJSON takes the map data and passes it through encoding/json to convert it into the
-// given Go native structure pointed to by v. v must be a pointer to a struct.
-func decodeViaJSON(data interface{}, v interface{}) error {
-	// Perform the task by simply marshalling the input into JSON,
-	// then unmarshalling it into target native Go struct.
-	b, err := json.Marshal(data)
-	if err != nil {
-		return err
-	}
-	return json.Unmarshal(b, v)
-}
-
-func Benchmark_DecodeViaJSON(b *testing.B) {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-		Extra  map[string]string
-	}
-
-	input := map[string]interface{}{
-		"name":   "Mitchell",
-		"age":    91,
-		"emails": []string{"one", "two", "three"},
-		"extra": map[string]string{
-			"twitter": "mitchellh",
-		},
-	}
-
-	var result Person
-	for i := 0; i < b.N; i++ {
-		decodeViaJSON(input, &result)
-	}
-}
-
-func Benchmark_DecodeBasic(b *testing.B) {
-	input := map[string]interface{}{
-		"vstring": "foo",
-		"vint":    42,
-		"Vuint":   42,
-		"vbool":   true,
-		"Vfloat":  42.42,
-		"vsilent": true,
-		"vdata":   42,
-	}
-
-	var result Basic
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeEmbedded(b *testing.B) {
-	input := map[string]interface{}{
-		"vstring": "foo",
-		"Basic": map[string]interface{}{
-			"vstring": "innerfoo",
-		},
-		"vunique": "bar",
-	}
-
-	var result Embedded
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeTypeConversion(b *testing.B) {
-	input := map[string]interface{}{
-		"IntToFloat":    42,
-		"IntToUint":     42,
-		"IntToBool":     1,
-		"IntToString":   42,
-		"UintToInt":     42,
-		"UintToFloat":   42,
-		"UintToBool":    42,
-		"UintToString":  42,
-		"BoolToInt":     true,
-		"BoolToUint":    true,
-		"BoolToFloat":   true,
-		"BoolToString":  true,
-		"FloatToInt":    42.42,
-		"FloatToUint":   42.42,
-		"FloatToBool":   42.42,
-		"FloatToString": 42.42,
-		"StringToInt":   "42",
-		"StringToUint":  "42",
-		"StringToBool":  "1",
-		"StringToFloat": "42.42",
-		"SliceToMap":    []interface{}{},
-		"MapToSlice":    map[string]interface{}{},
-	}
-
-	var resultStrict TypeConversionResult
-	for i := 0; i < b.N; i++ {
-		Decode(input, &resultStrict)
-	}
-}
-
-func Benchmark_DecodeMap(b *testing.B) {
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vother": map[interface{}]interface{}{
-			"foo": "foo",
-			"bar": "bar",
-		},
-	}
-
-	var result Map
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeMapOfStruct(b *testing.B) {
-	input := map[string]interface{}{
-		"value": map[string]interface{}{
-			"foo": map[string]string{"vstring": "one"},
-			"bar": map[string]string{"vstring": "two"},
-		},
-	}
-
-	var result MapOfStruct
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeSlice(b *testing.B) {
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": []string{"foo", "bar", "baz"},
-	}
-
-	var result Slice
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeSliceOfStruct(b *testing.B) {
-	input := map[string]interface{}{
-		"value": []map[string]interface{}{
-			{"vstring": "one"},
-			{"vstring": "two"},
-		},
-	}
-
-	var result SliceOfStruct
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
-
-func Benchmark_DecodeWeaklyTypedInput(b *testing.B) {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-	}
-
-	// This input can come from anywhere, but typically comes from
-	// something like decoding JSON, generated by a weakly typed language
-	// such as PHP.
-	input := map[string]interface{}{
-		"name":   123,                      // number => string
-		"age":    "42",                     // string => number
-		"emails": map[string]interface{}{}, // empty map => empty array
-	}
-
-	var result Person
-	config := &DecoderConfig{
-		WeaklyTypedInput: true,
-		Result:           &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		panic(err)
-	}
-
-	for i := 0; i < b.N; i++ {
-		decoder.Decode(input)
-	}
-}
-
-func Benchmark_DecodeMetadata(b *testing.B) {
-	type Person struct {
-		Name string
-		Age  int
-	}
-
-	input := map[string]interface{}{
-		"name":  "Mitchell",
-		"age":   91,
-		"email": "foo@bar.com",
-	}
-
-	var md Metadata
-	var result Person
-	config := &DecoderConfig{
-		Metadata: &md,
-		Result:   &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		panic(err)
-	}
-
-	for i := 0; i < b.N; i++ {
-		decoder.Decode(input)
-	}
-}
-
-func Benchmark_DecodeMetadataEmbedded(b *testing.B) {
-	input := map[string]interface{}{
-		"vstring": "foo",
-		"vunique": "bar",
-	}
-
-	var md Metadata
-	var result EmbeddedSquash
-	config := &DecoderConfig{
-		Metadata: &md,
-		Result:   &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		b.Fatalf("err: %s", err)
-	}
-
-	for i := 0; i < b.N; i++ {
-		decoder.Decode(input)
-	}
-}
-
-func Benchmark_DecodeTagged(b *testing.B) {
-	input := map[string]interface{}{
-		"foo": "bar",
-		"bar": "value",
-	}
-
-	var result Tagged
-	for i := 0; i < b.N; i++ {
-		Decode(input, &result)
-	}
-}
diff --git a/vendor/github.com/mitchellh/mapstructure/mapstructure_bugs_test.go b/vendor/github.com/mitchellh/mapstructure/mapstructure_bugs_test.go
deleted file mode 100644
index ecfb76987..000000000
--- a/vendor/github.com/mitchellh/mapstructure/mapstructure_bugs_test.go
+++ /dev/null
@@ -1,278 +0,0 @@
-package mapstructure
-
-import "testing"
-
-// GH-1
-func TestDecode_NilValue(t *testing.T) {
-	input := map[string]interface{}{
-		"vfoo":   nil,
-		"vother": nil,
-	}
-
-	var result Map
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("should not error: %s", err)
-	}
-
-	if result.Vfoo != "" {
-		t.Fatalf("value should be default: %s", result.Vfoo)
-	}
-
-	if result.Vother != nil {
-		t.Fatalf("Vother should be nil: %s", result.Vother)
-	}
-}
-
-// GH-10
-func TestDecode_mapInterfaceInterface(t *testing.T) {
-	input := map[interface{}]interface{}{
-		"vfoo":   nil,
-		"vother": nil,
-	}
-
-	var result Map
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("should not error: %s", err)
-	}
-
-	if result.Vfoo != "" {
-		t.Fatalf("value should be default: %s", result.Vfoo)
-	}
-
-	if result.Vother != nil {
-		t.Fatalf("Vother should be nil: %s", result.Vother)
-	}
-}
-
-// #48
-func TestNestedTypePointerWithDefaults(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": map[string]interface{}{
-			"vstring": "foo",
-			"vint":    42,
-			"vbool":   true,
-		},
-	}
-
-	result := NestedPointer{
-		Vbar: &Basic{
-			Vuint: 42,
-		},
-	}
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	if result.Vbar.Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vbar.Vstring)
-	}
-
-	if result.Vbar.Vint != 42 {
-		t.Errorf("vint value should be 42: %#v", result.Vbar.Vint)
-	}
-
-	if result.Vbar.Vbool != true {
-		t.Errorf("vbool value should be true: %#v", result.Vbar.Vbool)
-	}
-
-	if result.Vbar.Vextra != "" {
-		t.Errorf("vextra value should be empty: %#v", result.Vbar.Vextra)
-	}
-
-	// this is the error
-	if result.Vbar.Vuint != 42 {
-		t.Errorf("vuint value should be 42: %#v", result.Vbar.Vuint)
-	}
-
-}
-
-type NestedSlice struct {
-	Vfoo   string
-	Vbars  []Basic
-	Vempty []Basic
-}
-
-// #48
-func TestNestedTypeSliceWithDefaults(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbars": []map[string]interface{}{
-			{"vstring": "foo", "vint": 42, "vbool": true},
-			{"vint": 42, "vbool": true},
-		},
-		"vempty": []map[string]interface{}{
-			{"vstring": "foo", "vint": 42, "vbool": true},
-			{"vint": 42, "vbool": true},
-		},
-	}
-
-	result := NestedSlice{
-		Vbars: []Basic{
-			{Vuint: 42},
-			{Vstring: "foo"},
-		},
-	}
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	if result.Vbars[0].Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vbars[0].Vstring)
-	}
-	// this is the error
-	if result.Vbars[0].Vuint != 42 {
-		t.Errorf("vuint value should be 42: %#v", result.Vbars[0].Vuint)
-	}
-}
-
-// #48 workaround
-func TestNestedTypeWithDefaults(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": map[string]interface{}{
-			"vstring": "foo",
-			"vint":    42,
-			"vbool":   true,
-		},
-	}
-
-	result := Nested{
-		Vbar: Basic{
-			Vuint: 42,
-		},
-	}
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	if result.Vbar.Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vbar.Vstring)
-	}
-
-	if result.Vbar.Vint != 42 {
-		t.Errorf("vint value should be 42: %#v", result.Vbar.Vint)
-	}
-
-	if result.Vbar.Vbool != true {
-		t.Errorf("vbool value should be true: %#v", result.Vbar.Vbool)
-	}
-
-	if result.Vbar.Vextra != "" {
-		t.Errorf("vextra value should be empty: %#v", result.Vbar.Vextra)
-	}
-
-	// this is the error
-	if result.Vbar.Vuint != 42 {
-		t.Errorf("vuint value should be 42: %#v", result.Vbar.Vuint)
-	}
-
-}
-
-// #67 panic() on extending slices (decodeSlice with disabled ZeroValues)
-func TestDecodeSliceToEmptySliceWOZeroing(t *testing.T) {
-	t.Parallel()
-
-	type TestStruct struct {
-		Vfoo []string
-	}
-
-	decode := func(m interface{}, rawVal interface{}) error {
-		config := &DecoderConfig{
-			Metadata:   nil,
-			Result:     rawVal,
-			ZeroFields: false,
-		}
-
-		decoder, err := NewDecoder(config)
-		if err != nil {
-			return err
-		}
-
-		return decoder.Decode(m)
-	}
-
-	{
-		input := map[string]interface{}{
-			"vfoo": []string{"1"},
-		}
-
-		result := &TestStruct{}
-
-		err := decode(input, &result)
-		if err != nil {
-			t.Fatalf("got an err: %s", err.Error())
-		}
-	}
-
-	{
-		input := map[string]interface{}{
-			"vfoo": []string{"1"},
-		}
-
-		result := &TestStruct{
-			Vfoo: []string{},
-		}
-
-		err := decode(input, &result)
-		if err != nil {
-			t.Fatalf("got an err: %s", err.Error())
-		}
-	}
-
-	{
-		input := map[string]interface{}{
-			"vfoo": []string{"2", "3"},
-		}
-
-		result := &TestStruct{
-			Vfoo: []string{"1"},
-		}
-
-		err := decode(input, &result)
-		if err != nil {
-			t.Fatalf("got an err: %s", err.Error())
-		}
-	}
-}
-
-// #70
-func TestNextSquashMapstructure(t *testing.T) {
-	data := &struct {
-		Level1 struct {
-			Level2 struct {
-				Foo string
-			} `mapstructure:",squash"`
-		} `mapstructure:",squash"`
-	}{}
-	err := Decode(map[interface{}]interface{}{"foo": "baz"}, &data)
-	if err != nil {
-		t.Fatalf("should not error: %s", err)
-	}
-	if data.Level1.Level2.Foo != "baz" {
-		t.Fatal("value should be baz")
-	}
-}
diff --git a/vendor/github.com/mitchellh/mapstructure/mapstructure_examples_test.go b/vendor/github.com/mitchellh/mapstructure/mapstructure_examples_test.go
deleted file mode 100644
index f17c214a8..000000000
--- a/vendor/github.com/mitchellh/mapstructure/mapstructure_examples_test.go
+++ /dev/null
@@ -1,203 +0,0 @@
-package mapstructure
-
-import (
-	"fmt"
-)
-
-func ExampleDecode() {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-		Extra  map[string]string
-	}
-
-	// This input can come from anywhere, but typically comes from
-	// something like decoding JSON where we're not quite sure of the
-	// struct initially.
-	input := map[string]interface{}{
-		"name":   "Mitchell",
-		"age":    91,
-		"emails": []string{"one", "two", "three"},
-		"extra": map[string]string{
-			"twitter": "mitchellh",
-		},
-	}
-
-	var result Person
-	err := Decode(input, &result)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Printf("%#v", result)
-	// Output:
-	// mapstructure.Person{Name:"Mitchell", Age:91, Emails:[]string{"one", "two", "three"}, Extra:map[string]string{"twitter":"mitchellh"}}
-}
-
-func ExampleDecode_errors() {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-		Extra  map[string]string
-	}
-
-	// This input can come from anywhere, but typically comes from
-	// something like decoding JSON where we're not quite sure of the
-	// struct initially.
-	input := map[string]interface{}{
-		"name":   123,
-		"age":    "bad value",
-		"emails": []int{1, 2, 3},
-	}
-
-	var result Person
-	err := Decode(input, &result)
-	if err == nil {
-		panic("should have an error")
-	}
-
-	fmt.Println(err.Error())
-	// Output:
-	// 5 error(s) decoding:
-	//
-	// * 'Age' expected type 'int', got unconvertible type 'string'
-	// * 'Emails[0]' expected type 'string', got unconvertible type 'int'
-	// * 'Emails[1]' expected type 'string', got unconvertible type 'int'
-	// * 'Emails[2]' expected type 'string', got unconvertible type 'int'
-	// * 'Name' expected type 'string', got unconvertible type 'int'
-}
-
-func ExampleDecode_metadata() {
-	type Person struct {
-		Name string
-		Age  int
-	}
-
-	// This input can come from anywhere, but typically comes from
-	// something like decoding JSON where we're not quite sure of the
-	// struct initially.
-	input := map[string]interface{}{
-		"name":  "Mitchell",
-		"age":   91,
-		"email": "foo@bar.com",
-	}
-
-	// For metadata, we make a more advanced DecoderConfig so we can
-	// more finely configure the decoder that is used. In this case, we
-	// just tell the decoder we want to track metadata.
-	var md Metadata
-	var result Person
-	config := &DecoderConfig{
-		Metadata: &md,
-		Result:   &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		panic(err)
-	}
-
-	if err := decoder.Decode(input); err != nil {
-		panic(err)
-	}
-
-	fmt.Printf("Unused keys: %#v", md.Unused)
-	// Output:
-	// Unused keys: []string{"email"}
-}
-
-func ExampleDecode_weaklyTypedInput() {
-	type Person struct {
-		Name   string
-		Age    int
-		Emails []string
-	}
-
-	// This input can come from anywhere, but typically comes from
-	// something like decoding JSON, generated by a weakly typed language
-	// such as PHP.
-	input := map[string]interface{}{
-		"name":   123,                      // number => string
-		"age":    "42",                     // string => number
-		"emails": map[string]interface{}{}, // empty map => empty array
-	}
-
-	var result Person
-	config := &DecoderConfig{
-		WeaklyTypedInput: true,
-		Result:           &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		panic(err)
-	}
-
-	err = decoder.Decode(input)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Printf("%#v", result)
-	// Output: mapstructure.Person{Name:"123", Age:42, Emails:[]string{}}
-}
-
-func ExampleDecode_tags() {
-	// Note that the mapstructure tags defined in the struct type
-	// can indicate which fields the values are mapped to.
-	type Person struct {
-		Name string `mapstructure:"person_name"`
-		Age  int    `mapstructure:"person_age"`
-	}
-
-	input := map[string]interface{}{
-		"person_name": "Mitchell",
-		"person_age":  91,
-	}
-
-	var result Person
-	err := Decode(input, &result)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Printf("%#v", result)
-	// Output:
-	// mapstructure.Person{Name:"Mitchell", Age:91}
-}
-
-func ExampleDecode_embeddedStruct() {
-	// Squashing multiple embedded structs is allowed using the squash tag.
-	// This is demonstrated by creating a composite struct of multiple types
-	// and decoding into it. In this case, a person can carry with it both
-	// a Family and a Location, as well as their own FirstName.
-	type Family struct {
-		LastName string
-	}
-	type Location struct {
-		City string
-	}
-	type Person struct {
-		Family    `mapstructure:",squash"`
-		Location  `mapstructure:",squash"`
-		FirstName string
-	}
-
-	input := map[string]interface{}{
-		"FirstName": "Mitchell",
-		"LastName":  "Hashimoto",
-		"City":      "San Francisco",
-	}
-
-	var result Person
-	err := Decode(input, &result)
-	if err != nil {
-		panic(err)
-	}
-
-	fmt.Printf("%s %s, %s", result.FirstName, result.LastName, result.City)
-	// Output:
-	// Mitchell Hashimoto, San Francisco
-}
diff --git a/vendor/github.com/mitchellh/mapstructure/mapstructure_test.go b/vendor/github.com/mitchellh/mapstructure/mapstructure_test.go
deleted file mode 100644
index 64b122a9d..000000000
--- a/vendor/github.com/mitchellh/mapstructure/mapstructure_test.go
+++ /dev/null
@@ -1,1708 +0,0 @@
-package mapstructure
-
-import (
-	"encoding/json"
-	"io"
-	"reflect"
-	"sort"
-	"strings"
-	"testing"
-)
-
-type Basic struct {
-	Vstring     string
-	Vint        int
-	Vuint       uint
-	Vbool       bool
-	Vfloat      float64
-	Vextra      string
-	vsilent     bool
-	Vdata       interface{}
-	VjsonInt    int
-	VjsonFloat  float64
-	VjsonNumber json.Number
-}
-
-type BasicSquash struct {
-	Test Basic `mapstructure:",squash"`
-}
-
-type Embedded struct {
-	Basic
-	Vunique string
-}
-
-type EmbeddedPointer struct {
-	*Basic
-	Vunique string
-}
-
-type EmbeddedSquash struct {
-	Basic   `mapstructure:",squash"`
-	Vunique string
-}
-
-type SliceAlias []string
-
-type EmbeddedSlice struct {
-	SliceAlias `mapstructure:"slice_alias"`
-	Vunique    string
-}
-
-type ArrayAlias [2]string
-
-type EmbeddedArray struct {
-	ArrayAlias `mapstructure:"array_alias"`
-	Vunique    string
-}
-
-type SquashOnNonStructType struct {
-	InvalidSquashType int `mapstructure:",squash"`
-}
-
-type Map struct {
-	Vfoo   string
-	Vother map[string]string
-}
-
-type MapOfStruct struct {
-	Value map[string]Basic
-}
-
-type Nested struct {
-	Vfoo string
-	Vbar Basic
-}
-
-type NestedPointer struct {
-	Vfoo string
-	Vbar *Basic
-}
-
-type NilInterface struct {
-	W io.Writer
-}
-
-type Slice struct {
-	Vfoo string
-	Vbar []string
-}
-
-type SliceOfStruct struct {
-	Value []Basic
-}
-
-type Array struct {
-	Vfoo string
-	Vbar [2]string
-}
-
-type ArrayOfStruct struct {
-	Value [2]Basic
-}
-
-type Func struct {
-	Foo func() string
-}
-
-type Tagged struct {
-	Extra string `mapstructure:"bar,what,what"`
-	Value string `mapstructure:"foo"`
-}
-
-type TypeConversionResult struct {
-	IntToFloat         float32
-	IntToUint          uint
-	IntToBool          bool
-	IntToString        string
-	UintToInt          int
-	UintToFloat        float32
-	UintToBool         bool
-	UintToString       string
-	BoolToInt          int
-	BoolToUint         uint
-	BoolToFloat        float32
-	BoolToString       string
-	FloatToInt         int
-	FloatToUint        uint
-	FloatToBool        bool
-	FloatToString      string
-	SliceUint8ToString string
-	StringToSliceUint8 []byte
-	ArrayUint8ToString string
-	StringToInt        int
-	StringToUint       uint
-	StringToBool       bool
-	StringToFloat      float32
-	StringToStrSlice   []string
-	StringToIntSlice   []int
-	StringToStrArray   [1]string
-	StringToIntArray   [1]int
-	SliceToMap         map[string]interface{}
-	MapToSlice         []interface{}
-	ArrayToMap         map[string]interface{}
-	MapToArray         [1]interface{}
-}
-
-func TestBasicTypes(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vstring":     "foo",
-		"vint":        42,
-		"Vuint":       42,
-		"vbool":       true,
-		"Vfloat":      42.42,
-		"vsilent":     true,
-		"vdata":       42,
-		"vjsonInt":    json.Number("1234"),
-		"vjsonFloat":  json.Number("1234.5"),
-		"vjsonNumber": json.Number("1234.5"),
-	}
-
-	var result Basic
-	err := Decode(input, &result)
-	if err != nil {
-		t.Errorf("got an err: %s", err.Error())
-		t.FailNow()
-	}
-
-	if result.Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vstring)
-	}
-
-	if result.Vint != 42 {
-		t.Errorf("vint value should be 42: %#v", result.Vint)
-	}
-
-	if result.Vuint != 42 {
-		t.Errorf("vuint value should be 42: %#v", result.Vuint)
-	}
-
-	if result.Vbool != true {
-		t.Errorf("vbool value should be true: %#v", result.Vbool)
-	}
-
-	if result.Vfloat != 42.42 {
-		t.Errorf("vfloat value should be 42.42: %#v", result.Vfloat)
-	}
-
-	if result.Vextra != "" {
-		t.Errorf("vextra value should be empty: %#v", result.Vextra)
-	}
-
-	if result.vsilent != false {
-		t.Error("vsilent should not be set, it is unexported")
-	}
-
-	if result.Vdata != 42 {
-		t.Error("vdata should be valid")
-	}
-
-	if result.VjsonInt != 1234 {
-		t.Errorf("vjsonint value should be 1234: %#v", result.VjsonInt)
-	}
-
-	if result.VjsonFloat != 1234.5 {
-		t.Errorf("vjsonfloat value should be 1234.5: %#v", result.VjsonFloat)
-	}
-
-	if !reflect.DeepEqual(result.VjsonNumber, json.Number("1234.5")) {
-		t.Errorf("vjsonnumber value should be '1234.5': %T, %#v", result.VjsonNumber, result.VjsonNumber)
-	}
-}
-
-func TestBasic_IntWithFloat(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vint": float64(42),
-	}
-
-	var result Basic
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err)
-	}
-}
-
-func TestBasic_Merge(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vint": 42,
-	}
-
-	var result Basic
-	result.Vuint = 100
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err)
-	}
-
-	expected := Basic{
-		Vint:  42,
-		Vuint: 100,
-	}
-	if !reflect.DeepEqual(result, expected) {
-		t.Fatalf("bad: %#v", result)
-	}
-}
-
-// Test for issue #46.
-func TestBasic_Struct(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vdata": map[string]interface{}{
-			"vstring": "foo",
-		},
-	}
-
-	var result, inner Basic
-	result.Vdata = &inner
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err)
-	}
-	expected := Basic{
-		Vdata: &Basic{
-			Vstring: "foo",
-		},
-	}
-	if !reflect.DeepEqual(result, expected) {
-		t.Fatalf("bad: %#v", result)
-	}
-}
-
-func TestDecode_BasicSquash(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vstring": "foo",
-	}
-
-	var result BasicSquash
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Test.Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Test.Vstring)
-	}
-}
-
-func TestDecode_Embedded(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vstring": "foo",
-		"Basic": map[string]interface{}{
-			"vstring": "innerfoo",
-		},
-		"vunique": "bar",
-	}
-
-	var result Embedded
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vstring != "innerfoo" {
-		t.Errorf("vstring value should be 'innerfoo': %#v", result.Vstring)
-	}
-
-	if result.Vunique != "bar" {
-		t.Errorf("vunique value should be 'bar': %#v", result.Vunique)
-	}
-}
-
-func TestDecode_EmbeddedPointer(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vstring": "foo",
-		"Basic": map[string]interface{}{
-			"vstring": "innerfoo",
-		},
-		"vunique": "bar",
-	}
-
-	var result EmbeddedPointer
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	expected := EmbeddedPointer{
-		Basic: &Basic{
-			Vstring: "innerfoo",
-		},
-		Vunique: "bar",
-	}
-	if !reflect.DeepEqual(result, expected) {
-		t.Fatalf("bad: %#v", result)
-	}
-}
-
-func TestDecode_EmbeddedSlice(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"slice_alias": []string{"foo", "bar"},
-		"vunique":     "bar",
-	}
-
-	var result EmbeddedSlice
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if !reflect.DeepEqual(result.SliceAlias, SliceAlias([]string{"foo", "bar"})) {
-		t.Errorf("slice value: %#v", result.SliceAlias)
-	}
-
-	if result.Vunique != "bar" {
-		t.Errorf("vunique value should be 'bar': %#v", result.Vunique)
-	}
-}
-
-func TestDecode_EmbeddedArray(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"array_alias": [2]string{"foo", "bar"},
-		"vunique":     "bar",
-	}
-
-	var result EmbeddedArray
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if !reflect.DeepEqual(result.ArrayAlias, ArrayAlias([2]string{"foo", "bar"})) {
-		t.Errorf("array value: %#v", result.ArrayAlias)
-	}
-
-	if result.Vunique != "bar" {
-		t.Errorf("vunique value should be 'bar': %#v", result.Vunique)
-	}
-}
-
-func TestDecode_EmbeddedSquash(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vstring": "foo",
-		"vunique": "bar",
-	}
-
-	var result EmbeddedSquash
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vstring)
-	}
-
-	if result.Vunique != "bar" {
-		t.Errorf("vunique value should be 'bar': %#v", result.Vunique)
-	}
-}
-
-func TestDecode_SquashOnNonStructType(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"InvalidSquashType": 42,
-	}
-
-	var result SquashOnNonStructType
-	err := Decode(input, &result)
-	if err == nil {
-		t.Fatal("unexpected success decoding invalid squash field type")
-	} else if !strings.Contains(err.Error(), "unsupported type for squash") {
-		t.Fatalf("unexpected error message for invalid squash field type: %s", err)
-	}
-}
-
-func TestDecode_DecodeHook(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vint": "WHAT",
-	}
-
-	decodeHook := func(from reflect.Kind, to reflect.Kind, v interface{}) (interface{}, error) {
-		if from == reflect.String && to != reflect.String {
-			return 5, nil
-		}
-
-		return v, nil
-	}
-
-	var result Basic
-	config := &DecoderConfig{
-		DecodeHook: decodeHook,
-		Result:     &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = decoder.Decode(input)
-	if err != nil {
-		t.Fatalf("got an err: %s", err)
-	}
-
-	if result.Vint != 5 {
-		t.Errorf("vint should be 5: %#v", result.Vint)
-	}
-}
-
-func TestDecode_DecodeHookType(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vint": "WHAT",
-	}
-
-	decodeHook := func(from reflect.Type, to reflect.Type, v interface{}) (interface{}, error) {
-		if from.Kind() == reflect.String &&
-			to.Kind() != reflect.String {
-			return 5, nil
-		}
-
-		return v, nil
-	}
-
-	var result Basic
-	config := &DecoderConfig{
-		DecodeHook: decodeHook,
-		Result:     &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = decoder.Decode(input)
-	if err != nil {
-		t.Fatalf("got an err: %s", err)
-	}
-
-	if result.Vint != 5 {
-		t.Errorf("vint should be 5: %#v", result.Vint)
-	}
-}
-
-func TestDecode_Nil(t *testing.T) {
-	t.Parallel()
-
-	var input interface{}
-	result := Basic{
-		Vstring: "foo",
-	}
-
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if result.Vstring != "foo" {
-		t.Fatalf("bad: %#v", result.Vstring)
-	}
-}
-
-func TestDecode_NilInterfaceHook(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"w": "",
-	}
-
-	decodeHook := func(f, t reflect.Type, v interface{}) (interface{}, error) {
-		if t.String() == "io.Writer" {
-			return nil, nil
-		}
-
-		return v, nil
-	}
-
-	var result NilInterface
-	config := &DecoderConfig{
-		DecodeHook: decodeHook,
-		Result:     &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = decoder.Decode(input)
-	if err != nil {
-		t.Fatalf("got an err: %s", err)
-	}
-
-	if result.W != nil {
-		t.Errorf("W should be nil: %#v", result.W)
-	}
-}
-
-func TestDecode_FuncHook(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"foo": "baz",
-	}
-
-	decodeHook := func(f, t reflect.Type, v interface{}) (interface{}, error) {
-		if t.Kind() != reflect.Func {
-			return v, nil
-		}
-		val := v.(string)
-		return func() string { return val }, nil
-	}
-
-	var result Func
-	config := &DecoderConfig{
-		DecodeHook: decodeHook,
-		Result:     &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = decoder.Decode(input)
-	if err != nil {
-		t.Fatalf("got an err: %s", err)
-	}
-
-	if result.Foo() != "baz" {
-		t.Errorf("Foo call result should be 'baz': %s", result.Foo())
-	}
-}
-
-func TestDecode_NonStruct(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"foo": "bar",
-		"bar": "baz",
-	}
-
-	var result map[string]string
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if result["foo"] != "bar" {
-		t.Fatal("foo is not bar")
-	}
-}
-
-func TestDecode_StructMatch(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vbar": Basic{
-			Vstring: "foo",
-		},
-	}
-
-	var result Nested
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vbar.Vstring != "foo" {
-		t.Errorf("bad: %#v", result)
-	}
-}
-
-func TestDecode_TypeConversion(t *testing.T) {
-	input := map[string]interface{}{
-		"IntToFloat":         42,
-		"IntToUint":          42,
-		"IntToBool":          1,
-		"IntToString":        42,
-		"UintToInt":          42,
-		"UintToFloat":        42,
-		"UintToBool":         42,
-		"UintToString":       42,
-		"BoolToInt":          true,
-		"BoolToUint":         true,
-		"BoolToFloat":        true,
-		"BoolToString":       true,
-		"FloatToInt":         42.42,
-		"FloatToUint":        42.42,
-		"FloatToBool":        42.42,
-		"FloatToString":      42.42,
-		"SliceUint8ToString": []uint8("foo"),
-		"StringToSliceUint8": "foo",
-		"ArrayUint8ToString": [3]uint8{'f', 'o', 'o'},
-		"StringToInt":        "42",
-		"StringToUint":       "42",
-		"StringToBool":       "1",
-		"StringToFloat":      "42.42",
-		"StringToStrSlice":   "A",
-		"StringToIntSlice":   "42",
-		"StringToStrArray":   "A",
-		"StringToIntArray":   "42",
-		"SliceToMap":         []interface{}{},
-		"MapToSlice":         map[string]interface{}{},
-		"ArrayToMap":         []interface{}{},
-		"MapToArray":         map[string]interface{}{},
-	}
-
-	expectedResultStrict := TypeConversionResult{
-		IntToFloat:  42.0,
-		IntToUint:   42,
-		UintToInt:   42,
-		UintToFloat: 42,
-		BoolToInt:   0,
-		BoolToUint:  0,
-		BoolToFloat: 0,
-		FloatToInt:  42,
-		FloatToUint: 42,
-	}
-
-	expectedResultWeak := TypeConversionResult{
-		IntToFloat:         42.0,
-		IntToUint:          42,
-		IntToBool:          true,
-		IntToString:        "42",
-		UintToInt:          42,
-		UintToFloat:        42,
-		UintToBool:         true,
-		UintToString:       "42",
-		BoolToInt:          1,
-		BoolToUint:         1,
-		BoolToFloat:        1,
-		BoolToString:       "1",
-		FloatToInt:         42,
-		FloatToUint:        42,
-		FloatToBool:        true,
-		FloatToString:      "42.42",
-		SliceUint8ToString: "foo",
-		StringToSliceUint8: []byte("foo"),
-		ArrayUint8ToString: "foo",
-		StringToInt:        42,
-		StringToUint:       42,
-		StringToBool:       true,
-		StringToFloat:      42.42,
-		StringToStrSlice:   []string{"A"},
-		StringToIntSlice:   []int{42},
-		StringToStrArray:   [1]string{"A"},
-		StringToIntArray:   [1]int{42},
-		SliceToMap:         map[string]interface{}{},
-		MapToSlice:         []interface{}{},
-		ArrayToMap:         map[string]interface{}{},
-		MapToArray:         [1]interface{}{},
-	}
-
-	// Test strict type conversion
-	var resultStrict TypeConversionResult
-	err := Decode(input, &resultStrict)
-	if err == nil {
-		t.Errorf("should return an error")
-	}
-	if !reflect.DeepEqual(resultStrict, expectedResultStrict) {
-		t.Errorf("expected %v, got: %v", expectedResultStrict, resultStrict)
-	}
-
-	// Test weak type conversion
-	var decoder *Decoder
-	var resultWeak TypeConversionResult
-
-	config := &DecoderConfig{
-		WeaklyTypedInput: true,
-		Result:           &resultWeak,
-	}
-
-	decoder, err = NewDecoder(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = decoder.Decode(input)
-	if err != nil {
-		t.Fatalf("got an err: %s", err)
-	}
-
-	if !reflect.DeepEqual(resultWeak, expectedResultWeak) {
-		t.Errorf("expected \n%#v, got: \n%#v", expectedResultWeak, resultWeak)
-	}
-}
-
-func TestDecoder_ErrorUnused(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vstring": "hello",
-		"foo":     "bar",
-	}
-
-	var result Basic
-	config := &DecoderConfig{
-		ErrorUnused: true,
-		Result:      &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = decoder.Decode(input)
-	if err == nil {
-		t.Fatal("expected error")
-	}
-}
-
-func TestMap(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vother": map[interface{}]interface{}{
-			"foo": "foo",
-			"bar": "bar",
-		},
-	}
-
-	var result Map
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an error: %s", err)
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	if result.Vother == nil {
-		t.Fatal("vother should not be nil")
-	}
-
-	if len(result.Vother) != 2 {
-		t.Error("vother should have two items")
-	}
-
-	if result.Vother["foo"] != "foo" {
-		t.Errorf("'foo' key should be foo, got: %#v", result.Vother["foo"])
-	}
-
-	if result.Vother["bar"] != "bar" {
-		t.Errorf("'bar' key should be bar, got: %#v", result.Vother["bar"])
-	}
-}
-
-func TestMapMerge(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vother": map[interface{}]interface{}{
-			"foo": "foo",
-			"bar": "bar",
-		},
-	}
-
-	var result Map
-	result.Vother = map[string]string{"hello": "world"}
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an error: %s", err)
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	expected := map[string]string{
-		"foo":   "foo",
-		"bar":   "bar",
-		"hello": "world",
-	}
-	if !reflect.DeepEqual(result.Vother, expected) {
-		t.Errorf("bad: %#v", result.Vother)
-	}
-}
-
-func TestMapOfStruct(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"value": map[string]interface{}{
-			"foo": map[string]string{"vstring": "one"},
-			"bar": map[string]string{"vstring": "two"},
-		},
-	}
-
-	var result MapOfStruct
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err)
-	}
-
-	if result.Value == nil {
-		t.Fatal("value should not be nil")
-	}
-
-	if len(result.Value) != 2 {
-		t.Error("value should have two items")
-	}
-
-	if result.Value["foo"].Vstring != "one" {
-		t.Errorf("foo value should be 'one', got: %s", result.Value["foo"].Vstring)
-	}
-
-	if result.Value["bar"].Vstring != "two" {
-		t.Errorf("bar value should be 'two', got: %s", result.Value["bar"].Vstring)
-	}
-}
-
-func TestNestedType(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": map[string]interface{}{
-			"vstring": "foo",
-			"vint":    42,
-			"vbool":   true,
-		},
-	}
-
-	var result Nested
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	if result.Vbar.Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vbar.Vstring)
-	}
-
-	if result.Vbar.Vint != 42 {
-		t.Errorf("vint value should be 42: %#v", result.Vbar.Vint)
-	}
-
-	if result.Vbar.Vbool != true {
-		t.Errorf("vbool value should be true: %#v", result.Vbar.Vbool)
-	}
-
-	if result.Vbar.Vextra != "" {
-		t.Errorf("vextra value should be empty: %#v", result.Vbar.Vextra)
-	}
-}
-
-func TestNestedTypePointer(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": &map[string]interface{}{
-			"vstring": "foo",
-			"vint":    42,
-			"vbool":   true,
-		},
-	}
-
-	var result NestedPointer
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	if result.Vbar.Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vbar.Vstring)
-	}
-
-	if result.Vbar.Vint != 42 {
-		t.Errorf("vint value should be 42: %#v", result.Vbar.Vint)
-	}
-
-	if result.Vbar.Vbool != true {
-		t.Errorf("vbool value should be true: %#v", result.Vbar.Vbool)
-	}
-
-	if result.Vbar.Vextra != "" {
-		t.Errorf("vextra value should be empty: %#v", result.Vbar.Vextra)
-	}
-}
-
-// Test for issue #46.
-func TestNestedTypeInterface(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": &map[string]interface{}{
-			"vstring": "foo",
-			"vint":    42,
-			"vbool":   true,
-
-			"vdata": map[string]interface{}{
-				"vstring": "bar",
-			},
-		},
-	}
-
-	var result NestedPointer
-	result.Vbar = new(Basic)
-	result.Vbar.Vdata = new(Basic)
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got an err: %s", err.Error())
-	}
-
-	if result.Vfoo != "foo" {
-		t.Errorf("vfoo value should be 'foo': %#v", result.Vfoo)
-	}
-
-	if result.Vbar.Vstring != "foo" {
-		t.Errorf("vstring value should be 'foo': %#v", result.Vbar.Vstring)
-	}
-
-	if result.Vbar.Vint != 42 {
-		t.Errorf("vint value should be 42: %#v", result.Vbar.Vint)
-	}
-
-	if result.Vbar.Vbool != true {
-		t.Errorf("vbool value should be true: %#v", result.Vbar.Vbool)
-	}
-
-	if result.Vbar.Vextra != "" {
-		t.Errorf("vextra value should be empty: %#v", result.Vbar.Vextra)
-	}
-
-	if result.Vbar.Vdata.(*Basic).Vstring != "bar" {
-		t.Errorf("vstring value should be 'bar': %#v", result.Vbar.Vdata.(*Basic).Vstring)
-	}
-}
-
-func TestSlice(t *testing.T) {
-	t.Parallel()
-
-	inputStringSlice := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": []string{"foo", "bar", "baz"},
-	}
-
-	inputStringSlicePointer := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": &[]string{"foo", "bar", "baz"},
-	}
-
-	outputStringSlice := &Slice{
-		"foo",
-		[]string{"foo", "bar", "baz"},
-	}
-
-	testSliceInput(t, inputStringSlice, outputStringSlice)
-	testSliceInput(t, inputStringSlicePointer, outputStringSlice)
-}
-
-func TestInvalidSlice(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": 42,
-	}
-
-	result := Slice{}
-	err := Decode(input, &result)
-	if err == nil {
-		t.Errorf("expected failure")
-	}
-}
-
-func TestSliceOfStruct(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"value": []map[string]interface{}{
-			{"vstring": "one"},
-			{"vstring": "two"},
-		},
-	}
-
-	var result SliceOfStruct
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got unexpected error: %s", err)
-	}
-
-	if len(result.Value) != 2 {
-		t.Fatalf("expected two values, got %d", len(result.Value))
-	}
-
-	if result.Value[0].Vstring != "one" {
-		t.Errorf("first value should be 'one', got: %s", result.Value[0].Vstring)
-	}
-
-	if result.Value[1].Vstring != "two" {
-		t.Errorf("second value should be 'two', got: %s", result.Value[1].Vstring)
-	}
-}
-
-func TestSliceToMap(t *testing.T) {
-	t.Parallel()
-
-	input := []map[string]interface{}{
-		{
-			"foo": "bar",
-		},
-		{
-			"bar": "baz",
-		},
-	}
-
-	var result map[string]interface{}
-	err := WeakDecode(input, &result)
-	if err != nil {
-		t.Fatalf("got an error: %s", err)
-	}
-
-	expected := map[string]interface{}{
-		"foo": "bar",
-		"bar": "baz",
-	}
-	if !reflect.DeepEqual(result, expected) {
-		t.Errorf("bad: %#v", result)
-	}
-}
-
-func TestArray(t *testing.T) {
-	t.Parallel()
-
-	inputStringArray := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": [2]string{"foo", "bar"},
-	}
-
-	inputStringArrayPointer := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": &[2]string{"foo", "bar"},
-	}
-
-	outputStringArray := &Array{
-		"foo",
-		[2]string{"foo", "bar"},
-	}
-
-	testArrayInput(t, inputStringArray, outputStringArray)
-	testArrayInput(t, inputStringArrayPointer, outputStringArray)
-}
-
-func TestInvalidArray(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": 42,
-	}
-
-	result := Array{}
-	err := Decode(input, &result)
-	if err == nil {
-		t.Errorf("expected failure")
-	}
-}
-
-func TestArrayOfStruct(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"value": []map[string]interface{}{
-			{"vstring": "one"},
-			{"vstring": "two"},
-		},
-	}
-
-	var result ArrayOfStruct
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got unexpected error: %s", err)
-	}
-
-	if len(result.Value) != 2 {
-		t.Fatalf("expected two values, got %d", len(result.Value))
-	}
-
-	if result.Value[0].Vstring != "one" {
-		t.Errorf("first value should be 'one', got: %s", result.Value[0].Vstring)
-	}
-
-	if result.Value[1].Vstring != "two" {
-		t.Errorf("second value should be 'two', got: %s", result.Value[1].Vstring)
-	}
-}
-
-func TestArrayToMap(t *testing.T) {
-	t.Parallel()
-
-	input := []map[string]interface{}{
-		{
-			"foo": "bar",
-		},
-		{
-			"bar": "baz",
-		},
-	}
-
-	var result map[string]interface{}
-	err := WeakDecode(input, &result)
-	if err != nil {
-		t.Fatalf("got an error: %s", err)
-	}
-
-	expected := map[string]interface{}{
-		"foo": "bar",
-		"bar": "baz",
-	}
-	if !reflect.DeepEqual(result, expected) {
-		t.Errorf("bad: %#v", result)
-	}
-}
-
-func TestMapOutputForStructuredInputs(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name    string
-		in      interface{}
-		target  interface{}
-		out     interface{}
-		wantErr bool
-	}{
-		{
-			"basic struct input",
-			&Basic{
-				Vstring: "vstring",
-				Vint:    2,
-				Vuint:   3,
-				Vbool:   true,
-				Vfloat:  4.56,
-				Vextra:  "vextra",
-				vsilent: true,
-				Vdata:   []byte("data"),
-			},
-			&map[string]interface{}{},
-			&map[string]interface{}{
-				"Vstring":     "vstring",
-				"Vint":        2,
-				"Vuint":       uint(3),
-				"Vbool":       true,
-				"Vfloat":      4.56,
-				"Vextra":      "vextra",
-				"Vdata":       []byte("data"),
-				"VjsonInt":    0,
-				"VjsonFloat":  0.0,
-				"VjsonNumber": json.Number(""),
-			},
-			false,
-		},
-		{
-			"embedded struct input",
-			&Embedded{
-				Vunique: "vunique",
-				Basic: Basic{
-					Vstring: "vstring",
-					Vint:    2,
-					Vuint:   3,
-					Vbool:   true,
-					Vfloat:  4.56,
-					Vextra:  "vextra",
-					vsilent: true,
-					Vdata:   []byte("data"),
-				},
-			},
-			&map[string]interface{}{},
-			&map[string]interface{}{
-				"Vunique": "vunique",
-				"Basic": map[string]interface{}{
-					"Vstring":     "vstring",
-					"Vint":        2,
-					"Vuint":       uint(3),
-					"Vbool":       true,
-					"Vfloat":      4.56,
-					"Vextra":      "vextra",
-					"Vdata":       []byte("data"),
-					"VjsonInt":    0,
-					"VjsonFloat":  0.0,
-					"VjsonNumber": json.Number(""),
-				},
-			},
-			false,
-		},
-		{
-			"slice input - should error",
-			[]string{"foo", "bar"},
-			&map[string]interface{}{},
-			&map[string]interface{}{},
-			true,
-		},
-		{
-			"struct with slice property",
-			&Slice{
-				Vfoo: "vfoo",
-				Vbar: []string{"foo", "bar"},
-			},
-			&map[string]interface{}{},
-			&map[string]interface{}{
-				"Vfoo": "vfoo",
-				"Vbar": []string{"foo", "bar"},
-			},
-			false,
-		},
-		{
-			"struct with slice of struct property",
-			&SliceOfStruct{
-				Value: []Basic{
-					Basic{
-						Vstring: "vstring",
-						Vint:    2,
-						Vuint:   3,
-						Vbool:   true,
-						Vfloat:  4.56,
-						Vextra:  "vextra",
-						vsilent: true,
-						Vdata:   []byte("data"),
-					},
-				},
-			},
-			&map[string]interface{}{},
-			&map[string]interface{}{
-				"Value": []Basic{
-					Basic{
-						Vstring: "vstring",
-						Vint:    2,
-						Vuint:   3,
-						Vbool:   true,
-						Vfloat:  4.56,
-						Vextra:  "vextra",
-						vsilent: true,
-						Vdata:   []byte("data"),
-					},
-				},
-			},
-			false,
-		},
-		{
-			"struct with map property",
-			&Map{
-				Vfoo:   "vfoo",
-				Vother: map[string]string{"vother": "vother"},
-			},
-			&map[string]interface{}{},
-			&map[string]interface{}{
-				"Vfoo": "vfoo",
-				"Vother": map[string]string{
-					"vother": "vother",
-				}},
-			false,
-		},
-		{
-			"tagged struct",
-			&Tagged{
-				Extra: "extra",
-				Value: "value",
-			},
-			&map[string]string{},
-			&map[string]string{
-				"bar": "extra",
-				"foo": "value",
-			},
-			false,
-		},
-		{
-			"omit tag struct",
-			&struct {
-				Value string `mapstructure:"value"`
-				Omit  string `mapstructure:"-"`
-			}{
-				Value: "value",
-				Omit:  "omit",
-			},
-			&map[string]string{},
-			&map[string]string{
-				"value": "value",
-			},
-			false,
-		},
-		{
-			"decode to wrong map type",
-			&struct {
-				Value string
-			}{
-				Value: "string",
-			},
-			&map[string]int{},
-			&map[string]int{},
-			true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := Decode(tt.in, tt.target); (err != nil) != tt.wantErr {
-				t.Fatalf("%q: TestMapOutputForStructuredInputs() unexpected error: %s", tt.name, err)
-			}
-
-			if !reflect.DeepEqual(tt.out, tt.target) {
-				t.Fatalf("%q: TestMapOutputForStructuredInputs() expected: %#v, got: %#v", tt.name, tt.out, tt.target)
-			}
-		})
-	}
-}
-
-func TestInvalidType(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vstring": 42,
-	}
-
-	var result Basic
-	err := Decode(input, &result)
-	if err == nil {
-		t.Fatal("error should exist")
-	}
-
-	derr, ok := err.(*Error)
-	if !ok {
-		t.Fatalf("error should be kind of Error, instead: %#v", err)
-	}
-
-	if derr.Errors[0] != "'Vstring' expected type 'string', got unconvertible type 'int'" {
-		t.Errorf("got unexpected error: %s", err)
-	}
-
-	inputNegIntUint := map[string]interface{}{
-		"vuint": -42,
-	}
-
-	err = Decode(inputNegIntUint, &result)
-	if err == nil {
-		t.Fatal("error should exist")
-	}
-
-	derr, ok = err.(*Error)
-	if !ok {
-		t.Fatalf("error should be kind of Error, instead: %#v", err)
-	}
-
-	if derr.Errors[0] != "cannot parse 'Vuint', -42 overflows uint" {
-		t.Errorf("got unexpected error: %s", err)
-	}
-
-	inputNegFloatUint := map[string]interface{}{
-		"vuint": -42.0,
-	}
-
-	err = Decode(inputNegFloatUint, &result)
-	if err == nil {
-		t.Fatal("error should exist")
-	}
-
-	derr, ok = err.(*Error)
-	if !ok {
-		t.Fatalf("error should be kind of Error, instead: %#v", err)
-	}
-
-	if derr.Errors[0] != "cannot parse 'Vuint', -42.000000 overflows uint" {
-		t.Errorf("got unexpected error: %s", err)
-	}
-}
-
-func TestDecodeMetadata(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": map[string]interface{}{
-			"vstring": "foo",
-			"Vuint":   42,
-			"foo":     "bar",
-		},
-		"bar": "nil",
-	}
-
-	var md Metadata
-	var result Nested
-
-	err := DecodeMetadata(input, &result, &md)
-	if err != nil {
-		t.Fatalf("err: %s", err.Error())
-	}
-
-	expectedKeys := []string{"Vbar", "Vbar.Vstring", "Vbar.Vuint", "Vfoo"}
-	sort.Strings(md.Keys)
-	if !reflect.DeepEqual(md.Keys, expectedKeys) {
-		t.Fatalf("bad keys: %#v", md.Keys)
-	}
-
-	expectedUnused := []string{"Vbar.foo", "bar"}
-	if !reflect.DeepEqual(md.Unused, expectedUnused) {
-		t.Fatalf("bad unused: %#v", md.Unused)
-	}
-}
-
-func TestMetadata(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vfoo": "foo",
-		"vbar": map[string]interface{}{
-			"vstring": "foo",
-			"Vuint":   42,
-			"foo":     "bar",
-		},
-		"bar": "nil",
-	}
-
-	var md Metadata
-	var result Nested
-	config := &DecoderConfig{
-		Metadata: &md,
-		Result:   &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = decoder.Decode(input)
-	if err != nil {
-		t.Fatalf("err: %s", err.Error())
-	}
-
-	expectedKeys := []string{"Vbar", "Vbar.Vstring", "Vbar.Vuint", "Vfoo"}
-	sort.Strings(md.Keys)
-	if !reflect.DeepEqual(md.Keys, expectedKeys) {
-		t.Fatalf("bad keys: %#v", md.Keys)
-	}
-
-	expectedUnused := []string{"Vbar.foo", "bar"}
-	if !reflect.DeepEqual(md.Unused, expectedUnused) {
-		t.Fatalf("bad unused: %#v", md.Unused)
-	}
-}
-
-func TestMetadata_Embedded(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"vstring": "foo",
-		"vunique": "bar",
-	}
-
-	var md Metadata
-	var result EmbeddedSquash
-	config := &DecoderConfig{
-		Metadata: &md,
-		Result:   &result,
-	}
-
-	decoder, err := NewDecoder(config)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = decoder.Decode(input)
-	if err != nil {
-		t.Fatalf("err: %s", err.Error())
-	}
-
-	expectedKeys := []string{"Vstring", "Vunique"}
-
-	sort.Strings(md.Keys)
-	if !reflect.DeepEqual(md.Keys, expectedKeys) {
-		t.Fatalf("bad keys: %#v", md.Keys)
-	}
-
-	expectedUnused := []string{}
-	if !reflect.DeepEqual(md.Unused, expectedUnused) {
-		t.Fatalf("bad unused: %#v", md.Unused)
-	}
-}
-
-func TestNonPtrValue(t *testing.T) {
-	t.Parallel()
-
-	err := Decode(map[string]interface{}{}, Basic{})
-	if err == nil {
-		t.Fatal("error should exist")
-	}
-
-	if err.Error() != "result must be a pointer" {
-		t.Errorf("got unexpected error: %s", err)
-	}
-}
-
-func TestTagged(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"foo": "bar",
-		"bar": "value",
-	}
-
-	var result Tagged
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("unexpected error: %s", err)
-	}
-
-	if result.Value != "bar" {
-		t.Errorf("value should be 'bar', got: %#v", result.Value)
-	}
-
-	if result.Extra != "value" {
-		t.Errorf("extra should be 'value', got: %#v", result.Extra)
-	}
-}
-
-func TestWeakDecode(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"foo": "4",
-		"bar": "value",
-	}
-
-	var result struct {
-		Foo int
-		Bar string
-	}
-
-	if err := WeakDecode(input, &result); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	if result.Foo != 4 {
-		t.Fatalf("bad: %#v", result)
-	}
-	if result.Bar != "value" {
-		t.Fatalf("bad: %#v", result)
-	}
-}
-
-func TestWeakDecodeMetadata(t *testing.T) {
-	t.Parallel()
-
-	input := map[string]interface{}{
-		"foo":    "4",
-		"bar":    "value",
-		"unused": "value",
-	}
-
-	var md Metadata
-	var result struct {
-		Foo int
-		Bar string
-	}
-
-	if err := WeakDecodeMetadata(input, &result, &md); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	if result.Foo != 4 {
-		t.Fatalf("bad: %#v", result)
-	}
-	if result.Bar != "value" {
-		t.Fatalf("bad: %#v", result)
-	}
-
-	expectedKeys := []string{"Bar", "Foo"}
-	sort.Strings(md.Keys)
-	if !reflect.DeepEqual(md.Keys, expectedKeys) {
-		t.Fatalf("bad keys: %#v", md.Keys)
-	}
-
-	expectedUnused := []string{"unused"}
-	if !reflect.DeepEqual(md.Unused, expectedUnused) {
-		t.Fatalf("bad unused: %#v", md.Unused)
-	}
-}
-
-func testSliceInput(t *testing.T, input map[string]interface{}, expected *Slice) {
-	var result Slice
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got error: %s", err)
-	}
-
-	if result.Vfoo != expected.Vfoo {
-		t.Errorf("Vfoo expected '%s', got '%s'", expected.Vfoo, result.Vfoo)
-	}
-
-	if result.Vbar == nil {
-		t.Fatalf("Vbar a slice, got '%#v'", result.Vbar)
-	}
-
-	if len(result.Vbar) != len(expected.Vbar) {
-		t.Errorf("Vbar length should be %d, got %d", len(expected.Vbar), len(result.Vbar))
-	}
-
-	for i, v := range result.Vbar {
-		if v != expected.Vbar[i] {
-			t.Errorf(
-				"Vbar[%d] should be '%#v', got '%#v'",
-				i, expected.Vbar[i], v)
-		}
-	}
-}
-
-func testArrayInput(t *testing.T, input map[string]interface{}, expected *Array) {
-	var result Array
-	err := Decode(input, &result)
-	if err != nil {
-		t.Fatalf("got error: %s", err)
-	}
-
-	if result.Vfoo != expected.Vfoo {
-		t.Errorf("Vfoo expected '%s', got '%s'", expected.Vfoo, result.Vfoo)
-	}
-
-	if result.Vbar == [2]string{} {
-		t.Fatalf("Vbar a slice, got '%#v'", result.Vbar)
-	}
-
-	if len(result.Vbar) != len(expected.Vbar) {
-		t.Errorf("Vbar length should be %d, got %d", len(expected.Vbar), len(result.Vbar))
-	}
-
-	for i, v := range result.Vbar {
-		if v != expected.Vbar[i] {
-			t.Errorf(
-				"Vbar[%d] should be '%#v', got '%#v'",
-				i, expected.Vbar[i], v)
-		}
-	}
-}