}


/**
 * Property delegate for registering new elements in the container.
 *
 * `tasks { val rebuild by registering }`
 *
 * @param T the domain object type
 * @param C the concrete container type
 */
inline val <T : Any, C : NamedDomainObjectContainer<T>> C.registering: RegisteringDomainObjectDelegateProvider<out C>
    get() = RegisteringDomainObjectDelegateProvider.of(this)

                val pipistrelle: TaskProvider<Task> by tasks.existing {
                    description += "B"
                }

                val yate: TaskProvider<Task> by tasks.registering
                val vansire: TaskProvider<Task> by tasks.registering {
                    description += "!"
                }
            }

            fun typed() {

                val foo: Task by tasks.getting(Task::class)

val generateRelocatedPackageList by tasks.registering(PackageListGenerator::class) {
    classpath.from(runtimeClasspath)
    outputFile = generatedTxtFileFor("api-relocated")
}

// Extract public API metadata from source code of Gradle module Jars packaged in the distribution (used by the two tasks below to handle default imports in build scripts)
val dslMetaData by tasks.registering(ExtractDslMetaDataTask::class) {

        )
    }

    @Test
    fun `val domainObject by registering`() {

        val domainObjectProvider = mockDomainObjectProviderFor(DomainObject())
        val container = mock<NamedDomainObjectContainer<DomainObject>> {
            on { register("domainObject") } doReturn domainObjectProvider
        }

        container {

            val domainObject by registering

            inOrder(container, domainObjectProvider) {

                        dependencies {
                            implementation("org.apache.commons:commons-lang3:3.11")
                        }
                    }
                    val integTest by registering(JvmTestSuite::class) {
                        useJUnit()
                    }
                }
            }

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

----
====

== Registering a build service and connecting it to a task

To create a build service, you register the service instance using the link:{javadocPath}/org/gradle/api/services/BuildServiceRegistry.html#registerIfAbsent-java.lang.String-java.lang.Class-org.gradle.api.Action-[BuildServiceRegistry.registerIfAbsent()] method.
Registering the service does not create the service instance.

        ex.message == "Factory registration for '${fullyQualifiedNameOf(ManagedThingSpec)}' is invalid because it doesn't extend an interface with a default implementation"
    }

    def "fails when registering non-interface internal view"() {
        when:
        instanceFactory.register(ModelType.of(ThingSpec), new SimpleModelRuleDescriptor("thing"))
            .withInternalView(ModelType.of(Object))
        then:

	if err == nil {
		t.Error("expected error registering ReplyNotPointer")
	}
	err = Register(new(ArgNotPublic))
	if err == nil {
		t.Error("expected error registering ArgNotPublic")
	}
	err = Register(new(ReplyNotPublic))
	if err == nil {
		t.Error("expected error registering ReplyNotPublic")
	}
	err = Register(NeedsPtrType(0))
	if err == nil {
		t.Error("expected error registering NeedsPtrType")

        then:
        0 * validator.validateMutation(_)
    }

    def "registering an all rule toggles the hasRule flag"() {
        given:
        def action = Mock(Action)

        when:
        substitutions.all(action)

        then:
        substitutions.rulesMayAddProjectDependency()
    }

    def "registering a substitute rule with (#from, #to) causes hasRule #result"() {
        given:

[[sec::declare_feature_variants]]
== Registering features

Features can be declared by applying the `java-library` plugin.
The following code illustrates how to declare a feature named `mongodbSupport`:

.Registering a feature
====