dependsOn assertUnresolved
    classpath = configurations.conf
    destinationDirectory = buildDir
}
"""

        then:
        succeeds "war"
    }

    def "can make war task cacheable with runtime api"() {
        given:
        def webXml = file('web.xml') << '<web/>'
        createDir('web-inf') {
            webinf1 {
                file 'file1.txt'
            }
        }

            return localResolveStateFactory.stateFor(model, componentIdentifier, moduleVersionIdentifier, configurationsProvider, module.getStatus(), schema);
        } else {
            // Mark the state as 'ad hoc' and not cacheable
            return localResolveStateFactory.adHocStateFor(model, componentIdentifier, moduleVersionIdentifier, configurationsProvider, module.getStatus(), schema);
        }
    }

[WARNING]
====
If you want to share task output from incremental builds, i.e. non-clean builds, you have to make sure that all cacheable tasks are properly configured and implemented to deal with stale output.
There are for example annotation processors that do not clean up stale files in the corresponding classes/resources directories.

/**
 * Generates a Gradle metadata file to represent a published {@link org.gradle.api.component.SoftwareComponent} instance.
 *
 * @since 4.3
 */
@DisableCachingByDefault(because = "Not made cacheable, yet")
public abstract class GenerateModuleMetadata extends DefaultTask {
    private final Transient<Property<Publication>> publication;
    private final Transient<ListProperty<Publication>> publications;

image::performance/task-execution-cacheable.png[title="A task oriented view of performance"]

image::performance/timeline-not-cacheable.png[title="Timeline screen with 'not cacheable' tasks only"]

Sort by task duration on the timeline screen to highlight tasks with great time saving potential.
The build scan above shows that `:task1` and `:task3` could be improved and made cacheable
and shows why Gradle didn't cache them.

import org.gradle.work.DisableCachingByDefault

/**
 * Generates a multi-project native build that has project dependencies and tests.
 */
@DisableCachingByDefault(because = "Not made cacheable, yet")
class NativeProjectWithDepsGeneratorTask extends TemplateProjectGeneratorTask {

    /** Represents a native library requirement */
    class Dependency {
        String project
        String library

        when:
        executor.execute(id, null, detailsToResult, onCacheMiss, cachePolicy)

        then:
        0 * _
    }

    def "executes the rule without caching if the rule is not cacheable"() {
        withNonCacheableToUpperCaseRule()
        def id = new Id('Alicia')

        when:
        execute(id)

        then:
        result.length == 6
        0 * _
    }

 * tasks signatory and signature type.
 */
@DisableCachingByDefault(because = "Not made cacheable, yet")
public abstract class Sign extends DefaultTask implements SignatureSpec {

    private SignatureType signatureType;
    private Signatory signatory;
    private boolean required = true;

        failure.assertHasCause("Execution failed for MakeGreen: ${file('b/build/b.jar')}.")
        failure.assertHasCause("No service of type class ${File.name} available.")
    }

    def "task implementation cannot use cacheable transform annotation"() {
        expectReindentedValidationMessage()
        buildFile << """
            @CacheableTransform
            class MyTask extends DefaultTask {
                @TaskAction void execute() {}

To enable the build cache for an artifact transform, add the `@link:{javadocPath}/org/gradle/api/artifacts/transform/CacheableTransform.html[CacheableTransform]` annotation on the action class.