_ * testTask.getFilter() >> testFilter
        _ * tasksContainerInternal.findByPath(TEST_TASK_NAME) >> testTask
        TaskCollection<Test> testTaskCollection = Mock()
        _ * testTaskCollection.iterator() >> [testTask].iterator()
        _ * tasksContainerInternal.withType(AbstractTestTask) >> testTaskCollection
        _ * testTask.getOutputs() >> outputsInternal

    }

    def "can configure TestNG with an Action"() {
        when:
        testTask.useTestNG { TestNGOptions options ->
            options.suiteName = 'Custom Suite'
        }

        then:
        testTask.options.suiteName == 'Custom Suite'
    }

    TestNGTestFramework createFramework() {
        new TestNGTestFramework(testTask, new DefaultTestFilter(), objects)
    }

                suites {
                    test {
                        useTestNG('${TestNGCoverage.NEWEST}')
                        targets {
                            all {
                                testTask.configure {
                                    options {
                                        /* left empty */
                                    }
                                }
                            }

    private final Provider<Boolean> dryRun;

    public TestNGTestFramework(final Test testTask, DefaultTestFilter filter, ObjectFactory objects) {
        this(
            filter,
            objects,
            testTask.getTemporaryDirFactory(),
            testTask.getReports().getHtml(),
            objects.newInstance(TestNGOptions.class),
            testTask.getDryRun()
        );
    }

            testing {
                suites {
                    test {
                        useJUnit()
                        targets {
                            all {
                                testTask.configure {
                                    doLast {
                                        assert testFramework instanceof ${JUnitTestFramework.canonicalName}

                "task rootTask",
                "task testTask",
                "class ConventionBean { def getConventionProperty() { 'convention' } }"
        )
        file("child/build.gradle").writelns(
                "ext.childProperty = 'child'",
                "ext.sharedProperty = 'shared'",
                "task testTask {",
                "  doLast { new Reporter().checkProperties(project) }",

    val defaultExecuter = "embedded"
    val prefix = testType.prefix
    testType.executers.forEach { executer ->
        val taskName = "$executer${prefix.capitalize()}Test"
        val testTask = createTestTask(taskName, executer, sourceSet, testType) {
            this.setSystemPropertiesOfTestJVM("latest")
            this.systemProperties["org.gradle.integtest.crossVersion"] = "true"

 */

plugins {
    kotlin("multiplatform") version "$kotlinVersion"
}

repositories {
    mavenCentral()
}

kotlin {
    js(IR) {
        browser {
            testTask {
                useKarma {
                    useChromeHeadless()
                    $enableCssSupportOld
                }
            }

            $enableCssSupportNew
        }
    }

        given:
        project.apply plugin: 'java'
        RepoScriptBlockUtil.configureMavenCentral(project.repositories)
        def testTask = project.tasks.getByName('test')
        JacocoTaskExtension extension = testTask.extensions.getByType(JacocoTaskExtension)

        when:
        extension.with {
            destinationFile = project.file('build/jacoco/fake.exec')

                subprojects {
                    tasks.withType(com.android.build.gradle.tasks.factory.AndroidUnitTest) { testTask ->
                        testTask.finalizedBy(finalizerTask)
                        finalizerTask.configure {
                            dependsOn testTask
                        }
                    }
                }
            """.stripIndent()
        }
    }