p2.parent.is(root)
        p2.componentIdentifier.projectPath == ":p2"
        p2.componentIdentifier.buildTreePath == ":p2"
        p2.childProjects.empty

        root.childProjects.toList() == [p1, p2]

        registry.stateFor(root.componentIdentifier).is(root)
        registry.stateFor(p1.componentIdentifier).is(p1)
        registry.stateFor(p2.componentIdentifier).is(p2)

    private final Map<ExternalResourceName, List<String>> directoriesToList = new HashMap<>();

    public ResourceVersionLister(ExternalResourceRepository repository) {
        this.repository = repository;
    }

    @Override
    public void listVersions(ModuleIdentifier module, IvyArtifactName artifact, List<ResourcePattern> patterns, BuildableModuleVersionListingResolveResult result) {
        List<String> collector = new ArrayList<>();

        compileKotlin()
        val generated = file("build/generated-sources/kotlin-dsl-plugins/kotlin").walkTopDown().filter { it.isFile }.map { it.name }
        assertThat(generated.toList(), equalTo(listOf("CorrectPlugin.kt")))
    }

    @Issue("https://github.com/gradle/gradle/issues/16154")
    @Test
    fun `file annotations and package statement in precompiled script plugin handled correctly`() {

data class KotlinDslScriptsParameter(
    val correlationId: String?,
    val scriptFiles: List<File>
)


internal
fun <T : Any> commonPrefixOf(lists: List<List<T>>): List<T> =
    lists.minByOrNull { it.size }?.let { maxCommonPrefix ->
        maxCommonPrefix.indices.asSequence().takeWhile { index ->
            lists.all { list -> list[index] == maxCommonPrefix[index] }
        }.lastOrNull()?.let { maxCommonIndex ->

        List<String> executedBuildIds = executionDataProvider.getReportScenarios().stream()
            .flatMap(scenario -> scenario.getTeamCityExecutions().stream().map(PerformanceTestExecutionResult::getTeamCityBuildId))
            .collect(Collectors.toList());

        executionDataProvider.getReportScenarios().stream()

        if (componentType == null) {
            throw new IllegalStateException("Must specify component type and artifacts to query.");
        }

        List<? extends ResolutionAwareRepository> repositories = repositoriesSupplier.get();
        List<ResolutionAwareRepository> filteredRepositories = repositories.stream()
            .filter(repository -> {
                if (repository instanceof ContentFilteringRepository) {

    }

    /**
     * @return the list of parameters copy. Any change to returned list is NOT reflected on this instance. To add
     * parameters, use {@link #addParameter(Parameter)} method.
     */
    public List<Parameter> getParameters() {
        return new ArrayList<>(parameters);
    }

    /**
     * @param parameters the new list of parameters
     * @throws DuplicateParameterException if any

        else -> null
    }
}


internal
data class TargetTypedSchema(
    val extensions: List<ProjectSchemaEntry<TypeOf<*>>>,
    val conventions: List<ProjectSchemaEntry<TypeOf<*>>>,
    val tasks: List<ProjectSchemaEntry<TypeOf<*>>>,
    val containerElements: List<ProjectSchemaEntry<TypeOf<*>>>
)


internal
fun targetSchemaFor(target: Any, targetType: TypeOf<*>): TargetTypedSchema {

        }
    }

    fun addElements(target: MutableSet<Any>) {
        if (containsTransforms) {
            target.add(ResolutionBackedFileCollectionSpec(resolutionHostDisplayName, lenient, elements.toList()))
        } else {
            // Contains a fixed set of files - can throw away this instance
            target.addAll(elements)
        }
    }

            .forEach((key1, versions) -> {
                List<ComponentVariantIdentifier> candidateIds = versions.stream()
                    .flatMap(c -> details.getCandidates(c).stream())
                    .map(detail -> new DefaultComponentVariantIdentifier(detail.getId(), detail.getVariantName()))
                    .collect(Collectors.toList());