Depenancy upgrades and movign to dep. (#8630)

vendor/github.com/mitchellh/mapstructure/decode_hooks_test.go

@@ -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)
-		}
-	}
-}

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
 	}
 

vendor/github.com/mitchellh/mapstructure/mapstructure_benchmark_test.go

@@ -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)
-	}
-}

vendor/github.com/mitchellh/mapstructure/mapstructure_bugs_test.go

@@ -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")
-	}
-}

vendor/github.com/mitchellh/mapstructure/mapstructure_examples_test.go

@@ -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
-}