Function TEST

eval/eval/function_step_test.cc:746–783

    &TestNameFn);

TEST(FunctionStepTestUnknownFunctionResults, CaptureArgs) {
  ExecutionPath path;
  CelFunctionRegistry registry;

  ASSERT_OK(registry.Register(
      std::make_unique<ConstFunction>(CelValue::CreateInt64(2), "Const2")));
  ASSERT_OK(registry.Register(
      std::make_unique<ConstFunction>(CelValue::CreateInt64(3), "Const3")));
  ASSERT_OK(registry.Register(
      std::make_unique<AddFunction>(ShouldReturnUnknown::kYes)));

  CallExpr call1 = ConstFunction::MakeCall("Const2");
  CallExpr call2 = ConstFunction::MakeCall("Const3");
  CallExpr add_call = AddFunction::MakeCall();

  ASSERT_OK_AND_ASSIGN(auto step0, MakeTestFunctionStep(call1, registry));
  ASSERT_OK_AND_ASSIGN(auto step1, MakeTestFunctionStep(call2, registry));
  ASSERT_OK_AND_ASSIGN(auto step2, MakeTestFunctionStep(add_call, registry));

  path.push_back(std::move(step0));
  path.push_back(std::move(step1));
  path.push_back(std::move(step2));
  cel::RuntimeOptions options;
  options.unknown_processing =
      cel::UnknownProcessingOptions::kAttributeAndFunction;
  auto env = NewTestingRuntimeEnv();
  CelExpressionFlatImpl impl(
      env,
      FlatExpression(std::move(path),
                     /*comprehension_slot_count=*/0,
                     env->type_registry.GetComposedTypeProvider(), options));

  Activation activation;
  google::protobuf::Arena arena;

  ASSERT_OK_AND_ASSIGN(CelValue value, impl.Evaluate(activation, &arena));
  ASSERT_TRUE(value.IsUnknownSet());
}

TEST(FunctionStepTestUnknownFunctionResults, MergeDownCaptureArgs) {
  ExecutionPath path;