private
    val taskPathReports: Map<String, List<File>>
        get() = parameters.taskPathToReports.get()

    private
    val rootBuildDir: File
        get() = parameters.rootBuildDir.get().asFile

    private
    val testPathToBinaryResultsDirs: Map<String, File>
        get() = parameters.testPathToBinaryResultsDirs.get()

        # If you use Oracle and its Synonym, specify this property.
        #; includeSynonyms=true
    }
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o variousMap: (NotRequired - Default map:{})
    #  The various settings about JDBC task mainly.
    #
    ; variousMap = map:{
        # o objectTypeTargetList: (NotRequired - Default list:{TABLE;VIEW})

    # o filterVariablesMap: (NotRequired - Default map:{})
    #  You can specify the filter variables for DDL.
    #
    #; filterVariablesMap = map:{abc=AAA}
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o additionalUserMap: (NotRequired - Default map:{})
    #  You can set additional users.
    #  Elements of this map are as below:

            val scenarioObj = it as JSONObject
            val testId = scenarioObj["testId"] as String
            val groups = (scenarioObj["groups"] as JSONArray).map {
                val groupObj = it as JSONObject
                val testProject = groupObj["testProject"] as String
                val coverage = (groupObj["coverage"] as JSONObject).map { entry ->

                    entryPoints.add(classDetails)
                }
            }
        }

    fun getDependencies() = classes.map { it.value.outputClassFilename to it.value.dependencies.map { it.outputClassFilename } }.toMap()
}


class ClassDetails(val outputClassName: String) {
    var visited: Boolean = false
    val dependencies: MutableSet<ClassDetails> = linkedSetOf()

            firDiagnostic.c.map { coneKotlinType ->
                firSymbolBuilder.typeBuilder.buildKtType(coneKotlinType)
            },
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.AMBIGUOUS_SUPER) { firDiagnostic ->
        AmbiguousSuperImpl(
            firDiagnostic.a.map { coneKotlinType ->

    }

    fun getAllConverters(conversionForCollectionValues: HLParameterConversion): Map<KClass<*>, HLParameterConversion> {
        return buildMap {
            putAll(typeMapping)
            put(
                Map::class,
                HLMapParameterConversion(
                    "key",
                    "value",

    buffer.writeUtf8(
      """
      |    180C; ; Map to nothing
      |    0041; 0061; Case map
      |    0390; 03B9 0308 0301; Case map
      |
      """.trimMargin(),
    )

    val mappings = buffer.readCodePointMappings()
    assertEquals(
      mapOf(
        // Map to nothing.
        0x180c to "",
        // Case map.
        'A'.code to "a",
        // Case map.
        'ΐ'.code to "\u03B9\u0308\u0301",
      ),

    listOf("7.3", "7.6"), // 7.3 <=version < 7.6
    listOf("7.6", "8.3"), // 7.6 <=version < 8.3
    listOf("8.3", "99.0") // 8.3 <=version < 99.0
)

typealias BuildProjectToSubprojectTestClassTimes = Map<String, Map<String, List<TestClassTime>>>

interface FunctionalTestBucketProvider {
    fun createFunctionalTestsFor(stage: Stage, testCoverage: TestCoverage): List<FunctionalTest>
}

        }

        fun assertHasErrors(vararg errors: String) {
            assertThat("Has errors", richReport.errors.map { it.message }, CoreMatchers.equalTo(errors.toList()))
        }

        fun assertHasWarnings(vararg warnings: String) {
            assertThat("Has warnings", richReport.warnings.map { it.message }, CoreMatchers.equalTo(warnings.toList()))
        }