method parameter. It will be shut down automatically after the test runs.

```
class MyTest {
  @Test
  void test(MockWebServer server) {
    ...
  }
}
```

Alternately you may add the [MockWebServer] as a constructor parameter:

```
class MyTest {
  private final MockWebServer server;

  MyTest(MockWebServer server) {
    this.server = server;
  }

  @Test
  void test() {
    ...

            }
        }

        then:
        // 1 test class + 2 test method events
        stdout.toString().contains("Reusing configuration cache.")
        events.testClassesAndMethods.size() == 3
        assertTestExecuted(className: 'example.MyTest', methodName: 'foo', task: ':secondTest')
        assertTestExecuted(className: 'example.MyTest', methodName: 'foo2', task: ':secondTest')

        assertTestNotExecuted(className: "example.MyTest")
    }

    def "can target specific test task and methods"() {
        when:
        launchTests { TestLauncher launcher ->
            launcher.withTaskAndTestMethods(':secondTest', "example.MyTest", ["foo2"])
        }
        then:
        assertTaskNotExecuted(":test")
        assertTaskExecuted(":secondTest")

            ${mavenCentralRepository()}
            dependencies { ${testImplementationConfiguration} 'junit:junit:4.13' }
        """
        file('src/test/java/example/MyTest.java').text = """
            package example;
            public class MyTest {
                @org.junit.Test public void foo() throws Exception {
                     org.junit.Assert.assertEquals(1, 1);
                }
            }
        """

    @Override
    String getStandaloneTestClass() {
        return testClass('MyTest')
    }

    @Override
    String testClass(String className) {
        return """
            import org.junit.jupiter.api.*;

            public class $className {
               @Test
               @Tag("MyTest\$Fast")
               public void fastTest() {

     *
     * ```
     * typealias MyString = String
     * typealias MyList<A> = List<A>
     *
     * val list: MyList<MyString> = listOf()
     * ```
     *
     * `MyList<MyString>` may be expanded to a type `List<String>` with an abbreviated type `MyList<String>`, where `String` also has the
     * abbreviated type `MyString`. The abbreviated type is not `MyList<MyString>`, although it might be rendered as such.
     *
     *

        exception.stackTrace = stacktrace

        expect:
        formatter.format(testDescriptor, [exception]) == '''\
    java.lang.Exception: ouch
        at org.ClassName1.methodName1(FileName1.java:11)
        at org.ClassName2.methodName2(FileName2.java:22)
        at ClassName$1$1.whatever(MyTest.java:22)
'''
    }

    def "cannot compile against classes that are not part of Gradle's public API"() {
        when:
        buildFile << testablePluginProject()

        file('src/test/groovy/MyTest.groovy') << """
            class MyTest extends groovy.test.GroovyTestCase {

                void testImplIsHidden() {
                    try {
                        getClass().classLoader.loadClass("$Maps.name")

            ${mavenCentralRepository()}

            dependencies {
                testImplementation 'junit:junit:4.13'
            }
        """
        file('src/test/java/MyTest.java') << '''
            public class MyTest {

                @org.junit.Test
                public void pass() {
                }

                // if the test task is executed without a filter then the build fails

    def "options can be set prior to setting same test framework for the default test task"() {
        given:
        file('src/test/java/MyTest.java') << standaloneTestClass
        file("src/test/java/Slow.java") << """public interface Slow {}"""

        settingsFile << "rootProject.name = 'Sample'"
        buildFile << """apply plugin: 'java'
            test {