Method TestCreate

cpp/src/arrow/array/array_test.cc:3300–3340

  template <size_t BYTE_WIDTH = 16>
  std::shared_ptr<Array> TestCreate(int32_t precision, const DecimalVector& draw,
                                    const std::vector<uint8_t>& valid_bytes,
                                    int64_t offset) const {
    auto type = std::make_shared<TYPE>(precision, 4);
    auto builder = std::make_shared<DecimalBuilder>(type);

    const size_t size = draw.size();

    ARROW_EXPECT_OK(builder->Reserve(size));

    for (size_t i = 0; i < size; ++i) {
      if (valid_bytes[i]) {
        ARROW_EXPECT_OK(builder->Append(draw[i]));
      } else {
        ARROW_EXPECT_OK(builder->AppendNull());
      }
    }

    std::shared_ptr<Array> out;
    FinishAndCheckPadding(builder.get(), &out);
    EXPECT_EQ(builder->length(), 0);

    std::vector<uint8_t> raw_bytes;

    raw_bytes.reserve(size * BYTE_WIDTH);
    MakeData<BYTE_WIDTH>(draw, &raw_bytes);

    auto expected_data = std::make_shared<Buffer>(raw_bytes.data(), BYTE_WIDTH);
    std::shared_ptr<Buffer> expected_null_bitmap;
    EXPECT_OK_AND_ASSIGN(expected_null_bitmap, internal::BytesToBits(valid_bytes));

    int64_t expected_null_count = CountNulls(valid_bytes);
    auto expected = std::make_shared<DecimalArray>(
        type, size, expected_data, expected_null_bitmap, expected_null_count);

    std::shared_ptr<Array> lhs = out->Slice(offset);
    std::shared_ptr<Array> rhs = expected->Slice(offset);
    ASSERT_ARRAYS_EQUAL(*rhs, *lhs);

    return out;
  }
};

using Decimal32Test = DecimalTest<Decimal32Type>;