Function EvaluateAttributeHelper

eval/eval/container_access_step_test.cc:56–104

using TestParamType = std::tuple<bool, bool, bool>;

CelValue EvaluateAttributeHelper(
    const absl_nonnull std::shared_ptr<const RuntimeEnv>& env,
    google::protobuf::Arena* arena, CelValue container, CelValue key,
    bool use_recursive_impl, bool receiver_style, bool enable_unknown,
    const std::vector<CelAttributePattern>& patterns) {
  ExecutionPath path;

  Expr expr;
  SourceInfo source_info;
  auto& call = expr.mutable_call_expr();

  call.set_function(cel::builtin::kIndex);

  call.mutable_args().reserve(2);
  Expr& container_expr = (receiver_style) ? call.mutable_target()
                                          : call.mutable_args().emplace_back();
  Expr& key_expr = call.mutable_args().emplace_back();

  container_expr.mutable_ident_expr().set_name("container");
  key_expr.mutable_ident_expr().set_name("key");

  if (use_recursive_impl) {
    path.push_back(std::make_unique<WrappedDirectStep>(
        CreateDirectContainerAccessStep(CreateDirectIdentStep("container", 1),
                                        CreateDirectIdentStep("key", 2),
                                        /*enable_optional_types=*/false, 3),
        3));
  } else {
    path.push_back(std::move(CreateIdentStep("container", 1).value()));
    path.push_back(std::move(CreateIdentStep("key", 2).value()));
    path.push_back(std::move(CreateContainerAccessStep(call, 3).value()));
  }

  cel::RuntimeOptions options;
  options.unknown_processing = cel::UnknownProcessingOptions::kAttributeOnly;
  options.enable_heterogeneous_equality = false;
  CelExpressionFlatImpl cel_expr(
      env,
      FlatExpression(std::move(path), /*comprehension_slot_count=*/0,
                     env->type_registry.GetComposedTypeProvider(), options));
  Activation activation;

  activation.InsertValue("container", container);
  activation.InsertValue("key", key);

  activation.set_unknown_attribute_patterns(patterns);
  auto result = cel_expr.Evaluate(activation, arena);
  return *result;
}

class ContainerAccessStepTest : public ::testing::Test {
 protected: