"""
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
            myExtension.message = "the message"
        """
        file("b/build.gradle") << """
            plugins.apply(my.MyPlugin)
            def otherProject = project(':a')
            myExtension.message = otherProject.myExtension.message
        """

        when:
        executer.withArguments(ENABLE_CLI, WARN_PROBLEMS_CLI_OPT)

                    MyExtension myExtension(ExtensionContainer extensions) {
                        extensions.getByType(MyExtension)
                    }

                    @Model
                    String value(MyExtension myExtension) {
                        myExtension.value
                    }

                    @Mutate
                    void addTasks(ModelMap<Task> tasks, String value) {

            extensions.getByType(MyExtension::class).some("api.get")
            extensions.configure<MyExtension> { some("api.configure") }
            the<MyExtension>().some("kotlin.reified.get")
            the(MyExtension::class).some("kotlin.kclass.get")
            configure<MyExtension> { some("kotlin.configure") }
            my.some("accessor.get")
            my { some("accessor.configure") }

            $builderContent
            def message = project.myExtension.message.get()
            return new MyModel(message)
        """)

        addBuilderRegisteringPluginImplementation(childBuildName, "MyModelBuilder", """
            def model = project.extensions.create("myExtension", MyExtension)
            model.message = "It works from project \${project.identityPath}"
        """)
    }

        given:
        buildFile << '''
        interface MyExtension {
            MapProperty<String, String> getProp()
        }

        project.extensions.create('myExt', MyExtension)

        task wrongValueTypeDsl {
            def myExt = project.extensions.getByType(MyExtension)
            doLast {
                myExt.prop = 123
            }
        }

        """

        file("b/build.gradle") << """
            import ${Property.name}

            interface MyExtension {
                Property<String> getFoo()
            }

            def myExtension = extensions.create('myExtension', MyExtension)
            myExtension.foo.set('configured')
        """

        when:

    }

    def 'can use custom Extension'() {
        given:
        file('src/test/java/org/gradle/MyExtension.java') << '''
package org.gradle;
import org.junit.jupiter.api.extension.*;

public class MyExtension implements TestInstancePostProcessor {
        @Override
        public void postProcessTestInstance(Object testInstance, ExtensionContext context) {

            import org.gradle.api.*

            open class MyExtension<T>

            class FooPlugin : Plugin<Project> {
                override fun apply(project: Project): Unit = project.run {
                    // Using add() without specifying the public type causes type erasure
                    extensions.add("mine", MyExtension<String>())
                }
            }
            """
        )

        and:
        fixture.assertStateLoaded()

        when:
        file("a/build.gradle") << """
            myExtension.message = 'this is project a'
        """
        file("b/build.gradle") << """
            myExtension.message = 'this is project b'
        """

        server.expect("configure-root")
        server.expectConcurrent("configure-a", "configure-b")

        model2[1].message == "It works from project :a"

        and:
        fixture.assertStateLoaded()
        outputDoesNotContain("creating model")

        when:
        buildFile << """
            myExtension.message = 'this is the root project'
        """

        executer.withArguments(ENABLE_CLI)
        def model3 = runBuildAction(new FetchCustomModelForEachProject())

        then:
        model3.size() == 2