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.junit.jupiter.api.Assertions.assertEquals;
  
  import java.time.Duration;
  import java.time.Period;
  import org.apache.arrow.memory.BufferAllocator;
  import org.apache.arrow.vector.holders.IntervalMonthDayNanoHolder;
  import org.apache.arrow.vector.holders.NullableIntervalMonthDayNanoHolder;
  import org.apache.arrow.vector.types.IntervalUnit;
  import org.apache.arrow.vector.types.Types;
  import org.apache.arrow.vector.types.pojo.ArrowType;
  import org.junit.jupiter.api.AfterEach;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  public class TestIntervalMonthDayNanoVector {
  
    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 testBasics() {
      try (final IntervalMonthDayNanoVector vector =
          new IntervalMonthDayNanoVector(/* name= */ "", allocator)) {
        int valueCount = 100;
        vector.setInitialCapacity(valueCount);
        vector.allocateNew();
        NullableIntervalMonthDayNanoHolder nullableHolder = new NullableIntervalMonthDayNanoHolder();
        nullableHolder.isSet = 1;
        nullableHolder.months = 2;
        nullableHolder.days = 20;
        nullableHolder.nanoseconds = 123;
        IntervalMonthDayNanoHolder holder = new IntervalMonthDayNanoHolder();
        holder.months = Integer.MIN_VALUE;
        holder.days = Integer.MIN_VALUE;
        holder.nanoseconds = Long.MIN_VALUE;
  
        vector.set(0, /* months= */ 1, /* days= */ 2, /* nanoseconds= */ -2);
        vector.setSafe(2, /* months= */ 1, /* days= */ 2, /* nanoseconds= */ -3);
        vector.setSafe(/* index= */ 4, nullableHolder);
        vector.set(3, holder);
        nullableHolder.isSet = 0;
        vector.setSafe(/* index= */ 5, nullableHolder);
        vector.setValueCount(5);
  
        assertEquals("P1M2D PT-0.000000002S ", vector.getAsStringBuilder(0).toString());
        assertEquals(null, vector.getAsStringBuilder(1));
        assertEquals("P1M2D PT-0.000000003S ", vector.getAsStringBuilder(2).toString());
        assertEquals(
            new PeriodDuration(
                Period.of(0, Integer.MIN_VALUE, Integer.MIN_VALUE), Duration.ofNanos(Long.MIN_VALUE)),
            vector.getObject(3));
        assertEquals("P2M20D PT0.000000123S ", vector.getAsStringBuilder(4).toString());
  
        assertEquals(null, vector.getObject(5));
  
        vector.get(1, nullableHolder);
        assertEquals(0, nullableHolder.isSet);
  
        vector.get(2, nullableHolder);
        assertEquals(1, nullableHolder.isSet);
        assertEquals(1, nullableHolder.months);
        assertEquals(2, nullableHolder.days);
        assertEquals(-3, nullableHolder.nanoseconds);
  
        IntervalMonthDayNanoVector.getDays(vector.valueBuffer, 2);
        assertEquals(1, IntervalMonthDayNanoVector.getMonths(vector.valueBuffer, 2));
        assertEquals(2, IntervalMonthDayNanoVector.getDays(vector.valueBuffer, 2));
        assertEquals(-3, IntervalMonthDayNanoVector.getNanoseconds(vector.valueBuffer, 2));
  
        assertEquals(0, vector.isSet(1));
        assertEquals(1, vector.isSet(2));
  
        assertEquals(Types.MinorType.INTERVALMONTHDAYNANO, vector.getMinorType());
        ArrowType fieldType = vector.getField().getType();
        assertEquals(ArrowType.ArrowTypeID.Interval, fieldType.getTypeID());
        ArrowType.Interval intervalType = (ArrowType.Interval) fieldType;
        assertEquals(IntervalUnit.MONTH_DAY_NANO, intervalType.getUnit());
      }
    }
  }
  