}

    @Override
    public Optional<String> validationErrorFor(String group, String name, AttributeContainer attributes) {
        Category category = attributes.getAttribute(Category.CATEGORY_ATTRIBUTE);
        if (category != null) {
            if (Category.ENFORCED_PLATFORM.equals(category.getName())) {
                return Optional.of("contains a dependency on enforced platform '" + group + ":" + name + "'");
            }
        }

        }

        boolean result = inclusions.isEmpty();

        for (Class<?> category : categories) {
            if (matches(category, inclusions)) {
                result = true;
                break;
            }
        }

        if (result) {
            for (Class<?> category : categories) {
                if (matches(category, exclusions)) {
                    result = false;
                    break;

			t.Fatalf("failed to read trace: %s", err)
		}
		for category := range logs {
			event := mustFindLogV2(t, bytes.NewReader(traceData), category)
			if wantEvent := logs[category]; wantEvent == nil {
				logs[category] = &event
			} else if got, want := dumpStackV2(&event), dumpStackV2(wantEvent); got != want {
				t.Errorf("%q: got stack:\n%s\nwant stack:\n%s\n", category, got, want)
			}
		}
	}
}

            file-dep.jar {artifactType=jar}
            api-1.0.jar (test:api:1.0) {artifactType=jar, org.gradle.status=release}

import static org.gradle.api.attributes.Bundling.SHADOWED
import static org.gradle.api.attributes.Category.CATEGORY_ATTRIBUTE
import static org.gradle.api.attributes.Category.DOCUMENTATION
import static org.gradle.api.attributes.Category.LIBRARY
import static org.gradle.api.attributes.Category.REGULAR_PLATFORM
import static org.gradle.api.attributes.DocsType.DOCS_TYPE_ATTRIBUTE

        when:
        def event = new LogEvent(TIMESTAMP, CATEGORY, LogLevel.LIFECYCLE, MESSAGE, new RuntimeException(), new OperationIdentifier(42L))
        def result = serialize(event, serializer)

        then:
        result instanceof LogEvent
        result.timestamp == TIMESTAMP
        result.category == CATEGORY
        result.logLevel == LogLevel.LIFECYCLE
        result.message == MESSAGE

    private final String namespace;
    private final String category;
    private final List<String> subcategories;

    private DefaultProblemCategory(String namespace, String category, String... subcategories) {
        this.namespace = namespace;
        this.category = category;
        this.subcategories = Arrays.asList(subcategories);
    }

                canBeResolved = false
                assert canBeConsumed

                attributes {
                    attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category, Category.DOCUMENTATION));
                }
            }
        """

        when:
        succeeds ':outgoingVariants'

        then:

                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "foo"))
                    }
                }
                other {
                    outgoing {
                        artifact file("bar.txt")
                    }
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "bar"))
                    }

    }

    def "describes arbitrary attributes"() {
        when:
        attributes.attribute(Category.CATEGORY_ATTRIBUTE, named(Category, Category.DOCUMENTATION))
            .attribute(DocsType.DOCS_TYPE_ATTRIBUTE, named(DocsType, DocsType.SAMPLES))
            .attribute(Bundling.BUNDLING_ATTRIBUTE, named(Bundling, Bundling.EMBEDDED))