import org.gradle.util.GradleVersion

class CacheableTaskProgressEventsCrossVersionSpec extends ToolingApiSpecification {
    def setup() {
        buildFile << """
            apply plugin: 'base'

            task cacheable {
                def outputFile = new File(buildDir, "output")
                inputs.file("input")
                outputs.file(outputFile)
                outputs.cacheIf { true }

                doLast {

class CacheableTaskOutcomeCrossVersionSpec extends ToolingApiSpecification {
    def setup() {
        buildFile << """
            apply plugin: 'base'

            task cacheable {
                def outputFile = new File(buildDir, "output")
                inputs.file("input")
                outputs.file(outputFile)
                outputs.cacheIf { true }

                doLast {

== Instrumented test execution (i.e., Espresso tests)

Android instrumented tests (`DeviceProviderInstrumentTestTask`), often referred to as “Espresso” tests, are also not cacheable.
The Google Android team is also working to make such tests cacheable.
Please see https://issuetracker.google.com/issues/115873051[this issue].

        val parameterObject: TransformParameters? = read()?.uncheckedCast()
        val implementationClass = readClass()
        val cacheable = readBoolean()

        return DefaultTransform.IsolateTransformParameters(
            parameterObject,
            implementationClass,
            cacheable,
            RootScriptDomainObjectContext.INSTANCE,
            parameterScheme.inspectionScheme.propertyWalker,

    @Override
    public InternalProblems getProblemsService() {
        return ProblemsProgressEventEmitterHolder.get();
    }

    @Override
    public TypeValidationContext forType(Class<?> type, boolean cacheable) {
        types.add(type);
        Supplier<Optional<PluginId>> pluginId = () -> typeOriginInspector.findPluginDefining(type);
        return new ProblemRecordingTypeValidationContext(type, pluginId) {
            @Override

        return classInfos.get(type, aClass -> createTaskClassInfo(aClass.asSubclass(Task.class)));
    }

    private static TaskClassInfo createTaskClassInfo(Class<? extends Task> type) {
        boolean cacheable = type.isAnnotationPresent(CacheableTask.class);
        Optional<String> reasonNotToTrackState = Optional.ofNullable(type.getAnnotation(UntrackedTask.class))
            .map(UntrackedTask::because);

        'validation:type-validation:invalid-use-of-type-annotation' : 'Incorrect use of type annotation',
        'validation:type-validation:not-cacheable-without-reason' : 'Not cacheable without reason',

        visitInputArtifact(visitor);
    }

    private String normalizeAbsolutePath(String path) {
        // We try to normalize the absolute path, so the workspace id is stable between machines for cacheable transforms.
        if (path.startsWith(rootProjectLocation)) {
            return path.substring(rootProjectLocation.length());
        }
        return path;
    }

import static org.gradle.internal.logging.text.StyledTextOutput.Style.Identifier;
import static org.gradle.internal.logging.text.StyledTextOutput.Style.Normal;

@UntrackedTask(because = "Produces only non-cacheable console output")
public abstract class ShowToolchainsTask extends DefaultTask {

    private static final Comparator<JvmToolchainMetadata> TOOLCHAIN_COMPARATOR = Comparator

        WorkValidationContext validationContext = node.getValidationContext();
        Class<?> taskType = GeneratedSubclasses.unpackType(node.getTask());
        // We don't know whether the task is cacheable or not, so we ignore cacheability problems for scheduling
        TypeValidationContext typeValidationContext = validationContext.forType(taskType, false);
        node.getTaskProperties().validateType(typeValidationContext);