Add generated file

This PR adds generated files under pkg/client and vendor folder.

vendor/k8s.io/kubernetes/pkg/scheduler/testing/BUILD

@@ -0,0 +1,57 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "fake_cache.go",
+        "fake_lister.go",
+        "pods_to_cache.go",
+        "util.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/scheduler/testing",
+    deps = [
+        "//pkg/api/legacyscheme:go_default_library",
+        "//pkg/apis/core:go_default_library",
+        "//pkg/apis/core/install:go_default_library",
+        "//pkg/scheduler/algorithm:go_default_library",
+        "//pkg/scheduler/cache:go_default_library",
+        "//vendor/k8s.io/api/apps/v1beta1:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/api/extensions/v1beta1:go_default_library",
+        "//vendor/k8s.io/api/policy/v1beta1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/labels: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/client-go/listers/core/v1:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["util_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/scheduler/testing/fake_cache.go

@@ -0,0 +1,110 @@
+/*
+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 testing
+
+import (
+	"k8s.io/api/core/v1"
+	policy "k8s.io/api/policy/v1beta1"
+	"k8s.io/apimachinery/pkg/labels"
+	schedulercache "k8s.io/kubernetes/pkg/scheduler/cache"
+)
+
+// FakeCache is used for testing
+type FakeCache struct {
+	AssumeFunc       func(*v1.Pod)
+	ForgetFunc       func(*v1.Pod)
+	IsAssumedPodFunc func(*v1.Pod) bool
+	GetPodFunc       func(*v1.Pod) *v1.Pod
+}
+
+// AssumePod is a fake method for testing.
+func (f *FakeCache) AssumePod(pod *v1.Pod) error {
+	f.AssumeFunc(pod)
+	return nil
+}
+
+// FinishBinding is a fake method for testing.
+func (f *FakeCache) FinishBinding(pod *v1.Pod) error { return nil }
+
+// ForgetPod is a fake method for testing.
+func (f *FakeCache) ForgetPod(pod *v1.Pod) error {
+	f.ForgetFunc(pod)
+	return nil
+}
+
+// AddPod is a fake method for testing.
+func (f *FakeCache) AddPod(pod *v1.Pod) error { return nil }
+
+// UpdatePod is a fake method for testing.
+func (f *FakeCache) UpdatePod(oldPod, newPod *v1.Pod) error { return nil }
+
+// RemovePod is a fake method for testing.
+func (f *FakeCache) RemovePod(pod *v1.Pod) error { return nil }
+
+// IsAssumedPod is a fake method for testing.
+func (f *FakeCache) IsAssumedPod(pod *v1.Pod) (bool, error) {
+	return f.IsAssumedPodFunc(pod), nil
+}
+
+// GetPod is a fake method for testing.
+func (f *FakeCache) GetPod(pod *v1.Pod) (*v1.Pod, error) {
+	return f.GetPodFunc(pod), nil
+}
+
+// AddNode is a fake method for testing.
+func (f *FakeCache) AddNode(node *v1.Node) error { return nil }
+
+// UpdateNode is a fake method for testing.
+func (f *FakeCache) UpdateNode(oldNode, newNode *v1.Node) error { return nil }
+
+// RemoveNode is a fake method for testing.
+func (f *FakeCache) RemoveNode(node *v1.Node) error { return nil }
+
+// UpdateNodeNameToInfoMap is a fake method for testing.
+func (f *FakeCache) UpdateNodeNameToInfoMap(infoMap map[string]*schedulercache.NodeInfo) error {
+	return nil
+}
+
+// AddPDB is a fake method for testing.
+func (f *FakeCache) AddPDB(pdb *policy.PodDisruptionBudget) error { return nil }
+
+// UpdatePDB is a fake method for testing.
+func (f *FakeCache) UpdatePDB(oldPDB, newPDB *policy.PodDisruptionBudget) error { return nil }
+
+// RemovePDB is a fake method for testing.
+func (f *FakeCache) RemovePDB(pdb *policy.PodDisruptionBudget) error { return nil }
+
+// ListPDBs is a fake method for testing.
+func (f *FakeCache) ListPDBs(selector labels.Selector) ([]*policy.PodDisruptionBudget, error) {
+	return nil, nil
+}
+
+// List is a fake method for testing.
+func (f *FakeCache) List(s labels.Selector) ([]*v1.Pod, error) { return nil, nil }
+
+// FilteredList is a fake method for testing.
+func (f *FakeCache) FilteredList(filter schedulercache.PodFilter, selector labels.Selector) ([]*v1.Pod, error) {
+	return nil, nil
+}
+
+// Snapshot is a fake method for testing
+func (f *FakeCache) Snapshot() *schedulercache.Snapshot {
+	return &schedulercache.Snapshot{}
+}
+
+// IsUpToDate is a fake mthod for testing
+func (f *FakeCache) IsUpToDate(*schedulercache.NodeInfo) bool { return true }

vendor/k8s.io/kubernetes/pkg/scheduler/testing/fake_lister.go

@@ -0,0 +1,217 @@
+/*
+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 testing
+
+import (
+	"fmt"
+
+	apps "k8s.io/api/apps/v1beta1"
+	"k8s.io/api/core/v1"
+	extensions "k8s.io/api/extensions/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	corelisters "k8s.io/client-go/listers/core/v1"
+	"k8s.io/kubernetes/pkg/scheduler/algorithm"
+	schedulercache "k8s.io/kubernetes/pkg/scheduler/cache"
+)
+
+var _ algorithm.NodeLister = &FakeNodeLister{}
+
+// FakeNodeLister implements NodeLister on a []string for test purposes.
+type FakeNodeLister []*v1.Node
+
+// List returns nodes as a []string.
+func (f FakeNodeLister) List() ([]*v1.Node, error) {
+	return f, nil
+}
+
+var _ algorithm.PodLister = &FakePodLister{}
+
+// FakePodLister implements PodLister on an []v1.Pods for test purposes.
+type FakePodLister []*v1.Pod
+
+// List returns []*v1.Pod matching a query.
+func (f FakePodLister) List(s labels.Selector) (selected []*v1.Pod, err error) {
+	for _, pod := range f {
+		if s.Matches(labels.Set(pod.Labels)) {
+			selected = append(selected, pod)
+		}
+	}
+	return selected, nil
+}
+
+// FilteredList returns pods matching a pod filter and a label selector.
+func (f FakePodLister) FilteredList(podFilter schedulercache.PodFilter, s labels.Selector) (selected []*v1.Pod, err error) {
+	for _, pod := range f {
+		if podFilter(pod) && s.Matches(labels.Set(pod.Labels)) {
+			selected = append(selected, pod)
+		}
+	}
+	return selected, nil
+}
+
+var _ algorithm.ServiceLister = &FakeServiceLister{}
+
+// FakeServiceLister implements ServiceLister on []v1.Service for test purposes.
+type FakeServiceLister []*v1.Service
+
+// List returns v1.ServiceList, the list of all services.
+func (f FakeServiceLister) List(labels.Selector) ([]*v1.Service, error) {
+	return f, nil
+}
+
+// GetPodServices gets the services that have the selector that match the labels on the given pod.
+func (f FakeServiceLister) GetPodServices(pod *v1.Pod) (services []*v1.Service, err error) {
+	var selector labels.Selector
+
+	for i := range f {
+		service := f[i]
+		// consider only services that are in the same namespace as the pod
+		if service.Namespace != pod.Namespace {
+			continue
+		}
+		selector = labels.Set(service.Spec.Selector).AsSelectorPreValidated()
+		if selector.Matches(labels.Set(pod.Labels)) {
+			services = append(services, service)
+		}
+	}
+	return
+}
+
+var _ algorithm.ControllerLister = &FakeControllerLister{}
+
+// FakeControllerLister implements ControllerLister on []v1.ReplicationController for test purposes.
+type FakeControllerLister []*v1.ReplicationController
+
+// List returns []v1.ReplicationController, the list of all ReplicationControllers.
+func (f FakeControllerLister) List(labels.Selector) ([]*v1.ReplicationController, error) {
+	return f, nil
+}
+
+// GetPodControllers gets the ReplicationControllers that have the selector that match the labels on the given pod
+func (f FakeControllerLister) GetPodControllers(pod *v1.Pod) (controllers []*v1.ReplicationController, err error) {
+	var selector labels.Selector
+
+	for i := range f {
+		controller := f[i]
+		if controller.Namespace != pod.Namespace {
+			continue
+		}
+		selector = labels.Set(controller.Spec.Selector).AsSelectorPreValidated()
+		if selector.Matches(labels.Set(pod.Labels)) {
+			controllers = append(controllers, controller)
+		}
+	}
+	if len(controllers) == 0 {
+		err = fmt.Errorf("Could not find Replication Controller for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
+	}
+
+	return
+}
+
+var _ algorithm.ReplicaSetLister = &FakeReplicaSetLister{}
+
+// FakeReplicaSetLister implements ControllerLister on []extensions.ReplicaSet for test purposes.
+type FakeReplicaSetLister []*extensions.ReplicaSet
+
+// GetPodReplicaSets gets the ReplicaSets that have the selector that match the labels on the given pod
+func (f FakeReplicaSetLister) GetPodReplicaSets(pod *v1.Pod) (rss []*extensions.ReplicaSet, err error) {
+	var selector labels.Selector
+
+	for _, rs := range f {
+		if rs.Namespace != pod.Namespace {
+			continue
+		}
+		selector, err = metav1.LabelSelectorAsSelector(rs.Spec.Selector)
+		if err != nil {
+			return
+		}
+
+		if selector.Matches(labels.Set(pod.Labels)) {
+			rss = append(rss, rs)
+		}
+	}
+	if len(rss) == 0 {
+		err = fmt.Errorf("Could not find ReplicaSet for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
+	}
+
+	return
+}
+
+var _ algorithm.StatefulSetLister = &FakeStatefulSetLister{}
+
+// FakeStatefulSetLister implements ControllerLister on []apps.StatefulSet for testing purposes.
+type FakeStatefulSetLister []*apps.StatefulSet
+
+// GetPodStatefulSets gets the StatefulSets that have the selector that match the labels on the given pod.
+func (f FakeStatefulSetLister) GetPodStatefulSets(pod *v1.Pod) (sss []*apps.StatefulSet, err error) {
+	var selector labels.Selector
+
+	for _, ss := range f {
+		if ss.Namespace != pod.Namespace {
+			continue
+		}
+		selector, err = metav1.LabelSelectorAsSelector(ss.Spec.Selector)
+		if err != nil {
+			return
+		}
+		if selector.Matches(labels.Set(pod.Labels)) {
+			sss = append(sss, ss)
+		}
+	}
+	if len(sss) == 0 {
+		err = fmt.Errorf("Could not find StatefulSet for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
+	}
+	return
+}
+
+// FakePersistentVolumeClaimLister implements PersistentVolumeClaimLister on []*v1.PersistentVolumeClaim for test purposes.
+type FakePersistentVolumeClaimLister []*v1.PersistentVolumeClaim
+
+var _ corelisters.PersistentVolumeClaimLister = FakePersistentVolumeClaimLister{}
+
+// List returns not implemented error.
+func (f FakePersistentVolumeClaimLister) List(selector labels.Selector) (ret []*v1.PersistentVolumeClaim, err error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+// PersistentVolumeClaims returns a FakePersistentVolumeClaimLister object.
+func (f FakePersistentVolumeClaimLister) PersistentVolumeClaims(namespace string) corelisters.PersistentVolumeClaimNamespaceLister {
+	return &fakePersistentVolumeClaimNamespaceLister{
+		pvcs:      f,
+		namespace: namespace,
+	}
+}
+
+// fakePersistentVolumeClaimNamespaceLister is implementation of PersistentVolumeClaimNamespaceLister returned by List() above.
+type fakePersistentVolumeClaimNamespaceLister struct {
+	pvcs      []*v1.PersistentVolumeClaim
+	namespace string
+}
+
+func (f *fakePersistentVolumeClaimNamespaceLister) Get(name string) (*v1.PersistentVolumeClaim, error) {
+	for _, pvc := range f.pvcs {
+		if pvc.Name == name && pvc.Namespace == f.namespace {
+			return pvc, nil
+		}
+	}
+	return nil, fmt.Errorf("persistentvolumeclaim %q not found", name)
+}
+
+func (f fakePersistentVolumeClaimNamespaceLister) List(selector labels.Selector) (ret []*v1.PersistentVolumeClaim, err error) {
+	return nil, fmt.Errorf("not implemented")
+}

vendor/k8s.io/kubernetes/pkg/scheduler/testing/pods_to_cache.go

@@ -0,0 +1,65 @@
+/*
+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 testing
+
+import (
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	schedulercache "k8s.io/kubernetes/pkg/scheduler/cache"
+)
+
+// PodsToCache is used for testing
+type PodsToCache []*v1.Pod
+
+// AssumePod returns nil.
+func (p PodsToCache) AssumePod(pod *v1.Pod) error { return nil }
+
+// ForgetPod returns nil.
+func (p PodsToCache) ForgetPod(pod *v1.Pod) error { return nil }
+
+// AddPod returns nil.
+func (p PodsToCache) AddPod(pod *v1.Pod) error { return nil }
+
+// UpdatePod returns nil.
+func (p PodsToCache) UpdatePod(oldPod, newPod *v1.Pod) error { return nil }
+
+// RemovePod returns nil.
+func (p PodsToCache) RemovePod(pod *v1.Pod) error { return nil }
+
+// AddNode returns nil.
+func (p PodsToCache) AddNode(node *v1.Node) error { return nil }
+
+// UpdateNode returns nil.
+func (p PodsToCache) UpdateNode(oldNode, newNode *v1.Node) error { return nil }
+
+// RemoveNode returns nil.
+func (p PodsToCache) RemoveNode(node *v1.Node) error { return nil }
+
+// UpdateNodeNameToInfoMap returns nil.
+func (p PodsToCache) UpdateNodeNameToInfoMap(infoMap map[string]*schedulercache.NodeInfo) error {
+	return nil
+}
+
+// List returns pods matching the label selector.
+func (p PodsToCache) List(s labels.Selector) (selected []*v1.Pod, err error) {
+	for _, pod := range p {
+		if s.Matches(labels.Set(pod.Labels)) {
+			selected = append(selected, pod)
+		}
+	}
+	return selected, nil
+}

vendor/k8s.io/kubernetes/pkg/scheduler/testing/util.go

@@ -0,0 +1,173 @@
+/*
+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 testing
+
+import (
+	"fmt"
+	"mime"
+	"os"
+	"reflect"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/kubernetes/pkg/api/legacyscheme"
+	api "k8s.io/kubernetes/pkg/apis/core"
+
+	// Init the core api installation
+	_ "k8s.io/kubernetes/pkg/apis/core/install"
+)
+
+// TestGroup defines a api group for testing.
+type TestGroup struct {
+	externalGroupVersion schema.GroupVersion
+	internalGroupVersion schema.GroupVersion
+	internalTypes        map[string]reflect.Type
+	externalTypes        map[string]reflect.Type
+}
+
+var (
+	// Groups defines a TestGroup map.
+	Groups = make(map[string]TestGroup)
+	// Test defines a TestGroup object.
+	Test TestGroup
+
+	serializer runtime.SerializerInfo
+)
+
+func init() {
+	if apiMediaType := os.Getenv("KUBE_TEST_API_TYPE"); len(apiMediaType) > 0 {
+		var ok bool
+		mediaType, _, err := mime.ParseMediaType(apiMediaType)
+		if err != nil {
+			panic(err)
+		}
+		serializer, ok = runtime.SerializerInfoForMediaType(legacyscheme.Codecs.SupportedMediaTypes(), mediaType)
+		if !ok {
+			panic(fmt.Sprintf("no serializer for %s", apiMediaType))
+		}
+	}
+
+	kubeTestAPI := os.Getenv("KUBE_TEST_API")
+	if len(kubeTestAPI) != 0 {
+		// priority is "first in list preferred", so this has to run in reverse order
+		testGroupVersions := strings.Split(kubeTestAPI, ",")
+		for i := len(testGroupVersions) - 1; i >= 0; i-- {
+			gvString := testGroupVersions[i]
+			groupVersion, err := schema.ParseGroupVersion(gvString)
+			if err != nil {
+				panic(fmt.Sprintf("Error parsing groupversion %v: %v", gvString, err))
+			}
+
+			internalGroupVersion := schema.GroupVersion{Group: groupVersion.Group, Version: runtime.APIVersionInternal}
+			Groups[groupVersion.Group] = TestGroup{
+				externalGroupVersion: groupVersion,
+				internalGroupVersion: internalGroupVersion,
+				internalTypes:        legacyscheme.Scheme.KnownTypes(internalGroupVersion),
+				externalTypes:        legacyscheme.Scheme.KnownTypes(groupVersion),
+			}
+		}
+	}
+
+	if _, ok := Groups[api.GroupName]; !ok {
+		externalGroupVersion := schema.GroupVersion{Group: api.GroupName, Version: "v1"}
+		Groups[api.GroupName] = TestGroup{
+			externalGroupVersion: externalGroupVersion,
+			internalGroupVersion: api.SchemeGroupVersion,
+			internalTypes:        legacyscheme.Scheme.KnownTypes(api.SchemeGroupVersion),
+			externalTypes:        legacyscheme.Scheme.KnownTypes(externalGroupVersion),
+		}
+	}
+
+	Test = Groups[api.GroupName]
+}
+
+// Codec returns the codec for the API version to test against, as set by the
+// KUBE_TEST_API_TYPE env var.
+func (g TestGroup) Codec() runtime.Codec {
+	if serializer.Serializer == nil {
+		return legacyscheme.Codecs.LegacyCodec(g.externalGroupVersion)
+	}
+	return legacyscheme.Codecs.CodecForVersions(serializer.Serializer, legacyscheme.Codecs.UniversalDeserializer(), schema.GroupVersions{g.externalGroupVersion}, nil)
+}
+
+// SelfLink returns a self link that will appear to be for the version Version().
+// 'resource' should be the resource path, e.g. "pods" for the Pod type. 'name' should be
+// empty for lists.
+func (g TestGroup) SelfLink(resource, name string) string {
+	if g.externalGroupVersion.Group == api.GroupName {
+		if name == "" {
+			return fmt.Sprintf("/api/%s/%s", g.externalGroupVersion.Version, resource)
+		}
+		return fmt.Sprintf("/api/%s/%s/%s", g.externalGroupVersion.Version, resource, name)
+	}
+
+	// TODO: will need a /apis prefix once we have proper multi-group
+	// support
+	if name == "" {
+		return fmt.Sprintf("/apis/%s/%s/%s", g.externalGroupVersion.Group, g.externalGroupVersion.Version, resource)
+	}
+	return fmt.Sprintf("/apis/%s/%s/%s/%s", g.externalGroupVersion.Group, g.externalGroupVersion.Version, resource, name)
+}
+
+// ResourcePathWithPrefix returns the appropriate path for the given prefix (watch, proxy, redirect, etc), resource, namespace and name.
+// For ex, this is of the form:
+// /api/v1/watch/namespaces/foo/pods/pod0 for v1.
+func (g TestGroup) ResourcePathWithPrefix(prefix, resource, namespace, name string) string {
+	var path string
+	if g.externalGroupVersion.Group == api.GroupName {
+		path = "/api/" + g.externalGroupVersion.Version
+	} else {
+		// TODO: switch back once we have proper multiple group support
+		// path = "/apis/" + g.Group + "/" + Version(group...)
+		path = "/apis/" + g.externalGroupVersion.Group + "/" + g.externalGroupVersion.Version
+	}
+
+	if prefix != "" {
+		path = path + "/" + prefix
+	}
+	if namespace != "" {
+		path = path + "/namespaces/" + namespace
+	}
+	// Resource names are lower case.
+	resource = strings.ToLower(resource)
+	if resource != "" {
+		path = path + "/" + resource
+	}
+	if name != "" {
+		path = path + "/" + name
+	}
+	return path
+}
+
+// ResourcePath returns the appropriate path for the given resource, namespace and name.
+// For example, this is of the form:
+// /api/v1/namespaces/foo/pods/pod0 for v1.
+func (g TestGroup) ResourcePath(resource, namespace, name string) string {
+	return g.ResourcePathWithPrefix("", resource, namespace, name)
+}
+
+// SubResourcePath returns the appropriate path for the given resource, namespace,
+// name and subresource.
+func (g TestGroup) SubResourcePath(resource, namespace, name, sub string) string {
+	path := g.ResourcePathWithPrefix("", resource, namespace, name)
+	if sub != "" {
+		path = path + "/" + sub
+	}
+
+	return path
+}

vendor/k8s.io/kubernetes/pkg/scheduler/testing/util_test.go

@@ -0,0 +1,214 @@
+/*
+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 testing
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+func TestResourcePathWithPrefix(t *testing.T) {
+	testCases := []struct {
+		prefix    string
+		resource  string
+		namespace string
+		name      string
+		expected  string
+	}{
+		{"prefix", "resource", "mynamespace", "myresource", "/api/" + Test.externalGroupVersion.Version + "/prefix/namespaces/mynamespace/resource/myresource"},
+		{"prefix", "resource", "", "myresource", "/api/" + Test.externalGroupVersion.Version + "/prefix/resource/myresource"},
+		{"prefix", "resource", "mynamespace", "", "/api/" + Test.externalGroupVersion.Version + "/prefix/namespaces/mynamespace/resource"},
+		{"prefix", "resource", "", "", "/api/" + Test.externalGroupVersion.Version + "/prefix/resource"},
+		{"", "resource", "mynamespace", "myresource", "/api/" + Test.externalGroupVersion.Version + "/namespaces/mynamespace/resource/myresource"},
+	}
+	for _, item := range testCases {
+		if actual := Test.ResourcePathWithPrefix(item.prefix, item.resource, item.namespace, item.name); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for prefix: %s, resource: %s, namespace: %s and name: %s", item.expected, actual, item.prefix, item.resource, item.namespace, item.name)
+		}
+	}
+
+	TestGroup := Test
+	TestGroup.externalGroupVersion.Group = "TestGroup"
+
+	testGroupCases := []struct {
+		prefix    string
+		resource  string
+		namespace string
+		name      string
+		expected  string
+	}{
+		{"prefix", "resource", "mynamespace", "myresource", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/prefix/namespaces/mynamespace/resource/myresource"},
+		{"prefix", "resource", "", "myresource", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/prefix/resource/myresource"},
+		{"prefix", "resource", "mynamespace", "", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/prefix/namespaces/mynamespace/resource"},
+		{"prefix", "resource", "", "", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/prefix/resource"},
+		{"", "resource", "mynamespace", "myresource", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/namespaces/mynamespace/resource/myresource"},
+	}
+	for _, item := range testGroupCases {
+		if actual := TestGroup.ResourcePathWithPrefix(item.prefix, item.resource, item.namespace, item.name); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for prefix: %s, resource: %s, namespace: %s and name: %s", item.expected, actual, item.prefix, item.resource, item.namespace, item.name)
+		}
+	}
+
+}
+
+func TestResourcePath(t *testing.T) {
+	testCases := []struct {
+		resource  string
+		namespace string
+		name      string
+		expected  string
+	}{
+		{"resource", "mynamespace", "myresource", "/api/" + Test.externalGroupVersion.Version + "/namespaces/mynamespace/resource/myresource"},
+		{"resource", "", "myresource", "/api/" + Test.externalGroupVersion.Version + "/resource/myresource"},
+		{"resource", "mynamespace", "", "/api/" + Test.externalGroupVersion.Version + "/namespaces/mynamespace/resource"},
+		{"resource", "", "", "/api/" + Test.externalGroupVersion.Version + "/resource"},
+	}
+	for _, item := range testCases {
+		if actual := Test.ResourcePath(item.resource, item.namespace, item.name); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for resource: %s, namespace: %s and name: %s", item.expected, actual, item.resource, item.namespace, item.name)
+		}
+	}
+
+	TestGroup := Test
+	TestGroup.externalGroupVersion.Group = "TestGroup"
+
+	testGroupCases := []struct {
+		resource  string
+		namespace string
+		name      string
+		expected  string
+	}{
+		{"resource", "mynamespace", "myresource", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/namespaces/mynamespace/resource/myresource"},
+		{"resource", "", "myresource", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/resource/myresource"},
+		{"resource", "mynamespace", "", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/namespaces/mynamespace/resource"},
+		{"resource", "", "", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/resource"},
+	}
+	for _, item := range testGroupCases {
+		if actual := TestGroup.ResourcePath(item.resource, item.namespace, item.name); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for resource: %s, namespace: %s and name: %s", item.expected, actual, item.resource, item.namespace, item.name)
+		}
+	}
+
+}
+
+func TestSubResourcePath(t *testing.T) {
+	testCases := []struct {
+		resource  string
+		namespace string
+		name      string
+		sub       string
+		expected  string
+	}{
+		{"resource", "mynamespace", "myresource", "subresource", "/api/" + Test.externalGroupVersion.Version + "/namespaces/mynamespace/resource/myresource/subresource"},
+		{"resource", "mynamespace", "myresource", "", "/api/" + Test.externalGroupVersion.Version + "/namespaces/mynamespace/resource/myresource"},
+	}
+	for _, item := range testCases {
+		if actual := Test.SubResourcePath(item.resource, item.namespace, item.name, item.sub); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for resource: %s, namespace: %s, name: %s and sub: %s", item.expected, actual, item.resource, item.namespace, item.name, item.sub)
+		}
+	}
+
+	TestGroup := Test
+	TestGroup.externalGroupVersion.Group = "TestGroup"
+
+	testGroupCases := []struct {
+		resource  string
+		namespace string
+		name      string
+		sub       string
+		expected  string
+	}{
+		{"resource", "mynamespace", "myresource", "subresource", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/namespaces/mynamespace/resource/myresource/subresource"},
+		{"resource", "mynamespace", "myresource", "", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/namespaces/mynamespace/resource/myresource"},
+	}
+	for _, item := range testGroupCases {
+		if actual := TestGroup.SubResourcePath(item.resource, item.namespace, item.name, item.sub); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for resource: %s, namespace: %s, name: %s and sub: %s", item.expected, actual, item.resource, item.namespace, item.name, item.sub)
+		}
+	}
+
+}
+
+func TestSelfLink(t *testing.T) {
+	testCases := []struct {
+		resource string
+		name     string
+		expected string
+	}{
+		{"resource", "name", "/api/" + Test.externalGroupVersion.Version + "/resource/name"},
+		{"resource", "", "/api/" + Test.externalGroupVersion.Version + "/resource"},
+	}
+	for _, item := range testCases {
+		if actual := Test.SelfLink(item.resource, item.name); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for resource: %s and name: %s", item.expected, actual, item.resource, item.name)
+		}
+	}
+
+	TestGroup := Test
+	TestGroup.externalGroupVersion.Group = "TestGroup"
+
+	testGroupCases := []struct {
+		resource string
+		name     string
+		expected string
+	}{
+		{"resource", "name", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/resource/name"},
+		{"resource", "", "/apis/" + TestGroup.externalGroupVersion.Group + "/" + TestGroup.externalGroupVersion.Version + "/resource"},
+	}
+	for _, item := range testGroupCases {
+		if actual := TestGroup.SelfLink(item.resource, item.name); actual != item.expected {
+			t.Errorf("Expected: %s, got: %s for resource: %s and name: %s", item.expected, actual, item.resource, item.name)
+		}
+	}
+}
+
+var status = &metav1.Status{
+	Status:  metav1.StatusFailure,
+	Code:    200,
+	Reason:  metav1.StatusReasonUnknown,
+	Message: "",
+}
+
+func TestV1EncodeDecodeStatus(t *testing.T) {
+	v1Codec := Test.Codec()
+
+	encoded, err := runtime.Encode(v1Codec, 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(v1Codec, encoded)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(status, decoded) {
+		t.Errorf("expected: %#v, got: %#v", status, decoded)
+	}
+}