use subtest for table units

pkg/scheduler/algorithm/priorities/balanced_resource_allocation_test.go

@@ -216,7 +216,7 @@ func TestBalancedResourceAllocation(t *testing.T) {
 		pods         []*v1.Pod
 		nodes        []*v1.Node
 		expectedList schedulerapi.HostPriorityList
-		test         string
+		name         string
 	}{
 		{
 			/*
@@ -233,7 +233,7 @@ func TestBalancedResourceAllocation(t *testing.T) {
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
-			test:         "nothing scheduled, nothing requested",
+			name:         "nothing scheduled, nothing requested",
 		},
 		{
 			/*
@@ -250,7 +250,7 @@ func TestBalancedResourceAllocation(t *testing.T) {
 			pod:          &v1.Pod{Spec: cpuAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 6000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 7}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
-			test:         "nothing scheduled, resources requested, differently sized machines",
+			name:         "nothing scheduled, resources requested, differently sized machines",
 		},
 		{
 			/*
@@ -267,7 +267,7 @@ func TestBalancedResourceAllocation(t *testing.T) {
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
-			test:         "no resources requested, pods scheduled",
+			name:         "no resources requested, pods scheduled",
 			pods: []*v1.Pod{
 				{Spec: machine1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
 				{Spec: machine1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
@@ -290,7 +290,7 @@ func TestBalancedResourceAllocation(t *testing.T) {
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 4}, {Host: "machine2", Score: 6}},
-			test:         "no resources requested, pods scheduled with resources",
+			name:         "no resources requested, pods scheduled with resources",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
 				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
@@ -313,7 +313,7 @@ func TestBalancedResourceAllocation(t *testing.T) {
 			pod:          &v1.Pod{Spec: cpuAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 6}, {Host: "machine2", Score: 9}},
-			test:         "resources requested, pods scheduled with resources",
+			name:         "resources requested, pods scheduled with resources",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly},
 				{Spec: cpuAndMemory},
@@ -334,7 +334,7 @@ func TestBalancedResourceAllocation(t *testing.T) {
 			pod:          &v1.Pod{Spec: cpuAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 50000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 6}, {Host: "machine2", Score: 6}},
-			test:         "resources requested, pods scheduled with resources, differently sized machines",
+			name:         "resources requested, pods scheduled with resources, differently sized machines",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly},
 				{Spec: cpuAndMemory},
@@ -355,7 +355,7 @@ func TestBalancedResourceAllocation(t *testing.T) {
 			pod:          &v1.Pod{Spec: cpuOnly},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
-			test:         "requested resources exceed node capacity",
+			name:         "requested resources exceed node capacity",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly},
 				{Spec: cpuAndMemory},
@@ -365,7 +365,7 @@ func TestBalancedResourceAllocation(t *testing.T) {
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 0, 0), makeNode("machine2", 0, 0)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
-			test:         "zero node resources, pods scheduled with resources",
+			name:         "zero node resources, pods scheduled with resources",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly},
 				{Spec: cpuAndMemory},
@@ -389,7 +389,7 @@ func TestBalancedResourceAllocation(t *testing.T) {
 			},
 			nodes:        []*v1.Node{makeNode("machine3", 3500, 40000), makeNode("machine4", 4000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine3", Score: 8}, {Host: "machine4", Score: 9}},
-			test:         "Include volume count on a node for balanced resource allocation",
+			name:         "Include volume count on a node for balanced resource allocation",
 			pods: []*v1.Pod{
 				{Spec: cpuAndMemory3},
 				{Spec: podwithVol1},
@@ -400,20 +400,22 @@ func TestBalancedResourceAllocation(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
-		if len(test.pod.Spec.Volumes) > 0 {
-			maxVolumes := 5
-			for _, info := range nodeNameToInfo {
-				info.TransientInfo.TransNodeInfo.AllocatableVolumesCount = getExistingVolumeCountForNode(info.Pods(), maxVolumes)
-				info.TransientInfo.TransNodeInfo.RequestedVolumes = len(test.pod.Spec.Volumes)
+		t.Run(test.name, func(t *testing.T) {
+			nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
+			if len(test.pod.Spec.Volumes) > 0 {
+				maxVolumes := 5
+				for _, info := range nodeNameToInfo {
+					info.TransientInfo.TransNodeInfo.AllocatableVolumesCount = getExistingVolumeCountForNode(info.Pods(), maxVolumes)
+					info.TransientInfo.TransNodeInfo.RequestedVolumes = len(test.pod.Spec.Volumes)
+				}
 			}
-		}
-		list, err := priorityFunction(BalancedResourceAllocationMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-		if !reflect.DeepEqual(test.expectedList, list) {
-			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
-		}
+			list, err := priorityFunction(BalancedResourceAllocationMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+			if !reflect.DeepEqual(test.expectedList, list) {
+				t.Errorf("expected %#v, got %#v", test.expectedList, list)
+			}
+		})
 	}
 }

pkg/scheduler/algorithm/priorities/image_locality_test.go

@@ -110,7 +110,7 @@ func TestImageLocalityPriority(t *testing.T) {
 		pods         []*v1.Pod
 		nodes        []*v1.Node
 		expectedList schedulerapi.HostPriorityList
-		test         string
+		name         string
 	}{
 		{
 			// Pod: gcr.io/40 gcr.io/250
@@ -125,7 +125,7 @@ func TestImageLocalityPriority(t *testing.T) {
 			pod:          &v1.Pod{Spec: test40250},
 			nodes:        []*v1.Node{makeImageNode("machine1", node401402000), makeImageNode("machine2", node25010)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 1}, {Host: "machine2", Score: 3}},
-			test:         "two images spread on two nodes, prefer the larger image one",
+			name:         "two images spread on two nodes, prefer the larger image one",
 		},
 		{
 			// Pod: gcr.io/40 gcr.io/140
@@ -140,7 +140,7 @@ func TestImageLocalityPriority(t *testing.T) {
 			pod:          &v1.Pod{Spec: test40140},
 			nodes:        []*v1.Node{makeImageNode("machine1", node401402000), makeImageNode("machine2", node25010)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 2}, {Host: "machine2", Score: 0}},
-			test:         "two images on one node, prefer this node",
+			name:         "two images on one node, prefer this node",
 		},
 		{
 			// Pod: gcr.io/2000 gcr.io/10
@@ -155,23 +155,25 @@ func TestImageLocalityPriority(t *testing.T) {
 			pod:          &v1.Pod{Spec: testMinMax},
 			nodes:        []*v1.Node{makeImageNode("machine1", node401402000), makeImageNode("machine2", node25010)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}},
-			test:         "if exceed limit, use limit",
+			name:         "if exceed limit, use limit",
 		},
 	}
 
 	for _, test := range tests {
-		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
-		list, err := priorityFunction(ImageLocalityPriorityMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-
-		sort.Sort(test.expectedList)
-		sort.Sort(list)
-
-		if !reflect.DeepEqual(test.expectedList, list) {
-			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
+			list, err := priorityFunction(ImageLocalityPriorityMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+
+			sort.Sort(test.expectedList)
+			sort.Sort(list)
+
+			if !reflect.DeepEqual(test.expectedList, list) {
+				t.Errorf("expected %#v, got %#v", test.expectedList, list)
+			}
+		})
 	}
 }
 

pkg/scheduler/algorithm/priorities/least_requested_test.go

@@ -94,7 +94,7 @@ func TestLeastRequested(t *testing.T) {
 		pods         []*v1.Pod
 		nodes        []*v1.Node
 		expectedList schedulerapi.HostPriorityList
-		test         string
+		name         string
 	}{
 		{
 			/*
@@ -111,7 +111,7 @@ func TestLeastRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
-			test:         "nothing scheduled, nothing requested",
+			name:         "nothing scheduled, nothing requested",
 		},
 		{
 			/*
@@ -128,7 +128,7 @@ func TestLeastRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: cpuAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 6000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 3}, {Host: "machine2", Score: 5}},
-			test:         "nothing scheduled, resources requested, differently sized machines",
+			name:         "nothing scheduled, resources requested, differently sized machines",
 		},
 		{
 			/*
@@ -145,7 +145,7 @@ func TestLeastRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}},
-			test:         "no resources requested, pods scheduled",
+			name:         "no resources requested, pods scheduled",
 			pods: []*v1.Pod{
 				{Spec: machine1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
 				{Spec: machine1Spec, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
@@ -168,7 +168,7 @@ func TestLeastRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 7}, {Host: "machine2", Score: 5}},
-			test:         "no resources requested, pods scheduled with resources",
+			name:         "no resources requested, pods scheduled with resources",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
 				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
@@ -191,7 +191,7 @@ func TestLeastRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: cpuAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 5}, {Host: "machine2", Score: 4}},
-			test:         "resources requested, pods scheduled with resources",
+			name:         "resources requested, pods scheduled with resources",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly},
 				{Spec: cpuAndMemory},
@@ -212,7 +212,7 @@ func TestLeastRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: cpuAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 50000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 5}, {Host: "machine2", Score: 6}},
-			test:         "resources requested, pods scheduled with resources, differently sized machines",
+			name:         "resources requested, pods scheduled with resources, differently sized machines",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly},
 				{Spec: cpuAndMemory},
@@ -233,7 +233,7 @@ func TestLeastRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: cpuOnly},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 5}, {Host: "machine2", Score: 2}},
-			test:         "requested resources exceed node capacity",
+			name:         "requested resources exceed node capacity",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly},
 				{Spec: cpuAndMemory},
@@ -243,7 +243,7 @@ func TestLeastRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 0, 0), makeNode("machine2", 0, 0)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
-			test:         "zero node resources, pods scheduled with resources",
+			name:         "zero node resources, pods scheduled with resources",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly},
 				{Spec: cpuAndMemory},
@@ -252,13 +252,15 @@ func TestLeastRequested(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
-		list, err := priorityFunction(LeastRequestedPriorityMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-		if !reflect.DeepEqual(test.expectedList, list) {
-			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
+			list, err := priorityFunction(LeastRequestedPriorityMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+			if !reflect.DeepEqual(test.expectedList, list) {
+				t.Errorf("expected %#v, got %#v", test.expectedList, list)
+			}
+		})
 	}
 }

pkg/scheduler/algorithm/priorities/metadata_test.go

@@ -117,13 +117,13 @@ func TestPriorityMetadata(t *testing.T) {
 	}
 	tests := []struct {
 		pod      *v1.Pod
-		test     string
+		name     string
 		expected interface{}
 	}{
 		{
 			pod:      nil,
 			expected: nil,
-			test:     "pod is nil , priorityMetadata is nil",
+			name:     "pod is nil , priorityMetadata is nil",
 		},
 		{
 			pod: podWithTolerationsAndAffinity,
@@ -132,7 +132,7 @@ func TestPriorityMetadata(t *testing.T) {
 				podTolerations: tolerations,
 				affinity:       podAffinity,
 			},
-			test: "Produce a priorityMetadata with default requests",
+			name: "Produce a priorityMetadata with default requests",
 		},
 		{
 			pod: podWithTolerationsAndRequests,
@@ -141,7 +141,7 @@ func TestPriorityMetadata(t *testing.T) {
 				podTolerations: tolerations,
 				affinity:       nil,
 			},
-			test: "Produce a priorityMetadata with specified requests",
+			name: "Produce a priorityMetadata with specified requests",
 		},
 		{
 			pod: podWithAffinityAndRequests,
@@ -150,7 +150,7 @@ func TestPriorityMetadata(t *testing.T) {
 				podTolerations: nil,
 				affinity:       podAffinity,
 			},
-			test: "Produce a priorityMetadata with specified requests",
+			name: "Produce a priorityMetadata with specified requests",
 		},
 	}
 	mataDataProducer := NewPriorityMetadataFactory(
@@ -159,9 +159,11 @@ func TestPriorityMetadata(t *testing.T) {
 		schedulertesting.FakeReplicaSetLister([]*extensions.ReplicaSet{}),
 		schedulertesting.FakeStatefulSetLister([]*apps.StatefulSet{}))
 	for _, test := range tests {
-		ptData := mataDataProducer(test.pod, nil)
-		if !reflect.DeepEqual(test.expected, ptData) {
-			t.Errorf("%s: expected %#v, got %#v", test.test, test.expected, ptData)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			ptData := mataDataProducer(test.pod, nil)
+			if !reflect.DeepEqual(test.expected, ptData) {
+				t.Errorf("expected %#v, got %#v", test.expected, ptData)
+			}
+		})
 	}
 }

pkg/scheduler/algorithm/priorities/most_requested_test.go

@@ -109,7 +109,7 @@ func TestMostRequested(t *testing.T) {
 		pods         []*v1.Pod
 		nodes        []*v1.Node
 		expectedList schedulerapi.HostPriorityList
-		test         string
+		name         string
 	}{
 		{
 			/*
@@ -126,7 +126,7 @@ func TestMostRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}},
-			test:         "nothing scheduled, nothing requested",
+			name:         "nothing scheduled, nothing requested",
 		},
 		{
 			/*
@@ -143,7 +143,7 @@ func TestMostRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: cpuAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 6000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 6}, {Host: "machine2", Score: 5}},
-			test:         "nothing scheduled, resources requested, differently sized machines",
+			name:         "nothing scheduled, resources requested, differently sized machines",
 		},
 		{
 			/*
@@ -160,7 +160,7 @@ func TestMostRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 3}, {Host: "machine2", Score: 4}},
-			test:         "no resources requested, pods scheduled with resources",
+			name:         "no resources requested, pods scheduled with resources",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels2}},
 				{Spec: cpuOnly, ObjectMeta: metav1.ObjectMeta{Labels: labels1}},
@@ -183,7 +183,7 @@ func TestMostRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: cpuAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 10000, 20000), makeNode("machine2", 10000, 20000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 4}, {Host: "machine2", Score: 5}},
-			test:         "resources requested, pods scheduled with resources",
+			name:         "resources requested, pods scheduled with resources",
 			pods: []*v1.Pod{
 				{Spec: cpuOnly},
 				{Spec: cpuAndMemory},
@@ -204,18 +204,20 @@ func TestMostRequested(t *testing.T) {
 			pod:          &v1.Pod{Spec: bigCPUAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 10000, 8000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 4}, {Host: "machine2", Score: 2}},
-			test:         "resources requested with more than the node, pods scheduled with resources",
+			name:         "resources requested with more than the node, pods scheduled with resources",
 		},
 	}
 
 	for _, test := range tests {
-		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
-		list, err := priorityFunction(MostRequestedPriorityMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-		if !reflect.DeepEqual(test.expectedList, list) {
-			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(test.pods, test.nodes)
+			list, err := priorityFunction(MostRequestedPriorityMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+			if !reflect.DeepEqual(test.expectedList, list) {
+				t.Errorf("expected %#v, got %#v", test.expectedList, list)
+			}
+		})
 	}
 }

pkg/scheduler/algorithm/priorities/node_affinity_test.go

@@ -105,7 +105,7 @@ func TestNodeAffinityPriority(t *testing.T) {
 		pod          *v1.Pod
 		nodes        []*v1.Node
 		expectedList schedulerapi.HostPriorityList
-		test         string
+		name         string
 	}{
 		{
 			pod: &v1.Pod{
@@ -119,7 +119,7 @@ func TestNodeAffinityPriority(t *testing.T) {
 				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
 			},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
-			test:         "all machines are same priority as NodeAffinity is nil",
+			name:         "all machines are same priority as NodeAffinity is nil",
 		},
 		{
 			pod: &v1.Pod{
@@ -133,7 +133,7 @@ func TestNodeAffinityPriority(t *testing.T) {
 				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
 			},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
-			test:         "no machine macthes preferred scheduling requirements in NodeAffinity of pod so all machines' priority is zero",
+			name:         "no machine macthes preferred scheduling requirements in NodeAffinity of pod so all machines' priority is zero",
 		},
 		{
 			pod: &v1.Pod{
@@ -147,7 +147,7 @@ func TestNodeAffinityPriority(t *testing.T) {
 				{ObjectMeta: metav1.ObjectMeta{Name: "machine3", Labels: label3}},
 			},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
-			test:         "only machine1 matches the preferred scheduling requirements of pod",
+			name:         "only machine1 matches the preferred scheduling requirements of pod",
 		},
 		{
 			pod: &v1.Pod{
@@ -161,19 +161,21 @@ func TestNodeAffinityPriority(t *testing.T) {
 				{ObjectMeta: metav1.ObjectMeta{Name: "machine2", Labels: label2}},
 			},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 1}, {Host: "machine5", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 3}},
-			test:         "all machines matches the preferred scheduling requirements of pod but with different priorities ",
+			name:         "all machines matches the preferred scheduling requirements of pod but with different priorities ",
 		},
 	}
 
 	for _, test := range tests {
-		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
-		nap := priorityFunction(CalculateNodeAffinityPriorityMap, CalculateNodeAffinityPriorityReduce, nil)
-		list, err := nap(test.pod, nodeNameToInfo, test.nodes)
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-		if !reflect.DeepEqual(test.expectedList, list) {
-			t.Errorf("%s: \nexpected %#v, \ngot      %#v", test.test, test.expectedList, list)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
+			nap := priorityFunction(CalculateNodeAffinityPriorityMap, CalculateNodeAffinityPriorityReduce, nil)
+			list, err := nap(test.pod, nodeNameToInfo, test.nodes)
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+			if !reflect.DeepEqual(test.expectedList, list) {
+				t.Errorf("expected %#v, \ngot      %#v", test.expectedList, list)
+			}
+		})
 	}
 }

pkg/scheduler/algorithm/priorities/node_label_test.go

@@ -36,7 +36,7 @@ func TestNewNodeLabelPriority(t *testing.T) {
 		label        string
 		presence     bool
 		expectedList schedulerapi.HostPriorityList
-		test         string
+		name         string
 	}{
 		{
 			nodes: []*v1.Node{
@@ -47,7 +47,7 @@ func TestNewNodeLabelPriority(t *testing.T) {
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
 			label:        "baz",
 			presence:     true,
-			test:         "no match found, presence true",
+			name:         "no match found, presence true",
 		},
 		{
 			nodes: []*v1.Node{
@@ -58,7 +58,7 @@ func TestNewNodeLabelPriority(t *testing.T) {
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
 			label:        "baz",
 			presence:     false,
-			test:         "no match found, presence false",
+			name:         "no match found, presence false",
 		},
 		{
 			nodes: []*v1.Node{
@@ -69,7 +69,7 @@ func TestNewNodeLabelPriority(t *testing.T) {
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
 			label:        "foo",
 			presence:     true,
-			test:         "one match found, presence true",
+			name:         "one match found, presence true",
 		},
 		{
 			nodes: []*v1.Node{
@@ -80,7 +80,7 @@ func TestNewNodeLabelPriority(t *testing.T) {
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
 			label:        "foo",
 			presence:     false,
-			test:         "one match found, presence false",
+			name:         "one match found, presence false",
 		},
 		{
 			nodes: []*v1.Node{
@@ -91,7 +91,7 @@ func TestNewNodeLabelPriority(t *testing.T) {
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
 			label:        "bar",
 			presence:     true,
-			test:         "two matches found, presence true",
+			name:         "two matches found, presence true",
 		},
 		{
 			nodes: []*v1.Node{
@@ -102,25 +102,27 @@ func TestNewNodeLabelPriority(t *testing.T) {
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
 			label:        "bar",
 			presence:     false,
-			test:         "two matches found, presence false",
+			name:         "two matches found, presence false",
 		},
 	}
 
 	for _, test := range tests {
-		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
-		labelPrioritizer := &NodeLabelPrioritizer{
-			label:    test.label,
-			presence: test.presence,
-		}
-		list, err := priorityFunction(labelPrioritizer.CalculateNodeLabelPriorityMap, nil, nil)(nil, nodeNameToInfo, test.nodes)
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-		// sort the two lists to avoid failures on account of different ordering
-		sort.Sort(test.expectedList)
-		sort.Sort(list)
-		if !reflect.DeepEqual(test.expectedList, list) {
-			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
+			labelPrioritizer := &NodeLabelPrioritizer{
+				label:    test.label,
+				presence: test.presence,
+			}
+			list, err := priorityFunction(labelPrioritizer.CalculateNodeLabelPriorityMap, nil, nil)(nil, nodeNameToInfo, test.nodes)
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+			// sort the two lists to avoid failures on account of different ordering
+			sort.Sort(test.expectedList)
+			sort.Sort(list)
+			if !reflect.DeepEqual(test.expectedList, list) {
+				t.Errorf("expected %#v, got %#v", test.expectedList, list)
+			}
+		})
 	}
 }

pkg/scheduler/algorithm/priorities/node_prefer_avoid_pods_test.go

@@ -84,7 +84,7 @@ func TestNodePreferAvoidPriority(t *testing.T) {
 		pod          *v1.Pod
 		nodes        []*v1.Node
 		expectedList schedulerapi.HostPriorityList
-		test         string
+		name         string
 	}{
 		{
 			pod: &v1.Pod{
@@ -97,7 +97,7 @@ func TestNodePreferAvoidPriority(t *testing.T) {
 			},
 			nodes:        testNodes,
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
-			test:         "pod managed by ReplicationController should avoid a node, this node get lowest priority score",
+			name:         "pod managed by ReplicationController should avoid a node, this node get lowest priority score",
 		},
 		{
 			pod: &v1.Pod{
@@ -110,7 +110,7 @@ func TestNodePreferAvoidPriority(t *testing.T) {
 			},
 			nodes:        testNodes,
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
-			test:         "ownership by random controller should be ignored",
+			name:         "ownership by random controller should be ignored",
 		},
 		{
 			pod: &v1.Pod{
@@ -123,7 +123,7 @@ func TestNodePreferAvoidPriority(t *testing.T) {
 			},
 			nodes:        testNodes,
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: schedulerapi.MaxPriority}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
-			test:         "owner without Controller field set should be ignored",
+			name:         "owner without Controller field set should be ignored",
 		},
 		{
 			pod: &v1.Pod{
@@ -136,21 +136,23 @@ func TestNodePreferAvoidPriority(t *testing.T) {
 			},
 			nodes:        testNodes,
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: schedulerapi.MaxPriority}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: schedulerapi.MaxPriority}},
-			test:         "pod managed by ReplicaSet should avoid a node, this node get lowest priority score",
+			name:         "pod managed by ReplicaSet should avoid a node, this node get lowest priority score",
 		},
 	}
 
 	for _, test := range tests {
-		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
-		list, err := priorityFunction(CalculateNodePreferAvoidPodsPriorityMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-		// sort the two lists to avoid failures on account of different ordering
-		sort.Sort(test.expectedList)
-		sort.Sort(list)
-		if !reflect.DeepEqual(test.expectedList, list) {
-			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
+			list, err := priorityFunction(CalculateNodePreferAvoidPodsPriorityMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+			// sort the two lists to avoid failures on account of different ordering
+			sort.Sort(test.expectedList)
+			sort.Sort(list)
+			if !reflect.DeepEqual(test.expectedList, list) {
+				t.Errorf("expected %#v, got %#v", test.expectedList, list)
+			}
+		})
 	}
 }

pkg/scheduler/algorithm/priorities/resource_limits_test.go

@@ -103,49 +103,50 @@ func TestResourceLimistPriority(t *testing.T) {
 		pod          *v1.Pod
 		nodes        []*v1.Node
 		expectedList schedulerapi.HostPriorityList
-		test         string
+		name         string
 	}{
 		{
 			pod:          &v1.Pod{Spec: noResources},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 10000), makeNode("machine2", 4000, 0), makeNode("machine3", 0, 10000), makeNode("machine4", 0, 0)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}, {Host: "machine4", Score: 0}},
-			test:         "pod does not specify its resource limits",
+			name:         "pod does not specify its resource limits",
 		},
 		{
 			pod:          &v1.Pod{Spec: cpuOnly},
 			nodes:        []*v1.Node{makeNode("machine1", 3000, 10000), makeNode("machine2", 2000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 1}, {Host: "machine2", Score: 0}},
-			test:         "pod only specifies  cpu limits",
+			name:         "pod only specifies  cpu limits",
 		},
 		{
 			pod:          &v1.Pod{Spec: memOnly},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 4000), makeNode("machine2", 5000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 1}},
-			test:         "pod only specifies  mem limits",
+			name:         "pod only specifies  mem limits",
 		},
 		{
 			pod:          &v1.Pod{Spec: cpuAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 4000, 4000), makeNode("machine2", 5000, 10000)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 1}, {Host: "machine2", Score: 1}},
-			test:         "pod specifies both cpu and  mem limits",
+			name:         "pod specifies both cpu and  mem limits",
 		},
 		{
 			pod:          &v1.Pod{Spec: cpuAndMemory},
 			nodes:        []*v1.Node{makeNode("machine1", 0, 0)},
 			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}},
-			test:         "node does not advertise its allocatables",
+			name:         "node does not advertise its allocatables",
 		},
 	}
 
 	for _, test := range tests {
-		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
-		list, err := priorityFunction(ResourceLimitsPriorityMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-		if !reflect.DeepEqual(test.expectedList, list) {
-			t.Errorf("%s: expected %#v, got %#v", test.test, test.expectedList, list)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
+			list, err := priorityFunction(ResourceLimitsPriorityMap, nil, nil)(test.pod, nodeNameToInfo, test.nodes)
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+			if !reflect.DeepEqual(test.expectedList, list) {
+				t.Errorf("expected %#v, got %#v", test.expectedList, list)
+			}
+		})
 	}
-
 }

pkg/scheduler/algorithm/priorities/taint_toleration_test.go

@@ -54,11 +54,11 @@ func TestTaintAndToleration(t *testing.T) {
 		pod          *v1.Pod
 		nodes        []*v1.Node
 		expectedList schedulerapi.HostPriorityList
-		test         string
+		name         string
 	}{
 		// basic test case
 		{
-			test: "node with taints tolerated by the pod, gets a higher score than those node with intolerable taints",
+			name: "node with taints tolerated by the pod, gets a higher score than those node with intolerable taints",
 			pod: podWithTolerations([]v1.Toleration{{
 				Key:      "foo",
 				Operator: v1.TolerationOpEqual,
@@ -84,7 +84,7 @@ func TestTaintAndToleration(t *testing.T) {
 		},
 		// the count of taints that are tolerated by pod, does not matter.
 		{
-			test: "the nodes that all of their taints are tolerated by the pod, get the same score, no matter how many tolerable taints a node has",
+			name: "the nodes that all of their taints are tolerated by the pod, get the same score, no matter how many tolerable taints a node has",
 			pod: podWithTolerations([]v1.Toleration{
 				{
 					Key:      "cpu-type",
@@ -127,7 +127,7 @@ func TestTaintAndToleration(t *testing.T) {
 		},
 		// the count of taints on a node that are not tolerated by pod, matters.
 		{
-			test: "the more intolerable taints a node has, the lower score it gets.",
+			name: "the more intolerable taints a node has, the lower score it gets.",
 			pod: podWithTolerations([]v1.Toleration{{
 				Key:      "foo",
 				Operator: v1.TolerationOpEqual,
@@ -163,7 +163,7 @@ func TestTaintAndToleration(t *testing.T) {
 		},
 		// taints-tolerations priority only takes care about the taints and tolerations that have effect PreferNoSchedule
 		{
-			test: "only taints and tolerations that have effect PreferNoSchedule are checked by taints-tolerations priority function",
+			name: "only taints and tolerations that have effect PreferNoSchedule are checked by taints-tolerations priority function",
 			pod: podWithTolerations([]v1.Toleration{
 				{
 					Key:      "cpu-type",
@@ -205,7 +205,7 @@ func TestTaintAndToleration(t *testing.T) {
 			},
 		},
 		{
-			test: "Default behaviour No taints and tolerations, lands on node with no taints",
+			name: "Default behaviour No taints and tolerations, lands on node with no taints",
 			//pod without tolerations
 			pod: podWithTolerations([]v1.Toleration{}),
 			nodes: []*v1.Node{
@@ -226,16 +226,17 @@ func TestTaintAndToleration(t *testing.T) {
 		},
 	}
 	for _, test := range tests {
-		nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
-		ttp := priorityFunction(ComputeTaintTolerationPriorityMap, ComputeTaintTolerationPriorityReduce, nil)
-		list, err := ttp(test.pod, nodeNameToInfo, test.nodes)
-		if err != nil {
-			t.Errorf("%s, unexpected error: %v", test.test, err)
-		}
+		t.Run(test.name, func(t *testing.T) {
+			nodeNameToInfo := schedulercache.CreateNodeNameToInfoMap(nil, test.nodes)
+			ttp := priorityFunction(ComputeTaintTolerationPriorityMap, ComputeTaintTolerationPriorityReduce, nil)
+			list, err := ttp(test.pod, nodeNameToInfo, test.nodes)
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
 
-		if !reflect.DeepEqual(test.expectedList, list) {
-			t.Errorf("%s,\nexpected:\n\t%+v,\ngot:\n\t%+v", test.test, test.expectedList, list)
-		}
+			if !reflect.DeepEqual(test.expectedList, list) {
+				t.Errorf("expected:\n\t%+v,\ngot:\n\t%+v", test.expectedList, list)
+			}
+		})
 	}
-
 }