/*
* Copyright 2015 Realm Inc.
*
* 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 io.realm;
import android.support.test.runner.AndroidJUnit4;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import io.realm.entities.AllJavaTypes;
import io.realm.entities.AllTypes;
import io.realm.entities.AnnotationIndexTypes;
import io.realm.entities.Cat;
import io.realm.entities.CatOwner;
import io.realm.entities.Dog;
import io.realm.entities.NoPrimaryKeyNullTypes;
import io.realm.entities.NonLatinFieldNames;
import io.realm.entities.NullTypes;
import io.realm.entities.Owner;
import io.realm.entities.PrimaryKeyAsBoxedByte;
import io.realm.entities.PrimaryKeyAsBoxedInteger;
import io.realm.entities.PrimaryKeyAsBoxedLong;
import io.realm.entities.PrimaryKeyAsBoxedShort;
import io.realm.entities.PrimaryKeyAsString;
import io.realm.entities.StringOnly;
import io.realm.rule.RunInLooperThread;
import io.realm.rule.RunTestInLooperThread;
import io.realm.rule.TestRealmConfigurationFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@RunWith(AndroidJUnit4.class)
public class RealmQueryTests extends QueryTests {
private void populateTestRealm(Realm testRealm, int dataSize) {
testRealm.beginTransaction();
testRealm.deleteAll();
for (int i = 0; i < dataSize; ++i) {
AllTypes allTypes = testRealm.createObject(AllTypes.class);
allTypes.setColumnBoolean((i % 3) == 0);
allTypes.setColumnBinary(new byte[]{1, 2, 3});
allTypes.setColumnDate(new Date(DECADE_MILLIS * (i - (dataSize / 2))));
allTypes.setColumnDouble(Math.PI);
allTypes.setColumnFloat(1.2345f + i);
allTypes.setColumnString("test data " + i);
allTypes.setColumnLong(i);
NonLatinFieldNames nonLatinFieldNames = testRealm.createObject(NonLatinFieldNames.class);
nonLatinFieldNames.set델타(i);
nonLatinFieldNames.setΔέλτα(i);
nonLatinFieldNames.set베타(1.2345f + i);
nonLatinFieldNames.setΒήτα(1.2345f + i);
Dog dog = testRealm.createObject(Dog.class);
dog.setAge(i);
dog.setName("test data " + i);
allTypes.setColumnRealmObject(dog);
}
testRealm.commitTransaction();
}
private void populateTestRealm() {
populateTestRealm(realm, TEST_DATA_SIZE);
}
private void populateNoPrimaryKeyNullTypesRows(Realm testRealm, int dataSize) {
testRealm.beginTransaction();
testRealm.deleteAll();
for (int i = 0; i < dataSize; ++i) {
NoPrimaryKeyNullTypes noPrimaryKeyNullTypes = testRealm.createObject(NoPrimaryKeyNullTypes.class);
noPrimaryKeyNullTypes.setFieldStringNull((i % 3) == 0 ? null : "test data " + i);
noPrimaryKeyNullTypes.setFieldStringNotNull("test data " + i);
noPrimaryKeyNullTypes.setFieldBooleanNull((i % 3) == 0 ? null : (i % 3) == 1);
noPrimaryKeyNullTypes.setFieldBooleanNotNull((i % 3) == 0);
noPrimaryKeyNullTypes.setFieldByteNull((i % 3) == 0 ? null : (byte) i);
noPrimaryKeyNullTypes.setFieldByteNotNull((byte) i);
noPrimaryKeyNullTypes.setFieldShortNull((i % 3) == 0 ? null : (short) i);
noPrimaryKeyNullTypes.setFieldShortNotNull((short) i);
noPrimaryKeyNullTypes.setFieldIntegerNull((i % 3) == 0 ? null : i);
noPrimaryKeyNullTypes.setFieldIntegerNotNull(i);
noPrimaryKeyNullTypes.setFieldLongNull((i % 3) == 0 ? null : (long) i);
noPrimaryKeyNullTypes.setFieldLongNotNull((long) i);
noPrimaryKeyNullTypes.setFieldFloatNull((i % 3) == 0 ? null : 1.2345f + i);
noPrimaryKeyNullTypes.setFieldFloatNotNull(1.2345f + i);
noPrimaryKeyNullTypes.setFieldDoubleNull((i % 3) == 0 ? null : Math.PI + i);
noPrimaryKeyNullTypes.setFieldDoubleNotNull(Math.PI + i);
noPrimaryKeyNullTypes.setFieldDateNull((i % 3) == 0 ? null : new Date(DECADE_MILLIS * (i - (dataSize / 2))));
noPrimaryKeyNullTypes.setFieldDateNotNull(new Date(DECADE_MILLIS * (i - (dataSize / 2))));
}
testRealm.commitTransaction();
}
private void populateNoPrimaryKeyNullTypesRows() {
populateNoPrimaryKeyNullTypesRows(realm, TEST_NO_PRIMARY_KEY_NULL_TYPES_SIZE);
}
private enum ThreadConfinedMethods {
EQUAL_TO_STRING,
EQUAL_TO_STRING_WITH_CASE,
EQUAL_TO_BYTE,
EQUAL_TO_BYTE_ARRAY,
EQUAL_TO_SHORT,
EQUAL_TO_INTEGER,
EQUAL_TO_LONG,
EQUAL_TO_DOUBLE,
EQUAL_TO_FLOAT,
EQUAL_TO_BOOLEAN,
EQUAL_TO_DATE,
IN_STRING,
IN_STRING_WITH_CASE,
IN_BYTE,
IN_SHORT,
IN_INTEGER,
IN_LONG,
IN_DOUBLE,
IN_FLOAT,
IN_BOOLEAN,
IN_DATE,
NOT_EQUAL_TO_STRING,
NOT_EQUAL_TO_STRING_WITH_CASE,
NOT_EQUAL_TO_BYTE,
NOT_EQUAL_TO_BYTE_ARRAY,
NOT_EQUAL_TO_SHORT,
NOT_EQUAL_TO_INTEGER,
NOT_EQUAL_TO_LONG,
NOT_EQUAL_TO_DOUBLE,
NOT_EQUAL_TO_FLOAT,
NOT_EQUAL_TO_BOOLEAN,
NOT_EQUAL_TO_DATE,
GREATER_THAN_INTEGER,
GREATER_THAN_LONG,
GREATER_THAN_DOUBLE,
GREATER_THAN_FLOAT,
GREATER_THAN_DATE,
GREATER_THAN_OR_EQUAL_TO_INTEGER,
GREATER_THAN_OR_EQUAL_TO_LONG,
GREATER_THAN_OR_EQUAL_TO_DOUBLE,
GREATER_THAN_OR_EQUAL_TO_FLOAT,
GREATER_THAN_OR_EQUAL_TO_DATE,
LESS_THAN_INTEGER,
LESS_THAN_LONG,
LESS_THAN_DOUBLE,
LESS_THAN_FLOAT,
LESS_THAN_DATE,
LESS_THAN_OR_EQUAL_TO_INTEGER,
LESS_THAN_OR_EQUAL_TO_LONG,
LESS_THAN_OR_EQUAL_TO_DOUBLE,
LESS_THAN_OR_EQUAL_TO_FLOAT,
LESS_THAN_OR_EQUAL_TO_DATE,
BETWEEN_INTEGER,
BETWEEN_LONG,
BETWEEN_DOUBLE,
BETWEEN_FLOAT,
BETWEEN_DATE,
CONTAINS_STRING,
CONTAINS_STRING_WITH_CASE,
BEGINS_WITH_STRING,
BEGINS_WITH_STRING_WITH_CASE,
ENDS_WITH_STRING,
ENDS_WITH_STRING_WITH_CASE,
LIKE_STRING,
LIKE_STRING_WITH_CASE,
BEGIN_GROUP,
END_GROUP,
OR,
NOT,
IS_NULL,
IS_NOT_NULL,
IS_EMPTY,
IS_NOT_EMPTY,
IS_VALID,
DISTINCT,
DISTINCT_BY_MULTIPLE_FIELDS,
DISTINCT_ASYNC,
SUM,
AVERAGE,
MIN,
MINIMUM_DATE,
MAX,
MAXIMUM_DATE,
COUNT,
FIND_ALL,
FIND_ALL_ASYNC,
FIND_ALL_SORTED,
FIND_ALL_SORTED_ASYNC,
FIND_ALL_SORTED_WITH_ORDER,
FIND_ALL_SORTED_ASYNC_WITH_ORDER,
FIND_ALL_SORTED_WITH_TWO_ORDERS,
FIND_ALL_SORTED_ASYNC_WITH_TWO_ORDERS,
FIND_ALL_SORTED_WITH_MANY_ORDERS,
FIND_ALL_SORTED_ASYNC_WITH_MANY_ORDERS,
FIND_FIRST,
FIND_FIRST_ASYNC,
}
private static void callThreadConfinedMethod(RealmQuery<?> query, ThreadConfinedMethods method) {
switch (method) {
case EQUAL_TO_STRING: query.equalTo( AllJavaTypes.FIELD_STRING, "dummy value"); break;
case EQUAL_TO_STRING_WITH_CASE: query.equalTo( AllJavaTypes.FIELD_STRING, "dummy value", Case.INSENSITIVE); break;
case EQUAL_TO_BYTE: query.equalTo( AllJavaTypes.FIELD_BYTE, (byte) 1); break;
case EQUAL_TO_BYTE_ARRAY: query.equalTo( AllJavaTypes.FIELD_BINARY, new byte[] {0, 1, 2}); break;
case EQUAL_TO_SHORT: query.equalTo( AllJavaTypes.FIELD_SHORT, (short) 1); break;
case EQUAL_TO_INTEGER: query.equalTo( AllJavaTypes.FIELD_INT, 1); break;
case EQUAL_TO_LONG: query.equalTo( AllJavaTypes.FIELD_LONG, 1L); break;
case EQUAL_TO_DOUBLE: query.equalTo( AllJavaTypes.FIELD_DOUBLE, 1D); break;
case EQUAL_TO_FLOAT: query.equalTo( AllJavaTypes.FIELD_FLOAT, 1F); break;
case EQUAL_TO_BOOLEAN: query.equalTo( AllJavaTypes.FIELD_BOOLEAN, true); break;
case EQUAL_TO_DATE: query.equalTo( AllJavaTypes.FIELD_DATE, new Date(0L)); break;
case IN_STRING: query.in( AllJavaTypes.FIELD_STRING, new String[] {"dummy value1", "dummy value2"}); break;
case IN_STRING_WITH_CASE: query.in( AllJavaTypes.FIELD_STRING, new String[] {"dummy value1", "dummy value2"}, Case.INSENSITIVE); break;
case IN_BYTE: query.in( AllJavaTypes.FIELD_BYTE, new Byte[] {1, 2, 3}); break;
case IN_SHORT: query.in( AllJavaTypes.FIELD_SHORT, new Short[] {1, 2, 3}); break;
case IN_INTEGER: query.in( AllJavaTypes.FIELD_INT, new Integer[] {1, 2, 3}); break;
case IN_LONG: query.in( AllJavaTypes.FIELD_LONG, new Long[] {1L, 2L, 3L}); break;
case IN_DOUBLE: query.in( AllJavaTypes.FIELD_DOUBLE, new Double[] {1D, 2D, 3D}); break;
case IN_FLOAT: query.in( AllJavaTypes.FIELD_FLOAT, new Float[] {1F, 2F, 3F}); break;
case IN_BOOLEAN: query.in( AllJavaTypes.FIELD_BOOLEAN, new Boolean[] {true, false}); break;
case IN_DATE: query.in( AllJavaTypes.FIELD_DATE, new Date[] {new Date(0L)}); break;
case NOT_EQUAL_TO_STRING: query.notEqualTo( AllJavaTypes.FIELD_STRING, "dummy value"); break;
case NOT_EQUAL_TO_STRING_WITH_CASE: query.notEqualTo( AllJavaTypes.FIELD_STRING, "dummy value", Case.INSENSITIVE); break;
case NOT_EQUAL_TO_BYTE: query.notEqualTo( AllJavaTypes.FIELD_BYTE, (byte) 1); break;
case NOT_EQUAL_TO_BYTE_ARRAY: query.notEqualTo( AllJavaTypes.FIELD_BINARY, new byte[] {1,2,3}); break;
case NOT_EQUAL_TO_SHORT: query.notEqualTo( AllJavaTypes.FIELD_SHORT, (short) 1); break;
case NOT_EQUAL_TO_INTEGER: query.notEqualTo( AllJavaTypes.FIELD_INT, 1); break;
case NOT_EQUAL_TO_LONG: query.notEqualTo( AllJavaTypes.FIELD_LONG, 1L); break;
case NOT_EQUAL_TO_DOUBLE: query.notEqualTo( AllJavaTypes.FIELD_DOUBLE, 1D); break;
case NOT_EQUAL_TO_FLOAT: query.notEqualTo( AllJavaTypes.FIELD_FLOAT, 1F); break;
case NOT_EQUAL_TO_BOOLEAN: query.notEqualTo( AllJavaTypes.FIELD_BOOLEAN, true); break;
case NOT_EQUAL_TO_DATE: query.notEqualTo( AllJavaTypes.FIELD_DATE, new Date(0L)); break;
case GREATER_THAN_INTEGER: query.greaterThan( AllJavaTypes.FIELD_INT, 1); break;
case GREATER_THAN_LONG: query.greaterThan( AllJavaTypes.FIELD_LONG, 1L); break;
case GREATER_THAN_DOUBLE: query.greaterThan( AllJavaTypes.FIELD_DOUBLE, 1D); break;
case GREATER_THAN_FLOAT: query.greaterThan( AllJavaTypes.FIELD_FLOAT, 1F); break;
case GREATER_THAN_DATE: query.greaterThan( AllJavaTypes.FIELD_DATE, new Date(0L)); break;
case GREATER_THAN_OR_EQUAL_TO_INTEGER: query.greaterThanOrEqualTo( AllJavaTypes.FIELD_INT, 1); break;
case GREATER_THAN_OR_EQUAL_TO_LONG: query.greaterThanOrEqualTo( AllJavaTypes.FIELD_LONG, 1L); break;
case GREATER_THAN_OR_EQUAL_TO_DOUBLE: query.greaterThanOrEqualTo( AllJavaTypes.FIELD_DOUBLE, 1D); break;
case GREATER_THAN_OR_EQUAL_TO_FLOAT: query.greaterThanOrEqualTo( AllJavaTypes.FIELD_FLOAT, 1F); break;
case GREATER_THAN_OR_EQUAL_TO_DATE: query.greaterThanOrEqualTo( AllJavaTypes.FIELD_DATE, new Date(0L)); break;
case LESS_THAN_INTEGER: query.lessThan( AllJavaTypes.FIELD_INT, 1); break;
case LESS_THAN_LONG: query.lessThan( AllJavaTypes.FIELD_LONG, 1L); break;
case LESS_THAN_DOUBLE: query.lessThan( AllJavaTypes.FIELD_DOUBLE, 1D); break;
case LESS_THAN_FLOAT: query.lessThan( AllJavaTypes.FIELD_FLOAT, 1F); break;
case LESS_THAN_DATE: query.lessThan( AllJavaTypes.FIELD_DATE, new Date(0L)); break;
case LESS_THAN_OR_EQUAL_TO_INTEGER: query.lessThanOrEqualTo( AllJavaTypes.FIELD_INT, 1); break;
case LESS_THAN_OR_EQUAL_TO_LONG: query.lessThanOrEqualTo( AllJavaTypes.FIELD_LONG, 1L); break;
case LESS_THAN_OR_EQUAL_TO_DOUBLE: query.lessThanOrEqualTo( AllJavaTypes.FIELD_DOUBLE, 1D); break;
case LESS_THAN_OR_EQUAL_TO_FLOAT: query.lessThanOrEqualTo( AllJavaTypes.FIELD_FLOAT, 1F); break;
case LESS_THAN_OR_EQUAL_TO_DATE: query.lessThanOrEqualTo( AllJavaTypes.FIELD_DATE, new Date(0L)); break;
case BETWEEN_INTEGER: query.between( AllJavaTypes.FIELD_INT, 1, 100); break;
case BETWEEN_LONG: query.between( AllJavaTypes.FIELD_LONG, 1L, 100L); break;
case BETWEEN_DOUBLE: query.between( AllJavaTypes.FIELD_DOUBLE, 1D, 100D); break;
case BETWEEN_FLOAT: query.between( AllJavaTypes.FIELD_FLOAT, 1F, 100F); break;
case BETWEEN_DATE: query.between( AllJavaTypes.FIELD_DATE, new Date(0L), new Date(10000L)); break;
case CONTAINS_STRING: query.contains( AllJavaTypes.FIELD_STRING, "dummy value"); break;
case CONTAINS_STRING_WITH_CASE: query.contains( AllJavaTypes.FIELD_STRING, "dummy value", Case.INSENSITIVE); break;
case BEGINS_WITH_STRING: query.beginsWith( AllJavaTypes.FIELD_STRING, "dummy value"); break;
case BEGINS_WITH_STRING_WITH_CASE: query.beginsWith( AllJavaTypes.FIELD_STRING, "dummy value", Case.INSENSITIVE); break;
case ENDS_WITH_STRING: query.endsWith( AllJavaTypes.FIELD_STRING, "dummy value"); break;
case ENDS_WITH_STRING_WITH_CASE: query.endsWith( AllJavaTypes.FIELD_STRING, "dummy value", Case.INSENSITIVE); break;
case LIKE_STRING: query.like( AllJavaTypes.FIELD_STRING, "dummy value"); break;
case LIKE_STRING_WITH_CASE: query.like( AllJavaTypes.FIELD_STRING, "dummy value", Case.INSENSITIVE); break;
case BEGIN_GROUP: query.beginGroup(); break;
case END_GROUP: query.endGroup(); break;
case OR: query.or(); break;
case NOT: query.not(); break;
case IS_NULL: query.isNull( AllJavaTypes.FIELD_DATE); break;
case IS_NOT_NULL: query.isNotNull( AllJavaTypes.FIELD_DATE); break;
case IS_EMPTY: query.isEmpty( AllJavaTypes.FIELD_STRING); break;
case IS_NOT_EMPTY: query.isNotEmpty( AllJavaTypes.FIELD_STRING); break;
case IS_VALID: query.isValid(); break;
case DISTINCT: query.distinct( AllJavaTypes.FIELD_STRING); break;
case DISTINCT_BY_MULTIPLE_FIELDS: query.distinct( AllJavaTypes.FIELD_STRING, AllJavaTypes.FIELD_ID); break;
case DISTINCT_ASYNC: query.distinctAsync( AllJavaTypes.FIELD_STRING); break;
case SUM: query.sum( AllJavaTypes.FIELD_INT); break;
case AVERAGE: query.average( AllJavaTypes.FIELD_INT); break;
case MIN: query.min( AllJavaTypes.FIELD_INT); break;
case MINIMUM_DATE: query.minimumDate( AllJavaTypes.FIELD_INT); break;
case MAX: query.max( AllJavaTypes.FIELD_INT); break;
case MAXIMUM_DATE: query.maximumDate( AllJavaTypes.FIELD_INT); break;
case COUNT: query.count(); break;
case FIND_ALL: query.findAll(); break;
case FIND_ALL_ASYNC: query.findAllAsync(); break;
case FIND_ALL_SORTED: query.findAllSorted( AllJavaTypes.FIELD_STRING); break;
case FIND_ALL_SORTED_ASYNC: query.findAllSortedAsync( AllJavaTypes.FIELD_STRING); break;
case FIND_ALL_SORTED_WITH_ORDER: query.findAllSorted( AllJavaTypes.FIELD_STRING, Sort.DESCENDING); break;
case FIND_ALL_SORTED_ASYNC_WITH_ORDER: query.findAllSortedAsync( AllJavaTypes.FIELD_STRING, Sort.DESCENDING); break;
case FIND_ALL_SORTED_WITH_TWO_ORDERS: query.findAllSorted( AllJavaTypes.FIELD_STRING, Sort.DESCENDING, AllJavaTypes.FIELD_ID, Sort.DESCENDING); break;
case FIND_ALL_SORTED_ASYNC_WITH_TWO_ORDERS: query.findAllSortedAsync( AllJavaTypes.FIELD_STRING, Sort.DESCENDING, AllJavaTypes.FIELD_ID, Sort.DESCENDING); break;
case FIND_ALL_SORTED_WITH_MANY_ORDERS: query.findAllSorted( new String[] {AllJavaTypes.FIELD_STRING, AllJavaTypes.FIELD_ID}, new Sort[] {Sort.DESCENDING, Sort.DESCENDING}); break;
case FIND_ALL_SORTED_ASYNC_WITH_MANY_ORDERS: query.findAllSortedAsync( new String[] {AllJavaTypes.FIELD_STRING, AllJavaTypes.FIELD_ID}, new Sort[] {Sort.DESCENDING, Sort.DESCENDING}); break;
case FIND_FIRST: query.findFirst(); break;
case FIND_FIRST_ASYNC: query.findFirstAsync(); break;
default:
throw new AssertionError("missing case for " + method);
}
}
@Test
public void callThreadConfinedMethodsFromWrongThread() throws Throwable {
final RealmQuery<AllJavaTypes> query = realm.where(AllJavaTypes.class);
final AtomicReference<Throwable> throwableFromThread = new AtomicReference<Throwable>();
final CountDownLatch testFinished = new CountDownLatch(1);
final String expectedMessage;
//noinspection TryWithIdenticalCatches
try {
final Field expectedMessageField = BaseRealm.class.getDeclaredField("INCORRECT_THREAD_MESSAGE");
expectedMessageField.setAccessible(true);
expectedMessage = (String) expectedMessageField.get(null);
} catch (NoSuchFieldException e) {
throw new AssertionError(e);
} catch (IllegalAccessException e) {
throw new AssertionError(e);
}
final Thread thread = new Thread("callThreadConfinedMethodsFromWrongThread") {
@Override
public void run() {
try {
for (ThreadConfinedMethods method : ThreadConfinedMethods.values()) {
try {
callThreadConfinedMethod(query, method);
fail("IllegalStateException must be thrown.");
} catch (Throwable e) {
if (e instanceof IllegalStateException && expectedMessage.equals(e.getMessage())) {
// expected exception
continue;
}
throwableFromThread.set(e);
return;
}
}
} finally {
testFinished.countDown();
}
}
};
thread.start();
TestHelper.awaitOrFail(testFinished);
final Throwable throwable = throwableFromThread.get();
if (throwable != null) {
throw throwable;
}
}
@Test
public void between() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList = realm.where(AllTypes.class)
.between(AllTypes.FIELD_LONG, 0, 9).findAll();
assertEquals(10, resultList.size());
resultList = realm.where(AllTypes.class).beginsWith(AllTypes.FIELD_STRING, "test data ").findAll();
assertEquals(TEST_OBJECTS_COUNT, resultList.size());
resultList = realm.where(AllTypes.class).beginsWith(AllTypes.FIELD_STRING, "test data 1")
.between(AllTypes.FIELD_LONG, 2, 20).findAll();
assertEquals(10, resultList.size());
resultList = realm.where(AllTypes.class).between(AllTypes.FIELD_LONG, 2, 20)
.beginsWith(AllTypes.FIELD_STRING, "test data 1").findAll();
assertEquals(10, resultList.size());
assertEquals(51, realm.where(AllTypes.class).between(AllTypes.FIELD_DATE,
new Date(0),
new Date(DECADE_MILLIS * 50)).count());
}
@Test
public void greaterThan() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList = realm.where(AllTypes.class)
.greaterThan(AllTypes.FIELD_FLOAT, 10.2345f).findAll();
assertEquals(TEST_OBJECTS_COUNT - 10, resultList.size());
resultList = realm.where(AllTypes.class).beginsWith(AllTypes.FIELD_STRING, "test data 1")
.greaterThan(AllTypes.FIELD_FLOAT, 150.2345f).findAll();
assertEquals(TEST_OBJECTS_COUNT - 150, resultList.size());
RealmQuery<AllTypes> query = realm.where(AllTypes.class).greaterThan(AllTypes.FIELD_FLOAT, 11.2345f);
resultList = query.between(AllTypes.FIELD_LONG, 1, 20).findAll();
assertEquals(10, resultList.size());
}
@Test
public void greaterThan_date() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList;
resultList = realm.where(AllTypes.class).greaterThan(AllTypes.FIELD_DATE, new Date(Long.MIN_VALUE)).findAll();
assertEquals(TEST_OBJECTS_COUNT, resultList.size());
resultList = realm.where(AllTypes.class).greaterThan(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * -80)).findAll();
assertEquals(179, resultList.size());
resultList = realm.where(AllTypes.class).greaterThan(AllTypes.FIELD_DATE, new Date(0)).findAll();
assertEquals(TEST_OBJECTS_COUNT / 2 - 1, resultList.size());
resultList = realm.where(AllTypes.class).greaterThan(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * 80)).findAll();
assertEquals(19, resultList.size());
resultList = realm.where(AllTypes.class).greaterThan(AllTypes.FIELD_DATE, new Date(Long.MAX_VALUE)).findAll();
assertEquals(0, resultList.size());
}
@Test
public void greaterThanOrEqualTo() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList = realm.where(AllTypes.class)
.greaterThanOrEqualTo(AllTypes.FIELD_FLOAT, 10.2345f).findAll();
assertEquals(TEST_OBJECTS_COUNT - 9, resultList.size());
resultList = realm.where(AllTypes.class).beginsWith(AllTypes.FIELD_STRING, "test data 1")
.greaterThanOrEqualTo(AllTypes.FIELD_FLOAT, 50.2345f).findAll();
assertEquals(TEST_OBJECTS_COUNT - 100, resultList.size());
RealmQuery<AllTypes> query = realm.where(AllTypes.class)
.greaterThanOrEqualTo(AllTypes.FIELD_FLOAT, 11.2345f);
query = query.between(AllTypes.FIELD_LONG, 1, 20);
resultList = query.beginsWith(AllTypes.FIELD_STRING, "test data 15").findAll();
assertEquals(1, resultList.size());
}
@Test
public void greaterThanOrEqualTo_date() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList;
resultList = realm.where(AllTypes.class).greaterThanOrEqualTo(AllTypes.FIELD_DATE, new Date(Long.MIN_VALUE)).findAll();
assertEquals(TEST_OBJECTS_COUNT, resultList.size());
resultList = realm.where(AllTypes.class).greaterThanOrEqualTo(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * -80)).findAll();
assertEquals(180, resultList.size());
resultList = realm.where(AllTypes.class).greaterThanOrEqualTo(AllTypes.FIELD_DATE, new Date(0)).findAll();
assertEquals(TEST_OBJECTS_COUNT / 2, resultList.size());
resultList = realm.where(AllTypes.class).greaterThanOrEqualTo(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * 80)).findAll();
assertEquals(20, resultList.size());
resultList = realm.where(AllTypes.class).greaterThanOrEqualTo(AllTypes.FIELD_DATE, new Date(Long.MAX_VALUE)).findAll();
assertEquals(0, resultList.size());
}
@Test
public void or() {
populateTestRealm(realm, 200);
RealmQuery<AllTypes> query = realm.where(AllTypes.class).equalTo(AllTypes.FIELD_FLOAT, 31.2345f);
RealmResults<AllTypes> resultList = query.or().between(AllTypes.FIELD_LONG, 1, 20).findAll();
assertEquals(21, resultList.size());
resultList = query.or().equalTo(AllTypes.FIELD_STRING, "test data 15").findAll();
assertEquals(21, resultList.size());
resultList = query.or().equalTo(AllTypes.FIELD_STRING, "test data 117").findAll();
assertEquals(22, resultList.size());
}
@Test(expected = UnsupportedOperationException.class)
public void or_missingFilters() {
realm.where(AllTypes.class).or().findAll();
}
@Test(expected = UnsupportedOperationException.class)
public void or_missingFilterBefore() {
realm.where(AllTypes.class).or().equalTo(AllTypes.FIELD_FLOAT, 31.2345f).findAll();
}
@Test(expected = UnsupportedOperationException.class)
public void or_missingFilterAfter() {
realm.where(AllTypes.class).or().equalTo(AllTypes.FIELD_FLOAT, 31.2345f).findAll();
}
@Test
public void not() {
populateTestRealm(); // create TEST_DATA_SIZE objects
// Only one object with value 5 -> TEST_DATA_SIZE-1 object with value "not 5".
RealmResults<AllTypes> list1 = realm.where(AllTypes.class).not().equalTo(AllTypes.FIELD_LONG, 5).findAll();
assertEquals(TEST_DATA_SIZE - 1, list1.size());
// not().greater() and lessThenOrEqual() must be the same.
RealmResults<AllTypes> list2 = realm.where(AllTypes.class).not().greaterThan(AllTypes.FIELD_LONG, 5).findAll();
RealmResults<AllTypes> list3 = realm.where(AllTypes.class).lessThanOrEqualTo(AllTypes.FIELD_LONG, 5).findAll();
assertEquals(list2.size(), list3.size());
for (int i = 0; i < list2.size(); i++) {
assertEquals(list2.get(i).getColumnLong(), list3.get(i).getColumnLong());
}
// excepted result: 0, 1, 2, 5
long expected[] = {0, 1, 2, 5};
RealmResults<AllTypes> list4 = realm.where(AllTypes.class)
.equalTo(AllTypes.FIELD_LONG, 5)
.or()
.not().beginGroup()
.greaterThan(AllTypes.FIELD_LONG, 2)
.endGroup()
.findAll();
assertEquals(4, list4.size());
for (int i = 0; i < list4.size(); i++) {
assertEquals(expected[i], list4.get(i).getColumnLong());
}
}
@Test (expected = UnsupportedOperationException.class)
public void not_aloneThrows() {
// a not() alone must fail
realm.where(AllTypes.class).not().findAll();
}
@Test
public void and_implicit() {
populateTestRealm(realm, 200);
RealmQuery<AllTypes> query = realm.where(AllTypes.class).equalTo(AllTypes.FIELD_FLOAT, 31.2345f);
RealmResults<AllTypes> resultList = query.between(AllTypes.FIELD_LONG, 1, 10).findAll();
assertEquals(0, resultList.size());
query = realm.where(AllTypes.class).equalTo(AllTypes.FIELD_FLOAT, 81.2345f);
resultList = query.between(AllTypes.FIELD_LONG, 1, 100).findAll();
assertEquals(1, resultList.size());
}
@Test
public void lessThan() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList = realm.where(AllTypes.class).
lessThan(AllTypes.FIELD_FLOAT, 31.2345f).findAll();
assertEquals(30, resultList.size());
RealmQuery<AllTypes> query = realm.where(AllTypes.class).lessThan(AllTypes.FIELD_FLOAT, 31.2345f);
resultList = query.between(AllTypes.FIELD_LONG, 1, 10).findAll();
assertEquals(10, resultList.size());
}
@Test
public void lessThan_Date() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList;
resultList = realm.where(AllTypes.class).lessThan(AllTypes.FIELD_DATE, new Date(Long.MIN_VALUE)).findAll();
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class).lessThan(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * -80)).findAll();
assertEquals(20, resultList.size());
resultList = realm.where(AllTypes.class).lessThan(AllTypes.FIELD_DATE, new Date(0)).findAll();
assertEquals(TEST_OBJECTS_COUNT / 2, resultList.size());
resultList = realm.where(AllTypes.class).lessThan(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * 80)).findAll();
assertEquals(180, resultList.size());
resultList = realm.where(AllTypes.class).lessThan(AllTypes.FIELD_DATE, new Date(Long.MAX_VALUE)).findAll();
assertEquals(TEST_OBJECTS_COUNT, resultList.size());
}
@Test
public void lessThanOrEqualTo() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList = realm.where(AllTypes.class)
.lessThanOrEqualTo(AllTypes.FIELD_FLOAT, 31.2345f).findAll();
assertEquals(31, resultList.size());
resultList = realm.where(AllTypes.class).lessThanOrEqualTo(AllTypes.FIELD_FLOAT, 31.2345f)
.between(AllTypes.FIELD_LONG, 11, 20).findAll();
assertEquals(10, resultList.size());
}
@Test
public void lessThanOrEqualTo_date() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList;
resultList = realm.where(AllTypes.class).lessThanOrEqualTo(AllTypes.FIELD_DATE, new Date(Long.MIN_VALUE)).findAll();
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class).lessThanOrEqualTo(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * -80)).findAll();
assertEquals(21, resultList.size());
resultList = realm.where(AllTypes.class).lessThanOrEqualTo(AllTypes.FIELD_DATE, new Date(0)).findAll();
assertEquals(TEST_OBJECTS_COUNT / 2 + 1, resultList.size());
resultList = realm.where(AllTypes.class).lessThanOrEqualTo(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * 80)).findAll();
assertEquals(181, resultList.size());
resultList = realm.where(AllTypes.class).lessThanOrEqualTo(AllTypes.FIELD_DATE, new Date(Long.MAX_VALUE)).findAll();
assertEquals(TEST_OBJECTS_COUNT, resultList.size());
}
@Test
public void equalTo() {
populateTestRealm(realm, 200);
RealmResults<AllTypes> resultList = realm.where(AllTypes.class)
.equalTo(AllTypes.FIELD_FLOAT, 31.2345f).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).greaterThan(AllTypes.FIELD_FLOAT, 11.0f)
.equalTo(AllTypes.FIELD_LONG, 10).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).greaterThan(AllTypes.FIELD_FLOAT, 11.0f)
.equalTo(AllTypes.FIELD_LONG, 1).findAll();
assertEquals(0, resultList.size());
}
@Test
public void equalTo_date() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList;
resultList = realm.where(AllTypes.class).equalTo(AllTypes.FIELD_DATE, new Date(Long.MIN_VALUE)).findAll();
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class).equalTo(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * -80)).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).equalTo(AllTypes.FIELD_DATE, new Date(0)).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).equalTo(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * 80)).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).equalTo(AllTypes.FIELD_DATE, new Date(Long.MAX_VALUE)).findAll();
assertEquals(0, resultList.size());
}
@Test
public void equalTo_nonLatinCharacters() {
populateTestRealm(realm, 200);
RealmResults<NonLatinFieldNames> resultList = realm.where(NonLatinFieldNames.class)
.equalTo(NonLatinFieldNames.FIELD_LONG_KOREAN_CHAR, 13).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NonLatinFieldNames.class)
.greaterThan(NonLatinFieldNames.FIELD_FLOAT_KOREAN_CHAR, 11.0f)
.equalTo(NonLatinFieldNames.FIELD_LONG_KOREAN_CHAR, 10).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NonLatinFieldNames.class)
.greaterThan(NonLatinFieldNames.FIELD_FLOAT_KOREAN_CHAR, 11.0f)
.equalTo(NonLatinFieldNames.FIELD_LONG_KOREAN_CHAR, 1).findAll();
assertEquals(0, resultList.size());
resultList = realm.where(NonLatinFieldNames.class)
.equalTo(NonLatinFieldNames.FIELD_LONG_GREEK_CHAR, 13).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NonLatinFieldNames.class)
.greaterThan(NonLatinFieldNames.FIELD_FLOAT_GREEK_CHAR, 11.0f)
.equalTo(NonLatinFieldNames.FIELD_LONG_GREEK_CHAR, 10).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NonLatinFieldNames.class)
.greaterThan(NonLatinFieldNames.FIELD_FLOAT_GREEK_CHAR, 11.0f)
.equalTo(NonLatinFieldNames.FIELD_LONG_GREEK_CHAR, 1).findAll();
assertEquals(0, resultList.size());
}
private void doTestForInString(String targetField) {
populateNoPrimaryKeyNullTypesRows();
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, (String[]) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new String[]{}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new String[]{"test data 14"}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new String[]{"test data 14", "test data 118", "test data 31", "test data 199"}).findAll();
assertEquals(4, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new String[]{"TEST data 14", "test data 118", "test data 31", "test DATA 199"}, Case.INSENSITIVE).findAll();
assertEquals(4, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(targetField, new String[]{"TEST data 14", "test data 118", "test data 31", "test DATA 199"}, Case.INSENSITIVE).findAll();
assertEquals(196, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(targetField, new String[]{"TEST data 14", "test data 118", "test data 31", "test DATA 199"}, Case.INSENSITIVE).findAll();
assertEquals(196, resultList.size());
}
private void doTestForInBoolean(String targetField, int expected1, int expected2, int expected3, int expected4) {
populateNoPrimaryKeyNullTypesRows();
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, (Boolean[]) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Boolean[]{}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Boolean[]{false}).findAll();
assertEquals(expected1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Boolean[]{true}).findAll();
assertEquals(expected2, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Boolean[]{true, false}).findAll();
assertEquals(expected3, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(targetField, new Boolean[]{true, false}).findAll();
assertEquals(expected4, resultList.size());
}
private void doTestForInDate(String targetField) {
populateNoPrimaryKeyNullTypesRows();
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, (Date[]) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Date[]{}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Date[]{new Date(DECADE_MILLIS * -80)}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Date[]{new Date(0)}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Date[]{new Date(DECADE_MILLIS * -80), new Date(0)}).findAll();
assertEquals(2, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(targetField, new Date[]{new Date(DECADE_MILLIS * -80), new Date(0)}).findAll();
assertEquals(198, resultList.size());
}
private void doTestForInDouble(String targetField) {
populateNoPrimaryKeyNullTypesRows();
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, (Double[]) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Double[]{}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Double[]{Math.PI + 1}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Double[]{Math.PI + 2}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Double[]{Math.PI + 1, Math.PI + 2}).findAll();
assertEquals(2, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(targetField, new Double[]{Math.PI + 1, Math.PI + 2}).findAll();
assertEquals(198, resultList.size());
}
private void doTestForInFloat(String targetField) {
populateNoPrimaryKeyNullTypesRows();
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, (Float[]) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Float[]{}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Float[]{1.2345f + 1}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Float[]{1.2345f + 2}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Float[]{1.2345f + 1, 1.2345f + 2}).findAll();
assertEquals(2, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(targetField, new Float[]{1.2345f + 1, 1.2345f + 2}).findAll();
assertEquals(198, resultList.size());
}
private void doTestForInByte(String targetField) {
populateNoPrimaryKeyNullTypesRows();
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, (Byte[]) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Byte[]{}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Byte[]{11}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Byte[]{13}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Byte[]{11, 13, 16, 98}).findAll();
assertEquals(4, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(targetField, new Byte[]{11, 13, 16, 98}).findAll();
assertEquals(196, resultList.size());
}
private void doTestForInShort(String targetField) {
populateNoPrimaryKeyNullTypesRows();
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, (Short[]) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Short[]{}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Short[]{11}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Short[]{4}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Short[]{2, 4, 5, 8}).findAll();
assertEquals(4, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(targetField, new Short[]{2, 4, 5, 8}).findAll();
assertEquals(196, resultList.size());
}
private void doTestForInInteger(String targetField) {
populateNoPrimaryKeyNullTypesRows();
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, (Integer[]) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Integer[]{}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Integer[]{11}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Integer[]{1}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Integer[]{1, 2, 4, 5}).findAll();
assertEquals(4, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(targetField, new Integer[]{1, 2, 4, 5}).findAll();
assertEquals(196, resultList.size());
}
private void doTestForInLong(String targetField) {
populateNoPrimaryKeyNullTypesRows();
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, (Long[]) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
try {
realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Long[]{}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Long[]{11l}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Long[]{13l}).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).in(targetField, new Long[]{13l, 14l, 16l, 98l}).findAll();
assertEquals(4, resultList.size());
resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(targetField, new Long[]{13l, 14l, 16l, 98l}).findAll();
assertEquals(196, resultList.size());
}
@Test
public void in_stringNotNull() {
doTestForInString(NoPrimaryKeyNullTypes.FIELD_STRING_NOT_NULL);
try {
realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_STRING_NOT_NULL, new String[]{"TEST data 14", "test data 118", null, "test DATA 199"}, Case.INSENSITIVE).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void in_stringNull() {
doTestForInString(NoPrimaryKeyNullTypes.FIELD_STRING_NULL);
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_STRING_NULL, new String[]{"TEST data 14", "test data 118", null, "test DATA 199"}, Case.INSENSITIVE).findAll();
assertEquals(130, resultList.size());
}
@Test
public void in_booleanNotNull() {
doTestForInBoolean(NoPrimaryKeyNullTypes.FIELD_BOOLEAN_NOT_NULL, 133, 67, 200, 0);
try {
realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_BOOLEAN_NOT_NULL, new Boolean[]{true, null, false}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void in_booleanNull() {
doTestForInBoolean(NoPrimaryKeyNullTypes.FIELD_BOOLEAN_NULL, 66, 67, 133, 67);
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_BOOLEAN_NULL, new Boolean[]{true, null, false}).findAll();
assertEquals(0, resultList.size());
}
@Test
public void in_dateNotNull() {
doTestForInDate(NoPrimaryKeyNullTypes.FIELD_DATE_NOT_NULL);
try {
realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_DATE_NOT_NULL, new Date[]{new Date(DECADE_MILLIS * -80), null, new Date(0)}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void in_dateNull() {
doTestForInDate(NoPrimaryKeyNullTypes.FIELD_DATE_NULL);
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_DATE_NULL, new Date[]{new Date(DECADE_MILLIS * -80), null, new Date(0)}).findAll();
assertEquals(131, resultList.size());
}
@Test
public void in_doubleNotNull() {
doTestForInDouble(NoPrimaryKeyNullTypes.FIELD_DOUBLE_NOT_NULL);
try {
realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_DOUBLE_NOT_NULL, new Double[]{Math.PI + 1, null, Math.PI + 2}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void in_doubleNull() {
doTestForInDouble(NoPrimaryKeyNullTypes.FIELD_DOUBLE_NULL);
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_DOUBLE_NULL, new Double[]{Math.PI + 1, null, Math.PI + 2}).findAll();
assertEquals(131, resultList.size());
}
@Test
public void in_floatNotNull() {
doTestForInFloat(NoPrimaryKeyNullTypes.FIELD_FLOAT_NOT_NULL);
try {
realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_FLOAT_NOT_NULL, new Float[]{1.2345f + 1, null, 1.2345f + 2}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void in_floatNull() {
doTestForInFloat(NoPrimaryKeyNullTypes.FIELD_FLOAT_NULL);
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_FLOAT_NULL, new Float[]{1.2345f + 1, null, 1.2345f + 2}).findAll();
assertEquals(131, resultList.size());
}
@Test
public void in_byteNotNull() {
doTestForInByte(NoPrimaryKeyNullTypes.FIELD_BYTE_NOT_NULL);
try {
realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_BYTE_NOT_NULL, new Byte[]{11, null, 13, 99}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void in_byteNull() {
doTestForInByte(NoPrimaryKeyNullTypes.FIELD_BYTE_NULL);
RealmResults resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_BYTE_NULL, new Byte[]{11, null, 13, 99}).findAll();
assertEquals(131, resultList.size());
}
@Test
public void in_shortNotNull() {
doTestForInShort(NoPrimaryKeyNullTypes.FIELD_SHORT_NOT_NULL);
try {
realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_SHORT_NOT_NULL, new Short[]{2, null, 5, 8}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void in_shortNull() {
doTestForInShort(NoPrimaryKeyNullTypes.FIELD_SHORT_NULL);
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_SHORT_NULL, new Short[]{2, null, 5, 8}).findAll();
assertEquals(130, resultList.size());
}
@Test
public void in_integerNotNull() {
doTestForInInteger(NoPrimaryKeyNullTypes.FIELD_INTEGER_NOT_NULL);
try {
realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_INTEGER_NOT_NULL, new Integer[]{1, null, 4, 5}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void in_integerNull() {
doTestForInInteger(NoPrimaryKeyNullTypes.FIELD_INTEGER_NULL);
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_INTEGER_NULL, new Integer[]{1, null, 4, 5}).findAll();
assertEquals(130, resultList.size());
}
@Test
public void in_longNotNull() {
doTestForInLong(NoPrimaryKeyNullTypes.FIELD_LONG_NOT_NULL);
try {
realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_LONG_NOT_NULL, new Long[]{13l, null, 16l, 98l}).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void in_longNull() {
doTestForInLong(NoPrimaryKeyNullTypes.FIELD_LONG_NULL);
RealmResults<NoPrimaryKeyNullTypes> resultList = realm.where(NoPrimaryKeyNullTypes.class).not().in(NoPrimaryKeyNullTypes.FIELD_LONG_NULL, new Long[]{13l, null, 16l, 98l}).findAll();
assertEquals(130, resultList.size());
}
@Test
public void notEqualTo() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList = realm.where(AllTypes.class)
.notEqualTo(AllTypes.FIELD_LONG, 31).findAll();
assertEquals(TEST_OBJECTS_COUNT - 1, resultList.size());
resultList = realm.where(AllTypes.class).notEqualTo(AllTypes.FIELD_FLOAT, 11.2345f)
.equalTo(AllTypes.FIELD_LONG, 10).findAll();
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class).notEqualTo(AllTypes.FIELD_FLOAT, 11.2345f)
.equalTo(AllTypes.FIELD_LONG, 1).findAll();
assertEquals(1, resultList.size());
}
@Test
public void notEqualTo_date() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList;
resultList = realm.where(AllTypes.class).notEqualTo(AllTypes.FIELD_DATE, new Date(Long.MIN_VALUE)).findAll();
assertEquals(TEST_OBJECTS_COUNT, resultList.size());
resultList = realm.where(AllTypes.class).notEqualTo(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * -80)).findAll();
assertEquals(TEST_OBJECTS_COUNT - 1, resultList.size());
resultList = realm.where(AllTypes.class).notEqualTo(AllTypes.FIELD_DATE, new Date(0)).findAll();
assertEquals(TEST_OBJECTS_COUNT - 1, resultList.size());
resultList = realm.where(AllTypes.class).notEqualTo(AllTypes.FIELD_DATE, new Date(DECADE_MILLIS * 80)).findAll();
assertEquals(TEST_OBJECTS_COUNT - 1, resultList.size());
resultList = realm.where(AllTypes.class).notEqualTo(AllTypes.FIELD_DATE, new Date(Long.MAX_VALUE)).findAll();
assertEquals(TEST_OBJECTS_COUNT, resultList.size());
}
@Test
public void contains_caseSensitive() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList = realm.where(AllTypes.class)
.contains("columnString", "DaTa 0", Case.INSENSITIVE)
.or().contains("columnString", "20")
.findAll();
assertEquals(3, resultList.size());
resultList = realm.where(AllTypes.class).contains("columnString", "DATA").findAll();
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class)
.contains("columnString", "TEST", Case.INSENSITIVE).findAll();
assertEquals(TEST_OBJECTS_COUNT, resultList.size());
}
@Test
public void contains_caseSensitiveWithNonLatinCharacters() {
populateTestRealm();
realm.beginTransaction();
realm.delete(AllTypes.class);
AllTypes at1 = realm.createObject(AllTypes.class);
at1.setColumnString("Αλφα");
AllTypes at2 = realm.createObject(AllTypes.class);
at2.setColumnString("βήτα");
AllTypes at3 = realm.createObject(AllTypes.class);
at3.setColumnString("δέλτα");
realm.commitTransaction();
RealmResults<AllTypes> resultList = realm.where(AllTypes.class)
.contains("columnString", "Α", Case.INSENSITIVE)
.or().contains("columnString", "δ")
.findAll();
// Without case sensitive there is 3, Α = α
// assertEquals(3,resultList.size());
assertEquals(2, resultList.size());
resultList = realm.where(AllTypes.class).contains("columnString", "α").findAll();
assertEquals(3, resultList.size());
resultList = realm.where(AllTypes.class).contains("columnString", "Δ").findAll();
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class).contains("columnString", "Δ",
Case.INSENSITIVE).findAll();
// Without case sensitive there is 1, Δ = δ
// assertEquals(1,resultList.size());
assertEquals(0, resultList.size());
}
@Test
public void like_caseSensitive() {
final int TEST_OBJECTS_COUNT = 200;
populateTestRealm(realm, TEST_OBJECTS_COUNT);
RealmResults<AllTypes> resultList = realm.where(AllTypes.class).like("columnString", "*DaTa*").findAll();
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "*DaTa*", Case.INSENSITIVE).findAll();
assertEquals(TEST_OBJECTS_COUNT, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "*DaTa 2?").findAll();
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "*DaTa 2?", Case.INSENSITIVE).findAll();
assertEquals(10, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "TEST*0").findAll();
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "TEST*0", Case.INSENSITIVE).findAll();
assertEquals(20, resultList.size());
}
@Test
public void like_caseSensitiveWithNonLatinCharacters() {
populateTestRealm();
String flagEmoji = new StringBuilder().append(Character.toChars(0x1F1E9)).toString();
String emojis = "ABC" + flagEmoji + "DEF";
realm.beginTransaction();
realm.delete(AllTypes.class);
AllTypes at1 = realm.createObject(AllTypes.class);
at1.setColumnString("Αλφα");
AllTypes at2 = realm.createObject(AllTypes.class);
at2.setColumnString("βήτα");
AllTypes at3 = realm.createObject(AllTypes.class);
at3.setColumnString("δέλτα");
AllTypes at4 = realm.createObject(AllTypes.class);
at4.setColumnString(emojis);
realm.commitTransaction();
RealmResults<AllTypes> resultList = realm.where(AllTypes.class).like("columnString", "*Α*").findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "*λ*").findAll();
assertEquals(2, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "*Δ*").findAll();
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "*Α*", Case.INSENSITIVE).findAll();
// without ASCII-only limitation A matches α
// assertEquals(3, resultList.size());
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "*λ*", Case.INSENSITIVE).findAll();
assertEquals(2, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "*Δ*", Case.INSENSITIVE).findAll();
// without ASCII-only limitation Δ matches δ
// assertEquals(1, resultList.size());
assertEquals(0, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "?λ*").findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "??λ*").findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "?λ*").findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "??λ*").findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "ABC?DEF*").findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllTypes.class).like("columnString", "*" + flagEmoji + "*").findAll();
assertEquals(1, resultList.size());
}
@Test
public void equalTo_withNonExistingField() {
try {
realm.where(AllTypes.class).equalTo("NotAField", 13).findAll();
fail("Should throw exception");
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void queryLink() {
realm.beginTransaction();
Owner owner = realm.createObject(Owner.class);
Dog dog1 = realm.createObject(Dog.class);
dog1.setName("Dog 1");
dog1.setWeight(1);
Dog dog2 = realm.createObject(Dog.class);
dog2.setName("Dog 2");
dog2.setWeight(2);
owner.getDogs().add(dog1);
owner.getDogs().add(dog2);
realm.commitTransaction();
// Dog.weight has index 4 which is more than the total number of columns in Owner
// This tests exposes a subtle error where the Owner table spec is used instead of Dog table spec.
RealmResults<Dog> dogs = realm.where(Owner.class).findFirst().getDogs().where()
.findAllSorted("name", Sort.ASCENDING);
Dog dog = dogs.where().equalTo("weight", 1d).findFirst();
assertEquals(dog1, dog);
}
@Test
public void findAllSorted_multiFailures() {
// Zero fields specified.
try {
realm.where(AllTypes.class).findAllSorted(new String[]{}, new Sort[]{});
fail();
} catch (IllegalArgumentException ignored) {
}
// Number of fields and sorting orders don't match.
try {
realm.where(AllTypes.class).findAllSorted(new String[]{AllTypes.FIELD_STRING},
new Sort[]{Sort.ASCENDING, Sort.ASCENDING});
fail();
} catch (IllegalArgumentException ignored) {
}
// Null is not allowed.
try {
realm.where(AllTypes.class).findAllSorted((String[]) null, null);
fail();
} catch (IllegalArgumentException ignored) {
}
try {
realm.where(AllTypes.class).findAllSorted(new String[]{AllTypes.FIELD_STRING}, null);
fail();
} catch (IllegalArgumentException ignored) {
}
// Non-existing field name.
try {
realm.where(AllTypes.class)
.findAllSorted(new String[]{AllTypes.FIELD_STRING, "do-not-exist"},
new Sort[]{Sort.ASCENDING, Sort.ASCENDING});
fail();
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void findAllSorted_singleField() {
realm.beginTransaction();
for (int i = 0; i < TEST_DATA_SIZE; i++) {
AllTypes allTypes = realm.createObject(AllTypes.class);
allTypes.setColumnLong(i);
}
realm.commitTransaction();
RealmResults<AllTypes> sortedList = realm.where(AllTypes.class)
.findAllSorted(new String[]{AllTypes.FIELD_LONG}, new Sort[]{Sort.DESCENDING});
assertEquals(TEST_DATA_SIZE, sortedList.size());
assertEquals(TEST_DATA_SIZE - 1, sortedList.first().getColumnLong());
assertEquals(0, sortedList.last().getColumnLong());
}
@Test
public void subQueryScope() {
populateTestRealm();
RealmResults<AllTypes> result = realm.where(AllTypes.class).lessThan("columnLong", 5).findAll();
RealmResults<AllTypes> subQueryResult = result.where().greaterThan("columnLong", 3).findAll();
assertEquals(1, subQueryResult.size());
}
@Test
public void findFirst() {
realm.beginTransaction();
Owner owner1 = realm.createObject(Owner.class);
owner1.setName("Owner 1");
Dog dog1 = realm.createObject(Dog.class);
dog1.setName("Dog 1");
dog1.setWeight(1);
Dog dog2 = realm.createObject(Dog.class);
dog2.setName("Dog 2");
dog2.setWeight(2);
owner1.getDogs().add(dog1);
owner1.getDogs().add(dog2);
Owner owner2 = realm.createObject(Owner.class);
owner2.setName("Owner 2");
Dog dog3 = realm.createObject(Dog.class);
dog3.setName("Dog 3");
dog3.setWeight(1);
Dog dog4 = realm.createObject(Dog.class);
dog4.setName("Dog 4");
dog4.setWeight(2);
owner2.getDogs().add(dog3);
owner2.getDogs().add(dog4);
realm.commitTransaction();
RealmList<Dog> dogs = realm.where(Owner.class).equalTo("name", "Owner 2").findFirst().getDogs();
Dog dog = dogs.where().equalTo("name", "Dog 4").findFirst();
assertEquals(dog4, dog);
}
@Test
public void georgian() {
String words[] = {"მონაცემთა ბაზა", "მიწისქვეშა გადასასვლელი", "რუსთაველის გამზირი",
"მთავარი ქუჩა", "სადგურის მოედანი", "ველოცირაპტორების ჯოგი"};
String sorted[] = {"ველოცირაპტორების ჯოგი", "მთავარი ქუჩა", "მიწისქვეშა გადასასვლელი",
"მონაცემთა ბაზა", "რუსთაველის გამზირი", "სადგურის მოედანი"};
realm.beginTransaction();
realm.delete(StringOnly.class);
for (String word : words) {
StringOnly stringOnly = realm.createObject(StringOnly.class);
stringOnly.setChars(word);
}
realm.commitTransaction();
RealmResults<StringOnly> stringOnlies1 = realm.where(StringOnly.class).contains("chars", "მთავარი").findAll();
assertEquals(1, stringOnlies1.size());
RealmResults<StringOnly> stringOnlies2 = realm.where(StringOnly.class).findAll();
stringOnlies2 = stringOnlies2.sort("chars");
for (int i = 0; i < stringOnlies2.size(); i++) {
assertEquals(sorted[i], stringOnlies2.get(i).getChars());
}
}
// Quering a non-nullable field with null is an error.
@Test
public void equalTo_notNullableFields() {
TestHelper.populateTestRealmForNullTests(realm);
// 1 String
try {
realm.where(NullTypes.class).equalTo(NullTypes.FIELD_STRING_NOT_NULL,
(String) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 2 Bytes
try {
realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BYTES_NOT_NULL, (byte[]) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 3 Boolean
try {
realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BOOLEAN_NOT_NULL, (Boolean) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 4 Byte
try {
realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BYTE_NOT_NULL, (Byte) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 5 Short
try {
realm.where(NullTypes.class).equalTo(NullTypes.FIELD_SHORT_NOT_NULL, (Short) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 6 Integer
try {
realm.where(NullTypes.class).equalTo(NullTypes.FIELD_INTEGER_NOT_NULL, (Integer) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 7 Long
try {
realm.where(NullTypes.class).equalTo(NullTypes.FIELD_LONG_NOT_NULL, (Long) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 8 Float
try {
realm.where(NullTypes.class).equalTo(NullTypes.FIELD_FLOAT_NOT_NULL, (Float) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 9 Double
try {
realm.where(NullTypes.class).equalTo(NullTypes.FIELD_DOUBLE_NOT_NULL, (Double) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 10 Date
try {
realm.where(NullTypes.class).equalTo(NullTypes.FIELD_DATE_NOT_NULL, (Date) null).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
// Querying a non-nullable field with null is an error.
@Test
public void isNull_notNullableFields() {
// 1 String
try {
realm.where(NullTypes.class).isNull(NullTypes.FIELD_STRING_NOT_NULL).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 2 Bytes
try {
realm.where(NullTypes.class).isNull(NullTypes.FIELD_BYTES_NOT_NULL).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 3 Boolean
try {
realm.where(NullTypes.class).isNull(NullTypes.FIELD_BOOLEAN_NOT_NULL).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 4 Byte
try {
realm.where(NullTypes.class).isNull(NullTypes.FIELD_BYTE_NOT_NULL).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 5 Short
try {
realm.where(NullTypes.class).isNull(NullTypes.FIELD_SHORT_NOT_NULL).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 6 Integer
try {
realm.where(NullTypes.class).isNull(NullTypes.FIELD_INTEGER_NOT_NULL).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 7 Long
try {
realm.where(NullTypes.class).isNull(NullTypes.FIELD_LONG_NOT_NULL).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 8 Float
try {
realm.where(NullTypes.class).isNull(NullTypes.FIELD_FLOAT_NOT_NULL).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 9 Double
try {
realm.where(NullTypes.class).isNull(NullTypes.FIELD_DOUBLE_NOT_NULL).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
// 10 Date
try {
realm.where(NullTypes.class).isNull(NullTypes.FIELD_DATE_NOT_NULL).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
// Queries nullable PrimaryKey.
@Test
public void equalTo_nullPrimaryKeys() {
final long SECONDARY_FIELD_NUMBER = 49992417L;
final String SECONDARY_FIELD_STRING = "Realm is a mobile database hundreds of millions of people rely on.";
// Fills up a Realm with one user PrimaryKey value and 9 numeric values, starting from -5.
TestHelper.populateTestRealmWithStringPrimaryKey(realm, (String) null, SECONDARY_FIELD_NUMBER, 10, -5);
TestHelper.populateTestRealmWithBytePrimaryKey(realm, (Byte) null, SECONDARY_FIELD_STRING, 10, -5);
TestHelper.populateTestRealmWithShortPrimaryKey(realm, (Short) null, SECONDARY_FIELD_STRING, 10, -5);
TestHelper.populateTestRealmWithIntegerPrimaryKey(realm, (Integer) null, SECONDARY_FIELD_STRING, 10, -5);
TestHelper.populateTestRealmWithLongPrimaryKey(realm, (Long) null, SECONDARY_FIELD_STRING, 10, -5);
// String
assertEquals(SECONDARY_FIELD_NUMBER, realm.where(PrimaryKeyAsString.class).equalTo(PrimaryKeyAsString.FIELD_PRIMARY_KEY, (String) null).findAll().first().getId());
// Boxed Byte
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedByte.class).equalTo(PrimaryKeyAsBoxedByte.FIELD_PRIMARY_KEY, (Byte) null).findAll().first().getName());
// Boxed Short
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedShort.class).equalTo(PrimaryKeyAsBoxedShort.FIELD_PRIMARY_KEY, (Short) null).findAll().first().getName());
// Boxed Integer
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedInteger.class).equalTo(PrimaryKeyAsBoxedInteger.FIELD_PRIMARY_KEY, (Integer) null).findAll().first().getName());
// Boxed Long
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedLong.class).equalTo(PrimaryKeyAsBoxedLong.FIELD_PRIMARY_KEY, (Long) null).findAll().first().getName());
}
@Test
public void isNull_nullPrimaryKeys() {
final long SECONDARY_FIELD_NUMBER = 49992417L;
final String SECONDARY_FIELD_STRING = "Realm is a mobile database hundreds of millions of people rely on.";
// Fills up a realm with one user PrimaryKey value and 9 numeric values, starting from -5.
TestHelper.populateTestRealmWithStringPrimaryKey(realm, (String) null, SECONDARY_FIELD_NUMBER, 10, -5);
TestHelper.populateTestRealmWithBytePrimaryKey(realm, (Byte) null, SECONDARY_FIELD_STRING, 10, -5);
TestHelper.populateTestRealmWithShortPrimaryKey(realm, (Short) null, SECONDARY_FIELD_STRING, 10, -5);
TestHelper.populateTestRealmWithIntegerPrimaryKey(realm, (Integer) null, SECONDARY_FIELD_STRING, 10, -5);
TestHelper.populateTestRealmWithLongPrimaryKey(realm, (Long) null, SECONDARY_FIELD_STRING, 10, -5);
// String
assertEquals(SECONDARY_FIELD_NUMBER, realm.where(PrimaryKeyAsString.class).isNull(PrimaryKeyAsString.FIELD_PRIMARY_KEY).findAll().first().getId());
// Boxed Byte
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedByte.class).isNull(PrimaryKeyAsBoxedByte.FIELD_PRIMARY_KEY).findAll().first().getName());
// Boxed Short
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedShort.class).isNull(PrimaryKeyAsBoxedShort.FIELD_PRIMARY_KEY).findAll().first().getName());
// Boxed Integer
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedInteger.class).isNull(PrimaryKeyAsBoxedInteger.FIELD_PRIMARY_KEY).findAll().first().getName());
// Boxed Long
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedLong.class).isNull(PrimaryKeyAsBoxedLong.FIELD_PRIMARY_KEY).findAll().first().getName());
}
@Test
public void notEqualTo_nullPrimaryKeys() {
final long SECONDARY_FIELD_NUMBER = 49992417L;
final String SECONDARY_FIELD_STRING = "Realm is a mobile database hundreds of millions of people rely on.";
// Fills up a realm with one user PrimaryKey value and one numeric values, starting from -1.
TestHelper.populateTestRealmWithStringPrimaryKey(realm, (String) null, SECONDARY_FIELD_NUMBER, 2, -1);
TestHelper.populateTestRealmWithBytePrimaryKey(realm, (Byte) null, SECONDARY_FIELD_STRING, 2, -1);
TestHelper.populateTestRealmWithShortPrimaryKey(realm, (Short) null, SECONDARY_FIELD_STRING, 2, -1);
TestHelper.populateTestRealmWithIntegerPrimaryKey(realm, (Integer) null, SECONDARY_FIELD_STRING, 2, -1);
TestHelper.populateTestRealmWithLongPrimaryKey(realm, (Long) null, SECONDARY_FIELD_STRING, 2, -1);
// String
assertEquals(SECONDARY_FIELD_NUMBER, realm.where(PrimaryKeyAsString.class).notEqualTo(PrimaryKeyAsString.FIELD_PRIMARY_KEY, "-1").findAll().first().getId());
// Boxed Byte
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedByte.class).notEqualTo(PrimaryKeyAsBoxedByte.FIELD_PRIMARY_KEY, Byte.valueOf((byte) -1)).findAll().first().getName());
// Boxed Short
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedShort.class).notEqualTo(PrimaryKeyAsBoxedShort.FIELD_PRIMARY_KEY, Short.valueOf((short) -1)).findAll().first().getName());
// Boxed Integer
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedInteger.class).notEqualTo(PrimaryKeyAsBoxedInteger.FIELD_PRIMARY_KEY, Integer.valueOf(-1)).findAll().first().getName());
// Boxed Long
assertEquals(SECONDARY_FIELD_STRING, realm.where(PrimaryKeyAsBoxedLong.class).notEqualTo(PrimaryKeyAsBoxedLong.FIELD_PRIMARY_KEY, Long.valueOf((long) -1)).findAll().first().getName());
}
@Test
public void beginWith_nullStringPrimaryKey() {
final long SECONDARY_FIELD_NUMBER = 49992417L;
TestHelper.populateTestRealmWithStringPrimaryKey(realm, (String) null, SECONDARY_FIELD_NUMBER, 10, -5);
assertEquals(SECONDARY_FIELD_NUMBER, realm.where(PrimaryKeyAsString.class).beginsWith(PrimaryKeyAsString.FIELD_PRIMARY_KEY, (String) null).findAll().first().getId());
}
@Test
public void contains_nullStringPrimaryKey() {
final long SECONDARY_FIELD_NUMBER = 49992417L;
TestHelper.populateTestRealmWithStringPrimaryKey(realm, (String) null, SECONDARY_FIELD_NUMBER, 10, -5);
assertEquals(SECONDARY_FIELD_NUMBER, realm.where(PrimaryKeyAsString.class).contains(PrimaryKeyAsString.FIELD_PRIMARY_KEY, (String) null).findAll().first().getId());
}
@Test
public void endsWith_nullStringPrimaryKey() {
final long SECONDARY_FIELD_NUMBER = 49992417L;
TestHelper.populateTestRealmWithStringPrimaryKey(realm, (String) null, SECONDARY_FIELD_NUMBER, 10, -5);
assertEquals(SECONDARY_FIELD_NUMBER, realm.where(PrimaryKeyAsString.class).endsWith(PrimaryKeyAsString.FIELD_PRIMARY_KEY, (String) null).findAll().first().getId());
}
@Test
public void like_nullStringPrimaryKey() {
final long SECONDARY_FIELD_NUMBER = 49992417L;
TestHelper.populateTestRealmWithStringPrimaryKey(realm, (String) null, SECONDARY_FIELD_NUMBER, 10, -5);
assertEquals(
SECONDARY_FIELD_NUMBER,
realm.where(PrimaryKeyAsString.class).like(PrimaryKeyAsString.FIELD_PRIMARY_KEY, (String) null)
.findAll().first().getId());
}
@Test
public void between_nullPrimaryKeysIsNotZero() {
// Fills up a realm with one user PrimaryKey value and 9 numeric values, starting from -5.
TestHelper.populateTestRealmWithBytePrimaryKey(realm, (Byte) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithShortPrimaryKey(realm, (Short) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithIntegerPrimaryKey(realm, (Integer) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithLongPrimaryKey(realm, (Long) null, (String) null, 10, -5);
// Boxed Byte
assertEquals(3, realm.where(PrimaryKeyAsBoxedByte.class).between(PrimaryKeyAsBoxedByte.FIELD_PRIMARY_KEY, -1, 1).count());
// Boxed Short
assertEquals(3, realm.where(PrimaryKeyAsBoxedShort.class).between(PrimaryKeyAsBoxedShort.FIELD_PRIMARY_KEY, -1, 1).count());
// Boxed Integer
assertEquals(3, realm.where(PrimaryKeyAsBoxedInteger.class).between(PrimaryKeyAsBoxedInteger.FIELD_PRIMARY_KEY, -1, 1).count());
// Boxed Long
assertEquals(3, realm.where(PrimaryKeyAsBoxedLong.class).between(PrimaryKeyAsBoxedLong.FIELD_PRIMARY_KEY, -1, 1).count());
}
@Test
public void greaterThan_nullPrimaryKeysIsNotZero() {
// Fills up a realm with one user PrimaryKey value and 9 numeric values, starting from -5.
TestHelper.populateTestRealmWithBytePrimaryKey(realm, (Byte) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithShortPrimaryKey(realm, (Short) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithIntegerPrimaryKey(realm, (Integer) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithLongPrimaryKey(realm, (Long) null, (String) null, 10, -5);
// Boxed Byte
assertEquals(4, realm.where(PrimaryKeyAsBoxedByte.class).greaterThan(PrimaryKeyAsBoxedByte.FIELD_PRIMARY_KEY, -1).count());
// Boxed Short
assertEquals(4, realm.where(PrimaryKeyAsBoxedShort.class).greaterThan(PrimaryKeyAsBoxedShort.FIELD_PRIMARY_KEY, -1).count());
// Boxed Integer
assertEquals(4, realm.where(PrimaryKeyAsBoxedInteger.class).greaterThan(PrimaryKeyAsBoxedInteger.FIELD_PRIMARY_KEY, -1).count());
// Boxed Long
assertEquals(4, realm.where(PrimaryKeyAsBoxedLong.class).greaterThan(PrimaryKeyAsBoxedLong.FIELD_PRIMARY_KEY, -1).count());
}
@Test
public void greaterThanOrEqualTo_nullPrimaryKeysIsNotZero() {
// Fills up a realm with one user PrimaryKey value and 9 numeric values, starting from -5.
TestHelper.populateTestRealmWithBytePrimaryKey(realm, (Byte) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithShortPrimaryKey(realm, (Short) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithIntegerPrimaryKey(realm, (Integer) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithLongPrimaryKey(realm, (Long) null, (String) null, 10, -5);
// Boxed Byte
assertEquals(5, realm.where(PrimaryKeyAsBoxedByte.class).greaterThanOrEqualTo(PrimaryKeyAsBoxedByte.FIELD_PRIMARY_KEY, -1).count());
// Boxed Short
assertEquals(5, realm.where(PrimaryKeyAsBoxedShort.class).greaterThanOrEqualTo(PrimaryKeyAsBoxedShort.FIELD_PRIMARY_KEY, -1).count());
// Boxed Integer
assertEquals(5, realm.where(PrimaryKeyAsBoxedInteger.class).greaterThanOrEqualTo(PrimaryKeyAsBoxedInteger.FIELD_PRIMARY_KEY, -1).count());
// Boxed Long
assertEquals(5, realm.where(PrimaryKeyAsBoxedLong.class).greaterThanOrEqualTo(PrimaryKeyAsBoxedLong.FIELD_PRIMARY_KEY, -1).count());
}
@Test
public void lessThan_nullPrimaryKeysIsNotZero() {
// Fills up a realm with one user PrimaryKey value and 9 numeric values, starting from -5.
TestHelper.populateTestRealmWithBytePrimaryKey(realm, (Byte) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithShortPrimaryKey(realm, (Short) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithIntegerPrimaryKey(realm, (Integer) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithLongPrimaryKey(realm, (Long) null, (String) null, 10, -5);
// Boxed Byte
assertEquals(6, realm.where(PrimaryKeyAsBoxedByte.class).lessThan(PrimaryKeyAsBoxedByte.FIELD_PRIMARY_KEY, 1).count());
// Boxed Short
assertEquals(6, realm.where(PrimaryKeyAsBoxedShort.class).lessThan(PrimaryKeyAsBoxedShort.FIELD_PRIMARY_KEY, 1).count());
// Boxed Integer
assertEquals(6, realm.where(PrimaryKeyAsBoxedInteger.class).lessThan(PrimaryKeyAsBoxedInteger.FIELD_PRIMARY_KEY, 1).count());
// Boxed Long
assertEquals(6, realm.where(PrimaryKeyAsBoxedLong.class).lessThan(PrimaryKeyAsBoxedLong.FIELD_PRIMARY_KEY, 1).count());
}
@Test
public void lessThanOrEqualTo_nullPrimaryKeysIsNotZero() {
// Fills up a realm with one user PrimaryKey value and 9 numeric values, starting from -5.
TestHelper.populateTestRealmWithBytePrimaryKey(realm, (Byte) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithShortPrimaryKey(realm, (Short) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithIntegerPrimaryKey(realm, (Integer) null, (String) null, 10, -5);
TestHelper.populateTestRealmWithLongPrimaryKey(realm, (Long) null, (String) null, 10, -5);
// Boxed Byte
assertEquals(7, realm.where(PrimaryKeyAsBoxedByte.class).lessThanOrEqualTo(PrimaryKeyAsBoxedByte.FIELD_PRIMARY_KEY, 1).count());
// Boxed Short
assertEquals(7, realm.where(PrimaryKeyAsBoxedShort.class).lessThanOrEqualTo(PrimaryKeyAsBoxedShort.FIELD_PRIMARY_KEY, 1).count());
// Boxed Integer
assertEquals(7, realm.where(PrimaryKeyAsBoxedInteger.class).lessThanOrEqualTo(PrimaryKeyAsBoxedInteger.FIELD_PRIMARY_KEY, 1).count());
// Boxed Long
assertEquals(7, realm.where(PrimaryKeyAsBoxedLong.class).lessThanOrEqualTo(PrimaryKeyAsBoxedLong.FIELD_PRIMARY_KEY, 1).count());
}
// Queries nullable fields with equalTo null.
@Test
public void equalTo_nullableFields() {
TestHelper.populateTestRealmForNullTests(realm);
// 1 String
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_STRING_NULL, "Horse").count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_STRING_NULL, (String) null).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_STRING_NULL, "Fish").count());
assertEquals(0, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_STRING_NULL, "Goat").count());
// 2 Bytes
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BYTES_NULL, new byte[] {0}).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BYTES_NULL, (byte[]) null).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BYTES_NULL, new byte[] {1, 2}).count());
assertEquals(0, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BYTES_NULL, new byte[] {1, 2, 3}).count());
// 3 Boolean
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BOOLEAN_NULL, true).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BOOLEAN_NULL, (Boolean) null).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BOOLEAN_NULL, false).count());
// 4 Byte
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BYTE_NULL, 1).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BYTE_NULL, (byte) 1).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BYTE_NULL, (Byte) null).count());
assertEquals(0, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_BYTE_NULL, (byte) 42).count());
// 5 Short for other long based columns, only test null
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_SHORT_NULL, 1).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_SHORT_NULL, (short) 1).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_SHORT_NULL, (Short) null).count());
assertEquals(0, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_SHORT_NULL, (short) 42).count());
// 6 Integer
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_INTEGER_NULL, 1).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_INTEGER_NULL, (Integer) null).count());
assertEquals(0, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_INTEGER_NULL, 42).count());
// 7 Long
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_LONG_NULL, 1).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_LONG_NULL, (long) 1).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_LONG_NULL, (Long) null).count());
assertEquals(0, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_LONG_NULL, (long) 42).count());
// 8 Float
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_FLOAT_NULL, 1F).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_FLOAT_NULL, (Float) null).count());
assertEquals(0, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_FLOAT_NULL, 42F).count());
// 9 Double
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_DOUBLE_NULL, 1D).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_DOUBLE_NULL, (Double) null).count());
assertEquals(0, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_DOUBLE_NULL, 42D).count());
// 10 Date
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_DATE_NULL, new Date(0)).count());
assertEquals(1, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_DATE_NULL, (Date) null).count());
assertEquals(0, realm.where(NullTypes.class).equalTo(NullTypes.FIELD_DATE_NULL, new Date(424242)).count());
// 11 Object skipped, doesn't support equalTo query
}
// Queries nullable field for null.
@Test
public void isNull_nullableFields() {
TestHelper.populateTestRealmForNullTests(realm);
// 1 String
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_STRING_NULL).count());
// 2 Bytes
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_BYTES_NULL).count());
// 3 Boolean
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_BOOLEAN_NULL).count());
// 4 Byte
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_BYTE_NULL).count());
// 5 Short
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_SHORT_NULL).count());
// 6 Integer
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_INTEGER_NULL).count());
// 7 Long
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_LONG_NULL).count());
// 8 Float
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_FLOAT_NULL).count());
// 9 Double
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_DOUBLE_NULL).count());
// 10 Date
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_DATE_NULL).count());
// 11 Object
assertEquals(1, realm.where(NullTypes.class).isNull(NullTypes.FIELD_OBJECT_NULL).count());
}
// Queries nullable field for not null.
@Test
public void notEqualTo_nullableFields() {
TestHelper.populateTestRealmForNullTests(realm);
// 1 String
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_STRING_NULL, "Horse").count());
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_STRING_NULL, (String) null).count());
// 2 Bytes
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_BYTES_NULL, new byte[] {1, 2}).count());
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_BYTES_NULL, (byte[]) null).count());
// 3 Boolean
assertEquals(1, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_BOOLEAN_NULL, false).count());
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_BOOLEAN_NULL, (Boolean) null).count());
// 4 Byte
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_BYTE_NULL, (byte) 1).count());
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_BYTE_NULL, (Byte) null).count());
// 5 Short
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_SHORT_NULL, (short) 1).count());
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_SHORT_NULL, (Byte) null).count());
// 6 Integer
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_INTEGER_NULL, 1).count());
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_INTEGER_NULL, (Integer) null).count());
// 7 Long
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_LONG_NULL, 1).count());
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_LONG_NULL, (Integer) null).count());
// 8 Float
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_FLOAT_NULL, 1F).count());
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_FLOAT_NULL, (Float) null).count());
// 9 Double
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_DOUBLE_NULL, 1D).count());
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_DOUBLE_NULL, (Double) null).count());
// 10 Date
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_DATE_NULL, new Date(0)).count());
assertEquals(2, realm.where(NullTypes.class).notEqualTo(NullTypes.FIELD_DATE_NULL, (Date) null).count());
// 11 Object skipped, doesn't support notEqualTo query
}
// Queries nullable field for not null.
@Test
public void isNotNull_nullableFields() {
TestHelper.populateTestRealmForNullTests(realm);
// 1 String
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_STRING_NULL).count());
// 2 Bytes
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_BYTES_NULL).count());
// 3 Boolean
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_BOOLEAN_NULL).count());
// 4 Byte
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_BYTE_NULL).count());
// 5 Short
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_SHORT_NULL).count());
// 6 Integer
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_INTEGER_NULL).count());
// 7 Long
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_LONG_NULL).count());
// 8 Float
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_FLOAT_NULL).count());
// 9 Double
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_DOUBLE_NULL).count());
// 10 Date
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_DATE_NULL).count());
// 11 Object
assertEquals(2, realm.where(NullTypes.class).isNotNull(NullTypes.FIELD_OBJECT_NULL).count());
}
// Queries nullable field with beginsWith - all strings begin with null.
@Test
public void beginWith_nullForNullableStrings() {
TestHelper.populateTestRealmForNullTests(realm);
assertEquals("Fish", realm.where(NullTypes.class).beginsWith(NullTypes.FIELD_STRING_NULL,
(String) null).findFirst().getFieldStringNotNull());
}
// Queries nullable field with contains - all strings contain null.
@Test
public void contains_nullForNullableStrings() {
TestHelper.populateTestRealmForNullTests(realm);
assertEquals("Fish", realm.where(NullTypes.class).contains(NullTypes.FIELD_STRING_NULL,
(String) null).findFirst().getFieldStringNotNull());
}
// Queries nullable field with endsWith - all strings end with null.
@Test
public void endsWith_nullForNullableStrings() {
TestHelper.populateTestRealmForNullTests(realm);
assertEquals("Fish", realm.where(NullTypes.class).endsWith(NullTypes.FIELD_STRING_NULL,
(String) null).findFirst().getFieldStringNotNull());
}
// Queries nullable field with like - nulls do not match either '?' or '*'.
@Test
public void like_nullForNullableStrings() {
TestHelper.populateTestRealmForNullTests(realm);
RealmResults<NullTypes> resultList = realm.where(NullTypes.class).like(NullTypes.FIELD_STRING_NULL, "*")
.findAll();
assertEquals(2, resultList.size());
resultList = realm.where(NullTypes.class).like(NullTypes.FIELD_STRING_NULL, "?").findAll();
assertEquals(0, resultList.size());
}
// Queries with between and table has null values in row.
@Test
public void between_nullValuesInRow() {
TestHelper.populateTestRealmForNullTests(realm);
// 6 Integer
assertEquals(1, realm.where(NullTypes.class).between(NullTypes.FIELD_INTEGER_NULL, 2, 4).count());
// 7 Long
assertEquals(1, realm.where(NullTypes.class).between(NullTypes.FIELD_LONG_NULL, 2L, 4L).count());
// 8 Float
assertEquals(1, realm.where(NullTypes.class).between(NullTypes.FIELD_FLOAT_NULL, 2F, 4F).count());
// 9 Double
assertEquals(1, realm.where(NullTypes.class).between(NullTypes.FIELD_DOUBLE_NULL, 2D, 4D).count());
// 10 Date
assertEquals(1, realm.where(NullTypes.class).between(NullTypes.FIELD_DATE_NULL, new Date(10000),
new Date(20000)).count());
}
// Queries with greaterThan and table has null values in row.
@Test
public void greaterThan_nullValuesInRow() {
TestHelper.populateTestRealmForNullTests(realm);
// 6 Integer
assertEquals(1, realm.where(NullTypes.class).greaterThan(NullTypes.FIELD_INTEGER_NULL, 2).count());
// 7 Long
assertEquals(1, realm.where(NullTypes.class).greaterThan(NullTypes.FIELD_LONG_NULL, 2L).count());
// 8 Float
assertEquals(1, realm.where(NullTypes.class).greaterThan(NullTypes.FIELD_FLOAT_NULL, 2F).count());
// 9 Double
assertEquals(1, realm.where(NullTypes.class).greaterThan(NullTypes.FIELD_DOUBLE_NULL, 2D).count());
// 10 Date
assertEquals(1, realm.where(NullTypes.class).greaterThan(NullTypes.FIELD_DATE_NULL,
new Date(5000)).count());
}
// Queries with greaterThanOrEqualTo and table has null values in row.
@Test
public void greaterThanOrEqualTo_nullValuesInRow() {
TestHelper.populateTestRealmForNullTests(realm);
// 6 Integer
assertEquals(1, realm.where(NullTypes.class).greaterThanOrEqualTo(NullTypes.FIELD_INTEGER_NULL, 3).count());
// 7 Long
assertEquals(1, realm.where(NullTypes.class).greaterThanOrEqualTo(NullTypes.FIELD_LONG_NULL, 3L).count());
// 8 Float
assertEquals(1, realm.where(NullTypes.class).greaterThanOrEqualTo(NullTypes.FIELD_FLOAT_NULL, 3F).count());
// 9 Double
assertEquals(1, realm.where(NullTypes.class).greaterThanOrEqualTo(NullTypes.FIELD_DOUBLE_NULL, 3D).count());
// 10 Date
assertEquals(1, realm.where(NullTypes.class).greaterThanOrEqualTo(NullTypes.FIELD_DATE_NULL,
new Date(10000)).count());
}
// Queries with lessThan and table has null values in row.
@Test
public void lessThan_nullValuesInRow() {
TestHelper.populateTestRealmForNullTests(realm);
// 6 Integer
assertEquals(1, realm.where(NullTypes.class).lessThan(NullTypes.FIELD_INTEGER_NULL, 2).count());
// 7 Long
assertEquals(1, realm.where(NullTypes.class).lessThan(NullTypes.FIELD_LONG_NULL, 2L).count());
// 8 Float
assertEquals(1, realm.where(NullTypes.class).lessThan(NullTypes.FIELD_FLOAT_NULL, 2F).count());
// 9 Double
assertEquals(1, realm.where(NullTypes.class).lessThan(NullTypes.FIELD_DOUBLE_NULL, 2D).count());
// 10 Date
assertEquals(1, realm.where(NullTypes.class).lessThan(NullTypes.FIELD_DATE_NULL,
new Date(5000)).count());
}
// Queries with lessThanOrEqualTo and table has null values in row.
@Test
public void lessThanOrEqual_nullValuesInRow() {
TestHelper.populateTestRealmForNullTests(realm);
// 6 Integer
assertEquals(1, realm.where(NullTypes.class).lessThanOrEqualTo(NullTypes.FIELD_INTEGER_NULL, 1).count());
// 7 Long
assertEquals(1, realm.where(NullTypes.class).lessThanOrEqualTo(NullTypes.FIELD_LONG_NULL, 1L).count());
// 8 Float
assertEquals(1, realm.where(NullTypes.class).lessThanOrEqualTo(NullTypes.FIELD_FLOAT_NULL, 1F).count());
// 9 Double
assertEquals(1, realm.where(NullTypes.class).lessThanOrEqualTo(NullTypes.FIELD_DOUBLE_NULL, 1D).count());
// 10 Date
assertEquals(1, realm.where(NullTypes.class).lessThanOrEqualTo(NullTypes.FIELD_DATE_NULL,
new Date(9999)).count());
}
// If the RealmQuery is built on a TableView, it should not crash when used after GC.
// See issue #1161 for more details.
@Test
public void buildQueryFromResultsGC() {
// According to the testing, setting this to 10 can almost certainly trigger the GC.
// Uses 30 here can ensure GC happen. (Tested with 4.3 1G Ram and 5.0 3G Ram)
final int count = 30;
RealmResults<CatOwner> results = realm.where(CatOwner.class).findAll();
for (int i = 1; i <= count; i++) {
@SuppressWarnings({"unused"})
byte garbage[] = TestHelper.allocGarbage(0);
results = results.where().findAll();
System.gc(); // If a native resource has a reference count = 0, doing GC here might lead to a crash.
}
}
private static byte[][] binaries = {{1, 2, 3}, {1, 2}, {1, 2, 3}, {2, 3}, {2}, {4, 5, 6}};
private void createBinaryOnlyDataSet() {
realm.beginTransaction();
for (int i = 0; i < binaries.length; i++) {
AllJavaTypes binaryOnly = new AllJavaTypes((long) i);
binaryOnly.setFieldBinary(binaries[i]);
realm.copyToRealm(binaryOnly);
}
realm.commitTransaction();
}
@Test
public void equalTo_binary() {
createBinaryOnlyDataSet();
RealmResults<AllJavaTypes> resultList;
resultList = realm.where(AllJavaTypes.class).equalTo(AllJavaTypes.FIELD_BINARY, binaries[0]).findAll();
assertEquals(2, resultList.size());
resultList = realm.where(AllJavaTypes.class).equalTo(AllJavaTypes.FIELD_BINARY, binaries[1]).findAll();
assertEquals(1, resultList.size());
resultList = realm.where(AllJavaTypes.class).equalTo(AllJavaTypes.FIELD_BINARY, new byte[] {1}).findAll();
assertEquals(0, resultList.size());
}
@Test
public void equalTo_binary_multiFailures() {
createBinaryOnlyDataSet();
// Non-binary field.
try {
RealmResults<AllJavaTypes> resultList = realm.where(AllJavaTypes.class)
.equalTo(AllJavaTypes.FIELD_INT, binaries[0]).findAll();
fail("Should throw exception.");
} catch (IllegalArgumentException ignored) {
}
// Non-existent field.
try {
RealmResults<AllJavaTypes> resultList = realm.where(AllJavaTypes.class)
.equalTo("NotAField", binaries[0]).findAll();
fail("Should throw exception.");
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void notEqualTo_binary() {
createBinaryOnlyDataSet();
RealmResults<AllJavaTypes> resultList;
resultList = realm.where(AllJavaTypes.class).notEqualTo(AllJavaTypes.FIELD_BINARY, binaries[0]).findAll();
assertEquals(4, resultList.size());
resultList = realm.where(AllJavaTypes.class).notEqualTo(AllJavaTypes.FIELD_BINARY, binaries[1]).findAll();
assertEquals(5, resultList.size());
resultList = realm.where(AllJavaTypes.class).notEqualTo(AllJavaTypes.FIELD_BINARY, new byte[] {1}).findAll();
assertEquals(6, resultList.size());
}
@Test
public void notEqualTo_binary_multiFailures() {
createBinaryOnlyDataSet();
// Non-binary field.
try {
RealmResults<AllJavaTypes> resultList = realm.where(AllJavaTypes.class)
.notEqualTo(AllJavaTypes.FIELD_INT, binaries[0]).findAll();
fail("Should throw exception.");
} catch (IllegalArgumentException ignored) {
}
// Non-existent field.
try {
RealmResults<AllJavaTypes> resultList = realm.where(AllJavaTypes.class)
.notEqualTo("NotAField", binaries[0]).findAll();
fail("Should throw exception.");
} catch (IllegalArgumentException ignored) {
}
}
// Tests min on empty columns.
@Test
public void min_emptyColumns() {
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertNull(query.min(NullTypes.FIELD_INTEGER_NOT_NULL));
assertNull(query.min(NullTypes.FIELD_FLOAT_NOT_NULL));
assertNull(query.min(NullTypes.FIELD_DOUBLE_NOT_NULL));
assertNull(query.minimumDate(NullTypes.FIELD_DATE_NOT_NULL));
}
// Tests min on columns with all null rows.
@Test
public void min_allNullColumns() {
TestHelper.populateAllNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertNull(query.min(NullTypes.FIELD_INTEGER_NULL));
assertNull(query.min(NullTypes.FIELD_FLOAT_NULL));
assertNull(query.min(NullTypes.FIELD_DOUBLE_NULL));
assertNull(query.minimumDate(NullTypes.FIELD_DATE_NULL));
}
// Tests min on columns with all non-null rows.
@Test
public void min_allNonNullRows() {
TestHelper.populateAllNonNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(-1, query.min(NullTypes.FIELD_INTEGER_NULL).intValue());
assertEquals(-2f, query.min(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
assertEquals(-3d, query.min(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
assertEquals(-2000, query.minimumDate(NullTypes.FIELD_DATE_NULL).getTime());
}
// Tests min on columns with partial null rows.
@Test
public void min_partialNullRows() {
TestHelper.populatePartialNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(3, query.min(NullTypes.FIELD_INTEGER_NULL).intValue());
assertEquals(4f, query.min(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
assertEquals(5d, query.min(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
}
// Test max on empty columns
@Test
public void max_emptyColumns() {
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertNull(query.max(NullTypes.FIELD_INTEGER_NOT_NULL));
assertNull(query.max(NullTypes.FIELD_FLOAT_NOT_NULL));
assertNull(query.max(NullTypes.FIELD_DOUBLE_NOT_NULL));
assertNull(query.maximumDate(NullTypes.FIELD_DATE_NOT_NULL));
}
// Tests max on columns with all null rows.
@Test
public void max_allNullColumns() {
TestHelper.populateAllNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertNull(query.max(NullTypes.FIELD_INTEGER_NULL));
assertNull(query.max(NullTypes.FIELD_FLOAT_NULL));
assertNull(query.max(NullTypes.FIELD_DOUBLE_NULL));
assertNull(query.maximumDate(NullTypes.FIELD_DATE_NULL));
}
// Tests max on columns with all non-null rows.
@Test
public void max_allNonNullRows() {
TestHelper.populateAllNonNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(4, query.max(NullTypes.FIELD_INTEGER_NULL).intValue());
assertEquals(5f, query.max(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
assertEquals(6d, query.max(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
assertEquals(12345, query.maximumDate(NullTypes.FIELD_DATE_NULL).getTime());
}
// Tests max on columns with partial null rows.
@Test
public void max_partialNullRows() {
TestHelper.populatePartialNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(4, query.max(NullTypes.FIELD_INTEGER_NULL).intValue());
assertEquals(5f, query.max(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
assertEquals(6d, query.max(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
assertEquals(12345, query.maximumDate(NullTypes.FIELD_DATE_NULL).getTime());
}
// Tests average on empty columns.
@Test
public void average_emptyColumns() {
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(0d, query.average(NullTypes.FIELD_INTEGER_NULL), 0d);
assertEquals(0d, query.average(NullTypes.FIELD_FLOAT_NULL), 0d);
assertEquals(0d, query.average(NullTypes.FIELD_DOUBLE_NULL), 0d);
}
// Tests average on columns with all null rows.
@Test
public void average_allNullColumns() {
TestHelper.populateAllNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(0d, query.average(NullTypes.FIELD_INTEGER_NULL), 0d);
assertEquals(0d, query.average(NullTypes.FIELD_FLOAT_NULL), 0d);
assertEquals(0d, query.average(NullTypes.FIELD_DOUBLE_NULL), 0d);
}
// Tests average on columns with all non-null rows.
@Test
public void average_allNonNullRows() {
TestHelper.populateAllNonNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(2.0, query.average(NullTypes.FIELD_INTEGER_NULL), 0d);
assertEquals(7.0 / 3, query.average(NullTypes.FIELD_FLOAT_NULL), 0.001d);
assertEquals(8.0 / 3, query.average(NullTypes.FIELD_DOUBLE_NULL), 0.001d);
}
// Tests average on columns with partial null rows.
@Test
public void average_partialNullRows() {
TestHelper.populatePartialNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(3.5, query.average(NullTypes.FIELD_INTEGER_NULL), 0d);
assertEquals(4.5, query.average(NullTypes.FIELD_FLOAT_NULL), 0d);
assertEquals(5.5, query.average(NullTypes.FIELD_DOUBLE_NULL), 0d);
}
// Tests sum on empty columns.
@Test
public void sum_emptyColumns() {
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(0, query.sum(NullTypes.FIELD_INTEGER_NULL).intValue());
assertEquals(0f, query.sum(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
assertEquals(0d, query.sum(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
}
// Tests sum on columns with all null rows.
@Test
public void sum_allNullColumns() {
TestHelper.populateAllNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(0, query.sum(NullTypes.FIELD_INTEGER_NULL).intValue());
assertEquals(0f, query.sum(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
assertEquals(0d, query.sum(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
}
// Tests sum on columns with all non-null rows.
@Test
public void sum_allNonNullRows() {
TestHelper.populateAllNonNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(6, query.sum(NullTypes.FIELD_INTEGER_NULL).intValue());
assertEquals(7f, query.sum(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
assertEquals(8d, query.sum(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
}
// Tests sum on columns with partial null rows.
@Test
public void sum_partialNullRows() {
TestHelper.populatePartialNullRowsForNumericTesting(realm);
RealmQuery<NullTypes> query = realm.where(NullTypes.class);
assertEquals(7, query.sum(NullTypes.FIELD_INTEGER_NULL).intValue());
assertEquals(9f, query.sum(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
assertEquals(11d, query.sum(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
}
@Test
public void count() {
populateTestRealm(realm, TEST_DATA_SIZE);
assertEquals(TEST_DATA_SIZE, realm.where(AllTypes.class).count());
}
// Tests isNull on link's nullable field.
@Test
public void isNull_linkField() {
TestHelper.populateTestRealmForNullTests(realm);
// For the link with null value, query isNull on its fields should return true.
// 1 String
assertEquals(2, realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_STRING_NULL).count());
// 2 Bytes
assertEquals(2, realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BYTES_NULL).count());
// 3 Boolean
assertEquals(2, realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BOOLEAN_NULL).count());
// 4 Byte
assertEquals(2, realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BYTE_NULL).count());
// 5 Short
assertEquals(2, realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_SHORT_NULL).count());
// 6 Integer
assertEquals(2, realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_INTEGER_NULL).count());
// 7 Long
assertEquals(2, realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_LONG_NULL).count());
// 8 Float
assertEquals(2, realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_FLOAT_NULL).count());
// 9 Double
assertEquals(2, realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_DOUBLE_NULL).count());
// 10 Date
assertEquals(2, realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_DATE_NULL).count());
// 11 Object
// FIXME: Currently, Realm Core does not support isNull() query for nested link field.
//assertEquals(1, realm.where(NullTypes.class).isNull(
// NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_OBJECT_NULL).count());
try {
realm.where(NullTypes.class).isNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_OBJECT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
}
// Tests isNull on link's not-nullable field. Should throw.
@Test
public void isNull_linkFieldNotNullable() {
TestHelper.populateTestRealmForNullTests(realm);
// 1 String
try {
realm.where(NullTypes.class)
.isNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_STRING_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 2 Bytes
try {
realm.where(NullTypes.class)
.isNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BYTES_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 3 Boolean
try {
realm.where(NullTypes.class)
.isNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BOOLEAN_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 4 Byte
try {
realm.where(NullTypes.class)
.isNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BYTE_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 5 Short
try {
realm.where(NullTypes.class)
.isNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_SHORT_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 6 Integer
try {
realm.where(NullTypes.class)
.isNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_INTEGER_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 7 Long
try {
realm.where(NullTypes.class)
.isNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_LONG_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 8 Float
try {
realm.where(NullTypes.class)
.isNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_FLOAT_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 9 Double
try {
realm.where(NullTypes.class)
.isNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_DOUBLE_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 10 Date
try {
realm.where(NullTypes.class)
.isNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_DATE_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 11 Object skipped, doesn't support equalTo query
}
// Tests isNotNull on link's nullable field.
@Test
public void isNotNull_linkField() {
TestHelper.populateTestRealmForNullTests(realm);
// 1 String
assertEquals(1, realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_STRING_NULL).count());
// 2 Bytes
assertEquals(1, realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BYTES_NULL).count());
// 3 Boolean
assertEquals(1, realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BOOLEAN_NULL).count());
// 4 Byte
assertEquals(1, realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BYTE_NULL).count());
// 5 Short
assertEquals(1, realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_SHORT_NULL).count());
// 6 Integer
assertEquals(1, realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_INTEGER_NULL).count());
// 7 Long
assertEquals(1, realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_LONG_NULL).count());
// 8 Float
assertEquals(1, realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_FLOAT_NULL).count());
// 9 Double
assertEquals(1, realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_DOUBLE_NULL).count());
// 10 Date
assertEquals(1, realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_DATE_NULL).count());
// 11 Object
//assertEquals(1, realm.where(NullTypes.class).isNotNull(
// NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_OBJECT_NULL).count());
// FIXME: Currently, Realm Core does not support isNotNull() query for nested link field.
try {
realm.where(NullTypes.class).isNotNull(
NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_OBJECT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
}
// Tests isNotNull on link's not-nullable field. Should throw.
@Test
public void isNotNull_linkFieldNotNullable() {
TestHelper.populateTestRealmForNullTests(realm);
// 1 String
try {
realm.where(NullTypes.class)
.isNotNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_STRING_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 2 Bytes
try {
realm.where(NullTypes.class)
.isNotNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BYTES_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 3 Boolean
try {
realm.where(NullTypes.class)
.isNotNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BOOLEAN_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 4 Byte
try {
realm.where(NullTypes.class)
.isNotNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_BYTE_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 5 Short
try {
realm.where(NullTypes.class)
.isNotNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_SHORT_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 6 Integer
try {
realm.where(NullTypes.class)
.isNotNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_INTEGER_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 7 Long
try {
realm.where(NullTypes.class)
.isNotNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_LONG_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 8 Float
try {
realm.where(NullTypes.class)
.isNotNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_FLOAT_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 9 Double
try {
realm.where(NullTypes.class)
.isNotNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_DOUBLE_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 10 Date
try {
realm.where(NullTypes.class)
.isNotNull(NullTypes.FIELD_OBJECT_NULL + "." + NullTypes.FIELD_DATE_NOT_NULL);
fail();
} catch (IllegalArgumentException ignored) {
}
// 11 Object skipped, RealmObject is always nullable.
}
// Calling isNull on fields with the RealmList type will trigger an exception.
@Test
public void isNull_listFieldThrows() {
try {
realm.where(Owner.class).isNull("dogs");
fail();
} catch (IllegalArgumentException expected) {
assertEquals("Illegal Argument: RealmList(dogs) is not nullable.", expected.getMessage());
}
try {
realm.where(Cat.class).isNull("owner.dogs");
fail();
} catch (IllegalArgumentException expected) {
assertEquals("Illegal Argument: RealmList(dogs) is not nullable.", expected.getMessage());
}
}
// Calling isNotNull on fields with the RealmList type will trigger an exception.
@Test
public void isNotNull_listFieldThrows() {
try {
realm.where(Owner.class).isNotNull("dogs");
fail();
} catch (IllegalArgumentException expected) {
assertEquals("Illegal Argument: RealmList(dogs) is not nullable.", expected.getMessage());
}
try {
realm.where(Cat.class).isNotNull("owner.dogs");
fail();
} catch (IllegalArgumentException expected) {
assertEquals("Illegal Argument: RealmList(dogs) is not nullable.", expected.getMessage());
}
}
@Ignore("Disabled because it is time consuming")
@Test
public void largeRealmMultipleThreads() throws InterruptedException {
final int nObjects = 500000;
final int nThreads = 3;
final CountDownLatch latch = new CountDownLatch(nThreads);
realm.beginTransaction();
realm.delete(StringOnly.class);
for (int i = 0; i < nObjects; i++) {
StringOnly stringOnly = realm.createObject(StringOnly.class);
stringOnly.setChars(String.format("string %d", i));
}
realm.commitTransaction();
for (int i = 0; i < nThreads; i++) {
Thread thread = new Thread(
new Runnable() {
@Override
@SuppressWarnings("ElementsCountedInLoop")
public void run() {
RealmConfiguration realmConfig = configFactory.createConfiguration();
Realm realm = Realm.getInstance(realmConfig);
RealmResults<StringOnly> realmResults = realm.where(StringOnly.class).findAll();
int n = 0;
for (StringOnly ignored : realmResults) {
n = n + 1;
}
assertEquals(nObjects, n);
realm.close();
latch.countDown();
}
}
);
thread.start();
}
TestHelper.awaitOrFail(latch);
}
@Test
public void isValid_tableQuery() {
final RealmQuery<AllTypes> query = realm.where(AllTypes.class);
assertTrue(query.isValid());
populateTestRealm(realm, 1);
// Still valid if result changed.
assertTrue(query.isValid());
realm.close();
assertFalse(query.isValid());
}
@Test
public void isValid_tableViewQuery() {
populateTestRealm();
final RealmQuery<AllTypes> query = realm.where(AllTypes.class).greaterThan(AllTypes.FIELD_FLOAT, 5f)
.findAll().where();
assertTrue(query.isValid());
populateTestRealm(realm, 1);
// Still valid if table view changed.
assertTrue(query.isValid());
realm.close();
assertFalse(query.isValid());
}
// Test for https://github.com/realm/realm-java/issues/1905
@Test
public void resultOfTableViewQuery() {
populateTestRealm();
final RealmResults<AllTypes> results = realm.where(AllTypes.class).equalTo(AllTypes.FIELD_LONG, 3L).findAll();
assertEquals(1, results.size());
assertEquals("test data 3", results.first().getColumnString());
final RealmQuery<AllTypes> tableViewQuery = results.where();
assertEquals("test data 3", tableViewQuery.findAll().first().getColumnString());
assertEquals("test data 3", tableViewQuery.findFirst().getColumnString());
}
@Test
public void isValid_linkViewQuery() {
populateTestRealm(realm, 1);
final RealmList<Dog> list = realm.where(AllTypes.class).findFirst().getColumnRealmList();
final RealmQuery<Dog> query = list.where();
final long listLength = query.count();
assertTrue(query.isValid());
realm.beginTransaction();
final Dog dog = realm.createObject(Dog.class);
dog.setName("Dog");
list.add(dog);
realm.commitTransaction();
// Still valid if base view changed.
assertEquals(listLength + 1, query.count());
assertTrue(query.isValid());
realm.close();
assertFalse(query.isValid());
}
@Test
public void isValid_removedParent() {
populateTestRealm(realm, 1);
final AllTypes obj = realm.where(AllTypes.class).findFirst();
final RealmQuery<Dog> query = obj.getColumnRealmList().where();
assertTrue(query.isValid());
realm.beginTransaction();
obj.deleteFromRealm();
realm.commitTransaction();
// Invalid if parent has been removed.
assertFalse(query.isValid());
}
@Test
public void isEmpty() {
createIsEmptyDataSet(realm);
for (RealmFieldType type : SUPPORTED_IS_EMPTY_TYPES) {
switch (type) {
case STRING:
assertEquals(1, realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_STRING).count());
break;
case BINARY:
assertEquals(1, realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_BINARY).count());
break;
case LIST:
assertEquals(1, realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_LIST).count());
break;
default:
fail("Unknown type: " + type);
}
}
}
@Test
public void isEmpty_acrossLink() {
createIsEmptyDataSet(realm);
for (RealmFieldType type : SUPPORTED_IS_EMPTY_TYPES) {
switch (type) {
case STRING:
assertEquals(1, realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_OBJECT + "." + AllJavaTypes.FIELD_STRING).count());
break;
case BINARY:
assertEquals(1, realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_OBJECT + "." + AllJavaTypes.FIELD_BINARY).count());
break;
case LIST:
assertEquals(1, realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_OBJECT + "." + AllJavaTypes.FIELD_LIST).count());
break;
default:
fail("Unknown type: " + type);
}
}
}
@Test
public void isEmpty_illegalFieldTypeThrows() {
for (RealmFieldType type : NOT_SUPPORTED_IS_EMPTY_TYPES) {
try {
switch (type) {
case INTEGER:
realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_LONG).findAll();
break;
case FLOAT:
realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_FLOAT).findAll();
break;
case DOUBLE:
realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_DOUBLE).findAll();
break;
case BOOLEAN:
realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_BOOLEAN).findAll();
break;
case OBJECT:
realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_OBJECT).findAll();
break;
case DATE:
realm.where(AllJavaTypes.class).isEmpty(AllJavaTypes.FIELD_DATE).findAll();
break;
default:
fail("Unknown type: " + type);
}
fail(type + " should throw an exception");
} catch (IllegalArgumentException ignored) {
}
}
}
@Test
public void isEmpty_invalidFieldNameThrows() {
String[] fieldNames = new String[] {null, "", "foo", AllJavaTypes.FIELD_OBJECT + ".foo"};
for (String fieldName : fieldNames) {
try {
realm.where(AllJavaTypes.class).isEmpty(fieldName).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
}
@Test
public void isNotEmpty() {
createIsNotEmptyDataSet(realm);
for (RealmFieldType type : SUPPORTED_IS_NOT_EMPTY_TYPES) {
switch (type) {
case STRING:
assertEquals(1, realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_STRING).count());
break;
case BINARY:
assertEquals(1, realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_BINARY).count());
break;
case LIST:
assertEquals(1, realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_LIST).count());
break;
default:
fail("Unknown type: " + type);
}
}
}
@Test
public void isNotEmpty_acrossLink() {
createIsNotEmptyDataSet(realm);
for (RealmFieldType type : SUPPORTED_IS_NOT_EMPTY_TYPES) {
switch (type) {
case STRING:
assertEquals(1, realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_OBJECT + "." + AllJavaTypes.FIELD_STRING).count());
break;
case BINARY:
assertEquals(1, realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_OBJECT + "." + AllJavaTypes.FIELD_BINARY).count());
break;
case LIST:
assertEquals(1, realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_OBJECT + "." + AllJavaTypes.FIELD_LIST).count());
break;
default:
fail("Unknown type: " + type);
}
}
}
@Test
public void isNotEmpty_illegalFieldTypeThrows() {
for (RealmFieldType type : NOT_SUPPORTED_IS_NOT_EMPTY_TYPES) {
try {
switch (type) {
case INTEGER:
realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_LONG).findAll();
break;
case FLOAT:
realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_FLOAT).findAll();
break;
case DOUBLE:
realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_DOUBLE).findAll();
break;
case BOOLEAN:
realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_BOOLEAN).findAll();
break;
case OBJECT:
realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_OBJECT).findAll();
break;
case DATE:
realm.where(AllJavaTypes.class).isNotEmpty(AllJavaTypes.FIELD_DATE).findAll();
break;
default:
fail("Unknown type: " + type);
}
fail(type + " should throw an exception");
} catch (IllegalArgumentException ignored) {
}
}
}
@Test
public void isNotEmpty_invalidFieldNameThrows() {
String[] fieldNames = new String[] {null, "", "foo", AllJavaTypes.FIELD_OBJECT + ".foo"};
for (String fieldName : fieldNames) {
try {
realm.where(AllJavaTypes.class).isNotEmpty(fieldName).findAll();
fail();
} catch (IllegalArgumentException ignored) {
}
}
}
// Tests that deep queries work on a lot of data.
@Test
public void deepLinkListQuery() {
realm.executeTransaction(new Realm.Transaction() {
@Override
public void execute(Realm realm) {
// Crashes with i == 1000, 500, 100, 89, 85, 84.
// Doesn't crash for i == 10, 50, 75, 82, 83.
for (int i = 0; i < 84; i++) {
AllJavaTypes obj = realm.createObject(AllJavaTypes.class, i + 1);
obj.setFieldBoolean(i % 2 == 0);
obj.setFieldObject(obj);
RealmResults<AllJavaTypes> items = realm.where(AllJavaTypes.class).findAll();
RealmList<AllJavaTypes> fieldList = obj.getFieldList();
for (int j = 0; j < items.size(); j++) {
fieldList.add(items.get(j));
}
}
}
});
for (int i = 0; i < 4; i++) {
realm.where(AllJavaTypes.class).equalTo(
AllJavaTypes.FIELD_LIST + "." + AllJavaTypes.FIELD_OBJECT + "." + AllJavaTypes.FIELD_BOOLEAN, true)
.findAll();
}
}
@Test
public void findAllSorted_onSubObjectField() {
populateTestRealm(realm, TEST_DATA_SIZE);
RealmResults<AllTypes> results = realm.where(AllTypes.class)
.findAllSorted(AllTypes.FIELD_REALMOBJECT + "." + Dog.FIELD_AGE);
assertEquals(0, results.get(0).getColumnRealmObject().getAge());
assertEquals(TEST_DATA_SIZE - 1, results.get(TEST_DATA_SIZE - 1).getColumnRealmObject().getAge());
}
@Test
@RunTestInLooperThread
public void findAllSortedAsync_onSubObjectField() {
Realm realm = looperThread.getRealm();
populateTestRealm(realm, TEST_DATA_SIZE);
RealmResults<AllTypes> results = realm.where(AllTypes.class)
.findAllSortedAsync(AllTypes.FIELD_REALMOBJECT + "." + Dog.FIELD_AGE);
looperThread.keepStrongReference(results);
results.addChangeListener(new RealmChangeListener<RealmResults<AllTypes>>() {
@Override
public void onChange(RealmResults<AllTypes> results) {
assertEquals(0, results.get(0).getColumnRealmObject().getAge());
assertEquals(TEST_DATA_SIZE - 1, results.get(TEST_DATA_SIZE - 1).getColumnRealmObject().getAge());
looperThread.testComplete();
}
});
}
@Test
public void findAllSorted_listOnSubObjectField() {
String[] fieldNames = new String[2];
fieldNames[0] = AllTypes.FIELD_REALMOBJECT + "." + Dog.FIELD_AGE;
fieldNames[1] = AllTypes.FIELD_REALMOBJECT + "." + Dog.FIELD_AGE;
Sort[] sorts = new Sort[2];
sorts[0] = Sort.ASCENDING;
sorts[1] = Sort.ASCENDING;
populateTestRealm(realm, TEST_DATA_SIZE);
RealmResults<AllTypes> results = realm.where(AllTypes.class)
.findAllSorted(fieldNames, sorts);
assertEquals(0, results.get(0).getColumnRealmObject().getAge());
assertEquals(TEST_DATA_SIZE - 1, results.get(TEST_DATA_SIZE - 1).getColumnRealmObject().getAge());
}
@Test
@RunTestInLooperThread
public void findAllSortedAsync_listOnSubObjectField() {
Realm realm = looperThread.getRealm();
String[] fieldNames = new String[2];
fieldNames[0] = AllTypes.FIELD_REALMOBJECT + "." + Dog.FIELD_AGE;
fieldNames[1] = AllTypes.FIELD_REALMOBJECT + "." + Dog.FIELD_AGE;
Sort[] sorts = new Sort[2];
sorts[0] = Sort.ASCENDING;
sorts[1] = Sort.ASCENDING;
populateTestRealm(realm, TEST_DATA_SIZE);
RealmResults<AllTypes> results = realm.where(AllTypes.class)
.findAllSortedAsync(fieldNames, sorts);
looperThread.keepStrongReference(results);
results.addChangeListener(new RealmChangeListener<RealmResults<AllTypes>>() {
@Override
public void onChange(RealmResults<AllTypes> results) {
assertEquals(0, results.get(0).getColumnRealmObject().getAge());
assertEquals(TEST_DATA_SIZE - 1, results.get(TEST_DATA_SIZE - 1).getColumnRealmObject().getAge());
looperThread.testComplete();
}
});
}
// RealmQuery.distinct(): requires indexing, and type = boolean, integer, date, string.
private void populateForDistinct(Realm realm, long numberOfBlocks, long numberOfObjects, boolean withNull) {
realm.beginTransaction();
for (int i = 0; i < numberOfObjects * numberOfBlocks; i++) {
for (int j = 0; j < numberOfBlocks; j++) {
AnnotationIndexTypes obj = realm.createObject(AnnotationIndexTypes.class);
obj.setIndexBoolean(j % 2 == 0);
obj.setIndexLong(j);
obj.setIndexDate(withNull ? null : new Date(1000L * j));
obj.setIndexString(withNull ? null : "Test " + j);
obj.setNotIndexBoolean(j % 2 == 0);
obj.setNotIndexLong(j);
obj.setNotIndexDate(withNull ? null : new Date(1000L * j));
obj.setNotIndexString(withNull ? null : "Test " + j);
obj.setFieldObject(obj);
}
}
realm.commitTransaction();
}
private void populateForDistinctInvalidTypesLinked(Realm realm) {
realm.beginTransaction();
AllJavaTypes notEmpty = new AllJavaTypes();
notEmpty.setFieldBinary(new byte[]{1, 2, 3});
notEmpty.setFieldObject(notEmpty);
notEmpty.setFieldList(new RealmList<AllJavaTypes>(notEmpty));
realm.copyToRealm(notEmpty);
realm.commitTransaction();
}
@Test
public void distinct() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10; // Must be greater than 1
populateForDistinct(realm, numberOfBlocks, numberOfObjects, false);
RealmResults<AnnotationIndexTypes> distinctBool = realm.where(AnnotationIndexTypes.class).distinct(AnnotationIndexTypes.FIELD_INDEX_BOOL);
assertEquals(2, distinctBool.size());
for (String field : new String[]{AnnotationIndexTypes.FIELD_INDEX_LONG, AnnotationIndexTypes.FIELD_INDEX_DATE, AnnotationIndexTypes.FIELD_INDEX_STRING}) {
RealmResults<AnnotationIndexTypes> distinct = realm.where(AnnotationIndexTypes.class).distinct(field);
assertEquals(field, numberOfBlocks, distinct.size());
}
}
@Test
public void distinct_withNullValues() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, true);
for (String field : new String[]{AnnotationIndexTypes.FIELD_INDEX_DATE, AnnotationIndexTypes.FIELD_INDEX_STRING}) {
RealmResults<AnnotationIndexTypes> distinct = realm.where(AnnotationIndexTypes.class).distinct(field);
assertEquals(field, 1, distinct.size());
}
}
@Test
public void distinct_notIndexedFields() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, false);
RealmResults<AnnotationIndexTypes> distinctBool = realm.where(AnnotationIndexTypes.class)
.distinct(AnnotationIndexTypes.FIELD_NOT_INDEX_BOOL);
assertEquals(2, distinctBool.size());
for (String field : new String[]{AnnotationIndexTypes.FIELD_NOT_INDEX_LONG,
AnnotationIndexTypes.FIELD_NOT_INDEX_DATE, AnnotationIndexTypes.FIELD_NOT_INDEX_STRING}) {
RealmResults<AnnotationIndexTypes> distinct = realm.where(AnnotationIndexTypes.class).distinct(field);
assertEquals(field, numberOfBlocks, distinct.size());
}
}
@Test
public void distinct_doesNotExist() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10; // Must be greater than 1
populateForDistinct(realm, numberOfBlocks, numberOfObjects, false);
try {
realm.where(AnnotationIndexTypes.class).distinct("doesNotExist");
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void distinct_invalidTypes() {
populateTestRealm();
for (String field : new String[]{AllTypes.FIELD_REALMOBJECT, AllTypes.FIELD_REALMLIST, AllTypes.FIELD_DOUBLE, AllTypes.FIELD_FLOAT}) {
try {
realm.where(AllTypes.class).distinct(field);
fail(field);
} catch (IllegalArgumentException ignored) {
}
}
}
@Test
public void distinct_indexedLinkedFields() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, true);
for (String field : AnnotationIndexTypes.INDEX_FIELDS) {
try {
realm.where(AnnotationIndexTypes.class).distinct(AnnotationIndexTypes.FIELD_OBJECT + "." + field);
fail("Unsupported Index" + field + " linked field");
} catch (IllegalArgumentException ignored) {
}
}
}
@Test
public void distinct_notIndexedLinkedFields() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, true);
for (String field : AnnotationIndexTypes.NOT_INDEX_FIELDS) {
try {
realm.where(AnnotationIndexTypes.class).distinct(AnnotationIndexTypes.FIELD_OBJECT + "." + field);
fail("Unsupported notIndex" + field + " linked field");
} catch (IllegalArgumentException ignored) {
}
}
}
@Test
public void distinct_invalidTypesLinkedFields() {
populateForDistinctInvalidTypesLinked(realm);
try {
realm.where(AllJavaTypes.class).distinct(AllJavaTypes.FIELD_OBJECT + "." + AllJavaTypes.FIELD_BINARY);
} catch (IllegalArgumentException ignored) {
}
}
@Test
@RunTestInLooperThread
public void distinctAsync() throws Throwable {
final AtomicInteger changeListenerCalled = new AtomicInteger(4);
final Realm realm = looperThread.getRealm();
final long numberOfBlocks = 25;
final long numberOfObjects = 10; // Must be greater than 1
populateForDistinct(realm, numberOfBlocks, numberOfObjects, false);
final RealmResults<AnnotationIndexTypes> distinctBool = realm.where(AnnotationIndexTypes.class).distinctAsync(AnnotationIndexTypes.FIELD_INDEX_BOOL);
final RealmResults<AnnotationIndexTypes> distinctLong = realm.where(AnnotationIndexTypes.class).distinctAsync(AnnotationIndexTypes.FIELD_INDEX_LONG);
final RealmResults<AnnotationIndexTypes> distinctDate = realm.where(AnnotationIndexTypes.class).distinctAsync(AnnotationIndexTypes.FIELD_INDEX_DATE);
final RealmResults<AnnotationIndexTypes> distinctString = realm.where(AnnotationIndexTypes.class).distinctAsync(AnnotationIndexTypes.FIELD_INDEX_STRING);
assertFalse(distinctBool.isLoaded());
assertTrue(distinctBool.isValid());
assertTrue(distinctBool.isEmpty());
assertFalse(distinctLong.isLoaded());
assertTrue(distinctLong.isValid());
assertTrue(distinctLong.isEmpty());
assertFalse(distinctDate.isLoaded());
assertTrue(distinctDate.isValid());
assertTrue(distinctDate.isEmpty());
assertFalse(distinctString.isLoaded());
assertTrue(distinctString.isValid());
assertTrue(distinctString.isEmpty());
final Runnable endTest = new Runnable() {
@Override
public void run() {
if (changeListenerCalled.decrementAndGet() == 0) {
looperThread.testComplete();
}
}
};
looperThread.keepStrongReference(distinctBool);
looperThread.keepStrongReference(distinctLong);
looperThread.keepStrongReference(distinctDate);
looperThread.keepStrongReference(distinctString);
distinctBool.addChangeListener(new RealmChangeListener<RealmResults<AnnotationIndexTypes>>() {
@Override
public void onChange(RealmResults<AnnotationIndexTypes> object) {
assertEquals(2, distinctBool.size());
endTest.run();
}
});
distinctLong.addChangeListener(new RealmChangeListener<RealmResults<AnnotationIndexTypes>>() {
@Override
public void onChange(RealmResults<AnnotationIndexTypes> object) {
assertEquals(numberOfBlocks, distinctLong.size());
endTest.run();
}
});
distinctDate.addChangeListener(new RealmChangeListener<RealmResults<AnnotationIndexTypes>>() {
@Override
public void onChange(RealmResults<AnnotationIndexTypes> object) {
assertEquals(numberOfBlocks, distinctDate.size());
endTest.run();
}
});
distinctString.addChangeListener(new RealmChangeListener<RealmResults<AnnotationIndexTypes>>() {
@Override
public void onChange(RealmResults<AnnotationIndexTypes> object) {
assertEquals(numberOfBlocks, distinctString.size());
endTest.run();
}
});
}
@Test
@RunTestInLooperThread
public void distinctAsync_withNullValues() throws Throwable {
final AtomicInteger changeListenerCalled = new AtomicInteger(2);
final Realm realm = looperThread.getRealm();
final long numberOfBlocks = 25;
final long numberOfObjects = 10; // must be greater than 1
populateForDistinct(realm, numberOfBlocks, numberOfObjects, true);
final RealmResults<AnnotationIndexTypes> distinctDate = realm.where(AnnotationIndexTypes.class)
.distinctAsync(AnnotationIndexTypes.FIELD_INDEX_DATE);
final RealmResults<AnnotationIndexTypes> distinctString = realm.where(AnnotationIndexTypes.class)
.distinctAsync(AnnotationIndexTypes.FIELD_INDEX_STRING);
final Runnable endTest = new Runnable() {
@Override
public void run() {
if (changeListenerCalled.decrementAndGet() == 0) {
looperThread.testComplete();
}
}
};
looperThread.keepStrongReference(distinctDate);
looperThread.keepStrongReference(distinctString);
distinctDate.addChangeListener(new RealmChangeListener<RealmResults<AnnotationIndexTypes>>() {
@Override
public void onChange(RealmResults<AnnotationIndexTypes> object) {
assertEquals(1, distinctDate.size());
endTest.run();
}
});
distinctString.addChangeListener(new RealmChangeListener<RealmResults<AnnotationIndexTypes>>() {
@Override
public void onChange(RealmResults<AnnotationIndexTypes> object) {
assertEquals(1, distinctString.size());
endTest.run();
}
});
}
@Test
@RunTestInLooperThread
public void distinctAsync_doesNotExist() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, false);
try {
realm.where(AnnotationIndexTypes.class).distinctAsync("doesNotExist");
} catch (IllegalArgumentException ignored) {
}
looperThread.testComplete();
}
@Test
@RunTestInLooperThread
public void distinctAsync_invalidTypes() {
populateTestRealm(realm, TEST_DATA_SIZE);
for (String field : new String[]{AllTypes.FIELD_REALMOBJECT, AllTypes.FIELD_REALMLIST, AllTypes.FIELD_DOUBLE, AllTypes.FIELD_FLOAT}) {
try {
realm.where(AllTypes.class).distinctAsync(field);
} catch (IllegalArgumentException ignored) {
}
}
looperThread.testComplete();
}
@Test
@RunTestInLooperThread
public void distinctAsync_indexedLinkedFields() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, false);
for (String field : AnnotationIndexTypes.INDEX_FIELDS) {
try {
realm.where(AnnotationIndexTypes.class).distinctAsync(AnnotationIndexTypes.FIELD_OBJECT + "." + field);
fail("Unsupported " + field + " linked field");
} catch (IllegalArgumentException ignored) {
}
}
looperThread.testComplete();
}
@Test
@RunTestInLooperThread
public void distinctAsync_notIndexedLinkedFields() {
populateForDistinctInvalidTypesLinked(realm);
try {
realm.where(AllJavaTypes.class).distinctAsync(AllJavaTypes.FIELD_OBJECT + "." + AllJavaTypes.FIELD_BINARY);
} catch (IllegalArgumentException ignored) {
}
looperThread.testComplete();
}
@Test
public void distinctMultiArgs() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10; // Must be greater than 1
populateForDistinct(realm, numberOfBlocks, numberOfObjects, false);
RealmQuery<AnnotationIndexTypes> query = realm.where(AnnotationIndexTypes.class);
RealmResults<AnnotationIndexTypes> distinctMulti = query.distinct(AnnotationIndexTypes.FIELD_INDEX_BOOL, AnnotationIndexTypes.INDEX_FIELDS);
assertEquals(numberOfBlocks, distinctMulti.size());
}
@Test
public void distinctMultiArgs_switchedFieldsOrder() {
final long numberOfBlocks = 25;
TestHelper.populateForDistinctFieldsOrder(realm, numberOfBlocks);
// Regardless of the block size defined above, the output size is expected to be the same, 4 in this case, due to receiving unique combinations of tuples.
RealmQuery<AnnotationIndexTypes> query = realm.where(AnnotationIndexTypes.class);
RealmResults<AnnotationIndexTypes> distinctStringLong = query.distinct(AnnotationIndexTypes.FIELD_INDEX_STRING, AnnotationIndexTypes.FIELD_INDEX_LONG);
RealmResults<AnnotationIndexTypes> distinctLongString = query.distinct(AnnotationIndexTypes.FIELD_INDEX_LONG, AnnotationIndexTypes.FIELD_INDEX_STRING);
assertEquals(4, distinctStringLong.size());
assertEquals(4, distinctLongString.size());
assertEquals(distinctStringLong.size(), distinctLongString.size());
}
@Test
public void distinctMultiArgs_emptyField() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, false);
RealmQuery<AnnotationIndexTypes> query = realm.where(AnnotationIndexTypes.class);
// An empty string field in the middle.
try {
query.distinct(AnnotationIndexTypes.FIELD_INDEX_BOOL, "", AnnotationIndexTypes.FIELD_INDEX_INT);
} catch (IllegalArgumentException ignored) {
}
// An empty string field at the end.
try {
query.distinct(AnnotationIndexTypes.FIELD_INDEX_BOOL, AnnotationIndexTypes.FIELD_INDEX_INT, "");
} catch (IllegalArgumentException ignored) {
}
// A null string field in the middle.
try {
query.distinct(AnnotationIndexTypes.FIELD_INDEX_BOOL, (String) null, AnnotationIndexTypes.FIELD_INDEX_INT);
} catch (IllegalArgumentException ignored) {
}
// A null string field at the end.
try {
query.distinct(AnnotationIndexTypes.FIELD_INDEX_BOOL, AnnotationIndexTypes.FIELD_INDEX_INT, (String) null);
} catch (IllegalArgumentException ignored) {
}
// (String) Null makes varargs a null array.
try {
query.distinct(AnnotationIndexTypes.FIELD_INDEX_BOOL, (String) null);
} catch (IllegalArgumentException ignored) {
}
// Two (String) null for first and varargs fields.
try {
query.distinct((String) null, (String) null);
} catch (IllegalArgumentException ignored) {
}
// "" & (String) null combination.
try {
query.distinct("", (String) null);
} catch (IllegalArgumentException ignored) {
}
// "" & (String) null combination.
try {
query.distinct((String) null, "");
} catch (IllegalArgumentException ignored) {
}
// Two empty fields tests.
try {
query.distinct("", "");
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void distinctMultiArgs_withNullValues() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, true);
RealmQuery<AnnotationIndexTypes> query = realm.where(AnnotationIndexTypes.class);
RealmResults<AnnotationIndexTypes> distinctMulti = query.distinct(AnnotationIndexTypes.FIELD_INDEX_DATE, AnnotationIndexTypes.FIELD_INDEX_STRING);
assertEquals(1, distinctMulti.size());
}
@Test
public void distinctMultiArgs_notIndexedFields() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, false);
RealmQuery<AnnotationIndexTypes> query = realm.where(AnnotationIndexTypes.class);
try {
query.distinct(AnnotationIndexTypes.FIELD_NOT_INDEX_STRING, AnnotationIndexTypes.NOT_INDEX_FIELDS);
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void distinctMultiArgs_doesNotExistField() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, false);
RealmQuery<AnnotationIndexTypes> query = realm.where(AnnotationIndexTypes.class);
try {
query.distinct(AnnotationIndexTypes.FIELD_INDEX_INT, AnnotationIndexTypes.NONEXISTANT_MIX_FIELDS);
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void distinctMultiArgs_invalidTypesFields() {
populateTestRealm();
RealmQuery<AllTypes> query = realm.where(AllTypes.class);
try {
query.distinct(AllTypes.FIELD_REALMOBJECT, AllTypes.INVALID_TYPES_FIELDS_FOR_DISTINCT);
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void distinctMultiArgs_indexedLinkedFields() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, true);
RealmQuery<AnnotationIndexTypes> query = realm.where(AnnotationIndexTypes.class);
try {
query.distinct(AnnotationIndexTypes.INDEX_LINKED_FIELD_STRING, AnnotationIndexTypes.INDEX_LINKED_FIELDS);
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void distinctMultiArgs_notIndexedLinkedFields() {
final long numberOfBlocks = 25;
final long numberOfObjects = 10;
populateForDistinct(realm, numberOfBlocks, numberOfObjects, true);
RealmQuery<AnnotationIndexTypes> query = realm.where(AnnotationIndexTypes.class);
try {
query.distinct(AnnotationIndexTypes.NOT_INDEX_LINKED_FILED_STRING, AnnotationIndexTypes.NOT_INDEX_LINKED_FIELDS);
} catch (IllegalArgumentException ignored) {
}
}
@Test
public void distinctMultiArgs_invalidTypesLinkedFields() {
populateForDistinctInvalidTypesLinked(realm);
RealmQuery<AllJavaTypes> query = realm.where(AllJavaTypes.class);
try {
query.distinct(AllJavaTypes.INVALID_LINKED_BINARY_FIELD_FOR_DISTINCT, AllJavaTypes.INVALID_LINKED_TYPES_FIELDS_FOR_DISTINCT);
} catch (IllegalArgumentException ignored) {
}
}
@Test(expected = UnsupportedOperationException.class)
public void beginGroup_missingEndGroup() {
realm.where(AllTypes.class).beginGroup().findAll();
}
@Test(expected = UnsupportedOperationException.class)
public void endGroup_missingBeginGroup() {
realm.where(AllTypes.class).endGroup().findAll();
}
}