outputContains('system_property_available in buildSrc:                 true')
        outputContains('system_property_available in buildSrc:                 true')
        outputContains('project_property_available in buildSrc:                false')
        outputContains('system_property_available in included buildSrc:        true')
        outputContains('project_property_available in included buildSrc:       false')

    @Nullable
    @Override
    public ResourceLock getProjectToLock() {
        // Ignore, as the node in the other build's execution graph takes care of this
        return null;
    }

    @Nullable
    @Override
    public ProjectInternal getOwningProject() {
        // Ignore, as the node in the other build's execution graph takes care of this
        return null;
    }

    @Override

        expect:
        executer.usingProjectDirectory(file("buildSrc"))
        fails("tasks")

        file("buildSrc").assertIsEmptyDir()
        assertNoProjectCaches(executer.gradleUserHomeDir)
    }

    def "treats empty buildSrc inside a build as undefined build"() {
        given:
        settingsFile.touch()
        file("buildSrc").createDir()

        expect:

     */
    void setRootDir(String rootDir);

    /**
     * Defines the plugins to be injected into the build.
     *
     * <p>Currently, plugins must be located in the calling build's `buildSrc` project.</p>
     *
     * @param configuration the configuration action for adding injected plugins
     * @since 4.6
     */
    void plugins(Action<? super InjectedPluginDependencies> configuration);

In this sample, `myproject.library-conventions` plugin uses a custom task class from `buildSrc/src/main/java` to configure library README checks:
====
include::sample[dir="kotlin",files="buildSrc/src/main/kotlin/myproject.library-conventions.gradle.kts[tags=use-java-class]"]
include::sample[dir="groovy",files="buildSrc/src/main/groovy/myproject.library-conventions.gradle[tags=use-java-class]"]
====

                        .run()
        }

        then:
        !events.operations.find { it.descriptor.displayName == "Build buildSrc" }

        when:
        events.clear()
        file("buildSrc/build.gradle") << "println 'buildSrc'"
        withConnection {
            ProjectConnection connection ->
                connection.newBuild()
                        .addProgressListener(events)

        }
    }

    @Test
    fun `version catalogs from outer builds are not available as accessors`() {
        withKotlinBuildSrc()
        withSimpleVersionCatalog()
        withFile("buildSrc/src/main/kotlin/plugin-without-plugins.gradle.kts", "println(libs)")
        withFile(
            "buildSrc/src/main/kotlin/plugin-with-plugins.gradle.kts",
            """
            plugins { id("base") }

    @Issue("https://github.com/gradle/gradle/issues/5110")
    def "buildSrc project can apply IDE plugin"() {
        file("buildSrc/build.gradle") << """
            apply plugin: '${pluginId}'
        """

        expect:
        succeeds(":buildSrc:${workspaceTask}")
        def workspace = workspace(file("buildSrc"), "buildSrc")
        if (libraryPluginId == "java-library") {

    }

    /**
     * Returns source directories from buildSrc if any.
     */
    fun buildSrcRootsOf(projectRoot: File): Collection<File> =
        projectRoot.resolve("buildSrc/$buildSrcSourceRootsFilePath")
            .takeIf { it.isFile }
            ?.readLines()
            ?.map { projectRoot.resolve("buildSrc/$it") }
            ?: buildSrcRootsFallbackFor(projectRoot)

    private

        val type = SchemaType.of<NonExistingType>()

        val projectSchema = availableProjectSchemaFor(
            schemaWithExtensions("buildScan" to type),
            ClassPath.EMPTY
        )

        assertThat(
            projectSchema.extension("buildScan").type,
            equalTo(inaccessible(type, nonAvailable(type.kotlinString)))
        )
    }

    @Test