Пример #1
0
 /**
  * Test to see if a particular item that does exist in the same Realm does not exist in the result
  * set of another query.
  */
 public void testContainsSameRealmNotContained() {
   RealmResults<AllTypes> items =
       testRealm.where(AllTypes.class).lessThan(AllTypes.FIELD_LONG, 1000).findAll();
   AllTypes anotherType =
       testRealm.where(AllTypes.class).greaterThan(AllTypes.FIELD_LONG, 1000).findFirst();
   assertFalse(
       "Should not be able to find item in another result list.", items.contains(anotherType));
 }
Пример #2
0
 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));
 }
Пример #3
0
  public void testFindFirst() {
    AllTypes result = testRealm.where(AllTypes.class).findFirst();
    assertEquals(0, result.getColumnLong());
    assertEquals("test data 0", result.getColumnString());

    AllTypes none = testRealm.where(AllTypes.class).equalTo(FIELD_STRING, "smurf").findFirst();
    assertNull(none);
  }
Пример #4
0
  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());
  }
Пример #5
0
  public void testNullToNonNullResults() {
    RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
    RealmAdapter realmAdapter = new RealmAdapter(getContext(), null, automaticUpdate);
    realmAdapter.updateRealmResults(resultList);

    assertEquals(TEST_DATA_SIZE, realmAdapter.getCount());
  }
Пример #6
0
 public void testGetItemId() {
   RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
   RealmAdapter realmAdapter = new RealmAdapter(getContext(), resultList, automaticUpdate);
   for (int i = 0; i < resultList.size(); i++) {
     assertEquals(i, realmAdapter.getItemId(i));
   }
 }
Пример #7
0
  // Test average on empty columns
  public void testAvgGivesCorrectValueForEmptyColumns() {
    RealmResults<NullTypes> resultList = testRealm.where(NullTypes.class).findAll();

    assertEquals(0d, resultList.average(NullTypes.FIELD_INTEGER_NOT_NULL), 0d);
    assertEquals(0d, resultList.average(NullTypes.FIELD_FLOAT_NOT_NULL), 0d);
    assertEquals(0d, resultList.average(NullTypes.FIELD_DOUBLE_NOT_NULL), 0d);
  }
Пример #8
0
  public void testAvgGivesCorrectValue() {
    RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
    double N = (double) TEST_DATA_SIZE;

    // Sum of numbers 1 to M: M*(M+1)/2
    // See setUp() for values of fields
    // N = TEST_DATA_SIZE

    // Type: double; a = 3.1415
    // a, a+1, ..., a+i, ..., a+N-1
    // sum = 3.1415*N + N*(N-1)/2
    // average = sum/N = 3.1415+(N-1)/2
    double average = 3.1415 + (N - 1.0) * 0.5;
    assertEquals(average, resultList.average(FIELD_DOUBLE), 0.0001);

    // Type: long
    // 0, 1, ..., N-1
    // sum = N*(N-1)/2
    // average = sum/N = (N-1)/2
    assertEquals(0.5 * (N - 1), resultList.average(FIELD_LONG), 0.0001);

    // Type: float; b = 1.234567
    // b, b+1, ..., b+i, ..., b+N-1
    // sum = b*N + N*(N-1)/2
    // average = sum/N = b + (N-1)/2
    assertEquals(1.234567 + 0.5 * (N - 1.0), resultList.average(FIELD_FLOAT), 0.0001);
  }
Пример #9
0
 public void testEmptyRealmResult() {
   RealmResults<AllTypes> resultList =
       testRealm.where(AllTypes.class).equalTo(FIELD_STRING, "Not there").findAll();
   RealmAdapter realmAdapter = new RealmAdapter(getContext(), resultList, automaticUpdate);
   assertEquals(0, realmAdapter.getRealmResults().size());
   assertEquals(0, realmAdapter.getCount());
 }
Пример #10
0
  public void testSumGivesCorrectValue() {
    RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();

    Number sum = resultList.sum(FIELD_LONG);
    // Sum of numbers 0 to M-1: (M-1)*M/2
    assertEquals((TEST_DATA_SIZE - 1) * TEST_DATA_SIZE / 2, sum.intValue());
  }
Пример #11
0
 // Test max on empty columns
 public void testMaxValueForEmptyColumns() {
   RealmResults<NullTypes> results = testRealm.where(NullTypes.class).findAll();
   assertNull(results.max(NullTypes.FIELD_INTEGER_NOT_NULL));
   assertNull(results.max(NullTypes.FIELD_FLOAT_NOT_NULL));
   assertNull(results.max(NullTypes.FIELD_DOUBLE_NOT_NULL));
   assertNull(results.maxDate(NullTypes.FIELD_DATE_NOT_NULL));
 }
Пример #12
0
  public void testSortByLong() {
    RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
    RealmResults<AllTypes> sortedList = testRealm.allObjects(AllTypes.class);
    sortedList.sort(FIELD_LONG, RealmResults.SORT_ORDER_DESCENDING);
    assertEquals("Should have same size", resultList.size(), sortedList.size());
    assertEquals(TEST_DATA_SIZE, sortedList.size());
    assertEquals(
        "First excepted to be last",
        resultList.first().getColumnLong(),
        sortedList.last().getColumnLong());

    RealmResults<AllTypes> reverseList = sortedList;
    reverseList.sort(FIELD_LONG, RealmResults.SORT_ORDER_ASCENDING);
    assertEquals(TEST_DATA_SIZE, reverseList.size());
    assertEquals(
        "First excepted to be first",
        resultList.first().getColumnLong(),
        reverseList.first().getColumnLong());
    assertEquals(
        "Last excepted to be last",
        resultList.last().getColumnLong(),
        reverseList.last().getColumnLong());

    RealmResults<AllTypes> reserveSortedList = reverseList;
    reverseList.sort(FIELD_LONG, RealmResults.SORT_ORDER_DESCENDING);
    assertEquals(TEST_DATA_SIZE, reserveSortedList.size());
  }
Пример #13
0
  // Test sum on nullable rows with all null values
  public void testSumGivesCorrectValueForAllNullRows() {
    TestHelper.populateAllNullRowsForNumericTesting(testRealm);

    RealmResults<NullTypes> resultList = testRealm.where(NullTypes.class).findAll();
    assertEquals(0, resultList.sum(NullTypes.FIELD_INTEGER_NULL).intValue());
    assertEquals(0f, resultList.sum(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
    assertEquals(0d, resultList.sum(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
  }
Пример #14
0
  // Test sum on nullable rows with partial null values
  public void testAvgGivesCorrectValueForPartialNullRows() {
    populatePartialNullRowsForNumericTesting();
    RealmResults<NullTypes> resultList = testRealm.where(NullTypes.class).findAll();

    assertEquals(1, resultList.sum(NullTypes.FIELD_INTEGER_NULL).intValue());
    assertEquals(2f, resultList.sum(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
    assertEquals(3d, resultList.sum(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
  }
Пример #15
0
  // Test min on nullable rows with partial null values
  public void testMinValueForPartialNullRows() {
    populatePartialNullRowsForNumericTesting();

    RealmResults<NullTypes> results = testRealm.where(NullTypes.class).findAll();
    assertEquals(0, results.min(NullTypes.FIELD_INTEGER_NULL).intValue());
    assertEquals(0f, results.min(NullTypes.FIELD_FLOAT_NULL).floatValue(), 0f);
    assertEquals(0d, results.min(NullTypes.FIELD_DOUBLE_NULL).doubleValue(), 0d);
  }
Пример #16
0
 public void testSortOnNonExistingColumn() {
   try {
     RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
     resultList.sort("Non-existing");
     fail("Column should not exist");
   } catch (IllegalArgumentException ignored) {
   }
 }
Пример #17
0
  // Test average on nullable rows with all null values
  public void testAvgGivesCorrectValueForAllNullRows() {
    TestHelper.populateAllNullRowsForNumericTesting(testRealm);

    RealmResults<NullTypes> resultList = testRealm.where(NullTypes.class).findAll();
    assertEquals(0d, resultList.average(NullTypes.FIELD_INTEGER_NULL), 0d);
    assertEquals(0d, resultList.average(NullTypes.FIELD_FLOAT_NULL), 0d);
    assertEquals(0d, resultList.average(NullTypes.FIELD_DOUBLE_NULL), 0d);
  }
Пример #18
0
 public void testAdapterParameterExceptions() {
   RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
   try {
     RealmAdapter realmAdapter = new RealmAdapter(null, resultList, automaticUpdate);
     fail("Should throw exception if context is null");
   } catch (IllegalArgumentException ignore) {
   }
 }
Пример #19
0
  // Test average on nullable rows with partial null values
  public void testAvgForPartialNullRows() {
    populatePartialNullRowsForNumericTesting();
    RealmResults<NullTypes> resultList = testRealm.where(NullTypes.class).findAll();

    assertEquals(0.5, resultList.average(NullTypes.FIELD_INTEGER_NULL), 0d);
    assertEquals(1.0, resultList.average(NullTypes.FIELD_FLOAT_NULL), 0d);
    assertEquals(1.5, resultList.average(NullTypes.FIELD_DOUBLE_NULL), 0d);
  }
Пример #20
0
  // 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());
  }
Пример #21
0
  // Test max on nullable rows with all null values
  public void testMaxValueForAllNullRows() {
    TestHelper.populateAllNullRowsForNumericTesting(testRealm);

    RealmResults<NullTypes> results = testRealm.where(NullTypes.class).findAll();
    assertNull(results.max(NullTypes.FIELD_INTEGER_NULL));
    assertNull(results.max(NullTypes.FIELD_FLOAT_NULL));
    assertNull(results.max(NullTypes.FIELD_DOUBLE_NULL));
    assertNull(results.maxDate(NullTypes.FIELD_DATE_NULL));
  }
Пример #22
0
 public void testManyConditions() {
   RealmQuery<AllTypes> query = testRealm.where(AllTypes.class);
   query.equalTo(FIELD_LONG, 0);
   for (int i = 1; i < TEST_DATA_SIZE; i++) {
     query.or().equalTo(FIELD_LONG, i);
   }
   RealmResults<AllTypes> allTypesRealmResults = query.findAll();
   assertEquals(TEST_DATA_SIZE, allTypesRealmResults.size());
 }
Пример #23
0
  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());
  }
Пример #24
0
  public void testQueryDateField() {
    RealmQuery<AllTypes> query =
        testRealm.where(AllTypes.class).equalTo(FIELD_DATE, new Date(YEAR_MILLIS * 5));
    RealmResults<AllTypes> all = query.findAll();
    assertEquals(1, query.count());
    assertEquals(1, all.size());

    // before 1901
    query = testRealm.where(AllTypes.class).equalTo(FIELD_DATE, new Date(YEAR_MILLIS * -100));
    all = query.findAll();
    assertEquals(1, query.count());
    assertEquals(1, all.size());

    // after 2038
    query = testRealm.where(AllTypes.class).equalTo(FIELD_DATE, new Date(YEAR_MILLIS * 100));
    all = query.findAll();
    assertEquals(1, query.count());
    assertEquals(1, all.size());
  }
Пример #25
0
 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");
   }
 }
Пример #26
0
  public void testFindAllSorted() {
    RealmResults<AllTypes> allTypes =
        testRealm.where(AllTypes.class).findAllSorted(FIELD_LONG, Sort.ASCENDING);
    assertEquals(TEST_DATA_SIZE, allTypes.size());
    assertEquals(0, allTypes.first().getColumnLong());
    assertEquals(TEST_DATA_SIZE - 1, allTypes.last().getColumnLong());

    RealmResults<AllTypes> reverseList =
        testRealm.where(AllTypes.class).findAllSorted(FIELD_LONG, Sort.DESCENDING);
    assertEquals(TEST_DATA_SIZE, reverseList.size());
    assertEquals(0, reverseList.last().getColumnLong());
    assertEquals(TEST_DATA_SIZE - 1, reverseList.first().getColumnLong());

    try {
      testRealm.where(AllTypes.class).findAllSorted("invalid", Sort.DESCENDING);
      fail();
    } catch (IllegalArgumentException ignored) {
    }
  }
Пример #27
0
  // 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());
  }
Пример #28
0
  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());
  }
Пример #29
0
  public void testGetItem() {
    RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll();
    RealmAdapter realmAdapter = new RealmAdapter(getContext(), resultList, automaticUpdate);

    assertEquals(resultList.get(0).getColumnString(), realmAdapter.getItem(0).getColumnString());
    assertEquals(resultList.size(), realmAdapter.getRealmResults().size());
    assertEquals(
        resultList.last().getColumnString(),
        realmAdapter.getRealmResults().last().getColumnString());
  }
Пример #30
0
  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();
      }
    }
  }