// Extract the resulting tensor.
    add_output2 = TF_OutputListGet(add_outputs, 0);
    TF_DeleteOutputList(add_outputs);
  }

  // 3rd Output will be Matrix Multiplication of add_output1 and add_output2
  TF_AbstractTensor* mm_output;
  {
    // Build an abstract operation, inputs and output.
    auto* mm_op = TF_NewAbstractOp(graph_ctx);
    TF_AbstractOpSetOpType(mm_op, "MatMul", s);

  }
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> inputs) {
    fbb_.AddOffset(Operator::VT_INPUTS, inputs);
  }
  void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> outputs) {
    fbb_.AddOffset(Operator::VT_OUTPUTS, outputs);
  }
  void add_builtin_options_type(tflite::BuiltinOptions builtin_options_type) {

    auto signature_key_buf =
        builder_.CreateString(signature_def_data.signature_key);
    tflite::SignatureDefBuilder sig_def_builder(builder_);
    sig_def_builder.add_inputs(inputs_buf);
    sig_def_builder.add_outputs(outputs_buf);
    sig_def_builder.add_signature_key(signature_key_buf);
    sig_def_builder.add_subgraph_index(signature_def_data.subgraph_index);
    signature_defs_buffer.push_back(sig_def_builder.Finish());

        def builder = TransformExecutionResult.builderFor(inputArtifact, outputDir)
        for (File file in files) {
            builder.addOutput(file) {}
        }
        return builder.build()
    }

    TestFile file(String path) {
        temporaryFolder.file(path)
    }

        GroupedTaskOutputFixture task = tasks.get(taskName);
        if (task == null) {
            task = new GroupedTaskOutputFixture(taskName);
            tasks.put(taskName, task);
        }

        task.addOutput(taskOutput);
        task.setOutcome(taskOutcome);
    }

    private void consumeTransformOutput(Matcher matcher) {
        String initialSubjectType = matcher.group(1);
        String subject = matcher.group(2);

import static org.gradle.util.internal.CollectionUtils.join;

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(""));

 */
public abstract class GroupedWorkOutputFixture {

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

    /**
     * Adds an output entry to the group.
     */
    public void addOutput(String output) {
        outputs.add(output);
    }

    /**
     * Returns concatenated non-empty output entries.
     */
    public String getOutput() {

        return outputFile;
    }

    private File resolveAndRegister(Object path, Consumer<File> prepareOutputLocation) {
        File output = resolver.resolve(path);
        resultBuilder.addOutput(output, prepareOutputLocation);
        return output;
    }

    private static void validateOutputExists(File outputDir, File output) {
        if (!output.exists()) {

        /**
         * Adds an output location to the result.
         *
         * @param workspaceAction an action to run when the output is a produced output in the workspace.
         */
        public void addOutput(File output, Consumer<File> workspaceAction) {
            if (output.equals(inputArtifact)) {
                delegate.addEntireInputArtifact();
            } else if (output.equals(outputDir)) {