when:
        cleanBuildDir()
        withBuildCache().run "producer"
        then:
        skipped ":producer"

        when:
        withBuildCache().run "producer", "--info"
        !output.contains("Caching disabled for task ':producer'")
        then:
        skipped ":producer"
    }

    def "task can be cached after loaded from cache"() {
        file("input.txt").text = "input"

> Task :sourcesJar
> Task :publishBinaryAndSourcesPublicationToExternalRepository SKIPPED
> Task :publishBinaryAndSourcesPublicationToInternalRepository
> Task :generateDescriptorFileForBinaryPublication
> Task :generateMetadataFileForBinaryPublication
> Task :publishBinaryPublicationToExternalRepository
> Task :publishBinaryPublicationToInternalRepository SKIPPED
> Task :publish

BUILD SUCCESSFUL in 0s

			if off < at.Elem.Size_ {
				cgoCheckUsingType(at.Elem, src, off, size)
			}
			src = add(src, at.Elem.Size_)
			skipped := off
			if skipped > at.Elem.Size_ {
				skipped = at.Elem.Size_
			}
			checked := at.Elem.Size_ - skipped
			off -= skipped
			if size <= checked {
				return
			}
			size -= checked
		}
	case abi.Struct:
		st := (*structtype)(unsafe.Pointer(typ))

        when:
        withBuildCache().run 'myTask', '-Panonymous'
        then:
        skipped(':myTask')

        when:
        withBuildCache().run 'myTask'
        then:
        skipped(':myTask')

        when:
        withBuildCache().run 'myTask', '-Panonymous'
        then:
        skipped(':myTask')
    }

    private TestFile setupTaskClassWithActionProperty() {

        switch (getResultType()) {
            case SUCCESS:
                return "success";
            case FAILURE:
                return "failures";
            case SKIPPED:
                return "skipped";
            default:
                throw new IllegalStateException();
        }
    }

    public String getFormattedResultType() {
        switch (getResultType()) {

        ':wearable:generateDebugResources': FROM_CACHE,
        ':wearable:javaPreCompileDebug': FROM_CACHE,
        ':wearable:kaptDebugKotlin': SKIPPED,
        ':wearable:kaptGenerateStubsDebugKotlin': SKIPPED,
        ':wearable:mapDebugSourceSetPaths': SUCCESS,
        ':wearable:mergeDebugAssets': SUCCESS,
        ':wearable:mergeDebugGlobalSynthetics': FROM_CACHE,

	var (
		lastErr error
		skipped []runtime.Decoder
	)

	// try recognizers, record any decoders we need to give a chance later
	for _, r := range d.decoders {
		switch t := r.(type) {
		case RecognizingDecoder:
			ok, unknown, err := t.RecognizesData(data)
			if err != nil {
				lastErr = err
				continue
			}
			if unknown {
				skipped = append(skipped, t)
				continue
			}
			if !ok {

        then:
        succeeds ":b:${language.compileTaskName}"
        skipped ":a:${language.compileTaskName}"
        skipped ":b:${language.compileTaskName}"

        when:
        resourceFile.delete()

        then:
        succeeds ":b:${language.compileTaskName}"
        skipped ":a:${language.compileTaskName}"
        skipped ":b:${language.compileTaskName}"

        when:

        given:
        buildFile << basicScalaProject()
        file('src/main/scala/MyClass.java') << javaClassWithCustomAnnotation()

        when:
        fails 'compileScala'

        then:
        skipped(':compileJava')
        executedAndNotSkipped(':compileScala')
        result.assertHasErrorOutput('error: package org.gradle does not exist')
        failure.assertHasCause('javac returned non-zero exit code')
    }

        when:
        run 'compileScala'

        then:
        executedAndNotSkipped ':compileScala'

        when:
        run 'compileScala'

        then:
        skipped ':compileScala'

        when:
        buildScript(scalaProjectBuildScript(newZincVersion, newScalaVersion))
        run 'compileScala'

        then:
        executedAndNotSkipped ':compileScala'