Or equal: add tests for integer, float and byte array.

Author: greenrobot-team

tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java

@@ -42,6 +42,7 @@
 import static io.objectbox.TestEntity_.simpleLong;
 import static io.objectbox.TestEntity_.simpleShort;
 import static io.objectbox.TestEntity_.simpleString;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -138,6 +139,36 @@ public void testScalarLessAndGreater() {
         assertEquals(3, query.count());
     }
 
+    @Test
+    public void integer_lessAndGreater_works() {
+        putTestEntitiesScalars();
+        int value = 2004;
+
+        buildFindAndAssert(
+                box.query().less(TestEntity_.simpleInt, value),
+                4,
+                (index, item) -> assertTrue(item.getSimpleInt() < value)
+        );
+
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleInt, value),
+                5,
+                (index, item) -> assertTrue(item.getSimpleInt() > value)
+        );
+
+        buildFindAndAssert(
+                box.query().lessOrEqual(TestEntity_.simpleInt, value),
+                5,
+                (index, item) -> assertTrue(item.getSimpleInt() <= value)
+        );
+
+        buildFindAndAssert(
+                box.query().greaterOrEqual(TestEntity_.simpleInt, value),
+                6,
+                (index, item) -> assertTrue(item.getSimpleInt() >= value)
+        );
+    }
+
     @Test
     public void testScalarBetween() {
         putTestEntitiesScalars();
@@ -352,40 +383,96 @@ public void testByteArrayEqualsAndSetParameter() {
     }
 
     @Test
-    public void testByteArrayLess() {
+    public void byteArray_lessAndGreater_works() {
         putTestEntitiesScalars();
-
         byte[] value = {1, 2, (byte) 2005};
-        Query<TestEntity> query = box.query().less(simpleByteArray, value).build();
-        List<TestEntity> results = query.find();
 
-        assertEquals(5, results.size());
-        // Java does not have compareTo for arrays, so just make sure its not equal to the value
-        for (TestEntity result : results) {
-            assertFalse(Arrays.equals(value, result.getSimpleByteArray()));
-        }
-    }
-
-    @Test
-    public void testByteArrayGreater() {
+        // Java does not have compareTo for arrays, so just make sure its not equal to the value.
+        ListItemAsserter<TestEntity> resultsNotEqual = (index, item) -> assertFalse(Arrays.equals(value, item.getSimpleByteArray()));
+
+        buildFindAndAssert(
+                box.query().less(TestEntity_.simpleByteArray, value), 5, resultsNotEqual
+        );
+
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleByteArray, value), 4, resultsNotEqual
+        );
+
+        buildFindAndAssert(
+                box.query().lessOrEqual(TestEntity_.simpleByteArray, value),
+                6,
+                (index, item) -> {
+                    if (index == 5) {
+                        assertArrayEquals(value, item.getSimpleByteArray());
+                    } else {
+                        assertFalse(Arrays.equals(value, item.getSimpleByteArray()));
+                    }
+                }
+        );
+
+        buildFindAndAssert(
+                box.query().greaterOrEqual(TestEntity_.simpleByteArray, value),
+                5,
+                (index, item) -> {
+                    if (index == 0) {
+                        assertArrayEquals(value, item.getSimpleByteArray());
+                    } else {
+                        assertFalse(Arrays.equals(value, item.getSimpleByteArray()));
+                    }
+                }
+        );
+
+        // greater and less
+        byte[] valueGreater = {1, 2, (byte) 2002};
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleByteArray, valueGreater).less(TestEntity_.simpleByteArray, value),
+                2,
+                (index, item) -> {
+                    assertFalse(Arrays.equals(value, item.getSimpleByteArray()));
+                    assertFalse(Arrays.equals(valueGreater, item.getSimpleByteArray()));
+                }
+        );
+    }
+
+    @Test
+    public void float_lessAndGreater_works() {
         putTestEntitiesScalars();
-
-        byte[] value = {1, 2, (byte) 2005};
-        Query<TestEntity> query = box.query().greater(simpleByteArray, value).build();
-        List<TestEntity> results = query.find();
-
-        assertEquals(4, results.size());
-        // Java does not have compareTo for arrays, so just make sure its not equal to the value
-        for (TestEntity result : results) {
-            assertFalse(Arrays.equals(value, result.getSimpleByteArray()));
-        }
-    }
-
-    @Test
-    public void testScalarFloatLessAndGreater() {
-        putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().greater(simpleFloat, 400.29f).less(simpleFloat, 400.51f).build();
-        assertEquals(3, query.count());
+        float value = 400.5f;
+
+        buildFindAndAssert(
+                box.query().less(TestEntity_.simpleFloat, value),
+                5,
+                (index, item) -> assertTrue(item.getSimpleFloat() < value)
+        );
+
+        buildFindAndAssert(
+                box.query().lessOrEqual(TestEntity_.simpleFloat, value),
+                6,
+                (index, item) -> assertTrue(item.getSimpleFloat() <= value)
+        );
+
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleFloat, value),
+                4,
+                (index, item) -> assertTrue(item.getSimpleFloat() > value)
+        );
+
+        buildFindAndAssert(
+                box.query().greaterOrEqual(TestEntity_.simpleFloat, value),
+                5,
+                (index, item) -> assertTrue(item.getSimpleFloat() >= value)
+        );
+
+        float valueLess = 400.51f;
+        float valueGreater = 400.29f;
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleFloat, valueGreater).less(TestEntity_.simpleFloat, valueLess),
+                3,
+                (index, item) -> {
+                    assertTrue(item.getSimpleFloat() < valueLess);
+                    assertTrue(item.getSimpleFloat() > valueGreater);
+                }
+        );
     }
 
     @Test
@@ -736,4 +823,16 @@ public void testDescribe() {
         assertTrue(describeActual.contains(TestEntity_.simpleInt.name));
         assertEquals("(simpleString ==(i) \"Hello\"\n OR simpleInt > 42)", query.describeParameters());
     }
+
+    private <T> void buildFindAndAssert(QueryBuilder<T> builder, int expectedCount, ListItemAsserter<T> asserter) {
+        List<T> results = builder.build().find();
+        assertEquals(expectedCount, results.size());
+        for (int i = 0; i < results.size(); i++) {
+            asserter.assertListItem(i, results.get(i));
+        }
+    }
+
+    private interface ListItemAsserter<T> {
+        void assertListItem(int index, T item);
+    }
 }