}
                        }
                    }
                }
            }
        """

        file("src/test/java/FooTest.java") << """
            ${testFrameworkImports}
            public class FooTest {
                @Test public void foo() {
                    System.err.println("Run foo!");
                }
            }
        """

        """

        file("src/test/java/FooTest.java") << """
            public class FooTest {
                @org.junit.Test public void passes() {}
                @org.junit.Test public void fails() { throw new RuntimeException("Boo!"); }
            }
        """

        when:
        withConnection { it.newBuild().withArguments('test', '--tests', 'FooTest.passes').run() }

        then:

        .containsExactly(Foo.class);
    assertThat(findClassesToTest(ImmutableList.of(Foo.class, FooTest.class), "testNotPublic"))
        .containsExactly(Foo.class);
  }

  public void testFindClassesToTest_withCorrespondingTestClassAndExplicitlyTested() {
    ImmutableList<Class<?>> classes = ImmutableList.of(Foo.class, FooTest.class);

public interface TestFilter {

    /**
     * Appends a test name pattern to the inclusion filter. Wildcard '*' is supported, either test method name or class name is supported. Examples of test names: "com.foo.FooTest.someMethod",
     * "com.foo.FooTest", "*FooTest*", "com.foo*". See examples in the docs for {@link TestFilter}.
     *
     * @param testNamePattern test name pattern to include, can be class or method name, can contain wildcard '*'

func TestDecodeInto(t *testing.T) {
	type PluginFooConfig struct {
		FooTest string `json:"fooTest,omitempty"`
	}
	tests := []struct {
		name     string
		args     *runtime.Unknown
		expected PluginFooConfig
	}{
		{
			name: "test decode for JSON config",
			args: &runtime.Unknown{
				ContentType: runtime.ContentTypeJSON,
				Raw: []byte(`{
					"fooTest": "test decode"
				}`),
			},
			expected: PluginFooConfig{

        .containsExactly(Foo.class);
    assertThat(findClassesToTest(ImmutableList.of(Foo.class, FooTest.class), "testNotPublic"))
        .containsExactly(Foo.class);
  }

  public void testFindClassesToTest_withCorrespondingTestClassAndExplicitlyTested() {
    ImmutableList<Class<?>> classes = ImmutableList.of(Foo.class, FooTest.class);

    @Override
    protected void setupProjectIn(TestFile projectDir) {
        projectDir.file("src/main/java/Foo.java") << "public class Foo {}"
        projectDir.file("src/test/java/FooTest.java") << """
            import org.junit.*;

            public class FooTest {
                @Test
                public void test() {
                    new Foo();
                }
            }
        """

class TestTaskJvmArgsProviderIntegrationTest extends AbstractIntegrationSpec {

    def "jvm argument providers are passed to the test worker"() {
        file("src/test/java/FooTest.java") << """
            import java.io.*;
            import org.junit.*;

            public class FooTest {
                @Test
                public void test() throws IOException {
                    String location = System.getProperty("input.path");

            }
            """
        )

        withFile("src/main/kotlin/foo.gradle.kts", "plugins { base }")
        withFile(
            "src/test/kotlin/fooTest.kt",
            """
            import org.junit.Test
            class FooTest {
                @Test fun testFoo() { }
            }
            """.trimIndent()
        )

        build("test", "jacocoTestCoverageVerification")
    }

        succeeds('test').assertTasksNotSkipped()
    }

    def "test up-to-date status respects test name patterns"() {
        file("src/test/java/FooTest.java") << """
            ${testFrameworkImports}
            public class FooTest {
                @Test public void test() {}
            }
        """.stripIndent()
        file("src/test/java/BarTest.java") << """
            ${testFrameworkImports}