Setup of the coverage index.

eval/compiler/BUILD

@@ -5,6 +5,7 @@ DEFAULT_VISIBILITY = [
     "//eval:__subpackages__",
     "//runtime:__subpackages__",
     "//extensions:__subpackages__",
+    "//testing:__subpackages__",
 ]
 
 # This package contains code

testing/testrunner/BUILD

@@ -44,6 +44,8 @@ cc_library(
         "//internal:testing_no_main",
         "//runtime",
         "//runtime:activation",
+        "//tools:cel_unparser",
+        "//tools:navigable_ast",
         "@com_google_absl//absl/functional:overload",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
@@ -80,6 +82,7 @@ cc_test(
     deps = [
         ":cel_expression_source",
         ":cel_test_context",
+        ":coverage_index",
         ":runner_lib",
         "//checker:type_checker_builder",
         "//checker:validation_result",
@@ -115,14 +118,18 @@ cc_library(
     deps = [
         ":cel_test_context",
         ":cel_test_factories",
+        ":coverage_index",
         ":runner_lib",
+        "//eval/public:cel_expression",
         "//internal:testing_no_main",
+        "//runtime",
         "@com_google_absl//absl/flags:flag",
         "@com_google_absl//absl/log:absl_check",
         "@com_google_absl//absl/log:absl_log",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
+        "@com_google_absl//absl/strings:str_format",
         "@com_google_cel_spec//proto/cel/expr/conformance/test:suite_cc_proto",
         "@com_google_protobuf//:protobuf",
         "@com_google_protobuf//src/google/protobuf/io",
@@ -135,3 +142,27 @@ cc_library(
     hdrs = ["cel_expression_source.h"],
     deps = ["@com_google_cel_spec//proto/cel/expr:checked_cc_proto"],
 )
+
+cc_library(
+    name = "coverage_index",
+    srcs = ["coverage_index.cc"],
+    hdrs = ["coverage_index.h"],
+    deps = [
+        "//common:ast",
+        "//common:value",
+        "//eval/compiler:cel_expression_builder_flat_impl",
+        "//eval/compiler:instrumentation",
+        "//eval/public:cel_expression",
+        "//internal:casts",
+        "//runtime",
+        "//runtime/internal:runtime_impl",
+        "//tools:cel_unparser",
+        "//tools:navigable_ast",
+        "@com_google_absl//absl/base:nullability",
+        "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/status:statusor",
+        "@com_google_absl//absl/strings",
+        "@com_google_cel_spec//proto/cel/expr:syntax_cc_proto",
+    ],
+)

testing/testrunner/cel_cc_test.bzl

@@ -21,6 +21,7 @@ def cel_cc_test(
         test_suite = "",
         filegroup = "",
         deps = [],
+        enable_coverage = False,
         test_data_path = "",
         data = []):
     """trigger the cc impl of the CEL test runner.
@@ -36,6 +37,7 @@ def cel_cc_test(
           expression.
         deps: list of dependencies for the cc_test rule.
         data: list of data dependencies for the cc_test rule.
+        enable_coverage: bool whether to enable coverage collection.
         test_data_path: absolute path of the directory containing the test files. This is needed only
           if the test files are not located in the same directory as the BUILD file.
     """
@@ -48,6 +50,8 @@ def cel_cc_test(
         test_suite = test_data_path + "/" + test_suite
         args.append("--test_suite_path=" + test_suite)
 
+    args.append("--collect_coverage=" + str(enable_coverage))
+
     cc_test(
         name = name,
         data = data,

testing/testrunner/coverage_index.cc

@@ -0,0 +1,192 @@
+// Copyright 2025 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "testing/testrunner/coverage_index.h"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "cel/expr/syntax.pb.h"
+#include "absl/base/nullability.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "common/ast.h"
+#include "common/value.h"
+#include "eval/compiler/cel_expression_builder_flat_impl.h"
+#include "eval/compiler/instrumentation.h"
+#include "eval/public/cel_expression.h"
+#include "internal/casts.h"
+#include "runtime/internal/runtime_impl.h"
+#include "runtime/runtime.h"
+#include "tools/cel_unparser.h"
+#include "tools/navigable_ast.h"
+
+namespace cel::test {
+namespace {
+
+using ::cel::expr::CheckedExpr;
+using ::cel::expr::Type;
+using ::google::api::expr::runtime::CelExpressionBuilder;
+using ::google::api::expr::runtime::Instrumentation;
+using ::google::api::expr::runtime::InstrumentationFactory;
+
+const Type* absl_nullable FindCheckerType(const CheckedExpr& expr,
+                                          int64_t expr_id) {
+  if (auto it = expr.type_map().find(expr_id); it != expr.type_map().end()) {
+    return &it->second;
+  }
+  return nullptr;
+}
+
+bool InferredBooleanNode(const CheckedExpr& checked_expr,
+                         const NavigableProtoAstNode& node) {
+  int64_t node_id = node.expr()->id();
+  const auto* checker_type = FindCheckerType(checked_expr, node_id);
+  if (checker_type != nullptr) {
+    return checker_type->has_primitive() &&
+           checker_type->primitive() == Type::BOOL;
+  }
+
+  return false;
+}
+
+void TraverseAndCalculateCoverage(
+    const CheckedExpr& checked_expr, const NavigableProtoAstNode& node,
+    const absl::flat_hash_map<int64_t, CoverageIndex::NodeCoverageStats>&
+        stats_map,
+    bool log_unencountered, std::string preceeding_tabs,
+    CoverageIndex::CoverageReport& report) {
+  int64_t node_id = node.expr()->id();
+
+  const CoverageIndex::NodeCoverageStats& stats = stats_map.at(node_id);
+  report.nodes++;
+
+  absl::StatusOr<std::string> unparsed =
+      google::api::expr::Unparse(*node.expr());
+  std::string expr_text = unparsed.ok() ? *unparsed : "unparse_failed";
+
+  bool is_interesting_bool_node =
+      stats.is_boolean_node && !node.expr()->has_const_expr() &&
+      (!node.expr()->has_call_expr() ||
+       node.expr()->call_expr().function() != "cel.@block");
+
+  bool node_covered = stats.covered;
+  if (node_covered) {
+    report.covered_nodes++;
+  } else if (log_unencountered) {
+    if (is_interesting_bool_node) {
+      report.unencountered_nodes.push_back(
+          absl::StrCat("Expression ID ", node_id, " ('", expr_text, "')"));
+    }
+    log_unencountered = false;
+  }
+
+  if (is_interesting_bool_node) {
+    report.branches += 2;
+    if (stats.has_true_branch) {
+      report.covered_boolean_outcomes++;
+    } else if (log_unencountered) {
+      report.unencountered_branches.push_back(
+          absl::StrCat("\n", preceeding_tabs, "Expression ID ", node_id, " ('",
+                       expr_text, "'): Never evaluated to 'true'"));
+      preceeding_tabs += "\t\t";
+    }
+    if (stats.has_false_branch) {
+      report.covered_boolean_outcomes++;
+    } else if (log_unencountered) {
+      report.unencountered_branches.push_back(
+          absl::StrCat("\n", preceeding_tabs, "Expression ID ", node_id, " ('",
+                       expr_text, "'): Never evaluated to 'false'"));
+      preceeding_tabs += "\t\t";
+    }
+  }
+
+  for (const auto* child : node.children()) {
+    TraverseAndCalculateCoverage(checked_expr, *child, stats_map,
+                                 log_unencountered, preceeding_tabs, report);
+  }
+}
+
+}  // namespace
+
+void CoverageIndex::RecordCoverage(int64_t node_id, const cel::Value& value) {
+  NodeCoverageStats& stats = node_coverage_stats_[node_id];
+  stats.covered = true;
+  if (node_coverage_stats_[node_id].is_boolean_node) {
+    if (value.AsBool()->NativeValue()) {
+      stats.has_true_branch = true;
+    } else {
+      stats.has_false_branch = true;
+    }
+  }
+}
+
+void CoverageIndex::Init(const cel::expr::CheckedExpr& checked_expr) {
+  checked_expr_ = checked_expr;
+  navigable_ast_ = NavigableProtoAst::Build(checked_expr_.expr());
+  for (const auto& node : navigable_ast_.Root().DescendantsPreorder()) {
+    NodeCoverageStats stats;
+    stats.is_boolean_node = InferredBooleanNode(checked_expr_, node);
+    node_coverage_stats_[node.expr()->id()] = stats;
+  }
+}
+
+CoverageIndex::CoverageReport CoverageIndex::GetCoverageReport() const {
+  CoverageReport report;
+  if (node_coverage_stats_.empty()) {
+    return report;
+  }
+  TraverseAndCalculateCoverage(checked_expr_, navigable_ast_.Root(),
+                               node_coverage_stats_, true, "", report);
+  report.cel_expression =
+      google::api::expr::Unparse(checked_expr_).value_or("");
+  return report;
+}
+
+InstrumentationFactory InstrumentationFactoryForCoverage(
+    CoverageIndex& coverage_index) {
+  return [&](const cel::Ast& ast) -> Instrumentation {
+    return [&](int64_t node_id, const cel::Value& value) -> absl::Status {
+      coverage_index.RecordCoverage(node_id, value);
+      return absl::OkStatus();
+    };
+  };
+}
+
+absl::Status EnableCoverageInRuntime(cel::Runtime& runtime,
+                                     CoverageIndex& coverage_index) {
+  auto& runtime_impl =
+      cel::internal::down_cast<runtime_internal::RuntimeImpl&>(runtime);
+  runtime_impl.expr_builder().AddProgramOptimizer(
+      google::api::expr::runtime::CreateInstrumentationExtension(
+          InstrumentationFactoryForCoverage(coverage_index)));
+  return absl::OkStatus();
+}
+
+absl::Status EnableCoverageInCelExpressionBuilder(
+    CelExpressionBuilder& cel_expression_builder,
+    CoverageIndex& coverage_index) {
+  auto& cel_expression_builder_impl = cel::internal::down_cast<
+      google::api::expr::runtime::CelExpressionBuilderFlatImpl&>(
+      cel_expression_builder);
+  cel_expression_builder_impl.flat_expr_builder().AddProgramOptimizer(
+      google::api::expr::runtime::CreateInstrumentationExtension(
+          InstrumentationFactoryForCoverage(coverage_index)));
+  return absl::OkStatus();
+}
+
+}  // namespace cel::test