/// `Tensor` objects in `outputs`. The number and order of `outputs` will
  /// match `fetch_outputs`.
  Status Run(const std::vector<Output>& fetch_outputs,
             std::vector<Tensor>* outputs) const;

  /// Same as above, but use the mapping in `inputs` as feeds.
  Status Run(const FeedType& inputs, const std::vector<Output>& fetch_outputs,
             std::vector<Tensor>* outputs) const;

        outputs.add(output);
    }

    /**
     * Returns concatenated non-empty output entries.
     */
    public String getOutput() {
        List<String> nonEmptyOutputs = filter(outputs, string -> !string.equals(""));
        return join("\n", nonEmptyOutputs);
    }

    /**
     * Returns all output entries.
     */
    public List<String> getOutputs() {
        return outputs;
    }

    /**

     */
    DISABLE_CONDITION_SATISFIED,

    /**
     * The work has no outputs declared.
     */
    NO_OUTPUTS_DECLARED,

    /**
     * Work has declared output that is not cacheable.
     *
     * Reasons for non-cacheable outputs:
     * <ul>
     *     <li>an output contains a file tree,</li>
     *     <li>an output is not tracked.</li>
     * </ul>
     */
    NON_CACHEABLE_OUTPUT,

    /**

    delete(layout.buildDirectory.file("outputs/1.txt"))
}
// end::removed-output[]

// tag::reverse[]
tasks.register<IncrementalReverseTask>("incrementalReverse") {
    inputDir = file("inputs")
    outputDir = layout.buildDirectory.dir("outputs")
    inputProperty = project.findProperty("taskInputProperty") as String? ?: "original"
}
// end::reverse[]

        def output = new File(outputDirectory, entry.name)
        if (!output.canonicalPath.startsWith(outputDirectoryCanonicalPath)) {
            throw new ZipException("Zip entry '${entry.name}' is outside of the output directory")
        }
        if (entry.isDirectory) {
            output.mkdirs()
        } else {
            output.parentFile.mkdirs()

                abstract Provider<FileSystemLocation> getInput()

                void transform(TransformOutputs outputs) {
                    def dir = input.get().asFile
                    assert dir.directory
                    println("transforming [\${dir.name}]")
                    outputs.file("\${dir.name}.size").text = 'ok'
                }
            }
        """
    }

    @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"