import org.gradle.reporting.ReportRenderer;
import org.gradle.util.internal.GFileUtils;

import java.io.File;
import java.io.IOException;
import java.util.List;

import static org.gradle.api.tasks.testing.TestResult.ResultType.SKIPPED;

public class DefaultTestReport implements TestReporter {
    private final BuildOperationRunner buildOperationRunner;
    private final BuildOperationExecutor buildOperationExecutor;

    }

    static TestStartEvent createTestStartEvent() {
        new TestStartEvent(new Date().time)
    }

    static TestResult createTestResult() {
        new DefaultTestResult(TestResult.ResultType.SUCCESS, new Date().time, new Date().time, 2L, 2L, 0L, [])
    }

    static TestCompleteEvent createTestCompleteEvent() {
        new TestCompleteEvent(new Date().time)
    }

    TfeControlType:$control
  );

  let builders = [
    OpBuilder<(ins "Type":$result_type,
      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
    [{
      Type token_type = TokenType::get($_builder.getContext());
      Type control_type = ControlType::get($_builder.getContext());
      $_state.types = { result_type, token_type, control_type };
      $_state.attributes.append(attributes.begin(), attributes.end());

}  // namespace internal
}  // namespace testing

#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
  ::testing::internal::AssertHelper(result_type, file, line, message) \
    = ::testing::Message()

#define GTEST_MESSAGE_(message, result_type) \
  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)

#define GTEST_FATAL_FAILURE_(message) \

      output_types.reserve(op_with_region->getNumResults());
      for (const Value result : op_with_region->getResults()) {
        const Type result_type = result.getType();
        if (mlir::isa<NoneType>(result_type)) {
          outputs_replaced.push_back(result);
          output_types.push_back(result_type);
          continue;
        }
        const Type result_element_type =

    // Sometimes the result type is more specific than what the reshape builder
    // can infer.
    auto result_type = op.getResult().getType();
    rewriter.replaceOpWithNewOp<ReshapeOp>(op, result_type, permuted,
                                           output_shape);

    return success();
  }
};

class LowerBatchToSpaceND : public RewritePattern {

        quant_type = quant::DownCastScale(quant_type, min, max, op.getLoc());
      }
    }
    rewriter.setInsertionPointAfter(stats_op);
    Type result_type = quant_type.castFromExpressedType(stats_op.getType());
    auto q =
        rewriter.create<Q>(stats_op.getLoc(), result_type, stats_op.getArg());
    rewriter.replaceOpWithNewOp<DQ>(stats_op, stats_op.getType(), q);
    return success();
  }
};

}  // namespace internal
}  // namespace testing

#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
  ::testing::internal::AssertHelper(result_type, file, line, message) \
    = ::testing::Message()

#define GTEST_MESSAGE_(message, result_type) \
  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)

#define GTEST_FATAL_FAILURE_(message) \

  for (auto it : llvm::zip(op.getResultTypes(), updated_results)) {
    auto& updated_result = std::get<1>(it);
    Type result_type = std::get<0>(it);
    if (result_type != updated_result.getType()) {
      updated_result =
          rewriter.create<TF::CastOp>(op.getLoc(), result_type, updated_result,
                                      /*Truncate=*/rewriter.getBoolAttr(false));
    }
  }

                return new TypedRecord<D, R>(
                    descriptor,
                    BuildOperationTypes.detailsType(buildOperationType).cast(descriptor.getDetails()),
                    BuildOperationTypes.resultType(buildOperationType).cast(result),
                    failure
                );
            }

        }

        public static class TypedRecord<D, R> {