named("quickTest") {
        dependsOn("embeddedIntegTest")
    }

    named("platformTest") {
        dependsOn("forkingIntegTest")
    }

    named("allVersionsIntegMultiVersionTest") {
        dependsOn("integMultiVersionTest")
    }

    named("parallelTest") {
        dependsOn("parallelIntegTest")
    }

    named("noDaemonTest") {

    named(name, T::class)


/**
 * Locates a task by name and type, without triggering its creation or configuration, failing if there is no such task.
 *
 * @see [TaskCollection.named]
 */
@Suppress("unchecked_cast")
fun <T : Task> TaskCollection<out Task>.named(name: String, type: KClass<T>): TaskProvider<T> =
    (this as TaskCollection<T>).named(name, type.java)

}

func (cache *MethodSetCache) lookupNamed(named *types.Named) struct{ value, pointer *types.MethodSet } {
	if cache.named == nil {
		cache.named = make(map[*types.Named]struct{ value, pointer *types.MethodSet })
	}
	// Avoid recomputing mset(*T) for each distinct Pointer
	// instance whose underlying type is a named type.
	msets, ok := cache.named[named]
	if !ok {
		msets.value = types.NewMethodSet(named)

import org.gradle.kotlin.dsl.named


fun ConsumableConfiguration.configureAsRuntimeElements(objects: ObjectFactory) {
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
        attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))

                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "custom"))
                    }
                }

                sample2 {
                    assert canBeResolved

                    attributes {
                        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_RUNTIME))

        return this;
    }

    @Override
    public JvmEcosystemAttributesDetails documentation(String docsType) {
        attributes.attribute(Category.CATEGORY_ATTRIBUTE, objectFactory.named(Category.class, Category.DOCUMENTATION));
        attributes.attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objectFactory.named(DocsType.class, docsType));
        return this;

                assert(components.named<TestComponent>("first").get().name == "first")
                assert(components.named<TestComponent>("first").get().value.get() == 1)
                assert(components.named<TestComponent>("first").get() is DefaultTestComponent)

                assert(components.named<CustomComponent>("second").get().name == "second")
                assert(components.named<CustomComponent>("second").get().value.get() == 2)

        when:
        container.named("a", method)
        then:
        ex = thrown(Throwable)
        assertDoesNotAllowMethod(ex, methodUnderTest)

        when:
        container.named("a", getType(), method)
        then:
        ex = thrown(Throwable)
        assertDoesNotAllowMethod(ex, methodUnderTest)

        when:
        container.withType(container.type).named("a").configure(method)
        then:

    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_RUNTIME))
        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.DOCUMENTATION))
        attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType, 'jacoco-coverage-data'))
    }
    outgoing.artifact(tasks.named('test').map { task ->
        task.extensions.getByType(JacocoTaskExtension).destinationFile
    })

        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"
                }
            }