def files = configurations._compileFreeDebug
                    doLast {
                       assert files.collect { it.name } == ['b-foo.jar']
                    }
                }
                task checkRelease(dependsOn: configurations._compileFreeRelease) {
                    def files = configurations._compileFreeRelease
                    doLast {
                       assert files.collect { it.name } == ['b-bar.jar']

                shouldCount.set(false)
                doLast {
                    println("Service not used")
                }
            }
        """

        when:
        run("unused")

        then:
        output.count("service:") == 0
        output.count("Service not used") == 1
    }

    def "can use service from task doFirst() or doLast() action"() {
        serviceImplementation()

            task fileProducer {
                outputs.file 'build/out.txt'
                doLast {
                    file('build/out.txt').text = 'some content'
                }
            }
            task dirProducer {
                outputs.dir 'build/outdir'
                doLast {
                    file('build/outdir').mkdirs()

        def configurationCache = newConfigurationCacheFixture()

        buildFile << """
            task broken {
                doLast {
                    println("project = " + project.name)
                }
            }
            task anotherBroken {
                doLast {
                    println("configurations = " + project.configurations.all)
                }
            }

            configurations.conf.resolutionStrategy.dependencySubstitution {
                substitute module('org.utils:api:1.3') using module('org.utils:api:1.+')
            }

            task check {
                doLast {
                    def deps = configurations.conf.incoming.resolutionResult.allDependencies as List
                    assert deps.size() == 1
                    assert deps[0].requested.version == '1.3'

        buildFile << """
            apply plugin: 'java-library'

            tasks.register("verifyExtension") {
                def lib = libs.foo
                assert lib instanceof Provider
                doLast {
                    def dep = lib.get()
                    assert dep instanceof MinimalExternalModuleDependency
                    assert dep.module.group == 'org.gradle.test'

            }
            task resolve {
                def files = configurations.conf
                doLast {
                    files.files
                }
            }
            task checkGraph {
                def result = configurations.conf.incoming.resolutionResult.rootComponent
                doLast {
                    def root = result.get()

            }.files

            task resolveFilesWhenSerialized {
                def input = provider { files2*.name }
                doLast {
                    println input.get()
                }
            }

            task usesFiles2 {
                doLast {
                    println files2*.name
                }
            }
        """

        when:

+
Use the link:{groovyDslPath}/org.gradle.api.Task.html#org.gradle.api.Task:doLast(org.gradle.api.Action)[Task.doLast()] method instead, like this:
+
----
task myTask {
    doLast {
        ...
    }
}
----

        }
    }


    private static byte[] createToken ( final SSPContext ctx, final byte[] token, Subject s ) throws CIFSException {
        if ( s != null ) {
            try {
                return Subject.doAs(s, new PrivilegedExceptionAction<byte[]>() {

                    @Override
                    public byte[] run () throws Exception {