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:

    }

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

    private static String customTaskImpl() {
        """

        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())
                );
            }
        };
    }

      (BinaryOp (TFL_ReshapeOp:$lhs $input1, (Arith_ConstantOp:$shape1 $s1)),
                (TFL_ReshapeOp:$rhs $input2, (Arith_ConstantOp:$shape2 $s2))),
      (TFL_ReshapeOp (BinaryOp $input1, $input2), $shape1),
      [(IsTailOfShape $rhs, $lhs),
       (IsTailOfShape $lhs, $rhs),
       (IsTailOfShape $input1, $input2),
       (IsTailOfShape $input2, $input1),
       (SameElementType $input1, $input2)]>;

        then:
        ruleAction.inputTypes == []
        closureCalled == "it"

        when:
        ruleAction = ruleActionAdapter.createFromClosure(String, { String s, String input1, Integer input2 -> closureCalled = input1 + input2 })
        ruleAction.execute("", ["foo", 3])

        then:
        ruleAction.inputTypes == [String, Integer]
        closureCalled == "foo3"
    }

    def "can adapt from action" () {

  // CHECK: %[[INPUT0:.*]] = "tf.Placeholder.input"
  %0 = "tf.Placeholder.input"(%arg0) : (tensor<f32>) -> tensor<f32>
  // CHECK: %[[INPUT1:.*]] = "tf.Placeholder.input"
  %1 = "tf.Placeholder.input"(%arg1) : (tensor<f32>) -> tensor<f32>
  %2 = arith.constant dense<true> : tensor<i1>

  // CHECK: "tf.Multiply"(%[[INPUT1]], %[[INPUT0]])

    %0 = func.call @func_0_CPU_QUANTIZED_INT8(%arg0, %arg1, %arg2) {tac.device = "CPU", tac.inference_type = "QUANTIZED_INT8", tac.interface_name = "func_0"} : (tensor<100x!quant.uniform<i8:f32, 2.000000e-01:-3>>,...

}

// -----

// Check number of replicated inputs is evenly divisible by 'n'.
func.func @verifier_replicate_bad_operandSegmentSizes(%arg0: tensor<*xi32>) {
  "tf_device.replicate" (%arg0, %arg0, %arg0, %arg0) ({
// expected-error@-1 {{'tf_device.replicate' op expects number of replicated inputs (4) to be evenly divisible by 'n' (3)}}
  ^entry(%input0: tensor<*xi32>, %input1: tensor<*xi32>):
    tf_device.return

// CHECK-NEXT:    name: "min_runtime_version",
// CHECK-NEXT:    buffer: 6
// CHECK-NEXT:  } ],
// CHECK-NEXT:  signature_defs: [ {
// CHECK-NEXT:    inputs: [ {
// CHECK-NEXT:      name: "input1",
// CHECK-NEXT:      tensor_index: 1
// CHECK-NEXT:    }, {
// CHECK-NEXT:      name: "input2"
// CHECK-NEXT:    } ],
// CHECK-NEXT:    outputs: [ {
// CHECK-NEXT:      name: "end_logits",
// CHECK-NEXT:      tensor_index: 4

// CHECK-NEXT:    } ],
// CHECK-NEXT:    inputs: [ 0, 1 ],
// CHECK-NEXT:    outputs: [ 6, 5 ],
// CHECK-NEXT:    operators: [ {
// CHECK-NEXT:      inputs: [ 0, 3, 2 ],
// CHECK-NEXT:      outputs: [ 5 ],
// CHECK-NEXT:      builtin_options_type: FullyConnectedOptions,
// CHECK-NEXT:      builtin_options: {
// CHECK-EMPTY:
// CHECK-NEXT:      }
// CHECK-NEXT:    }, {
// CHECK-NEXT:      inputs: [ 0, 4, 2 ],