Function main

testing/testrunner/runner_bin.cc:224–295

}  // namespace

int main(int argc, char** argv) {
  testing::InitGoogleTest(&argc, argv);
  // Create a test context using the factory function returned by the global
  // factory function provider which was initialized by the user.
  absl::StatusOr<std::unique_ptr<cel::test::CelTestContext>>
      cel_test_context_or = cel::test::internal::GetCelTestContextFactory()();
  if (!cel_test_context_or.ok()) {
    ABSL_LOG(FATAL) << "Failed to create CEL test context from factory: "
                    << cel_test_context_or.status();
  }
  std::unique_ptr<cel::test::CelTestContext> cel_test_context =
      std::move(cel_test_context_or.value());

  // We manually enable coverage here instead of just setting the
  // `enable_coverage` flag on the context. This is intentional and necessary
  // for this binary's reporting model.
  //
  // This binary needs a single coverage report for all tests run.
  // We create `coverage_index` here, local to the `main` function, so its
  // lifetime spans the entire test run.
  //
  // We must pass this specific instance to the
  // `CoverageReportingEnvironment`, which Google Test calls after all
  // dynamically registered tests are finished.
  //
  // If we just set the `enable_coverage` flag, the `TestRunner`'s
  // constructor (as used in our `cc_test` files) would create its own
  // internal `CoverageIndex`. That internal index would be destroyed
  // with the `TestRunner` and would not populate the `coverage_index`
  // instance needed by our global reporter.
  //
  // This manual approach ensures all tests populate the same `coverage_index`
  // (the one local to `main`), which is then ready for the final report.
  cel::test::CoverageIndex coverage_index;

  if (absl::GetFlag(FLAGS_collect_coverage)) {
    if (cel_test_context->runtime() != nullptr) {
      ABSL_CHECK_OK(cel::test::EnableCoverageInRuntime(
          const_cast<cel::Runtime&>(*cel_test_context->runtime()),
          coverage_index));
    } else if (cel_test_context->cel_expression_builder() != nullptr) {
      ABSL_CHECK_OK(cel::test::EnableCoverageInCelExpressionBuilder(
          const_cast<CelExpressionBuilder&>(
              *cel_test_context->cel_expression_builder()),
          coverage_index));
    }
  }

  // Update the context with an expression from flags, if provided.
  // This will FATAL if an expression is set by both the factory and flags.
  UpdateWithExpressionFromCommandLineFlags(*cel_test_context);

  auto test_runner = std::make_shared<TestRunner>(std::move(cel_test_context));
  ABSL_CHECK_OK(RegisterTests(GetTestSuite(), test_runner));

  // Make sure the checked expression exists during the entire test run since
  // the ast references it during coverage collection at teardown.
  absl::StatusOr<cel::expr::CheckedExpr> checked_expr =