buildEnvironmentExtension.gitCommitId = service.flatMap { it.gitCommitId }
        buildEnvironmentExtension.gitBranch = service.flatMap { it.gitBranch }
        buildEnvironmentExtension.repoRoot = this@with
        buildEnvironmentExtension.rootProjectBuildDir = service.flatMap { it.parameters.rootProjectBuildDir }
    }

    override val failsStage: Boolean
        get() = false

    val buildSpecs: List<FlameGraphGenerationBuildSpec>
        get() =
            scenarios.flatMap { scenario ->
                Os.values().flatMap { os ->
                    val arch = if (os == Os.MACOS) Arch.AARCH64 else Arch.AMD64
                    if (os == Os.WINDOWS) {
                        listOf("jprofiler")

        .filter { type -> type.isPublic && apiSpec.isApi(type.sourceName) }
        .flatMap { type -> kotlinExtensionFunctionsFor(type, sinceSupplier) }
        .distinctBy(::signatureKey)


private
fun signatureKey(extension: KotlinExtensionFunction): List<Any> = extension.run {
    listOf(targetType.sourceName, name) +
        parameters.flatMap { apiTypeKey(it.type) }
}


private

        }

        // second step get parameter names of all plugin goals
        Set<String> parametersNamesAll = mojoDescriptor.getPluginDescriptor().getMojos().stream()
                .flatMap(m -> m.getParameters().stream())
                .flatMap(this::getParameterNames)
                .collect(Collectors.toSet());

        unknownParameters = getUnknownParameters(mojoExecution, parametersNamesAll);

                                                .flatMap(dm -> dm.child(DEPENDENCIES))
                                                .orElse(null),
                                        DEPENDENCY_MANAGEMENT))
                        .filter(container -> container.element != null),
                // Profile dependencies
                root.child(PROFILES).stream()
                        .flatMap(profiles -> profiles.children(PROFILE))

    reportTask {
        sources.from(kotlinMainSourceSet.sourceDirectories)
    }
}

tasks.named("check") { dependsOn(reportTask) }

consumableVariant("txt", reportTask.flatMap { it.textReportFile })
consumableVariant("html", reportTask.flatMap { it.htmlReportFile })

fun consumableVariant(reportType: String, artifact: Provider<RegularFile>) = configurations.create("incubatingReport${reportType.capitalize()}") {

) : FunctionalTestBucketProvider {
    private val objectMapper = ObjectMapper().registerKotlinModule()
    private val buckets: Map<TestCoverage, List<BuildTypeBucket>> by lazy {
        val uuidToTestCoverage = model.stages.flatMap { it.functionalTests }.associateBy { it.uuid }
        val testCoverageAndBuckets: List<Map<String, Any>> = objectMapper.readValue(testBucketsJson.readText())
        testCoverageAndBuckets.associate { testCoverageAndBucket ->

    /**
     * All found class files bytes by Kotlin source name.
     */
    fun allClassesBytesBySourceName(): Sequence<Pair<String, ClassBytesSupplier>> =
        relevantClassPathFiles.asSequence()
            .flatMap { sourceNamesFrom(it) }
            .mapNotNull { sourceName ->
                classBytesSupplierForSourceName(sourceName)?.let { sourceName to it }
            }

    private

        .expect("A", "B", "C", "D", "E");
  }

  public void testFlatMap() {
    SpliteratorTester.of(
            () ->
                CollectSpliterators.flatMap(
                    Arrays.spliterator(new String[] {"abc", "", "de", "f", "g", ""}),
                    (String str) -> charactersOf(str).spliterator(),

            spec.getSourceRoots().from(extension.getKotlinDslSource());
            spec.getSourceRoots().from(runtimeExtensions.flatMap(GradleKotlinDslRuntimeGeneratedSources::getGeneratedSources));
            spec.getClasspath().from(extension.getClasspath());
            spec.getClasspath().from(runtimeExtensions.flatMap(GradleKotlinDslRuntimeGeneratedSources::getGeneratedClasses));