Fix more tests

Author: rahulketch

parquet-column/src/test/java/org/apache/parquet/internal/column/columnindex/TestBinaryTruncator.java

@@ -32,6 +32,8 @@
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.CharsetDecoder;
 import java.nio.charset.CodingErrorAction;
@@ -93,7 +95,7 @@ public void testContractNonStringTypes() {
     testTruncator(
         Types.required(FIXED_LEN_BYTE_ARRAY).length(12).as(INTERVAL).named("test_fixed_interval"), false);
     testTruncator(Types.required(BINARY).as(DECIMAL).precision(10).scale(2).named("test_binary_decimal"), false);
-    testTruncator(Types.required(INT96).named("test_int96"), false);
+    testInt96Truncator(Types.required(INT96).named("test_int96"), false);
   }
 
   @Test
@@ -157,6 +159,22 @@ public void testContractStringTypes() {
     testTruncator(Types.required(FIXED_LEN_BYTE_ARRAY).length(5).named("test_fixed"), true);
   }
 
+  private Binary createInt96Value(long nanoseconds, int julianDay) {
+    return Binary.fromConstantByteArray(
+        ByteBuffer.allocate(12)
+            .order(ByteOrder.LITTLE_ENDIAN)
+            .putLong(nanoseconds)
+            .putInt(julianDay)
+            .array());
+  }
+
+  private void testInt96Truncator(PrimitiveType type, boolean strict) {
+    BinaryTruncator truncator = BinaryTruncator.getTruncator(type);
+    Comparator<Binary> comparator = type.comparator();
+    checkContract(truncator, comparator, createInt96Value(0, 2458849), strict, strict);
+    checkContract(truncator, comparator, createInt96Value(100, 128849), strict, strict);
+  }
+
   private void testTruncator(PrimitiveType type, boolean strict) {
     BinaryTruncator truncator = BinaryTruncator.getTruncator(type);
     Comparator<Binary> comparator = type.comparator();

parquet-column/src/test/java/org/apache/parquet/schema/TestTypeBuilders.java

@@ -1334,7 +1334,7 @@ public void testTypeConstructionWithUndefinedColumnOrder() {
   @Test
   public void testTypeConstructionWithTypeDefinedColumnOrder() {
     PrimitiveTypeName[] types =
-        new PrimitiveTypeName[] {BOOLEAN, INT32, INT64, FLOAT, DOUBLE, BINARY, FIXED_LEN_BYTE_ARRAY};
+        new PrimitiveTypeName[] {BOOLEAN, INT32, INT64, INT96, FLOAT, DOUBLE, BINARY, FIXED_LEN_BYTE_ARRAY};
     for (PrimitiveTypeName type : types) {
       String name = type.toString() + "_";
       int len = type == FIXED_LEN_BYTE_ARRAY ? 42 : 0;
@@ -1350,8 +1350,6 @@ public void testTypeConstructionWithTypeDefinedColumnOrder() {
 
   @Test
   public void testTypeConstructionWithUnsupportedColumnOrder() {
-    assertThrows(null, IllegalArgumentException.class, (Callable<PrimitiveType>) () ->
-        Types.optional(INT96).columnOrder(ColumnOrder.typeDefined()).named("int96_unsupported"));
     assertThrows(null, IllegalArgumentException.class, (Callable<PrimitiveType>)
         () -> Types.optional(FIXED_LEN_BYTE_ARRAY)
             .length(12)

parquet-column/src/test/java/org/apache/parquet/schema/TestTypeBuildersWithLogicalTypes.java

@@ -349,9 +349,6 @@ public void testIntervalAnnotationRejectsNonFixed12() {
 
   @Test
   public void testTypeConstructionWithUnsupportedColumnOrder() {
-    assertThrows(null, IllegalArgumentException.class, () -> Types.optional(INT96)
-        .columnOrder(ColumnOrder.typeDefined())
-        .named("int96_unsupported"));
     assertThrows(null, IllegalArgumentException.class, () -> Types.optional(PrimitiveTypeName.FIXED_LEN_BYTE_ARRAY)
         .length(12)
         .as(LogicalTypeAnnotation.IntervalLogicalTypeAnnotation.getInstance())

parquet-hadoop/src/test/java/org/apache/parquet/statistics/RandomValues.java

@@ -20,6 +20,8 @@
 package org.apache.parquet.statistics;
 
 import java.math.BigInteger;
+import java.nio.ByteOrder;
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Iterator;
@@ -213,11 +215,11 @@ public Long nextValue() {
     }
   }
 
-  public static class Int96Generator extends RandomBinaryBase<BigInteger> {
-    private final RandomRange<BigInteger> randomRange = new RandomRange<BigInteger>(randomInt96(), randomInt96());
-    private final BigInteger minimum = randomRange.minimum();
-    private final BigInteger maximum = randomRange.maximum();
-    private final BigInteger range = maximum.subtract(minimum);
+  public static class Int96Generator extends RandomBinaryBase<Binary> {
+    private final RandomRange<Integer> randomRangeJulianDay = new RandomRange<>(randomInt(), randomInt());
+    private final int minimumJulianDay = randomRangeJulianDay.minimum();
+    private final int maximumJulianDay = randomRangeJulianDay.maximum();
+    private final int rangeJulianDay = (maximumJulianDay - minimumJulianDay);
 
     private static final int INT_96_LENGTH = 12;
 
@@ -226,13 +228,21 @@ public Int96Generator(long seed) {
     }
 
     @Override
-    public BigInteger nextValue() {
-      return (minimum.add(randomInt96(range)));
+    public Binary nextValue() {
+      long timeOfDay = randomLong();
+      int julianDay = minimumJulianDay + randomPositiveInt(rangeJulianDay);
+
+      ByteBuffer.wrap(buffer)
+          .order(ByteOrder.LITTLE_ENDIAN)
+          .putLong(timeOfDay)
+          .putInt(julianDay);
+
+      return Binary.fromReusedByteArray(buffer, 0, INT_96_LENGTH);
     }
 
     @Override
     public Binary nextBinaryValue() {
-      return FixedBinaryTestUtils.getFixedBinary(INT_96_LENGTH, nextValue());
+      return nextValue();
     }
   }