private val nullableAnnotationName = "org.jspecify.annotations.Nullable"
    private val nullUnmarkedAnnotationName = "org.jspecify.annotations.NullUnmarked"

    @Test
    fun `from non-null returning to null-unmarked returning is breaking`() {

        checkNotBinaryCompatibleJava(
            v1 = """
                public class Source {
                    public String foo() { return "bar"; }

plugins {
    id("gradlebuild.module-identity")
}

val gradleModule = the<GradleModuleExtension>()

configureJarTasks()

pluginManager.withPlugin("java-base") {
    configureClasspathManifestGeneration()
}

fun configureJarTasks() {
    tasks.withType<Jar>().configureEach {
        archiveBaseName = gradleModule.identity.baseName
        archiveVersion = gradleModule.identity.version.map { it.baseVersion.version }

    protected
    fun sortChanges(originalChanges: List<AcceptedApiChange>) = originalChanges.toMutableList().sortedBy { it.type + '#' + it.member }

    @VisibleForTesting
    data class AcceptedApiChange(
        val type: String?,
        val member: String?,
        val acceptation: String?,
        val changes: List<String>?
    ) {
        override fun toString(): String = "Type: '$type', Member: '$member'"

            }
        }
    }
}

fun stageTriggerId(
    model: CIBuildModel,
    stage: Stage,
    os: Os? = null,
) = stageTriggerId(model, stage.stageName, os)

fun stageTriggerUuid(
    model: CIBuildModel,
    stage: Stage,
    os: Os? = null,
) = stageTriggerUuid(model, stage.stageName, os)

fun stageTriggerId(
    model: CIBuildModel,
    stageName: StageName,

        }
    }

    private
    fun findMismatches(originalChanges: List<AcceptedApiChange>, sortedChanges: List<AcceptedApiChange>): List<AcceptedApiChange> {
        return originalChanges.filterIndexed { index, acceptedApiChange -> sortedChanges[index] != acceptedApiChange }
    }

    private
    fun buildErrorMessage(formattedMismatches: Map<File, String>): String {

    abstract val outputDir: DirectoryProperty

    @TaskAction
    fun extract() {
        val androidStudioDistribution = androidStudioRuntime.singleFile
        when {
            androidStudioDistribution.name.endsWith(".dmg") -> extractDmg(androidStudioDistribution)
            else -> extractZipOrTar(androidStudioDistribution)
        }
    }

    fun extractZipOrTar(androidStudioDistribution: File) {
        fsOps.copy {

        val monitoredTaskPaths: SetProperty<String>
    }

    override fun onFinish(event: FinishEvent) {
        if (event !is TaskFinishEvent) {
            return
        }

        val taskPath = event.descriptor.taskPath
        if (shouldInclude(taskPath)) {
            action(taskPath, event.result)
        }
    }

        }
    }

    private
    fun Task.findTraceJson(): List<File> {
        if (this !is Test) {
            return emptyList()
        }
        // e.g. build/test-results/embeddedIntegTest/trace.json
        return listOf(project.layout.buildDirectory.file("test-results/$name/trace.json").get().asFile)
    }

    private
    fun Task.genericHtmlReports() = when (this) {

     */
    abstract val usesFutureStdlib: Property<Boolean>

    /**
     * The JVM version that all JVM code in this compilation will target.
     */
    abstract val targetJvmVersion: Property<Int>

    fun Project.from(sourceSet: SourceSet) {
        associate(tasks.named<JavaCompile>(sourceSet.getCompileTaskName("java")))
        plugins.withType<GroovyBasePlugin>() {

import org.gradle.api.provider.Provider
import java.io.File

fun Configuration.getSingleFileProvider(): Provider<File> {
    val name = this.name
    return incoming.files.elements.map {
        require(it.size <= 1) {
            "Expected at most one file in configuration '$name' but found: $it"
        }
        it.firstOrNull()?.asFile
    }
}

fun NamedDomainObjectProvider<Configuration>.getSingleFileProvider(): Provider<File> {