}

// Disable the test report for the individual test task
tasks.named<Test>("test") {
    reports.html.required = false
}

// Share the test report data to be aggregated for the whole project
configurations.create("binaryTestResultsElements") {
    isCanBeResolved = false
    isCanBeConsumed = true
    attributes {
        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.DOCUMENTATION))

    description = 'Runs the integration tests.'
    group = "verification"
    testClassesDirs = integrationTest.output.classesDirs
    classpath = integrationTest.runtimeClasspath
    mustRunAfter(tasks.named('test'))
}
tasks.named('check') {
    dependsOn(integrationTestTask)
}
// end::test-task[]

def functionalTest = sourceSets.create("functionalTest")
dependencies {
    functionalTestImplementation(project)
}

        "named { it == \"help\" }"          | "all {}"            | true                  | true
        "named { it == \"help\" }"          | "forEach {}"        | true                  | false
        "named { it == \"help\" }"          | "configureEach {}"  | false                 | false
        "named { it == \"help\" }"          | "toList()"          | true                  | false

        canBeConsumed = true
        canBeResolved = false
        attributes {
            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.LIBRARY))
            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_RUNTIME))
            attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling, Bundling.EXTERNAL))
            attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, JavaVersion.current().majorVersionNumber)

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

        and:
        container.findByName("task") != null
        container.findByName("task") == task

        and:
        container.withType(DefaultTask).named("task").isPresent()
        container.withType(DefaultTask).named("task").get() == task

        and:
        1 * taskFactory.create(_ as TaskIdentity) >> task
        1 * action.execute(_) >> { throw new RuntimeException("Failing creation rule") }

class ObjectFactoryExtensionsTest {

    @Test
    fun named() {

        val objectFactory = mock<ObjectFactory> {
            on { named(any<Class<Named>>(), eq("foo")) } doReturn SomeNamed("foo")
        }

        val named = objectFactory.named<SomeNamed>("foo")
        assertThat(named.name, equalTo("foo"))

        inOrder(objectFactory) {
            verify(objectFactory).named(SomeNamed::class.java, "foo")

                Map<String, String> map = populate(new HashMap<String, String>(), entries);
                return Collections.checkedMap(map, String.class, String.class);
              }
            })
        .named("checkedMap/HashMap")
        .withFeatures(
            MapFeature.GENERAL_PURPOSE,
            MapFeature.ALLOWS_NULL_KEYS,
            MapFeature.ALLOWS_NULL_VALUES,
            MapFeature.ALLOWS_ANY_NULL_QUERIES,

                extendsFrom(bazar)
            }

            val cabin: NamedDomainObjectProvider<Configuration> = configurations.named("cabin")
            val castle: NamedDomainObjectProvider<Configuration> = configurations.named("castle") {
                extendsFrom(cabin.get())
            }

            val valley: NamedDomainObjectProvider<Configuration> = configurations.register("valley")

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