(BinaryCompatibilityRepositorySetupRule.REPOSITORY_CONTEXT_KEY): repository
                ]
            }

            @Override
            <T> T getUserData(String key) {
                getUserData()[key]
            }

            @Override
            <T> void putUserData(String key, T value) {
                getUserData().put(key, value)
            }
        }
        rule
    }

                tmpTestFiles.keys
            )
            cleanUp(tmpTestFiles.keys)
            projectPathToLeftoverFiles[projectPath] = tmpTestFiles
        }

        // Third run: verify and throw exceptions
        val exceptions = mutableListOf<Exception>()
        parameters.projectStates.get()
            .filter { projectPathToLeftoverFiles.containsKey(it.key) }

            "-PtestJavaVersion=$testJvmVersion",
            "-PtestJavaVendor=$testJvmVendor"
        ) +
            listOf(buildScanTag(buildScanTag)) +
            buildScanValues.map { buildScanCustomValue(it.key, it.value) }
        ).filter { it.isNotBlank() }.joinToString(separator = " ")
}

fun functionalTestParameters(os: Os): List<String> {
    return listOf(
        "-PteamCityBuildId=%teamcity.build.id%",

            functionalTestsWithSplit.forEach {
                assertAllSplitsArePresent(it.key, it.value)
                assertCorrectParameters(it.key, it.value)
            }
        }

        fun assertProjectAreSplitByGradleVersionCorrectly(buckets: List<List<String>>, testType: TestType, functionalTests: List<BaseGradleBuildType>) {

    }

    protected BinaryCompatibilityRepository getRepository() {
        return context.userData[BinaryCompatibilityRepositorySetupRule.REPOSITORY_CONTEXT_KEY] as BinaryCompatibilityRepository
    }

    protected static boolean isNewOrRemoved(JApiCompatibility member) {
        if (member instanceof JApiHasChangeStatus) {

                val duration = it as JSONObject
                val testProject = duration["testProject"] as String
                duration.entries
                    .filter { (key, _) -> key != "testProject" }
                    .map { (osString, timeInMs) ->
                        val os = Os.valueOf(osString.uppercase(Locale.US))

// Do not use ternary expression here, since "istanbul ignore next" is buggy
let TMP_KEY_IGNORE = 'node-ignore'
/* istanbul ignore else */
if (typeof Symbol !== 'undefined') {
    TMP_KEY_IGNORE = Symbol.for('node-ignore')
}
const KEY_IGNORE = TMP_KEY_IGNORE

const define = (object, key, value) =>
    Object.defineProperty(object, key, {value})

const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g

const RETURN_FALSE = () => false

) : VersionsToIncubatingCollector {

    override fun collectFrom(sourceFile: File): VersionsToIncubating =
        collectors
            .flatMap { it.collectFrom(sourceFile).entries }
            .associate { it.key to it.value }
}


private
const val versionNotFound = "Not found"


private
class JavaVersionsToIncubatingCollector(srcDir: File) : VersionsToIncubatingCollector {

    private