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;

    /**
     * The type of output the report produces
     */
    enum OutputType {

        /**
         * The report outputs a single file.
         * <p>
         * That is, the {@link #getOutputLocation()} points to a single file.
         */
        FILE,

        /**
         * The report outputs files into a directory.
         * <p>

            class MyPlugin : Plugin<Project> {
                override fun apply(target: Project) {
                    target.tasks.register("myTask") { task ->
                        task.outputs.file("build/output.txt")
                        task.doLast(Action { println("Hello") })
                    }
                }
            }
        """

        buildFile << """
            plugins {

    for (auto input : forward_inputs_) {
      if (input) {
        input->Unref();
      }
    }
    for (auto output : forward_outputs_) {
      if (output) {
        output->Unref();
      }
    }
  }

 private:
  // TODO(b/174778737): Only hold needed inputs and outputs.
  vector<AbstractTensorHandle*> forward_inputs_;
  vector<AbstractTensorHandle*> forward_outputs_;
};

}  // namespace

                configurations { create("default") }
            }
            project(":producer") {
                task producer {
                    ext.output = objects.fileProperty()
                    outputs.file output
                    output.set(file("out"))
                }
                task longRunning {
                    dependsOn producer
                    doLast {

                classpath(sourceSets.main.output.classesDirs)
                mainClass = 'org.gradle.TestMain'
                args projectDir, testFile
                def output = new ByteArrayOutputStream()
                standardOutput = output
                doLast {
                    assert testFile.exists()

         *     <li>{@code NO-SOURCE} - executing the work was no necessary to produce the outputs</li>
         *     <li>{@code UP-TO-DATE} - the outputs have not changed, because the work is already up-to-date</li>
         *     <li>{@code FROM-CACHE} - the outputs have been loaded from the build cache</li>
         * </ul>
         */
        @Nullable
        String getSkipMessage();

                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    println "processing [\${input.name}]"
                    assert input.file
                    def output = outputs.file(input.name + ".green")
                    output.text = input.name + ".green"
                }
            }
        """

    ss << "\n\t" << it.first << " -> "
       << DataTypeString(it.second.imported_dtype) << " "
       << it.second.shape.DebugString();
  }
  ss << "\noutputs:";
  for (auto& output : outputs) ss << " " << output;
  ss << "\ncontrol_outputs:";
  for (auto& output : control_outputs) ss << " " << output;
  ss << "\nprune_unused_nodes: " << prune_unused_nodes;
  ss << "\nconvert_legacy_fed_inputs: " << convert_legacy_fed_inputs;

        commandLineExecution.execute(executionListener)

        then:
        outputs.stdErr.contains('--broken')
        outputs.stdErr.contains('USAGE: gradle [option...] [task...]')
        outputs.stdErr.contains('--help')
        outputs.stdErr.contains('--some-option')

        and: