makeGCContainer("foo1", "baz", 0, 0, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo2", "bar", 2, 2, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo2", "bar", 1, 1, runtimeapi.ContainerState_CONTAINER_EXITED),
				makeGCContainer("foo2", "bar", 0, 0, runtimeapi.ContainerState_CONTAINER_EXITED),
			},
			remain:               []int{0, 1, 3, 4, 6, 7},

        then:
        events.testClassesAndMethods.size() == 5
        assertTestExecuted(className: 'example.MyTest', methodName: 'foo', task: ':secondTest')
        assertTestExecuted(className: 'example.MyTest', methodName: 'foo2', task: ':secondTest')
        assertTestExecuted(className: 'example2.MyOtherTest2', methodName: 'baz', task: ':secondTest')
    }

    def "can select test methods"() {
        when:

	set := newStatefulSet(3)
	pod := newStatefulSetPod(set, 0)
	pod.OwnerReferences = nil
	set2 := newStatefulSet(3)
	set2.Name = "foo2"
	om.setsIndexer.Add(set)
	om.setsIndexer.Add(set2)
	clone := *pod
	clone.Labels = map[string]string{"foo2": "bar2"}
	fakeResourceVersion(&clone)
	ssc.updatePod(logger, &clone, pod)
	if got, want := ssc.queue.Len(), 2; got != want {

	addNodes(manager.nodeStore, 0, 5, nil)
	manager.dsStore.Add(ds)
	expectSyncDaemonSets(t, manager, ds, podControl, 5, 0, 0)
	markPodsReady(podControl.podStore)

	ds.Spec.Template.Spec.Containers[0].Image = "foo2/bar2"
	ds.Spec.UpdateStrategy.Type = apps.RollingUpdateDaemonSetStrategyType
	intStr := intstr.FromInt32(int32(maxUnavailable))
	ds.Spec.UpdateStrategy.RollingUpdate = &apps.RollingUpdateDaemonSet{MaxUnavailable: &intStr}

        file("anotherProject/foo").text = "foo2"

        when:
        executer.withWorkerDaemonsExpirationDisabled()
        succeeds("runInWorker2")

        then:
        assertWorkerExecuted("runInWorker")
        assertWorkerExecuted("runInWorker2")

        and:
        file("bar/foo").text == "foo"
        file("anotherProject/bar/foo").text == "foo2"

        and:

        def build1 = singleProjectBuild("build1") {
            buildFile << "task foo1"
        }
        def build2 = singleProjectBuild("build2") {
            buildFile << "task foo2"
        }

        when:
        def allProgress = new CopyOnWriteArrayList<String>()

        concurrent.start {
            def connector = toolingApi.connector(build1)

        conf2.artifacts.add(Mock(PublishArtifact))
        ConfigurationVariant variant2 = conf2.outgoing.getVariants().create("variant2")
        variant2.attributes.attribute(Attribute.of("foo2", String), "bar2")
        variant2.artifacts.add(Stub(PublishArtifact))
        variant2.artifacts.add(Stub(PublishArtifact))

        when:

        def foo1 = mavenHttpRepo.module('org', 'foo', '1').publish()
        def foo2 = mavenHttpRepo.module('org', 'foo', '2').publish()
        def foo3 = mavenHttpRepo.module('org', 'foo', '3').publish()
        def bar1 = mavenHttpRepo.module('org', 'bar', '1')
            .dependsOn(foo2).publish()

        buildFile << """
            dependencies {
                implementation 'org:foo:[1,3]'

            public class MyTest {
                @org.junit.Test public void foo() throws Exception {
                     org.junit.Assert.assertEquals(1, 1);
                }
                @org.junit.Test public void foo2() throws Exception {
                     org.junit.Assert.assertEquals(1, 1);
                }
            }
        """

        file("src/test/java/example2/MyOtherTest.java") << """

			first: map[string]FileProjection{
				"foo": {Mode: 0644, Data: []byte("foo")},
				"bar": {Mode: 0644, Data: []byte("bar")},
			},
			next: map[string]FileProjection{
				"foo": {Mode: 0644, Data: []byte("foo2")},
				"bar": {Mode: 0640, Data: []byte("bar2")},
			},
			shouldWrite: true,
		},
		{
			name: "no update",
			first: map[string]FileProjection{
				"foo": {Mode: 0644, Data: []byte("foo")},