}


internal
fun Project.createTestTask(name: String, executer: String, sourceSet: SourceSet, testType: TestType, extraConfig: Action<IntegrationTest>): TaskProvider<IntegrationTest> =
    tasks.register<IntegrationTest>(name) {
        val integTest = project.the<IntegrationTestExtension>()
        project.getBucketProvider().get().bucketProvider.configureTest(this, sourceSet.name)

import gradlebuild.basics.repoRoot
import gradlebuild.basics.toLowerCase
import gradlebuild.basics.toolchainInstallationPaths
import gradlebuild.integrationtests.addDependenciesAndConfigurations
import gradlebuild.integrationtests.ide.AndroidStudioProvisioningExtension
import gradlebuild.integrationtests.ide.AndroidStudioProvisioningPlugin
import gradlebuild.performance.Config.performanceTestAndroidStudioJvmArgs

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package gradlebuild.performance.tasks

import com.google.common.collect.Sets
import gradlebuild.integrationtests.tasks.DistributionTest
import gradlebuild.performance.PerformanceTestService
import gradlebuild.performance.ScenarioBuildResultData
import gradlebuild.performance.reporter.PerformanceReporter
import groovy.json.JsonOutput

import gradlebuild.integrationtests.model.GradleDistribution
import org.asciidoctor.gradle.jvm.AsciidoctorTask
import org.gradle.docs.internal.tasks.CheckLinks
import org.gradle.docs.samples.internal.tasks.InstallSample
import org.gradle.internal.os.OperatingSystem

import javax.inject.Inject

import static gradlebuild.basics.BuildEnvironmentKt.repoRoot
import static gradlebuild.basics.BuildParamsKt.isConfigurationCacheEnabledForDocsTests

			</activation>
			<properties>
				<test.include.path>**/*Test.java</test.include.path>
				<test.command.args>--illegal-access=permit</test.command.args>
			</properties>
		</profile>
		<profile>
			<id>integrationTests</id>
			<properties>
				<test.include.path>**/*Tests.java</test.include.path>
				<test.command.args />
			</properties>
		</profile>
	</profiles>
	<build>
		<finalName>fess</finalName>
		<resources>

                        useJUnitJupiter()
                    }
                    integrationTest(JvmTestSuite) {
                        useJUnitJupiter()
                    }
                }
            }

            tasks.named('check') {
                dependsOn(testing.suites.integrationTest)
            }
        """.stripIndent()

        expect:
        succeeds("check")
    }

<4> Define a new suite called `integrationTest`.  Note that all suites other than the built-in `test` suite will by convention work as if `useJUnitJupiter()` was called.  You do *not* have to explicitly configure the testing framework on these additional suites, unless you wish to change to another framework.

            tasks.withType(Test).configureEach {
                throw new RuntimeException('Configuring tests failed')
            }

            testing {
                suites {
                    integrationTest(JvmTestSuite) {
                        useJUnit()
                    }
                }
            }

            dependencies {

        executer.inDirectory(dslDir)

        when:
        def result = succeeds("test", "integrationTest")

        then:
        result.assertTaskOrder(":test", ":integrationTest")

        and:
        assertTestsRunCount(
            getTestResultsFileAsXml(dslDir, "org.gradle.PersonIntTest", "integrationTest"),
            1)

        where:
        dsl << ['groovy', 'kotlin']
    }

Consequently, source code directories for other test types should follow a similar pattern:

----
.
└── src
    ├── functionalTest
    │   └── groovy      // <1>
    ├── integrationTest
    │   └── groovy      // <2>
    ├── main
    │   ├── java        // <3>
    └── test
        └── groovy      // <4>
----
<1> Source directory containing functional tests