// See https://github.com/gradle/gradle/issues/18460.
                LOGGER.debug("More outputs are being registered even though the build output cleanup registry has already been finalized. New outputs: {}", files);
            } else {
                this.outputs.add(fileCollectionFactory.resolving(files));
            }
        }
    }

    @Override

  /// `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;
    }

    /**

  TF_OpDefinitionBuilderAddInput(builder, "input1: uint8");
  TF_OpDefinitionBuilderAddInput(builder, "input2: uint32");
  TF_OpDefinitionBuilderAddOutput(builder, "output1: uint8");
  TF_OpDefinitionBuilderAddOutput(builder, "output2: uint8");
  TF_OpDefinitionBuilderSetShapeInferenceFunction(
      builder, &TF_ShapeInferenceContextSetUnknownShape);
  TF_Status* status = TF_NewStatus();

                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    println "processing \${input.name} using \${parameters.someFiles*.name}"
                    def output = outputs.file(input.name + ".green")
                    def paramContent = parameters.someFiles.collect { it.file ? it.text : it.list().length }.join("")
                    output.text = input.text + paramContent + ".green"

  Output live0 = ops::Add(root.WithOpName("live0"), m0.output, m1.output);
  Output live1 = ops::Add(root.WithOpName("live1"), m2.output, m3.output);

  Output halfdead0 =
      ops::Add(root.WithOpName("halfdead0"), m0.output, m2.output);
  Output halfdead1 =
      ops::Add(root.WithOpName("halfdead1"), m1.output, m3.output);

  std::unique_ptr<DeadnessAnalysis> result;

public class OutputSnapshotUtil {

    /**
     * Finds outputs that are still present since the last execution when overlapping outputs are present.
     *
     * Note: when there are no overlapping outputs, all outputs currently existing in the output locations
     * are considered outputs of the work.
     *
     * If a property did not exist after the previous execution then all the outputs for it will be ignored.
     *

                @Override
                void transform(TransformOutputs outputs) {
                    // Simulate transform leaving file open
                    def output = outputs.file("output.txt")
                    output.createNewFile()
                    TestState.fileKeptOpen = output.newOutputStream()
                    TestState.fileKeptOpen << "output"
                    TestState.fileKeptOpen.flush()
                }

        withBuildCache().run "compileJava", "--info"

        then:
        noneSkipped()
        output.contains("Build cache key for task ':compileJava' is ")
        !output.contains("Appending implementation to build cache key:")
        !output.contains("Appending input value fingerprint for")
        !output.contains("Appending input file fingerprints for 'classpath'")
    }

    // Note: when replication is supported, this op will have N outputs.
    .Output("outputs: T")
    .Attr("T: type")
    .SetShapeFn([](InferenceContext* c) {
      for (int i = 0; i < c->num_outputs(); ++i) {
        c->set_output(i, c->input(0));
      }
      return absl::OkStatus();
    })
    .Doc(
        "Operator that connects the output of an XLA computation to other "
        "consumer graph nodes.");