.includeClass('example.MyTest')
                     .includeClass('example2.MyOtherTest2')
            }
        }

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

        def testClass = events.operation("Test class example.MyTest")
        testClass.descriptor.jvmTestKind == JvmTestKind.SUITE
        testClass.descriptor.name == 'example.MyTest'
        testClass.descriptor.displayName == 'Test class example.MyTest'
        testClass.descriptor.suiteName == 'example.MyTest'
        testClass.descriptor.className == 'example.MyTest'
        testClass.descriptor.methodName == null

// make sure only one instantiation is created.

import (
	"fmt"

	"cmd/compile/internal/test/testdata/mysort"
)

type MyString struct {
	string
}

func (a *MyString) Less(b *MyString) bool {
	return a.string < b.string
}

func main() {
	mysort.F()

	sl1 := []*mysort.MyInt{{7}, {1}, {4}, {6}}
	mysort.Sort(sl1)
	fmt.Printf("%v %v %v %v\n", sl1[0], sl1[1], sl1[2], sl1[3])

            launcher.withJvmTestClasses("example.MyTest")
            launcher.withJvmTestMethods("example.MyTest", "foo")
        }

        then:
        assertTestExecuted(className: "example.MyTest", methodName: "foo", task: ":test")
        assertTestExecuted(className: "example.MyTest", methodName: "foo", task: ":secondTest")
        assertTestExecuted(className: "example.MyTest", methodName: "foo2", task: ":secondTest")

            assert !taskOutput.contains("""MyTest > testExpectation ${TestLogEvent.STANDARD_OUT.consoleMarker}
    standard output""")
            assert !taskOutput.contains("""MyTest > testExpectation ${TestLogEvent.STANDARD_ERROR.consoleMarker}
    standard error""")
        } else {
            outputDoesNotContain("""MyTest > testExpectation ${TestLogEvent.STANDARD_OUT.consoleMarker}
    standard output""")

        given:
        buildFile << java9Build()

        file('src/test/java/MyTest.java') << standaloneTestClass

        when:
        succeeds 'test'

        then:
        noExceptionThrown()

        and:
        classFormat(classFile('java', 'test', 'MyTest.class')) == 53

    }

    @Requires(UnitTestPreconditions.Jdk9OrLater)

			DoRaw(context.TODO())
		if err != nil {
			t.Fatal(err)
		}
		obj, err := decodeYAML(result)
		if err != nil {
			t.Fatal(err, string(result))
		}
		if obj.GetName() != "mytest" {
			t.Fatalf("expected mytest, got %s", obj.GetName())
		}
		if obj.GetAPIVersion() != apiVersion {

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")