Function TEST_P

runtime/regex_precompilation_test.cc:79–121

class RegexPrecompilationTest : public testing::TestWithParam<TestCase> {};

TEST_P(RegexPrecompilationTest, Basic) {
  RuntimeOptions options;
  const TestCase& test_case = GetParam();
  ASSERT_OK_AND_ASSIGN(cel::RuntimeBuilder builder,
                       CreateStandardRuntimeBuilder(
                           internal::GetTestingDescriptorPool(), options));

  auto status = RegisterHelper<BinaryFunctionAdapter<
      absl::StatusOr<Value>, const StringValue&, const StringValue&>>::
      RegisterGlobalOverload(
          "prepend",
          [](const StringValue& value, const StringValue& prefix) {
            return StringValue(
                absl::StrCat(prefix.ToString(), value.ToString()));
          },
          builder.function_registry());
  ASSERT_THAT(status, IsOk());

  ASSERT_THAT(EnableRegexPrecompilation(builder), IsOk());

  ASSERT_OK_AND_ASSIGN(auto runtime, std::move(builder).Build());

  ASSERT_OK_AND_ASSIGN(ParsedExpr parsed_expr, Parse(test_case.expression));

  auto program_or =
      ProtobufRuntimeAdapter::CreateProgram(*runtime, parsed_expr);
  if (!test_case.create_status.ok()) {
    ASSERT_THAT(program_or.status(),
                StatusIs(test_case.create_status.code(),
                         HasSubstr(test_case.create_status.message())));
    return;
  }

  ASSERT_OK_AND_ASSIGN(auto program, std::move(program_or));

  google::protobuf::Arena arena;
  Activation activation;
  activation.InsertOrAssignValue("string_var",
                                 StringValue(&arena, "string_var"));

  ASSERT_OK_AND_ASSIGN(Value value, program->Evaluate(&arena, activation));
  EXPECT_THAT(value, test_case.result_matcher);
}

TEST_P(RegexPrecompilationTest, WithConstantFolding) {
  RuntimeOptions options;