configureProject().assertBuildScriptCompilationAvoided().assertOutputContains("bar")
    }

    @Test
    fun `avoids buildscript recompilation on non ABI change in buildSrc`() {
        val className = givenJavaClassInBuildSrcContains(
            """
            public void foo() {
                System.out.println("foo");
            }
            """
        )

        ).assertSameApi()
    }

    // test throws until we can detect lambdas in inline functions and treat them as ABI
    @Test(expected = CompileAvoidanceException::class)
    fun `changes to inline method bodies change generated API class`() {
        givenChangingClass(
            "Foo",
            """
                inline fun foo(): String {
                    return "foo"
                }
            """,

2. Accept the changes.\
If you are sure that the changes are intentional, follow the steps described in the report.
This includes adding the description of the changes to the `accepted-public-api-changes.json` file, and providing a reason for each change.
You can add the changes to any place in the file, e.g. at the top.

3. Make sure the file with accepted changes is sorted.\

The `init` task uses the (also built-in) `wrapper` task to create a Gradle wrapper script, `gradlew`.

The first step is to create a folder for the new project and change directory into it.

[listing.terminal.sample-command]
----
\$ mkdir demo
\$ cd demo
----

== Run the init task

        upgradedProperties.assertContentContains("org.gradle.api.Task")
        upgradedProperties.assertContentContains("org.gradle.api.plugins.quality.Checkstyle")

        // Given, change only some classes but not metadata
        File(projectRoot, "core/src/main/java/org/gradle/api/TaskAction.java").writeText("""
            package org.gradle.api;
            public interface TaskAction {}
        """)

 * and it should be appropriately marked with `@file:Incubating`.
 *
 * When the target method of an extension functions is de-incubated, removing at a later point is a breaking change.
 * The corresponding extension function gets automatically de-incubated during source generation.
 * But the same applies to the implicit file class, and it has to be de-incubated when any

    remoteUri = repoRoot(project).asFile.absolutePath
    // Remember to update accordingly when rebasing/squashing
    // Do not use the "Rebase and merge" nor "Squash and merge" Github buttons when merging a PR that change the baseline
    ref = '264bd7744d2e89b2708303cd56bb11bc5003fa7e'
}

// === Declarative DSL ===
performanceTest.registerTestProject("largeEmptyMultiProjectDeclarativeDsl", JavaExecProjectGeneratorTask) {

        return sourceCompatibility;
    }
    
    public void setSourceCompatibility(String sourceCompatibility) {
        this.sourceCompatibility = sourceCompatibility;
    }
} 
```
and we want to change it to:

```java
abstract class JavaCompile {
    @Input
    public Property<String> getSourceCompatibility();
} 
```

                            Scenario(
                                "org.gradle.performance.regression.corefeature.FileSystemWatchingPerformanceTest",
                                "assemble for non-abi change with file system watching and configuration caching"
                            ),
                            it
                        )
                    }
                )
            )
        ),

    fun singleAbstractMethodOf(classNode: ClassNode) =
        classNode.methods.singleOrNull { it.access.run { !isStatic && isAbstract } }

    /**
     * Test if a method is a prime declaration or an overrides that change the signature.
     *
     * There's no way to tell from the byte code that a method overrides the signature
     * of a parent declaration other than crawling up the type hierarchy.
     */
    private