From bff79a2cdf285cb0340947a65f0ce635f03da64f Mon Sep 17 00:00:00 2001 From: Norman Jordan Date: Mon, 17 Jun 2024 10:19:56 -0700 Subject: [PATCH] Added unit tests for ValueIterableVector implementations --- java/vector/pom.xml | 5 + .../arrow/vector/TestValueVectorIterable.java | 909 ++++++++++++++++++ 2 files changed, 914 insertions(+) create mode 100644 java/vector/src/test/java/org/apache/arrow/vector/TestValueVectorIterable.java diff --git a/java/vector/pom.xml b/java/vector/pom.xml index ddde5197700c7..aa022b0c2e3a4 100644 --- a/java/vector/pom.xml +++ b/java/vector/pom.xml @@ -86,6 +86,11 @@ under the License. org.slf4j slf4j-api + + org.hamcrest + hamcrest + test + diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestValueVectorIterable.java b/java/vector/src/test/java/org/apache/arrow/vector/TestValueVectorIterable.java new file mode 100644 index 0000000000000..e6b79e89b9942 --- /dev/null +++ b/java/vector/src/test/java/org/apache/arrow/vector/TestValueVectorIterable.java @@ -0,0 +1,909 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.arrow.vector; + +import static org.hamcrest.MatcherAssert.assertThat; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.time.Duration; +import java.time.LocalDateTime; +import java.time.Period; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.apache.arrow.memory.BufferAllocator; +import org.apache.arrow.vector.complex.FixedSizeListVector; +import org.apache.arrow.vector.complex.LargeListVector; +import org.apache.arrow.vector.complex.ListVector; +import org.apache.arrow.vector.complex.ListViewVector; +import org.apache.arrow.vector.complex.NonNullableStructVector; +import org.apache.arrow.vector.complex.StructVector; +import org.apache.arrow.vector.complex.impl.NullableStructWriter; +import org.apache.arrow.vector.complex.impl.UnionLargeListWriter; +import org.apache.arrow.vector.complex.impl.UnionListViewWriter; +import org.apache.arrow.vector.complex.impl.UnionListWriter; +import org.apache.arrow.vector.types.TimeUnit; +import org.apache.arrow.vector.types.Types; +import org.apache.arrow.vector.types.pojo.ArrowType; +import org.apache.arrow.vector.types.pojo.Field; +import org.apache.arrow.vector.types.pojo.FieldType; +import org.apache.arrow.vector.util.Text; +import org.hamcrest.collection.IsIterableContainingInOrder; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class TestValueVectorIterable { + private BufferAllocator allocator; + + @BeforeEach + public void init() { + allocator = new DirtyRootAllocator(Long.MAX_VALUE, (byte) 100); + } + + @AfterEach + public void terminate() throws Exception { + allocator.close(); + } + + @Test + public void testBigIntVectorIterable() { + try (final BigIntVector bigIntVector = new BigIntVector("bigInt", allocator)) { + bigIntVector.allocateNew(3); + bigIntVector.setSafe(0, 6); + bigIntVector.setSafe(1, 2); + bigIntVector.setSafe(2, 19); + bigIntVector.setValueCount(3); + + assertThat( + bigIntVector.getValueIterable(), IsIterableContainingInOrder.contains(6L, 2L, 19L)); + } + } + + @Test + public void testBitVectorIterable() { + try (final BitVector bitVector = new BitVector("bit", allocator)) { + bitVector.allocateNew(3); + bitVector.setSafe(0, 0); + bitVector.setNull(1); + bitVector.setSafe(2, 1); + bitVector.setValueCount(3); + + assertThat( + bitVector.getValueIterable(), IsIterableContainingInOrder.contains(false, null, true)); + } + } + + @Test + public void testDateDayVectorIterable() { + try (final DateDayVector dateDayVector = new DateDayVector("dateDay", allocator)) { + dateDayVector.allocateNew(3); + dateDayVector.setSafe(0, 30000); + dateDayVector.setNull(1); + dateDayVector.setSafe(2, 555); + dateDayVector.setValueCount(3); + + assertThat( + dateDayVector.getValueIterable(), IsIterableContainingInOrder.contains(30000, null, 555)); + } + } + + @Test + public void testDateMilliVectorIterable() { + try (final DateMilliVector dateMilliVector = new DateMilliVector("dateMilli", allocator)) { + dateMilliVector.allocateNew(3); + dateMilliVector.setSafe(0, 30000L); + dateMilliVector.setNull(1); + dateMilliVector.setSafe(2, 555L); + dateMilliVector.setValueCount(3); + + final LocalDateTime value1 = LocalDateTime.ofEpochSecond(30L, 0, ZoneOffset.ofHours(0)); + final LocalDateTime value3 = + LocalDateTime.ofEpochSecond(0L, 555000000, ZoneOffset.ofHours(0)); + assertThat( + dateMilliVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testDecimal256VectorIterable() { + try (final Decimal256Vector decimal256Vector = + new Decimal256Vector("decimal256", allocator, 8, 2)) { + decimal256Vector.allocateNew(3); + decimal256Vector.setSafe(0, 30000L); + decimal256Vector.setNull(1); + decimal256Vector.setSafe(2, 555L); + decimal256Vector.setValueCount(3); + + final BigDecimal value1 = new BigDecimal(300L).setScale(2, RoundingMode.HALF_UP); + final BigDecimal value3 = + new BigDecimal(555L).scaleByPowerOfTen(-2).setScale(2, RoundingMode.HALF_UP); + assertThat( + decimal256Vector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testDecimalVectorIterable() { + try (final DecimalVector decimalVector = new DecimalVector("decimalDay", allocator, 8, 2)) { + decimalVector.allocateNew(3); + decimalVector.setSafe(0, 30000); + decimalVector.setNull(1); + decimalVector.setSafe(2, 555); + decimalVector.setValueCount(3); + + final BigDecimal value1 = new BigDecimal(300L).setScale(2, RoundingMode.HALF_UP); + final BigDecimal value3 = + new BigDecimal(555L).scaleByPowerOfTen(-2).setScale(2, RoundingMode.HALF_UP); + assertThat( + decimalVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testDurationVectorIterable() { + try (final DurationVector durationVector = + new DurationVector( + Field.nullablePrimitive("duration", new ArrowType.Duration(TimeUnit.MILLISECOND)), + allocator)) { + durationVector.allocateNew(3); + durationVector.setSafe(0, 30000); + durationVector.setNull(1); + durationVector.setSafe(2, 555); + durationVector.setValueCount(3); + + final Duration value1 = Duration.ofMillis(30000); + final Duration value3 = Duration.ofMillis(555); + assertThat( + durationVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testFixedSizeBinaryVectorIterable() { + try (final FixedSizeBinaryVector fixedSizeBinaryVector = + new FixedSizeBinaryVector("binary", allocator, 4)) { + final byte[] value1 = new byte[] {0, 0, 0, 1}; + final byte[] value3 = new byte[] {1, 0, 0, 0}; + + fixedSizeBinaryVector.allocateNew(3); + fixedSizeBinaryVector.setSafe(0, value1); + fixedSizeBinaryVector.setNull(1); + fixedSizeBinaryVector.setSafe(2, value3); + fixedSizeBinaryVector.setValueCount(3); + + assertThat( + fixedSizeBinaryVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testFloat2VectorIterable() { + try (final Float2Vector float2Vector = new Float2Vector("float2", allocator)) { + float2Vector.allocateNew(3); + float2Vector.setSafe(0, (short) 7777); + float2Vector.setNull(1); + float2Vector.setSafe(2, (short) 5); + float2Vector.setValueCount(3); + + assertThat( + float2Vector.getValueIterable(), + IsIterableContainingInOrder.contains((short) 7777, null, (short) 5)); + } + } + + @Test + public void testFloat4VectorIterable() { + try (final Float4Vector float4Vector = new Float4Vector("float4", allocator)) { + float4Vector.allocateNew(3); + float4Vector.setSafe(0, 16.32f); + float4Vector.setNull(1); + float4Vector.setSafe(2, -10.75f); + float4Vector.setValueCount(3); + + assertThat( + float4Vector.getValueIterable(), + IsIterableContainingInOrder.contains(16.32f, null, -10.75f)); + } + } + + @Test + public void testFloat8VectorIterable() { + try (final Float8Vector float8Vector = new Float8Vector("float8", allocator)) { + float8Vector.allocateNew(3); + float8Vector.setSafe(0, 16.32); + float8Vector.setNull(1); + float8Vector.setSafe(2, -10.75); + float8Vector.setValueCount(3); + + assertThat( + float8Vector.getValueIterable(), + IsIterableContainingInOrder.contains(16.32, null, -10.75)); + } + } + + @Test + public void testIntVectorIterable() { + try (final IntVector intVector = new IntVector("int", allocator)) { + intVector.allocateNew(3); + intVector.setSafe(0, 78); + intVector.setNull(1); + intVector.setSafe(2, -93); + intVector.setValueCount(3); + + assertThat(intVector.getValueIterable(), IsIterableContainingInOrder.contains(78, null, -93)); + } + } + + @Test + public void testIntervalDayVectorIterable() { + try (final IntervalDayVector intervalDayVector = + new IntervalDayVector("intervalDay", allocator)) { + intervalDayVector.allocateNew(3); + intervalDayVector.setSafe(0, 63, 0); + intervalDayVector.setNull(1); + intervalDayVector.setSafe(2, 555, 0); + intervalDayVector.setValueCount(3); + + final Duration value1 = Duration.ofDays(63); + final Duration value3 = Duration.ofDays(555); + assertThat( + intervalDayVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testIntervalMonthDayNanoVectorIterable() { + try (final IntervalMonthDayNanoVector intervalMonthDayNanoVector = + new IntervalMonthDayNanoVector("intervalMonthDayNano", allocator)) { + intervalMonthDayNanoVector.allocateNew(3); + intervalMonthDayNanoVector.setSafe(0, 3, 4, 0); + intervalMonthDayNanoVector.setNull(1); + intervalMonthDayNanoVector.setSafe(2, 7, 18, 0); + intervalMonthDayNanoVector.setValueCount(3); + + final PeriodDuration value1 = new PeriodDuration(Period.of(0, 3, 4), Duration.ofSeconds(0)); + final PeriodDuration value3 = new PeriodDuration(Period.of(0, 7, 18), Duration.ofSeconds(0)); + assertThat( + intervalMonthDayNanoVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testIntervalYearVectorIterable() { + try (final IntervalYearVector intervalYearVector = + new IntervalYearVector("intervalYear", allocator)) { + intervalYearVector.allocateNew(3); + intervalYearVector.setSafe(0, 3); + intervalYearVector.setNull(1); + intervalYearVector.setSafe(2, 17); + intervalYearVector.setValueCount(3); + + final Period value1 = Period.ofMonths(3); + final Period value3 = Period.ofMonths(17); + assertThat( + intervalYearVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testLargeVarBinaryVectorIterable() { + try (final LargeVarBinaryVector largeVarBinaryVector = + new LargeVarBinaryVector("largeVarBinary", allocator)) { + final byte[] value1 = new byte[] {0, 0, 0, 1}; + final byte[] value3 = new byte[] {1, 0, 0}; + + largeVarBinaryVector.allocateNew(3); + largeVarBinaryVector.setSafe(0, value1); + largeVarBinaryVector.setNull(1); + largeVarBinaryVector.setSafe(2, value3); + largeVarBinaryVector.setValueCount(3); + + assertThat( + largeVarBinaryVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testLargeVarCharVectorIterable() { + try (final LargeVarCharVector largeVarCharVector = + new LargeVarCharVector("largeVarChar", allocator)) { + final Text value1 = new Text("hello"); + final Text value3 = new Text("worlds"); + + largeVarCharVector.allocateNew(3); + largeVarCharVector.setSafe(0, value1); + largeVarCharVector.setNull(1); + largeVarCharVector.setSafe(2, value3); + largeVarCharVector.setValueCount(3); + + assertThat( + largeVarCharVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testNullVectorIterable() { + try (final NullVector nullVector = new NullVector("null", 3)) { + assertThat( + nullVector.getValueIterable(), IsIterableContainingInOrder.contains(null, null, null)); + } + } + + @Test + public void testSmallIntVectorIterable() { + try (final SmallIntVector smallIntVector = new SmallIntVector("smallInt", allocator)) { + smallIntVector.allocateNew(3); + smallIntVector.setSafe(0, 78); + smallIntVector.setNull(1); + smallIntVector.setSafe(2, -93); + smallIntVector.setValueCount(3); + + assertThat( + smallIntVector.getValueIterable(), + IsIterableContainingInOrder.contains((short) 78, null, (short) -93)); + } + } + + @Test + public void testTimeMicroVectorIterable() { + try (final TimeMicroVector timeMicroVector = new TimeMicroVector("timeMicro", allocator)) { + timeMicroVector.allocateNew(3); + timeMicroVector.setSafe(0, 70000); + timeMicroVector.setNull(1); + timeMicroVector.setSafe(2, 555); + timeMicroVector.setValueCount(3); + + assertThat( + timeMicroVector.getValueIterable(), + IsIterableContainingInOrder.contains(70000L, null, 555L)); + } + } + + @Test + public void testTimeMilliVectorIterable() { + try (final TimeMilliVector timeMilliVector = new TimeMilliVector("timeMilli", allocator)) { + timeMilliVector.allocateNew(3); + timeMilliVector.setSafe(0, 70000); + timeMilliVector.setNull(1); + timeMilliVector.setSafe(2, 555); + timeMilliVector.setValueCount(3); + + final LocalDateTime value1 = LocalDateTime.ofEpochSecond(70L, 0, ZoneOffset.ofHours(0)); + final LocalDateTime value3 = + LocalDateTime.ofEpochSecond(0L, 555000000, ZoneOffset.ofHours(0)); + assertThat( + timeMilliVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testTimeNanoVectorIterable() { + try (final TimeNanoVector timeNanoVector = new TimeNanoVector("timeNano", allocator)) { + timeNanoVector.allocateNew(3); + timeNanoVector.setSafe(0, 70000); + timeNanoVector.setNull(1); + timeNanoVector.setSafe(2, 555); + timeNanoVector.setValueCount(3); + + assertThat( + timeNanoVector.getValueIterable(), + IsIterableContainingInOrder.contains(70000L, null, 555L)); + } + } + + @Test + public void testTimeSecVectorIterable() { + try (final TimeSecVector timeSecVector = new TimeSecVector("timeSec", allocator)) { + timeSecVector.allocateNew(3); + timeSecVector.setSafe(0, 70000); + timeSecVector.setNull(1); + timeSecVector.setSafe(2, 555); + timeSecVector.setValueCount(3); + + assertThat( + timeSecVector.getValueIterable(), IsIterableContainingInOrder.contains(70000, null, 555)); + } + } + + @Test + public void testTimeStampMicroTZVectorIterable() { + try (final TimeStampMicroTZVector timeStampMicroTzVector = + new TimeStampMicroTZVector("timeStampMicroTZ", allocator, "UTC")) { + timeStampMicroTzVector.allocateNew(3); + timeStampMicroTzVector.setSafe(0, 70000); + timeStampMicroTzVector.setNull(1); + timeStampMicroTzVector.setSafe(2, 555); + timeStampMicroTzVector.setValueCount(3); + + assertThat( + timeStampMicroTzVector.getValueIterable(), + IsIterableContainingInOrder.contains(70000L, null, 555L)); + } + } + + @Test + public void testTimeStampMicroVectorIterable() { + try (final TimeStampMicroVector timeStampMicroVector = + new TimeStampMicroVector("timeStampMicro", allocator)) { + timeStampMicroVector.allocateNew(3); + timeStampMicroVector.setSafe(0, 70000); + timeStampMicroVector.setNull(1); + timeStampMicroVector.setSafe(2, 555); + timeStampMicroVector.setValueCount(3); + + final LocalDateTime value1 = LocalDateTime.ofEpochSecond(0L, 70000000, ZoneOffset.ofHours(0)); + final LocalDateTime value3 = LocalDateTime.ofEpochSecond(0L, 555000, ZoneOffset.ofHours(0)); + assertThat( + timeStampMicroVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testTimeStampMilliTZVectorIterable() { + try (final TimeStampMilliTZVector timeStampMilliTzVector = + new TimeStampMilliTZVector("timeStampMilliTZ", allocator, "UTC")) { + timeStampMilliTzVector.allocateNew(3); + timeStampMilliTzVector.setSafe(0, 70000); + timeStampMilliTzVector.setNull(1); + timeStampMilliTzVector.setSafe(2, 555); + timeStampMilliTzVector.setValueCount(3); + + assertThat( + timeStampMilliTzVector.getValueIterable(), + IsIterableContainingInOrder.contains(70000L, null, 555L)); + } + } + + @Test + public void testTimeStampMilliVectorIterable() { + try (final TimeStampMilliVector timeStampMilliVector = + new TimeStampMilliVector("timeStampMilli", allocator)) { + timeStampMilliVector.allocateNew(3); + timeStampMilliVector.setSafe(0, 70000); + timeStampMilliVector.setNull(1); + timeStampMilliVector.setSafe(2, 555); + timeStampMilliVector.setValueCount(3); + + final LocalDateTime value1 = LocalDateTime.ofEpochSecond(70L, 0, ZoneOffset.ofHours(0)); + final LocalDateTime value3 = + LocalDateTime.ofEpochSecond(0L, 555000000, ZoneOffset.ofHours(0)); + assertThat( + timeStampMilliVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testTimeStampNanoTZVectorIterable() { + try (final TimeStampNanoTZVector timeStampNanoTzVector = + new TimeStampNanoTZVector("timeStampNanoTZ", allocator, "UTC")) { + timeStampNanoTzVector.allocateNew(3); + timeStampNanoTzVector.setSafe(0, 70000); + timeStampNanoTzVector.setNull(1); + timeStampNanoTzVector.setSafe(2, 555); + timeStampNanoTzVector.setValueCount(3); + + assertThat( + timeStampNanoTzVector.getValueIterable(), + IsIterableContainingInOrder.contains(70000L, null, 555L)); + } + } + + @Test + public void testTimeStampNanoVectorIterable() { + try (final TimeStampNanoVector timeStampNanoVector = + new TimeStampNanoVector("timeStampNano", allocator)) { + timeStampNanoVector.allocateNew(3); + timeStampNanoVector.setSafe(0, 70000); + timeStampNanoVector.setNull(1); + timeStampNanoVector.setSafe(2, 555); + timeStampNanoVector.setValueCount(3); + + final LocalDateTime value1 = LocalDateTime.ofEpochSecond(0L, 70000, ZoneOffset.ofHours(0)); + final LocalDateTime value3 = LocalDateTime.ofEpochSecond(0L, 555, ZoneOffset.ofHours(0)); + assertThat( + timeStampNanoVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testTimeStampSecTZVectorIterable() { + try (final TimeStampSecTZVector timeStampSecTzVector = + new TimeStampSecTZVector("timeStampSecTZ", allocator, "UTC")) { + timeStampSecTzVector.allocateNew(3); + timeStampSecTzVector.setSafe(0, 70000); + timeStampSecTzVector.setNull(1); + timeStampSecTzVector.setSafe(2, 555); + timeStampSecTzVector.setValueCount(3); + + assertThat( + timeStampSecTzVector.getValueIterable(), + IsIterableContainingInOrder.contains(70000L, null, 555L)); + } + } + + @Test + public void testTimeStampSecVectorIterable() { + try (final TimeStampSecVector timeStampSecVector = + new TimeStampSecVector("timeStampSec", allocator)) { + timeStampSecVector.allocateNew(3); + timeStampSecVector.setSafe(0, 70000); + timeStampSecVector.setNull(1); + timeStampSecVector.setSafe(2, 555); + timeStampSecVector.setValueCount(3); + + final LocalDateTime value1 = LocalDateTime.ofEpochSecond(70000L, 0, ZoneOffset.ofHours(0)); + final LocalDateTime value3 = LocalDateTime.ofEpochSecond(555L, 0, ZoneOffset.ofHours(0)); + assertThat( + timeStampSecVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testTinyIntVectorIterable() { + try (final TinyIntVector tinyIntVector = new TinyIntVector("tinyInt", allocator)) { + tinyIntVector.allocateNew(3); + tinyIntVector.setSafe(0, 8); + tinyIntVector.setNull(1); + tinyIntVector.setSafe(2, -17); + tinyIntVector.setValueCount(3); + + assertThat( + tinyIntVector.getValueIterable(), + IsIterableContainingInOrder.contains((byte) 8, null, (byte) -17)); + } + } + + @Test + public void testUInt1VectorIterable() { + try (final UInt1Vector uint1Vector = new UInt1Vector("uint1", allocator)) { + uint1Vector.allocateNew(3); + uint1Vector.setSafe(0, 8); + uint1Vector.setNull(1); + uint1Vector.setSafe(2, 101); + uint1Vector.setValueCount(3); + + assertThat( + uint1Vector.getValueIterable(), + IsIterableContainingInOrder.contains((byte) 8, null, (byte) 101)); + } + } + + @Test + public void testUInt2VectorIterable() { + try (final UInt2Vector uint2Vector = new UInt2Vector("uint2", allocator)) { + uint2Vector.allocateNew(3); + uint2Vector.setSafe(0, 78); + uint2Vector.setNull(1); + uint2Vector.setSafe(2, 3456); + uint2Vector.setValueCount(3); + + assertThat( + uint2Vector.getValueIterable(), + IsIterableContainingInOrder.contains((char) 78, null, (char) 3456)); + } + } + + @Test + public void testUInt4VectorIterable() { + try (final UInt4Vector uint4Vector = new UInt4Vector("uint4", allocator)) { + uint4Vector.allocateNew(3); + uint4Vector.setSafe(0, 78); + uint4Vector.setNull(1); + uint4Vector.setSafe(2, 3456); + uint4Vector.setValueCount(3); + + assertThat( + uint4Vector.getValueIterable(), IsIterableContainingInOrder.contains(78, null, 3456)); + } + } + + @Test + public void testUInt8VectorIterable() { + try (final UInt8Vector uint8Vector = new UInt8Vector("uint8", allocator)) { + uint8Vector.allocateNew(3); + uint8Vector.setSafe(0, 6); + uint8Vector.setSafe(1, 2); + uint8Vector.setSafe(2, 19); + uint8Vector.setValueCount(3); + + assertThat(uint8Vector.getValueIterable(), IsIterableContainingInOrder.contains(6L, 2L, 19L)); + } + } + + @Test + public void testVarBinaryVectorIterable() { + try (final VarBinaryVector varBinaryVector = new VarBinaryVector("varBinary", allocator)) { + final byte[] value1 = new byte[] {0, 0, 0, 1}; + final byte[] value3 = new byte[] {1, 0, 0}; + + varBinaryVector.allocateNew(3); + varBinaryVector.setSafe(0, value1); + varBinaryVector.setNull(1); + varBinaryVector.setSafe(2, value3); + varBinaryVector.setValueCount(3); + + assertThat( + varBinaryVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testVarCharVectorIterable() { + try (final VarCharVector varCharVector = new VarCharVector("varChar", allocator)) { + final Text value1 = new Text("hello"); + final Text value3 = new Text("worlds"); + + varCharVector.allocateNew(3); + varCharVector.setSafe(0, value1); + varCharVector.setNull(1); + varCharVector.setSafe(2, value3); + varCharVector.setValueCount(3); + + assertThat( + varCharVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testViewVarBinaryVectorIterable() { + try (final ViewVarBinaryVector viewVarBinaryVector = + new ViewVarBinaryVector("viewVarBinary", allocator)) { + final byte[] value1 = new byte[] {0, 0, 0, 1}; + final byte[] value3 = new byte[] {1, 0, 0}; + + viewVarBinaryVector.allocateNew(3); + viewVarBinaryVector.setSafe(0, value1); + viewVarBinaryVector.setNull(1); + viewVarBinaryVector.setSafe(2, value3); + viewVarBinaryVector.setValueCount(3); + + assertThat( + viewVarBinaryVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testViewVarCharVectorIterable() { + try (final ViewVarCharVector viewVarCharVector = + new ViewVarCharVector("viewVarChar", allocator)) { + final Text value1 = new Text("hello"); + final Text value3 = new Text("worlds"); + + viewVarCharVector.allocateNew(3); + viewVarCharVector.setSafe(0, value1); + viewVarCharVector.setNull(1); + viewVarCharVector.setSafe(2, value3); + viewVarCharVector.setValueCount(3); + + assertThat( + viewVarCharVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } + + @Test + public void testFIxedSizeListVectorIterable() { + try (final FixedSizeListVector fixedSizeListVector = + new FixedSizeListVector( + "fixedSizeList", allocator, FieldType.nullable(new ArrowType.FixedSizeList(3)), null)) { + final IntVector listVector = + (IntVector) + fixedSizeListVector + .addOrGetVector(FieldType.nullable(Types.MinorType.INT.getType())) + .getVector(); + listVector.setSafe(0, 1); + listVector.setSafe(1, 2); + listVector.setSafe(2, 3); + listVector.setSafe(3, 4); + listVector.setSafe(4, 5); + listVector.setSafe(5, 6); + listVector.setValueCount(6); + fixedSizeListVector.setValueCount(2); + fixedSizeListVector.setNotNull(0); + fixedSizeListVector.setNotNull(1); + + final List list1 = new ArrayList<>(); + list1.add(1); + list1.add(2); + list1.add(3); + final List list2 = new ArrayList<>(); + list2.add(4); + list2.add(5); + list2.add(6); + + assertThat( + fixedSizeListVector.getValueIterable(), + IsIterableContainingInOrder.contains(list1, list2)); + } + } + + @Test + public void testLargeListVectorIterable() { + try (final LargeListVector largeListVector = LargeListVector.empty("largeList", allocator)) { + UnionLargeListWriter writer = largeListVector.getWriter(); + writer.allocate(); + + writer.startList(); + writer.integer().writeInt(1); + writer.integer().writeInt(2); + writer.integer().writeInt(3); + writer.endList(); + writer.startList(); + writer.integer().writeInt(4); + writer.integer().writeInt(5); + writer.endList(); + + largeListVector.setValueCount(2); + + final List list1 = new ArrayList<>(); + list1.add(1); + list1.add(2); + list1.add(3); + final List list2 = new ArrayList<>(); + list2.add(4); + list2.add(5); + + assertThat( + largeListVector.getValueIterable(), IsIterableContainingInOrder.contains(list1, list2)); + } + } + + @Test + public void testListVectorIterable() { + try (final ListVector listVector = ListVector.empty("largeList", allocator)) { + UnionListWriter writer = listVector.getWriter(); + writer.allocate(); + + writer.startList(); + writer.integer().writeInt(1); + writer.integer().writeInt(2); + writer.integer().writeInt(3); + writer.endList(); + writer.startList(); + writer.integer().writeInt(4); + writer.integer().writeInt(5); + writer.endList(); + + listVector.setValueCount(2); + + final List list1 = new ArrayList<>(); + list1.add(1); + list1.add(2); + list1.add(3); + final List list2 = new ArrayList<>(); + list2.add(4); + list2.add(5); + + assertThat(listVector.getValueIterable(), IsIterableContainingInOrder.contains(list1, list2)); + } + } + + @Test + public void testListViewVectorIterable() { + try (final ListViewVector listViewVector = ListViewVector.empty("largeList", allocator)) { + UnionListViewWriter writer = listViewVector.getWriter(); + writer.allocate(); + + writer.startList(); + writer.integer().writeInt(1); + writer.integer().writeInt(2); + writer.integer().writeInt(3); + writer.endList(); + writer.startList(); + writer.integer().writeInt(4); + writer.integer().writeInt(5); + writer.endList(); + + listViewVector.setValueCount(2); + + final List list1 = new ArrayList<>(); + list1.add(1); + list1.add(2); + list1.add(3); + final List list2 = new ArrayList<>(); + list2.add(4); + list2.add(5); + + assertThat( + listViewVector.getValueIterable(), IsIterableContainingInOrder.contains(list1, list2)); + } + } + + @Test + public void testNonNullableStructVectorIterable() { + try (final NonNullableStructVector nonNullableStructVector = + NonNullableStructVector.empty("nonNullableStruct", allocator)) { + nonNullableStructVector.setValueCount(2); + + IntVector key1Vector = + nonNullableStructVector.addOrGet( + "key1", FieldType.notNullable(new ArrowType.Int(32, true)), IntVector.class); + IntVector key2Vector = + nonNullableStructVector.addOrGet( + "key2", FieldType.notNullable(new ArrowType.Int(32, true)), IntVector.class); + key1Vector.setSafe(0, 1); + key1Vector.setSafe(1, 3); + key2Vector.setSafe(0, 2); + key2Vector.setSafe(1, 4); + key1Vector.setValueCount(2); + key2Vector.setValueCount(2); + + final Map value1 = new HashMap<>(); + value1.put("key1", 1); + value1.put("key2", 2); + final Map value2 = new HashMap<>(); + value2.put("key1", 3); + value2.put("key2", 4); + + assertThat( + nonNullableStructVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, value2)); + } + } + + @Test + public void testStructVectorIterable() { + try (final StructVector structVector = StructVector.empty("struct", allocator)) { + structVector.addOrGetList("struct"); + NullableStructWriter structWriter = structVector.getWriter(); + structWriter.setPosition(0); + structWriter.start(); + structWriter.integer("key1").writeInt(1); + structWriter.integer("key2").writeInt(2); + structWriter.end(); + structWriter.setPosition(2); + structWriter.start(); + structWriter.integer("key1").writeInt(3); + structWriter.integer("key2").writeInt(4); + structWriter.end(); + structWriter.setValueCount(3); + + final Map value1 = new HashMap<>(); + value1.put("key1", 1); + value1.put("key2", 2); + final Map value3 = new HashMap<>(); + value3.put("key1", 3); + value3.put("key2", 4); + + assertThat( + structVector.getValueIterable(), + IsIterableContainingInOrder.contains(value1, null, value3)); + } + } +}