test {
                inputs1 = files("input1.txt")
                inputs2 = files("input2.txt", "input3.txt")
            }
        """

        when:
        succeeds "test", "--info"

        then:
        executedAndNotSkipped ':test'
        outputContains "Input property 'inputs1' file ${file("input2.txt")} has been removed."

    }

    def "out-of-date when input file changes"() {
        given:
        def inputFile = file("input.txt")
        inputFile.text = "foo"
        buildFile << """
            ${keyInfo.addAsPropertiesScript()}
            signing {
                ${signingConfiguration()}
            }
            task signCustomFile(type: Sign) {
                sign(file("input.txt"))
            }
        """

TEST(OpsTest, TestBasicOpRegistration) {
  TF_OpDefinitionBuilder* builder = TF_NewOpDefinitionBuilder("SomeOp");
  TF_OpDefinitionBuilderAddAttr(builder, "attr1: string");
  TF_OpDefinitionBuilderAddInput(builder, "input1: uint8");
  TF_OpDefinitionBuilderAddInput(builder, "input2: uint16");
  TF_OpDefinitionBuilderAddOutput(builder, "output1: uint32");
  TF_Status* status = TF_NewStatus();
  TF_RegisterOpDefinition(builder, status);

node {
  name: "replicated_input_0"
  op: "Identity"
  input: "input0"
  input: "^TPUReplicateMetadata"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "_tpu_replicate"
    value {
      s: "cluster"
    }
  }
}
node {
  name: "replicated_input_1"
  op: "Identity"
  input: "input1"
  input: "^TPUReplicateMetadata"
  attr {
    key: "T"

  func.return %2 : tensor<3x2xf32>
}

// -----

// CHECK-LABEL: func @uniform_quantized_add_bias_not_const
func.func @uniform_quantized_add_bias_not_const(%input1: tensor<3x2xi32>, %input2: tensor<2xi32>) -> tensor<3x2xi32> {
  %input_scales = "tf.Const"() { value = dense<2.0> : tensor<f32> } : () -> tensor<f32>
  %input_zps = "tf.Const"() { value = dense<4> : tensor<i32> } : () -> tensor<i32>

	// the SPIFFE bundle endpoints.
	serverCerts := []*x509.Certificate{s1.Certificate(), s2.Certificate()}

	input1 := map[string]string{
		"foo": s1.Listener.Addr().String(),
	}
	// This simulates the case when there are multiple different servers to talk to.
	input2 := map[string]string{
		"foo": s1.Listener.Addr().String(),
		"bar": s2.Listener.Addr().String(),
	}

	cases := []struct {

        file("input.txt").createNewFile()
        file("input-nested.txt").createNewFile()
        file("input1.txt").createNewFile()
        file("input2.txt").createNewFile()
        file("inputs").createDir()
        file("inputs/inputA.txt").createNewFile()
        file("inputs/inputB.txt").createNewFile()
        file("inputs1").createDir()
        file("inputs2").createDir()

        buildFile """

        where:
        inputAnnotation   | inputType             | inputPath         | inputToPrint
        "@InputDirectory" | "DirectoryProperty"   | "input"           | "getInput().file('input.txt').get().asFile.text"
        "@InputFile"      | "RegularFileProperty" | "input/input.txt" | "getInput().get().asFile.text"
    }

    }

    def "can increase the quiet period"() {
        given:
        inputDir.createDir("input1")
        inputDir.createDir("input2")
        def inputFile1 = inputDir.file("input1/input.txt")
        def inputFile2 = inputDir.file("input2/input.txt")

        when:
        succeeds("theTask", "-D${StartParameterBuildOptions.ContinuousBuildQuietPeriodOption.PROPERTY_NAME}=5000")

  TFE_DeleteContextOptions(opts);

  TFE_TensorHandle* input1 = TestMatrixTensorHandle(ctx);
  TFE_TensorHandle* input2 = TestMatrixTensorHandle(ctx);
  TFE_Op* identityOp = TFE_NewOp(ctx, "IdentityN", status);
  CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
  TFE_TensorHandle* inputs[] = {input1, input2};
  TFE_OpAddInputList(identityOp, inputs, 2, status);
  CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);