Namespace: "foo-ns",
		},
		Spec: v1.PodSpec{
			Containers: []v1.Container{
				{
					Name:  "foo1",
					Image: "busybox",
				},
				{
					Name:  "foo2",
					Image: "busybox",
				},
				{
					Name:  "foo3",
					Image: "busybox",
				},
			},
		},
		Status: v1.PodStatus{
			ContainerStatuses: []v1.ContainerStatus{
				{
					ContainerID: "://id1",

                fflush(stdout);
                return 0;
            }

            """),
            sourceFile("asm", "foo1/sum.s", getAsmSource("sum1")),
            sourceFile("asm", "foo2/sum.s", getAsmSource("sum2"))
        ]
    }

    @Override
    List<SourceFile> getHeaderFiles() {
        []
    }

    protected def getAsmSource(String methodName) {

        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:

class PropertiesAsMapTest {

    @Test
    void testPropertiesAsMap() {
        Properties props = new Properties();
        props.setProperty("foo1", "bar1");
        props.setProperty("foo2", "bar2");
        PropertiesAsMap pam = new PropertiesAsMap(props);
        assertEquals(2, pam.size());
        Set<Entry<String, String>> set = pam.entrySet();
        assertNotNull(set);

		},
		ClusterID: "",
	})
	ReplicatedFooServiceV2 = MakeService(ServiceArgs{
		Hostname: ReplicatedFooServiceName,
		Address:  "10.3.0.1",
		ServiceAccounts: []string{
			"spiffe://cluster.local/ns/default/sa/foo2",
			"spiffe://cluster.local/ns/default/sa/foo-share",
		},
		ClusterID: "",
	})

	// WorldService is a mock service with `world.default.svc.cluster.local` as
	// a hostname and `10.2.0.0` for ip

        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)

		"dir/subdir1/foo1": "dummy.txt",
		"dir/subdir1/foo2": "dummy.txt",
		"dir/subdir1/foo3": "dummy.txt",
		"dir/subdir2/foo4": "dummy.txt",
		"dir/zzlast": "dummy.txt"
	}
}
-- dummy.txt --
`)

	var seen []string
	Walk("dir", func(path string, info fs.FileInfo, err error) error {
		seen = append(seen, filepath.ToSlash(path))
		if info.Name() == "foo2" {
			return filepath.SkipAll
		}
		return nil

        ruleAction.execute("", ["foo", 3])

        then:
        ruleAction.inputTypes == [String, Integer]
        closureCalled == "foo3"
    }

    def "can adapt from action" () {
        ruleActionAdapter = new DefaultRuleActionAdapter(noopValidator, "context")
        def actionCalled = false

        when:

			imports: []metaImport{
				{Prefix: "example.com/user/foo", VCS: "git", RepoRoot: "https://example.com/repo/target"},
				{Prefix: "example.com/user/fooa", VCS: "git", RepoRoot: "https://example.com/repo/target"},
			},
			path: "example.com/user/fooa",
			mi:   metaImport{Prefix: "example.com/user/fooa", VCS: "git", RepoRoot: "https://example.com/repo/target"},
		},
		{
			imports: []metaImport{

        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: