Function TEST_P

extensions/select_optimization_test.cc:910–951

      public testing::WithParamInterface<ProgramOptimizerTestCase> {};

TEST_P(SelectOptimizationProgramOptimizerTest, Default) {
  const ProgramOptimizerTestCase& test_case = GetParam();
  google::protobuf::LinkMessageReflection<NestedTestAllTypes>();

  RuntimeOptions options = runtime_options_;
  options.unknown_processing = UnknownProcessingOptions::kAttributeAndFunction;
  options.enable_missing_attribute_errors = true;

  FlatExprBuilder builder(env_, options);

  builder.AddAstTransform(std::make_unique<SelectOptimizationAstUpdater>());
  builder.AddProgramOptimizer(CreateSelectOptimizationProgramOptimizer());

  ASSERT_OK_AND_ASSIGN(std::unique_ptr<cel::Ast> ast,
                       CompileForTestCase(test_case.expr));

  ASSERT_OK_AND_ASSIGN(FlatExpression plan,
                       builder.CreateExpressionImpl(std::move(ast), nullptr));

  cel::Activation act;
  // activation only uses a ptr to the underlying message, persist them.
  std::vector<std::unique_ptr<NestedTestAllTypes>> vars;
  for (const auto& entry : test_case.vars) {
    vars.push_back(std::make_unique<NestedTestAllTypes>());
    ASSERT_TRUE(
        google::protobuf::TextFormat::ParseFromString(entry.second, vars.back().get()));
    ASSERT_THAT(TestBindLegacyMessage(entry.first, *vars.back(), &arena_, act),
                IsOk());
  }

  if (test_case.setup_activation != nullptr) {
    ASSERT_THAT(test_case.setup_activation(&arena_, act), IsOk());
  }

  auto state = plan.MakeEvaluatorState(env_->descriptor_pool.get(),
                                       env_->MutableMessageFactory(), &arena_);
  absl::StatusOr<Value> result = plan.EvaluateWithCallback(
      act, /*embedder_context=*/nullptr,
      google::api::expr::runtime::EvaluationListener(), state);

  ASSERT_NO_FATAL_FAILURE(test_case.expectations(result));
}

TEST_P(SelectOptimizationProgramOptimizerTest, ForceFallbackImpl) {
  const ProgramOptimizerTestCase& test_case = GetParam();