void theRule(List subject, String input1, Integer input2, Set input3) {
            subject.add(input1)
            subject.add(input2)
            subject.addAll(input3)
        }
    }

    static class ArrayListRuleSource {
        @Mutate
        void theRule(ArrayList subject, String input1, Integer input2, Set input3) {
            subject.add(input1)
            subject.add(input2)
            subject.addAll(input3)

  func.func @add(%arg0: tensor<?xf32> {tf_saved_model.index_path = ["input1"]}, %arg1: tensor<?xf32> {tf_saved_model.index_path = ["input2"]}) -> (tensor<?xf32> {tf_saved_model.index_path = ["result"]}) attributes {tf.entry_function = {control_outputs = "", inputs = "input1:0,input2:0", outputs = "result:0"}, tf_saved_model.exported_names = ["add"]} {

# RUN: tf_tfl_translate -tf-input-arrays=input0,input1 \
# RUN:                  -tf-input-shapes=4:4 \
# RUN:                  -tf-input-data-types=DT_FLOAT,DT_FLOAT \
# RUN:                  -tf-output-arrays=Add \
# RUN:                  -tf-inference-type=DT_QUINT8 \
# RUN:                  -tf-input-min-values='-2,-3' \
# RUN:                  -tf-input-max-values='2,3' \
# RUN:                  --quant-stats=%s.stats \

        connection.queueIncoming(input1)
        connection.queueIncoming(input2)
        connection.queueIncoming(closeInput)
        received.await()
        daemonConnection.stop()

        then:
        1 * handler.onInput(input1)
        1 * handler.onInput(input2)
        1 * handler.onEndOfInput() >> { received.countDown() }
        0 * handler._
    }

        
        input2 = getResourceFile("2.txt")
        output2 = signing.signatureType.fileFor(input2)
        input2Artifact = new DefaultPublishArtifact(input2.name, "Text File", "txt", null, null, input2)
        
        [output1, output2].each { output ->
            assert !output.exists() || output.delete()
        }
        
        assert input1.text && input2.text  // don't care what it is, just need some
    }
    

# RUN: tf_tfl_translate -tf-input-arrays=input0,input1 -tf-input-shapes=4:4 -tf-input-data-types=DT_INT32,DT_INT32 -tf-output-arrays=Add %s -o - | flatbuffer_to_string - | FileCheck %s

# Add two tensor<4xi32> inputs and return the result

node {
  name: "Add"
  op: "Add"
  input: "input0"
  input: "input1"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
}
node {
  name: "input0"
  op: "Placeholder"
  attr {

        0 * calculated._
    }

    def "notifies each of the inputs of task start and complete"() {
        def input1 = Mock(LifecycleAwareValue)
        def input2 = "other"
        def input3 = Mock(LifecycleAwareValue)
        def fileCollection = new CalculatedTaskInputFileCollection(taskDependencyFactory, ":task", Stub(MinimalFileSet), input1, input2, input3)

        when:
        fileCollection.prepareValue()

}

// CHECK:      node {
// CHECK-NEXT:   name: "input0"
// CHECK-NEXT:   op: "_Arg"
// CHECK:      node {
// CHECK-NEXT:   name: "input1"
// CHECK-NEXT:   op: "_Arg"
// CHECK:      node {
// CHECK-NEXT:   name: "Add{{_.*_1}}"
// CHECK-NEXT:   op: "Add"
// CHECK-NEXT:   input: "input0"
// CHECK-NEXT:   input: "input1"
// CHECK:      node {
// CHECK-NEXT:   name: "Add"
// CHECK-NEXT:   op: "_Retval"

    def setup() {
        INVOCATION_COUNT.set(0)
    }

    def "input artifact selection is restored when using the in-memory cache"() {
        def transform = registerTransform(IdentityTransform)

        def inputArtifact1 = file("input1/input.txt")
        inputArtifact1.text = "Hello"

        def inputArtifact2 = file("input2/input.txt")
        inputArtifact2.text = "Hello"

        expect:

  Init(2);
  // Create nested loop:
  //  while (input1 < 6) {
  //    inner_input1 = input1
  //    while (inner_input1 < 3) {
  //      input2 += 1
  //      inner_input1 += 2
  //    }
  //    input1 += input2
  //  }
  //
  // Expected execution with initial values input1 = input2 = 0:
  //
  // outer inner               inner_
  // step# step# input1 input2 input1
  // ------------------------------------