}
		})
	}
}

func Test_buildNestedMap(t *testing.T) {
	type args struct {
		flatMap map[string]string
	}
	tests := []struct {
		name       string
		args       args
		wantResult map[string]any
	}{
		{
			name: "configmap",
			args: args{
				flatMap: map[string]string{
					"one.two.valuethree":      "onetwovaluethree",
					"one.two.three.valuefour": "onetwothreevaluefour",

        return fingerprinters.flatMap(Collection::stream).map(fingerprinter ->
                registration(directorySensitivity, lineEndingSensitivity, fingerprinter)
            );
    }

    private static <T> Stream<T> withAllLineEndingSensitivities(Function<LineEndingSensitivity, Stream<T>> f) {
        return stream(LineEndingSensitivity.values()).flatMap(f);
    }

        .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

}

func Ap[T, U any](t Option[Func1[T, U]], a Option[T]) Option[U] {
	return FlatMap(t, func(f Func1[T, U]) Option[U] {
		return Map(a, f)
	})
}

func Map[T, U any](opt Option[T], f func(v T) U) Option[U] {
	return FlatMap(opt, func(v T) Option[U] {
		return Some(f(v))
	})
}

func FlatMap[T, U any](opt Option[T], fn func(v T) Option[U]) Option[U] {
	if opt.IsDefined() {
		return fn(opt.Get())

    private
    fun Sequence<Project>.withJavaBasePlugin() =
        filter { it.plugins.hasPlugin(JavaBasePlugin::class.java) }

    private
    fun Sequence<Project>.allSourceSetsRoots() =
        flatMap { it.sourceSets.flatMap { it.allSource.srcDirs }.asSequence() }

    private
    val Project.sourceSets
        get() = the<SourceSetContainer>()
}


@CacheableTask
abstract class GenerateSourceRootsFile : DefaultTask() {

        return Optional.of(snapshotContext)
            .flatMap(IoFunction.wrap(this::hashContent));
    }

    @Override
    Optional<HashCode> tryHash(ZipEntryContext zipEntryContext) {
        return Optional.of(zipEntryContext)
            .flatMap(IoFunction.wrap(this::hashContent));
    }

        outputFile.text == "Permission: 755"

        where:
        wiring << [
            //"fsOps.permissions(producer.flatMap { it.outputFile.asFile }.map { it.readText() }).map { it.toUnixNumeric() }", //TODO: https://github.com/gradle/gradle/issues/19252
            "fsOps.permissions(producer.flatMap { it.outputFile }.map { it.asFile.readText() }).map { it.toUnixNumeric() }"
        ]
    }

                    outFile.text = archives.${archiveType}(inputFile.get().asFile).read().text
                }
            }

            tasks.register("myTask", MyTask) {
                inputFile.set(createArchive.flatMap { it.outputFile })
                outputFile.set(layout.buildDirectory.file("unpacked/file.txt"))
            }
        """

        when:
        run "myTask"

        then:

    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()}") {
    isVisible = false

            return;
        }
        Set<String> classesWithJavaSource = recompilationSpec.getClassesToCompile().stream()
            .flatMap(classToCompile -> sourceFileClassNameConverter.getRelativeSourcePaths(classToCompile).stream())
            .filter(sourcePath -> sourcePath.endsWith(".java"))
            .flatMap(sourcePath -> sourceFileClassNameConverter.getClassNames(sourcePath).stream())
            .collect(Collectors.toSet());