}
                }
            }
        """

        when:
        succeeds "tasks", "--all"

        then:
        output.contains "a - task a"
        output.contains "b - task b"
        output.contains "c - task c"
    }

    def "can use rule DSL to configure task using another task as input"() {
        given:
        buildFile << '''
            model {

    }

    SearchResult<GccMetadata> output(String outputStr, GccCompilerType compilerType = GCC) {
        output(outputStr, "", compilerType)
    }

    SearchResult<GccMetadata> output(String output, String error, GccCompilerType compilerType = GCC, List<File> path = []) {
        runsCompiler(output, error)
        def provider = new GccMetadataProvider(execActionFactory, compilerType)

        given:
        buildScript simpleBuildWithTestSuites()

        when:
        run 'dependentComponents'

        then:
        !output.contains('utilTest')
        !output.contains('libTest')
        !output.contains('(t) - Test suite binary')
        output.contains 'Some test suites were not shown, use --test-suites or --all to show them.'
    }

    def "displays dependent test suites when using #option"() {

        """

        then:
        succeeds("myTask")
        output.contains "value: original"
        output.contains "reuse: false"

        when:
        waitBeforeModification(markerFile)
        markerFile.text = "changed"

        then:
        buildTriggeredAndSucceeded()
        output.contains "value: changed"
        output.contains "reuse: true"

    }

       .Input("inputs: N * T")
       .Output("output: T")
       .Output("value_index: int32")

    For example:
      %2 = tf_executor.Merge %0, %1, %2, %3 : tensor<*xf32>

    Note: Additional result corresponds to the control output.
  }];

  let arguments = (ins
    Variadic<AnyType>:$inputs_and_control
  );

  let results = (outs
    AnyTensor:$output,
    TensorOf<[I32]>:$value_index,

            println "src dir 1: " + srcDir.get()
            println "output dir 1: " + outputDir.get()
            buildDir = "output/some-dir"
            childDirName = "other-child"
            println "src dir 2: " + srcDir.get()
            println "output dir 2: " + outputDir.get()
"""

        when:
        run()

        then:

        run("notUpToDate")

        then:
        output.count("EVENT:") == 1
        outputContains("EVENT: finish :notUpToDate OK")

        when:
        run("notUpToDate")

        then:
        output.count("EVENT:") == 1
        outputContains("EVENT: finish :notUpToDate OK")

        when:
        fails("broken")

        then:
        output.count("EVENT:") == 3

}
"""

        when:
        run ":dependencies"

        then:
        output.contains """
compile
\\--- project :c
     \\--- project :a
          +--- project :b
          |    \\--- project :c (*)
          \\--- project :c (*)
"""

        adapter.output('1.1.2', grrr)

        then:
        1 * listener.output({ it instanceof DecoratingTestDescriptor && it.id == '1.1' }, woof)
        1 * listener.output({ it instanceof DecoratingTestDescriptor && it.id == '1' }, woof)
        1 * listener.output({ it instanceof UnknownTestDescriptor }, grrr)
        0 * listener.output(_, _)
    }

			}
			ui.PrintErr("Generating report in ", tempFile.Name())
			output = tempFile
		}
		_, err := io.Copy(output, input)
		return err
	}
}

func invokeDot(format string) PostProcessor {
	return func(input io.Reader, output io.Writer, ui plugin.UI) error {
		cmd := exec.Command("dot", "-T"+format)
		cmd.Stdin, cmd.Stdout, cmd.Stderr = input, output, os.Stderr
		if err := cmd.Run(); err != nil {