if (op->getNumOperands() != 2 || op->getResultTypes().size() != 1)
    return failure();

  // Check that the result shape is fully defined.
  auto result_type =
      mlir::dyn_cast_or_null<RankedTensorType>(op->getResultTypes().front());
  if (!result_type || !result_type.hasStaticShape()) return failure();

  bool changed = false;
  for (uint64_t i = 0, e = op->getNumOperands(); i < e; ++i) {

    auto const_type = mlir::dyn_cast<ShapedType>(op.getOperand(0).getType());
    auto result_type = mlir::dyn_cast<ShapedType>(op.getResult().getType());
    if (!const_type || !const_type.getElementType().isSignlessInteger(4) ||
        !result_type || !result_type.getElementType().isSignlessInteger(8)) {
      return failure();
    }

    auto input_op =

public class BaseCrossBuildResultsStore<R extends CrossBuildPerformanceResults> extends AbstractWritableResultsStore<R> {

    private final String resultType;

    public BaseCrossBuildResultsStore(String resultType) {
        super(new PerformanceDatabase("cross_build_results"));
        this.resultType = resultType;
    }

    @Override
    public void report(final R results) {

        !mlir::isa<TensorType>(input.getType()))
      return nullptr;
    return builder.create<TF::CastOp>(conversion_loc, result_type, input,
                                      /*truncate=*/builder.getBoolAttr(false));
  }
};

// Checks if a block wraps a single operation and the single operation results
// are perfectly forwarded to the block's terminator.
bool BlockWrapsSingleOp(Block* block) {

   public:
    QuantizedType GetResultQuantizedType(int index) {
      auto op = this->getOperation();
      const auto result_type =
          op->getResult(index).getType().template cast<ShapedType>();
      if (!result_type.getElementType().template isa<FloatType>()) return {};
      Builder builder(op->getContext());
      const IntegerType storage_type = builder.getIntegerType(BitWidth);

        result.add(new TestMethodResult(2, "fail").completed(new DefaultTestResult(TestResult.ResultType.FAILURE, 250, 300, 1, 0, 1, [new RuntimeException("bar")])))
        result.add(new TestMethodResult(3, "fail2").completed(new DefaultTestResult(TestResult.ResultType.FAILURE, 300, 450, 1, 0, 1, [new RuntimeException("foo")])))

        then:

        results.addTest(test())

        expect:
        results.resultType == SUCCESS;
    }

    def computesResultTypeWhenSuccessAndIgnored() {
        results.addTest(test())
        results.addTest(test())
        results.ignored(test())

        expect:
        results.resultType == SKIPPED;
    }

    def computesResultTypeWhenSuccessAndIgnoredAndFailed() {

        return ignored;
    }

    @Override
    public ResultType getResultType() {
        if (!failures.isEmpty()) {
            return ResultType.FAILURE;
        }
        if (getIgnoredCount() > 0) {
            return ResultType.SKIPPED;
        }
        return ResultType.SUCCESS;
    }

    public String getFormattedSuccessRate() {

  auto result_type =
      OpTrait::util::getBroadcastedType(x.getType(), y.getType());
  if (!result_type) {
    if (incompatible_shape_error.getValue()) {
      mlir::emitError(loc, "non-broadcastable operands");
    } else {
      return UnrankedTensorType::get(builder->getI1Type());
    }
  }

  auto ranked_type = mlir::dyn_cast<RankedTensorType>(result_type);

package org.gradle.api.internal.tasks.testing

import org.gradle.api.tasks.testing.TestFailure
import org.gradle.api.tasks.testing.TestResult

class SimpleTestResult implements TestResult {
    TestResult.ResultType resultType = TestResult.ResultType.SUCCESS
    List<Throwable> exceptions = []
    Throwable exception = exceptions[0]
    List<TestFailure> failures
    long startTime = 0
    long endTime = startTime + 100
    long testCount = 1