"with the same name and no classifier"               | "publishTest-1.9.jar"                  | null               | "Invalid publication 'ivy': multiple artifacts with the identical name, extension, type and classifier ('publishTest', jar', 'jar', 'null'"
        "with the same name and a classifier"                | "publishTest-1.9.jar"                  | "optional-feature" | null

        result.assertTaskSkipped(":a")
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE, because = "Flaky")
    def "cannot mutate named instance from groovy"() {
        buildFile << """
            interface Thing extends Named { }

            def t1 = objects.named(Thing, "t1")
            task changeProp {
                doLast {
                    t1.name = "123"
                }
            }

 *
 * <p>Features are classified by their capabilities. Each variant of a feature provides at least
 * the same set of capabilities as the feature itself. Since all variants of a feature are derived
 * from the same sources, they all expose the same API or "content" and thus provide the same
 * capabilities. Some variants may expose additional capabilities than those of its owning feature,
 * for example with fat jars.</p>
 *

                @Mutate
                void setName(Named named) {
                    named.name = "superclass"
                }

                @Mutate
                void addTask(ModelMap<Task> tasks, Named named) {
                    tasks.create("echo") {
                        it.doLast {
                            println "name: $named.name"
                        }
                    }

            onNamedWithAction("alice", DomainObjectBase.Foo::class, aliceProvider)
            on { named(eq("bob"), eq(DomainObjectBase.Bar::class.java)) } doReturn bobProvider
            on { named(eq("jim")) } doReturn defaultProvider
            on { named(eq("steve")) } doReturn defaultProvider
        }

        container {
            val a = "alice"(DomainObjectBase.Foo::class) {

                    val integTest by registering(JvmTestSuite::class) {
                        useJUnit()
                    }
                }
            }

            tasks.named("check") {
                dependsOn(testing.suites.named("integTest"))
            }

            tasks.register("checkConfiguration") {
                dependsOn("test", "integTest")

}

tasks.named("task1"){
    println("NAMED TASK1: This is executed during the configuration phase")
    doFirst {
        println("NAMED TASK1 - doFirst: This is executed during the execution phase")
    }
    doLast {
        println("NAMED TASK1 - doLast: This is executed during the execution phase")
    }
}

tasks.named("task2"){

The same requirement applies to next/* (described below), which will
become a go1.XX.txt for XX >= 19.

The next/ directory contains the only files intended to be mutated.
Each file in that directory contains a list of features that may be added
to the next release of Go. The files in this directory only affect the
warning output from the go api tool. Each file should be named

// Interprets the named kernel construction attribute as bool and
// places it into *val. *status is set to TF_OK.
//
// If the attribute could not be found or could not be interpreted as
// bool, *status is populated with an error.
TF_CAPI_EXPORT extern void TF_OpKernelConstruction_GetAttrBool(
    TF_OpKernelConstruction* ctx, const char* attr_name, TF_Bool* val,
    TF_Status* status);

    }

    static class PriorityTest {

        interface MyService {}

        @Named
        static class MyServiceImpl implements MyService {}

        @Named
        @Priority(10)
        static class MyPriorityServiceImpl implements MyService {}

        @Named
        static class MyMojo {
            @Inject
            MyService service;
        }
    }

    @Test