tasks.register('doSomething') {
                doLast {
                    println 'do something'
                }
            }
        """

        when:
        executeTaskViaGradleProjectLaunchable("doSomething")

        then:
        assertHasBuildSuccessfulLogging()
        outputContains("do something")
    }

        then:
        0 * _

        when:
        listenerManager.getBroadcaster(TestListener).something("12")

        then:
        1 * created.run()
        0 * _

        when:
        listenerManager.getBroadcaster(NotStatefulListener).something("12")

        then:
        1 * service.something("12")
        0 * _
    }

        'exact match'                                    | [key: 'something']              | 'foo'
        'exact match'                                    | [key: 'something else']         | 'bar'
        'partial match on key but attribute is optional' | [key: 'something', extra: 'no'] | 'foo'
    }

    def "revalidates default configuration if it has attributes"() {

        given:
        def project = project('root', null, Stub(GradleInternal))
        def action = { files -> files.builtBy('something') } as Action<ConfigurableFileCollection>

        when:
        def fileCollection = project.files('path', action)

        then:
        fileCollection.builtBy == ['something'] as Set
    }

    def "can create file tree configured with an Action"() {
        given:

Asynchronous code just means that the language 💬 has a way to tell the computer / program 🤖 that at some point in the code, it 🤖 will have to wait for *something else* to finish somewhere else. Let's say that *something else* is called "slow-file" 📝.

So, during that time, the computer can go and do some other work, while "slow-file" 📝 finishes.

!!! info "`@decorator` Info"
    That `@something` syntax in Python is called a "decorator".

    You put it on top of a function. Like a pretty decorative hat (I guess that's where the term came from).

    A "decorator" takes the function below and does something with it.

                abstract DirectoryProperty getSources()

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void doSomething() {
                    outputFile.get().asFile.text = "executed"
                }
            }

            tasks.register("taskWithInputs", TaskWithInputs) {
                sources.set(file("inputDir"))

		return fallbackOrder, nil
	}

	// Try to figure out the order to use for searches.
	// If we don't recognize something, use fallbackOrder.
	// That will use cgo unless the Go resolver was explicitly requested.
	// If we do figure out the order, return something other
	// than fallbackOrder to use the Go resolver with that order.

	dnsConf = getSystemDNSConfig()

    }

    def "logs generic deprecation message for specific thing"() {
        when:
        DeprecationLogger.deprecate("Something").willBeRemovedInGradle9().undocumented().nagUser()

        then:
        expectMessage "Something has been deprecated. This is scheduled to be removed in Gradle ${NEXT_GRADLE_VERSION}."
    }

    def "logs deprecated behavior message"() {
        when:

                contextualLabel == 'Type \'MyTask\' method \'notAGetter()\' should not be annotated with: @Input'
                details == 'Input/Output annotations are ignored if they are placed on something else than a getter'
                solutions == [
                    'Remove the annotations',
                    'Rename the method',
                ]