public void testSortWithGreekCharacters() {
testRealm.beginTransaction();
testRealm.clear(AllTypes.class);
AllTypes at1 = testRealm.createObject(AllTypes.class);
at1.setColumnString("αύριο");
AllTypes at2 = testRealm.createObject(AllTypes.class);
at2.setColumnString("ημέρες");
AllTypes at3 = testRealm.createObject(AllTypes.class);
at3.setColumnString("δοκιμές");
testRealm.commitTransaction();
RealmResults<AllTypes> result = testRealm.allObjects(AllTypes.class);
RealmResults<AllTypes> sortedResult = result.where().findAll();
sortedResult.sort(FIELD_STRING);
assertEquals(3, sortedResult.size());
assertEquals("αύριο", sortedResult.first().getColumnString());
assertEquals("αύριο", sortedResult.get(0).getColumnString());
assertEquals("δοκιμές", sortedResult.get(1).getColumnString());
assertEquals("ημέρες", sortedResult.get(2).getColumnString());
RealmResults<AllTypes> reverseResult = result.where().findAll();
reverseResult.sort(FIELD_STRING, RealmResults.SORT_ORDER_DESCENDING);
assertEquals(3, reverseResult.size());
assertEquals("αύριο", reverseResult.last().getColumnString());
assertEquals("ημέρες", reverseResult.get(0).getColumnString());
assertEquals("δοκιμές", reverseResult.get(1).getColumnString());
assertEquals("αύριο", reverseResult.get(2).getColumnString());
}
public void testSortWithRussianCharacters() {
testRealm.beginTransaction();
testRealm.clear(AllTypes.class);
AllTypes at1 = testRealm.createObject(AllTypes.class);
at1.setColumnString("Санкт-Петербург");
AllTypes at2 = testRealm.createObject(AllTypes.class);
at2.setColumnString("Москва");
AllTypes at3 = testRealm.createObject(AllTypes.class);
at3.setColumnString("Новороссийск");
testRealm.commitTransaction();
RealmResults<AllTypes> result = testRealm.allObjects(AllTypes.class);
RealmResults<AllTypes> sortedResult = result.where().findAll();
sortedResult.sort(FIELD_STRING);
assertEquals(3, sortedResult.size());
assertEquals("Москва", sortedResult.first().getColumnString());
assertEquals("Москва", sortedResult.get(0).getColumnString());
assertEquals("Новороссийск", sortedResult.get(1).getColumnString());
assertEquals("Санкт-Петербург", sortedResult.get(2).getColumnString());
RealmResults<AllTypes> reverseResult = result.where().findAll();
reverseResult.sort(FIELD_STRING, RealmResults.SORT_ORDER_DESCENDING);
assertEquals(3, reverseResult.size());
assertEquals("Москва", reverseResult.last().getColumnString());
assertEquals("Санкт-Петербург", reverseResult.get(0).getColumnString());
assertEquals("Новороссийск", reverseResult.get(1).getColumnString());
assertEquals("Москва", reverseResult.get(2).getColumnString());
}
// No sorting order defined. There are Korean, Arabic and Chinese characters.
public void testSortWithManyDifferentCharacters() {
testRealm.beginTransaction();
testRealm.clear(AllTypes.class);
AllTypes at1 = testRealm.createObject(AllTypes.class);
at1.setColumnString("단위");
AllTypes at2 = testRealm.createObject(AllTypes.class);
at2.setColumnString("테스트");
AllTypes at3 = testRealm.createObject(AllTypes.class);
at3.setColumnString("وحدة");
AllTypes at4 = testRealm.createObject(AllTypes.class);
at4.setColumnString("اختبار");
AllTypes at5 = testRealm.createObject(AllTypes.class);
at5.setColumnString("单位");
AllTypes at6 = testRealm.createObject(AllTypes.class);
at6.setColumnString("试验");
AllTypes at7 = testRealm.createObject(AllTypes.class);
at7.setColumnString("單位");
AllTypes at8 = testRealm.createObject(AllTypes.class);
at8.setColumnString("測試");
testRealm.commitTransaction();
RealmResults<AllTypes> result = testRealm.allObjects(AllTypes.class);
RealmResults<AllTypes> sortedResult = result.where().findAll();
sortedResult.sort(FIELD_STRING);
assertEquals(8, sortedResult.size());
@SuppressWarnings("UnnecessaryLocalVariable")
RealmResults<AllTypes> reverseResult = result;
reverseResult.sort(FIELD_STRING, RealmResults.SORT_ORDER_DESCENDING);
assertEquals(8, reverseResult.size());
}
private void populatePartialNullRowsForNumericTesting() {
NullTypes nullTypes1 = new NullTypes();
nullTypes1.setId(1);
nullTypes1.setFieldIntegerNull(1);
nullTypes1.setFieldFloatNull(2F);
nullTypes1.setFieldDoubleNull(3D);
nullTypes1.setFieldBooleanNull(true);
nullTypes1.setFieldStringNull("4");
nullTypes1.setFieldDateNull(new Date(12345));
NullTypes nullTypes2 = new NullTypes();
nullTypes2.setId(2);
NullTypes nullTypes3 = new NullTypes();
nullTypes3.setId(3);
nullTypes3.setFieldIntegerNull(0);
nullTypes3.setFieldFloatNull(0F);
nullTypes3.setFieldDoubleNull(0D);
nullTypes3.setFieldBooleanNull(false);
nullTypes3.setFieldStringNull("0");
nullTypes3.setFieldDateNull(new Date(0));
testRealm.beginTransaction();
testRealm.copyToRealm(nullTypes1);
testRealm.copyToRealm(nullTypes2);
testRealm.copyToRealm(nullTypes3);
testRealm.commitTransaction();
}
public void testSortWithDanishCharacters() {
testRealm.beginTransaction();
testRealm.clear(AllTypes.class);
AllTypes at1 = testRealm.createObject(AllTypes.class);
at1.setColumnString("Æble");
AllTypes at2 = testRealm.createObject(AllTypes.class);
at2.setColumnString("Øl");
AllTypes at3 = testRealm.createObject(AllTypes.class);
at3.setColumnString("Århus");
testRealm.commitTransaction();
RealmResults<AllTypes> result = testRealm.allObjects(AllTypes.class);
RealmResults<AllTypes> sortedResult = result.where().findAll();
sortedResult.sort(FIELD_STRING);
assertEquals(3, sortedResult.size());
assertEquals("Æble", sortedResult.first().getColumnString());
assertEquals("Æble", sortedResult.get(0).getColumnString());
assertEquals("Øl", sortedResult.get(1).getColumnString());
assertEquals("Århus", sortedResult.get(2).getColumnString());
RealmResults<AllTypes> reverseResult = result.where().findAll();
reverseResult.sort(FIELD_STRING, Sort.DESCENDING);
assertEquals(3, reverseResult.size());
assertEquals("Æble", reverseResult.last().getColumnString());
assertEquals("Århus", reverseResult.get(0).getColumnString());
assertEquals("Øl", reverseResult.get(1).getColumnString());
assertEquals("Æble", reverseResult.get(2).getColumnString());
}
// Triggered an ARM bug
public void testComparisons() {
testRealm.beginTransaction();
testRealm.clear(AllTypes.class);
long id = -1;
for (int i = 0; i < 10; i++) {
AllTypes allTypes = testRealm.createObject(AllTypes.class);
allTypes.setColumnLong(id--);
}
testRealm.commitTransaction();
assertEquals(
10, testRealm.where(AllTypes.class).between(AllTypes.FIELD_LONG, -10, -1).findAll().size());
assertEquals(
10, testRealm.where(AllTypes.class).greaterThan(AllTypes.FIELD_LONG, -11).findAll().size());
assertEquals(
10,
testRealm
.where(AllTypes.class)
.greaterThanOrEqualTo(AllTypes.FIELD_LONG, -10)
.findAll()
.size());
assertEquals(
10, testRealm.where(AllTypes.class).lessThan(AllTypes.FIELD_LONG, 128).findAll().size());
assertEquals(
10, testRealm.where(AllTypes.class).lessThan(AllTypes.FIELD_LONG, 127).findAll().size());
assertEquals(
10,
testRealm
.where(AllTypes.class)
.lessThanOrEqualTo(AllTypes.FIELD_LONG, -1)
.findAll()
.size());
assertEquals(
10, testRealm.where(AllTypes.class).lessThan(AllTypes.FIELD_LONG, 0).findAll().size());
}
public void testShouldNotContainRemovedItem() {
RealmQuery<AllTypes> query = testRealm.where(AllTypes.class).findAll().where();
AllTypes item = testRealm.where(AllTypes.class).findFirst();
testRealm.beginTransaction();
item.removeFromRealm();
testRealm.commitTransaction();
assertFalse("Should not contain a removed item.", query.findAll().contains(item));
}
// void clear(Class<?> classSpec)
public void testClearEmptiesTable() {
RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
assertEquals(TEST_DATA_SIZE, resultList.size());
testRealm.beginTransaction();
resultList.clear();
testRealm.commitTransaction();
assertEquals(0, resultList.size());
}
public void testWithEmptyRealmObjects() {
testRealm.beginTransaction();
testRealm.clear(AllTypes.class);
testRealm.commitTransaction();
try {
testRealm.where(AllTypes.class).findAll().sort(FIELD_STRING);
} catch (IllegalArgumentException e) {
fail("Failed to sort an empty RealmResults");
}
}
public void testRemoveLastEmptyList() {
RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
testRealm.beginTransaction();
resultList.clear();
assertEquals(0, resultList.size());
resultList.removeLast();
testRealm.commitTransaction();
assertEquals(0, resultList.size());
}
public void testClearFromAdapter() {
RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
RealmAdapter realmAdapter = new RealmAdapter(getContext(), resultList, automaticUpdate);
testRealm.beginTransaction();
realmAdapter.getRealmResults().clear();
testRealm.commitTransaction();
assertEquals(0, realmAdapter.getCount());
assertEquals(0, resultList.size());
}
public void testRemove() {
RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
testRealm.beginTransaction();
resultList.remove(0);
testRealm.commitTransaction();
assertEquals(TEST_DATA_SIZE - 1, resultList.size());
AllTypes allTypes = resultList.get(0);
assertEquals(1, allTypes.getColumnLong());
}
public void testRemoveFromAdapter() {
RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
RealmAdapter realmAdapter = new RealmAdapter(getContext(), resultList, automaticUpdate);
testRealm.beginTransaction();
realmAdapter.getRealmResults().remove(0);
testRealm.commitTransaction();
assertEquals(TEST_DATA_SIZE - 1, realmAdapter.getCount());
resultList = testRealm.where(AllTypes.class).equalTo(FIELD_STRING, "test data 0").findAll();
assertEquals(0, resultList.size());
}
protected void setUp() throws Exception {
super.setUp();
Realm.deleteRealmFile(getContext());
testRealm = Realm.getInstance(getContext());
testRealm.beginTransaction();
for (int i = 0; i < TEST_DATA_SIZE; ++i) {
AllTypes allTypes = testRealm.createObject(AllTypes.class);
allTypes.setColumnString("test data " + i);
}
testRealm.commitTransaction();
}
public boolean methodWrongThread(final Method method)
throws ExecutionException, InterruptedException {
final RealmResults<AllTypes> allTypeses = testRealm.where(AllTypes.class).findAll();
testRealm.beginTransaction();
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<Boolean> future =
executorService.submit(
new Callable<Boolean>() {
@Override
public Boolean call() throws Exception {
try {
switch (method) {
case METHOD_MIN:
allTypeses.min(FIELD_FLOAT);
break;
case METHOD_MAX:
allTypeses.max(FIELD_FLOAT);
break;
case METHOD_SUM:
allTypeses.sum(FIELD_FLOAT);
break;
case METHOD_AVG:
allTypeses.average(FIELD_FLOAT);
break;
case METHOD_SORT:
allTypeses.sort(FIELD_FLOAT);
break;
case METHOD_WHERE:
allTypeses.where();
break;
case METHOD_REMOVE:
allTypeses.remove(0);
break;
case METHOD_REMOVE_LAST:
allTypeses.removeLast();
break;
case METHOD_CLEAR:
allTypeses.clear();
break;
}
return false;
} catch (IllegalStateException ignored) {
return true;
}
}
});
Boolean result = future.get();
testRealm.cancelTransaction();
return result;
}
// Setting a nullable field to null is not an error
public void testSetNullField() {
TestHelper.populateTestRealmForNullTests(testRealm);
RealmResults<NullTypes> list = testRealm.allObjects(NullTypes.class);
// 1 String
testRealm.beginTransaction();
list.first().setFieldStringNull(null);
testRealm.commitTransaction();
assertNull(testRealm.allObjects(NullTypes.class).first().getFieldStringNull());
// 2 Bytes
testRealm.beginTransaction();
list.first().setFieldBytesNull(null);
testRealm.commitTransaction();
assertNull(testRealm.allObjects(NullTypes.class).first().getFieldBytesNull());
// 3 Boolean
testRealm.beginTransaction();
list.first().setFieldBooleanNull(null);
testRealm.commitTransaction();
assertNull(testRealm.allObjects(NullTypes.class).first().getFieldBooleanNull());
// 4 Byte
// 5 Short 6 Integer 7 Long are skipped
testRealm.beginTransaction();
list.first().setFieldByteNull(null);
testRealm.commitTransaction();
assertNull(testRealm.allObjects(NullTypes.class).first().getFieldByteNull());
// 8 Float
testRealm.beginTransaction();
list.first().setFieldFloatNull(null);
testRealm.commitTransaction();
assertNull(testRealm.allObjects(NullTypes.class).first().getFieldFloatNull());
// 9 Double
testRealm.beginTransaction();
list.first().setFieldDoubleNull(null);
testRealm.commitTransaction();
assertNull(testRealm.allObjects(NullTypes.class).first().getFieldDoubleNull());
// 10 Date
testRealm.beginTransaction();
list.first().setFieldDateNull(null);
testRealm.commitTransaction();
assertNull(testRealm.allObjects(NullTypes.class).first().getFieldDateNull());
}
public void testSortByChildObject() {
testRealm.beginTransaction();
Owner owner = testRealm.createObject(Owner.class);
owner.setName("owner");
Cat cat = testRealm.createObject(Cat.class);
cat.setName("cat");
owner.setCat(cat);
testRealm.commitTransaction();
RealmQuery<Owner> query = testRealm.where(Owner.class);
RealmResults<Owner> owners = query.findAll();
try {
owners.sort("cat.name");
fail("Sorting by child object properties should result in a IllegalArgumentException");
} catch (IllegalArgumentException ignore) {
}
}
public void testSortWithTwoLanguages() {
testRealm.beginTransaction();
testRealm.clear(AllTypes.class);
AllTypes allTypes1 = testRealm.createObject(AllTypes.class);
allTypes1.setColumnString("test");
AllTypes allTypes2 = testRealm.createObject(AllTypes.class);
allTypes2.setColumnString("αύριο");
AllTypes allTypes3 = testRealm.createObject(AllTypes.class);
allTypes3.setColumnString("work");
testRealm.commitTransaction();
try {
RealmResults<AllTypes> result = testRealm.allObjects(AllTypes.class);
result.sort(FIELD_STRING);
} catch (IllegalArgumentException e) {
fail("Failed to sort with two kinds of alphabets");
}
}
public void testRemoveLast() {
RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
testRealm.beginTransaction();
resultList.removeLast();
testRealm.commitTransaction();
assertEquals(
"ResultList.removeLast did not remove record", TEST_DATA_SIZE - 1, resultList.size());
AllTypes allTypes = resultList.get(resultList.size() - 1);
assertEquals(
"ResultList.removeLast unexpected last record",
TEST_DATA_SIZE - 2,
allTypes.getColumnLong());
RealmResults<AllTypes> resultListCheck = testRealm.where(AllTypes.class).findAll();
assertEquals("ResultList.removeLast not committed", TEST_DATA_SIZE - 1, resultListCheck.size());
}
// first() and last() will throw an exception when no element exist
public void testResultListFirstLastThrowIfEmpty() {
testRealm.beginTransaction();
testRealm.clear(AllTypes.class);
testRealm.commitTransaction();
RealmResults<AllTypes> allTypes = testRealm.allObjects(AllTypes.class);
assertEquals(0, allTypes.size());
try {
allTypes.first();
fail();
} catch (ArrayIndexOutOfBoundsException ignored) {
}
try {
allTypes.last();
fail();
} catch (ArrayIndexOutOfBoundsException ignored) {
}
}
public void testContainsDoesNotContainAnItem() {
RealmConfiguration realmConfig =
TestHelper.createConfiguration(getContext(), "contains_test.realm");
Realm.deleteRealm(realmConfig);
Realm testRealmTwo = Realm.getInstance(realmConfig);
try {
testRealmTwo.beginTransaction();
testRealmTwo.allObjects(AllTypes.class).clear();
testRealmTwo.allObjects(NonLatinFieldNames.class).clear();
for (int i = 0; i < TEST_DATA_SIZE; ++i) {
AllTypes allTypes = testRealmTwo.createObject(AllTypes.class);
allTypes.setColumnBoolean((i % 2) == 0);
allTypes.setColumnBinary(new byte[] {1, 2, 3});
allTypes.setColumnDate(new Date(YEAR_MILLIS * (i - TEST_DATA_SIZE / 2)));
allTypes.setColumnDouble(3.1415 + i);
allTypes.setColumnFloat(1.234567f + i);
allTypes.setColumnString("test data " + i);
allTypes.setColumnLong(i);
Dog d = testRealmTwo.createObject(Dog.class);
d.setName("Foo " + i);
allTypes.setColumnRealmObject(d);
allTypes.getColumnRealmList().add(d);
NonLatinFieldNames nonLatinFieldNames = testRealmTwo.createObject(NonLatinFieldNames.class);
nonLatinFieldNames.set델타(i);
nonLatinFieldNames.setΔέλτα(i);
}
testRealmTwo.commitTransaction();
final AllTypes item = testRealmTwo.where(AllTypes.class).findFirst();
assertFalse(
"Should not be able to find one object in another Realm via RealmResults#contains",
testRealm.where(AllTypes.class).findAll().contains(item));
} finally {
if (testRealmTwo != null && !testRealmTwo.isClosed()) {
testRealmTwo.close();
}
}
}
public void testUpdateRealmResultInAdapter() {
RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
resultList.sort(FIELD_STRING);
RealmAdapter realmAdapter = new RealmAdapter(getContext(), resultList, false);
assertEquals(
resultList.first().getColumnString(),
realmAdapter.getRealmResults().first().getColumnString());
assertEquals(resultList.size(), realmAdapter.getRealmResults().size());
testRealm.beginTransaction();
AllTypes allTypes = testRealm.createObject(AllTypes.class);
allTypes.setColumnString("test data " + TEST_DATA_SIZE);
testRealm.commitTransaction();
assertEquals(
resultList.last().getColumnString(),
realmAdapter.getRealmResults().last().getColumnString());
assertEquals(resultList.size(), realmAdapter.getRealmResults().size());
RealmResults<AllTypes> emptyResultList =
testRealm.where(AllTypes.class).equalTo(FIELD_STRING, "Not there").findAll();
realmAdapter.updateRealmResults(emptyResultList);
assertEquals(emptyResultList.size(), realmAdapter.getRealmResults().size());
}
private void populateTestRealm(int objects) {
testRealm.beginTransaction();
testRealm.allObjects(AllTypes.class).clear();
testRealm.allObjects(NonLatinFieldNames.class).clear();
for (int i = 0; i < objects; ++i) {
AllTypes allTypes = testRealm.createObject(AllTypes.class);
allTypes.setColumnBoolean((i % 2) == 0);
allTypes.setColumnBinary(new byte[] {1, 2, 3});
allTypes.setColumnDate(new Date(YEAR_MILLIS * (i - objects / 2)));
allTypes.setColumnDouble(3.1415 + i);
allTypes.setColumnFloat(1.234567f + i);
allTypes.setColumnString("test data " + i);
allTypes.setColumnLong(i);
Dog d = testRealm.createObject(Dog.class);
d.setName("Foo " + i);
allTypes.setColumnRealmObject(d);
allTypes.getColumnRealmList().add(d);
NonLatinFieldNames nonLatinFieldNames = testRealm.createObject(NonLatinFieldNames.class);
nonLatinFieldNames.set델타(i);
nonLatinFieldNames.setΔέλτα(i);
}
testRealm.commitTransaction();
}
// Setting a not-nullable field to null is an error
public void testNullFieldNotNullableField() {
TestHelper.populateTestRealmForNullTests(testRealm);
RealmResults<NullTypes> list = testRealm.allObjects(NullTypes.class);
// 1 String
try {
testRealm.beginTransaction();
list.first().setFieldStringNotNull(null);
fail();
} catch (IllegalArgumentException ignored) {
} finally {
testRealm.cancelTransaction();
}
// 2 Bytes
try {
testRealm.beginTransaction();
list.first().setFieldBytesNotNull(null);
fail();
} catch (IllegalArgumentException ignored) {
} finally {
testRealm.cancelTransaction();
}
// 3 Boolean
try {
testRealm.beginTransaction();
list.first().setFieldBooleanNotNull(null);
fail();
} catch (IllegalArgumentException ignored) {
} finally {
testRealm.cancelTransaction();
}
// 4 Byte
try {
testRealm.beginTransaction();
list.first().setFieldBytesNotNull(null);
fail();
} catch (IllegalArgumentException ignored) {
} finally {
testRealm.cancelTransaction();
}
// 5 Short 6 Integer 7 Long are skipped for this case, same with Bytes
// 8 Float
try {
testRealm.beginTransaction();
list.first().setFieldFloatNotNull(null);
fail();
} catch (IllegalArgumentException ignored) {
} finally {
testRealm.cancelTransaction();
}
// 9 Double
try {
testRealm.beginTransaction();
list.first().setFieldDoubleNotNull(null);
fail();
} catch (IllegalArgumentException ignored) {
} finally {
testRealm.cancelTransaction();
}
// 10 Date
try {
testRealm.beginTransaction();
list.first().setFieldDateNotNull(null);
fail();
} catch (IllegalArgumentException ignored) {
} finally {
testRealm.cancelTransaction();
}
}