binary1.name >> "test1"

        expect:
        container.add(binary1)
        container.realizeNow()
        def p = container.getByName("test1")

        p.present
        p.get() == binary1
    }

    def "querying the result of get by name fails when not realized"() {
        def binary1 = Stub(SwiftBinary)
        binary1.name >> "test1"

        given:

import org.junit.*;

public class SomeIntegTest {
    @Test public void test1() {}
    @Test public void test2() {}

	}

	for _, test := range tests {
		err := v.Validate(getPodWithProfile(test.profile))
		if test.expectValid {
			assert.NoError(t, err, "Pod with profile %q should be valid", test.profile)
		} else {
			assert.Error(t, err, fmt.Sprintf("Pod with profile %q should trigger a validation error", test.profile))
		}
	}

	// Test multi-container pod.
	pod := &v1.Pod{

        assertEquals("test.sh", list.get(0));
        assertEquals("test1 ' test2", list.get(1));

        cmd = "test.sh 'test1 \" test2'";
        params.clear();
        list = extractor.parseCommand(cmd, params);
        assertEquals(2, list.size());
        assertEquals("test.sh", list.get(0));
        assertEquals("test1 \" test2", list.get(1));

        cmd = "test.sh $INPUT_FILE";
        params.clear();

    @Test
    @DisplayName("and a test display name")
    void test() {
    }
}
"""
        when:
        launchTests { TestLauncher launcher ->
            launcher.withTaskAndTestClasses(':test', ['org.example.SimpleTests'])
        }

        then:
        jvmTestEvents {
            task(":test") {
                suite("Gradle Test Run :test") {
                    suite("Gradle Test Executor") {

        collector.beforeTest(test)
        collector.beforeTest(test2)
        collector.onOutput(test, new DefaultTestOutputEvent(StdErr, "err-1"))
        collector.onOutput(test2, new DefaultTestOutputEvent(StdOut, "out-2"))
        collector.onOutput(test, new DefaultTestOutputEvent(StdOut, "out-1"))

        then:
        1 * writer.onOutput(3, 1, new DefaultTestOutputEvent(StdErr, "err-1"))

		fmt.Sprintf(DestinationHost, "test", 0, 0),
		fmt.Sprintf(MirrorHost, 0),
		fmt.Sprintf(VSGateway, 0),
		fmt.Sprintf(URISchemeMethodAuthorityRegexMatch, 0, 0, "test"),
		fmt.Sprintf(HeaderAndQueryParamsRegexMatch, 0, 0, "test", "test"),
		fmt.Sprintf(AllowOriginsRegexMatch, 0, 0),
		fmt.Sprintf(WorkloadSelector, "test"),
		fmt.Sprintf(PortInPorts, 0),
		fmt.Sprintf(FromRegistry, "test", 0),
		fmt.Sprintf(ImageInContainer, 0),

	for _, test := range tests {
		t.Run("", func(t *testing.T) {
			args := []string{"operator", "init", "--dry-run"}
			if test.operatorNamespace != "" {
				args = append(args, "--operatorNamespace", test.operatorNamespace)
			}
			if test.watchedNamespaces != "" {
				args = append(args, "--watchedNamespaces", test.watchedNamespaces)
			}

			kubeClientFunc = func() (kube.CLIClient, error) {
				return nil, nil
			}

		if err != nil && !test.expectError {
			t.Errorf("test %q failed: %v", test.name, err)
		}
		if err == nil && test.expectError {
			t.Errorf("test %q failed: expected error, got success", test.name)
		}

		if err = test.validate(base); err != nil {
			t.Errorf("test %q failed validation: %v", test.name, err)
		}

		os.RemoveAll(base)
	}
}

        where:
        path1    | path2    | test1   | test2   | expectedEntries
        '/pathA' | '/pathA' | 'false' | 'false' | [[path: '/pathA', test: 'false']]
        '/pathA' | '/pathA' | 'false' | 'true'  | [[path: '/pathA', test: 'false']]
        '/pathA' | '/pathA' | 'true'  | 'false' | [[path: '/pathA', test: 'false']]