from.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements, LibraryElements.JAR))

            to.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, Usage.JAVA_API))
            to.attribute(artifactType, 'java-classes-directory')

        attributes {
            attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage.JAVA_RUNTIME))
            attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category.LIBRARY))
            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.objects.named("gradle-local-repository"))
            attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling.EMBEDDED))
        }
        isCanBeResolved = false

        "Object"   | "123"
        "List"     | "['string']"
        "Flavor"   | "objects.named(Flavor, 'abc')"
        "Named"    | "objects.named(Named, 'abc')"
        "Number[]" | "[1, 1.2] as Number[]"
    }

    def "attribute value is isolated from original value"() {
        given:
        buildFile << """
    class Thing implements Named, Serializable {
        String name
    }
    def attr = Attribute.of(List)

                Collections.addAll(innerSet, elements);
                return Collections.checkedNavigableSet(innerSet, String.class);
              }
            })
        .named("checkedNavigableSet/TreeSet, natural")
        .withFeatures(
            SetFeature.GENERAL_PURPOSE,
            CollectionFeature.KNOWN_ORDER,
            CollectionFeature.SERIALIZABLE,

type SizedPod struct {
	Named
	Size string
}

func SizedPodCollection(pods krt.Collection[*corev1.Pod]) krt.Collection[SizedPod] {
	return krt.NewCollection(pods, func(ctx krt.HandlerContext, i *corev1.Pod) *SizedPod {
		s, f := i.Labels["size"]
		if !f {
			return nil
		}
		return &SizedPod{
			Named: NewNamed(i),
			Size:  s,
		}
	})
}

func NewNamed(n config.Namer) Named {
	return Named{

}

// tag::api[]
tasks.named("check")                    // <1>
tasks.register("myTask1")               // <2>

tasks.named<JavaCompile>("compileJava") // <3>
tasks.register<Copy>("myCopy1")         // <4>

tasks.named("assemble") {               // <5>
    dependsOn(":myTask1")
}
tasks.register("myTask2") {             // <6>
    description = "Some meaningful words"
}

tasks.named<Test>("test") {             // <7>

        attributes {
            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_RUNTIME))
            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.DOCUMENTATION))
            attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling, Bundling.EXTERNAL))
            attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType, DocsType.SOURCES))
        }
    }.artifacts
    doLast {

        }

        container.named<DomainObject>("foo").configure {
            foo = "reified access"
        }
        container.named<DomainObject>("foo") {
            bar = "reified configuration"
        }

        container.named("bar", DomainObject::class).configure {
            foo = "typed access"
        }
        container.named("bar", DomainObject::class) {

    }

    def "named(String, Action) fails when named element requested in filtered collection with incompatible type"() {
        when:
        accessedBy { map, action -> map.withType(specialItemClass).named("item", action) }

        then:
        def ex = thrown InvalidModelRuleException

                }
            }

            tasks.register("verify") {
                assert(components.named("java").get() is DefaultJvmSoftwareComponent)
                assert(configurations.named("javadocElements").isPresent())
                assert(sourceSets.named("main").isPresent())
            }
        """

        expect:
        succeeds "verify"
    }