Obj(),
			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": "6000", "memory": "10000"}).Obj(),
			},
			existingPods: []*v1.Pod{
				st.MakePod().Node("node1").Req(map[v1.ResourceName]string{"cpu": "2000", "memory": "4000"}).Obj(),

	}

	instance1 := "instance-1"

	node1 := "node-1"
	node1Selector := &v1.NodeSelector{
		NodeSelectorTerms: []v1.NodeSelectorTerm{{
			MatchExpressions: []v1.NodeSelectorRequirement{{
				Key:      "kubernetes.io/hostname",
				Operator: v1.NodeSelectorOpIn,
				Values:   []string{node1},
			}},
		}},
	}
	node1Resources := resources{node1: map[string]ResourceModels{
		driver1: {

            builder.setStreamedValueListener(listener)
            builder.run()
        }

        then:
        models.size() == 4

        and:
        CustomModel model1 = models.get(0)
        model1.value == 1

        and:
        GradleProject gradleProject = models.get(1)
        gradleProject.name == "hello-world"

        and:
        CustomModel model2 = models.get(2)

    def "should resolve and filter first level dependencies in tree"() {
        given:
        def spec = Mock(Spec)
        def node1 = new TestResolvedDependency()
        def node2 = new TestResolvedDependency()
        def node3 = new TestResolvedDependency()
        def firstLevelDependencies = [(Mock(ModuleDependency)): node1, (Mock(ModuleDependency)): node2, (Mock(ModuleDependency)): node3]

			Key:    "kubernetes.io/hostname",
			Values: []string{"node1", "node1"},
		}},
	}}

	topologyMultiValues := []api.TopologySelectorTerm{{
		MatchLabelExpressions: []api.TopologySelectorLabelRequirement{{
			Key:    "kubernetes.io/hostname",
			Values: []string{"node1", "node2"},
		}},
	}}

	topologyEmptyMatchLabelExpressions := []api.TopologySelectorTerm{{

			expectedLabelSelector: labels.Instance{},
		},
		{
			name:                  "specific match",
			svc:                   makeFakeSvc(`{"kubernetes.io/hostname": "node1"}`),
			expectedLabelSelector: labels.Instance{"kubernetes.io/hostname": "node1"},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			selector := getNodeSelectorsForService(tc.svc)

					Name:              "pod1",
					Namespace:         testNS,
					Addresses:         [][]byte{parseIP("140.140.0.10")},
					Network:           testNW,
					ClusterId:         testC,
					Node:              "node1",
					CanonicalName:     "a",
					CanonicalRevision: "latest",
					ServiceAccount:    "sa1",
					WorkloadType:      workloadapi.WorkloadType_POD,
					WorkloadName:      "pod1",
				},
			},
		},

	if bm.Count() == 0 {
		return 0
	}

	var count float64 = 0
	var sum float64 = 0
	for _, node1 := range bm.GetBits() {
		for _, node2 := range bm.GetBits() {
			sum += float64(d[node1][node2])
			count++
		}
	}

	return sum / count

        when:
        addToGraph(destroyer)
        addToGraphAndPopulate(producer)
        def node1 = selectNextNode()

        then:
        assertIsResolveMutationsOf(node1, destroyer)
        assertNoWorkReadyToStart()

        when:
        node1.execute()
        finishedExecuting(node1)
        def node2 = selectNextNode()
        def node3 = selectNextNode()

        then:

				Obj(),
			oldNode:      st.MakeNode().Name("node-a").Label("zone", "zone1").Label("node", "node1").Label("foo", "bar").Obj(),
			newNode:      st.MakeNode().Name("node-a").Label("zone", "zone1").Label("node", "node1").Obj(),
			expectedHint: framework.Queue,
		},
		{
			name: "create node with non-related labels",