}
        }
        templateVersionConfiguration.isTransitive = false
        val resolutionResult: ResolutionResult = templateVersionConfiguration.incoming.resolutionResult
        val matches: List<ResolvedComponentResult> = resolutionResult.allComponents.filter { it != resolutionResult.root }
        if (matches.isEmpty()) {
            throw GradleException("Could not locate any matches for $notation")
        }

  <details>
  <summary>See details</summary>
  <table>
            <tr>
                <td>${title}</td>
                <td>Added Lines</td>
                <td>% of Total Line Changes</td>
                <td>Deleted Lines</td>
                <td>% of Total Line Changes</td>
                <td>Files Changed</td>
                <td>% of Total Files Changed</td>
            </tr>`;

    preppedStatistics.forEach(summary => {

                }
            }
    }

    /**
     * Zip a list of files with same root directory to a zip file.
     *
     * @param destZip the target zip file
     * @param srcFiles the mapping of relative path to the file
     */
    private
    fun zip(destZip: File, srcFiles: List<Pair<String, File>>) {
        if (srcFiles.isEmpty()) {
            return
        }

class ReleasedVersionsDetails(currentBaseVersion: GradleVersion, releasedVersionsFile: RegularFile) {
    val allPreviousVersions: List<GradleVersion>
    val mostRecentRelease: GradleVersion
    val mostRecentSnapshot: GradleVersion

    val allTestedVersions: List<GradleVersion>

    val mainTestedVersions: List<GradleVersion>

    init {
        val lowestInterestingVersion = GradleVersion.version("0.8")

import model.PerformanceTestCoverage
import model.PerformanceTestProjectSpec
import model.Stage

abstract class PerformanceTestProject(model: CIBuildModel, val spec: PerformanceTestProjectSpec, val performanceTests: List<PerformanceTest>) : Project({
    this.id(spec.asConfigurationId(model))
    this.name = spec.asName()
}) {
    init {
        performanceTests.forEach(this::buildType)
    }
}

                            // Since JDK 11, package-list is missing from javadoc output files and superseded by element-list file, but a lot of external tools still need it
                            // Here we generate this file manually
                            copySpec.from(generatedJavadocDirectory.file("element-list"), sub -> {
                                sub.rename(t -> "package-list");
                            });

 * @param {Map} groupedFiles - map of platforms for containing info about the changes to files in that platform, from call to categorize
 * @param {[FileMetadata]} fileMetadatas - gitStream's list of metadata about file changes in the PR including path
 * @returns {[Object]} Returns list of computed summary statistic objects for each platform in the input groupedFiles

        }

        fun assertHasAccepted(vararg accepted: Pair<String, List<String>>) {
            assertThat("Has accepted", richReport.accepted, CoreMatchers.equalTo(accepted.map { ReportMessage(it.first, it.second) }))
        }

        fun assertHasErrors(vararg errors: List<String>) {
            assertHasErrors(*errors.toList().flatten().toTypedArray())
        }

    fun BuildSteps.gradleStep(tasks: List<String>) {
        gradleWrapper {
            name = "GRADLE_RUNNER"
            gradleParams = (
                tasks +
                    buildToolGradleParameters(isContinue = false)
                ).joinToString(separator = " ")
            skipConditionally()
        }
    }

    fun BuildSteps.adHocPerformanceTest(tests: List<String>) {
        gradleStep(

    val testCoverage: TestCoverage,
    val stage: Stage
) : Project({
    this.id(testCoverage.asId(model))
    this.name = testCoverage.asName()
}) {
    val functionalTests: List<BaseGradleBuildType> = functionalTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)
    init {
        functionalTests.forEach(this::buildType)
    }