Replace godep with dep

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/controller_ref_test.go

@@ -0,0 +1,133 @@
+/*
+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 v1
+
+import (
+	"testing"
+
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+type metaObj struct {
+	ObjectMeta
+	TypeMeta
+}
+
+func TestNewControllerRef(t *testing.T) {
+	gvk := schema.GroupVersionKind{
+		Group:   "group",
+		Version: "v1",
+		Kind:    "Kind",
+	}
+	obj1 := &metaObj{
+		ObjectMeta: ObjectMeta{
+			Name: "name",
+			UID:  "uid1",
+		},
+	}
+	controllerRef := NewControllerRef(obj1, gvk)
+	if controllerRef.UID != obj1.UID {
+		t.Errorf("Incorrect UID: %s", controllerRef.UID)
+	}
+	if controllerRef.Controller == nil || *controllerRef.Controller != true {
+		t.Error("Controller must be set to true")
+	}
+	if controllerRef.BlockOwnerDeletion == nil || *controllerRef.BlockOwnerDeletion != true {
+		t.Error("BlockOwnerDeletion must be set to true")
+	}
+	if controllerRef.APIVersion == "" ||
+		controllerRef.Kind == "" ||
+		controllerRef.Name == "" {
+		t.Errorf("All controllerRef fields must be set: %v", controllerRef)
+	}
+}
+
+func TestGetControllerOf(t *testing.T) {
+	gvk := schema.GroupVersionKind{
+		Group:   "group",
+		Version: "v1",
+		Kind:    "Kind",
+	}
+	obj1 := &metaObj{
+		ObjectMeta: ObjectMeta{
+			UID:  "uid1",
+			Name: "name1",
+		},
+	}
+	controllerRef := NewControllerRef(obj1, gvk)
+	var falseRef = false
+	obj2 := &metaObj{
+		ObjectMeta: ObjectMeta{
+			UID:  "uid2",
+			Name: "name1",
+			OwnerReferences: []OwnerReference{
+				{
+					Name:       "owner1",
+					Controller: &falseRef,
+				},
+				*controllerRef,
+				{
+					Name:       "owner2",
+					Controller: &falseRef,
+				},
+			},
+		},
+	}
+
+	if GetControllerOf(obj1) != nil {
+		t.Error("GetControllerOf must return null")
+	}
+	c := GetControllerOf(obj2)
+	if c.Name != controllerRef.Name || c.UID != controllerRef.UID {
+		t.Errorf("Incorrect result of GetControllerOf: %v", c)
+	}
+}
+
+func TestIsControlledBy(t *testing.T) {
+	gvk := schema.GroupVersionKind{
+		Group:   "group",
+		Version: "v1",
+		Kind:    "Kind",
+	}
+	obj1 := &metaObj{
+		ObjectMeta: ObjectMeta{
+			UID: "uid1",
+		},
+	}
+	obj2 := &metaObj{
+		ObjectMeta: ObjectMeta{
+			UID: "uid2",
+			OwnerReferences: []OwnerReference{
+				*NewControllerRef(obj1, gvk),
+			},
+		},
+	}
+	obj3 := &metaObj{
+		ObjectMeta: ObjectMeta{
+			UID: "uid3",
+			OwnerReferences: []OwnerReference{
+				*NewControllerRef(obj2, gvk),
+			},
+		},
+	}
+	if !IsControlledBy(obj2, obj1) || !IsControlledBy(obj3, obj2) {
+		t.Error("Incorrect IsControlledBy result: false")
+	}
+	if IsControlledBy(obj3, obj1) {
+		t.Error("Incorrect IsControlledBy result: true")
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/doc.go

@@ -19,4 +19,4 @@ limitations under the License.
 // +k8s:defaulter-gen=TypeMeta
 
 // +groupName=meta.k8s.io
-package v1
+package v1 // import "k8s.io/apimachinery/pkg/apis/meta/v1"

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/duration_test.go

@@ -0,0 +1,153 @@
+/*
+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 v1
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/ghodss/yaml"
+)
+
+type DurationHolder struct {
+	D Duration `json:"d"`
+}
+
+func TestDurationMarshalYAML(t *testing.T) {
+	cases := []struct {
+		input  Duration
+		result string
+	}{
+		{Duration{5 * time.Second}, "d: 5s\n"},
+		{Duration{2 * time.Minute}, "d: 2m0s\n"},
+		{Duration{time.Hour + 3*time.Millisecond}, "d: 1h0m0.003s\n"},
+	}
+
+	for _, c := range cases {
+		input := DurationHolder{c.input}
+		result, err := yaml.Marshal(&input)
+		if err != nil {
+			t.Errorf("Failed to marshal input: %q: %v", input, err)
+		}
+		if string(result) != c.result {
+			t.Errorf("Failed to marshal input: %q: expected %q, got %q", input, c.result, string(result))
+		}
+	}
+}
+
+func TestDurationUnmarshalYAML(t *testing.T) {
+	cases := []struct {
+		input  string
+		result Duration
+	}{
+		{"d: 0s\n", Duration{}},
+		{"d: 5s\n", Duration{5 * time.Second}},
+		{"d: 2m0s\n", Duration{2 * time.Minute}},
+		{"d: 1h0m0.003s\n", Duration{time.Hour + 3*time.Millisecond}},
+
+		// Units with zero values can optionally be dropped
+		{"d: 2m\n", Duration{2 * time.Minute}},
+		{"d: 1h0.003s\n", Duration{time.Hour + 3*time.Millisecond}},
+	}
+
+	for _, c := range cases {
+		var result DurationHolder
+		if err := yaml.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("Failed to unmarshal input %q: %v", c.input, err)
+		}
+		if result.D != c.result {
+			t.Errorf("Failed to unmarshal input %q: expected %q, got %q", c.input, c.result, result)
+		}
+	}
+}
+
+func TestDurationMarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  Duration
+		result string
+	}{
+		{Duration{5 * time.Second}, `{"d":"5s"}`},
+		{Duration{2 * time.Minute}, `{"d":"2m0s"}`},
+		{Duration{time.Hour + 3*time.Millisecond}, `{"d":"1h0m0.003s"}`},
+	}
+
+	for _, c := range cases {
+		input := DurationHolder{c.input}
+		result, err := json.Marshal(&input)
+		if err != nil {
+			t.Errorf("Failed to marshal input: %q: %v", input, err)
+		}
+		if string(result) != c.result {
+			t.Errorf("Failed to marshal input: %q: expected %q, got %q", input, c.result, string(result))
+		}
+	}
+}
+
+func TestDurationUnmarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  string
+		result Duration
+	}{
+		{`{"d":"0s"}`, Duration{}},
+		{`{"d":"5s"}`, Duration{5 * time.Second}},
+		{`{"d":"2m0s"}`, Duration{2 * time.Minute}},
+		{`{"d":"1h0m0.003s"}`, Duration{time.Hour + 3*time.Millisecond}},
+
+		// Units with zero values can optionally be dropped
+		{`{"d":"2m"}`, Duration{2 * time.Minute}},
+		{`{"d":"1h0.003s"}`, Duration{time.Hour + 3*time.Millisecond}},
+	}
+
+	for _, c := range cases {
+		var result DurationHolder
+		if err := json.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("Failed to unmarshal input %q: %v", c.input, err)
+		}
+		if result.D != c.result {
+			t.Errorf("Failed to unmarshal input %q: expected %q, got %q", c.input, c.result, result)
+		}
+	}
+}
+
+func TestDurationMarshalJSONUnmarshalYAML(t *testing.T) {
+	cases := []struct {
+		input Duration
+	}{
+		{Duration{}},
+		{Duration{5 * time.Second}},
+		{Duration{2 * time.Minute}},
+		{Duration{time.Hour + 3*time.Millisecond}},
+	}
+
+	for i, c := range cases {
+		input := DurationHolder{c.input}
+		jsonMarshalled, err := json.Marshal(&input)
+		if err != nil {
+			t.Errorf("%d-1: Failed to marshal input: '%v': %v", i, input, err)
+		}
+
+		var result DurationHolder
+		if err := yaml.Unmarshal(jsonMarshalled, &result); err != nil {
+			t.Errorf("%d-2: Failed to unmarshal '%+v': %v", i, string(jsonMarshalled), err)
+		}
+
+		if input.D != result.D {
+			t.Errorf("%d-4: Failed to marshal input '%#v': got %#v", i, input, result)
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/group_version_test.go

@@ -0,0 +1,78 @@
+/*
+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 v1
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	jsoniter "github.com/json-iterator/go"
+)
+
+type GroupVersionHolder struct {
+	GV GroupVersion `json:"val"`
+}
+
+func TestGroupVersionUnmarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  []byte
+		expect GroupVersion
+	}{
+		{[]byte(`{"val": "v1"}`), GroupVersion{"", "v1"}},
+		{[]byte(`{"val": "extensions/v1beta1"}`), GroupVersion{"extensions", "v1beta1"}},
+	}
+
+	for _, c := range cases {
+		var result GroupVersionHolder
+		// test golang lib's JSON codec
+		if err := json.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("JSON codec failed to unmarshal input '%v': %v", c.input, err)
+		}
+		if !reflect.DeepEqual(result.GV, c.expect) {
+			t.Errorf("JSON codec failed to unmarshal input '%s': expected %+v, got %+v", c.input, c.expect, result.GV)
+		}
+		// test the json-iterator codec
+		if err := jsoniter.ConfigFastest.Unmarshal(c.input, &result); err != nil {
+			t.Errorf("json-iterator codec failed to unmarshal input '%v': %v", c.input, err)
+		}
+		if !reflect.DeepEqual(result.GV, c.expect) {
+			t.Errorf("json-iterator codec failed to unmarshal input '%s': expected %+v, got %+v", c.input, c.expect, result.GV)
+		}
+	}
+}
+
+func TestGroupVersionMarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  GroupVersion
+		expect []byte
+	}{
+		{GroupVersion{"", "v1"}, []byte(`{"val":"v1"}`)},
+		{GroupVersion{"extensions", "v1beta1"}, []byte(`{"val":"extensions/v1beta1"}`)},
+	}
+
+	for _, c := range cases {
+		input := GroupVersionHolder{c.input}
+		result, err := json.Marshal(&input)
+		if err != nil {
+			t.Errorf("Failed to marshal input '%v': %v", input, err)
+		}
+		if !reflect.DeepEqual(result, c.expect) {
+			t.Errorf("Failed to marshal input '%+v': expected: %s, got: %s", input, c.expect, result)
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/helpers_test.go

@@ -0,0 +1,154 @@
+/*
+Copyright 2016 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 v1
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"k8s.io/apimachinery/pkg/labels"
+)
+
+func TestLabelSelectorAsSelector(t *testing.T) {
+	matchLabels := map[string]string{"foo": "bar"}
+	matchExpressions := []LabelSelectorRequirement{{
+		Key:      "baz",
+		Operator: LabelSelectorOpIn,
+		Values:   []string{"qux", "norf"},
+	}}
+	mustParse := func(s string) labels.Selector {
+		out, e := labels.Parse(s)
+		if e != nil {
+			panic(e)
+		}
+		return out
+	}
+	tc := []struct {
+		in        *LabelSelector
+		out       labels.Selector
+		expectErr bool
+	}{
+		{in: nil, out: labels.Nothing()},
+		{in: &LabelSelector{}, out: labels.Everything()},
+		{
+			in:  &LabelSelector{MatchLabels: matchLabels},
+			out: mustParse("foo=bar"),
+		},
+		{
+			in:  &LabelSelector{MatchExpressions: matchExpressions},
+			out: mustParse("baz in (norf,qux)"),
+		},
+		{
+			in:  &LabelSelector{MatchLabels: matchLabels, MatchExpressions: matchExpressions},
+			out: mustParse("baz in (norf,qux),foo=bar"),
+		},
+		{
+			in: &LabelSelector{
+				MatchExpressions: []LabelSelectorRequirement{{
+					Key:      "baz",
+					Operator: LabelSelectorOpExists,
+					Values:   []string{"qux", "norf"},
+				}},
+			},
+			expectErr: true,
+		},
+	}
+
+	for i, tc := range tc {
+		out, err := LabelSelectorAsSelector(tc.in)
+		if err == nil && tc.expectErr {
+			t.Errorf("[%v]expected error but got none.", i)
+		}
+		if err != nil && !tc.expectErr {
+			t.Errorf("[%v]did not expect error but got: %v", i, err)
+		}
+		if !reflect.DeepEqual(out, tc.out) {
+			t.Errorf("[%v]expected:\n\t%+v\nbut got:\n\t%+v", i, tc.out, out)
+		}
+	}
+}
+
+func TestLabelSelectorAsMap(t *testing.T) {
+	matchLabels := map[string]string{"foo": "bar"}
+	matchExpressions := func(operator LabelSelectorOperator, values []string) []LabelSelectorRequirement {
+		return []LabelSelectorRequirement{{
+			Key:      "baz",
+			Operator: operator,
+			Values:   values,
+		}}
+	}
+
+	tests := []struct {
+		in        *LabelSelector
+		out       map[string]string
+		errString string
+	}{
+		{in: nil, out: nil},
+		{
+			in:  &LabelSelector{MatchLabels: matchLabels},
+			out: map[string]string{"foo": "bar"},
+		},
+		{
+			in:  &LabelSelector{MatchLabels: matchLabels, MatchExpressions: matchExpressions(LabelSelectorOpIn, []string{"norf"})},
+			out: map[string]string{"foo": "bar", "baz": "norf"},
+		},
+		{
+			in:  &LabelSelector{MatchExpressions: matchExpressions(LabelSelectorOpIn, []string{"norf"})},
+			out: map[string]string{"baz": "norf"},
+		},
+		{
+			in:        &LabelSelector{MatchLabels: matchLabels, MatchExpressions: matchExpressions(LabelSelectorOpIn, []string{"norf", "qux"})},
+			out:       map[string]string{"foo": "bar"},
+			errString: "without a single value cannot be converted",
+		},
+		{
+			in:        &LabelSelector{MatchExpressions: matchExpressions(LabelSelectorOpNotIn, []string{"norf", "qux"})},
+			out:       map[string]string{},
+			errString: "cannot be converted",
+		},
+		{
+			in:        &LabelSelector{MatchLabels: matchLabels, MatchExpressions: matchExpressions(LabelSelectorOpExists, []string{})},
+			out:       map[string]string{"foo": "bar"},
+			errString: "cannot be converted",
+		},
+		{
+			in:        &LabelSelector{MatchExpressions: matchExpressions(LabelSelectorOpDoesNotExist, []string{})},
+			out:       map[string]string{},
+			errString: "cannot be converted",
+		},
+	}
+
+	for i, tc := range tests {
+		out, err := LabelSelectorAsMap(tc.in)
+		if err == nil && len(tc.errString) > 0 {
+			t.Errorf("[%v]expected error but got none.", i)
+			continue
+		}
+		if err != nil && len(tc.errString) == 0 {
+			t.Errorf("[%v]did not expect error but got: %v", i, err)
+			continue
+		}
+		if err != nil && len(tc.errString) > 0 && !strings.Contains(err.Error(), tc.errString) {
+			t.Errorf("[%v]expected error with %q but got: %v", i, tc.errString, err)
+			continue
+		}
+		if !reflect.DeepEqual(out, tc.out) {
+			t.Errorf("[%v]expected:\n\t%+v\nbut got:\n\t%+v", i, tc.out, out)
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/labels_test.go

@@ -0,0 +1,120 @@
+/*
+Copyright 2016 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 v1
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestCloneSelectorAndAddLabel(t *testing.T) {
+	labels := map[string]string{
+		"foo1": "bar1",
+		"foo2": "bar2",
+		"foo3": "bar3",
+	}
+
+	cases := []struct {
+		labels     map[string]string
+		labelKey   string
+		labelValue string
+		want       map[string]string
+	}{
+		{
+			labels: labels,
+			want:   labels,
+		},
+		{
+			labels:     labels,
+			labelKey:   "foo4",
+			labelValue: "89",
+			want: map[string]string{
+				"foo1": "bar1",
+				"foo2": "bar2",
+				"foo3": "bar3",
+				"foo4": "89",
+			},
+		},
+		{
+			labels:     nil,
+			labelKey:   "foo4",
+			labelValue: "12",
+			want: map[string]string{
+				"foo4": "12",
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		ls_in := LabelSelector{MatchLabels: tc.labels}
+		ls_out := LabelSelector{MatchLabels: tc.want}
+
+		got := CloneSelectorAndAddLabel(&ls_in, tc.labelKey, tc.labelValue)
+		if !reflect.DeepEqual(got, &ls_out) {
+			t.Errorf("got %v, want %v", got, tc.want)
+		}
+	}
+}
+
+func TestAddLabelToSelector(t *testing.T) {
+	labels := map[string]string{
+		"foo1": "bar1",
+		"foo2": "bar2",
+		"foo3": "bar3",
+	}
+
+	cases := []struct {
+		labels     map[string]string
+		labelKey   string
+		labelValue string
+		want       map[string]string
+	}{
+		{
+			labels: labels,
+			want:   labels,
+		},
+		{
+			labels:     labels,
+			labelKey:   "foo4",
+			labelValue: "89",
+			want: map[string]string{
+				"foo1": "bar1",
+				"foo2": "bar2",
+				"foo3": "bar3",
+				"foo4": "89",
+			},
+		},
+		{
+			labels:     nil,
+			labelKey:   "foo4",
+			labelValue: "12",
+			want: map[string]string{
+				"foo4": "12",
+			},
+		},
+	}
+
+	for _, tc := range cases {
+		ls_in := LabelSelector{MatchLabels: tc.labels}
+		ls_out := LabelSelector{MatchLabels: tc.want}
+
+		got := AddLabelToSelector(&ls_in, tc.labelKey, tc.labelValue)
+		if !reflect.DeepEqual(got, &ls_out) {
+			t.Errorf("got %v, want %v", got, tc.want)
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/micro_time_test.go

@@ -0,0 +1,139 @@
+/*
+Copyright 2016 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 v1
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/ghodss/yaml"
+)
+
+type MicroTimeHolder struct {
+	T MicroTime `json:"t"`
+}
+
+func TestMicroTimeMarshalYAML(t *testing.T) {
+	cases := []struct {
+		input  MicroTime
+		result string
+	}{
+		{MicroTime{}, "t: null\n"},
+		{DateMicro(1998, time.May, 5, 1, 5, 5, 50, time.FixedZone("test", -4*60*60)), "t: 1998-05-05T05:05:05.000000Z\n"},
+		{DateMicro(1998, time.May, 5, 5, 5, 5, 0, time.UTC), "t: 1998-05-05T05:05:05.000000Z\n"},
+	}
+
+	for _, c := range cases {
+		input := MicroTimeHolder{c.input}
+		result, err := yaml.Marshal(&input)
+		if err != nil {
+			t.Errorf("Failed to marshal input: '%v': %v", input, err)
+		}
+		if string(result) != c.result {
+			t.Errorf("Failed to marshal input: '%v': expected %+v, got %q", input, c.result, string(result))
+		}
+	}
+}
+
+func TestMicroTimeUnmarshalYAML(t *testing.T) {
+	cases := []struct {
+		input  string
+		result MicroTime
+	}{
+		{"t: null\n", MicroTime{}},
+		{"t: 1998-05-05T05:05:05.000000Z\n", MicroTime{Date(1998, time.May, 5, 5, 5, 5, 0, time.UTC).Local()}},
+	}
+
+	for _, c := range cases {
+		var result MicroTimeHolder
+		if err := yaml.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("Failed to unmarshal input '%v': %v", c.input, err)
+		}
+		if result.T != c.result {
+			t.Errorf("Failed to unmarshal input '%v': expected %+v, got %+v", c.input, c.result, result)
+		}
+	}
+}
+
+func TestMicroTimeMarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  MicroTime
+		result string
+	}{
+		{MicroTime{}, "{\"t\":null}"},
+		{DateMicro(1998, time.May, 5, 5, 5, 5, 50, time.UTC), "{\"t\":\"1998-05-05T05:05:05.000000Z\"}"},
+		{DateMicro(1998, time.May, 5, 5, 5, 5, 0, time.UTC), "{\"t\":\"1998-05-05T05:05:05.000000Z\"}"},
+	}
+
+	for _, c := range cases {
+		input := MicroTimeHolder{c.input}
+		result, err := json.Marshal(&input)
+		if err != nil {
+			t.Errorf("Failed to marshal input: '%v': %v", input, err)
+		}
+		if string(result) != c.result {
+			t.Errorf("Failed to marshal input: '%v': expected %+v, got %q", input, c.result, string(result))
+		}
+	}
+}
+
+func TestMicroTimeUnmarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  string
+		result MicroTime
+	}{
+		{"{\"t\":null}", MicroTime{}},
+		{"{\"t\":\"1998-05-05T05:05:05.000000Z\"}", MicroTime{Date(1998, time.May, 5, 5, 5, 5, 0, time.UTC).Local()}},
+	}
+
+	for _, c := range cases {
+		var result MicroTimeHolder
+		if err := json.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("Failed to unmarshal input '%v': %v", c.input, err)
+		}
+		if result.T != c.result {
+			t.Errorf("Failed to unmarshal input '%v': expected %+v, got %+v", c.input, c.result, result)
+		}
+	}
+}
+
+func TestMicroTimeProto(t *testing.T) {
+	cases := []struct {
+		input MicroTime
+	}{
+		{MicroTime{}},
+		{DateMicro(1998, time.May, 5, 1, 5, 5, 50, time.Local)},
+		{DateMicro(1998, time.May, 5, 5, 5, 5, 0, time.Local)},
+	}
+
+	for _, c := range cases {
+		input := c.input
+		data, err := input.Marshal()
+		if err != nil {
+			t.Fatalf("Failed to marshal input: '%v': %v", input, err)
+		}
+		time := MicroTime{}
+		if err := time.Unmarshal(data); err != nil {
+			t.Fatalf("Failed to unmarshal output: '%v': %v", input, err)
+		}
+		if !reflect.DeepEqual(input, time) {
+			t.Errorf("Marshal->Unmarshal is not idempotent: '%v' vs '%v'", input, time)
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/time_test.go

@@ -0,0 +1,173 @@
+/*
+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 v1
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/ghodss/yaml"
+)
+
+type TimeHolder struct {
+	T Time `json:"t"`
+}
+
+func TestTimeMarshalYAML(t *testing.T) {
+	cases := []struct {
+		input  Time
+		result string
+	}{
+		{Time{}, "t: null\n"},
+		{Date(1998, time.May, 5, 1, 5, 5, 50, time.FixedZone("test", -4*60*60)), "t: 1998-05-05T05:05:05Z\n"},
+		{Date(1998, time.May, 5, 5, 5, 5, 0, time.UTC), "t: 1998-05-05T05:05:05Z\n"},
+	}
+
+	for _, c := range cases {
+		input := TimeHolder{c.input}
+		result, err := yaml.Marshal(&input)
+		if err != nil {
+			t.Errorf("Failed to marshal input: '%v': %v", input, err)
+		}
+		if string(result) != c.result {
+			t.Errorf("Failed to marshal input: '%v': expected %+v, got %q", input, c.result, string(result))
+		}
+	}
+}
+
+func TestTimeUnmarshalYAML(t *testing.T) {
+	cases := []struct {
+		input  string
+		result Time
+	}{
+		{"t: null\n", Time{}},
+		{"t: 1998-05-05T05:05:05Z\n", Time{Date(1998, time.May, 5, 5, 5, 5, 0, time.UTC).Local()}},
+	}
+
+	for _, c := range cases {
+		var result TimeHolder
+		if err := yaml.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("Failed to unmarshal input '%v': %v", c.input, err)
+		}
+		if result.T != c.result {
+			t.Errorf("Failed to unmarshal input '%v': expected %+v, got %+v", c.input, c.result, result)
+		}
+	}
+}
+
+func TestTimeMarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  Time
+		result string
+	}{
+		{Time{}, "{\"t\":null}"},
+		{Date(1998, time.May, 5, 5, 5, 5, 50, time.UTC), "{\"t\":\"1998-05-05T05:05:05Z\"}"},
+		{Date(1998, time.May, 5, 5, 5, 5, 0, time.UTC), "{\"t\":\"1998-05-05T05:05:05Z\"}"},
+	}
+
+	for _, c := range cases {
+		input := TimeHolder{c.input}
+		result, err := json.Marshal(&input)
+		if err != nil {
+			t.Errorf("Failed to marshal input: '%v': %v", input, err)
+		}
+		if string(result) != c.result {
+			t.Errorf("Failed to marshal input: '%v': expected %+v, got %q", input, c.result, string(result))
+		}
+	}
+}
+
+func TestTimeUnmarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  string
+		result Time
+	}{
+		{"{\"t\":null}", Time{}},
+		{"{\"t\":\"1998-05-05T05:05:05Z\"}", Time{Date(1998, time.May, 5, 5, 5, 5, 0, time.UTC).Local()}},
+	}
+
+	for _, c := range cases {
+		var result TimeHolder
+		if err := json.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("Failed to unmarshal input '%v': %v", c.input, err)
+		}
+		if result.T != c.result {
+			t.Errorf("Failed to unmarshal input '%v': expected %+v, got %+v", c.input, c.result, result)
+		}
+	}
+}
+
+func TestTimeMarshalJSONUnmarshalYAML(t *testing.T) {
+	cases := []struct {
+		input Time
+	}{
+		{Time{}},
+		{Date(1998, time.May, 5, 5, 5, 5, 50, time.Local).Rfc3339Copy()},
+		{Date(1998, time.May, 5, 5, 5, 5, 0, time.Local).Rfc3339Copy()},
+	}
+
+	for i, c := range cases {
+		input := TimeHolder{c.input}
+		jsonMarshalled, err := json.Marshal(&input)
+		if err != nil {
+			t.Errorf("%d-1: Failed to marshal input: '%v': %v", i, input, err)
+		}
+
+		var result TimeHolder
+		err = yaml.Unmarshal(jsonMarshalled, &result)
+		if err != nil {
+			t.Errorf("%d-2: Failed to unmarshal '%+v': %v", i, string(jsonMarshalled), err)
+		}
+
+		iN, iO := input.T.Zone()
+		oN, oO := result.T.Zone()
+		if iN != oN || iO != oO {
+			t.Errorf("%d-3: Time zones differ before and after serialization %s:%d %s:%d", i, iN, iO, oN, oO)
+		}
+
+		if input.T.UnixNano() != result.T.UnixNano() {
+			t.Errorf("%d-4: Failed to marshal input '%#v': got %#v", i, input, result)
+		}
+	}
+}
+
+func TestTimeProto(t *testing.T) {
+	cases := []struct {
+		input Time
+	}{
+		{Time{}},
+		{Date(1998, time.May, 5, 1, 5, 5, 0, time.Local)},
+		{Date(1998, time.May, 5, 5, 5, 5, 0, time.Local)},
+	}
+
+	for _, c := range cases {
+		input := c.input
+		data, err := input.Marshal()
+		if err != nil {
+			t.Fatalf("Failed to marshal input: '%v': %v", input, err)
+		}
+		time := Time{}
+		if err := time.Unmarshal(data); err != nil {
+			t.Fatalf("Failed to unmarshal output: '%v': %v", input, err)
+		}
+		if !reflect.DeepEqual(input, time) {
+			t.Errorf("Marshal->Unmarshal is not idempotent: '%v' vs '%v'", input, time)
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/types_test.go

@@ -0,0 +1,134 @@
+/*
+Copyright 2016 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 v1
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	jsoniter "github.com/json-iterator/go"
+)
+
+func TestVerbsUgorjiMarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  APIResource
+		result string
+	}{
+		{APIResource{}, `{"name":"","singularName":"","namespaced":false,"kind":"","verbs":null}`},
+		{APIResource{Verbs: Verbs([]string{})}, `{"name":"","singularName":"","namespaced":false,"kind":"","verbs":[]}`},
+		{APIResource{Verbs: Verbs([]string{"delete"})}, `{"name":"","singularName":"","namespaced":false,"kind":"","verbs":["delete"]}`},
+	}
+
+	for i, c := range cases {
+		result, err := json.Marshal(&c.input)
+		if err != nil {
+			t.Errorf("[%d] Failed to marshal input: '%v': %v", i, c.input, err)
+		}
+		if string(result) != c.result {
+			t.Errorf("[%d] Failed to marshal input: '%v': expected '%v', got '%v'", i, c.input, c.result, string(result))
+		}
+	}
+}
+
+func TestVerbsUgorjiUnmarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  string
+		result APIResource
+	}{
+		{`{}`, APIResource{}},
+		{`{"verbs":null}`, APIResource{}},
+		{`{"verbs":[]}`, APIResource{Verbs: Verbs([]string{})}},
+		{`{"verbs":["delete"]}`, APIResource{Verbs: Verbs([]string{"delete"})}},
+	}
+
+	for i, c := range cases {
+		var result APIResource
+		if err := jsoniter.ConfigFastest.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("[%d] Failed to unmarshal input '%v': %v", i, c.input, err)
+		}
+		if !reflect.DeepEqual(result, c.result) {
+			t.Errorf("[%d] Failed to unmarshal input '%v': expected %+v, got %+v", i, c.input, c.result, result)
+		}
+	}
+}
+
+// TestUgorjiMarshalJSONWithOmit tests that we don't have regressions regarding nil and empty slices with "omit"
+func TestUgorjiMarshalJSONWithOmit(t *testing.T) {
+	cases := []struct {
+		input  LabelSelector
+		result string
+	}{
+		{LabelSelector{}, `{}`},
+		{LabelSelector{MatchExpressions: []LabelSelectorRequirement{}}, `{}`},
+		{LabelSelector{MatchExpressions: []LabelSelectorRequirement{{}}}, `{"matchExpressions":[{"key":"","operator":""}]}`},
+	}
+
+	for i, c := range cases {
+		result, err := json.Marshal(&c.input)
+		if err != nil {
+			t.Errorf("[%d] Failed to marshal input: '%v': %v", i, c.input, err)
+		}
+		if string(result) != c.result {
+			t.Errorf("[%d] Failed to marshal input: '%v': expected '%v', got '%v'", i, c.input, c.result, string(result))
+		}
+	}
+}
+
+func TestVerbsUnmarshalJSON(t *testing.T) {
+	cases := []struct {
+		input  string
+		result APIResource
+	}{
+		{`{}`, APIResource{}},
+		{`{"verbs":null}`, APIResource{}},
+		{`{"verbs":[]}`, APIResource{Verbs: Verbs([]string{})}},
+		{`{"verbs":["delete"]}`, APIResource{Verbs: Verbs([]string{"delete"})}},
+	}
+
+	for i, c := range cases {
+		var result APIResource
+		if err := json.Unmarshal([]byte(c.input), &result); err != nil {
+			t.Errorf("[%d] Failed to unmarshal input '%v': %v", i, c.input, err)
+		}
+		if !reflect.DeepEqual(result, c.result) {
+			t.Errorf("[%d] Failed to unmarshal input '%v': expected %+v, got %+v", i, c.input, c.result, result)
+		}
+	}
+}
+
+func TestVerbsProto(t *testing.T) {
+	cases := []APIResource{
+		{},
+		{Verbs: Verbs([]string{})},
+		{Verbs: Verbs([]string{"delete"})},
+	}
+
+	for _, input := range cases {
+		data, err := input.Marshal()
+		if err != nil {
+			t.Fatalf("Failed to marshal input: '%v': %v", input, err)
+		}
+		resource := APIResource{}
+		if err := resource.Unmarshal(data); err != nil {
+			t.Fatalf("Failed to unmarshal output: '%v': %v", input, err)
+		}
+		if !reflect.DeepEqual(input, resource) {
+			t.Errorf("Marshal->Unmarshal is not idempotent: '%v' vs '%v'", input, resource)
+		}
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured/unstructured_test.go

@@ -0,0 +1,60 @@
+/*
+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 unstructured
+
+import (
+	"io/ioutil"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestCodecOfUnstructuredList tests that there are no data races in Encode().
+// i.e. that it does not mutate the object being encoded.
+func TestCodecOfUnstructuredList(t *testing.T) {
+	var wg sync.WaitGroup
+	concurrency := 10
+	list := UnstructuredList{
+		Object: map[string]interface{}{},
+	}
+	wg.Add(concurrency)
+	for i := 0; i < concurrency; i++ {
+		go func() {
+			defer wg.Done()
+			assert.NoError(t, UnstructuredJSONScheme.Encode(&list, ioutil.Discard))
+		}()
+	}
+	wg.Wait()
+}
+
+func TestUnstructuredList(t *testing.T) {
+	list := &UnstructuredList{
+		Object: map[string]interface{}{"kind": "List", "apiVersion": "v1"},
+		Items: []Unstructured{
+			{Object: map[string]interface{}{"kind": "Pod", "apiVersion": "v1", "metadata": map[string]interface{}{"name": "test"}}},
+		},
+	}
+	content := list.UnstructuredContent()
+	items := content["items"].([]interface{})
+	if len(items) != 1 {
+		t.Fatalf("unexpected items: %#v", items)
+	}
+	if getNestedField(items[0].(map[string]interface{}), "metadata", "name") != "test" {
+		t.Fatalf("unexpected fields: %#v", items[0])
+	}
+}

vendor/k8s.io/apimachinery/pkg/apis/meta/v1/validation/validation_test.go

@@ -0,0 +1,94 @@
+/*
+Copyright 2016 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 validation
+
+import (
+	"strings"
+	"testing"
+
+	"k8s.io/apimachinery/pkg/util/validation/field"
+)
+
+func TestValidateLabels(t *testing.T) {
+	successCases := []map[string]string{
+		{"simple": "bar"},
+		{"now-with-dashes": "bar"},
+		{"1-starts-with-num": "bar"},
+		{"1234": "bar"},
+		{"simple/simple": "bar"},
+		{"now-with-dashes/simple": "bar"},
+		{"now-with-dashes/now-with-dashes": "bar"},
+		{"now.with.dots/simple": "bar"},
+		{"now-with.dashes-and.dots/simple": "bar"},
+		{"1-num.2-num/3-num": "bar"},
+		{"1234/5678": "bar"},
+		{"1.2.3.4/5678": "bar"},
+		{"UpperCaseAreOK123": "bar"},
+		{"goodvalue": "123_-.BaR"},
+	}
+	for i := range successCases {
+		errs := ValidateLabels(successCases[i], field.NewPath("field"))
+		if len(errs) != 0 {
+			t.Errorf("case[%d] expected success, got %#v", i, errs)
+		}
+	}
+
+	namePartErrMsg := "name part must consist of"
+	nameErrMsg := "a qualified name must consist of"
+	labelErrMsg := "a valid label must be an empty string or consist of"
+	maxLengthErrMsg := "must be no more than"
+
+	labelNameErrorCases := []struct {
+		labels map[string]string
+		expect string
+	}{
+		{map[string]string{"nospecialchars^=@": "bar"}, namePartErrMsg},
+		{map[string]string{"cantendwithadash-": "bar"}, namePartErrMsg},
+		{map[string]string{"only/one/slash": "bar"}, nameErrMsg},
+		{map[string]string{strings.Repeat("a", 254): "bar"}, maxLengthErrMsg},
+	}
+	for i := range labelNameErrorCases {
+		errs := ValidateLabels(labelNameErrorCases[i].labels, field.NewPath("field"))
+		if len(errs) != 1 {
+			t.Errorf("case[%d]: expected failure", i)
+		} else {
+			if !strings.Contains(errs[0].Detail, labelNameErrorCases[i].expect) {
+				t.Errorf("case[%d]: error details do not include %q: %q", i, labelNameErrorCases[i].expect, errs[0].Detail)
+			}
+		}
+	}
+
+	labelValueErrorCases := []struct {
+		labels map[string]string
+		expect string
+	}{
+		{map[string]string{"toolongvalue": strings.Repeat("a", 64)}, maxLengthErrMsg},
+		{map[string]string{"backslashesinvalue": "some\\bad\\value"}, labelErrMsg},
+		{map[string]string{"nocommasallowed": "bad,value"}, labelErrMsg},
+		{map[string]string{"strangecharsinvalue": "?#$notsogood"}, labelErrMsg},
+	}
+	for i := range labelValueErrorCases {
+		errs := ValidateLabels(labelValueErrorCases[i].labels, field.NewPath("field"))
+		if len(errs) != 1 {
+			t.Errorf("case[%d]: expected failure", i)
+		} else {
+			if !strings.Contains(errs[0].Detail, labelValueErrorCases[i].expect) {
+				t.Errorf("case[%d]: error details do not include %q: %q", i, labelValueErrorCases[i].expect, errs[0].Detail)
+			}
+		}
+	}
+}