def operation = signing.sign(input1, input2)
        
        then:
        output1.exists() && output2.exists()
        [input1, input2] == operation.filesToSign.files.toList()[0..1]
        [output1, output2] == operation.signatureFiles.files.toList()[0..1]
        [output1, output2] == operation.signatures*.file.toList()
    }

    def "sign multiple artifacts with defaults"() {
        when:

        outputContains(output3)

        where:
        expression                                                                                      | output1                     | output2                            | output3

        }
    }

    private void onlyTestClass1In(String output) {
        assert output.contains('TestClass1.testMethod')
        assert !output.contains('TestClass2.testMethod')
    }

    private void onlyTestClass2In(String output) {
        assert output.contains('TestClass2.testMethod')
        assert !output.contains('TestClass1.testMethod')
    }

        then:
        output1.toString().contains(ARG_1)
        output1.toString().contains(ARG_2)

        when:
        String output2 = runBuild { launcher -> launcher.addArguments(["-P$ARG_1" as String]).addArguments(["-P$ARG_2" as String]) }

        then:
        output2.toString().contains(ARG_1)

          ],
          "name": "output0",
          "quantization": {
          }
        },
        {
          "shape": [
            128,
            32,
            32,
            3
          ],
          "name": "output1",
          "quantization": {
          }
        }
      ],
      "inputs": [
        0,
        1
      ],
      "outputs": [
        2,
        3
      ],

        withWatchFs().run ":incremental", "-DoutputDir=output1"
        then:
        executedAndNotSkipped(":incremental")

        when:
        file("build/output2/overlapping.txt").text = "overlapping"
        waitForChangesToBePickedUp()
        withWatchFs().run ":incremental", "-DoutputDir=output2"
        then:
        executedAndNotSkipped(":incremental")
        file("build/output1").assertDoesNotExist()

        when:

                }
                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")) {

            hiddenNonBuildable = true;
            return;
        }
        StyledTextOutput output = builder.getOutput();
        GraphRenderer renderer = new GraphRenderer(output);
        renderer.visit(output1 -> {
            output1.withStyle(Identifier).text(component.getName());
            output1.withStyle(Description).text(" - Components that depend on " + component.getDisplayName());
        }, true);

            output->DebugString(100));
}

REGISTER_OP("AllocateOutputOp0").Output("output1: float");

TEST_F(DeviceKernelOpTest, TestAllocateEmptyOutput) {
  auto my_compute_func = [](void* kernel, TF_OpKernelContext* ctx) {
    TF_Status* s = TF_NewStatus();
    // Allocate empty output
    int64_t dim = 0;
    TF_Tensor* output = TF_AllocateOutput(

        setup:
        sampleBuildWithTest()

        when:
        String output1 = runTaskAndTestClassUsing(firstDebug)
        String output2 = runTaskAndTestClassUsing(secondDebug)

        then:
        assertTestDebugMode(output1, firstDebug)
        assertTestDebugMode(output2, secondDebug)

        where:
        scenarioName                     | firstDebug | secondDebug