dependsOn testing.suites.$suiteName
            }

            tasks.register('checkConfiguration') {
                dependsOn $suiteName
                doLast {
                    def ${suiteName}CompileClasspathFileNames = compile*.name
                    def ${suiteName}RuntimeClasspathFileNames = runtime*.name

                dependsOn(testing.suites.named("$suiteName"))
            }

            tasks.register("checkConfiguration") {
                dependsOn("$suiteName")
                doLast {
                    val ${suiteName}CompileClasspathFileNames = configurations.getByName("${suiteName}CompileClasspath").files.map { it.name }

        rootSuite.descriptor.jvmTestKind == JvmTestKind.SUITE
        rootSuite.descriptor.name == 'Gradle Test Run :test'
        rootSuite.descriptor.displayName == 'Gradle Test Run :test'
        rootSuite.descriptor.suiteName == 'Gradle Test Run :test'
        rootSuite.descriptor.className == null
        rootSuite.descriptor.methodName == null
        rootSuite.descriptor.parent == null

            ErrorMessageBuilder err = new ErrorMessageBuilder()
            err.title("The following test events were received but not verified")
            remainingEvents.each { err.candidate("${it} : Kind=${it.jvmTestKind} suiteName=${it.suiteName} className=${it.className} methodName=${it.methodName} displayName=${it.displayName}") }
            throw err.build()
        }
    }

    interface TestEventsSpec {

     */
    @Internal
    public String getSuiteName() {
        return suiteName;
    }

    public void setSuiteName(String suiteName) {
        this.suiteName = suiteName;
    }

    /**
     * Sets the default name of the test, if one is not specified in a suite XML file or in the source code.
     */
    @Internal

        expect:
        succeeds ":integTest"
        assertIntegTestsExecuted()
    }
    // endregion custom test suite

    // region all suites
    def "can set test framework in #suiteName suite prior to setting options within test task"() {
        given:
        buildFile << """
        // Configure task through suite
        testing {
            suites {
                integTest(JvmTestSuite) {

		}
	}
	return strings.ReplaceAll(d, "/", "_")
}

// NewSuite returns a new suite instance.
func NewSuite(m *testing.M) Suite {
	_, f, _, _ := goruntime.Caller(1)
	suiteName := deriveSuiteName(f)

	return newSuite(suiteName,
		func(_ *suiteContext) int {
			return m.Run()
		},
		os.Exit,
		getSettings)
}

            assert event.descriptor.displayName == 'some test suite in human readable form'
            assert event.descriptor.jvmTestKind == JvmTestKind.SUITE
            assert event.descriptor.suiteName == 'some suite'
            assert event.descriptor.className == 'some class'
            assert event.descriptor.methodName == 'some method'
            assert event.descriptor.parent == null
        }
    }

                ":linkHelloTestGoogleTestExe", ":helloTestGoogleTestExe", ":runHelloTestGoogleTestExe"

        def testResults = new GoogleTestTestResults(file("build/test-results/helloTest/test_detail.xml"))
        testResults.suiteNames == ['HelloTest']
        testResults.suites['HelloTest'].passingTests == ['test_sum']
        testResults.suites['HelloTest'].failingTests == []
        testResults.checkTestCases(1, 1, 0)
    }

        file("build/test-results/helloTest/CUnitAutomated-Listing.xml").assertExists()

        def testResults = new CUnitTestResults(file("build/test-results/helloTest/CUnitAutomated-Results.xml"))
        testResults.suiteNames == ['hello test']
        testResults.suites['hello test'].passingTests == ['test_sum']
        testResults.suites['hello test'].failingTests == []
        testResults.checkTestCases(1, 1, 0)