public:

void SetUp() { pool_ = default_memory_pool(); }

protected:

MemoryPool* pool_;

// These are placeholders

auto data = std::make_shared<Buffer>(nullptr, 0);

auto null_bitmap = std::make_shared<Buffer>(nullptr, 0);

std::unique_ptr<Int32Array> arr(new Int32Array(100, data, null_bitmap, 10));

ASSERT_EQ(10, arr->null_count());

std::unique_ptr<Int32Array> arr_no_nulls(new Int32Array(100, data));

ASSERT_EQ(0, arr_no_nulls->null_count());

std::unique_ptr<Int32Array> arr_default_null_count(

new Int32Array(100, data, null_bitmap));

ASSERT_EQ(kUnknownNullCount, arr_default_null_count->data()->null_count);

// Placeholder buffer

auto data = std::make_shared<Buffer>(nullptr, 0);

std::unique_ptr<Int32Array> arr(new Int32Array(100, data));

ASSERT_EQ(arr->length(), 100);

std::shared_ptr<Array>* out) {

int64_t null_count = v.size() - std::accumulate(v.begin(), v.end(), 0);

std::shared_ptr<Buffer> null_buf;

RETURN_NOT_OK(BitUtil::BytesToBits(v, default_memory_pool(), &null_buf));

TypedBufferBuilder<int32_t> value_builder(pool);

for (size_t i = 0; i < v.size(); ++i) {

RETURN_NOT_OK(value_builder.Append(0));

}

std::shared_ptr<Buffer> values;

RETURN_NOT_OK(value_builder.Finish(&values));

*out = std::make_shared<Int32Array>(v.size(), values, null_buf, null_count);

return Status::OK();

std::shared_ptr<Array> array, equal_array, unequal_array;

ASSERT_OK(MakeArrayFromValidBytes({1, 0, 1, 1, 0, 1, 0, 0}, pool_, &array));

ASSERT_OK(MakeArrayFromValidBytes({1, 0, 1, 1, 0, 1, 0, 0}, pool_, &equal_array));

ASSERT_OK(MakeArrayFromValidBytes({1, 1, 1, 1, 0, 1, 0, 0}, pool_, &unequal_array));

EXPECT_TRUE(array->Equals(array));

EXPECT_TRUE(array->Equals(equal_array));

EXPECT_TRUE(equal_array->Equals(array));

EXPECT_FALSE(equal_array->Equals(unequal_array));

EXPECT_FALSE(unequal_array->Equals(equal_array));

EXPECT_TRUE(array->RangeEquals(4, 8, 4, unequal_array));

EXPECT_FALSE(array->RangeEquals(0, 4, 0, unequal_array));

EXPECT_FALSE(array->RangeEquals(0, 8, 0, unequal_array));

EXPECT_FALSE(array->RangeEquals(1, 2, 1, unequal_array));

auto timestamp_ns_array = std::make_shared<NumericArray<TimestampType>>(

timestamp(TimeUnit::NANO), array->length(), array->data()->buffers[1],

array->data()->buffers[0], array->null_count());

auto timestamp_us_array = std::make_shared<NumericArray<TimestampType>>(

timestamp(TimeUnit::MICRO), array->length(), array->data()->buffers[1],

array->data()->buffers[0], array->null_count());

ASSERT_FALSE(array->Equals(timestamp_ns_array));

// ARROW-2567: Ensure that not only the type id but also the type equality

// itself is checked.

ASSERT_FALSE(timestamp_us_array->Equals(timestamp_ns_array));

auto array_1 = std::make_shared<NullArray>(10);

auto array_2 = std::make_shared<NullArray>(10);

auto array_3 = std::make_shared<NullArray>(20);

EXPECT_TRUE(array_1->Equals(array_1));

EXPECT_TRUE(array_1->Equals(array_2));

EXPECT_FALSE(array_1->Equals(array_3));

std::vector<uint8_t> valid_bytes = {1, 0, 1, 1, 0, 1, 0, 0, 0};

std::shared_ptr<Array> array;

ASSERT_OK(MakeArrayFromValidBytes(valid_bytes, pool_, &array));

ASSERT_EQ(5, array->null_count());

auto slice = array->Slice(1, 4);

ASSERT_EQ(2, slice->null_count());

slice = array->Slice(4);

ASSERT_EQ(4, slice->null_count());

slice = array->Slice(0);

ASSERT_EQ(5, slice->null_count());

// No bitmap, compute 0

std::shared_ptr<Buffer> data;

const int kBufferSize = 64;

ASSERT_OK(AllocateBuffer(pool_, kBufferSize, &data));

memset(data->mutable_data(), 0, kBufferSize);

auto arr = std::make_shared<Int32Array>(16, data, nullptr, -1);

ASSERT_EQ(0, arr->null_count());

auto null_arr = std::make_shared<NullArray>(10);

auto null_arr_sliced = null_arr->Slice(3, 6);

// The internal null count is 6, does not require recomputation

ASSERT_EQ(6, null_arr_sliced->data()->null_count);

ASSERT_EQ(6, null_arr_sliced->null_count());

// clang-format off

std::vector<uint8_t> null_bitmap = {1, 0, 1, 1, 0, 1, 0, 0,

1, 0, 1, 1, 0, 1, 0, 0,

1, 0, 1, 1, 0, 1, 0, 0,

1, 0, 1, 1, 0, 1, 0, 0,

1, 0, 0, 1};

// clang-format on

int64_t null_count = 0;

for (uint8_t x : null_bitmap) {

if (x == 0) {

++null_count;

}

}

std::shared_ptr<Buffer> null_buf;

ASSERT_OK(BitUtil::BytesToBits(null_bitmap, default_memory_pool(), &null_buf));

std::unique_ptr<Array> arr;

arr.reset(new Int32Array(null_bitmap.size(), nullptr, null_buf, null_count));

ASSERT_EQ(null_count, arr->null_count());

ASSERT_EQ(5, null_buf->size());

ASSERT_TRUE(arr->null_bitmap()->Equals(*null_buf.get()));

for (size_t i = 0; i < null_bitmap.size(); ++i) {

EXPECT_EQ(null_bitmap[i] != 0, !arr->IsNull(i)) << i;

EXPECT_EQ(null_bitmap[i] != 0, arr->IsValid(i)) << i;

}

const int64_t size = 10;

std::unique_ptr<Array> arr;

arr.reset(new Int32Array(size, nullptr, nullptr, 0));

for (size_t i = 0; i < size; ++i) {

EXPECT_TRUE(arr->IsValid(i));

EXPECT_FALSE(arr->IsNull(i));

}

#ifdef NDEBUG

const int64_t length = static_cast<int64_t>(std::numeric_limits<int32_t>::max()) + 1;

#elif !defined(ARROW_VALGRIND)

// use a smaller size since the insert function isn't optimized properly on debug and

// the test takes a long time to complete

const int64_t length = 2 << 24;

#else

// use an even smaller size with valgrind

const int64_t length = 2 << 20;

#endif

BooleanBuilder builder;

std::vector<bool> zeros(length);

ASSERT_OK(builder.AppendValues(zeros));

std::shared_ptr<Array> result;

FinishAndCheckPadding(&builder, &result);

ASSERT_EQ(length, result->length());

NullBuilder builder;

std::shared_ptr<Array> array;

ASSERT_OK(builder.AppendNull());

ASSERT_OK(builder.Append(nullptr));

ASSERT_OK(builder.AppendNull());

ASSERT_OK(builder.AppendNulls(2));

ASSERT_OK(builder.Finish(&array));

const auto& null_array = checked_cast<NullArray&>(*array);

ASSERT_EQ(null_array.length(), 5);

ASSERT_EQ(null_array.null_count(), 5);

UInt8Builder builder(pool_);

ASSERT_OK(builder.Resize(1000));

ASSERT_EQ(1000, builder.capacity());

// Reserve overallocates for small upsizes.

ASSERT_OK(builder.Reserve(1030));

ASSERT_GE(builder.capacity(), 1500);

UInt8Builder builder(pool_);

ASSERT_OK(builder.Resize(1000));

ASSERT_EQ(1000, builder.capacity());

// Can't downsize.

ASSERT_RAISES(Invalid, builder.Resize(500));

public:

typedef typename Attrs::ArrayType ArrayType;

typedef typename Attrs::BuilderType BuilderType;

typedef typename Attrs::T T;

typedef typename Attrs::Type Type;

virtual void SetUp() {

TestBuilder::SetUp();

type_ = Attrs::type();

std::unique_ptr<ArrayBuilder> tmp;

ASSERT_OK(MakeBuilder(pool_, type_, &tmp));

builder_.reset(checked_cast<BuilderType*>(tmp.release()));

ASSERT_OK(MakeBuilder(pool_, type_, &tmp));

builder_nn_.reset(checked_cast<BuilderType*>(tmp.release()));

}

void RandomData(int64_t N, double pct_null = 0.1) {

Attrs::draw(N, &draws_);

valid_bytes_.resize(static_cast<size_t>(N));

random_null_bytes(N, pct_null, valid_bytes_.data());

}

void Check(const std::unique_ptr<BuilderType>& builder, bool nullable) {

int64_t size = builder->length();

auto ex_data = Buffer::Wrap(draws_.data(), size);

std::shared_ptr<Buffer> ex_null_bitmap;

int64_t ex_null_count = 0;

if (nullable) {

ASSERT_OK(

BitUtil::BytesToBits(valid_bytes_, default_memory_pool(), &ex_null_bitmap));

ex_null_count = CountNulls(valid_bytes_);

} else {

ex_null_bitmap = nullptr;

}

auto expected =

std::make_shared<ArrayType>(size, ex_data, ex_null_bitmap, ex_null_count);

std::shared_ptr<Array> out;

FinishAndCheckPadding(builder.get(), &out);

std::shared_ptr<ArrayType> result = std::dynamic_pointer_cast<ArrayType>(out);

// Builder is now reset

ASSERT_EQ(0, builder->length());

ASSERT_EQ(0, builder->capacity());

ASSERT_EQ(0, builder->null_count());

ASSERT_EQ(ex_null_count, result->null_count());

ASSERT_TRUE(result->Equals(*expected));

}

void FlipValue(T* ptr) {

auto byteptr = reinterpret_cast<uint8_t*>(ptr);

*byteptr = static_cast<uint8_t>(~*byteptr);

}

protected:

std::unique_ptr<BuilderType> builder_;

std::unique_ptr<BuilderType> builder_nn_;

std::vector<T> draws_;

std::vector<uint8_t> valid_bytes_;

PTYPE_DECL(Boolean, uint8_t)

};

template <>

void TestPrimitiveBuilder<PBoolean>::RandomData(int64_t N, double pct_null) {

draws_.resize(static_cast<size_t>(N));

valid_bytes_.resize(static_cast<size_t>(N));

random_null_bytes(N, 0.5, draws_.data());

random_null_bytes(N, pct_null, valid_bytes_.data());

}

template <>

void TestPrimitiveBuilder<PBoolean>::FlipValue(T* ptr) {

*ptr = !*ptr;

}

template <>

void TestPrimitiveBuilder<PBoolean>::Check(const std::unique_ptr<BooleanBuilder>& builder,

bool nullable) {

const int64_t size = builder->length();

// Build expected result array

std::shared_ptr<Buffer> ex_data;

std::shared_ptr<Buffer> ex_null_bitmap;

int64_t ex_null_count = 0;

ASSERT_OK(BitUtil::BytesToBits(draws_, default_memory_pool(), &ex_data));

if (nullable) {

ASSERT_OK(BitUtil::BytesToBits(valid_bytes_, default_memory_pool(), &ex_null_bitmap));

ex_null_count = CountNulls(valid_bytes_);

} else {

ex_null_bitmap = nullptr;

}

auto expected =

std::make_shared<BooleanArray>(size, ex_data, ex_null_bitmap, ex_null_count);

ASSERT_EQ(size, expected->length());

// Finish builder and check result array

std::shared_ptr<Array> out;

FinishAndCheckPadding(builder.get(), &out);

std::shared_ptr<BooleanArray> result = std::dynamic_pointer_cast<BooleanArray>(out);

ASSERT_EQ(ex_null_count, result->null_count());

ASSERT_EQ(size, result->length());

for (int64_t i = 0; i < size; ++i) {

if (nullable) {

ASSERT_EQ(valid_bytes_[i] == 0, result->IsNull(i)) << i;

} else {

ASSERT_FALSE(result->IsNull(i));

}

if (!result->IsNull(i)) {

bool actual = BitUtil::GetBit(result->values()->data(), i);

ASSERT_EQ(draws_[i] != 0, actual) << i;

}

}

AssertArraysEqual(*result, *expected);

// buffers are correctly sized

ASSERT_EQ(result->data()->buffers[0]->size(), BitUtil::BytesForBits(size));

ASSERT_EQ(result->data()->buffers[1]->size(), BitUtil::BytesForBits(size));

// Builder is now reset

ASSERT_EQ(0, builder->length());

ASSERT_EQ(0, builder->capacity());

ASSERT_EQ(0, builder->null_count());

}

TEST(NumericBuilderAccessors, TestSettersGetters) {

int64_t datum = 42;

int64_t new_datum = 43;

NumericBuilder<Int64Type> builder(int64(), default_memory_pool());

builder.Reset();

ASSERT_OK(builder.Append(datum));

ASSERT_EQ(builder.GetValue(0), datum);

// Now update the value.

builder[0] = new_datum;

ASSERT_EQ(builder.GetValue(0), new_datum);

ASSERT_EQ(((const NumericBuilder<Int64Type>&)builder)[0], new_datum);

}

typedef ::testing::Types<PBoolean, PUInt8, PUInt16, PUInt32, PUInt64, PInt8, PInt16,

PInt32, PInt64, PFloat, PDouble>

Primitives;

TYPED_TEST_CASE(TestPrimitiveBuilder, Primitives);

TYPED_TEST(TestPrimitiveBuilder, TestInit) {

ASSERT_OK(this->builder_->Reserve(1000));

ASSERT_EQ(1000, this->builder_->capacity());

// Small upsize => should overallocate

ASSERT_OK(this->builder_->Reserve(1200));

ASSERT_GE(1500, this->builder_->capacity());

// Large upsize => should allocate exactly

ASSERT_OK(this->builder_->Reserve(32768));

ASSERT_EQ(32768, this->builder_->capacity());

// unsure if this should go in all builder classes

ASSERT_EQ(0, this->builder_->num_children());

}

TYPED_TEST(TestPrimitiveBuilder, TestAppendNull) {

int64_t size = 1000;

for (int64_t i = 0; i < size; ++i) {

ASSERT_OK(this->builder_->AppendNull());

}

std::shared_ptr<Array> out;

FinishAndCheckPadding(this->builder_.get(), &out);

auto result = std::dynamic_pointer_cast<typename TypeParam::ArrayType>(out);

for (int64_t i = 0; i < size; ++i) {

ASSERT_TRUE(result->IsNull(i)) << i;

}

}

TYPED_TEST(TestPrimitiveBuilder, TestAppendNulls) {

const int64_t size = 10;

ASSERT_OK(this->builder_->AppendNulls(size));

std::shared_ptr<Array> result;

FinishAndCheckPadding(this->builder_.get(), &result);

for (int64_t i = 0; i < size; ++i) {

ASSERT_FALSE(result->IsValid(i));

}

}

TYPED_TEST(TestPrimitiveBuilder, TestArrayDtorDealloc) {

DECL_T();

int64_t size = 1000;

std::vector<T>& draws = this->draws_;

std::vector<uint8_t>& valid_bytes = this->valid_bytes_;

int64_t memory_before = this->pool_->bytes_allocated();

this->RandomData(size);

ASSERT_OK(this->builder_->Reserve(size));

int64_t i;

for (i = 0; i < size; ++i) {

if (valid_bytes[i] > 0) {

ASSERT_OK(this->builder_->Append(draws[i]));

} else {

ASSERT_OK(this->builder_->AppendNull());

}

}

do {

std::shared_ptr<Array> result;

FinishAndCheckPadding(this->builder_.get(), &result);

} while (false);

ASSERT_EQ(memory_before, this->pool_->bytes_allocated());

}

TYPED_TEST(TestPrimitiveBuilder, Equality) {

DECL_T();

const int64_t size = 1000;

this->RandomData(size);

std::vector<T>& draws = this->draws_;

std::vector<uint8_t>& valid_bytes = this->valid_bytes_;

std::shared_ptr<Array> array, equal_array, unequal_array;

auto builder = this->builder_.get();

ASSERT_OK(MakeArray(valid_bytes, draws, size, builder, &array));

ASSERT_OK(MakeArray(valid_bytes, draws, size, builder, &equal_array));

// Make the not equal array by negating the first valid element with itself.

const auto first_valid = std::find_if(valid_bytes.begin(), valid_bytes.end(),

[](uint8_t valid) { return valid > 0; });

const int64_t first_valid_idx = std::distance(valid_bytes.begin(), first_valid);

// This should be true with a very high probability, but might introduce flakiness

ASSERT_LT(first_valid_idx, size - 1);

this->FlipValue(&draws[first_valid_idx]);

ASSERT_OK(MakeArray(valid_bytes, draws, size, builder, &unequal_array));

// test normal equality

EXPECT_TRUE(array->Equals(array));

EXPECT_TRUE(array->Equals(equal_array));

EXPECT_TRUE(equal_array->Equals(array));

EXPECT_FALSE(equal_array->Equals(unequal_array));

EXPECT_FALSE(unequal_array->Equals(equal_array));

// Test range equality

EXPECT_FALSE(array->RangeEquals(0, first_valid_idx + 1, 0, unequal_array));

EXPECT_FALSE(array->RangeEquals(first_valid_idx, size, first_valid_idx, unequal_array));

EXPECT_TRUE(array->RangeEquals(0, first_valid_idx, 0, unequal_array));

EXPECT_TRUE(

array->RangeEquals(first_valid_idx + 1, size, first_valid_idx + 1, unequal_array));

}

TYPED_TEST(TestPrimitiveBuilder, SliceEquality) {

DECL_T();

const int64_t size = 1000;

this->RandomData(size);

std::vector<T>& draws = this->draws_;

std::vector<uint8_t>& valid_bytes = this->valid_bytes_;

auto builder = this->builder_.get();

std::shared_ptr<Array> array;

ASSERT_OK(MakeArray(valid_bytes, draws, size, builder, &array));

std::shared_ptr<Array> slice, slice2;

slice = array->Slice(5);

slice2 = array->Slice(5);

ASSERT_EQ(size - 5, slice->length());

ASSERT_TRUE(slice->Equals(slice2));

ASSERT_TRUE(array->RangeEquals(5, array->length(), 0, slice));

// Chained slices

slice2 = array->Slice(2)->Slice(3);

ASSERT_TRUE(slice->Equals(slice2));

slice = array->Slice(5, 10);

slice2 = array->Slice(5, 10);

ASSERT_EQ(10, slice->length());

ASSERT_TRUE(slice->Equals(slice2));

ASSERT_TRUE(array->RangeEquals(5, 15, 0, slice));

}

TYPED_TEST(TestPrimitiveBuilder, TestAppendScalar) {

DECL_T();

const int64_t size = 10000;

std::vector<T>& draws = this->draws_;

std::vector<uint8_t>& valid_bytes = this->valid_bytes_;

this->RandomData(size);

ASSERT_OK(this->builder_->Reserve(1000));

ASSERT_OK(this->builder_nn_->Reserve(1000));

int64_t null_count = 0;

// Append the first 1000

for (size_t i = 0; i < 1000; ++i) {

if (valid_bytes[i] > 0) {

ASSERT_OK(this->builder_->Append(draws[i]));

} else {

ASSERT_OK(this->builder_->AppendNull());

++null_count;

}

ASSERT_OK(this->builder_nn_->Append(draws[i]));

}

ASSERT_EQ(null_count, this->builder_->null_count());

ASSERT_EQ(1000, this->builder_->length());

ASSERT_EQ(1000, this->builder_->capacity());

ASSERT_EQ(1000, this->builder_nn_->length());

ASSERT_EQ(1000, this->builder_nn_->capacity());

ASSERT_OK(this->builder_->Reserve(size - 1000));

ASSERT_OK(this->builder_nn_->Reserve(size - 1000));

// Append the next 9000

for (size_t i = 1000; i < size; ++i) {

if (valid_bytes[i] > 0) {

ASSERT_OK(this->builder_->Append(draws[i]));

} else {

ASSERT_OK(this->builder_->AppendNull());

}

ASSERT_OK(this->builder_nn_->Append(draws[i]));

}

ASSERT_EQ(size, this->builder_->length());

ASSERT_GE(size, this->builder_->capacity());

ASSERT_EQ(size, this->builder_nn_->length());

ASSERT_GE(size, this->builder_nn_->capacity());

this->Check(this->builder_, true);

this->Check(this->builder_nn_, false);

}

TYPED_TEST(TestPrimitiveBuilder, TestAppendValues) {

DECL_T();

int64_t size = 10000;

this->RandomData(size);

std::vector<T>& draws = this->draws_;

std::vector<uint8_t>& valid_bytes = this->valid_bytes_;

// first slug

int64_t K = 1000;

ASSERT_OK(this->builder_->AppendValues(draws.data(), K, valid_bytes.data()));

ASSERT_OK(this->builder_nn_->AppendValues(draws.data(), K));

ASSERT_EQ(1000, this->builder_->length());

ASSERT_EQ(1000, this->builder_->capacity());

ASSERT_EQ(1000, this->builder_nn_->length());

ASSERT_EQ(1000, this->builder_nn_->capacity());

// Append the next 9000

ASSERT_OK(

this->builder_->AppendValues(draws.data() + K, size - K, valid_bytes.data() + K));

ASSERT_OK(this->builder_nn_->AppendValues(draws.data() + K, size - K));

ASSERT_EQ(size, this->builder_->length());

ASSERT_GE(size, this->builder_->capacity());

ASSERT_EQ(size, this->builder_nn_->length());

ASSERT_GE(size, this->builder_nn_->capacity());

this->Check(this->builder_, true);

this->Check(this->builder_nn_, false);

}

TYPED_TEST(TestPrimitiveBuilder, TestAppendValuesIter) {

int64_t size = 10000;

this->RandomData(size);

ASSERT_OK(this->builder_->AppendValues(this->draws_.begin(), this->draws_.end(),

this->valid_bytes_.begin()));

ASSERT_OK(this->builder_nn_->AppendValues(this->draws_.begin(), this->draws_.end()));

ASSERT_EQ(size, this->builder_->length());

ASSERT_GE(size, this->builder_->capacity());

this->Check(this->builder_, true);

this->Check(this->builder_nn_, false);

}

TYPED_TEST(TestPrimitiveBuilder, TestAppendValuesIterNullValid) {

int64_t size = 10000;

this->RandomData(size);

ASSERT_OK(this->builder_nn_->AppendValues(this->draws_.begin(),

this->draws_.begin() + size / 2,

static_cast<uint8_t*>(nullptr)));

ASSERT_GE(size / 2, this->builder_nn_->capacity());

ASSERT_OK(this->builder_nn_->AppendValues(this->draws_.begin() + size / 2,

this->draws_.end(),

static_cast<uint64_t*>(nullptr)));

this->Check(this->builder_nn_, false);

}

TYPED_TEST(TestPrimitiveBuilder, TestAppendValuesLazyIter) {

DECL_T();

int64_t size = 10000;

this->RandomData(size);

auto& draws = this->draws_;

auto& valid_bytes = this->valid_bytes_;

auto halve = [&draws](int64_t index) { return draws[index] / 2; };

auto lazy_iter = internal::MakeLazyRange(halve, size);

ASSERT_OK(this->builder_->AppendValues(lazy_iter.begin(), lazy_iter.end(),

valid_bytes.begin()));

std::vector<T> halved;

transform(draws.begin(), draws.end(), back_inserter(halved),

[](T in) { return in / 2; });

std::shared_ptr<Array> result;

FinishAndCheckPadding(this->builder_.get(), &result);

std::shared_ptr<Array> expected;

ASSERT_OK(

this->builder_->AppendValues(halved.data(), halved.size(), valid_bytes.data()));

FinishAndCheckPadding(this->builder_.get(), &expected);

ASSERT_TRUE(expected->Equals(result));

}

TYPED_TEST(TestPrimitiveBuilder, TestAppendValuesIterConverted) {

DECL_T();

// find type we can safely convert the tested values to and from

using conversion_type =

typename std::conditional<std::is_floating_point<T>::value, double,

typename std::conditional<std::is_unsigned<T>::value,

uint64_t, int64_t>::type>::type;

int64_t size = 10000;

this->RandomData(size);

// append convertible values

std::vector<conversion_type> draws_converted(this->draws_.begin(), this->draws_.end());

std::vector<int32_t> valid_bytes_converted(this->valid_bytes_.begin(),

this->valid_bytes_.end());

auto cast_values = internal::MakeLazyRange(

[&draws_converted](int64_t index) {

return static_cast<T>(draws_converted[index]);

},

size);

auto cast_valid = internal::MakeLazyRange(

[&valid_bytes_converted](int64_t index) {

return static_cast<bool>(valid_bytes_converted[index]);

},

size);

ASSERT_OK(this->builder_->AppendValues(cast_values.begin(), cast_values.end(),

cast_valid.begin()));

ASSERT_OK(this->builder_nn_->AppendValues(cast_values.begin(), cast_values.end()));

ASSERT_EQ(size, this->builder_->length());

ASSERT_GE(size, this->builder_->capacity());

ASSERT_EQ(size, this->builder_->length());

ASSERT_GE(size, this->builder_->capacity());

this->Check(this->builder_, true);

this->Check(this->builder_nn_, false);

}

TYPED_TEST(TestPrimitiveBuilder, TestZeroPadded) {

DECL_T();

int64_t size = 10000;

this->RandomData(size);

std::vector<T>& draws = this->draws_;

std::vector<uint8_t>& valid_bytes = this->valid_bytes_;

// first slug

int64_t K = 1000;

ASSERT_OK(this->builder_->AppendValues(draws.data(), K, valid_bytes.data()));

std::shared_ptr<Array> out;

FinishAndCheckPadding(this->builder_.get(), &out);

}

TYPED_TEST(TestPrimitiveBuilder, TestAppendValuesStdBool) {

// ARROW-1383

DECL_T();

int64_t size = 10000;

this->RandomData(size);

std::vector<T>& draws = this->draws_;

std::vector<bool> is_valid;

// first slug

int64_t K = 1000;

for (int64_t i = 0; i < K; ++i) {

is_valid.push_back(this->valid_bytes_[i] != 0);

}

ASSERT_OK(this->builder_->AppendValues(draws.data(), K, is_valid));

ASSERT_OK(this->builder_nn_->AppendValues(draws.data(), K));

ASSERT_EQ(1000, this->builder_->length());

ASSERT_EQ(1000, this->builder_->capacity());

ASSERT_EQ(1000, this->builder_nn_->length());

ASSERT_EQ(1000, this->builder_nn_->capacity());

// Append the next 9000

is_valid.clear();

std::vector<T> partial_draws;

for (int64_t i = K; i < size; ++i) {

partial_draws.push_back(draws[i]);

is_valid.push_back(this->valid_bytes_[i] != 0);

}

ASSERT_OK(this->builder_->AppendValues(partial_draws, is_valid));

ASSERT_OK(this->builder_nn_->AppendValues(partial_draws));

ASSERT_EQ(size, this->builder_->length());

ASSERT_GE(size, this->builder_->capacity());

ASSERT_EQ(size, this->builder_nn_->length());

ASSERT_GE(size, this->builder_->capacity());

this->Check(this->builder_, true);

this->Check(this->builder_nn_, false);

}

TYPED_TEST(TestPrimitiveBuilder, TestAdvance) {

int64_t n = 1000;

ASSERT_OK(this->builder_->Reserve(n));

ASSERT_OK(this->builder_->Advance(100));

ASSERT_EQ(100, this->builder_->length());

ASSERT_OK(this->builder_->Advance(900));

int64_t too_many = this->builder_->capacity() - 1000 + 1;

ASSERT_RAISES(Invalid, this->builder_->Advance(too_many));

}

TYPED_TEST(TestPrimitiveBuilder, TestResize) {

int64_t cap = kMinBuilderCapacity * 2;

ASSERT_OK(this->builder_->Reserve(cap));

ASSERT_EQ(cap, this->builder_->capacity());

}

TYPED_TEST(TestPrimitiveBuilder, TestReserve) {

ASSERT_OK(this->builder_->Reserve(10));

ASSERT_EQ(0, this->builder_->length());

ASSERT_EQ(kMinBuilderCapacity, this->builder_->capacity());

ASSERT_OK(this->builder_->Reserve(100));

ASSERT_EQ(0, this->builder_->length());

ASSERT_GE(100, this->builder_->capacity());

ASSERT_OK(this->builder_->Advance(100));

ASSERT_EQ(100, this->builder_->length());

ASSERT_GE(100, this->builder_->capacity());

ASSERT_RAISES(Invalid, this->builder_->Resize(1));

}

TEST(TestBooleanBuilder, AppendNullsAdvanceBuilder) {

BooleanBuilder builder;

std::vector<uint8_t> values = {1, 0, 0, 1};

std::vector<uint8_t> is_valid = {1, 1, 0, 1};

std::shared_ptr<Array> arr;

ASSERT_OK(builder.AppendValues(values.data(), 2));

ASSERT_OK(builder.AppendNulls(1));

ASSERT_OK(builder.AppendValues(values.data() + 3, 1));

ASSERT_OK(builder.Finish(&arr));

ASSERT_EQ(1, arr->null_count());

const auto& barr = static_cast<const BooleanArray&>(*arr);

ASSERT_TRUE(barr.Value(0));

ASSERT_FALSE(barr.Value(1));

ASSERT_TRUE(barr.IsNull(2));

ASSERT_TRUE(barr.Value(3));

}

TEST(TestBooleanBuilder, TestStdBoolVectorAppend) {

BooleanBuilder builder;

BooleanBuilder builder_nn;

std::vector<bool> values, is_valid;

const int length = 10000;

random_is_valid(length, 0.5, &values);

random_is_valid(length, 0.1, &is_valid);

const int chunksize = 1000;

for (int chunk = 0; chunk < length / chunksize; ++chunk) {

std::vector<bool> chunk_values, chunk_is_valid;

for (int i = chunk * chunksize; i < (chunk + 1) * chunksize; ++i) {

chunk_values.push_back(values[i]);

chunk_is_valid.push_back(is_valid[i]);

}

ASSERT_OK(builder.AppendValues(chunk_values, chunk_is_valid));

ASSERT_OK(builder_nn.AppendValues(chunk_values));

}

std::shared_ptr<Array> result, result_nn;

ASSERT_OK(builder.Finish(&result));

ASSERT_OK(builder_nn.Finish(&result_nn));

const auto& arr = checked_cast<const BooleanArray&>(*result);

const auto& arr_nn = checked_cast<const BooleanArray&>(*result_nn);