/*
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 equivalence

import (
	"errors"
	"reflect"
	"testing"

	"k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/resource"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/util/sets"
	"k8s.io/kubernetes/pkg/scheduler/algorithm"
	"k8s.io/kubernetes/pkg/scheduler/algorithm/predicates"
	schedulercache "k8s.io/kubernetes/pkg/scheduler/cache"
)

// makeBasicPod returns a Pod object with many of the fields populated.
func makeBasicPod(name string) *v1.Pod {
	isController := true
	return &v1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: "test-ns",
			Labels:    map[string]string{"app": "web", "env": "prod"},
			OwnerReferences: []metav1.OwnerReference{
				{
					APIVersion: "v1",
					Kind:       "ReplicationController",
					Name:       "rc",
					UID:        "123",
					Controller: &isController,
				},
			},
		},
		Spec: v1.PodSpec{
			Affinity: &v1.Affinity{
				NodeAffinity: &v1.NodeAffinity{
					RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{
						NodeSelectorTerms: []v1.NodeSelectorTerm{
							{
								MatchExpressions: []v1.NodeSelectorRequirement{
									{
										Key:      "failure-domain.beta.kubernetes.io/zone",
										Operator: "Exists",
									},
								},
							},
						},
					},
				},
				PodAffinity: &v1.PodAffinity{
					RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
						{
							LabelSelector: &metav1.LabelSelector{
								MatchLabels: map[string]string{"app": "db"}},
							TopologyKey: "kubernetes.io/hostname",
						},
					},
				},
				PodAntiAffinity: &v1.PodAntiAffinity{
					RequiredDuringSchedulingIgnoredDuringExecution: []v1.PodAffinityTerm{
						{
							LabelSelector: &metav1.LabelSelector{
								MatchLabels: map[string]string{"app": "web"}},
							TopologyKey: "kubernetes.io/hostname",
						},
					},
				},
			},
			InitContainers: []v1.Container{
				{
					Name:  "init-pause",
					Image: "gcr.io/google_containers/pause",
					Resources: v1.ResourceRequirements{
						Limits: v1.ResourceList{
							"cpu": resource.MustParse("1"),
							"mem": resource.MustParse("100Mi"),
						},
					},
				},
			},
			Containers: []v1.Container{
				{
					Name:  "pause",
					Image: "gcr.io/google_containers/pause",
					Resources: v1.ResourceRequirements{
						Limits: v1.ResourceList{
							"cpu": resource.MustParse("1"),
							"mem": resource.MustParse("100Mi"),
						},
					},
					VolumeMounts: []v1.VolumeMount{
						{
							Name:      "nfs",
							MountPath: "/srv/data",
						},
					},
				},
			},
			NodeSelector: map[string]string{"node-type": "awesome"},
			Tolerations: []v1.Toleration{
				{
					Effect:   "NoSchedule",
					Key:      "experimental",
					Operator: "Exists",
				},
			},
			Volumes: []v1.Volume{
				{
					VolumeSource: v1.VolumeSource{
						PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
							ClaimName: "someEBSVol1",
						},
					},
				},
				{
					VolumeSource: v1.VolumeSource{
						PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
							ClaimName: "someEBSVol2",
						},
					},
				},
				{
					Name: "nfs",
					VolumeSource: v1.VolumeSource{
						NFS: &v1.NFSVolumeSource{
							Server: "nfs.corp.example.com",
						},
					},
				},
			},
		},
	}
}

type predicateItemType struct {
	fit     bool
	reasons []algorithm.PredicateFailureReason
}

// mockPredicate provides an algorithm.FitPredicate with pre-set return values.
type mockPredicate struct {
	fit       bool
	reasons   []algorithm.PredicateFailureReason
	err       error
	callCount int
}

func (p *mockPredicate) predicate(*v1.Pod, algorithm.PredicateMetadata, *schedulercache.NodeInfo) (bool, []algorithm.PredicateFailureReason, error) {
	p.callCount++
	return p.fit, p.reasons, p.err
}

func TestRunPredicate(t *testing.T) {
	tests := []struct {
		name                                        string
		pred                                        mockPredicate
		expectFit, expectCacheHit, expectCacheWrite bool
		expectedReasons                             []algorithm.PredicateFailureReason
		expectedError                               string
	}{
		{
			name:             "pod fits/cache hit",
			pred:             mockPredicate{},
			expectFit:        true,
			expectCacheHit:   true,
			expectCacheWrite: false,
		},
		{
			name:             "pod fits/cache miss",
			pred:             mockPredicate{fit: true},
			expectFit:        true,
			expectCacheHit:   false,
			expectCacheWrite: true,
		},
		{
			name:             "pod doesn't fit/cache miss",
			pred:             mockPredicate{reasons: []algorithm.PredicateFailureReason{predicates.ErrFakePredicate}},
			expectFit:        false,
			expectCacheHit:   false,
			expectCacheWrite: true,
			expectedReasons:  []algorithm.PredicateFailureReason{predicates.ErrFakePredicate},
		},
		{
			name:             "pod doesn't fit/cache hit",
			pred:             mockPredicate{},
			expectFit:        false,
			expectCacheHit:   true,
			expectCacheWrite: false,
			expectedReasons:  []algorithm.PredicateFailureReason{predicates.ErrFakePredicate},
		},
		{
			name:             "predicate error",
			pred:             mockPredicate{err: errors.New("This is expected")},
			expectFit:        false,
			expectCacheHit:   false,
			expectCacheWrite: false,
			expectedError:    "This is expected",
		},
	}

	predicatesOrdering := []string{"testPredicate"}
	predicateID := 0
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			node := schedulercache.NewNodeInfo()
			testNode := &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "n1"}}
			node.SetNode(testNode)
			pod := &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "p1"}}
			meta := algorithm.EmptyPredicateMetadataProducer(nil, nil)

			// Initialize and populate equivalence class cache.
			ecache := NewCache(predicatesOrdering)
			ecache.Snapshot()
			nodeCache, _ := ecache.GetNodeCache(testNode.Name)

			equivClass := NewClass(pod)
			if test.expectCacheHit {
				nodeCache.updateResult(pod.Name, "testPredicate", predicateID, test.expectFit, test.expectedReasons, equivClass.hash, node)
			}

			fit, reasons, err := nodeCache.RunPredicate(test.pred.predicate, "testPredicate", predicateID, pod, meta, node, equivClass)

			if err != nil {
				if err.Error() != test.expectedError {
					t.Errorf("Expected error %v but got %v", test.expectedError, err)
				}
			} else if len(test.expectedError) > 0 {
				t.Errorf("Expected error %v but got nil", test.expectedError)
			}
			if fit && !test.expectFit {
				t.Errorf("pod should not fit")
			}
			if !fit && test.expectFit {
				t.Errorf("pod should fit")
			}
			if len(reasons) != len(test.expectedReasons) {
				t.Errorf("Expected failures: %v but got %v", test.expectedReasons, reasons)
			} else {
				for i, reason := range reasons {
					if reason != test.expectedReasons[i] {
						t.Errorf("Expected failures: %v but got %v", test.expectedReasons, reasons)
						break
					}
				}
			}
			if test.expectCacheHit && test.pred.callCount != 0 {
				t.Errorf("Predicate should not be called")
			}
			if !test.expectCacheHit && test.pred.callCount == 0 {
				t.Errorf("Predicate should be called")
			}
			_, ok := nodeCache.lookupResult(pod.Name, node.Node().Name, "testPredicate", predicateID, equivClass.hash)
			if !ok && test.expectCacheWrite {
				t.Errorf("Cache write should happen")
			}
			if !test.expectCacheHit && test.expectCacheWrite && !ok {
				t.Errorf("Cache write should happen")
			}
			if !test.expectCacheHit && !test.expectCacheWrite && ok {
				t.Errorf("Cache write should not happen")
			}
		})
	}
}

func TestUpdateResult(t *testing.T) {
	predicatesOrdering := []string{"GeneralPredicates"}
	tests := []struct {
		name               string
		pod                string
		predicateKey       string
		predicateID        int
		nodeName           string
		fit                bool
		reasons            []algorithm.PredicateFailureReason
		equivalenceHash    uint64
		expectPredicateMap bool
		expectCacheItem    predicateResult
	}{
		{
			name:               "test 1",
			pod:                "testPod",
			predicateKey:       "GeneralPredicates",
			predicateID:        0,
			nodeName:           "node1",
			fit:                true,
			equivalenceHash:    123,
			expectPredicateMap: false,
			expectCacheItem: predicateResult{
				Fit: true,
			},
		},
		{
			name:               "test 2",
			pod:                "testPod",
			predicateKey:       "GeneralPredicates",
			predicateID:        0,
			nodeName:           "node2",
			fit:                false,
			equivalenceHash:    123,
			expectPredicateMap: true,
			expectCacheItem: predicateResult{
				Fit: false,
			},
		},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			node := schedulercache.NewNodeInfo()
			testNode := &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: test.nodeName}}
			node.SetNode(testNode)

			// Initialize and populate equivalence class cache.
			ecache := NewCache(predicatesOrdering)
			nodeCache, _ := ecache.GetNodeCache(testNode.Name)

			if test.expectPredicateMap {
				predicateItem := predicateResult{
					Fit: true,
				}
				nodeCache.cache[test.predicateID] =
					resultMap{
						test.equivalenceHash: predicateItem,
					}
			}

			nodeCache.updateResult(
				test.pod,
				test.predicateKey,
				test.predicateID,
				test.fit,
				test.reasons,
				test.equivalenceHash,
				node,
			)

			cachedMapItem := nodeCache.cache[test.predicateID]
			if cachedMapItem == nil {
				t.Errorf("can't find expected cache item: %v", test.expectCacheItem)
			} else {
				if !reflect.DeepEqual(cachedMapItem[test.equivalenceHash], test.expectCacheItem) {
					t.Errorf("expected cached item: %v, but got: %v",
						test.expectCacheItem, cachedMapItem[test.equivalenceHash])
				}
			}
		})
	}
}

// slicesEqual wraps reflect.DeepEqual, but returns true when comparing nil and empty slice.
func slicesEqual(a, b []algorithm.PredicateFailureReason) bool {
	if len(a) == 0 && len(b) == 0 {
		return true
	}
	return reflect.DeepEqual(a, b)
}

func TestLookupResult(t *testing.T) {
	predicatesOrdering := []string{"GeneralPredicates"}
	tests := []struct {
		name                              string
		podName                           string
		nodeName                          string
		predicateKey                      string
		predicateID                       int
		equivalenceHashForUpdatePredicate uint64
		equivalenceHashForCalPredicate    uint64
		cachedItem                        predicateItemType
		expectedPredicateKeyMiss          bool
		expectedEquivalenceHashMiss       bool
		expectedPredicateItem             predicateItemType
	}{
		{
			name:                              "test 1",
			podName:                           "testPod",
			nodeName:                          "node1",
			equivalenceHashForUpdatePredicate: 123,
			equivalenceHashForCalPredicate:    123,
			predicateKey:                      "GeneralPredicates",
			predicateID:                       0,
			cachedItem: predicateItemType{
				fit:     false,
				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
			},
			expectedPredicateKeyMiss: true,
			expectedPredicateItem: predicateItemType{
				fit:     false,
				reasons: []algorithm.PredicateFailureReason{},
			},
		},
		{
			name:                              "test 2",
			podName:                           "testPod",
			nodeName:                          "node2",
			equivalenceHashForUpdatePredicate: 123,
			equivalenceHashForCalPredicate:    123,
			predicateKey:                      "GeneralPredicates",
			predicateID:                       0,
			cachedItem: predicateItemType{
				fit: true,
			},
			expectedPredicateKeyMiss: false,
			expectedPredicateItem: predicateItemType{
				fit:     true,
				reasons: []algorithm.PredicateFailureReason{},
			},
		},
		{
			name:                              "test 3",
			podName:                           "testPod",
			nodeName:                          "node3",
			equivalenceHashForUpdatePredicate: 123,
			equivalenceHashForCalPredicate:    123,
			predicateKey:                      "GeneralPredicates",
			predicateID:                       0,
			cachedItem: predicateItemType{
				fit:     false,
				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
			},
			expectedPredicateKeyMiss: false,
			expectedPredicateItem: predicateItemType{
				fit:     false,
				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
			},
		},
		{
			name:                              "test 4",
			podName:                           "testPod",
			nodeName:                          "node4",
			equivalenceHashForUpdatePredicate: 123,
			equivalenceHashForCalPredicate:    456,
			predicateKey:                      "GeneralPredicates",
			predicateID:                       0,
			cachedItem: predicateItemType{
				fit:     false,
				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
			},
			expectedPredicateKeyMiss:    false,
			expectedEquivalenceHashMiss: true,
			expectedPredicateItem: predicateItemType{
				fit:     false,
				reasons: []algorithm.PredicateFailureReason{},
			},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			testNode := &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: test.nodeName}}

			// Initialize and populate equivalence class cache.
			ecache := NewCache(predicatesOrdering)
			nodeCache, _ := ecache.GetNodeCache(testNode.Name)

			node := schedulercache.NewNodeInfo()
			node.SetNode(testNode)
			// set cached item to equivalence cache
			nodeCache.updateResult(
				test.podName,
				test.predicateKey,
				test.predicateID,
				test.cachedItem.fit,
				test.cachedItem.reasons,
				test.equivalenceHashForUpdatePredicate,
				node,
			)
			// if we want to do invalid, invalid the cached item
			if test.expectedPredicateKeyMiss {
				predicateKeys := sets.NewString()
				predicateKeys.Insert(test.predicateKey)
				ecache.InvalidatePredicatesOnNode(test.nodeName, predicateKeys)
			}
			// calculate predicate with equivalence cache
			result, ok := nodeCache.lookupResult(test.podName,
				test.nodeName,
				test.predicateKey,
				test.predicateID,
				test.equivalenceHashForCalPredicate,
			)
			fit, reasons := result.Fit, result.FailReasons
			// returned invalid should match expectedPredicateKeyMiss or expectedEquivalenceHashMiss
			if test.equivalenceHashForUpdatePredicate != test.equivalenceHashForCalPredicate {
				if ok && test.expectedEquivalenceHashMiss {
					t.Errorf("Failed: %s, expected (equivalence hash) cache miss", test.name)
				}
				if !ok && !test.expectedEquivalenceHashMiss {
					t.Errorf("Failed: %s, expected (equivalence hash) cache hit", test.name)
				}
			} else {
				if ok && test.expectedPredicateKeyMiss {
					t.Errorf("Failed: %s, expected (predicate key) cache miss", test.name)
				}
				if !ok && !test.expectedPredicateKeyMiss {
					t.Errorf("Failed: %s, expected (predicate key) cache hit", test.name)
				}
			}
			// returned predicate result should match expected predicate item
			if fit != test.expectedPredicateItem.fit {
				t.Errorf("Failed: %s, expected fit: %v, but got: %v", test.name, test.cachedItem.fit, fit)
			}
			if !slicesEqual(reasons, test.expectedPredicateItem.reasons) {
				t.Errorf("Failed: %s, expected reasons: %v, but got: %v",
					test.name, test.expectedPredicateItem.reasons, reasons)
			}
		})
	}
}

func TestGetEquivalenceHash(t *testing.T) {
	pod1 := makeBasicPod("pod1")
	pod2 := makeBasicPod("pod2")

	pod3 := makeBasicPod("pod3")
	pod3.Spec.Volumes = []v1.Volume{
		{
			VolumeSource: v1.VolumeSource{
				PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
					ClaimName: "someEBSVol111",
				},
			},
		},
	}

	pod4 := makeBasicPod("pod4")
	pod4.Spec.Volumes = []v1.Volume{
		{
			VolumeSource: v1.VolumeSource{
				PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
					ClaimName: "someEBSVol222",
				},
			},
		},
	}

	pod5 := makeBasicPod("pod5")
	pod5.Spec.Volumes = []v1.Volume{}

	pod6 := makeBasicPod("pod6")
	pod6.Spec.Volumes = nil

	pod7 := makeBasicPod("pod7")
	pod7.Spec.NodeSelector = nil

	pod8 := makeBasicPod("pod8")
	pod8.Spec.NodeSelector = make(map[string]string)

	type podInfo struct {
		pod         *v1.Pod
		hashIsValid bool
	}

	tests := []struct {
		name         string
		podInfoList  []podInfo
		isEquivalent bool
	}{
		{
			name: "pods with everything the same except name",
			podInfoList: []podInfo{
				{pod: pod1, hashIsValid: true},
				{pod: pod2, hashIsValid: true},
			},
			isEquivalent: true,
		},
		{
			name: "pods that only differ in their PVC volume sources",
			podInfoList: []podInfo{
				{pod: pod3, hashIsValid: true},
				{pod: pod4, hashIsValid: true},
			},
			isEquivalent: false,
		},
		{
			name: "pods that have no volumes, but one uses nil and one uses an empty slice",
			podInfoList: []podInfo{
				{pod: pod5, hashIsValid: true},
				{pod: pod6, hashIsValid: true},
			},
			isEquivalent: true,
		},
		{
			name: "pods that have no NodeSelector, but one uses nil and one uses an empty map",
			podInfoList: []podInfo{
				{pod: pod7, hashIsValid: true},
				{pod: pod8, hashIsValid: true},
			},
			isEquivalent: true,
		},
	}

	var (
		targetPodInfo podInfo
		targetHash    uint64
	)

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			for i, podInfo := range test.podInfoList {
				testPod := podInfo.pod
				eclassInfo := NewClass(testPod)
				if eclassInfo == nil && podInfo.hashIsValid {
					t.Errorf("Failed: pod %v is expected to have valid hash", testPod)
				}

				if eclassInfo != nil {
					// NOTE(harry): the first element will be used as target so
					// this logic can't verify more than two inequivalent pods
					if i == 0 {
						targetHash = eclassInfo.hash
						targetPodInfo = podInfo
					} else {
						if targetHash != eclassInfo.hash {
							if test.isEquivalent {
								t.Errorf("Failed: pod: %v is expected to be equivalent to: %v", testPod, targetPodInfo.pod)
							}
						}
					}
				}
			}
		})
	}
}

func TestInvalidateCachedPredicateItemOfAllNodes(t *testing.T) {
	testPredicate := "GeneralPredicates"
	testPredicateID := 0
	predicatesOrdering := []string{testPredicate}
	// tests is used to initialize all nodes
	tests := []struct {
		name                              string
		podName                           string
		nodeName                          string
		equivalenceHashForUpdatePredicate uint64
		cachedItem                        predicateItemType
	}{
		{
			name:                              "hash predicate 123 not fits host ports",
			podName:                           "testPod",
			nodeName:                          "node1",
			equivalenceHashForUpdatePredicate: 123,
			cachedItem: predicateItemType{
				fit: false,
				reasons: []algorithm.PredicateFailureReason{
					predicates.ErrPodNotFitsHostPorts,
				},
			},
		},
		{
			name:                              "hash predicate 456 not fits host ports",
			podName:                           "testPod",
			nodeName:                          "node2",
			equivalenceHashForUpdatePredicate: 456,
			cachedItem: predicateItemType{
				fit: false,
				reasons: []algorithm.PredicateFailureReason{
					predicates.ErrPodNotFitsHostPorts,
				},
			},
		},
		{
			name:                              "hash predicate 123 fits",
			podName:                           "testPod",
			nodeName:                          "node3",
			equivalenceHashForUpdatePredicate: 123,
			cachedItem: predicateItemType{
				fit: true,
			},
		},
	}
	ecache := NewCache(predicatesOrdering)

	for _, test := range tests {
		node := schedulercache.NewNodeInfo()
		testNode := &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: test.nodeName}}
		node.SetNode(testNode)

		nodeCache, _ := ecache.GetNodeCache(testNode.Name)
		// set cached item to equivalence cache
		nodeCache.updateResult(
			test.podName,
			testPredicate,
			testPredicateID,
			test.cachedItem.fit,
			test.cachedItem.reasons,
			test.equivalenceHashForUpdatePredicate,
			node,
		)
	}

	// invalidate cached predicate for all nodes
	ecache.InvalidatePredicates(sets.NewString(testPredicate))

	// there should be no cached predicate any more
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			if nodeCache, exist := ecache.nodeToCache[test.nodeName]; exist {
				if cache := nodeCache.cache[testPredicateID]; cache != nil {
					t.Errorf("Failed: cached item for predicate key: %v on node: %v should be invalidated",
						testPredicate, test.nodeName)
				}
			}
		})
	}
}

func TestInvalidateAllCachedPredicateItemOfNode(t *testing.T) {
	testPredicate := "GeneralPredicates"
	testPredicateID := 0
	predicatesOrdering := []string{testPredicate}
	// tests is used to initialize all nodes
	tests := []struct {
		name                              string
		podName                           string
		nodeName                          string
		equivalenceHashForUpdatePredicate uint64
		cachedItem                        predicateItemType
	}{
		{
			name:                              "hash predicate 123 not fits host ports",
			podName:                           "testPod",
			nodeName:                          "node1",
			equivalenceHashForUpdatePredicate: 123,
			cachedItem: predicateItemType{
				fit:     false,
				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
			},
		},
		{
			name:                              "hash predicate 456 not fits host ports",
			podName:                           "testPod",
			nodeName:                          "node2",
			equivalenceHashForUpdatePredicate: 456,
			cachedItem: predicateItemType{
				fit:     false,
				reasons: []algorithm.PredicateFailureReason{predicates.ErrPodNotFitsHostPorts},
			},
		},
		{
			name:                              "hash predicate 123 fits host ports",
			podName:                           "testPod",
			nodeName:                          "node3",
			equivalenceHashForUpdatePredicate: 123,
			cachedItem: predicateItemType{
				fit: true,
			},
		},
	}
	ecache := NewCache(predicatesOrdering)

	for _, test := range tests {
		node := schedulercache.NewNodeInfo()
		testNode := &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: test.nodeName}}
		node.SetNode(testNode)

		nodeCache, _ := ecache.GetNodeCache(testNode.Name)
		// set cached item to equivalence cache
		nodeCache.updateResult(
			test.podName,
			testPredicate,
			testPredicateID,
			test.cachedItem.fit,
			test.cachedItem.reasons,
			test.equivalenceHashForUpdatePredicate,
			node,
		)
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			oldNodeCache, _ := ecache.GetNodeCache(test.nodeName)
			oldGeneration := oldNodeCache.generation
			// invalidate cached predicate for all nodes
			ecache.InvalidateAllPredicatesOnNode(test.nodeName)
			if n, _ := ecache.GetNodeCache(test.nodeName); oldGeneration == n.generation {
				t.Errorf("Failed: cached item for node: %v should be invalidated", test.nodeName)
			}
		})
	}
}

func BenchmarkEquivalenceHash(b *testing.B) {
	pod := makeBasicPod("test")
	for i := 0; i < b.N; i++ {
		getEquivalencePod(pod)
	}
}