def initValue = inputType.contains("Map<") ? "[:]" : "[]"
        def inputDeclaration = "$inputType input = $initValue"
        groovyBuildFile(inputDeclaration, inputValue, operation)

        expect:
        runAndAssert("myTask", expectedResult)

        where:

                            const llvm::SmallVectorImpl<Attribute>& input_types,
                            llvm::SmallVectorImpl<Value>& input_values) const {
    if (input_types.size() <= 1) return;

    Type target_input_type = mlir::cast<TypeAttr>(input_types[0]).getValue();
    auto result_type = UnrankedTensorType::get(target_input_type);
    for (auto i = 1; i < input_types.size(); ++i) {

    ArrayRef<int64_t> shape = arg_shapes[i];
    Type element_type;
    if (auto input_ty =
            mlir::dyn_cast<RankedTensorType>(func_type.getInput(i))) {
      if (input_ty.getRank() != shape.size()) {
        return failure();
      }
      element_type = input_ty.getElementType();
    } else {
      auto unranked_input_ty =

        File input = getInput().get().getAsFile();
        InstrumentationInputType inputType = getInputType(input);
        switch (inputType) {
            case DEPENDENCY_ANALYSIS_DATA:
                doOutputTransformedFile(input, outputs);
                return;
            case ORIGINAL_ARTIFACT:

        ruleAction.execute("string", [])

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

        when:
        ruleAction = ruleActionAdapter.createFromClosure(String, { s -> closureCalled = s })
        ruleAction.execute("object", [])

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

        when:

    private final List<Class<?>> inputTypes;

    public ClosureBackedRuleAction(Class<T> subjectType, Closure<?> closure) {
        this.subjectType = subjectType;
        this.closure = closure;
        this.inputTypes = parseInputTypes(closure);
    }

    @Override
    public List<Class<?>> getInputTypes() {
        return inputTypes;
    }

    @Override

        File input = getInput().get().getAsFile();
        InstrumentationInputType inputType = getInputType(input);
        switch (inputType) {
            case DEPENDENCY_ANALYSIS_DATA:
                doMergeAndOutputAnalysis(input, outputs);
                return;
            case ORIGINAL_ARTIFACT:

  for (auto input : llvm::zip(getOperandTypes(), getInputSpecs())) {
    Type inputType = std::get<0>(input);
    Attribute inputSpec = std::get<1>(input);
    if (!isValidQuantizationSpec(inputSpec, inputType)) {
      return emitOpError() << "has incompatible specification " << inputSpec
                           << " and input type " << inputType;
    }
  }

  for (auto result : llvm::zip(getResultTypes(), getOutputSpecs())) {

  for (auto input : llvm::zip(getOperandTypes(), getInputSpecs())) {
    Type inputType = std::get<0>(input);
    Attribute inputSpec = std::get<1>(input);
    if (!isValidQuantizationSpec(inputSpec, inputType)) {
      return emitOpError() << "has incompatible specification " << inputSpec
                           << " and input type " << inputType;
    }
  }

  for (auto result : llvm::zip(getResultTypes(), getOutputSpecs())) {

  }

  std::vector<Value> inputs;
  std::vector<Value> outputs;
  computeInputsOutputs(ops, &inputs, &outputs);

  std::vector<Type> input_types;
  std::vector<Type> output_types;

  input_types.reserve(inputs.size());
  for (Value v : inputs) {
    input_types.push_back(v.getType());
  }
  output_types.reserve(outputs.size());
  for (Value v : outputs) {
    output_types.push_back(v.getType());
  }