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()); }
private void check(Realm realm) { RealmResults<Student> realmResults = realm.allObjects(Student.class); if (realmResults.size() != numberOfObjects) { throw new RuntimeException( String.format("Error in number of objectss.", realmResults.size(), numberOfObjects)); } }
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()); }
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()); }
// 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()); }
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 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()); }
// 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()); }
@Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); ImageLoaderConfiguration conf = new ImageLoaderConfiguration.Builder(getActivity()).build(); ImageLoader imageLoader = ImageLoader.getInstance(); imageLoader.init(conf); adapter = new FriendsArrayAdapter(getActivity(), R.layout.row_friends, imageLoader, this); setListAdapter(adapter); realm = Realm.getInstance(getActivity()); RealmResults<Friend> results = realm.allObjects(Friend.class); // TODO: Run async if (results.size() > 0) { if (!compact) { getListView().setVisibility(View.VISIBLE); progressBar.setVisibility(View.GONE); } adapter.update(results); } refreshFriends(); // TODO: Timeout on the refresh rate? }
/** * ********************************************************************************************* * VOD시청 */ public void addWatchVod(Date watchDate, String assetId, String title) { // Realm Database ********************************************************************** // Obtain a Realm instance Realm realm = Realm.getInstance(mContext); RealmResults<WatchVodObject> results = realm.where(WatchVodObject.class).findAll(); long iSeq = 0; if (results == null) { // } else { if (results.size() == 0) { iSeq = 0; } else { iSeq = realm.where(WatchVodObject.class).maximumInt("iSeq") + 1; } } WatchVodObject obj = new WatchVodObject(); obj.setiSeq((int) iSeq); obj.setdDate(watchDate); obj.setsAssetId(assetId); obj.setsTitle(title); realm.beginTransaction(); WatchVodObject obj2 = realm.copyToRealm(obj); realm.commitTransaction(); // Realm Database ********************************************************************** }
/** * getWishList로 전체 찜 목록을 가져왔을때 호출되는 함수. 기존의 Wish들을 삭제하고, 파라메터의 어레이로 다시 채운다. * * @param arr */ public void setAllWishList(JSONArray arr) { // Realm Database ********************************************************************** // Obtain a Realm instance Realm realm = Realm.getInstance(mContext); // remove all realm.beginTransaction(); realm.allObjects(WishObject.class).clear(); for (int i = 0; i < arr.length(); i++) { try { JSONObject jo = arr.getJSONObject(i); JSONObject asset = jo.getJSONObject("asset"); String assetId = asset.getString("assetId"); RealmResults<WishObject> results = mRealm.where(WishObject.class).equalTo("sAssetId", assetId).findAll(); if (results.size() > 0) { // skip } else { // 객체를 생성하거나 데이터를 수정하는 작업을 수행한다. WishObject wish = realm.createObject(WishObject.class); // Create a new object wish.setsAssetId(assetId); wish.setsPhoneNumber(jo.getString("phoneNumber")); wish.setsUserId(jo.getString("userId")); } } catch (JSONException e) { e.printStackTrace(); } } // 트랜잭션 종료 realm.commitTransaction(); // Realm Database ********************************************************************** }
public void testSortSingleField() { RealmResults<AllTypes> sortedList = testRealm.allObjects(AllTypes.class); sortedList.sort(new String[] {FIELD_LONG}, new boolean[] {RealmResults.SORT_ORDER_DESCENDING}); assertEquals(TEST_DATA_SIZE, sortedList.size()); assertEquals(TEST_DATA_SIZE - 1, sortedList.first().getColumnLong()); assertEquals(0, sortedList.last().getColumnLong()); }
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)); } }
// 2016-03-29 시청예약시 데이타베이스 처리를 programId 로 하는데 서버에서 programId를 중복으로 보내고 있다 // 그래서 시청시간을 추가함. public void removeWatchTvReserveAlarmWithProgramIdAndStartTime( String programId, String startTime) { int iSeq = 0; Realm realm = Realm.getInstance(mContext); realm.beginTransaction(); RealmResults<WatchTvObject> results = mRealm .where(WatchTvObject.class) .equalTo("sProgramId", programId) .equalTo("sProgramBroadcastingStartTime", startTime) .findAll(); if (results.size() > 0) { WatchTvObject obj = results.get(0); iSeq = obj.getiSeq(); obj.removeFromRealm(); } else { // } realm.commitTransaction(); AlarmManager alarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE); Intent intent = new Intent(mContext, WatchTvAlarmBroadcastReceiver.class); PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, iSeq, intent, PendingIntent.FLAG_NO_CREATE); if (pendingIntent != null) { alarmManager.cancel(pendingIntent); pendingIntent.cancel(); } }
public void getFromDatabase() { mEntityList.clear(); RealmResults<RealmZcool> zcoolRealmResults = mRealm.where(RealmZcool.class).findAll(); for (int i = zcoolRealmResults.size() - 1; i >= 0; i--) { mEntityList.add(zcoolRealmResults.get(i).toEntity()); } }
@Override public View getView(int position, View view, ViewGroup parent) { LayoutInflater inflater = activity.getLayoutInflater(); Type type = realmResults.get(position); // check which markers are available Boolean available = false; RealmResults<Marker> markers = Utils.realm.where(Marker.class).equalTo("city.id", Utils.city_id).findAll(); for (int i = 0; i < markers.size(); i++) { Marker thisMarker = markers.get(i); if (thisMarker.getType() == type.getType()) { available = true; } } // marker type is available show in list if (available) { rowView = inflater.inflate(R.layout.custom_filter_list, null, true); TextView filterName = (TextView) rowView.findViewById(R.id.FilterName); TextView filterType = (TextView) rowView.findViewById(R.id.FilterType); ImageView filterIcon = (ImageView) rowView.findViewById(R.id.TypeIcon); Switch filterDisplay = (Switch) rowView.findViewById(R.id.DisplayToggle); // set label depending on language set Utils.language = Utils.preferences.getInt("language", 0); if (Utils.language == 0) { filterName.setText(type.getName_nl()); } else if (Utils.language == 1) { filterName.setText(type.getName_en()); } else if (Utils.language == 2) { filterName.setText(type.getName_es()); } else { filterName.setText("int: " + Utils.language); } filterType.setText(String.format("%d", type.getType())); Context context = filterIcon.getContext(); int id = context .getResources() .getIdentifier(type.getImage(), "drawable", context.getPackageName()); Bitmap icon = BitmapFactory.decodeResource(context.getResources(), id); filterIcon.setImageBitmap(icon); filterDisplay.setChecked(type.getDisplay()); rowView.setTag(type); } else { rowView = inflater.inflate(R.layout.custom_empty_list, null, true); } return rowView; }
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()); }
public void testSortByDouble() { RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll(); RealmResults<AllTypes> sortedList = resultList.where().findAll(); sortedList.sort(FIELD_DOUBLE, Sort.DESCENDING); assertEquals(resultList.size(), sortedList.size()); assertEquals(TEST_DATA_SIZE, sortedList.size()); assertEquals(resultList.first().getColumnDouble(), sortedList.last().getColumnDouble()); RealmResults<AllTypes> reverseList = sortedList.where().findAll(); reverseList.sort(FIELD_DOUBLE, Sort.ASCENDING); assertEquals(TEST_DATA_SIZE, reverseList.size()); assertEquals(resultList.first().getColumnDouble(), reverseList.first().getColumnDouble()); assertEquals(resultList.last().getColumnDouble(), reverseList.last().getColumnDouble()); RealmResults<AllTypes> reverseSortedList = reverseList.where().findAll(); reverseSortedList.sort(FIELD_DOUBLE, Sort.DESCENDING); assertEquals(TEST_DATA_SIZE, reverseSortedList.size()); }
private void doTestSortOnColumnWithPartialNullValues(String fieldName) { RealmResults<NullTypes> resultList = testRealm.where(NullTypes.class).findAll(); // Ascending RealmResults<NullTypes> sortedList = testRealm.allObjects(NullTypes.class); sortedList.sort(fieldName, RealmResults.SORT_ORDER_ASCENDING); assertEquals("Should have same size", resultList.size(), sortedList.size()); // Null should always be the first one in the ascending sorted list assertEquals(2, sortedList.first().getId()); assertEquals(1, sortedList.last().getId()); // Descending sortedList = testRealm.allObjects(NullTypes.class); sortedList.sort(fieldName, RealmResults.SORT_ORDER_DESCENDING); assertEquals("Should have same size", resultList.size(), sortedList.size()); assertEquals(1, sortedList.first().getId()); // Null should always be the last one in the descending sorted list assertEquals(2, sortedList.last().getId()); }
public void testSortByFloat() { RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll(); RealmResults<AllTypes> sortedList = resultList.where().findAll(); sortedList.sort(FIELD_FLOAT, RealmResults.SORT_ORDER_DESCENDING); assertEquals(resultList.size(), sortedList.size()); assertEquals(TEST_DATA_SIZE, sortedList.size()); assertEquals(resultList.first().getColumnFloat(), sortedList.last().getColumnFloat()); RealmResults<AllTypes> reverseList = sortedList.where().findAll(); reverseList.sort(FIELD_FLOAT, RealmResults.SORT_ORDER_ASCENDING); assertEquals(TEST_DATA_SIZE, reverseList.size()); assertEquals(resultList.first().getColumnFloat(), reverseList.first().getColumnFloat()); assertEquals(resultList.last().getColumnFloat(), reverseList.last().getColumnFloat()); RealmResults<AllTypes> reverseSortedList = reverseList.where().findAll(); reverseSortedList.sort(FIELD_FLOAT, RealmResults.SORT_ORDER_DESCENDING); assertEquals(TEST_DATA_SIZE, reverseSortedList.size()); }
public void testQueryResult() { RealmResults<AllTypes> allTypes = testRealm.where(AllTypes.class).findAll(); assertEquals(TEST_DATA_SIZE, allTypes.size()); // querying a RealmResults should find objects that fulfill the condition RealmResults<AllTypes> onedigits = allTypes.where().lessThan(FIELD_LONG, 10).findAll(); assertEquals(Math.min(10, TEST_DATA_SIZE), onedigits.size()); // if no objects fulfill conditions, the result has zero objects RealmResults<AllTypes> none = allTypes.where().greaterThan(FIELD_LONG, TEST_DATA_SIZE).findAll(); assertEquals(0, none.size()); // querying a result with zero objects must give zero objects RealmResults<AllTypes> stillNone = none.where().greaterThan(FIELD_LONG, TEST_DATA_SIZE).findAll(); assertEquals(0, stillNone.size()); }
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()); }
public boolean isBookmarkChannelWithChannelId(String channelId) { RealmResults<BookmarkChannelObject> results = mRealm.where(BookmarkChannelObject.class).equalTo("sChannelId", channelId).findAll(); if (results.size() > 0) { return true; } else { return false; } }
public boolean isWatchTvReserveWithProgramId(String programId) { RealmResults<WatchTvObject> results = mRealm.where(WatchTvObject.class).equalTo("sProgramId", programId).findAll(); if (results.size() > 0) { return true; } else { return false; } }
public boolean isWishAsset(String assetId) { RealmResults<WishObject> results = mRealm.where(WishObject.class).equalTo("sAssetId", assetId).findAll(); if (results.size() > 0) { return true; } else { return false; } }
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()); }
public MainCategoryObject getMainCategoryObject(int i) { String sSortNo = String.valueOf(i); RealmResults<MainCategoryObject> results = mRealm.where(MainCategoryObject.class).equalTo("sSortNo", sSortNo).findAll(); if (results.size() > 0) { return results.get(0); } else { return null; } }
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) { } }
public void testSortWithAdapter() { RealmResults<AllTypes> resultList = testRealm.where(AllTypes.class).findAll(); resultList.sort(FIELD_STRING, RealmResults.SORT_ORDER_DESCENDING); RealmAdapter realmAdapter = new RealmAdapter(getContext(), resultList, automaticUpdate); assertEquals( resultList.first().getColumnString(), realmAdapter.getRealmResults().first().getColumnString()); assertEquals(resultList.size(), realmAdapter.getRealmResults().size()); resultList.sort(FIELD_STRING); assertEquals( resultList.last().getColumnString(), realmAdapter.getRealmResults().last().getColumnString()); assertEquals( resultList.get(TEST_DATA_SIZE / 2).getColumnString(), realmAdapter.getRealmResults().get(TEST_DATA_SIZE / 2).getColumnString()); assertEquals(resultList.size(), realmAdapter.getRealmResults().size()); }
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()); }