Function TEST_P

env/runtime_std_extensions_test.cc:61–118

using RuntimeStdExtensionTest = testing::TestWithParam<TestCase>;

TEST_P(RuntimeStdExtensionTest, RegisterStandardExtensions) {
  const TestCase& param = GetParam();
  Env env;
  env.SetDescriptorPool(cel::internal::GetSharedTestingDescriptorPool());
  RegisterStandardExtensions(env);

  Config compiler_config;
  // For the compilation step, assume latest version of the extension to ensure
  // a successful compilation. Later, we will test the runtime with different
  // extension versions.
  ASSERT_THAT(compiler_config.AddExtensionConfig(
                  param.extension_name, Config::ExtensionConfig::kLatest),
              IsOk());
  env.SetConfig(compiler_config);
  ASSERT_OK_AND_ASSIGN(std::unique_ptr<Compiler> compiler, env.NewCompiler());
  ASSERT_OK_AND_ASSIGN(ValidationResult result, compiler->Compile(param.expr));
  EXPECT_THAT(result.GetIssues(), IsEmpty()) << result.FormatError();
  ASSERT_OK_AND_ASSIGN(std::unique_ptr<Ast> ast, result.ReleaseAst());

  for (int version = 0; version <= param.latest_extension_version; ++version) {
    Config runtime_config;
    // Request a specific version of the extension to be configured in the
    // runtime.
    ASSERT_THAT(
        runtime_config.AddExtensionConfig(param.extension_name, version),
        IsOk());
    if (param.requires_optional_extension) {
      ASSERT_THAT(runtime_config.AddExtensionConfig("optional"), IsOk());
    }

    EnvRuntime env_runtime;
    env_runtime.SetDescriptorPool(
        cel::internal::GetSharedTestingDescriptorPool());
    RegisterStandardExtensions(env_runtime);
    env_runtime.SetConfig(runtime_config);
    ASSERT_OK_AND_ASSIGN(std::unique_ptr<Runtime> runtime,
                         env_runtime.NewRuntime());
    absl::StatusOr<std::unique_ptr<Program>> program_or =
        runtime->CreateProgram(std::make_unique<Ast>(*ast));

    // If the function is not supported in this extension version, check that
    // the program creation returned an error.
    if (!absl::c_contains(param.extension_versions, version)) {
      EXPECT_THAT(program_or, StatusIs(absl::StatusCode::kInvalidArgument))
          << " expr: " << param.expr << " version: " << version;
      continue;
    }

    ASSERT_THAT(program_or, IsOk())
        << " expr: " << param.expr << " version: " << version;
    std::unique_ptr<Program> program = *std::move(program_or);
    google::protobuf::Arena arena;
    Activation activation;
    ASSERT_OK_AND_ASSIGN(Value value, program->Evaluate(&arena, activation));
    EXPECT_TRUE(value.GetBool())
        << " expr: " << param.expr << " version: " << version;
  }
}