tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
                kotlinOptions.freeCompilerArgs += "-Xskip-metadata-version-check"
            }
            """
        )
        withFile("buildSrc/src/main/kotlin/some.gradle.kts", """println("some!")""")

        withDefaultSettings()
        withBuildScript("""plugins { id("some") }""")

        expectConventionDeprecations()

        def settings = withFile("my.settings.gradle.kts", """
            buildscript {
                dependencies {
                    classpath(files("${normalizedPathOf(settingsDependency)}"))
                }
            }
        """)

        and:
        def projectDependency = withEmptyJar("project-dependency.jar")
        withFile("build.gradle", """
            buildscript {

	b.ResourceFieldRef = value
	return b
}

// WithMode sets the Mode field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Mode field is set to the value of the last call.
func (b *DownwardAPIVolumeFileApplyConfiguration) WithMode(value int32) *DownwardAPIVolumeFileApplyConfiguration {
	b.Mode = &value

            "Project"
        )
    }

    private
    fun assertSucceedsForScriptWithReceiver(fileName: String, receiverType: String) {
        assertSucceeds(
            withFile(fileName, requiringImplicitReceiverOf(receiverType))
        )
    }

    private
    fun requiringImplicitReceiverOf(type: String) = """
        val $type.implicitReceiver get() = this

import java.util.Optional;
import java.util.stream.Stream;

public interface ChildMap<T> {

    boolean isEmpty();

    int size();

    Stream<Entry<T>> stream();

    <RESULT> RESULT withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, RESULT> handler);

    interface NodeHandler<T, RESULT> {
        RESULT handleAsDescendantOfChild(VfsRelativePath pathInChild, T child);

	return &ValidationRuleApplyConfiguration{}
}

// WithRule sets the Rule field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Rule field is set to the value of the last call.
func (b *ValidationRuleApplyConfiguration) WithRule(value string) *ValidationRuleApplyConfiguration {
	b.Rule = &value
	return b

	return &ValidationRuleApplyConfiguration{}
}

// WithRule sets the Rule field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Rule field is set to the value of the last call.
func (b *ValidationRuleApplyConfiguration) WithRule(value string) *ValidationRuleApplyConfiguration {
	b.Rule = &value
	return b

        withFile("plugins/src/main/kotlin/$fileName", text)
    }

    @Test
    fun `can access extension registered by included build plugin`() {
        // when:
        val result = build("ok")

        // then:
        result.assertOutputContains("It's 42!")

        // when: plugin changes in an incompatible way

        )
    }

    @Test
    fun `delegated properties follow Gradle mechanics and allow to model optional properties via nullable kotlin types`() {

        // given: build root gradle.properties file
        withFile(
            "gradle.properties",
            """
            setBuildProperty=build value
            emptyBuildProperty=

            userHomeOverriddenBuildProperty=build value

    @Test
    fun `warning is emitted if a gradle slash project dash schema dot json file is present`() {

        withDefaultSettings()
        withBuildScript("")

        withFile(projectSchemaResourcePath)

        assertThat(build("help").output, containsString(projectSchemaResourceDiscontinuedWarning))
    }