val myExtensionMock = mock<MyExtension>()
                val extensionsSchemaMock = mock<ExtensionsSchema> {
                    on { elements }.thenReturn(listOf<ExtensionSchema>(object : ExtensionSchema {
                        override fun getName(): String = "myExtension"
                        override fun getPublicType(): TypeOf<*> = TypeOf.typeOf(MyExtension::class.java)
                    }))
                }

            // apply(plugin = "my.gradle-plugin)
            apply<GradlePluginPlugin>()

            extensions.getByType(MyExtension::class).some("api.get")
            extensions.configure<MyExtension> { some("api.configure") }
            the<MyExtension>().some("kotlin.get")
            configure<MyExtension> { some("kotlin.configure") }
        """)
        withBuildScript("""tasks.register("noop")""")

        assertThat(

            import org.gradle.api.provider.Property
            interface MyExtension { val some: Property<String> }
            interface MyConvention { val more: Property<String> }
            interface Unregistered
        """
        file("plugin/src/main/kotlin/my-plugin.gradle.kts").text = """
            extensions.create<MyExtension>("myExtension")
            convention.plugins["myConvention"] = objects.newInstance<MyConvention>()

class MyPlugin implements Plugin<Project> {
    void apply(Project project) {
        // Create and configure the extension
        def extension = project.extensions.create("myExtension", MyExtension)
        // Create and configure the custom task
        project.tasks.register("myTask", MyCustomTask) {
            group = "custom"
            inputParameter = extension.inputParameter
        }
    }
}

class MyPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        // Create and configure the extension
        val extension = project.extensions.create("myExtension", MyExtension::class.java)
        // Create and configure the custom task
        project.tasks.register("myTask", MyCustomTask::class.java) {
            group = "custom"
            inputParameter = extension.inputParameter

                            plugins {
                                id("test")
                            }

                            val myExtension = extensions.get("myExtension") as TestExtension
                            myExtension.say.set("Hi!")

                            myExtension {
                                say = "Oh!"
                            }
                        ""${'"'})

 *              action.execute(options)
 *         }
 *     }
 *     extensions.create("myExtension", MyExtension)
 *     myExtension {
 *         options {
 *             optionsFile = layout.projectDirectory.file("options.properties")
 *         }
 *     }
 * </pre>
 * <p>

        then:
        model2.size() == 2
        fixture.assertStateLoaded()
        outputDoesNotContain("Callback before")


        when:
        buildFile << """
            myExtension.message = "updated message for root"
        """

        withIsolatedProjects()
        def model3 = runBuildAction(new FetchCustomModelForEachProject())

        then:
        model3.size() == 2

        buildFile << """
            abstract class MyExtension {
                abstract Property<String> getOther()

                Provider<String> getFoo() {
                    return other
                }
            }

            extensions.create("myext", MyExtension)
            myext {
                conventionMapping.map("foo", { project.provider { "foobar" } })

        "versions:b" | "libs.myversions.b"
        "versions-b:b" | "libs.myversions.b.b"
        "plugins:c" | "libs.myplugins.c"
        "plugins-c:c" | "libs.myplugins.c.c"
        "some:extensions" | "libs.some.myextensions"
        "another:class" | "libs.another.myclass"
        "the:convention" | "libs.the.myconvention"
        "some.class.embedded:d" | "libs.some.myclass.embedded.d"
        "Capitalized:Library" | "libs.capitalized.library"