From 74a03f12fc43a9bb19dd97c040bd0cbec3c2576f Mon Sep 17 00:00:00 2001
From: "Brian S. O'Neill" <bronee@gmail.com>
Date: Thu, 15 May 2008 00:38:57 +0000
Subject: Moved utility comparators to util package.

---
 .../amazon/carbonado/cursor/TestComparators.java   | 785 ---------------------
 .../com/amazon/carbonado/util/TestComparators.java | 785 +++++++++++++++++++++
 2 files changed, 785 insertions(+), 785 deletions(-)
 delete mode 100644 src/test/java/com/amazon/carbonado/cursor/TestComparators.java
 create mode 100644 src/test/java/com/amazon/carbonado/util/TestComparators.java

(limited to 'src')

diff --git a/src/test/java/com/amazon/carbonado/cursor/TestComparators.java b/src/test/java/com/amazon/carbonado/cursor/TestComparators.java
deleted file mode 100644
index c00b173..0000000
--- a/src/test/java/com/amazon/carbonado/cursor/TestComparators.java
+++ /dev/null
@@ -1,785 +0,0 @@
-/*
- * Copyright 2007 Amazon Technologies, Inc. or its affiliates.
- * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
- * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.
- *
- * Licensed 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 com.amazon.carbonado.cursor;
-
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
-import java.util.NoSuchElementException;
-
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
-
-import com.amazon.carbonado.Cursor;
-import com.amazon.carbonado.FetchException;
-
-import com.amazon.carbonado.stored.Dummy;
-import com.amazon.carbonado.stored.StorableTestMinimal;
-
-/**
- *
- * @author Brian S O'Neill
- */
-public class TestComparators extends TestCase {
-    public static void main(String[] args) {
-        junit.textui.TestRunner.run(suite());
-    }
-
-    public static TestSuite suite() {
-        return new TestSuite(TestComparators.class);
-    }
-
-    public TestComparators(String name) {
-        super(name);
-    }
-
-    protected void setUp() {
-    }
-
-    protected void tearDown() {
-    }
-
-    public void testSignedByteArray() {
-        Comparator<byte[]> c = Comparators.arrayComparator(byte[].class, false);
-
-        {
-            byte[] a = {};
-            byte[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            byte[] a = {1};
-            byte[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            byte[] a = {-1};
-            byte[] b = {1};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-
-        {
-            byte[] a = {Byte.MAX_VALUE};
-            byte[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            byte[] a = {1, 2, 3};
-            byte[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            byte[] a = {1, 2, 4};
-            byte[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            byte[] a = {1, 2, 3};
-            byte[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testUnsignedByteArray() {
-        Comparator<byte[]> c = Comparators.arrayComparator(byte[].class, true);
-
-        {
-            byte[] a = {};
-            byte[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            byte[] a = {1};
-            byte[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            byte[] a = {-1};
-            byte[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            byte[] a = {Byte.MAX_VALUE};
-            byte[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            byte[] a = {1, 2, 3};
-            byte[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            byte[] a = {1, 2, 4};
-            byte[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            byte[] a = {1, 2, 3};
-            byte[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testSignedShortArray() {
-        Comparator<short[]> c = Comparators.arrayComparator(short[].class, false);
-
-        {
-            short[] a = {};
-            short[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            short[] a = {1};
-            short[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            short[] a = {-1};
-            short[] b = {1};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-
-        {
-            short[] a = {Short.MAX_VALUE};
-            short[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            short[] a = {1, 2, 3};
-            short[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            short[] a = {1, 2, 4};
-            short[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            short[] a = {1, 2, 3};
-            short[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testUnsignedShortArray() {
-        Comparator<short[]> c = Comparators.arrayComparator(short[].class, true);
-
-        {
-            short[] a = {};
-            short[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            short[] a = {1};
-            short[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            short[] a = {-1};
-            short[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            short[] a = {Short.MAX_VALUE};
-            short[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            short[] a = {1, 2, 3};
-            short[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            short[] a = {1, 2, 4};
-            short[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            short[] a = {1, 2, 3};
-            short[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testSignedIntArray() {
-        Comparator<int[]> c = Comparators.arrayComparator(int[].class, false);
-
-        {
-            int[] a = {};
-            int[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            int[] a = {1};
-            int[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            int[] a = {-1};
-            int[] b = {1};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-
-        {
-            int[] a = {Integer.MAX_VALUE};
-            int[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            int[] a = {1, 2, 3};
-            int[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            int[] a = {1, 2, 4};
-            int[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            int[] a = {1, 2, 3};
-            int[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testUnsignedIntArray() {
-        Comparator<int[]> c = Comparators.arrayComparator(int[].class, true);
-
-        {
-            int[] a = {};
-            int[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            int[] a = {1};
-            int[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            int[] a = {-1};
-            int[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            int[] a = {Integer.MAX_VALUE};
-            int[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            int[] a = {1, 2, 3};
-            int[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            int[] a = {1, 2, 4};
-            int[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            int[] a = {1, 2, 3};
-            int[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testSignedLongArray() {
-        Comparator<long[]> c = Comparators.arrayComparator(long[].class, false);
-
-        {
-            long[] a = {};
-            long[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            long[] a = {1};
-            long[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            long[] a = {-1};
-            long[] b = {1};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-
-        {
-            long[] a = {Long.MAX_VALUE};
-            long[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            long[] a = {1, 2, 3};
-            long[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            long[] a = {1, 2, 4};
-            long[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            long[] a = {1, 2, 3};
-            long[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testUnsignedLongArray() {
-        Comparator<long[]> c = Comparators.arrayComparator(long[].class, true);
-
-        {
-            long[] a = {};
-            long[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            long[] a = {1};
-            long[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            long[] a = {-1};
-            long[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            long[] a = {Long.MAX_VALUE};
-            long[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            long[] a = {1, 2, 3};
-            long[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            long[] a = {1, 2, 4};
-            long[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            long[] a = {1, 2, 3};
-            long[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-
-        {
-            long[] a = {Long.MAX_VALUE};
-            long[] b = {Long.MAX_VALUE - 1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-    }
-
-    public void testBooleanArray() {
-        Comparator<boolean[]> c = Comparators.arrayComparator(boolean[].class, false);
-
-        {
-            boolean[] a = {};
-            boolean[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            boolean[] a = {true};
-            boolean[] b = {true};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            boolean[] a = {false};
-            boolean[] b = {true};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-
-        {
-            boolean[] a = {false, true, false};
-            boolean[] b = {false, true, false};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            boolean[] a = {false, true, true};
-            boolean[] b = {false, true, false};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            boolean[] a = {false, true, false};
-            boolean[] b = {false, true, false, false};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testCharArray() {
-        Comparator<char[]> c = Comparators.arrayComparator(char[].class, false);
-
-        {
-            char[] a = {};
-            char[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            char[] a = {1};
-            char[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            char[] a = {65535};
-            char[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            char[] a = {32767};
-            char[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            char[] a = {1, 2, 3};
-            char[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            char[] a = {1, 2, 4};
-            char[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            char[] a = {1, 2, 3};
-            char[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testFloatArray() {
-        Comparator<float[]> c = Comparators.arrayComparator(float[].class, false);
-
-        {
-            float[] a = {};
-            float[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            float[] a = {1};
-            float[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            float[] a = {Float.POSITIVE_INFINITY};
-            float[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            float[] a = {Float.NaN};
-            float[] b = {Float.POSITIVE_INFINITY};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            float[] a = {1, 2, 3};
-            float[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            float[] a = {1, 2, 4};
-            float[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            float[] a = {1, 2, 3};
-            float[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testDoubleArray() {
-        Comparator<double[]> c = Comparators.arrayComparator(double[].class, false);
-
-        {
-            double[] a = {};
-            double[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            double[] a = {1};
-            double[] b = {1};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            double[] a = {Double.POSITIVE_INFINITY};
-            double[] b = {1};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            double[] a = {Double.NaN};
-            double[] b = {Double.POSITIVE_INFINITY};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            double[] a = {1, 2, 3};
-            double[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            double[] a = {1, 2, 4};
-            double[] b = {1, 2, 3};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            double[] a = {1, 2, 3};
-            double[] b = {1, 2, 3, 4};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testComparableArray() {
-        Comparator<String[]> c = Comparators.arrayComparator(String[].class, false);
-
-        {
-            String[] a = {};
-            String[] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            String[] a = {"1"};
-            String[] b = {"1"};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            String[] a = {null};
-            String[] b = {"1"};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            String[] a = {"\uffff"};
-            String[] b = {"1"};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            String[] a = {"a"};
-            String[] b = {"B"};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            String[] a = {"1", "2", "3"};
-            String[] b = {"1", "2", "3"};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            String[] a = {"1", "2", "4"};
-            String[] b = {"1", "2", "3"};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            String[] a = {"1", "2", "3"};
-            String[] b = {"1", "2", "3", "4"};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-
-    public void testUnsignedByteArrayArray() {
-        Comparator<byte[][]> c = Comparators.arrayComparator(byte[][].class, true);
-
-        {
-            byte[][] a = {};
-            byte[][] b = {};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            byte[][] a = {{}};
-            byte[][] b = {{}};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            byte[][] a = {null};
-            byte[][] b = {{1}};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            byte[][] a = {{1, 2, 3}, {3, 4, 5}};
-            byte[][] b = {{1, 2, 3}, {3, 4, 5}};
-            assertTrue(c.compare(a, b) == 0);
-        }
-
-        {
-            byte[][] a = {{1, 2, 3}, {3, 4, 5}};
-            byte[][] b = {{1, 2, 3}};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            byte[][] a = {{1, 2, 4}, {3, 4, 5}};
-            byte[][] b = {{1, 2, 3}, {3, 4, 5}};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            byte[][] a = {{1, 2, 3}, {3, 4, 4}};
-            byte[][] b = {{1, 2, 3}, {3, 4, 5}};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-
-        {
-            byte[][] a = {{1, 2, 3}, {3, 4, 4}};
-            byte[][] b = {{1, 2, 3}, {3, 4, 5, 1, 2, 3}};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-
-        {
-            byte[][] a = {{1, 2, 3, 4}, {3, 4, 4}};
-            byte[][] b = {{1, 2, 3, 2}, {3, 4, 5, 1, 2, 3}};
-            assertTrue(c.compare(a, b) > 0);
-            assertTrue(c.compare(b, a) < 0);
-        }
-
-        {
-            byte[][] a = {{1, 2, 3}, {3, 4, 4}};
-            byte[][] b = {{1, 2, 3}, null};
-            assertTrue(c.compare(a, b) < 0);
-            assertTrue(c.compare(b, a) > 0);
-        }
-    }
-}
diff --git a/src/test/java/com/amazon/carbonado/util/TestComparators.java b/src/test/java/com/amazon/carbonado/util/TestComparators.java
new file mode 100644
index 0000000..1ee4186
--- /dev/null
+++ b/src/test/java/com/amazon/carbonado/util/TestComparators.java
@@ -0,0 +1,785 @@
+/*
+ * Copyright 2007 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed 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 com.amazon.carbonado.util;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.amazon.carbonado.Cursor;
+import com.amazon.carbonado.FetchException;
+
+import com.amazon.carbonado.stored.Dummy;
+import com.amazon.carbonado.stored.StorableTestMinimal;
+
+/**
+ *
+ * @author Brian S O'Neill
+ */
+public class TestComparators extends TestCase {
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+    public static TestSuite suite() {
+        return new TestSuite(TestComparators.class);
+    }
+
+    public TestComparators(String name) {
+        super(name);
+    }
+
+    protected void setUp() {
+    }
+
+    protected void tearDown() {
+    }
+
+    public void testSignedByteArray() {
+        Comparator<byte[]> c = Comparators.arrayComparator(byte[].class, false);
+
+        {
+            byte[] a = {};
+            byte[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            byte[] a = {1};
+            byte[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            byte[] a = {-1};
+            byte[] b = {1};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+
+        {
+            byte[] a = {Byte.MAX_VALUE};
+            byte[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            byte[] a = {1, 2, 3};
+            byte[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            byte[] a = {1, 2, 4};
+            byte[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            byte[] a = {1, 2, 3};
+            byte[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testUnsignedByteArray() {
+        Comparator<byte[]> c = Comparators.arrayComparator(byte[].class, true);
+
+        {
+            byte[] a = {};
+            byte[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            byte[] a = {1};
+            byte[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            byte[] a = {-1};
+            byte[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            byte[] a = {Byte.MAX_VALUE};
+            byte[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            byte[] a = {1, 2, 3};
+            byte[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            byte[] a = {1, 2, 4};
+            byte[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            byte[] a = {1, 2, 3};
+            byte[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testSignedShortArray() {
+        Comparator<short[]> c = Comparators.arrayComparator(short[].class, false);
+
+        {
+            short[] a = {};
+            short[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            short[] a = {1};
+            short[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            short[] a = {-1};
+            short[] b = {1};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+
+        {
+            short[] a = {Short.MAX_VALUE};
+            short[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            short[] a = {1, 2, 3};
+            short[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            short[] a = {1, 2, 4};
+            short[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            short[] a = {1, 2, 3};
+            short[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testUnsignedShortArray() {
+        Comparator<short[]> c = Comparators.arrayComparator(short[].class, true);
+
+        {
+            short[] a = {};
+            short[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            short[] a = {1};
+            short[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            short[] a = {-1};
+            short[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            short[] a = {Short.MAX_VALUE};
+            short[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            short[] a = {1, 2, 3};
+            short[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            short[] a = {1, 2, 4};
+            short[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            short[] a = {1, 2, 3};
+            short[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testSignedIntArray() {
+        Comparator<int[]> c = Comparators.arrayComparator(int[].class, false);
+
+        {
+            int[] a = {};
+            int[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            int[] a = {1};
+            int[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            int[] a = {-1};
+            int[] b = {1};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+
+        {
+            int[] a = {Integer.MAX_VALUE};
+            int[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            int[] a = {1, 2, 3};
+            int[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            int[] a = {1, 2, 4};
+            int[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            int[] a = {1, 2, 3};
+            int[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testUnsignedIntArray() {
+        Comparator<int[]> c = Comparators.arrayComparator(int[].class, true);
+
+        {
+            int[] a = {};
+            int[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            int[] a = {1};
+            int[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            int[] a = {-1};
+            int[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            int[] a = {Integer.MAX_VALUE};
+            int[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            int[] a = {1, 2, 3};
+            int[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            int[] a = {1, 2, 4};
+            int[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            int[] a = {1, 2, 3};
+            int[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testSignedLongArray() {
+        Comparator<long[]> c = Comparators.arrayComparator(long[].class, false);
+
+        {
+            long[] a = {};
+            long[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            long[] a = {1};
+            long[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            long[] a = {-1};
+            long[] b = {1};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+
+        {
+            long[] a = {Long.MAX_VALUE};
+            long[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            long[] a = {1, 2, 3};
+            long[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            long[] a = {1, 2, 4};
+            long[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            long[] a = {1, 2, 3};
+            long[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testUnsignedLongArray() {
+        Comparator<long[]> c = Comparators.arrayComparator(long[].class, true);
+
+        {
+            long[] a = {};
+            long[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            long[] a = {1};
+            long[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            long[] a = {-1};
+            long[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            long[] a = {Long.MAX_VALUE};
+            long[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            long[] a = {1, 2, 3};
+            long[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            long[] a = {1, 2, 4};
+            long[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            long[] a = {1, 2, 3};
+            long[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+
+        {
+            long[] a = {Long.MAX_VALUE};
+            long[] b = {Long.MAX_VALUE - 1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+    }
+
+    public void testBooleanArray() {
+        Comparator<boolean[]> c = Comparators.arrayComparator(boolean[].class, false);
+
+        {
+            boolean[] a = {};
+            boolean[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            boolean[] a = {true};
+            boolean[] b = {true};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            boolean[] a = {false};
+            boolean[] b = {true};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+
+        {
+            boolean[] a = {false, true, false};
+            boolean[] b = {false, true, false};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            boolean[] a = {false, true, true};
+            boolean[] b = {false, true, false};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            boolean[] a = {false, true, false};
+            boolean[] b = {false, true, false, false};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testCharArray() {
+        Comparator<char[]> c = Comparators.arrayComparator(char[].class, false);
+
+        {
+            char[] a = {};
+            char[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            char[] a = {1};
+            char[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            char[] a = {65535};
+            char[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            char[] a = {32767};
+            char[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            char[] a = {1, 2, 3};
+            char[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            char[] a = {1, 2, 4};
+            char[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            char[] a = {1, 2, 3};
+            char[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testFloatArray() {
+        Comparator<float[]> c = Comparators.arrayComparator(float[].class, false);
+
+        {
+            float[] a = {};
+            float[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            float[] a = {1};
+            float[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            float[] a = {Float.POSITIVE_INFINITY};
+            float[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            float[] a = {Float.NaN};
+            float[] b = {Float.POSITIVE_INFINITY};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            float[] a = {1, 2, 3};
+            float[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            float[] a = {1, 2, 4};
+            float[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            float[] a = {1, 2, 3};
+            float[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testDoubleArray() {
+        Comparator<double[]> c = Comparators.arrayComparator(double[].class, false);
+
+        {
+            double[] a = {};
+            double[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            double[] a = {1};
+            double[] b = {1};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            double[] a = {Double.POSITIVE_INFINITY};
+            double[] b = {1};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            double[] a = {Double.NaN};
+            double[] b = {Double.POSITIVE_INFINITY};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            double[] a = {1, 2, 3};
+            double[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            double[] a = {1, 2, 4};
+            double[] b = {1, 2, 3};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            double[] a = {1, 2, 3};
+            double[] b = {1, 2, 3, 4};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testComparableArray() {
+        Comparator<String[]> c = Comparators.arrayComparator(String[].class, false);
+
+        {
+            String[] a = {};
+            String[] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            String[] a = {"1"};
+            String[] b = {"1"};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            String[] a = {null};
+            String[] b = {"1"};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            String[] a = {"\uffff"};
+            String[] b = {"1"};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            String[] a = {"a"};
+            String[] b = {"B"};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            String[] a = {"1", "2", "3"};
+            String[] b = {"1", "2", "3"};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            String[] a = {"1", "2", "4"};
+            String[] b = {"1", "2", "3"};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            String[] a = {"1", "2", "3"};
+            String[] b = {"1", "2", "3", "4"};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+
+    public void testUnsignedByteArrayArray() {
+        Comparator<byte[][]> c = Comparators.arrayComparator(byte[][].class, true);
+
+        {
+            byte[][] a = {};
+            byte[][] b = {};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            byte[][] a = {{}};
+            byte[][] b = {{}};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            byte[][] a = {null};
+            byte[][] b = {{1}};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            byte[][] a = {{1, 2, 3}, {3, 4, 5}};
+            byte[][] b = {{1, 2, 3}, {3, 4, 5}};
+            assertTrue(c.compare(a, b) == 0);
+        }
+
+        {
+            byte[][] a = {{1, 2, 3}, {3, 4, 5}};
+            byte[][] b = {{1, 2, 3}};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            byte[][] a = {{1, 2, 4}, {3, 4, 5}};
+            byte[][] b = {{1, 2, 3}, {3, 4, 5}};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            byte[][] a = {{1, 2, 3}, {3, 4, 4}};
+            byte[][] b = {{1, 2, 3}, {3, 4, 5}};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+
+        {
+            byte[][] a = {{1, 2, 3}, {3, 4, 4}};
+            byte[][] b = {{1, 2, 3}, {3, 4, 5, 1, 2, 3}};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+
+        {
+            byte[][] a = {{1, 2, 3, 4}, {3, 4, 4}};
+            byte[][] b = {{1, 2, 3, 2}, {3, 4, 5, 1, 2, 3}};
+            assertTrue(c.compare(a, b) > 0);
+            assertTrue(c.compare(b, a) < 0);
+        }
+
+        {
+            byte[][] a = {{1, 2, 3}, {3, 4, 4}};
+            byte[][] b = {{1, 2, 3}, null};
+            assertTrue(c.compare(a, b) < 0);
+            assertTrue(c.compare(b, a) > 0);
+        }
+    }
+}
-- 
cgit v1.2.3