}
        1 * delegate.execute(work, context) >> delegateResult
        0 * _

        !outputs.file.exists()
        outputs.dir.isDirectory()
        outputs.dir.list() as List == []
    }

    def "cleanup for exclusive output works with missing files"() {
        def outputs = new WorkOutputs()
        outputs.dir.parentFile.mkdirs()
        outputs.file.parentFile.mkdirs()

        when:

    private final String[] inputs;

    private final String[] outputs;

    private String[] newInputs;

    private String[] newOutputs;

    public SynonymItem(final long id, final String[] inputs, final String[] outputs) {
        this.id = id;
        this.inputs = inputs;
        this.outputs = outputs;

        if (id == 0) {
            // create
            newInputs = inputs;

        }

        and:
        outputs.stdOut.contains("BEFORE OUT")
        stripped(outputs.stdOut).contains(result1.output)
        stripped(outputs.stdOut).contains(result2.output)
        outputs.stdOut.contains("AFTER OUT")

        and:
        outputs.stdErr.contains("BEFORE ERR")
        stripped(outputs.stdOut).contains(result1.error)
        stripped(outputs.stdOut).contains(result2.error)

            task producer {
                outputs.cacheIf { true }
                outputs.file("build/outputs/producer.txt")
                doLast {
                    file("build/outputs/producer.txt").text = "alma"
                }
            }

            task consumer {
                dependsOn producer
                outputs.cacheIf { true }
                inputs.file("build/outputs/producer.txt")

class A2{}
"""
        file('src/main/groovy/org/gradle/B.groovy') << 'package org.gradle; class B{}'
        outputs.snapshot { run "compileGroovy" }

        when:
        a.text = 'package org.gradle; class A1 {}'
        run "compileGroovy"

        then:
        outputs.recompiledClasses('A1')
        outputs.deletedClasses('A2')
    }

    def 'only recompile removed packages'() {
        given:

                absl::Span<AbstractTensorHandle*> outputs, bool use_function) {
  if (use_function) {
    const char* fn_name = "test_fn";
    core::RefCountPtr<AbstractFunction> scoped_func;
    // Returning null tensors from a tf.function is not supported, so we keep
    // track of indices in the model's outputs are nullptr in this set.
    // The FunctionDef only outputs the non-null tensors. We later pad the

    }

    /**
     * The way the outputs have been produced.
     */
    enum ExecutionOutcome {
        /**
         * The outputs haven't been changed, because the work is already up-to-date
         * (i.e. its inputs and outputs match that of the previous execution in the
         * same workspace).
         */
        UP_TO_DATE,

        /**
         * The outputs of the work have been loaded from the build cache.

  std::vector<Tensor> outputs;

  TF_EXPECT_OK(session.Run({{a, {1, 1}}}, {c}, &outputs));
  test::ExpectTensorEqual<int>(outputs[0], test::AsTensor<int>({3, 3}, {2}));

  auto d = Add(root, c, {39, 39});
  outputs.clear();
  TF_EXPECT_OK(session.Run({{a, {-10, 1}}}, {d}, &outputs));
  test::ExpectTensorEqual<int>(outputs[0], test::AsTensor<int>({31, 42}, {2}));
}

OutputTensor ToOutputTensor(const Output& output) {
  return OutputTensor(output.node(), output.index());
}

// Utility function for converting to internal C++ datatypes.
std::vector<OutputTensor> ToOutputTensors(const std::vector<Output>& outputs) {
  std::vector<OutputTensor> result(outputs.size());
  for (int i = 0; i < outputs.size(); ++i) {
    result[i] = ToOutputTensor(outputs[i]);
  }
  return result;
}

            #import "${otherHeaderFile.name}"
"""
        and:
        outputs.snapshot { run "mainExecutable" }

        when:
        otherHeaderFile << """
            // Some extra content
"""
        and:
        run "mainExecutable"

        then:
        executedAndNotSkipped compileTask

        and:
        outputs.recompiledFile sourceFile
    }

    @ToBeFixedForConfigurationCache