Function TEST_F

eval/compiler/constant_folding_test.cc:104–165

While CEL doesn't provide execution order guarantees per se, short circuiting operators are treated specially to evaluate to user expectations. These behaviors aren't easily observable since the flat expression doesn't expose any details about the program after building, so a lot of setup is needed to simulate what the expression builder does.

// expose any details about the program after building, so a lot of setup is
// needed to simulate what the expression builder does.
TEST_F(UpdatedConstantFoldingTest, SkipsTernary) {
  // Arrange
  ASSERT_OK_AND_ASSIGN(std::unique_ptr<cel::Ast> ast,
                       ParseFromCel("true ? true : false"));

  const Expr& call = ast->root_expr();
  const Expr& condition = call.call_expr().args()[0];
  const Expr& true_branch = call.call_expr().args()[1];
  const Expr& false_branch = call.call_expr().args()[2];

  ProgramBuilder program_builder;
  program_builder.EnterSubexpression(&call);
  // condition
  program_builder.EnterSubexpression(&condition);
  ASSERT_OK_AND_ASSIGN(auto step,
                       CreateConstValueStep(cel::BoolValue(true), -1));
  program_builder.AddStep(std::move(step));
  program_builder.ExitSubexpression(&condition);

  // true
  program_builder.EnterSubexpression(&true_branch);
  ASSERT_OK_AND_ASSIGN(step, CreateConstValueStep(cel::BoolValue(true), -1));
  program_builder.AddStep(std::move(step));
  program_builder.ExitSubexpression(&true_branch);

  // false
  program_builder.EnterSubexpression(&false_branch);
  ASSERT_OK_AND_ASSIGN(step, CreateConstValueStep(cel::BoolValue(true), -1));
  program_builder.AddStep(std::move(step));
  program_builder.ExitSubexpression(&false_branch);

  // ternary.
  ASSERT_OK_AND_ASSIGN(step, CreateConstValueStep(cel::NullValue(), -1));
  program_builder.AddStep(std::move(step));
  program_builder.ExitSubexpression(&call);

  std::shared_ptr<google::protobuf::Arena> arena;
  PlannerContext context(env_, resolver_, options_,
                         type_registry_.GetComposedTypeProvider(),
                         issue_collector_, program_builder, arena);

  ProgramOptimizerFactory constant_folder_factory =
      CreateConstantFoldingOptimizer();

  // Act
  // Issue the visitation calls.
  ASSERT_OK_AND_ASSIGN(std::unique_ptr<ProgramOptimizer> constant_folder,
                       constant_folder_factory(context, *ast));
  ASSERT_OK(constant_folder->OnPreVisit(context, call));
  ASSERT_OK(constant_folder->OnPreVisit(context, condition));
  ASSERT_OK(constant_folder->OnPostVisit(context, condition));
  ASSERT_OK(constant_folder->OnPreVisit(context, true_branch));
  ASSERT_OK(constant_folder->OnPostVisit(context, true_branch));
  ASSERT_OK(constant_folder->OnPreVisit(context, false_branch));
  ASSERT_OK(constant_folder->OnPostVisit(context, false_branch));
  ASSERT_OK(constant_folder->OnPostVisit(context, call));

  // Assert