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)

# 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
    }
    

    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
  // ------------------------------------

    def "can read from stream and then restart to use another stream"() {
        def input1 = encoded("string 1")
        def input2 = encoded("string 2")

        given:
        def decoder = new KryoBackedDecoder(input1)
        decoder.readString()
        decoder.restart(input2)

        expect:
        decoder.readPosition == 0
        decoder.readString() == "string 2"

        return new AbstractModelAction<T>(reference, descriptor, input1, input2) {
            @Override
            public void execute(MutableModelNode modelNode, List<ModelView<?>> inputs) {
                action.execute(modelNode,
                    Cast.<I>uncheckedCast(inputs.get(0).getInstance()),
                    Cast.<J>uncheckedCast(inputs.get(1).getInstance())
                );
            }
        };
    }

// CHECK-LABEL: @main_stream_0
// CHECK-SAME: ([[input0:%.*]]: !tf_mlrt.tensor, [[promise_b:%.*]]: !mlrt.promise)
func.func @main_stream_0(%input0: tensor<i32>, %promise_b: !mlrt.promise) {
  %const = "tf.Const"() {__op_key = 0 : i32, value = dense<1> : tensor<i32>} : () -> tensor<i32>
  // CHECK: [[a:%.*]] = tf_mlrt.executeop([[input0]],
  // CHECK-SAME: AddV2

    }

    private static String customTaskCode(String input1, String input2) {
        """
            ${customTaskImpl()}
            task customTask(type: CustomTask){
                input1 = '$input1'
                input2 = '$input2'
            }
        """
    }

    private static String customTaskImpl() {
        """