Function TEST_P

env/env_runtime_test.cc:59–108

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

TEST_P(EnvRuntimeTest, EndToEnd) {
  const TestCase& param = GetParam();
  auto descriptor_pool = cel::internal::GetSharedTestingDescriptorPool();
  ASSERT_OK_AND_ASSIGN(Config config, EnvConfigFromYaml(param.config_yaml));

  Env env;
  env.SetDescriptorPool(descriptor_pool);
  RegisterStandardExtensions(env);
  env.SetConfig(config);

  EnvRuntime env_runtime;
  env_runtime.SetDescriptorPool(descriptor_pool);
  RegisterStandardExtensions(env_runtime);
  env_runtime.SetConfig(config);

  ASSERT_OK_AND_ASSIGN(std::unique_ptr<Compiler> compiler, env.NewCompiler());
  std::unique_ptr<Ast> ast;
  if (!param.expected_to_fail) {
    ASSERT_OK_AND_ASSIGN(ValidationResult result,
                         compiler->Compile(param.expr));
    EXPECT_THAT(result.GetIssues(), IsEmpty()) << result.FormatError();
    ASSERT_OK_AND_ASSIGN(ast, result.ReleaseAst());
  } else {
    // Bypass type checking to allow compilation to succeed since we expect the
    // runtime to fail.
    ASSERT_OK_AND_ASSIGN(std::unique_ptr<Source> source,
                         NewSource(param.expr, ""));
    ASSERT_OK_AND_ASSIGN(ast, compiler->GetParser().Parse(*source));
  }
  ASSERT_OK_AND_ASSIGN(std::unique_ptr<Runtime> runtime,
                       env_runtime.NewRuntime());

  absl::StatusOr<std::unique_ptr<Program>> program_or =
      runtime->CreateProgram(std::move(ast));
  if (param.expected_to_fail) {
    EXPECT_THAT(program_or, StatusIs(absl::StatusCode::kInvalidArgument))
        << " expr: " << param.expr;
    return;
  }

  ASSERT_THAT(program_or, IsOk()) << " expr: " << param.expr;

  std::unique_ptr<Program> program = *std::move(program_or);
  ASSERT_NE(program, nullptr);

  google::protobuf::Arena arena;
  Activation activation;
  ASSERT_OK_AND_ASSIGN(Value value, program->Evaluate(&arena, activation));
  EXPECT_TRUE(value.GetBool()) << " expr: " << param.expr;
}

std::vector<TestCase> GetEnvRuntimeTestCases() {
  return {