Function ARROW_ASSIGN_OR_RAISE

cpp/src/arrow/ipc/test_common.cc:879–928

                       /*indices=*/ArrayFromJSON(int16(), "[2, 1, null, null, 2, 1, 0]"),
                       /*dictionary=*/values0));
  ARROW_ASSIGN_OR_RAISE(
      auto outer1, StructArray::Make({inner1, inner2}, {field("a", inner1->type()),
                                                        field("b", inner2->type())}));
  DCHECK_EQ(outer1->length(), length);

  // Field 2: dict(int8, struct(c: dict(int8, int64), d: dict(int16, list(dict(int8,
  // utf8)))))
  ARROW_ASSIGN_OR_RAISE(auto nested_values2,
                        ListArray::FromArrays(
                            /*offsets=*/*ArrayFromJSON(int32(), "[0, 1, 5, 5, 7]"),
                            /*values=*/*inner0));
  ARROW_ASSIGN_OR_RAISE(
      auto inner3, DictionaryArray::FromArrays(
                       dictionary(int16(), nested_values2->type()),
                       /*indices=*/ArrayFromJSON(int16(), "[0, 1, 3, null, 3, 2, 1]"),
                       /*dictionary=*/nested_values2));
  ARROW_ASSIGN_OR_RAISE(
      auto inner4, StructArray::Make({inner1, inner3}, {field("c", inner1->type()),
                                                        field("d", inner3->type())}));
  ARROW_ASSIGN_OR_RAISE(auto outer2,
                        DictionaryArray::FromArrays(
                            dictionary(int8(), inner4->type()),
                            /*indices=*/ArrayFromJSON(int8(), "[0, 2, 4, 6, 1, 3, 5]"),
                            /*dictionary=*/inner4));
  DCHECK_EQ(outer2->length(), length);

  auto schema = ::arrow::schema({
      field("f0", outer0->type()),
      field("f1", outer1->type()),
      field("f2", outer2->type()),
  });
  *out = RecordBatch::Make(schema, length, {outer0, outer1, outer2});
  return Status::OK();
}

Status MakeMap(std::shared_ptr<RecordBatch>* out) {
  constexpr int64_t kNumRows = 3;
  std::shared_ptr<Array> a0, a1;

  auto key_array = ArrayFromJSON(utf8(), R"(["k1", "k2", "k1", "k3", "k1", "k4"])");
  auto item_array = ArrayFromJSON(int16(), "[0, -1, 2, -3, 4, null]");
  RETURN_NOT_OK(MakeRandomMapArray(key_array, item_array, kNumRows,
                                   /*include_nulls=*/false, default_memory_pool(), &a0));
  RETURN_NOT_OK(MakeRandomMapArray(key_array, item_array, kNumRows,
                                   /*include_nulls=*/true, default_memory_pool(), &a1));
  auto f0 = field("f0", a0->type());
  auto f1 = field("f1", a1->type());
  *out = RecordBatch::Make(::arrow::schema({f0, f1}), kNumRows, {a0, a1});
  return Status::OK();
}

Status MakeMapOfDictionary(std::shared_ptr<RecordBatch>* out) {
  // Exercises ARROW-9660