}
                outputs.files files(fileList) withPropertyName("out")
                def output1 = project.file("build/output1.txt")
                def output2 = project.file("build/output2.txt")
                doLast {
                    output1.parentFile.mkdirs()
                    output1 << "data"
                    if (!System.getProperty("changedCardinality")) {

    }

    private static String[] customTaskWithOutputs(List<String> outputs) {
        (["customTask", "-PnumOutputs=${outputs.size()}"] + outputs.withIndex().collect { value, idx -> "-Poutput${idx}" + (value ? "=${value}" : '') }) as String[]
    }

    def "output files moved from one location to another marks task up-to-date"() {
        buildFile << """

                @InputFiles def inputFiles = project.layout.files()

                @OutputDirectory File outputs1
                @OutputDirectory File outputs2

                @TaskAction void action() {
                    new File(outputs1, "output1.txt").text = "output1"
                    new File(outputs2, "output2.txt").text = "output2"
                }
            }
        """

        buildFile << """

        output.contains 'Output: nested.outputFiles$2 [output-nested-2.txt]'
        output.contains 'Output: outputDirectories$1 [outputs1]'
        output.contains 'Output: outputDirectories$2 [outputs2]'
        output.contains "Output: outputDirectory [outputs]"
        output.contains "Output: outputFile [output.txt]"
        output.contains 'Output: outputFiles$1 [output1.txt]'

        createBuildScripts("""
            def customTask = tasks.register("myTask") {
                outputs.file("\${buildDir}/output.txt")
                outputs.file("\${buildDir}/output2.txt")
                doLast {
                    file("\${buildDir}/output.txt") << 'custom task'
                    file("\${buildDir}/output2.txt") << 'custom task'
                }

  // all the outputs of the main function are actually the final outputs.
  // main_func:
  //  %output1 = call @subgraph_1...
  //   ...
  //  %output2 = call @subgraph_m...
  //   ...
  //  %outputn = call @subgraph_k...
  //  return %output1, output2, ..., outputn.
  fn.walk([&](func::ReturnOp return_op) {
    for (auto output : return_op.getOperands()) {

   *
   *   A =[[0, 1],[1, 0]]
   *   B =[[1, 0],[0, 1]]
   *
   *   output1, output2, output3 = two_adds_and_mm(A, B)
   *
   * We expect outputs:
   *
   *   output1 = [[1, 1],[1, 1]]
   *   output2 = [[2, 0],[0, 2]]
   *   output3 = [[2, 2],[2, 2]]
   *
   */

  // Build eager context.
  TFE_ContextOptions* opts = TFE_NewContextOptions();

            file("build.gradle") << """
                task foo {
                    inputs.dir('src').ignoreEmptyDirectories(false).withPropertyName('src')
                    outputs.file('output.txt')
                    doLast {
                        file('output.txt') << 'do stuff'
                    }
                }
            """
            dir("src") {
                file("A.txt") << "fooA"

    # model and saving the output quantized model. These two member
    # attributes can be used to specify the paths for such models,
    # respectively. These paths will be cleaned up after each test case.
    self._input_saved_model_path = self.create_tempdir('input').full_path
    self._output_saved_model_path = self.create_tempdir('output').full_path
    # Extra output path occasionally used for comparing two different

                void myAction() {
                    def output = outputFile.get().asFile
                    output << launcher1.get().executablePath
                    output << launcher2.get().executablePath
                }
            }

            tasks.register("myToolchainTask", ToolchainTask) {
                outputFile = layout.buildDirectory.file("output.txt")
                launcher1 = javaToolchains.launcherFor {