}
      },
      {
        "subprojects": [
          "scala"
        ],
        "parallelizationMethod": {
          "name": "TestDistribution"
        }
      },
      {
        "subprojects": [
          "testing-native"
        ],
        "parallelizationMethod": {
          "name": "TestDistribution"
        }
      },
      {

                    ?: return None

            return when (methodJsonNode.get("name")?.asText()) {
                null -> None
                None::class.simpleName -> None
                TestDistribution::class.simpleName -> TestDistribution
                TestDistributionAlpine::class.simpleName -> TestDistributionAlpine
                TeamCityParallelTests::class.simpleName ->
                    TeamCityParallelTests(

        name = "${docsTestType.docsTestDesc} - ${testJava.version.toCapitalized()} ${os.asName()}"
        val parallelizationMethod =
            if (os == Os.LINUX) {
                ParallelizationMethod.TestDistribution
            } else {
                TeamCityParallelTests(4)
            }

        if (parallelizationMethod is TeamCityParallelTests) {
            features {
                parallelTests {

            }
        }

        useJUnitPlatform()
        configureSpock()
        configureFlakyTest()

        extensions.findByType<DevelocityTestConfiguration>()?.testDistribution {
            this as TestDistributionConfigurationInternal
            server = uri(testDistributionServerUrl.orElse("https://gbt-td.grdev.net"))

        return parallelize(subProjectTestClassTimes, testCoverage) { numberOfBatches ->
            when (testCoverage.os) {
                Os.LINUX -> ParallelizationMethod.TestDistribution
                Os.ALPINE -> ParallelizationMethod.TestDistributionAlpine
                else -> ParallelizationMethod.TeamCityParallelTests(numberOfBatches)
            }
        }
    }

        testCoverage: TestCoverage,
        bucketIndex: Int,
    ): FunctionalTest {
        val parallelizationMethod =
            when (testCoverage.os) {
                Os.LINUX -> ParallelizationMethod.TestDistribution
                else -> ParallelizationMethod.None
            }

        return FunctionalTest(
            model,
            testCoverage.getBucketUuid(model, bucketIndex),