content: /*
   * 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<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        final List<Integer> 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<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        final List<Integer> 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<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        final List<Integer> 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<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        final List<Integer> 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<String, Integer> value1 = new HashMap<>();
        value1.put("key1", 1);
        value1.put("key2", 2);
        final Map<String, Integer> 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<String, Integer> value1 = new HashMap<>();
        value1.put("key1", 1);
        value1.put("key2", 2);
        final Map<String, Integer> value3 = new HashMap<>();
        value3.put("key1", 3);
        value3.put("key2", 4);
  
        assertThat(
            structVector.getValueIterable(),
            IsIterableContainingInOrder.contains(value1, null, value3));
      }
    }
  }
  