thread.blockUntil.running
            lifecycle.stop()
            instant.stopped
        }

        then:
        instant.finished < instant.stopped
    }

    def "multiple threads can call stop() concurrently"() {
        expect:
        async {
            start {
                lifecycle.use {
                    instant.running
                    thread.block()
                }

        when:
        module.ivy.expectMetadataRetrieve()

        then:
        fails 'retrieve'
        assertTaskFailureDescription(":retrieve")
        failure.assertHasCause("Could not resolve all files for configuration ':compile'.")
            .assertHasCause("""Could not find org.group.name:projectA:1.2.
Searched in the following locations:
  - ${module.ivy.uri}
Required by:
""")

# tag::cli[]
# gradle wrapper --gradle-version=4.0 --distribution-type=all
# end::cli[]
executable: gradle
args: "wrapper --gradle-version=4.0 --distribution-type=all"

        buildFile << '''
class UnmanagedThing {
    def getSomeProp() {
        return this
    }
    def conf(Closure cl) {
        cl.delegate = this
        cl.call()
    }
}

class MyPlugin extends RuleSource {
    @Model
    UnmanagedThing thing() { return new UnmanagedThing() }
}
apply plugin: MyPlugin

model {
    thing {
        conf {

    }

    @Override
    public void setLocale(Locale locale) {
        delegate.setLocale(locale);
    }

    @Override
    public Boolean call() {
        try {
            return delegate.call();
        } finally {
            CompositeStoppable.stoppable(fileManager).stop();
            cleanupZipCache();
        }
    }

    /**

            ignoreProperty("timestamp")
        }
    }
}
// end::ignore-property-selected[]

// tag::ignore-property-all[]
normalization {
    runtimeClasspath {
        properties {
            ignoreProperty("timestamp")
        }
    }
}

// tag::all[]
// tag::task-rule[]
tasks.addRule("Pattern: ping<ID>") { String taskName ->

    if (taskName.startsWith("ping")) {
        task(taskName) {
            doLast {
                println "Pinging: " + (taskName - 'ping')
            }
        }
    }
}
// end::task-rule[]

tasks.register('groupPing') {
    dependsOn 'pingServer1', 'pingServer2'
}

import java.util.Map;

/**
 * An immutable view of all properties available for build options, calculated from command-line options, the environment and the various
 * properties files.
 */
public interface AllProperties {
    /**
     * Returns the system properties defined as command-line options.
     */
    Map<String, String> getRequestedSystemProperties();

    /**

     */
    void enqueue(Runnable task);

    /**
     * Runs the given action, blocking until the result is available.
     *

}
// end::dependencies[]

// tag::use_highest_asm[]
configurations.all {
    resolutionStrategy.capabilitiesResolution.withCapability('org.ow2.asm:asm') {
        selectHighestVersion()
    }
}
// end::use_highest_asm[]

// tag::declare_capability[]
dependencies {
    // Activate the "LoggingCapability" rule
    components.all(LoggingCapability)
}

@CompileStatic