tests := []struct {
		name         string
		runtimeClass *nodev1.RuntimeClass
		pod          *core.Pod
		expectError  bool
		expectedPod  *core.Pod
	}{
		{
			name: "overhead, no container requirements",
			runtimeClass: &nodev1.RuntimeClass{
				ObjectMeta: metav1.ObjectMeta{Name: "foo"},
				Handler:    "bar",
				Overhead: &nodev1.Overhead{
					PodFixed: corev1.ResourceList{

	apiv1 "k8s.io/api/core/v1"
	discoveryv1 "k8s.io/api/discovery/v1"
	eventsv1 "k8s.io/api/events/v1"
	networkingapiv1 "k8s.io/api/networking/v1"
	networkingapiv1alpha1 "k8s.io/api/networking/v1alpha1"
	nodev1 "k8s.io/api/node/v1"
	policyapiv1 "k8s.io/api/policy/v1"
	rbacv1 "k8s.io/api/rbac/v1"
	resourcev1alpha2 "k8s.io/api/resource/v1alpha2"
	schedulingapiv1 "k8s.io/api/scheduling/v1"
	storageapiv1 "k8s.io/api/storage/v1"

			inputNodeID:  "com.example.csi/csi-node1",
			inputTopology: map[string]string{
				"com.example.csi/zone": "zoneA",
			},
			expectedNode: &v1.Node{
				ObjectMeta: metav1.ObjectMeta{
					Name:        "node1",
					Annotations: map[string]string{annotationKeyNodeID: marshall(nodeIDMap{"com.example.csi.driver1": "com.example.csi/csi-node1"})},
					Labels:      labelMap{"com.example.csi/zone": "zoneA"},
				},

			nodes: []*v1.Node{
				st.MakeNode().Name("node1").Capacity(map[v1.ResourceName]string{"cpu": "4000", "memory": "10000"}).Obj(),
				st.MakeNode().Name("node2").Capacity(map[v1.ResourceName]string{"cpu": "4000", "memory": "10000"}).Obj(),
			},
			existingPods: []*v1.Pod{
				st.MakePod().Node("node1").Obj(),
				st.MakePod().Node("node1").Obj(),
			},

			expectedList: []framework.NodeScore{{Name: "node1", Score: 7}, {Name: "node2", Score: 0}},
			name:         "two images on one node, prefer this node",
		},
		{
			// Pod: gcr.io/4000 gcr.io/10

			// Node1
			// Image: gcr.io/4000:latest 2000MB
			// Score: 100 (4000 * 1/2 >= 1000M * 2, max-threshold)

			// Node2

			nodes:        []*v1.Node{makeNode("node1", 250, 1000*1024*1024, nil), makeNode("node2", 250, 1000*1024*1024, nil)},
			expectedList: []framework.NodeScore{{Name: "node1", Score: 100}, {Name: "node2", Score: 100}},
			name:         "no resources requested, pods with container scheduled",
			pods: []*v1.Pod{
				st.MakePod().Node("node1").Obj(),
				st.MakePod().Node("node1").Obj(),
			},

		return map[string][]string{
			f.etcdVersion: {"node1"},
		}, nil
	}

	if f.componentVersion == "" {
		return nil, errors.New("get component version failed")
	}

	if f.componentVersion == "multiVersion" {
		return map[string][]string{
			"node1": {"node1"},
			"node2": {"node2"},
		}, nil
	}

	return map[string][]string{
		f.componentVersion: {"node1"},
	}, nil
}

        expect:
        def converter = adapter.newGraph()
        def model1 = converter.adapt(TestModel.class, protocolModel1)
        def model2 = converter.adapt(TestModel.class, protocolModel2)
        !model1.is(model2)
        model1.project.is(model2.project)

        def otherModel1 = converter.adapt(TestModel.class, protocolModel1)
        model1.is(otherModel1)
    }

					"v1.8.1": {"node1"},
				},
				KubeControllerManagerVersions: map[string][]string{
					"v1.8.1": {"node1"},
				},
				KubeSchedulerVersions: map[string][]string{
					"v1.8.1": {"node1"},
				},
				KubeletVersions: map[string][]string{
					"v1.8.1": {"node1"},
				},
				EtcdVersions: map[string][]string{
					"3.0.17": {"node1"},
				},
				KubeadmVersion: "v1.8.2",

			nodes: []*v1.Node{
				st.MakeNode().Name("node1").Capacity(map[v1.ResourceName]string{"cpu": "4000", "memory": "10000"}).Obj(),
				st.MakeNode().Name("node2").Capacity(map[v1.ResourceName]string{"cpu": "4000", "memory": "10000"}).Obj(),
			},
			existingPods: []*v1.Pod{
				st.MakePod().Node("node1").Obj(),
				st.MakePod().Node("node1").Obj(),
				st.MakePod().Node("node2").Obj(),