vendor files

vendor/k8s.io/apimachinery/pkg/test/BUILD

@@ -0,0 +1,66 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "api_meta_help_test.go",
+        "api_meta_meta_test.go",
+        "apis_meta_v1_unstructed_unstructure_test.go",
+        "runtime_helper_test.go",
+        "runtime_serializer_protobuf_protobuf_test.go",
+        "runtime_unversioned_test.go",
+    ],
+    importpath = "k8s.io/apimachinery/pkg/test",
+    library = ":go_default_library",
+    deps = [
+        "//vendor/github.com/google/gofuzz:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/equality:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/testing:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/testapigroup:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/testapigroup/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer/protobuf:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/diff:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "util.go",
+        "zz_generated.deepcopy.go",
+    ],
+    importpath = "k8s.io/apimachinery/pkg/test",
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/testapigroup:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/testapigroup/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/serializer:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/apimachinery/pkg/test/api_meta_help_test.go

@@ -0,0 +1,331 @@
+/*
+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 test
+
+import (
+	"reflect"
+	"testing"
+
+	fuzz "github.com/google/gofuzz"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/apis/testapigroup"
+	"k8s.io/apimachinery/pkg/apis/testapigroup/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/diff"
+)
+
+func TestIsList(t *testing.T) {
+	tests := []struct {
+		obj    runtime.Object
+		isList bool
+	}{
+		{&testapigroup.CarpList{}, true},
+		{&testapigroup.Carp{}, false},
+	}
+	for _, item := range tests {
+		if e, a := item.isList, meta.IsListType(item.obj); e != a {
+			t.Errorf("%v: Expected %v, got %v", reflect.TypeOf(item.obj), e, a)
+		}
+	}
+}
+
+func TestExtractList(t *testing.T) {
+	list1 := []runtime.Object{
+		&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "1"}},
+		&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "2"}},
+	}
+	list2 := &ListV1{
+		Items: []runtime.RawExtension{
+			{Raw: []byte("foo")},
+			{Raw: []byte("bar")},
+			{Object: &v1.Carp{ObjectMeta: metav1.ObjectMeta{Name: "other"}}},
+		},
+	}
+	list3 := &fakePtrValueList{
+		Items: []*testapigroup.Carp{
+			{ObjectMeta: metav1.ObjectMeta{Name: "1"}},
+			{ObjectMeta: metav1.ObjectMeta{Name: "2"}},
+		},
+	}
+	list4 := &testapigroup.CarpList{
+		Items: []testapigroup.Carp{
+			{ObjectMeta: metav1.ObjectMeta{Name: "1"}},
+			{ObjectMeta: metav1.ObjectMeta{Name: "2"}},
+			{ObjectMeta: metav1.ObjectMeta{Name: "3"}},
+		},
+	}
+
+	testCases := []struct {
+		in    runtime.Object
+		out   []interface{}
+		equal bool
+	}{
+		{
+			in:  &List{},
+			out: []interface{}{},
+		},
+		{
+			in:  &ListV1{},
+			out: []interface{}{},
+		},
+		{
+			in:  &List{Items: list1},
+			out: []interface{}{list1[0], list1[1]},
+		},
+		{
+			in:    list2,
+			out:   []interface{}{&runtime.Unknown{Raw: list2.Items[0].Raw}, &runtime.Unknown{Raw: list2.Items[1].Raw}, list2.Items[2].Object},
+			equal: true,
+		},
+		{
+			in:  list3,
+			out: []interface{}{list3.Items[0], list3.Items[1]},
+		},
+		{
+			in:  list4,
+			out: []interface{}{&list4.Items[0], &list4.Items[1], &list4.Items[2]},
+		},
+	}
+	for i, test := range testCases {
+		list, err := meta.ExtractList(test.in)
+		if err != nil {
+			t.Fatalf("%d: extract: Unexpected error %v", i, err)
+		}
+		if e, a := len(test.out), len(list); e != a {
+			t.Fatalf("%d: extract: Expected %v, got %v", i, e, a)
+		}
+		for j, e := range test.out {
+			if e != list[j] {
+				if !test.equal {
+					t.Fatalf("%d: extract: Expected list[%d] to be %#v, but found %#v", i, j, e, list[j])
+				}
+				if !reflect.DeepEqual(e, list[j]) {
+					t.Fatalf("%d: extract: Expected list[%d] to be %#v, but found %#v", i, j, e, list[j])
+				}
+			}
+		}
+	}
+}
+
+func TestEachListItem(t *testing.T) {
+	list1 := []runtime.Object{
+		&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "1"}},
+		&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "2"}},
+	}
+	list2 := &ListV1{
+		Items: []runtime.RawExtension{
+			{Raw: []byte("foo")},
+			{Raw: []byte("bar")},
+			{Object: &v1.Carp{ObjectMeta: metav1.ObjectMeta{Name: "other"}}},
+		},
+	}
+	list3 := &fakePtrValueList{
+		Items: []*testapigroup.Carp{
+			{ObjectMeta: metav1.ObjectMeta{Name: "1"}},
+			{ObjectMeta: metav1.ObjectMeta{Name: "2"}},
+		},
+	}
+	list4 := &testapigroup.CarpList{
+		Items: []testapigroup.Carp{
+			{ObjectMeta: metav1.ObjectMeta{Name: "1"}},
+			{ObjectMeta: metav1.ObjectMeta{Name: "2"}},
+			{ObjectMeta: metav1.ObjectMeta{Name: "3"}},
+		},
+	}
+
+	testCases := []struct {
+		in  runtime.Object
+		out []interface{}
+	}{
+		{
+			in:  &List{},
+			out: []interface{}{},
+		},
+		{
+			in:  &ListV1{},
+			out: []interface{}{},
+		},
+		{
+			in:  &List{Items: list1},
+			out: []interface{}{list1[0], list1[1]},
+		},
+		{
+			in:  list2,
+			out: []interface{}{nil, nil, list2.Items[2].Object},
+		},
+		{
+			in:  list3,
+			out: []interface{}{list3.Items[0], list3.Items[1]},
+		},
+		{
+			in:  list4,
+			out: []interface{}{&list4.Items[0], &list4.Items[1], &list4.Items[2]},
+		},
+	}
+	for i, test := range testCases {
+		list := []runtime.Object{}
+		err := meta.EachListItem(test.in, func(obj runtime.Object) error {
+			list = append(list, obj)
+			return nil
+		})
+		if err != nil {
+			t.Fatalf("%d: each: Unexpected error %v", i, err)
+		}
+		if e, a := len(test.out), len(list); e != a {
+			t.Fatalf("%d: each: Expected %v, got %v", i, e, a)
+		}
+		for j, e := range test.out {
+			if e != list[j] {
+				t.Fatalf("%d: each: Expected list[%d] to be %#v, but found %#v", i, j, e, list[j])
+			}
+		}
+	}
+}
+
+type fakePtrInterfaceList struct {
+	Items *[]runtime.Object
+}
+
+func (obj fakePtrInterfaceList) GetObjectKind() schema.ObjectKind {
+	return schema.EmptyObjectKind
+}
+func (obj fakePtrInterfaceList) DeepCopyObject() runtime.Object {
+	panic("fakePtrInterfaceList does not support DeepCopy")
+}
+
+func TestExtractListOfInterfacePtrs(t *testing.T) {
+	pl := &fakePtrInterfaceList{
+		Items: &[]runtime.Object{},
+	}
+	list, err := meta.ExtractList(pl)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	if len(list) > 0 {
+		t.Fatalf("Expected empty list, got %#v", list)
+	}
+}
+
+type fakePtrValueList struct {
+	Items []*testapigroup.Carp
+}
+
+func (obj fakePtrValueList) GetObjectKind() schema.ObjectKind {
+	return schema.EmptyObjectKind
+}
+func (obj *fakePtrValueList) DeepCopyObject() runtime.Object {
+	if obj == nil {
+		return nil
+	}
+	clone := fakePtrValueList{
+		Items: make([]*testapigroup.Carp, len(obj.Items)),
+	}
+	for i, carp := range obj.Items {
+		clone.Items[i] = carp.DeepCopy()
+	}
+	return &clone
+}
+
+func TestSetList(t *testing.T) {
+	pl := &testapigroup.CarpList{}
+	list := []runtime.Object{
+		&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "1"}},
+		&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "2"}},
+		&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "3"}},
+	}
+	err := meta.SetList(pl, list)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	if e, a := len(list), len(pl.Items); e != a {
+		t.Fatalf("Expected %v, got %v", e, a)
+	}
+	for i := range list {
+		if e, a := list[i].(*testapigroup.Carp).Name, pl.Items[i].Name; e != a {
+			t.Fatalf("Expected %v, got %v", e, a)
+		}
+	}
+}
+
+func TestSetListToRuntimeObjectArray(t *testing.T) {
+	pl := &List{}
+	list := []runtime.Object{
+		&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "1"}},
+		&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "2"}},
+		&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "3"}},
+	}
+	err := meta.SetList(pl, list)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	if e, a := len(list), len(pl.Items); e != a {
+		t.Fatalf("Expected %v, got %v", e, a)
+	}
+	for i := range list {
+		if e, a := list[i], pl.Items[i]; e != a {
+			t.Fatalf("%d: unmatched: %s", i, diff.ObjectDiff(e, a))
+		}
+	}
+}
+
+func TestSetListToMatchingType(t *testing.T) {
+	pl := &unstructured.UnstructuredList{}
+	list := []runtime.Object{
+		&unstructured.Unstructured{Object: map[string]interface{}{"foo": 1}},
+		&unstructured.Unstructured{Object: map[string]interface{}{"foo": 2}},
+		&unstructured.Unstructured{Object: map[string]interface{}{"foo": 3}},
+	}
+	err := meta.SetList(pl, list)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	if e, a := len(list), len(pl.Items); e != a {
+		t.Fatalf("Expected %v, got %v", e, a)
+	}
+	for i := range list {
+		if e, a := list[i], &pl.Items[i]; !reflect.DeepEqual(e, a) {
+			t.Fatalf("%d: unmatched: %s", i, diff.ObjectDiff(e, a))
+		}
+	}
+}
+
+func TestSetExtractListRoundTrip(t *testing.T) {
+	fuzzer := fuzz.New().NilChance(0).NumElements(1, 5)
+	for i := 0; i < 5; i++ {
+		start := &testapigroup.CarpList{}
+		fuzzer.Fuzz(&start.Items)
+
+		list, err := meta.ExtractList(start)
+		if err != nil {
+			t.Errorf("Unexpected error %v", err)
+			continue
+		}
+		got := &testapigroup.CarpList{}
+		err = meta.SetList(got, list)
+		if err != nil {
+			t.Errorf("Unexpected error %v", err)
+			continue
+		}
+		if e, a := start, got; !reflect.DeepEqual(e, a) {
+			t.Fatalf("Expected %#v, got %#v", e, a)
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/test/api_meta_meta_test.go

@@ -0,0 +1,429 @@
+/*
+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 test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/google/gofuzz"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/testapigroup"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+)
+
+func TestAPIObjectMeta(t *testing.T) {
+	j := &testapigroup.Carp{
+		TypeMeta: metav1.TypeMeta{APIVersion: "/a", Kind: "b"},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace:       "bar",
+			Name:            "foo",
+			GenerateName:    "prefix",
+			UID:             "uid",
+			ResourceVersion: "1",
+			SelfLink:        "some/place/only/we/know",
+			Labels:          map[string]string{"foo": "bar"},
+			Annotations:     map[string]string{"x": "y"},
+			Finalizers: []string{
+				"finalizer.1",
+				"finalizer.2",
+			},
+		},
+	}
+	var _ metav1.Object = &j.ObjectMeta
+	var _ metav1.ObjectMetaAccessor = j
+	accessor, err := meta.Accessor(j)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if accessor != metav1.Object(j) {
+		t.Fatalf("should have returned the same pointer: %#v\n\n%#v", accessor, j)
+	}
+	if e, a := "bar", accessor.GetNamespace(); e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "foo", accessor.GetName(); e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "prefix", accessor.GetGenerateName(); e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "uid", string(accessor.GetUID()); e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "1", accessor.GetResourceVersion(); e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "some/place/only/we/know", accessor.GetSelfLink(); e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := []string{"finalizer.1", "finalizer.2"}, accessor.GetFinalizers(); !reflect.DeepEqual(e, a) {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+
+	typeAccessor, err := meta.TypeAccessor(j)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if e, a := "a", typeAccessor.GetAPIVersion(); e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "b", typeAccessor.GetKind(); e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+
+	accessor.SetNamespace("baz")
+	accessor.SetName("bar")
+	accessor.SetGenerateName("generate")
+	accessor.SetUID("other")
+	typeAccessor.SetAPIVersion("c")
+	typeAccessor.SetKind("d")
+	accessor.SetResourceVersion("2")
+	accessor.SetSelfLink("google.com")
+	accessor.SetFinalizers([]string{"finalizer.3"})
+
+	// Prove that accessor changes the original object.
+	if e, a := "baz", j.Namespace; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "bar", j.Name; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "generate", j.GenerateName; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := types.UID("other"), j.UID; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "c", j.APIVersion; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "d", j.Kind; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "2", j.ResourceVersion; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "google.com", j.SelfLink; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := []string{"finalizer.3"}, j.Finalizers; !reflect.DeepEqual(e, a) {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+
+	typeAccessor.SetAPIVersion("d")
+	typeAccessor.SetKind("e")
+	if e, a := "d", j.APIVersion; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "e", j.Kind; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+}
+
+func TestGenericTypeMeta(t *testing.T) {
+	type TypeMeta struct {
+		Kind              string                  `json:"kind,omitempty"`
+		Namespace         string                  `json:"namespace,omitempty"`
+		Name              string                  `json:"name,omitempty"`
+		GenerateName      string                  `json:"generateName,omitempty"`
+		UID               string                  `json:"uid,omitempty"`
+		CreationTimestamp metav1.Time             `json:"creationTimestamp,omitempty"`
+		SelfLink          string                  `json:"selfLink,omitempty"`
+		ResourceVersion   string                  `json:"resourceVersion,omitempty"`
+		APIVersion        string                  `json:"apiVersion,omitempty"`
+		Labels            map[string]string       `json:"labels,omitempty"`
+		Annotations       map[string]string       `json:"annotations,omitempty"`
+		OwnerReferences   []metav1.OwnerReference `json:"ownerReferences,omitempty"`
+		Finalizers        []string                `json:"finalizers,omitempty"`
+	}
+
+	j := struct{ TypeMeta }{TypeMeta{APIVersion: "a", Kind: "b"}}
+
+	typeAccessor, err := meta.TypeAccessor(&j)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if e, a := "a", typeAccessor.GetAPIVersion(); e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "b", typeAccessor.GetKind(); e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+
+	typeAccessor.SetAPIVersion("c")
+	typeAccessor.SetKind("d")
+
+	if e, a := "c", j.APIVersion; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "d", j.Kind; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+
+	typeAccessor.SetAPIVersion("d")
+	typeAccessor.SetKind("e")
+
+	if e, a := "d", j.APIVersion; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+	if e, a := "e", j.Kind; e != a {
+		t.Errorf("expected %v, got %v", e, a)
+	}
+}
+
+type InternalTypeMeta struct {
+	Kind              string                  `json:"kind,omitempty"`
+	Namespace         string                  `json:"namespace,omitempty"`
+	Name              string                  `json:"name,omitempty"`
+	GenerateName      string                  `json:"generateName,omitempty"`
+	UID               string                  `json:"uid,omitempty"`
+	CreationTimestamp metav1.Time             `json:"creationTimestamp,omitempty"`
+	SelfLink          string                  `json:"selfLink,omitempty"`
+	ResourceVersion   string                  `json:"resourceVersion,omitempty"`
+	Continue          string                  `json:"next,omitempty"`
+	APIVersion        string                  `json:"apiVersion,omitempty"`
+	Labels            map[string]string       `json:"labels,omitempty"`
+	Annotations       map[string]string       `json:"annotations,omitempty"`
+	Finalizers        []string                `json:"finalizers,omitempty"`
+	OwnerReferences   []metav1.OwnerReference `json:"ownerReferences,omitempty"`
+}
+
+func (m *InternalTypeMeta) GetResourceVersion() string   { return m.ResourceVersion }
+func (m *InternalTypeMeta) SetResourceVersion(rv string) { m.ResourceVersion = rv }
+func (m *InternalTypeMeta) GetSelfLink() string          { return m.SelfLink }
+func (m *InternalTypeMeta) SetSelfLink(link string)      { m.SelfLink = link }
+func (m *InternalTypeMeta) GetContinue() string          { return m.Continue }
+func (m *InternalTypeMeta) SetContinue(c string)         { m.Continue = c }
+
+type MyAPIObject struct {
+	TypeMeta InternalTypeMeta `json:",inline"`
+}
+
+func (obj *MyAPIObject) GetListMeta() metav1.ListInterface { return &obj.TypeMeta }
+
+func (obj *MyAPIObject) GetObjectKind() schema.ObjectKind { return obj }
+func (obj *MyAPIObject) SetGroupVersionKind(gvk schema.GroupVersionKind) {
+	obj.TypeMeta.APIVersion, obj.TypeMeta.Kind = gvk.ToAPIVersionAndKind()
+}
+func (obj *MyAPIObject) GroupVersionKind() schema.GroupVersionKind {
+	return schema.FromAPIVersionAndKind(obj.TypeMeta.APIVersion, obj.TypeMeta.Kind)
+}
+func (obj *MyAPIObject) DeepCopyObject() runtime.Object {
+	panic("MyAPIObject does not support DeepCopy")
+}
+
+type MyIncorrectlyMarkedAsAPIObject struct{}
+
+func (obj *MyIncorrectlyMarkedAsAPIObject) GetObjectKind() schema.ObjectKind {
+	return schema.EmptyObjectKind
+}
+func (obj *MyIncorrectlyMarkedAsAPIObject) DeepCopyObject() runtime.Object {
+	panic("MyIncorrectlyMarkedAsAPIObject does not support DeepCopy")
+}
+
+func TestResourceVersionerOfAPI(t *testing.T) {
+	type T struct {
+		runtime.Object
+		Expected string
+	}
+	testCases := map[string]T{
+		"empty api object":                   {&MyAPIObject{}, ""},
+		"api object with version":            {&MyAPIObject{TypeMeta: InternalTypeMeta{ResourceVersion: "1"}}, "1"},
+		"pointer to api object with version": {&MyAPIObject{TypeMeta: InternalTypeMeta{ResourceVersion: "1"}}, "1"},
+	}
+	versioning := meta.NewAccessor()
+	for key, testCase := range testCases {
+		actual, err := versioning.ResourceVersion(testCase.Object)
+		if err != nil {
+			t.Errorf("%s: unexpected error %#v", key, err)
+		}
+		if actual != testCase.Expected {
+			t.Errorf("%s: expected %v, got %v", key, testCase.Expected, actual)
+		}
+	}
+
+	failingCases := map[string]struct {
+		runtime.Object
+		Expected string
+	}{
+		"not a valid object to try": {&MyIncorrectlyMarkedAsAPIObject{}, "1"},
+	}
+	for key, testCase := range failingCases {
+		_, err := versioning.ResourceVersion(testCase.Object)
+		if err == nil {
+			t.Errorf("%s: expected error, got nil", key)
+		}
+	}
+
+	setCases := map[string]struct {
+		runtime.Object
+		Expected string
+	}{
+		"pointer to api object with version": {&MyAPIObject{TypeMeta: InternalTypeMeta{ResourceVersion: "1"}}, "1"},
+	}
+	for key, testCase := range setCases {
+		if err := versioning.SetResourceVersion(testCase.Object, "5"); err != nil {
+			t.Errorf("%s: unexpected error %#v", key, err)
+		}
+		actual, err := versioning.ResourceVersion(testCase.Object)
+		if err != nil {
+			t.Errorf("%s: unexpected error %#v", key, err)
+		}
+		if actual != "5" {
+			t.Errorf("%s: expected %v, got %v", key, "5", actual)
+		}
+	}
+}
+
+func TestTypeMetaSelfLinker(t *testing.T) {
+	table := map[string]struct {
+		obj     runtime.Object
+		expect  string
+		try     string
+		succeed bool
+	}{
+		"normal": {
+			obj:     &MyAPIObject{TypeMeta: InternalTypeMeta{SelfLink: "foobar"}},
+			expect:  "foobar",
+			try:     "newbar",
+			succeed: true,
+		},
+		"fail": {
+			obj:     &MyIncorrectlyMarkedAsAPIObject{},
+			succeed: false,
+		},
+	}
+
+	linker := runtime.SelfLinker(meta.NewAccessor())
+	for name, item := range table {
+		got, err := linker.SelfLink(item.obj)
+		if e, a := item.succeed, err == nil; e != a {
+			t.Errorf("%v: expected %v, got %v", name, e, a)
+		}
+		if e, a := item.expect, got; item.succeed && e != a {
+			t.Errorf("%v: expected %v, got %v", name, e, a)
+		}
+
+		err = linker.SetSelfLink(item.obj, item.try)
+		if e, a := item.succeed, err == nil; e != a {
+			t.Errorf("%v: expected %v, got %v", name, e, a)
+		}
+		if item.succeed {
+			got, err := linker.SelfLink(item.obj)
+			if err != nil {
+				t.Errorf("%v: expected no err, got %v", name, err)
+			}
+			if e, a := item.try, got; e != a {
+				t.Errorf("%v: expected %v, got %v", name, e, a)
+			}
+		}
+	}
+}
+
+type MyAPIObject2 struct {
+	metav1.TypeMeta
+	metav1.ObjectMeta
+}
+
+func getObjectMetaAndOwnerReferences() (myAPIObject2 MyAPIObject2, metaOwnerReferences []metav1.OwnerReference) {
+	fuzz.New().NilChance(.5).NumElements(1, 5).Fuzz(&myAPIObject2)
+	references := myAPIObject2.ObjectMeta.OwnerReferences
+	// This is necessary for the test to pass because the getter will return a
+	// non-nil slice.
+	metaOwnerReferences = make([]metav1.OwnerReference, 0)
+	for i := 0; i < len(references); i++ {
+		metaOwnerReferences = append(metaOwnerReferences, metav1.OwnerReference{
+			Kind:               references[i].Kind,
+			Name:               references[i].Name,
+			UID:                references[i].UID,
+			APIVersion:         references[i].APIVersion,
+			Controller:         references[i].Controller,
+			BlockOwnerDeletion: references[i].BlockOwnerDeletion,
+		})
+	}
+	if len(references) == 0 {
+		// This is necessary for the test to pass because the setter will make a
+		// non-nil slice.
+		myAPIObject2.ObjectMeta.OwnerReferences = make([]metav1.OwnerReference, 0)
+	}
+	return myAPIObject2, metaOwnerReferences
+}
+
+func testGetOwnerReferences(t *testing.T) {
+	obj, expected := getObjectMetaAndOwnerReferences()
+	accessor, err := meta.Accessor(&obj)
+	if err != nil {
+		t.Error(err)
+	}
+	references := accessor.GetOwnerReferences()
+	if !reflect.DeepEqual(references, expected) {
+		t.Errorf("expect %#v\n got %#v", expected, references)
+	}
+}
+
+func testSetOwnerReferences(t *testing.T) {
+	expected, references := getObjectMetaAndOwnerReferences()
+	obj := MyAPIObject2{}
+	accessor, err := meta.Accessor(&obj)
+	if err != nil {
+		t.Error(err)
+	}
+	accessor.SetOwnerReferences(references)
+	if e, a := expected.ObjectMeta.OwnerReferences, obj.ObjectMeta.OwnerReferences; !reflect.DeepEqual(e, a) {
+		t.Errorf("expect %#v\n got %#v", e, a)
+	}
+}
+
+func TestAccessOwnerReferences(t *testing.T) {
+	fuzzIter := 5
+	for i := 0; i < fuzzIter; i++ {
+		testGetOwnerReferences(t)
+		testSetOwnerReferences(t)
+	}
+}
+
+// BenchmarkAccessorSetFastPath shows the interface fast path
+func BenchmarkAccessorSetFastPath(b *testing.B) {
+	obj := &testapigroup.Carp{
+		TypeMeta: metav1.TypeMeta{APIVersion: "/a", Kind: "b"},
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace:       "bar",
+			Name:            "foo",
+			GenerateName:    "prefix",
+			UID:             "uid",
+			ResourceVersion: "1",
+			SelfLink:        "some/place/only/we/know",
+			Labels:          map[string]string{"foo": "bar"},
+			Annotations:     map[string]string{"x": "y"},
+		},
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		acc, err := meta.Accessor(obj)
+		if err != nil {
+			b.Fatal(err)
+		}
+		acc.SetNamespace("something")
+	}
+	b.StopTimer()
+}

vendor/k8s.io/apimachinery/pkg/test/apis_meta_v1_unstructed_unstructure_test.go

@@ -0,0 +1,571 @@
+/*
+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 test
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	apitesting "k8s.io/apimachinery/pkg/api/testing"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/apis/testapigroup"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+)
+
+func TestDecodeUnstructured(t *testing.T) {
+	groupVersionString := "v1"
+	rawJson := fmt.Sprintf(`{"kind":"Pod","apiVersion":"%s","metadata":{"name":"test"}}`, groupVersionString)
+	pl := &List{
+		Items: []runtime.Object{
+			&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "1"}},
+			&runtime.Unknown{
+				TypeMeta:    runtime.TypeMeta{Kind: "Pod", APIVersion: groupVersionString},
+				Raw:         []byte(rawJson),
+				ContentType: runtime.ContentTypeJSON,
+			},
+			&runtime.Unknown{
+				TypeMeta:    runtime.TypeMeta{Kind: "", APIVersion: groupVersionString},
+				Raw:         []byte(rawJson),
+				ContentType: runtime.ContentTypeJSON,
+			},
+			&unstructured.Unstructured{
+				Object: map[string]interface{}{
+					"kind":       "Foo",
+					"apiVersion": "Bar",
+					"test":       "value",
+				},
+			},
+		},
+	}
+	if errs := runtime.DecodeList(pl.Items, unstructured.UnstructuredJSONScheme); len(errs) == 1 {
+		t.Fatalf("unexpected error %v", errs)
+	}
+	if pod, ok := pl.Items[1].(*unstructured.Unstructured); !ok || pod.Object["kind"] != "Pod" || pod.Object["metadata"].(map[string]interface{})["name"] != "test" {
+		t.Errorf("object not converted: %#v", pl.Items[1])
+	}
+	if pod, ok := pl.Items[2].(*unstructured.Unstructured); !ok || pod.Object["kind"] != "Pod" || pod.Object["metadata"].(map[string]interface{})["name"] != "test" {
+		t.Errorf("object not converted: %#v", pl.Items[2])
+	}
+}
+
+func TestDecode(t *testing.T) {
+	tcs := []struct {
+		json []byte
+		want runtime.Object
+	}{
+		{
+			json: []byte(`{"apiVersion": "test", "kind": "test_kind"}`),
+			want: &unstructured.Unstructured{
+				Object: map[string]interface{}{"apiVersion": "test", "kind": "test_kind"},
+			},
+		},
+		{
+			json: []byte(`{"apiVersion": "test", "kind": "test_list", "items": []}`),
+			want: &unstructured.UnstructuredList{
+				Object: map[string]interface{}{"apiVersion": "test", "kind": "test_list"},
+				Items:  []unstructured.Unstructured{},
+			},
+		},
+		{
+			json: []byte(`{"items": [{"metadata": {"name": "object1", "deletionGracePeriodSeconds": 10}, "apiVersion": "test", "kind": "test_kind"}, {"metadata": {"name": "object2"}, "apiVersion": "test", "kind": "test_kind"}], "apiVersion": "test", "kind": "test_list"}`),
+			want: &unstructured.UnstructuredList{
+				Object: map[string]interface{}{"apiVersion": "test", "kind": "test_list"},
+				Items: []unstructured.Unstructured{
+					{
+						Object: map[string]interface{}{
+							"metadata":   map[string]interface{}{"name": "object1", "deletionGracePeriodSeconds": int64(10)},
+							"apiVersion": "test",
+							"kind":       "test_kind",
+						},
+					},
+					{
+						Object: map[string]interface{}{
+							"metadata":   map[string]interface{}{"name": "object2"},
+							"apiVersion": "test",
+							"kind":       "test_kind",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range tcs {
+		got, _, err := unstructured.UnstructuredJSONScheme.Decode(tc.json, nil, nil)
+		if err != nil {
+			t.Errorf("Unexpected error for %q: %v", string(tc.json), err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("Decode(%q) want: %v\ngot: %v", string(tc.json), tc.want, got)
+		}
+	}
+}
+
+func TestUnstructuredGetters(t *testing.T) {
+	trueVar := true
+	ten := int64(10)
+	unstruct := unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"kind":       "test_kind",
+			"apiVersion": "test_version",
+			"metadata": map[string]interface{}{
+				"name":                       "test_name",
+				"namespace":                  "test_namespace",
+				"generateName":               "test_generateName",
+				"uid":                        "test_uid",
+				"resourceVersion":            "test_resourceVersion",
+				"generation":                 ten,
+				"deletionGracePeriodSeconds": ten,
+				"selfLink":                   "test_selfLink",
+				"creationTimestamp":          "2009-11-10T23:00:00Z",
+				"deletionTimestamp":          "2010-11-10T23:00:00Z",
+				"labels": map[string]interface{}{
+					"test_label": "test_value",
+				},
+				"annotations": map[string]interface{}{
+					"test_annotation": "test_value",
+				},
+				"ownerReferences": []interface{}{
+					map[string]interface{}{
+						"kind":       "Pod",
+						"name":       "poda",
+						"apiVersion": "v1",
+						"uid":        "1",
+					},
+					map[string]interface{}{
+						"kind":       "Pod",
+						"name":       "podb",
+						"apiVersion": "v1",
+						"uid":        "2",
+						// though these fields are of type *bool, but when
+						// decoded from JSON, they are unmarshalled as bool.
+						"controller":         true,
+						"blockOwnerDeletion": true,
+					},
+				},
+				"finalizers": []interface{}{
+					"finalizer.1",
+					"finalizer.2",
+				},
+				"clusterName": "cluster123",
+			},
+		},
+	}
+
+	if got, want := unstruct.GetAPIVersion(), "test_version"; got != want {
+		t.Errorf("GetAPIVersions() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetKind(), "test_kind"; got != want {
+		t.Errorf("GetKind() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetNamespace(), "test_namespace"; got != want {
+		t.Errorf("GetNamespace() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetName(), "test_name"; got != want {
+		t.Errorf("GetName() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetGenerateName(), "test_generateName"; got != want {
+		t.Errorf("GetGenerateName() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetUID(), types.UID("test_uid"); got != want {
+		t.Errorf("GetUID() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetResourceVersion(), "test_resourceVersion"; got != want {
+		t.Errorf("GetResourceVersion() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetSelfLink(), "test_selfLink"; got != want {
+		t.Errorf("GetSelfLink() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetCreationTimestamp(), metav1.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC); !got.Equal(&want) {
+		t.Errorf("GetCreationTimestamp() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetDeletionTimestamp(), metav1.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC); got == nil || !got.Equal(&want) {
+		t.Errorf("GetDeletionTimestamp() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetLabels(), map[string]string{"test_label": "test_value"}; !reflect.DeepEqual(got, want) {
+		t.Errorf("GetLabels() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetAnnotations(), map[string]string{"test_annotation": "test_value"}; !reflect.DeepEqual(got, want) {
+		t.Errorf("GetAnnotations() = %s, want %s", got, want)
+	}
+	refs := unstruct.GetOwnerReferences()
+	expectedOwnerReferences := []metav1.OwnerReference{
+		{
+			Kind:       "Pod",
+			Name:       "poda",
+			APIVersion: "v1",
+			UID:        "1",
+		},
+		{
+			Kind:               "Pod",
+			Name:               "podb",
+			APIVersion:         "v1",
+			UID:                "2",
+			Controller:         &trueVar,
+			BlockOwnerDeletion: &trueVar,
+		},
+	}
+	if got, want := refs, expectedOwnerReferences; !reflect.DeepEqual(got, want) {
+		t.Errorf("GetOwnerReferences()=%v, want %v", got, want)
+	}
+	if got, want := unstruct.GetFinalizers(), []string{"finalizer.1", "finalizer.2"}; !reflect.DeepEqual(got, want) {
+		t.Errorf("GetFinalizers()=%v, want %v", got, want)
+	}
+	if got, want := unstruct.GetClusterName(), "cluster123"; got != want {
+		t.Errorf("GetClusterName()=%v, want %v", got, want)
+	}
+	if got, want := unstruct.GetDeletionGracePeriodSeconds(), &ten; !reflect.DeepEqual(got, want) {
+		t.Errorf("GetDeletionGracePeriodSeconds()=%v, want %v", got, want)
+	}
+	if got, want := unstruct.GetGeneration(), ten; !reflect.DeepEqual(got, want) {
+		t.Errorf("GetGeneration()=%v, want %v", got, want)
+	}
+}
+
+func TestUnstructuredSetters(t *testing.T) {
+	unstruct := unstructured.Unstructured{}
+	trueVar := true
+	ten := int64(10)
+
+	want := unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"kind":       "test_kind",
+			"apiVersion": "test_version",
+			"metadata": map[string]interface{}{
+				"name":                       "test_name",
+				"namespace":                  "test_namespace",
+				"generateName":               "test_generateName",
+				"uid":                        "test_uid",
+				"resourceVersion":            "test_resourceVersion",
+				"selfLink":                   "test_selfLink",
+				"creationTimestamp":          "2009-11-10T23:00:00Z",
+				"deletionTimestamp":          "2010-11-10T23:00:00Z",
+				"deletionGracePeriodSeconds": ten,
+				"generation":                 ten,
+				"labels": map[string]interface{}{
+					"test_label": "test_value",
+				},
+				"annotations": map[string]interface{}{
+					"test_annotation": "test_value",
+				},
+				"ownerReferences": []interface{}{
+					map[string]interface{}{
+						"kind":       "Pod",
+						"name":       "poda",
+						"apiVersion": "v1",
+						"uid":        "1",
+					},
+					map[string]interface{}{
+						"kind":               "Pod",
+						"name":               "podb",
+						"apiVersion":         "v1",
+						"uid":                "2",
+						"controller":         true,
+						"blockOwnerDeletion": true,
+					},
+				},
+				"finalizers": []interface{}{
+					"finalizer.1",
+					"finalizer.2",
+				},
+				"clusterName": "cluster123",
+			},
+		},
+	}
+
+	unstruct.SetAPIVersion("test_version")
+	unstruct.SetKind("test_kind")
+	unstruct.SetNamespace("test_namespace")
+	unstruct.SetName("test_name")
+	unstruct.SetGenerateName("test_generateName")
+	unstruct.SetUID(types.UID("test_uid"))
+	unstruct.SetResourceVersion("test_resourceVersion")
+	unstruct.SetSelfLink("test_selfLink")
+	unstruct.SetCreationTimestamp(metav1.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC))
+	date := metav1.Date(2010, time.November, 10, 23, 0, 0, 0, time.UTC)
+	unstruct.SetDeletionTimestamp(&date)
+	unstruct.SetLabels(map[string]string{"test_label": "test_value"})
+	unstruct.SetAnnotations(map[string]string{"test_annotation": "test_value"})
+	newOwnerReferences := []metav1.OwnerReference{
+		{
+			Kind:       "Pod",
+			Name:       "poda",
+			APIVersion: "v1",
+			UID:        "1",
+		},
+		{
+			Kind:               "Pod",
+			Name:               "podb",
+			APIVersion:         "v1",
+			UID:                "2",
+			Controller:         &trueVar,
+			BlockOwnerDeletion: &trueVar,
+		},
+	}
+	unstruct.SetOwnerReferences(newOwnerReferences)
+	unstruct.SetFinalizers([]string{"finalizer.1", "finalizer.2"})
+	unstruct.SetClusterName("cluster123")
+	unstruct.SetDeletionGracePeriodSeconds(&ten)
+	unstruct.SetGeneration(ten)
+
+	if !reflect.DeepEqual(unstruct, want) {
+		t.Errorf("Wanted: \n%s\n Got:\n%s", want, unstruct)
+	}
+}
+
+func TestOwnerReferences(t *testing.T) {
+	t.Parallel()
+	trueVar := true
+	falseVar := false
+	refs := []metav1.OwnerReference{
+		{
+			APIVersion: "v2",
+			Kind:       "K2",
+			Name:       "n2",
+			UID:        types.UID("abc1"),
+		},
+		{
+			APIVersion:         "v1",
+			Kind:               "K1",
+			Name:               "n1",
+			UID:                types.UID("abc2"),
+			Controller:         &trueVar,
+			BlockOwnerDeletion: &falseVar,
+		},
+		{
+			APIVersion:         "v3",
+			Kind:               "K3",
+			Name:               "n3",
+			UID:                types.UID("abc3"),
+			Controller:         &falseVar,
+			BlockOwnerDeletion: &trueVar,
+		},
+	}
+	for i, ref := range refs {
+		ref := ref
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			t.Parallel()
+			u1 := unstructured.Unstructured{
+				Object: make(map[string]interface{}),
+			}
+			refsX := []metav1.OwnerReference{ref}
+			u1.SetOwnerReferences(refsX)
+
+			have := u1.GetOwnerReferences()
+			if !reflect.DeepEqual(have, refsX) {
+				t.Errorf("Object references are not the same: %#v != %#v", have, refsX)
+			}
+		})
+	}
+}
+
+func TestUnstructuredListGetters(t *testing.T) {
+	unstruct := unstructured.UnstructuredList{
+		Object: map[string]interface{}{
+			"kind":       "test_kind",
+			"apiVersion": "test_version",
+			"metadata": map[string]interface{}{
+				"resourceVersion": "test_resourceVersion",
+				"selfLink":        "test_selfLink",
+			},
+		},
+	}
+
+	if got, want := unstruct.GetAPIVersion(), "test_version"; got != want {
+		t.Errorf("GetAPIVersions() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetKind(), "test_kind"; got != want {
+		t.Errorf("GetKind() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetResourceVersion(), "test_resourceVersion"; got != want {
+		t.Errorf("GetResourceVersion() = %s, want %s", got, want)
+	}
+
+	if got, want := unstruct.GetSelfLink(), "test_selfLink"; got != want {
+		t.Errorf("GetSelfLink() = %s, want %s", got, want)
+	}
+}
+
+func TestUnstructuredListSetters(t *testing.T) {
+	unstruct := unstructured.UnstructuredList{}
+
+	want := unstructured.UnstructuredList{
+		Object: map[string]interface{}{
+			"kind":       "test_kind",
+			"apiVersion": "test_version",
+			"metadata": map[string]interface{}{
+				"resourceVersion": "test_resourceVersion",
+				"selfLink":        "test_selfLink",
+			},
+		},
+	}
+
+	unstruct.SetAPIVersion("test_version")
+	unstruct.SetKind("test_kind")
+	unstruct.SetResourceVersion("test_resourceVersion")
+	unstruct.SetSelfLink("test_selfLink")
+
+	if !reflect.DeepEqual(unstruct, want) {
+		t.Errorf("Wanted: \n%s\n Got:\n%s", unstruct, want)
+	}
+}
+
+func TestDecodeNumbers(t *testing.T) {
+
+	// Start with a valid pod
+	originalJSON := []byte(`{
+		"kind":"Carp",
+		"apiVersion":"v1",
+		"metadata":{"name":"pod","namespace":"foo"},
+		"spec":{
+			"containers":[{"name":"container","image":"container"}],
+			"activeDeadlineSeconds":1000030003
+		}
+	}`)
+
+	pod := &testapigroup.Carp{}
+
+	_, codecs := TestScheme()
+	codec := apitesting.TestCodec(codecs, schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal})
+
+	err := runtime.DecodeInto(codec, originalJSON, pod)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Round-trip with unstructured codec
+	unstructuredObj, err := runtime.Decode(unstructured.UnstructuredJSONScheme, originalJSON)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	roundtripJSON, err := runtime.Encode(unstructured.UnstructuredJSONScheme, unstructuredObj)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Make sure we serialize back out in int form
+	if !strings.Contains(string(roundtripJSON), `"activeDeadlineSeconds":1000030003`) {
+		t.Errorf("Expected %s, got %s", `"activeDeadlineSeconds":1000030003`, string(roundtripJSON))
+	}
+
+	// Decode with structured codec again
+	obj2, err := runtime.Decode(codec, roundtripJSON)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	// ensure pod is still valid
+	pod2, ok := obj2.(*testapigroup.Carp)
+	if !ok {
+		t.Fatalf("expected an *api.Pod, got %#v", obj2)
+	}
+
+	// ensure round-trip preserved large integers
+	if !reflect.DeepEqual(pod, pod2) {
+		t.Fatalf("Expected\n\t%#v, got \n\t%#v", pod, pod2)
+	}
+}
+
+// TestAccessorMethods does opaque roundtrip testing against an Unstructured
+// instance's Object methods to ensure that what is "Set" matches what you
+// subsequently "Get" without any assertions against internal state.
+func TestAccessorMethods(t *testing.T) {
+	int64p := func(i int) *int64 {
+		v := int64(i)
+		return &v
+	}
+	tests := []struct {
+		accessor string
+		val      interface{}
+		nilVal   reflect.Value
+	}{
+		{accessor: "Namespace", val: "foo"},
+		{accessor: "Name", val: "bar"},
+		{accessor: "GenerateName", val: "baz"},
+		{accessor: "UID", val: types.UID("uid")},
+		{accessor: "ResourceVersion", val: "1"},
+		{accessor: "Generation", val: int64(5)},
+		{accessor: "SelfLink", val: "/foo"},
+		// TODO: Handle timestamps, which are being marshalled as UTC and
+		// unmarshalled as Local.
+		// https://github.com/kubernetes/kubernetes/issues/21402
+		// {accessor: "CreationTimestamp", val: someTime},
+		// {accessor: "DeletionTimestamp", val: someTimeP},
+		{accessor: "DeletionTimestamp", nilVal: reflect.ValueOf((*metav1.Time)(nil))},
+		{accessor: "DeletionGracePeriodSeconds", val: int64p(10)},
+		{accessor: "DeletionGracePeriodSeconds", val: int64p(0)},
+		{accessor: "DeletionGracePeriodSeconds", nilVal: reflect.ValueOf((*int64)(nil))},
+		{accessor: "Labels", val: map[string]string{"foo": "bar"}},
+		{accessor: "Annotations", val: map[string]string{"foo": "bar"}},
+		{accessor: "Initializers", val: &metav1.Initializers{Pending: []metav1.Initializer{{Name: "foo"}}}},
+		{accessor: "Initializers", val: &metav1.Initializers{}},
+		{accessor: "Initializers", nilVal: reflect.ValueOf((*metav1.Initializers)(nil))},
+		{accessor: "Finalizers", val: []string{"foo"}},
+		{accessor: "OwnerReferences", val: []metav1.OwnerReference{{Name: "foo"}}},
+		{accessor: "ClusterName", val: "foo"},
+	}
+	for i, test := range tests {
+		t.Logf("evaluating test %d (%s)", i, test.accessor)
+
+		u := &unstructured.Unstructured{}
+		setter := reflect.ValueOf(u).MethodByName("Set" + test.accessor)
+		getter := reflect.ValueOf(u).MethodByName("Get" + test.accessor)
+
+		args := []reflect.Value{}
+		if test.val != nil {
+			args = append(args, reflect.ValueOf(test.val))
+		} else {
+			args = append(args, test.nilVal)
+		}
+		setter.Call(args)
+
+		ret := getter.Call([]reflect.Value{})
+		actual := ret[0].Interface()
+
+		var expected interface{}
+		if test.val != nil {
+			expected = test.val
+		} else {
+			expected = test.nilVal.Interface()
+		}
+
+		if e, a := expected, actual; !reflect.DeepEqual(e, a) {
+			t.Fatalf("%s: expected %v (%T), got %v (%T)", test.accessor, e, e, a, a)
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/test/runtime_helper_test.go

@@ -0,0 +1,49 @@
+/*
+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 test
+
+import (
+	"testing"
+
+	apitesting "k8s.io/apimachinery/pkg/api/testing"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/testapigroup"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+func TestDecodeList(t *testing.T) {
+	pl := List{
+		Items: []runtime.Object{
+			&testapigroup.Carp{ObjectMeta: metav1.ObjectMeta{Name: "1"}},
+			&runtime.Unknown{
+				TypeMeta:    runtime.TypeMeta{Kind: "Carp", APIVersion: "v1"},
+				Raw:         []byte(`{"kind":"Carp","apiVersion":"` + "v1" + `","metadata":{"name":"test"}}`),
+				ContentType: runtime.ContentTypeJSON,
+			},
+		},
+	}
+
+	_, codecs := TestScheme()
+	Codec := apitesting.TestCodec(codecs, testapigroup.SchemeGroupVersion)
+
+	if errs := runtime.DecodeList(pl.Items, Codec); len(errs) != 0 {
+		t.Fatalf("unexpected error %v", errs)
+	}
+	if pod, ok := pl.Items[1].(*testapigroup.Carp); !ok || pod.Name != "test" {
+		t.Errorf("object not converted: %#v", pl.Items[1])
+	}
+}

vendor/k8s.io/apimachinery/pkg/test/runtime_serializer_protobuf_protobuf_test.go

@@ -0,0 +1,360 @@
+/*
+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 test
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/testapigroup/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer/protobuf"
+	"k8s.io/apimachinery/pkg/util/diff"
+)
+
+type testObject struct {
+	gvk schema.GroupVersionKind
+}
+
+func (d *testObject) GetObjectKind() schema.ObjectKind                { return d }
+func (d *testObject) SetGroupVersionKind(gvk schema.GroupVersionKind) { d.gvk = gvk }
+func (d *testObject) GroupVersionKind() schema.GroupVersionKind       { return d.gvk }
+func (d *testObject) DeepCopyObject() runtime.Object {
+	panic("testObject does not support DeepCopy")
+}
+
+type testMarshalable struct {
+	testObject
+	data []byte
+	err  error
+}
+
+func (d *testMarshalable) Marshal() ([]byte, error) {
+	return d.data, d.err
+}
+
+func (d *testMarshalable) DeepCopyObject() runtime.Object {
+	panic("testMarshalable does not support DeepCopy")
+}
+
+type testBufferedMarshalable struct {
+	testObject
+	data []byte
+	err  error
+}
+
+func (d *testBufferedMarshalable) Marshal() ([]byte, error) {
+	return nil, fmt.Errorf("not invokable")
+}
+
+func (d *testBufferedMarshalable) MarshalTo(data []byte) (int, error) {
+	copy(data, d.data)
+	return len(d.data), d.err
+}
+
+func (d *testBufferedMarshalable) Size() int {
+	return len(d.data)
+}
+
+func (d *testBufferedMarshalable) DeepCopyObject() runtime.Object {
+	panic("testBufferedMarshalable does not support DeepCopy")
+}
+
+func TestRecognize(t *testing.T) {
+	s := protobuf.NewSerializer(nil, nil, "application/protobuf")
+	ignores := [][]byte{
+		nil,
+		{},
+		[]byte("k8s"),
+		{0x6b, 0x38, 0x73, 0x01},
+	}
+	for i, data := range ignores {
+		if ok, _, err := s.RecognizesData(bytes.NewBuffer(data)); err != nil || ok {
+			t.Errorf("%d: should not recognize data: %v", i, err)
+		}
+	}
+	recognizes := [][]byte{
+		{0x6b, 0x38, 0x73, 0x00},
+		{0x6b, 0x38, 0x73, 0x00, 0x01},
+	}
+	for i, data := range recognizes {
+		if ok, _, err := s.RecognizesData(bytes.NewBuffer(data)); err != nil || !ok {
+			t.Errorf("%d: should recognize data: %v", i, err)
+		}
+	}
+}
+
+func TestEncode(t *testing.T) {
+	obj1 := &testMarshalable{testObject: testObject{}, data: []byte{}}
+	wire1 := []byte{
+		0x6b, 0x38, 0x73, 0x00, // prefix
+		0x0a, 0x04,
+		0x0a, 0x00, // apiversion
+		0x12, 0x00, // kind
+		0x12, 0x00, // data
+		0x1a, 0x00, // content-type
+		0x22, 0x00, // content-encoding
+	}
+	obj2 := &testMarshalable{
+		testObject: testObject{gvk: schema.GroupVersionKind{Kind: "test", Group: "other", Version: "version"}},
+		data:       []byte{0x01, 0x02, 0x03},
+	}
+	wire2 := []byte{
+		0x6b, 0x38, 0x73, 0x00, // prefix
+		0x0a, 0x15,
+		0x0a, 0x0d, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x2f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, // apiversion
+		0x12, 0x04, 0x74, 0x65, 0x73, 0x74, // kind
+		0x12, 0x03, 0x01, 0x02, 0x03, // data
+		0x1a, 0x00, // content-type
+		0x22, 0x00, // content-encoding
+	}
+
+	err1 := fmt.Errorf("a test error")
+
+	testCases := []struct {
+		obj   runtime.Object
+		data  []byte
+		errFn func(error) bool
+	}{
+		{
+			obj:   &testObject{},
+			errFn: protobuf.IsNotMarshalable,
+		},
+		{
+			obj:  obj1,
+			data: wire1,
+		},
+		{
+			obj:   &testMarshalable{testObject: obj1.testObject, err: err1},
+			errFn: func(err error) bool { return err == err1 },
+		},
+		{
+			// if this test fails, writing the "fast path" marshal is not the same as the "slow path"
+			obj:  &testBufferedMarshalable{testObject: obj1.testObject, data: obj1.data},
+			data: wire1,
+		},
+		{
+			obj:  obj2,
+			data: wire2,
+		},
+		{
+			// if this test fails, writing the "fast path" marshal is not the same as the "slow path"
+			obj:  &testBufferedMarshalable{testObject: obj2.testObject, data: obj2.data},
+			data: wire2,
+		},
+		{
+			obj:   &testBufferedMarshalable{testObject: obj1.testObject, err: err1},
+			errFn: func(err error) bool { return err == err1 },
+		},
+	}
+
+	for i, test := range testCases {
+		s := protobuf.NewSerializer(nil, nil, "application/protobuf")
+		data, err := runtime.Encode(s, test.obj)
+
+		switch {
+		case err == nil && test.errFn != nil:
+			t.Errorf("%d: failed: %v", i, err)
+			continue
+		case err != nil && test.errFn == nil:
+			t.Errorf("%d: failed: %v", i, err)
+			continue
+		case err != nil:
+			if !test.errFn(err) {
+				t.Errorf("%d: failed: %v", i, err)
+			}
+			if data != nil {
+				t.Errorf("%d: should not have returned nil data", i)
+			}
+			continue
+		}
+
+		if test.data != nil && !bytes.Equal(test.data, data) {
+			t.Errorf("%d: unexpected data:\n%s", i, hex.Dump(data))
+			continue
+		}
+
+		if ok, _, err := s.RecognizesData(bytes.NewBuffer(data)); !ok || err != nil {
+			t.Errorf("%d: did not recognize data generated by call: %v", i, err)
+		}
+	}
+}
+
+func TestProtobufDecode(t *testing.T) {
+	wire1 := []byte{
+		0x6b, 0x38, 0x73, 0x00, // prefix
+		0x0a, 0x04,
+		0x0a, 0x00, // apiversion
+		0x12, 0x00, // kind
+		0x12, 0x00, // data
+		0x1a, 0x00, // content-type
+		0x22, 0x00, // content-encoding
+	}
+	wire2 := []byte{
+		0x6b, 0x38, 0x73, 0x00, // prefix
+		0x0a, 0x15,
+		0x0a, 0x0d, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x2f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, // apiversion
+		0x12, 0x04, 0x74, 0x65, 0x73, 0x74, // kind
+		0x12, 0x07, 0x6b, 0x38, 0x73, 0x00, 0x01, 0x02, 0x03, // data
+		0x1a, 0x00, // content-type
+		0x22, 0x00, // content-encoding
+	}
+
+	//err1 := fmt.Errorf("a test error")
+
+	testCases := []struct {
+		obj   runtime.Object
+		data  []byte
+		errFn func(error) bool
+	}{
+		{
+			obj:   &runtime.Unknown{},
+			errFn: func(err error) bool { return err.Error() == "empty data" },
+		},
+		{
+			data:  []byte{0x6b},
+			errFn: func(err error) bool { return strings.Contains(err.Error(), "does not appear to be a protobuf message") },
+		},
+		{
+			obj: &runtime.Unknown{
+				Raw: []byte{},
+			},
+			data: wire1,
+		},
+		{
+			obj: &runtime.Unknown{
+				TypeMeta: runtime.TypeMeta{
+					APIVersion: "other/version",
+					Kind:       "test",
+				},
+				// content type is set because the prefix matches the content
+				ContentType: "application/protobuf",
+				Raw:         []byte{0x6b, 0x38, 0x73, 0x00, 0x01, 0x02, 0x03},
+			},
+			data: wire2,
+		},
+	}
+
+	for i, test := range testCases {
+		s := protobuf.NewSerializer(nil, nil, "application/protobuf")
+		unk := &runtime.Unknown{}
+		err := runtime.DecodeInto(s, test.data, unk)
+
+		switch {
+		case err == nil && test.errFn != nil:
+			t.Errorf("%d: failed: %v", i, err)
+			continue
+		case err != nil && test.errFn == nil:
+			t.Errorf("%d: failed: %v", i, err)
+			continue
+		case err != nil:
+			if !test.errFn(err) {
+				t.Errorf("%d: failed: %v", i, err)
+			}
+			continue
+		}
+
+		if !reflect.DeepEqual(unk, test.obj) {
+			t.Errorf("%d: unexpected object:\n%#v", i, unk)
+			continue
+		}
+	}
+}
+
+func TestDecodeObjects(t *testing.T) {
+	obj1 := &v1.Carp{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "cool",
+		},
+		Spec: v1.CarpSpec{
+			Hostname: "coolhost",
+		},
+	}
+	obj1wire, err := obj1.Marshal()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	wire1, err := (&runtime.Unknown{
+		TypeMeta: runtime.TypeMeta{Kind: "Carp", APIVersion: "v1"},
+		Raw:      obj1wire,
+	}).Marshal()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	unk2 := &runtime.Unknown{
+		TypeMeta: runtime.TypeMeta{Kind: "Carp", APIVersion: "v1"},
+	}
+	wire2 := make([]byte, len(wire1)*2)
+	n, err := unk2.NestedMarshalTo(wire2, obj1, uint64(obj1.Size()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n != len(wire1) || !bytes.Equal(wire1, wire2[:n]) {
+		t.Fatalf("unexpected wire:\n%s", hex.Dump(wire2[:n]))
+	}
+
+	wire1 = append([]byte{0x6b, 0x38, 0x73, 0x00}, wire1...)
+
+	testCases := []struct {
+		obj   runtime.Object
+		data  []byte
+		errFn func(error) bool
+	}{
+		{
+			obj:  obj1,
+			data: wire1,
+		},
+	}
+	scheme := runtime.NewScheme()
+	for i, test := range testCases {
+		scheme.AddKnownTypes(schema.GroupVersion{Version: "v1"}, &v1.Carp{})
+		v1.AddToScheme(scheme)
+		s := protobuf.NewSerializer(scheme, scheme, "application/protobuf")
+		obj, err := runtime.Decode(s, test.data)
+
+		switch {
+		case err == nil && test.errFn != nil:
+			t.Errorf("%d: failed: %v", i, err)
+			continue
+		case err != nil && test.errFn == nil:
+			t.Errorf("%d: failed: %v", i, err)
+			continue
+		case err != nil:
+			if !test.errFn(err) {
+				t.Errorf("%d: failed: %v", i, err)
+			}
+			if obj != nil {
+				t.Errorf("%d: should not have returned an object", i)
+			}
+			continue
+		}
+
+		if !apiequality.Semantic.DeepEqual(obj, test.obj) {
+			t.Errorf("%d: unexpected object:\n%s", i, diff.ObjectGoPrintDiff(test.obj, obj))
+			continue
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/test/runtime_unversioned_test.go

@@ -0,0 +1,99 @@
+/*
+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 test
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	// TODO: Ideally we should create the necessary package structure in e.g.,
+	// pkg/conversion/test/... instead of importing pkg/api here.
+	apitesting "k8s.io/apimachinery/pkg/api/testing"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+func TestV1EncodeDecodeStatus(t *testing.T) {
+	status := &metav1.Status{
+		Status:  metav1.StatusFailure,
+		Code:    200,
+		Reason:  metav1.StatusReasonUnknown,
+		Message: "",
+	}
+
+	_, codecs := TestScheme()
+	codec := apitesting.TestCodec(codecs, schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal})
+
+	encoded, err := runtime.Encode(codec, status)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	typeMeta := metav1.TypeMeta{}
+	if err := json.Unmarshal(encoded, &typeMeta); err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if typeMeta.Kind != "Status" {
+		t.Errorf("Kind is not set to \"Status\". Got %v", string(encoded))
+	}
+	if typeMeta.APIVersion != "v1" {
+		t.Errorf("APIVersion is not set to \"v1\". Got %v", string(encoded))
+	}
+	decoded, err := runtime.Decode(codec, encoded)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(status, decoded) {
+		t.Errorf("expected: %v, got: %v", status, decoded)
+	}
+}
+
+func TestExperimentalEncodeDecodeStatus(t *testing.T) {
+	status := &metav1.Status{
+		Status:  metav1.StatusFailure,
+		Code:    200,
+		Reason:  metav1.StatusReasonUnknown,
+		Message: "",
+	}
+	// TODO: caesarxuchao: use the testapi.Extensions.Codec() once the PR that
+	// moves experimental from v1 to v1beta1 got merged.
+	_, codecs := TestScheme()
+	expCodec := apitesting.TestCodec(codecs, schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal})
+
+	encoded, err := runtime.Encode(expCodec, status)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	typeMeta := metav1.TypeMeta{}
+	if err := json.Unmarshal(encoded, &typeMeta); err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if typeMeta.Kind != "Status" {
+		t.Errorf("Kind is not set to \"Status\". Got %s", encoded)
+	}
+	if typeMeta.APIVersion != "v1" {
+		t.Errorf("APIVersion is not set to \"\". Got %s", encoded)
+	}
+	decoded, err := runtime.Decode(expCodec, encoded)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(status, decoded) {
+		t.Errorf("expected: %v, got: %v", status, decoded)
+	}
+}

vendor/k8s.io/apimachinery/pkg/test/util.go

@@ -0,0 +1,69 @@
+/*
+Copyright 2017 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 test
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/testapigroup"
+	"k8s.io/apimachinery/pkg/apis/testapigroup/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	apiserializer "k8s.io/apimachinery/pkg/runtime/serializer"
+)
+
+// List and ListV1 should be kept in sync with k8s.io/kubernetes/pkg/api#List
+// and k8s.io/api/core/v1#List.
+//
+// +k8s:deepcopy-gen=true
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+type List struct {
+	metav1.TypeMeta
+	metav1.ListMeta
+
+	Items []runtime.Object
+}
+
+// +k8s:deepcopy-gen=true
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+type ListV1 struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+	Items []runtime.RawExtension `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+func TestScheme() (*runtime.Scheme, apiserializer.CodecFactory) {
+	internalGV := schema.GroupVersion{Group: "", Version: runtime.APIVersionInternal}
+	externalGV := schema.GroupVersion{Group: "", Version: "v1"}
+	scheme := runtime.NewScheme()
+
+	scheme.AddKnownTypes(internalGV,
+		&testapigroup.Carp{},
+		&testapigroup.CarpList{},
+		&List{},
+	)
+	scheme.AddKnownTypes(externalGV,
+		&v1.Carp{},
+		&v1.CarpList{},
+		&List{},
+	)
+	testapigroup.AddToScheme(scheme)
+	v1.AddToScheme(scheme)
+
+	codecs := apiserializer.NewCodecFactory(scheme)
+	return scheme, codecs
+}

vendor/k8s.io/apimachinery/pkg/test/zz_generated.deepcopy.go

@@ -0,0 +1,97 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2017 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.
+*/
+
+// This file was autogenerated by deepcopy-gen. Do not edit it manually!
+
+package test
+
+import (
+	runtime "k8s.io/apimachinery/pkg/runtime"
+)
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *List) DeepCopyInto(out *List) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]runtime.Object, len(*in))
+		for i := range *in {
+			if (*in)[i] == nil {
+				(*out)[i] = nil
+			} else {
+				(*out)[i] = (*in)[i].DeepCopyObject()
+			}
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new List.
+func (in *List) DeepCopy() *List {
+	if in == nil {
+		return nil
+	}
+	out := new(List)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *List) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ListV1) DeepCopyInto(out *ListV1) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]runtime.RawExtension, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ListV1.
+func (in *ListV1) DeepCopy() *ListV1 {
+	if in == nil {
+		return nil
+	}
+	out := new(ListV1)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *ListV1) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	} else {
+		return nil
+	}
+}