inputDir = project.mkdir('inputs')
        outputDir = project.mkdir('outputs')
        prop = 'foo'
    }
"""
        file('inputs/file0.txt') << "inputFile0"
        file('inputs/file1.txt') << "inputFile1"
        file('inputs/file2.txt') << "inputFile2"

        file('outputs/file1.txt') << "outputFile1"
        file('outputs/file2.txt') << "outputFile2"
    }

        registry.isOutputOwnedByBuild(file('outputs/even-an-other-dir'))
        !registry.isOutputOwnedByBuild(file('build'))
        !registry.isOutputOwnedByBuild(file('output'))
        !registry.isOutputOwnedByBuild(file('build/output'))
        !registry.isOutputOwnedByBuild(file('different-file/build/outputs'))
    }

    @Override
    public void transform(TransformOutputs outputs) {
        // We simulate fan-in behaviour:
        // We expect that a transform before this one outputs three artifacts: 1. analysis metadata, 2. the original file and 3. instrumentation marker file.
        // So if the input is analysis metadata we merge it and output it, otherwise it's original artifact, and we output that.
        File input = getInput().get().getAsFile();

public abstract class GroupedNodeFixture {

    private final List<String> outputs = new ArrayList<>(1);

    public void addOutput(String transformOutput) {
        outputs.add(transformOutput);
    }

    public String getOutput() {
        List<String> nonEmptyOutputs = filter(outputs, string -> !string.equals(""));
        return join("\n", nonEmptyOutputs);
    }

        ExecOutput result = findMSBuild().execWithFailure(args, buildEnvironment(workingDir));

        List<ExecutionOutput> outputs = getOutputFiles();
        assert outputs.size() == 1;
        String gradleStdout = fileContents(outputs.get(0).stdout);
        String gradleStderr = fileContents(outputs.get(0).stderr);
        System.out.println(result.getOut());
        System.out.println(gradleStdout);

        inputs.files "src/linkdir/existing"
        outputs.files "build/output"
        doLast {
            println "isEmpty: " + symlink.isEmpty()
        }
    }
"""
        Files.createSymbolicLink(Paths.get(symlink.toURI()), Paths.get(targetDir.toURI()))
        expect:
        succeeds("echo")
        executedAndNotSkipped(":echo")
        output.contains("isEmpty: false")
        when: "symlink is deleted"

      location, concat_dim_type, concat_dimension_attr);

  // Correctly set output shapes of concat op output if output shape is
  // statically known. Since the shape of TPUExecute op must be the same
  // across logical devices, we refer to the shape of 0th logical device
  // computation output.
  mlir::Type output_type;
  auto input_type = mlir::cast<mlir::TensorType>(inputs[0].getType());

[[sec:task_output_caching_details]]
== Cacheable tasks

Since a task describes all of its inputs and outputs, Gradle can compute a _build cache key_ that uniquely defines the task's outputs based on its inputs.
That build cache key is used to request previous outputs from a build cache or store new outputs in the build cache.

                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    def output = outputs.file("\${input.name}.${extension}")
                    println "${message} \${input.name} to \${output.name}"
                    output.text = String.valueOf(input.length())
                }
            }
        """
    }

//  noutputs - number of elements in `outputs` array
//  outputs - array of TF_Outputs that specify the outputs of the function.
//            If `noutputs` is zero (the function returns no outputs), `outputs`
//            can be null. `outputs` can contain the same tensor more than once.
//  output_names - The names of the function's outputs. `output_names` array