@Override public void run() { List<T> result = query.find(); for (DataObserver<List<T>> observer : observers) { observer.onData(result); } } });
@Test public void testEagerToSingle_NoResult() { Query<Order> query = orderBox.query().eager(Order_.customer).build(); query.find(); query.findFirst(); query.forEach(new QueryConsumer<Order>() { @Override public void accept(Order data) { } }); }
@Test public void testScalarEqual() { putTestEntitiesScalars(); Query<TestEntity> query = box.query().equal(simpleInt, 2007).build(); assertEquals(1, query.count()); assertEquals(8, query.findFirst().getId()); assertEquals(8, query.findUnique().getId()); List<TestEntity> all = query.find(); assertEquals(1, all.size()); assertEquals(8, all.get(0).getId()); }
@Test public void testSetParameter2Floats() { putTestEntitiesScalars(); Query<TestEntity> query = box.query().between(simpleFloat, 400.15, 400.75).parameterAlias("foo").build(); assertEquals(6, query.count()); query.setParameters(simpleFloat, 400.65, 400.85); List<TestEntity> entities = query.find(); assertEquals(2, entities.size()); assertEquals(8, entities.get(0).getId()); assertEquals(9, entities.get(1).getId()); query.setParameters("foo", 400.45, 400.55); assertEquals(6, query.findUnique().getId()); }
@Override public void run() { List<T> result = query.find(); observer.onData(result); } });
@Test public void testSetParameter2Ints() { putTestEntitiesScalars(); Query<TestEntity> query = box.query().between(simpleInt, 2005, 2008).parameterAlias("foo").build(); assertEquals(4, query.count()); query.setParameters(simpleInt, 2002, 2003); List<TestEntity> entities = query.find(); assertEquals(2, entities.size()); assertEquals(3, entities.get(0).getId()); assertEquals(4, entities.get(1).getId()); query.setParameters("foo", 2007, 2007); assertEquals(8, query.findUnique().getId()); }
@Test public void testEagerToMany_NoResult() { Query<Customer> query = customerBox.query().eager(Customer_.orders).build(); query.find(); query.findFirst(); query.forEach(new QueryConsumer<Customer>() { @Override public void accept(Customer data) { } }); }
@Test public void testOffsetLimit() { putTestEntitiesScalars(); Query<TestEntity> query = box.query().greater(simpleInt, 2002).less(simpleShort, 2108).build(); assertEquals(5, query.count()); assertEquals(4, query.find(1, 0).size()); assertEquals(1, query.find(4, 0).size()); assertEquals(2, query.find(0, 2).size()); List<TestEntity> list = query.find(1, 2); assertEquals(2, list.size()); assertEquals(2004, list.get(0).getSimpleInt()); assertEquals(2005, list.get(1).getSimpleInt()); }
@Test public void testNoConditions() { List<TestEntity> entities = putTestEntitiesScalars(); Query<TestEntity> query = box.query().build(); List<TestEntity> all = query.find(); assertEquals(entities.size(), all.size()); assertEquals(entities.size(), query.count()); }
@Test // Android JNI seems to have a limit of 512 local jobject references. Internally, we must delete those temporary // references when processing lists. This is the test for that. public void testBigResultList() { List<TestEntity> entities = new ArrayList<>(); String sameValueForAll = "schrodinger"; for (int i = 0; i < 10000; i++) { TestEntity entity = createTestEntity(sameValueForAll, i); entities.add(entity); } box.put(entities); int count = entities.size(); List<TestEntity> entitiesQueried = box.query().equal(simpleString, sameValueForAll).build().find(); assertEquals(count, entitiesQueried.size()); }
@Test public void testByteArrayLess() { 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() { 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 testFindWithFilter() { putTestEntitiesStrings(); List<TestEntity> entities = box.query().filter(createTestFilter()).build().find(); assertEquals(2, entities.size()); assertEquals("apple", entities.get(0).getSimpleString()); assertEquals("banana milk shake", entities.get(1).getSimpleString()); }
@Test public void testOrder() { putTestEntitiesStrings(); putTestEntity("BAR", 100); List<TestEntity> result = box.query().order(simpleString).build().find(); assertEquals(6, result.size()); assertEquals("apple", result.get(0).getSimpleString()); assertEquals("banana", result.get(1).getSimpleString()); assertEquals("banana milk shake", result.get(2).getSimpleString()); assertEquals("bar", result.get(3).getSimpleString()); assertEquals("BAR", result.get(4).getSimpleString()); assertEquals("foo bar", result.get(5).getSimpleString()); }
@Test public void testOr() { putTestEntitiesScalars(); Query<TestEntity> query = box.query().equal(simpleInt, 2007).or().equal(simpleLong, 3002).build(); List<TestEntity> entities = query.find(); assertEquals(2, entities.size()); assertEquals(3002, entities.get(0).getSimpleLong()); assertEquals(2007, entities.get(1).getSimpleInt()); }
@Test public void testFindWithComparator() { putTestEntitiesStrings(); List<TestEntity> entities = box.query().sort(new Comparator<TestEntity>() { @Override public int compare(TestEntity o1, TestEntity o2) { return o1.getSimpleString().substring(1).compareTo(o2.getSimpleString().substring(1)); } }).build().find(); assertEquals(5, entities.size()); assertEquals("banana", entities.get(0).getSimpleString()); assertEquals("banana milk shake", entities.get(1).getSimpleString()); assertEquals("bar", entities.get(2).getSimpleString()); assertEquals("foo bar", entities.get(3).getSimpleString()); assertEquals("apple", entities.get(4).getSimpleString()); }
@Test public void testStringGreater() { putTestEntitiesStrings(); putTestEntity("FOO", 100); Query<TestEntity> query = box.query().greater(simpleString, "banana juice").order(simpleString).build(); List<TestEntity> entities = query.find(); assertEquals(4, entities.size()); assertEquals("banana milk shake", entities.get(0).getSimpleString()); assertEquals("bar", entities.get(1).getSimpleString()); assertEquals("FOO", entities.get(2).getSimpleString()); assertEquals("foo bar", entities.get(3).getSimpleString()); query.setParameter(simpleString, "FO"); entities = query.find(); assertEquals(2, entities.size()); assertEquals("FOO", entities.get(0).getSimpleString()); assertEquals("foo bar", entities.get(1).getSimpleString()); // Case sensitive query = box.query().greater(simpleString, "banana", StringOrder.CASE_SENSITIVE).order(simpleString).build(); entities = query.find(); assertEquals(3, entities.size()); assertEquals("banana milk shake", entities.get(0).getSimpleString()); assertEquals("bar", entities.get(1).getSimpleString()); assertEquals("foo bar", entities.get(2).getSimpleString()); }
@Test public void testOrderDescCaseNullLast() { putTestEntity(null, 1000); putTestEntity("BAR", 100); putTestEntitiesStrings(); int flags = QueryBuilder.CASE_SENSITIVE | QueryBuilder.NULLS_LAST | QueryBuilder.DESCENDING; List<TestEntity> result = box.query().order(simpleString, flags).build().find(); assertEquals(7, result.size()); assertEquals("foo bar", result.get(0).getSimpleString()); assertEquals("bar", result.get(1).getSimpleString()); assertEquals("banana milk shake", result.get(2).getSimpleString()); assertEquals("banana", result.get(3).getSimpleString()); assertEquals("apple", result.get(4).getSimpleString()); assertEquals("BAR", result.get(5).getSimpleString()); assertNull(result.get(6).getSimpleString()); }
@Test public void testAnd() { putTestEntitiesScalars(); // OR precedence (wrong): {}, AND precedence (expected): 2008 Query<TestEntity> query = box.query().equal(simpleInt, 2006).and().equal(simpleInt, 2007).or().equal(simpleInt, 2008).build(); List<TestEntity> entities = query.find(); assertEquals(1, entities.size()); assertEquals(2008, entities.get(0).getSimpleInt()); }
@Test(expected = IllegalStateException.class) public void testBuildTwice() { QueryBuilder<TestEntity> queryBuilder = box.query(); for (int i = 0; i < 2; i++) { // calling any builder method after build should fail // note: not calling all variants for different types queryBuilder.isNull(TestEntity_.simpleString); queryBuilder.and(); queryBuilder.notNull(TestEntity_.simpleString); queryBuilder.or(); queryBuilder.equal(TestEntity_.simpleBoolean, true); queryBuilder.notEqual(TestEntity_.simpleBoolean, true); queryBuilder.less(TestEntity_.simpleInt, 42); queryBuilder.greater(TestEntity_.simpleInt, 42); queryBuilder.between(TestEntity_.simpleInt, 42, 43); queryBuilder.in(TestEntity_.simpleInt, new int[]{42}); queryBuilder.notIn(TestEntity_.simpleInt, new int[]{42}); queryBuilder.contains(TestEntity_.simpleString, "42"); queryBuilder.startsWith(TestEntity_.simpleString, "42"); queryBuilder.order(TestEntity_.simpleInt); queryBuilder.build().find(); } }