// Pre-actions before adding quantization logics. It creates a function with the
// func_name where input_val is an input and result_type is a result.
func::FuncOp PrepareFunctionRegister(PatternRewriter& rewriter, Value input_val,
                                     ShapedType result_type,
                                     StringRef func_name,
                                     Value& func_input_arg) {

Attribute ConstFoldBroadcastInDim(ShapedType result_type,
                                  DenseElementsAttr operand,
                                  DenseIntElementsAttr bcast_dims) {
  auto dimensions = llvm::to_vector(bcast_dims.getValues<int64_t>());
  const auto result_shape = result_type.getShape();
  // Index for the broadcasted matrix.
  llvm::SmallVector<int64_t, 16> current_index(result_type.getRank(), 0);

    }

    public DefaultTestResult(ResultType resultType, long startTime, long endTime, long testCount, long successfulCount, long failedCount, List<TestFailure> failures) {
        this.resultType = resultType;
        this.startTime = startTime;
        this.endTime = endTime;
        this.testCount = testCount;
        this.successfulCount = successfulCount;
        this.failedCount = failedCount;

    private final TestResult.ResultType resultType;

    @UsedByScanPlugin("test-distribution")
    public TestCompleteEvent(long endTime) {
        this(endTime, null);
    }

    @UsedByScanPlugin("test-distribution")
    public TestCompleteEvent(long endTime, TestResult.ResultType resultType) {
        this.endTime = endTime;
        this.resultType = resultType;
    }

    public long getEndTime() {

        1 * processor.completed(2, { it.resultType == SKIPPED })
        1 * processor.started({ it.id == 3 && it.name == "ignored" && it.className == AnIgnoredTestClass.name }, { it.parentId == 1 })
        1 * processor.completed(3, { it.resultType == SKIPPED })
        1 * processor.completed(1, { it.resultType == null })
        0 * processor._
    }

                        TestResult.ResultType resultType = TestResult.ResultType.SUCCESS;
                        boolean failed = status.contains("failed at");
                        if (failed) {
                            resultType = TestResult.ResultType.FAILURE;
                        }

        this.displayName = displayName;
    }

    public TestMethodResult(long id, String name, TestResult.ResultType resultType, long duration, long endTime) {
        this(id, name, name, resultType, duration, endTime);
    }

    public TestMethodResult(long id, String name, String displayName, TestResult.ResultType resultType, long duration, long endTime) {
        if (id < 1) {
            throw new IllegalArgumentException("id must be > 0");

        then: 1 * processor.completed(3, { it.resultType == ResultType.FAILURE })

        then: 1 * processor.started({ it.name == 'test' && it.className == ATestNGClassWithBrokenSetupMethod.name }, _)
        then: 1 * processor.completed(4, { it.resultType == ResultType.SKIPPED})

        then: 1 * processor.completed(2, { it.resultType == null})
        then: 1 * processor.completed(1, { it.resultType == null})

        0 * processor._

        readMethod1.name == 'method1'
        readMethod1.resultType == TestResult.ResultType.SUCCESS
        readMethod1.duration == 100
        readMethod1.endTime == 2300
        readMethod1.failures.empty

        def readMethod2 = readClass1.results[1]
        readMethod2.name == 'method2'
        readMethod2.resultType == TestResult.ResultType.FAILURE
        readMethod2.duration == 200
        readMethod2.endTime == 2700

        shape_data.push_back(it.getSExtValue());
      }
      result_type =
          RankedTensorType::get(shape_data, input_type.getElementType());
    }
    auto values_type = RankedTensorType::get(
        result_type.getShape(),
        mlir::cast<quant::UniformQuantizedType>(result_type.getElementType())
            .getStorageType());