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()))
        }

        fun assertHasInformation(vararg information: String) {

import java.util.zip.ZipEntry
import java.util.zip.ZipOutputStream
import javax.inject.Inject
import kotlin.collections.component1
import kotlin.collections.component2
import kotlin.collections.set
import kotlin.streams.toList


typealias LeftoverFiles = Map<File, List<String>>


abstract class TestFilesCleanupService @Inject constructor(
    private val fileSystemOperations: FileSystemOperations

    fun <T : Any> mapParsedKotlinFiles(vararg sourceRoots: File, block: (KtFile) -> T): List<T> =
        withParsedKotlinSource(sourceRoots.toList()) { ktFiles ->
            ktFiles.map(block)
        }

    fun parseSourceRoots(sourceRoots: List<File>, compilationClasspath: List<File>): ParsedKotlinFiles =
        Disposer.newDisposable().let { disposable ->

    private
    fun getRelocatedPackages(files: Sequence<Path>): List<String> = mutableListOf<String>().apply {
        implementation.collectPackages(files.toList()).dump(false, this::add)
    }

    @Test
    fun `generates a curated list of package prefixes from directories`() {
        assertEquals(EXPECTED_PACKAGE_LIST, getRelocatedPackages(someClasses()))
    }

        archiveFileNames.forEach { fileName ->
            assertTrue(rootDirFiles.any { it.name == fileName })
        }
    }

    private
    fun assertLeftoverFilesCleanedUpEventually(vararg leftoverFiles: String) {
        leftoverFiles.forEach {
            assertTrue(projectDir.resolve(it).walk().filter { it.isFile }.toList().isEmpty())
        }
    }

        numberOfBuckets,
        MAX_TEST_PROJECTS_PER_BUCKET,
        { numEmptyBuckets -> (0 until numEmptyBuckets).map { EmptyTestProjectBucket(it) }.toList() },
        { tests1, tests2 -> tests1 != tests2 }
    )
}

                }
            }
        });
    }

    private static List<String> ps() {
        return run(determinePsCommand()).assertZeroExit().stdout.lines().collect(Collectors.toList());
    }

    private static String[] determinePsCommand() {
        if (isWindows()) {
            return new String[]{"wmic", "process", "get", "processid,commandline"};
        } else if (isMacOS()) {

val Project.maxTestDistributionRemoteExecutors: Int?
    get() = gradleProperty(MAX_TEST_DISTRIBUTION_REMOTE_EXECUTORS).orNull?.toInt()

val Project.maxTestDistributionLocalExecutors: Int?
    get() = gradleProperty(MAX_TEST_DISTRIBUTION_LOCAL_EXECUTORS).orNull?.toInt()

val Project.flakyTestStrategy: FlakyTestStrategy
    get() = gradleProperty(FLAKY_TEST).let {
        if (it.getOrElse("").isEmpty()) {

                val matchResult = OLD_RELEASE_PATTERN.find(branchName)
                if (matchResult == null) {
                    null
                } else {
                    (matchResult.groupValues[1].toInt() - 4).apply {
                        require(this in 2..23)
                    }
                }
            }
        }
    }

    val isMainBranch: Boolean
        get() = isMaster || isRelease

                val agentNumEnv = System.getenv("USERNAME").replaceFirst("tcagent", "")
                if (Regex("""\d+""").containsMatchIn(agentNumEnv)) {
                    return agentNumEnv.toInt()
                }
            }
            return 1
        }