Function TEST

runtime/constant_folding_test.cc:141–182

    });

TEST(ConstantFoldingExtTest, LazyFunctionNotFolded) {
  google::protobuf::Arena arena;
  RuntimeOptions options;

  ASSERT_OK_AND_ASSIGN(cel::RuntimeBuilder builder,
                       CreateStandardRuntimeBuilder(
                           internal::GetTestingDescriptorPool(), options));
  int call_count = 0;
  using FunctionAdapter =
      BinaryFunctionAdapter<absl::StatusOr<Value>, const StringValue&,
                            const StringValue&>;
  auto fn = FunctionAdapter::WrapFunction(
      [&call_count](const StringValue& value, const StringValue& prefix) {
        call_count++;
        return StringValue(absl::StrCat(prefix.ToString(), value.ToString()));
      });
  FunctionDescriptor descriptor = FunctionAdapter::CreateDescriptor(
      "lazy_prepend", /*receiver_style=*/false);
  ASSERT_THAT(builder.function_registry().RegisterLazyFunction(descriptor),
              IsOk());

  ASSERT_THAT(EnableConstantFolding(builder), IsOk());

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

  ASSERT_OK_AND_ASSIGN(ParsedExpr parsed_expr,
                       Parse("lazy_prepend('def', 'abc') == 'abcdef'"));

  ASSERT_OK_AND_ASSIGN(auto program, ProtobufRuntimeAdapter::CreateProgram(
                                         *runtime, parsed_expr));
  EXPECT_EQ(call_count, 0);
  Activation activation;
  activation.InsertFunction(descriptor, std::move(fn));

  ASSERT_OK_AND_ASSIGN(Value result, program->Evaluate(&arena, activation));
  EXPECT_EQ(call_count, 1);
  EXPECT_THAT(result, IsBoolValue(true));

  ASSERT_OK_AND_ASSIGN(result, program->Evaluate(&arena, activation));
  EXPECT_EQ(call_count, 2);
  EXPECT_THAT(result, IsBoolValue(true));
}

TEST(ConstantFoldingExtTest, ContextualFunctionNotFolded) {
  google::protobuf::Arena arena;