Function CheckDictionary

cpp/src/arrow/compute/kernels/test_util_internal.cc:211–254

}  // namespace

void CheckDictionary(const std::string& func_name, const DatumVector& args,
                     bool result_is_encoded) {
  auto actual = CheckDictionaryNonRecursive(func_name, args, result_is_encoded);

  if (actual.is_scalar()) return;
  ASSERT_TRUE(actual.is_array());
  ASSERT_GE(actual.length(), 0);

  // Check all scalars
  for (int64_t i = 0; i < actual.length(); i++) {
    CheckDictionaryNonRecursive(func_name, GetDatums(GetScalars(args, i)),
                                result_is_encoded);
  }

  // Check slices of the input
  const auto slice_length = actual.length() / 3;
  if (slice_length > 0) {
    CheckDictionaryNonRecursive(func_name, SliceArrays(args, 0, slice_length),
                                result_is_encoded);
    CheckDictionaryNonRecursive(func_name, SliceArrays(args, slice_length, slice_length),
                                result_is_encoded);
    CheckDictionaryNonRecursive(func_name, SliceArrays(args, 2 * slice_length),
                                result_is_encoded);
  }

  // Check empty slice
  CheckDictionaryNonRecursive(func_name, SliceArrays(args, 0, 0), result_is_encoded);

  // Check chunked arrays
  if (slice_length > 0) {
    DatumVector chunked_args;
    chunked_args.reserve(args.size());
    for (const auto& arg : args) {
      if (arg.is_array()) {
        auto arr = arg.make_array();
        ArrayVector chunks{arr->Slice(0, slice_length), arr->Slice(slice_length)};
        chunked_args.push_back(std::make_shared<ChunkedArray>(std::move(chunks)));
      } else {
        chunked_args.push_back(arg);
      }
    }
    CheckDictionaryNonRecursive(func_name, chunked_args, result_is_encoded);
  }
}

void CheckScalarUnary(std::string func_name, Datum input, Datum expected,
                      const FunctionOptions* options) {