summaryrefslogtreecommitdiff
path: root/src/test/java/com/amazon/carbonado
diff options
context:
space:
mode:
authorBrian S. O'Neill <bronee@gmail.com>2007-10-11 21:00:12 +0000
committerBrian S. O'Neill <bronee@gmail.com>2007-10-11 21:00:12 +0000
commit14aa48fbc0f6275b15f8da5cbad7948c4fd9f08c (patch)
treebae7ccb9ed3e57c9d3f7157188dda8262ed09483 /src/test/java/com/amazon/carbonado
parente8a446562db9bf782bf6f01dc68826aeb1802673 (diff)
Support sorting of arrays.
Diffstat (limited to 'src/test/java/com/amazon/carbonado')
-rw-r--r--src/test/java/com/amazon/carbonado/cursor/TestComparators.java785
1 files changed, 785 insertions, 0 deletions
diff --git a/src/test/java/com/amazon/carbonado/cursor/TestComparators.java b/src/test/java/com/amazon/carbonado/cursor/TestComparators.java
new file mode 100644
index 0000000..c00b173
--- /dev/null
+++ b/src/test/java/com/amazon/carbonado/cursor/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.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);
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-11-03 16:04:26 +0000