},
		{
			pod: st.MakePod().Label("foo", "").Obj(),
			pods: []*v1.Pod{
				st.MakePod().Node("nodeA").Namespace(defaultNamespace).PodAntiAffinityExists("foo", "invalid-node-label", st.PodAntiAffinityWithRequiredReq).Obj(),
			},
			nodes: []*v1.Node{

        def rootNode = Mock(Node)
        def node1 = Mock(Node)
        def node2 = Mock(Node)
        def node3 = Mock(Node)
        def node4 = Mock(Node)
        def node5 = Mock(Node)
        def node6 = Mock(Node)
        def node7 = Mock(Node)

        hierarchy.recordNodeAccessingLocations(rootNode, [root.absolutePath])
        hierarchy.recordNodeAccessingLocations(node1, [root.file("location").absolutePath])

		},
		// there are 2 regions, say regionChina(node1,node3,node4) and regionIndia(node2,node5), both regions have nodes that match the preference.
		// But there are more nodes(actually more existing pods) in regionChina that match the preference than regionIndia.

				st.MakePod().Name("p2").UID("p2").Namespace(v1.NamespaceDefault).Node("node2").Req(mediumRes).Obj(),
			},
			// even though node1 will fail with error but node2 will still be returned as a valid nominated node.
			nodes: []*v1.Node{
				st.MakeNode().Name("node1").Capacity(largeRes).Label("error", "true").Obj(),
				st.MakeNode().Name("node2").Capacity(largeRes).Obj(),
			},

            [
                taskMatcher("node1", ":producer:producer", []),
                transformStepMatcher("node2", expectedTransformId1, ["node1"]),
                transformStepMatcher("node3", expectedTransformId2, ["node1"]),
                taskMatcher("node4", ":consumer1:resolve", ["node2"]),
                taskMatcher("node5", ":consumer2:resolve", ["node3"]),
            ]
        )

			},
			lease:                   createNodeLease("node0", metav1.NewMicroTime(fakeNow.Time)),
			expectedRequestCount:    1, // List
			expectedNodes:           nil,
			expectedPodStatusUpdate: false,
		},
		// Node created long time ago, without status. Node lease is missing.
		// Expect Unknown status posted from node controller.
		{

				nodeInfos = append(nodeInfos, ni)
			}
			nodes, _ := nodesWherePreemptionMightHelp(nodeInfos, tt.nodesStatuses)
			if len(tt.expected) != len(nodes) {
				t.Errorf("number of nodes is not the same as expected. exptectd: %d, got: %d. Nodes: %v", len(tt.expected), len(nodes), nodes)
			}
			for _, node := range nodes {
				name := node.Node().Name
				if _, found := tt.expected[name]; !found {

		{User: node1, Decision: authorizer.DecisionAllow, Secret: "shared-all"},

		{User: node2, Decision: authorizer.DecisionNoOpinion, Secret: "node1-only"},
		{User: node2, Decision: authorizer.DecisionAllow, Secret: "node1-node2-only"},
		{User: node2, Decision: authorizer.DecisionAllow, Secret: "shared-all"},

		{User: node3, Decision: authorizer.DecisionNoOpinion, Secret: "node1-only"},

				},
			},
			nodes: []*v1.Node{
				{ObjectMeta: metav1.ObjectMeta{Name: "node1", Labels: label1}},
				{ObjectMeta: metav1.ObjectMeta{Name: "node2", Labels: label2}},
				{ObjectMeta: metav1.ObjectMeta{Name: "node3", Labels: label3}},
			},
			expectedList: []framework.NodeScore{{Name: "node1", Score: 0}, {Name: "node2", Score: 0}, {Name: "node3", Score: 0}},
		},
		{
			// PreScore returns Skip.

        addNode(node1)
        removeNode(node1)
        bindings.add(rule)

        when:
        addNode(node2)

        then:
        bindings.getRulesWithSubject(nodeAtState("a", ModelNode.State.Finalized)) as List == [rule]
        rule.subjectBinding.boundTo == node2
    }

    def "can replace by-type subject when bound"() {
        def node1 = node("a", Long)
        def node2 = node("a", Long)