Replace godep with dep

vendor/k8s.io/apimachinery/pkg/conversion/converter_test.go

@@ -0,0 +1,826 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+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 conversion
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/google/gofuzz"
+	flag "github.com/spf13/pflag"
+
+	"k8s.io/apimachinery/pkg/util/diff"
+)
+
+var fuzzIters = flag.Int("fuzz-iters", 50, "How many fuzzing iterations to do.")
+
+// Test a weird version/kind embedding format.
+type MyWeirdCustomEmbeddedVersionKindField struct {
+	ID         string `json:"ID,omitempty"`
+	APIVersion string `json:"myVersionKey,omitempty"`
+	ObjectKind string `json:"myKindKey,omitempty"`
+	Z          string `json:"Z,omitempty"`
+	Y          uint64 `json:"Y,omitempty"`
+}
+
+type TestType1 struct {
+	MyWeirdCustomEmbeddedVersionKindField `json:",inline"`
+	A                                     string               `json:"A,omitempty"`
+	B                                     int                  `json:"B,omitempty"`
+	C                                     int8                 `json:"C,omitempty"`
+	D                                     int16                `json:"D,omitempty"`
+	E                                     int32                `json:"E,omitempty"`
+	F                                     int64                `json:"F,omitempty"`
+	G                                     uint                 `json:"G,omitempty"`
+	H                                     uint8                `json:"H,omitempty"`
+	I                                     uint16               `json:"I,omitempty"`
+	J                                     uint32               `json:"J,omitempty"`
+	K                                     uint64               `json:"K,omitempty"`
+	L                                     bool                 `json:"L,omitempty"`
+	M                                     map[string]int       `json:"M,omitempty"`
+	N                                     map[string]TestType2 `json:"N,omitempty"`
+	O                                     *TestType2           `json:"O,omitempty"`
+	P                                     []TestType2          `json:"Q,omitempty"`
+}
+
+type TestType2 struct {
+	A string `json:"A,omitempty"`
+	B int    `json:"B,omitempty"`
+}
+
+type ExternalTestType2 struct {
+	A string `json:"A,omitempty"`
+	B int    `json:"B,omitempty"`
+}
+type ExternalTestType1 struct {
+	MyWeirdCustomEmbeddedVersionKindField `json:",inline"`
+	A                                     string                       `json:"A,omitempty"`
+	B                                     int                          `json:"B,omitempty"`
+	C                                     int8                         `json:"C,omitempty"`
+	D                                     int16                        `json:"D,omitempty"`
+	E                                     int32                        `json:"E,omitempty"`
+	F                                     int64                        `json:"F,omitempty"`
+	G                                     uint                         `json:"G,omitempty"`
+	H                                     uint8                        `json:"H,omitempty"`
+	I                                     uint16                       `json:"I,omitempty"`
+	J                                     uint32                       `json:"J,omitempty"`
+	K                                     uint64                       `json:"K,omitempty"`
+	L                                     bool                         `json:"L,omitempty"`
+	M                                     map[string]int               `json:"M,omitempty"`
+	N                                     map[string]ExternalTestType2 `json:"N,omitempty"`
+	O                                     *ExternalTestType2           `json:"O,omitempty"`
+	P                                     []ExternalTestType2          `json:"Q,omitempty"`
+}
+
+func testLogger(t *testing.T) DebugLogger {
+	// We don't set logger to eliminate rubbish logs in tests.
+	// If you want to switch it, simply switch it to: "return t"
+	return nil
+}
+
+func TestConverter_byteSlice(t *testing.T) {
+	c := NewConverter(DefaultNameFunc)
+	src := []byte{1, 2, 3}
+	dest := []byte{}
+	err := c.Convert(&src, &dest, 0, nil)
+	if err != nil {
+		t.Fatalf("expected no error")
+	}
+	if e, a := src, dest; !reflect.DeepEqual(e, a) {
+		t.Errorf("expected %#v, got %#v", e, a)
+	}
+}
+
+func TestConverter_MismatchedTypes(t *testing.T) {
+	c := NewConverter(DefaultNameFunc)
+
+	err := c.RegisterConversionFunc(
+		func(in *[]string, out *int, s Scope) error {
+			if str, err := strconv.Atoi((*in)[0]); err != nil {
+				return err
+			} else {
+				*out = str
+				return nil
+			}
+		},
+	)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+
+	src := []string{"5"}
+	var dest *int
+	err = c.Convert(&src, &dest, 0, nil)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if e, a := 5, *dest; e != a {
+		t.Errorf("expected %#v, got %#v", e, a)
+	}
+}
+
+func TestConverter_DefaultConvert(t *testing.T) {
+	type A struct {
+		Foo string
+		Baz int
+	}
+	type B struct {
+		Bar string
+		Baz int
+	}
+	c := NewConverter(DefaultNameFunc)
+	c.Debug = testLogger(t)
+	c.nameFunc = func(t reflect.Type) string { return "MyType" }
+
+	// Ensure conversion funcs can call DefaultConvert to get default behavior,
+	// then fixup remaining fields manually
+	err := c.RegisterConversionFunc(func(in *A, out *B, s Scope) error {
+		if err := s.DefaultConvert(in, out, IgnoreMissingFields); err != nil {
+			return err
+		}
+		out.Bar = in.Foo
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+
+	x := A{"hello, intrepid test reader!", 3}
+	y := B{}
+
+	err = c.Convert(&x, &y, 0, nil)
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if e, a := x.Foo, y.Bar; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := x.Baz, y.Baz; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+}
+
+func TestConverter_DeepCopy(t *testing.T) {
+	type A struct {
+		Foo *string
+		Bar []string
+		Baz interface{}
+		Qux map[string]string
+	}
+	c := NewConverter(DefaultNameFunc)
+	c.Debug = testLogger(t)
+
+	foo, baz := "foo", "baz"
+	x := A{
+		Foo: &foo,
+		Bar: []string{"bar"},
+		Baz: &baz,
+		Qux: map[string]string{"qux": "qux"},
+	}
+	y := A{}
+
+	if err := c.Convert(&x, &y, 0, nil); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	*x.Foo = "foo2"
+	x.Bar[0] = "bar2"
+	*x.Baz.(*string) = "baz2"
+	x.Qux["qux"] = "qux2"
+	if e, a := *x.Foo, *y.Foo; e == a {
+		t.Errorf("expected difference between %v and %v", e, a)
+	}
+	if e, a := x.Bar, y.Bar; reflect.DeepEqual(e, a) {
+		t.Errorf("expected difference between %v and %v", e, a)
+	}
+	if e, a := *x.Baz.(*string), *y.Baz.(*string); e == a {
+		t.Errorf("expected difference between %v and %v", e, a)
+	}
+	if e, a := x.Qux, y.Qux; reflect.DeepEqual(e, a) {
+		t.Errorf("expected difference between %v and %v", e, a)
+	}
+}
+
+func TestConverter_CallsRegisteredFunctions(t *testing.T) {
+	type A struct {
+		Foo string
+		Baz int
+	}
+	type B struct {
+		Bar string
+		Baz int
+	}
+	type C struct{}
+	c := NewConverter(DefaultNameFunc)
+	c.Debug = testLogger(t)
+	err := c.RegisterConversionFunc(func(in *A, out *B, s Scope) error {
+		out.Bar = in.Foo
+		return s.Convert(&in.Baz, &out.Baz, 0)
+	})
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	err = c.RegisterConversionFunc(func(in *B, out *A, s Scope) error {
+		out.Foo = in.Bar
+		return s.Convert(&in.Baz, &out.Baz, 0)
+	})
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+
+	x := A{"hello, intrepid test reader!", 3}
+	y := B{}
+
+	err = c.Convert(&x, &y, 0, nil)
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if e, a := x.Foo, y.Bar; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := x.Baz, y.Baz; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+
+	z := B{"all your test are belong to us", 42}
+	w := A{}
+
+	err = c.Convert(&z, &w, 0, nil)
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if e, a := z.Bar, w.Foo; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := z.Baz, w.Baz; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+
+	err = c.RegisterConversionFunc(func(in *A, out *C, s Scope) error {
+		return fmt.Errorf("C can't store an A, silly")
+	})
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	err = c.Convert(&A{}, &C{}, 0, nil)
+	if err == nil {
+		t.Errorf("unexpected non-error")
+	}
+}
+
+func TestConverter_IgnoredConversion(t *testing.T) {
+	type A struct{}
+	type B struct{}
+
+	count := 0
+	c := NewConverter(DefaultNameFunc)
+	if err := c.RegisterConversionFunc(func(in *A, out *B, s Scope) error {
+		count++
+		return nil
+	}); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if err := c.RegisterIgnoredConversion(&A{}, &B{}); err != nil {
+		t.Fatal(err)
+	}
+	a := A{}
+	b := B{}
+	if err := c.Convert(&a, &b, 0, nil); err != nil {
+		t.Errorf("%v", err)
+	}
+	if count != 0 {
+		t.Errorf("unexpected number of conversion invocations")
+	}
+}
+
+func TestConverter_IgnoredConversionNested(t *testing.T) {
+	type C string
+	type A struct {
+		C C
+	}
+	type B struct {
+		C C
+	}
+
+	c := NewConverter(DefaultNameFunc)
+	typed := C("")
+	if err := c.RegisterIgnoredConversion(&typed, &typed); err != nil {
+		t.Fatal(err)
+	}
+	a := A{C: C("test")}
+	b := B{C: C("other")}
+	if err := c.Convert(&a, &b, AllowDifferentFieldTypeNames, nil); err != nil {
+		t.Errorf("%v", err)
+	}
+	if b.C != C("other") {
+		t.Errorf("expected no conversion of field C: %#v", b)
+	}
+}
+
+func TestConverter_GeneratedConversionOverriden(t *testing.T) {
+	type A struct{}
+	type B struct{}
+	c := NewConverter(DefaultNameFunc)
+	if err := c.RegisterConversionFunc(func(in *A, out *B, s Scope) error {
+		return nil
+	}); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if err := c.RegisterGeneratedConversionFunc(func(in *A, out *B, s Scope) error {
+		return fmt.Errorf("generated function should be overriden")
+	}); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+
+	a := A{}
+	b := B{}
+	if err := c.Convert(&a, &b, 0, nil); err != nil {
+		t.Errorf("%v", err)
+	}
+}
+
+func TestConverter_WithConversionOverriden(t *testing.T) {
+	type A struct{}
+	type B struct{}
+	c := NewConverter(DefaultNameFunc)
+	if err := c.RegisterConversionFunc(func(in *A, out *B, s Scope) error {
+		return fmt.Errorf("conversion function should be overriden")
+	}); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if err := c.RegisterGeneratedConversionFunc(func(in *A, out *B, s Scope) error {
+		return fmt.Errorf("generated function should be overriden")
+	}); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+
+	ext := NewConversionFuncs()
+	ext.Add(func(in *A, out *B, s Scope) error {
+		return nil
+	})
+	newc := c.WithConversions(ext)
+
+	a := A{}
+	b := B{}
+	if err := c.Convert(&a, &b, 0, nil); err == nil || err.Error() != "conversion function should be overriden" {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if err := newc.Convert(&a, &b, 0, nil); err != nil {
+		t.Errorf("%v", err)
+	}
+}
+
+func TestConverter_MapsStringArrays(t *testing.T) {
+	type A struct {
+		Foo   string
+		Baz   int
+		Other string
+	}
+	c := NewConverter(DefaultNameFunc)
+	c.Debug = testLogger(t)
+	if err := c.RegisterConversionFunc(func(input *[]string, out *string, s Scope) error {
+		if len(*input) == 0 {
+			*out = ""
+		}
+		*out = (*input)[0]
+		return nil
+	}); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+
+	x := map[string][]string{
+		"Foo":   {"bar"},
+		"Baz":   {"1"},
+		"Other": {"", "test"},
+		"other": {"wrong"},
+	}
+	y := A{"test", 2, "something"}
+
+	if err := c.Convert(&x, &y, AllowDifferentFieldTypeNames, nil); err == nil {
+		t.Error("unexpected non-error")
+	}
+
+	if err := c.RegisterConversionFunc(func(input *[]string, out *int, s Scope) error {
+		if len(*input) == 0 {
+			*out = 0
+		}
+		str := (*input)[0]
+		i, err := strconv.Atoi(str)
+		if err != nil {
+			return err
+		}
+		*out = i
+		return nil
+	}); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+
+	if err := c.Convert(&x, &y, AllowDifferentFieldTypeNames, nil); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if !reflect.DeepEqual(y, A{"bar", 1, ""}) {
+		t.Errorf("unexpected result: %#v", y)
+	}
+}
+
+func TestConverter_MapsStringArraysWithMappingKey(t *testing.T) {
+	type A struct {
+		Foo   string `json:"test"`
+		Baz   int
+		Other string
+	}
+	c := NewConverter(DefaultNameFunc)
+	c.Debug = testLogger(t)
+	if err := c.RegisterConversionFunc(func(input *[]string, out *string, s Scope) error {
+		if len(*input) == 0 {
+			*out = ""
+		}
+		*out = (*input)[0]
+		return nil
+	}); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+
+	x := map[string][]string{
+		"Foo":  {"bar"},
+		"test": {"baz"},
+	}
+	y := A{"", 0, ""}
+
+	if err := c.Convert(&x, &y, AllowDifferentFieldTypeNames|IgnoreMissingFields, &Meta{}); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if !reflect.DeepEqual(y, A{"bar", 0, ""}) {
+		t.Errorf("unexpected result: %#v", y)
+	}
+
+	mapping := func(key string, sourceTag, destTag reflect.StructTag) (source string, dest string) {
+		if s := destTag.Get("json"); len(s) > 0 {
+			return strings.SplitN(s, ",", 2)[0], key
+		}
+		return key, key
+	}
+
+	if err := c.Convert(&x, &y, AllowDifferentFieldTypeNames|IgnoreMissingFields, &Meta{KeyNameMapping: mapping}); err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if !reflect.DeepEqual(y, A{"baz", 0, ""}) {
+		t.Errorf("unexpected result: %#v", y)
+	}
+}
+
+func TestConverter_fuzz(t *testing.T) {
+	// Use the same types from the scheme test.
+	table := []struct {
+		from, to, check interface{}
+	}{
+		{&TestType1{}, &ExternalTestType1{}, &TestType1{}},
+		{&ExternalTestType1{}, &TestType1{}, &ExternalTestType1{}},
+	}
+
+	f := fuzz.New().NilChance(.5).NumElements(0, 100)
+	c := NewConverter(DefaultNameFunc)
+	c.nameFunc = func(t reflect.Type) string {
+		// Hide the fact that we don't have separate packages for these things.
+		return map[reflect.Type]string{
+			reflect.TypeOf(TestType1{}):         "TestType1",
+			reflect.TypeOf(ExternalTestType1{}): "TestType1",
+			reflect.TypeOf(TestType2{}):         "TestType2",
+			reflect.TypeOf(ExternalTestType2{}): "TestType2",
+		}[t]
+	}
+	c.Debug = testLogger(t)
+
+	for i, item := range table {
+		for j := 0; j < *fuzzIters; j++ {
+			f.Fuzz(item.from)
+			err := c.Convert(item.from, item.to, 0, nil)
+			if err != nil {
+				t.Errorf("(%v, %v): unexpected error: %v", i, j, err)
+				continue
+			}
+			err = c.Convert(item.to, item.check, 0, nil)
+			if err != nil {
+				t.Errorf("(%v, %v): unexpected error: %v", i, j, err)
+				continue
+			}
+			if e, a := item.from, item.check; !reflect.DeepEqual(e, a) {
+				t.Errorf("(%v, %v): unexpected diff: %v", i, j, diff.ObjectDiff(e, a))
+			}
+		}
+	}
+}
+
+func TestConverter_MapElemAddr(t *testing.T) {
+	type Foo struct {
+		A map[int]int
+	}
+	type Bar struct {
+		A map[string]string
+	}
+	c := NewConverter(DefaultNameFunc)
+	c.Debug = testLogger(t)
+	err := c.RegisterConversionFunc(
+		func(in *int, out *string, s Scope) error {
+			*out = fmt.Sprintf("%v", *in)
+			return nil
+		},
+	)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	err = c.RegisterConversionFunc(
+		func(in *string, out *int, s Scope) error {
+			if str, err := strconv.Atoi(*in); err != nil {
+				return err
+			} else {
+				*out = str
+				return nil
+			}
+		},
+	)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	f := fuzz.New().NilChance(0).NumElements(3, 3)
+	first := Foo{}
+	second := Bar{}
+	f.Fuzz(&first)
+	err = c.Convert(&first, &second, AllowDifferentFieldTypeNames, nil)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	third := Foo{}
+	err = c.Convert(&second, &third, AllowDifferentFieldTypeNames, nil)
+	if e, a := first, third; !reflect.DeepEqual(e, a) {
+		t.Errorf("Unexpected diff: %v", diff.ObjectDiff(e, a))
+	}
+}
+
+func TestConverter_tags(t *testing.T) {
+	type Foo struct {
+		A string `test:"foo"`
+	}
+	type Bar struct {
+		A string `test:"bar"`
+	}
+	c := NewConverter(DefaultNameFunc)
+	c.Debug = testLogger(t)
+	err := c.RegisterConversionFunc(
+		func(in *string, out *string, s Scope) error {
+			if e, a := "foo", s.SrcTag().Get("test"); e != a {
+				t.Errorf("expected %v, got %v", e, a)
+			}
+			if e, a := "bar", s.DestTag().Get("test"); e != a {
+				t.Errorf("expected %v, got %v", e, a)
+			}
+			return nil
+		},
+	)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	err = c.Convert(&Foo{}, &Bar{}, AllowDifferentFieldTypeNames, nil)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+}
+
+func TestConverter_meta(t *testing.T) {
+	type Foo struct{ A string }
+	type Bar struct{ A string }
+	c := NewConverter(DefaultNameFunc)
+	c.Debug = testLogger(t)
+	checks := 0
+	err := c.RegisterConversionFunc(
+		func(in *Foo, out *Bar, s Scope) error {
+			if s.Meta() == nil {
+				t.Errorf("Meta did not get passed!")
+			}
+			checks++
+			s.Convert(&in.A, &out.A, 0)
+			return nil
+		},
+	)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	err = c.RegisterConversionFunc(
+		func(in *string, out *string, s Scope) error {
+			if s.Meta() == nil {
+				t.Errorf("Meta did not get passed a second time!")
+			}
+			checks++
+			return nil
+		},
+	)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	err = c.Convert(&Foo{}, &Bar{}, 0, &Meta{})
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+	if checks != 2 {
+		t.Errorf("Registered functions did not get called.")
+	}
+}
+
+func TestConverter_flags(t *testing.T) {
+	type Foo struct{ A string }
+	type Bar struct{ A string }
+	table := []struct {
+		from, to      interface{}
+		flags         FieldMatchingFlags
+		shouldSucceed bool
+	}{
+		// Check that DestFromSource allows extra fields only in source.
+		{
+			from:          &struct{ A string }{},
+			to:            &struct{ A, B string }{},
+			flags:         DestFromSource,
+			shouldSucceed: false,
+		}, {
+			from:          &struct{ A, B string }{},
+			to:            &struct{ A string }{},
+			flags:         DestFromSource,
+			shouldSucceed: true,
+		},
+
+		// Check that SourceToDest allows for extra fields only in dest.
+		{
+			from:          &struct{ A string }{},
+			to:            &struct{ A, B string }{},
+			flags:         SourceToDest,
+			shouldSucceed: true,
+		}, {
+			from:          &struct{ A, B string }{},
+			to:            &struct{ A string }{},
+			flags:         SourceToDest,
+			shouldSucceed: false,
+		},
+
+		// Check that IgnoreMissingFields makes the above failure cases pass.
+		{
+			from:          &struct{ A string }{},
+			to:            &struct{ A, B string }{},
+			flags:         DestFromSource | IgnoreMissingFields,
+			shouldSucceed: true,
+		}, {
+			from:          &struct{ A, B string }{},
+			to:            &struct{ A string }{},
+			flags:         SourceToDest | IgnoreMissingFields,
+			shouldSucceed: true,
+		},
+
+		// Check that the field type name must match unless
+		// AllowDifferentFieldTypeNames is specified.
+		{
+			from:          &struct{ A, B Foo }{},
+			to:            &struct{ A Bar }{},
+			flags:         DestFromSource,
+			shouldSucceed: false,
+		}, {
+			from:          &struct{ A Foo }{},
+			to:            &struct{ A, B Bar }{},
+			flags:         SourceToDest,
+			shouldSucceed: false,
+		}, {
+			from:          &struct{ A, B Foo }{},
+			to:            &struct{ A Bar }{},
+			flags:         DestFromSource | AllowDifferentFieldTypeNames,
+			shouldSucceed: true,
+		}, {
+			from:          &struct{ A Foo }{},
+			to:            &struct{ A, B Bar }{},
+			flags:         SourceToDest | AllowDifferentFieldTypeNames,
+			shouldSucceed: true,
+		},
+	}
+	f := fuzz.New().NilChance(.5).NumElements(0, 100)
+	c := NewConverter(DefaultNameFunc)
+	c.Debug = testLogger(t)
+
+	for i, item := range table {
+		for j := 0; j < *fuzzIters; j++ {
+			f.Fuzz(item.from)
+			err := c.Convert(item.from, item.to, item.flags, nil)
+			if item.shouldSucceed && err != nil {
+				t.Errorf("(%v, %v): unexpected error: %v", i, j, err)
+				continue
+			}
+			if !item.shouldSucceed && err == nil {
+				t.Errorf("(%v, %v): unexpected non-error", i, j)
+				continue
+			}
+		}
+	}
+}
+
+func TestConverter_FieldRename(t *testing.T) {
+	type WeirdMeta struct {
+		Name string
+		Type string
+	}
+	type NameMeta struct {
+		Name string
+	}
+	type TypeMeta struct {
+		Type string
+	}
+	type A struct {
+		WeirdMeta
+	}
+	type B struct {
+		TypeMeta
+		NameMeta
+	}
+
+	c := NewConverter(DefaultNameFunc)
+	err := c.SetStructFieldCopy(WeirdMeta{}, "WeirdMeta", TypeMeta{}, "TypeMeta")
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	err = c.SetStructFieldCopy(WeirdMeta{}, "WeirdMeta", NameMeta{}, "NameMeta")
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	err = c.SetStructFieldCopy(TypeMeta{}, "TypeMeta", WeirdMeta{}, "WeirdMeta")
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	err = c.SetStructFieldCopy(NameMeta{}, "NameMeta", WeirdMeta{}, "WeirdMeta")
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	c.Debug = testLogger(t)
+
+	aVal := &A{
+		WeirdMeta: WeirdMeta{
+			Name: "Foo",
+			Type: "Bar",
+		},
+	}
+
+	bVal := &B{
+		TypeMeta: TypeMeta{"Bar"},
+		NameMeta: NameMeta{"Foo"},
+	}
+
+	table := map[string]struct {
+		from, to, expect interface{}
+		flags            FieldMatchingFlags
+	}{
+		"to": {
+			aVal,
+			&B{},
+			bVal,
+			AllowDifferentFieldTypeNames | SourceToDest | IgnoreMissingFields,
+		},
+		"from": {
+			bVal,
+			&A{},
+			aVal,
+			AllowDifferentFieldTypeNames | SourceToDest,
+		},
+		"toDestFirst": {
+			aVal,
+			&B{},
+			bVal,
+			AllowDifferentFieldTypeNames,
+		},
+		"fromDestFirst": {
+			bVal,
+			&A{},
+			aVal,
+			AllowDifferentFieldTypeNames | IgnoreMissingFields,
+		},
+	}
+
+	for name, item := range table {
+		err := c.Convert(item.from, item.to, item.flags, nil)
+		if err != nil {
+			t.Errorf("%v: unexpected error: %v", name, err)
+			continue
+		}
+		if e, a := item.expect, item.to; !reflect.DeepEqual(e, a) {
+			t.Errorf("%v: unexpected diff: %v", name, diff.ObjectDiff(e, a))
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/conversion/deep_copy_test.go

@@ -0,0 +1,161 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+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 conversion
+
+import (
+	"math/rand"
+	"reflect"
+	"testing"
+
+	"github.com/google/gofuzz"
+)
+
+func TestDeepCopy(t *testing.T) {
+	semantic := EqualitiesOrDie()
+	f := fuzz.New().NilChance(.5).NumElements(0, 100)
+	table := []interface{}{
+		map[string]string{},
+		int(5),
+		"hello world",
+		struct {
+			A, B, C struct {
+				D map[string]int
+			}
+			X []int
+			Y []byte
+		}{},
+	}
+	for _, obj := range table {
+		obj2, err := NewCloner().DeepCopy(obj)
+		if err != nil {
+			t.Errorf("Error: couldn't copy %#v", obj)
+			continue
+		}
+		if e, a := obj, obj2; !semantic.DeepEqual(e, a) {
+			t.Errorf("expected %#v\ngot %#v", e, a)
+		}
+
+		obj3 := reflect.New(reflect.TypeOf(obj)).Interface()
+		f.Fuzz(obj3)
+		obj4, err := NewCloner().DeepCopy(obj3)
+		if err != nil {
+			t.Errorf("Error: couldn't copy %#v", obj)
+			continue
+		}
+		if e, a := obj3, obj4; !semantic.DeepEqual(e, a) {
+			t.Errorf("expected %#v\ngot %#v", e, a)
+		}
+		f.Fuzz(obj3)
+	}
+}
+
+func copyOrDie(t *testing.T, in interface{}) interface{} {
+	out, err := NewCloner().DeepCopy(in)
+	if err != nil {
+		t.Fatalf("DeepCopy failed: %#q: %v", in, err)
+	}
+	return out
+}
+
+func TestDeepCopySliceSeparate(t *testing.T) {
+	x := []int{5}
+	y := copyOrDie(t, x).([]int)
+	x[0] = 3
+	if y[0] == 3 {
+		t.Errorf("deep copy wasn't deep: %#q %#q", x, y)
+	}
+}
+
+func TestDeepCopyArraySeparate(t *testing.T) {
+	x := [1]int{5}
+	y := copyOrDie(t, x).([1]int)
+	x[0] = 3
+	if y[0] == 3 {
+		t.Errorf("deep copy wasn't deep: %#q %#q", x, y)
+	}
+}
+
+func TestDeepCopyMapSeparate(t *testing.T) {
+	x := map[string]int{"foo": 5}
+	y := copyOrDie(t, x).(map[string]int)
+	x["foo"] = 3
+	if y["foo"] == 3 {
+		t.Errorf("deep copy wasn't deep: %#q %#q", x, y)
+	}
+}
+
+func TestDeepCopyPointerSeparate(t *testing.T) {
+	z := 5
+	x := &z
+	y := copyOrDie(t, x).(*int)
+	*x = 3
+	if *y == 3 {
+		t.Errorf("deep copy wasn't deep: %#q %#q", x, y)
+	}
+}
+
+func TestDeepCopyStruct(t *testing.T) {
+	type Foo struct {
+		A int
+	}
+	type Bar struct {
+		Foo
+		F *Foo
+	}
+	a := &Bar{Foo{1}, &Foo{2}}
+	b := copyOrDie(t, a).(*Bar)
+	a.A = 3
+	a.F.A = 4
+
+	if b.A != 1 || b.F.A != 2 {
+		t.Errorf("deep copy wasn't deep: %#v, %#v", a, b)
+	}
+}
+
+var result interface{}
+
+func BenchmarkDeepCopy(b *testing.B) {
+	table := []interface{}{
+		map[string]string{},
+		int(5),
+		"hello world",
+		struct {
+			A, B, C struct {
+				D map[string]int
+			}
+			X []int
+			Y []byte
+		}{},
+	}
+
+	f := fuzz.New().RandSource(rand.NewSource(1)).NilChance(.5).NumElements(0, 100)
+	for i := range table {
+		out := table[i]
+		obj := reflect.New(reflect.TypeOf(out)).Interface()
+		f.Fuzz(obj)
+		table[i] = obj
+	}
+
+	b.ResetTimer()
+	var r interface{}
+	for i := 0; i < b.N; i++ {
+		for j := range table {
+			r, _ = NewCloner().DeepCopy(table[j])
+		}
+	}
+	result = r
+}

vendor/k8s.io/apimachinery/pkg/conversion/doc.go

@@ -21,4 +21,4 @@ limitations under the License.
 // but for the fields which did not change, copying is automated. This makes it
 // easy to modify the structures you use in memory without affecting the format
 // you store on disk or respond to in your external API calls.
-package conversion
+package conversion // import "k8s.io/apimachinery/pkg/conversion"

vendor/k8s.io/apimachinery/pkg/conversion/helper_test.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+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 conversion
+
+import "testing"
+
+func TestInvalidPtrValueKind(t *testing.T) {
+	var simple interface{}
+	switch obj := simple.(type) {
+	default:
+		_, err := EnforcePtr(obj)
+		if err == nil {
+			t.Errorf("Expected error on invalid kind")
+		}
+	}
+}
+
+func TestEnforceNilPtr(t *testing.T) {
+	var nilPtr *struct{}
+	_, err := EnforcePtr(nilPtr)
+	if err == nil {
+		t.Errorf("Expected error on nil pointer")
+	}
+}

vendor/k8s.io/apimachinery/pkg/conversion/queryparams/convert_test.go

@@ -0,0 +1,212 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+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 queryparams_test
+
+import (
+	"net/url"
+	"reflect"
+	"testing"
+	"time"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/conversion/queryparams"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+type namedString string
+type namedBool bool
+
+type bar struct {
+	Float1   float32 `json:"float1"`
+	Float2   float64 `json:"float2"`
+	Int1     int64   `json:"int1,omitempty"`
+	Int2     int32   `json:"int2,omitempty"`
+	Int3     int16   `json:"int3,omitempty"`
+	Str1     string  `json:"str1,omitempty"`
+	Ignored  int
+	Ignored2 string
+}
+
+func (obj *bar) GetObjectKind() schema.ObjectKind { return schema.EmptyObjectKind }
+
+type foo struct {
+	Str       string            `json:"str"`
+	Integer   int               `json:"integer,omitempty"`
+	Slice     []string          `json:"slice,omitempty"`
+	Boolean   bool              `json:"boolean,omitempty"`
+	NamedStr  namedString       `json:"namedStr,omitempty"`
+	NamedBool namedBool         `json:"namedBool,omitempty"`
+	Foobar    bar               `json:"foobar,omitempty"`
+	Testmap   map[string]string `json:"testmap,omitempty"`
+}
+
+func (obj *foo) GetObjectKind() schema.ObjectKind { return schema.EmptyObjectKind }
+
+type baz struct {
+	Ptr  *int  `json:"ptr"`
+	Bptr *bool `json:"bptr,omitempty"`
+}
+
+func (obj *baz) GetObjectKind() schema.ObjectKind { return schema.EmptyObjectKind }
+
+// childStructs tests some of the types we serialize to query params for log API calls
+// notably, the nested time struct
+type childStructs struct {
+	Container    string       `json:"container,omitempty"`
+	Follow       bool         `json:"follow,omitempty"`
+	Previous     bool         `json:"previous,omitempty"`
+	SinceSeconds *int64       `json:"sinceSeconds,omitempty"`
+	SinceTime    *metav1.Time `json:"sinceTime,omitempty"`
+	EmptyTime    *metav1.Time `json:"emptyTime"`
+}
+
+func (obj *childStructs) GetObjectKind() schema.ObjectKind { return schema.EmptyObjectKind }
+
+func validateResult(t *testing.T, input interface{}, actual, expected url.Values) {
+	local := url.Values{}
+	for k, v := range expected {
+		local[k] = v
+	}
+	for k, v := range actual {
+		if ev, ok := local[k]; !ok || !reflect.DeepEqual(ev, v) {
+			if !ok {
+				t.Errorf("%#v: actual value key %s not found in expected map", input, k)
+			} else {
+				t.Errorf("%#v: values don't match: actual: %#v, expected: %#v", input, v, ev)
+			}
+		}
+		delete(local, k)
+	}
+	if len(local) > 0 {
+		t.Errorf("%#v: expected map has keys that were not found in actual map: %#v", input, local)
+	}
+}
+
+func TestConvert(t *testing.T) {
+	sinceSeconds := int64(123)
+	sinceTime := metav1.Date(2000, 1, 1, 12, 34, 56, 0, time.UTC)
+
+	tests := []struct {
+		input    interface{}
+		expected url.Values
+	}{
+		{
+			input: &foo{
+				Str: "hello",
+			},
+			expected: url.Values{"str": {"hello"}},
+		},
+		{
+			input: &foo{
+				Str:     "test string",
+				Slice:   []string{"one", "two", "three"},
+				Integer: 234,
+				Boolean: true,
+			},
+			expected: url.Values{"str": {"test string"}, "slice": {"one", "two", "three"}, "integer": {"234"}, "boolean": {"true"}},
+		},
+		{
+			input: &foo{
+				Str:       "named types",
+				NamedStr:  "value1",
+				NamedBool: true,
+			},
+			expected: url.Values{"str": {"named types"}, "namedStr": {"value1"}, "namedBool": {"true"}},
+		},
+		{
+			input: &foo{
+				Str: "don't ignore embedded struct",
+				Foobar: bar{
+					Float1: 5.0,
+				},
+			},
+			expected: url.Values{"str": {"don't ignore embedded struct"}, "float1": {"5"}, "float2": {"0"}},
+		},
+		{
+			// Ignore untagged fields
+			input: &bar{
+				Float1:   23.5,
+				Float2:   100.7,
+				Int1:     1,
+				Int2:     2,
+				Int3:     3,
+				Ignored:  1,
+				Ignored2: "ignored",
+			},
+			expected: url.Values{"float1": {"23.5"}, "float2": {"100.7"}, "int1": {"1"}, "int2": {"2"}, "int3": {"3"}},
+		},
+		{
+			// include fields that are not tagged omitempty
+			input: &foo{
+				NamedStr: "named str",
+			},
+			expected: url.Values{"str": {""}, "namedStr": {"named str"}},
+		},
+		{
+			input: &baz{
+				Ptr:  intp(5),
+				Bptr: boolp(true),
+			},
+			expected: url.Values{"ptr": {"5"}, "bptr": {"true"}},
+		},
+		{
+			input: &baz{
+				Bptr: boolp(true),
+			},
+			expected: url.Values{"ptr": {""}, "bptr": {"true"}},
+		},
+		{
+			input: &baz{
+				Ptr: intp(5),
+			},
+			expected: url.Values{"ptr": {"5"}},
+		},
+		{
+			input: &childStructs{
+				Container:    "mycontainer",
+				Follow:       true,
+				Previous:     true,
+				SinceSeconds: &sinceSeconds,
+				SinceTime:    &sinceTime, // test a custom marshaller
+				EmptyTime:    nil,        // test a nil custom marshaller without omitempty
+			},
+			expected: url.Values{"container": {"mycontainer"}, "follow": {"true"}, "previous": {"true"}, "sinceSeconds": {"123"}, "sinceTime": {"2000-01-01T12:34:56Z"}, "emptyTime": {""}},
+		},
+		{
+			input: &childStructs{
+				Container:    "mycontainer",
+				Follow:       true,
+				Previous:     true,
+				SinceSeconds: &sinceSeconds,
+				SinceTime:    nil, // test a nil custom marshaller with omitempty
+			},
+			expected: url.Values{"container": {"mycontainer"}, "follow": {"true"}, "previous": {"true"}, "sinceSeconds": {"123"}, "emptyTime": {""}},
+		},
+	}
+
+	for _, test := range tests {
+		result, err := queryparams.Convert(test.input)
+		if err != nil {
+			t.Errorf("Unexpected error while converting %#v: %v", test.input, err)
+		}
+		validateResult(t, test.input, result, test.expected)
+	}
+}
+
+func intp(n int) *int { return &n }
+
+func boolp(b bool) *bool { return &b }

vendor/k8s.io/apimachinery/pkg/conversion/queryparams/doc.go

@@ -16,4 +16,4 @@ limitations under the License.
 
 // Package queryparams provides conversion from versioned
 // runtime objects to URL query values
-package queryparams
+package queryparams // import "k8s.io/apimachinery/pkg/conversion/queryparams"

vendor/k8s.io/apimachinery/pkg/conversion/unstructured/doc.go

@@ -16,4 +16,4 @@ limitations under the License.
 
 // Package unstructured provides conversion from runtime objects
 // to map[string]interface{} representation.
-package unstructured
+package unstructured // import "k8s.io/apimachinery/pkg/conversion/unstructured"

vendor/k8s.io/apimachinery/pkg/conversion/unstructured/testing/BUILD

@@ -0,0 +1,28 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_test")
+
+go_test(
+    name = "go_default_test",
+    srcs = ["converter_test.go"],
+    deps = [
+        "//vendor/github.com/stretchr/testify/assert:go_default_library",
+        "//vendor/github.com/stretchr/testify/require:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/conversion/unstructured:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/diff:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/json:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/k8s.io/apimachinery/pkg/conversion/unstructured/testing/converter_test.go

@@ -0,0 +1,539 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+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.
+*/
+
+// These tests are in a separate package to break cyclic dependency in tests.
+// Unstructured type depends on unstructured converter package but we want to test how the converter handles
+// the Unstructured type so we need to import both.
+
+package testing
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"testing"
+
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	conversionunstructured "k8s.io/apimachinery/pkg/conversion/unstructured"
+	"k8s.io/apimachinery/pkg/util/diff"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// Definte a number of test types.
+type A struct {
+	A int    `json:"aa,omitempty"`
+	B string `json:"ab,omitempty"`
+	C bool   `json:"ac,omitempty"`
+}
+
+type B struct {
+	A A                 `json:"ba"`
+	B string            `json:"bb"`
+	C map[string]string `json:"bc"`
+	D []string          `json:"bd"`
+}
+
+type C struct {
+	A []A `json:"ca"`
+	B `json:",inline"`
+	C string         `json:"cc"`
+	D *int64         `json:"cd"`
+	E map[string]int `json:"ce"`
+	F []bool         `json:"cf"`
+	G []int          `json:"cg"`
+	H float32        `json:"ch"`
+	I []interface{}  `json:"ci"`
+}
+
+type D struct {
+	A []interface{} `json:"da"`
+}
+
+type E struct {
+	A interface{} `json:"ea"`
+}
+
+type F struct {
+	A string            `json:"fa"`
+	B map[string]string `json:"fb"`
+	C []A               `json:"fc"`
+	D int               `json:"fd"`
+	E float32           `json:"fe"`
+	F []string          `json:"ff"`
+	G []int             `json:"fg"`
+	H []bool            `json:"fh"`
+	I []float32         `json:"fi"`
+}
+
+type G struct {
+	CustomValue1   CustomValue    `json:"customValue1"`
+	CustomValue2   *CustomValue   `json:"customValue2"`
+	CustomPointer1 CustomPointer  `json:"customPointer1"`
+	CustomPointer2 *CustomPointer `json:"customPointer2"`
+}
+
+type CustomValue struct {
+	data []byte
+}
+
+// MarshalJSON has a value receiver on this type.
+func (c CustomValue) MarshalJSON() ([]byte, error) {
+	return c.data, nil
+}
+
+type CustomPointer struct {
+	data []byte
+}
+
+// MarshalJSON has a pointer receiver on this type.
+func (c *CustomPointer) MarshalJSON() ([]byte, error) {
+	return c.data, nil
+}
+
+func doRoundTrip(t *testing.T, item interface{}) {
+	data, err := json.Marshal(item)
+	if err != nil {
+		t.Errorf("Error when marshaling object: %v", err)
+		return
+	}
+
+	unstr := make(map[string]interface{})
+	err = json.Unmarshal(data, &unstr)
+	if err != nil {
+		t.Errorf("Error when unmarshaling to unstructured: %v", err)
+		return
+	}
+
+	data, err = json.Marshal(unstr)
+	if err != nil {
+		t.Errorf("Error when marshaling unstructured: %v", err)
+		return
+	}
+	unmarshalledObj := reflect.New(reflect.TypeOf(item).Elem()).Interface()
+	err = json.Unmarshal(data, &unmarshalledObj)
+	if err != nil {
+		t.Errorf("Error when unmarshaling to object: %v", err)
+		return
+	}
+	if !reflect.DeepEqual(item, unmarshalledObj) {
+		t.Errorf("Object changed during JSON operations, diff: %v", diff.ObjectReflectDiff(item, unmarshalledObj))
+		return
+	}
+
+	newUnstr, err := conversionunstructured.DefaultConverter.ToUnstructured(item)
+	if err != nil {
+		t.Errorf("ToUnstructured failed: %v", err)
+		return
+	}
+
+	newObj := reflect.New(reflect.TypeOf(item).Elem()).Interface()
+	err = conversionunstructured.DefaultConverter.FromUnstructured(newUnstr, newObj)
+	if err != nil {
+		t.Errorf("FromUnstructured failed: %v", err)
+		return
+	}
+
+	if !reflect.DeepEqual(item, newObj) {
+		t.Errorf("Object changed, diff: %v", diff.ObjectReflectDiff(item, newObj))
+	}
+}
+
+func TestRoundTrip(t *testing.T) {
+	intVal := int64(42)
+	testCases := []struct {
+		obj interface{}
+	}{
+		{
+			obj: &unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"apiVersion": "v1",
+					"kind":       "Foo",
+					"metadata": map[string]interface{}{
+						"name": "foo1",
+					},
+				},
+			},
+		},
+		{
+			// This (among others) tests nil map, slice and pointer.
+			obj: &C{
+				C: "ccc",
+			},
+		},
+		{
+			// This (among others) tests empty map and slice.
+			obj: &C{
+				A: []A{},
+				C: "ccc",
+				E: map[string]int{},
+				I: []interface{}{},
+			},
+		},
+		{
+			obj: &C{
+				A: []A{
+					{
+						A: 1,
+						B: "11",
+						C: true,
+					},
+					{
+						A: 2,
+						B: "22",
+						C: false,
+					},
+				},
+				B: B{
+					A: A{
+						A: 3,
+						B: "33",
+					},
+					B: "bbb",
+					C: map[string]string{
+						"k1": "v1",
+						"k2": "v2",
+					},
+					D: []string{"s1", "s2"},
+				},
+				C: "ccc",
+				D: &intVal,
+				E: map[string]int{
+					"k1": 1,
+					"k2": 2,
+				},
+				F: []bool{true, false, false},
+				G: []int{1, 2, 5},
+				H: 3.3,
+				I: []interface{}{nil, nil, nil},
+			},
+		},
+		{
+			// Test slice of interface{} with empty slices.
+			obj: &D{
+				A: []interface{}{[]interface{}{}, []interface{}{}},
+			},
+		},
+		{
+			// Test slice of interface{} with different values.
+			obj: &D{
+				A: []interface{}{3.0, "3.0", nil},
+			},
+		},
+	}
+
+	for i := range testCases {
+		doRoundTrip(t, testCases[i].obj)
+		if t.Failed() {
+			break
+		}
+	}
+}
+
+// Verifies that:
+// 1) serialized json -> object
+// 2) serialized json -> map[string]interface{} -> object
+// produces the same object.
+func doUnrecognized(t *testing.T, jsonData string, item interface{}, expectedErr error) {
+	unmarshalledObj := reflect.New(reflect.TypeOf(item).Elem()).Interface()
+	err := json.Unmarshal([]byte(jsonData), &unmarshalledObj)
+	if (err != nil) != (expectedErr != nil) {
+		t.Errorf("Unexpected error when unmarshaling to object: %v, expected: %v", err, expectedErr)
+		return
+	}
+
+	unstr := make(map[string]interface{})
+	err = json.Unmarshal([]byte(jsonData), &unstr)
+	if err != nil {
+		t.Errorf("Error when unmarshaling to unstructured: %v", err)
+		return
+	}
+	newObj := reflect.New(reflect.TypeOf(item).Elem()).Interface()
+	err = conversionunstructured.DefaultConverter.FromUnstructured(unstr, newObj)
+	if (err != nil) != (expectedErr != nil) {
+		t.Errorf("Unexpected error in FromUnstructured: %v, expected: %v", err, expectedErr)
+	}
+
+	if expectedErr == nil && !reflect.DeepEqual(unmarshalledObj, newObj) {
+		t.Errorf("Object changed, diff: %v", diff.ObjectReflectDiff(unmarshalledObj, newObj))
+	}
+}
+
+func TestUnrecognized(t *testing.T) {
+	testCases := []struct {
+		data string
+		obj  interface{}
+		err  error
+	}{
+		{
+			data: "{\"da\":[3.0,\"3.0\",null]}",
+			obj:  &D{},
+		},
+		{
+			data: "{\"ea\":[3.0,\"3.0\",null]}",
+			obj:  &E{},
+		},
+		{
+			data: "{\"ea\":[null,null,null]}",
+			obj:  &E{},
+		},
+		{
+			data: "{\"ea\":[[],[null]]}",
+			obj:  &E{},
+		},
+		{
+			data: "{\"ea\":{\"a\":[],\"b\":null}}",
+			obj:  &E{},
+		},
+		{
+			data: "{\"fa\":\"fa\",\"fb\":{\"a\":\"a\"}}",
+			obj:  &F{},
+		},
+		{
+			data: "{\"fa\":\"fa\",\"fb\":{\"a\":null}}",
+			obj:  &F{},
+		},
+		{
+			data: "{\"fc\":[null]}",
+			obj:  &F{},
+		},
+		{
+			data: "{\"fc\":[{\"aa\":123,\"ab\":\"bbb\"}]}",
+			obj:  &F{},
+		},
+		{
+			// Only unknown fields
+			data: "{\"fx\":[{\"aa\":123,\"ab\":\"bbb\"}],\"fz\":123}",
+			obj:  &F{},
+		},
+		{
+			data: "{\"fc\":[{\"aa\":\"aaa\",\"ab\":\"bbb\"}]}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal string into Go value of type int"),
+		},
+		{
+			data: "{\"fd\":123,\"fe\":3.5}",
+			obj:  &F{},
+		},
+		{
+			data: "{\"ff\":[\"abc\"],\"fg\":[123],\"fh\":[true,false]}",
+			obj:  &F{},
+		},
+		{
+			// Invalid string data
+			data: "{\"fa\":123}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number into Go value of type string"),
+		},
+		{
+			// Invalid string data
+			data: "{\"fa\":13.5}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number into Go value of type string"),
+		},
+		{
+			// Invalid string data
+			data: "{\"fa\":true}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal bool into Go value of type string"),
+		},
+		{
+			// Invalid []string data
+			data: "{\"ff\":123}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number into Go value of type []string"),
+		},
+		{
+			// Invalid []string data
+			data: "{\"ff\":3.5}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number into Go value of type []string"),
+		},
+		{
+			// Invalid []string data
+			data: "{\"ff\":[123,345]}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number into Go value of type string"),
+		},
+		{
+			// Invalid []int data
+			data: "{\"fg\":123}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number into Go value of type []int"),
+		},
+		{
+			// Invalid []int data
+			data: "{\"fg\":\"abc\"}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal string into Go value of type []int"),
+		},
+		{
+			// Invalid []int data
+			data: "{\"fg\":[\"abc\"]}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal string into Go value of type int"),
+		},
+		{
+			// Invalid []int data
+			data: "{\"fg\":[3.5]}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number 3.5 into Go value of type int"),
+		},
+		{
+			// Invalid []int data
+			data: "{\"fg\":[true,false]}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number 3.5 into Go value of type int"),
+		},
+		{
+			// Invalid []bool data
+			data: "{\"fh\":123}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number into Go value of type []bool"),
+		},
+		{
+			// Invalid []bool data
+			data: "{\"fh\":\"abc\"}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal string into Go value of type []bool"),
+		},
+		{
+			// Invalid []bool data
+			data: "{\"fh\":[\"abc\"]}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal string into Go value of type bool"),
+		},
+		{
+			// Invalid []bool data
+			data: "{\"fh\":[3.5]}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number into Go value of type bool"),
+		},
+		{
+			// Invalid []bool data
+			data: "{\"fh\":[123]}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number into Go value of type bool"),
+		},
+		{
+			// Invalid []float data
+			data: "{\"fi\":123}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal number into Go value of type []float32"),
+		},
+		{
+			// Invalid []float data
+			data: "{\"fi\":\"abc\"}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal string into Go value of type []float32"),
+		},
+		{
+			// Invalid []float data
+			data: "{\"fi\":[\"abc\"]}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal string into Go value of type float32"),
+		},
+		{
+			// Invalid []float data
+			data: "{\"fi\":[true]}",
+			obj:  &F{},
+			err:  fmt.Errorf("json: cannot unmarshal bool into Go value of type float32"),
+		},
+	}
+
+	for i := range testCases {
+		doUnrecognized(t, testCases[i].data, testCases[i].obj, testCases[i].err)
+		if t.Failed() {
+			break
+		}
+	}
+}
+
+func TestFloatIntConversion(t *testing.T) {
+	unstr := map[string]interface{}{"fd": float64(3)}
+
+	var obj F
+	if err := conversionunstructured.DefaultConverter.FromUnstructured(unstr, &obj); err != nil {
+		t.Errorf("Unexpected error in FromUnstructured: %v", err)
+	}
+
+	data, err := json.Marshal(unstr)
+	if err != nil {
+		t.Fatalf("Error when marshaling unstructured: %v", err)
+	}
+	var unmarshalled F
+	if err := json.Unmarshal(data, &unmarshalled); err != nil {
+		t.Fatalf("Error when unmarshaling to object: %v", err)
+	}
+
+	if !reflect.DeepEqual(obj, unmarshalled) {
+		t.Errorf("Incorrect conversion, diff: %v", diff.ObjectReflectDiff(obj, unmarshalled))
+	}
+}
+
+func TestCustomToUnstructured(t *testing.T) {
+	testcases := []struct {
+		Data     string
+		Expected interface{}
+	}{
+		{Data: `null`, Expected: nil},
+		{Data: `true`, Expected: true},
+		{Data: `false`, Expected: false},
+		{Data: `[]`, Expected: []interface{}{}},
+		{Data: `[1]`, Expected: []interface{}{int64(1)}},
+		{Data: `{}`, Expected: map[string]interface{}{}},
+		{Data: `{"a":1}`, Expected: map[string]interface{}{"a": int64(1)}},
+		{Data: `0`, Expected: int64(0)},
+		{Data: `0.0`, Expected: float64(0)},
+	}
+
+	for _, tc := range testcases {
+		tc := tc
+		t.Run(tc.Data, func(t *testing.T) {
+			t.Parallel()
+			result, err := conversionunstructured.DefaultConverter.ToUnstructured(&G{
+				CustomValue1:   CustomValue{data: []byte(tc.Data)},
+				CustomValue2:   &CustomValue{data: []byte(tc.Data)},
+				CustomPointer1: CustomPointer{data: []byte(tc.Data)},
+				CustomPointer2: &CustomPointer{data: []byte(tc.Data)},
+			})
+			require.NoError(t, err)
+			for field, fieldResult := range result {
+				assert.Equal(t, tc.Expected, fieldResult, field)
+			}
+		})
+	}
+}
+
+func TestCustomToUnstructuredTopLevel(t *testing.T) {
+	// Only objects are supported at the top level
+	topLevelCases := []interface{}{
+		&CustomValue{data: []byte(`{"a":1}`)},
+		&CustomPointer{data: []byte(`{"a":1}`)},
+	}
+	expected := map[string]interface{}{"a": int64(1)}
+	for i, obj := range topLevelCases {
+		obj := obj
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			t.Parallel()
+			result, err := conversionunstructured.DefaultConverter.ToUnstructured(obj)
+			require.NoError(t, err)
+			assert.Equal(t, expected, result)
+		})
+	}
+}