| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * 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 com.android.calendar.alerts; |
| |
| import static android.app.Notification.PRIORITY_DEFAULT; |
| import static android.app.Notification.PRIORITY_HIGH; |
| import static android.app.Notification.PRIORITY_MIN; |
| |
| import android.app.AlarmManager; |
| import android.content.SharedPreferences; |
| import android.database.MatrixCursor; |
| import android.provider.CalendarContract.Attendees; |
| import android.provider.CalendarContract.CalendarAlerts; |
| import android.test.AndroidTestCase; |
| import android.test.suitebuilder.annotation.SmallTest; |
| import android.test.suitebuilder.annotation.Smoke; |
| import android.text.format.DateUtils; |
| import android.text.format.Time; |
| |
| import com.android.calendar.GeneralPreferences; |
| import com.android.calendar.alerts.AlertService.NotificationInfo; |
| import com.android.calendar.alerts.AlertService.NotificationWrapper; |
| |
| import junit.framework.Assert; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Map; |
| import java.util.Set; |
| |
| public class AlertServiceTest extends AndroidTestCase { |
| |
| class MockSharedPreferences implements SharedPreferences { |
| |
| private Boolean mVibrate; |
| private String mRingtone; |
| private Boolean mPopup; |
| |
| // Strict mode will fail if a preference key is queried more than once. |
| private boolean mStrict = false; |
| |
| MockSharedPreferences() { |
| this(false); |
| } |
| |
| MockSharedPreferences(boolean strict) { |
| super(); |
| init(); |
| this.mStrict = strict; |
| } |
| |
| void init() { |
| mVibrate = true; |
| mRingtone = "/some/cool/ringtone"; |
| mPopup = true; |
| } |
| |
| @Override |
| public boolean contains(String key) { |
| if (GeneralPreferences.KEY_ALERTS_VIBRATE.equals(key)) { |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean getBoolean(String key, boolean defValue) { |
| if (GeneralPreferences.KEY_ALERTS_VIBRATE.equals(key)) { |
| if (mVibrate == null) { |
| Assert.fail(GeneralPreferences.KEY_ALERTS_VIBRATE |
| + " fetched more than once."); |
| } |
| boolean val = mVibrate; |
| if (mStrict) { |
| mVibrate = null; |
| } |
| return val; |
| } |
| if (GeneralPreferences.KEY_ALERTS_POPUP.equals(key)) { |
| if (mPopup == null) { |
| Assert.fail(GeneralPreferences.KEY_ALERTS_POPUP + " fetched more than once."); |
| } |
| boolean val = mPopup; |
| if (mStrict) { |
| mPopup = null; |
| } |
| return val; |
| } |
| throw new IllegalArgumentException(); |
| } |
| |
| @Override |
| public String getString(String key, String defValue) { |
| if (GeneralPreferences.KEY_ALERTS_RINGTONE.equals(key)) { |
| if (mRingtone == null) { |
| Assert.fail(GeneralPreferences.KEY_ALERTS_RINGTONE |
| + " fetched more than once."); |
| } |
| String val = mRingtone; |
| if (mStrict) { |
| mRingtone = null; |
| } |
| return val; |
| } |
| throw new IllegalArgumentException(); |
| } |
| |
| @Override |
| public Map<String, ?> getAll() { |
| throw new IllegalArgumentException(); |
| } |
| |
| @Override |
| public Set<String> getStringSet(String key, Set<String> defValues) { |
| throw new IllegalArgumentException(); |
| } |
| |
| @Override |
| public int getInt(String key, int defValue) { |
| throw new IllegalArgumentException(); |
| } |
| |
| @Override |
| public long getLong(String key, long defValue) { |
| throw new IllegalArgumentException(); |
| } |
| |
| @Override |
| public float getFloat(String key, float defValue) { |
| throw new IllegalArgumentException(); |
| } |
| |
| @Override |
| public Editor edit() { |
| throw new IllegalArgumentException(); |
| } |
| |
| @Override |
| public void registerOnSharedPreferenceChangeListener( |
| OnSharedPreferenceChangeListener listener) { |
| throw new IllegalArgumentException(); |
| } |
| |
| @Override |
| public void unregisterOnSharedPreferenceChangeListener( |
| OnSharedPreferenceChangeListener listener) { |
| throw new IllegalArgumentException(); |
| } |
| |
| } |
| |
| // Created these constants so the test cases are shorter |
| public static final int SCHEDULED = CalendarAlerts.STATE_SCHEDULED; |
| public static final int FIRED = CalendarAlerts.STATE_FIRED; |
| public static final int DISMISSED = CalendarAlerts.STATE_DISMISSED; |
| |
| public static final int ACCEPTED = Attendees.ATTENDEE_STATUS_ACCEPTED; |
| public static final int DECLINED = Attendees.ATTENDEE_STATUS_DECLINED; |
| public static final int INVITED = Attendees.ATTENDEE_STATUS_INVITED; |
| public static final int TENTATIVE = Attendees.ATTENDEE_STATUS_TENTATIVE; |
| |
| class NotificationInstance { |
| int mAlertId; |
| int[] mAlertIdsInDigest; |
| int mPriority; |
| |
| public NotificationInstance(int alertId, int priority) { |
| mAlertId = alertId; |
| mPriority = priority; |
| } |
| |
| public NotificationInstance(int[] alertIdsInDigest, int priority) { |
| mAlertIdsInDigest = alertIdsInDigest; |
| mPriority = priority; |
| } |
| } |
| |
| class Alert { |
| long mEventId; |
| int mAlertStatus; |
| int mResponseStatus; |
| int mAllDay; |
| long mBegin; |
| long mEnd; |
| int mMinute; |
| long mAlarmTime; |
| |
| public Alert(long eventId, int alertStatus, int responseStatus, int allDay, long begin, |
| long end, int minute, long alarmTime) { |
| mEventId = eventId; |
| mAlertStatus = alertStatus; |
| mResponseStatus = responseStatus; |
| mAllDay = allDay; |
| mBegin = begin; |
| mEnd = end; |
| mMinute = minute; |
| mAlarmTime = alarmTime; |
| } |
| |
| } |
| |
| class AlertsTable { |
| |
| ArrayList<Alert> mAlerts = new ArrayList<Alert>(); |
| |
| int addAlertRow(long eventId, int alertStatus, int responseStatus, int allDay, long begin, |
| long end, long alarmTime) { |
| Alert a = new Alert(eventId, alertStatus, responseStatus, allDay, begin, end, |
| 5 /* minute */, alarmTime); |
| int id = mAlerts.size(); |
| mAlerts.add(a); |
| return id; |
| } |
| |
| public MatrixCursor getAlertCursor() { |
| MatrixCursor alertCursor = new MatrixCursor(AlertService.ALERT_PROJECTION); |
| |
| int i = 0; |
| for (Alert a : mAlerts) { |
| Object[] ca = { |
| i++, |
| a.mEventId, |
| a.mAlertStatus, |
| "Title" + a.mEventId + " " + a.mMinute, |
| "Loc" + a.mEventId, |
| a.mResponseStatus, |
| a.mAllDay, |
| a.mAlarmTime > 0 ? a.mAlarmTime : a.mBegin - a.mMinute * 60 * 1000, |
| a.mMinute, |
| a.mBegin, |
| a.mEnd, |
| "Desc: " + a.mAlarmTime |
| }; |
| alertCursor.addRow(ca); |
| } |
| return alertCursor; |
| } |
| |
| } |
| |
| class NotificationTestManager extends NotificationMgr { |
| // Expected notifications |
| NotificationInstance[] mExpectedNotifications; |
| NotificationWrapper[] mActualNotifications; |
| boolean[] mCancelled; |
| |
| // CalendarAlerts table |
| private ArrayList<Alert> mAlerts; |
| |
| public NotificationTestManager(ArrayList<Alert> alerts, int maxNotifications) { |
| assertEquals(0, AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID); |
| mAlerts = alerts; |
| mExpectedNotifications = new NotificationInstance[maxNotifications + 1]; |
| mActualNotifications = new NotificationWrapper[mExpectedNotifications.length]; |
| mCancelled = new boolean[mExpectedNotifications.length]; |
| } |
| |
| public void expectTestNotification(int notificationId, int alertId, int highPriority) { |
| mExpectedNotifications[notificationId] = new NotificationInstance(alertId, |
| highPriority); |
| } |
| |
| public void expectTestNotification(int notificationId, int[] alertIds, int priority) { |
| mExpectedNotifications[notificationId] = new NotificationInstance(alertIds, priority); |
| } |
| |
| private <T> boolean nullContents(T[] array) { |
| for (T item : array) { |
| if (item != null) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| public void validateNotificationsAndReset() { |
| if (nullContents(mExpectedNotifications)) { |
| return; |
| } |
| |
| String debugStr = printActualNotifications(); |
| for (int id = 0; id < mActualNotifications.length; id++) { |
| NotificationInstance expected = mExpectedNotifications[id]; |
| NotificationWrapper actual = mActualNotifications[id]; |
| if (expected == null) { |
| assertNull("Received unexpected notificationId " + id + debugStr, actual); |
| assertTrue("NotificationId " + id + " should have been cancelled." + debugStr, |
| mCancelled[id]); |
| } else { |
| assertNotNull("Expected notificationId " + id + " but it was not posted." |
| + debugStr, actual); |
| assertFalse("NotificationId " + id + " should not have been cancelled." |
| + debugStr, mCancelled[id]); |
| assertEquals("Priority not as expected for notification " + id + debugStr, |
| expected.mPriority, actual.mNotification.priority); |
| if (expected.mAlertIdsInDigest == null) { |
| Alert a = mAlerts.get(expected.mAlertId); |
| assertEquals("Event ID not expected for notification " + id + debugStr, |
| a.mEventId, actual.mEventId); |
| assertEquals("Begin time not expected for notification " + id + debugStr, |
| a.mBegin, actual.mBegin); |
| assertEquals("End time not expected for notification " + id + debugStr, |
| a.mEnd, actual.mEnd); |
| } else { |
| // Notification should be a digest. |
| assertNotNull("Posted notification not a digest as expected." + debugStr, |
| actual.mNw); |
| assertEquals("Number of notifications in digest not as expected." |
| + debugStr, expected.mAlertIdsInDigest.length, actual.mNw.size()); |
| for (int i = 0; i < actual.mNw.size(); i++) { |
| Alert a = mAlerts.get(expected.mAlertIdsInDigest[i]); |
| assertEquals("Digest item " + i + ": Event ID not as expected" |
| + debugStr, a.mEventId, actual.mNw.get(i).mEventId); |
| assertEquals("Digest item " + i + ": Begin time in digest not expected" |
| + debugStr, a.mBegin, actual.mNw.get(i).mBegin); |
| assertEquals("Digest item " + i + ": End time in digest not expected" |
| + debugStr, a.mEnd, actual.mNw.get(i).mEnd); |
| } |
| } |
| } |
| } |
| |
| Arrays.fill(mCancelled, false); |
| Arrays.fill(mExpectedNotifications, null); |
| Arrays.fill(mActualNotifications, null); |
| } |
| |
| private String printActualNotifications() { |
| StringBuilder s = new StringBuilder(); |
| s.append("\n\nNotifications actually posted:\n"); |
| for (int i = mActualNotifications.length - 1; i >= 0; i--) { |
| NotificationWrapper actual = mActualNotifications[i]; |
| if (actual == null) { |
| continue; |
| } |
| s.append("Notification " + i + " -- "); |
| s.append("priority:" + actual.mNotification.priority); |
| if (actual.mNw == null) { |
| s.append(", eventId:" + actual.mEventId); |
| } else { |
| s.append(", eventIds:{"); |
| for (int digestIndex = 0; digestIndex < actual.mNw.size(); digestIndex++) { |
| s.append(actual.mNw.get(digestIndex).mEventId + ","); |
| } |
| s.append("}"); |
| } |
| s.append("\n"); |
| } |
| return s.toString(); |
| } |
| |
| /////////////////////////////// |
| // NotificationMgr methods |
| @Override |
| public void cancel(int id) { |
| assertTrue("id out of bound: " + id, 0 <= id); |
| assertTrue("id out of bound: " + id, id < mCancelled.length); |
| assertNull("id already used", mActualNotifications[id]); |
| assertFalse("id already used", mCancelled[id]); |
| mCancelled[id] = true; |
| assertNull("Unexpected cancel for id " + id, mExpectedNotifications[id]); |
| } |
| |
| @Override |
| public void notify(int id, NotificationWrapper nw) { |
| assertTrue("id out of bound: " + id, 0 <= id); |
| assertTrue("id out of bound: " + id, id < mExpectedNotifications.length); |
| assertNull("id already used: " + id, mActualNotifications[id]); |
| mActualNotifications[id] = nw; |
| } |
| } |
| |
| // TODO |
| // Catch updates of new state, notify time, and received time |
| // Test ringer, vibrate, |
| // Test intents, action email |
| |
| @Smoke |
| @SmallTest |
| public void testGenerateAlerts_none() { |
| MockSharedPreferences prefs = new MockSharedPreferences(); |
| AlertsTable at = new AlertsTable(); |
| NotificationTestManager ntm = new NotificationTestManager(at.mAlerts, |
| AlertService.MAX_NOTIFICATIONS); |
| |
| // Test no alert |
| long currentTime = 1000000; |
| AlertService.generateAlerts(mContext, ntm, new MockAlarmManager(mContext), prefs, |
| at.getAlertCursor(), currentTime, AlertService.MAX_NOTIFICATIONS); |
| ntm.validateNotificationsAndReset(); |
| } |
| |
| @Smoke |
| @SmallTest |
| public void testGenerateAlerts_single() { |
| MockSharedPreferences prefs = new MockSharedPreferences(); |
| MockAlarmManager alarmMgr = new MockAlarmManager(mContext); |
| AlertsTable at = new AlertsTable(); |
| NotificationTestManager ntm = new NotificationTestManager(at.mAlerts, |
| AlertService.MAX_NOTIFICATIONS); |
| |
| int id = at.addAlertRow(100, SCHEDULED, ACCEPTED, 0 /* all day */, 1300000, 2300000, 0); |
| |
| // Test one up coming alert |
| long currentTime = 1000000; |
| ntm.expectTestNotification(1, id, PRIORITY_HIGH); |
| |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), currentTime, |
| AlertService.MAX_NOTIFICATIONS); |
| ntm.validateNotificationsAndReset(); // This wipes out notification |
| // tests added so far |
| |
| // Test half way into an event |
| currentTime = 2300000; |
| ntm.expectTestNotification(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, id, PRIORITY_MIN); |
| |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), currentTime, |
| AlertService.MAX_NOTIFICATIONS); |
| ntm.validateNotificationsAndReset(); |
| |
| // Test event ended |
| currentTime = 4300000; |
| ntm.expectTestNotification(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, id, PRIORITY_MIN); |
| |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), currentTime, |
| AlertService.MAX_NOTIFICATIONS); |
| ntm.validateNotificationsAndReset(); |
| } |
| |
| @SmallTest |
| public void testGenerateAlerts_multiple() { |
| int maxNotifications = 10; |
| MockSharedPreferences prefs = new MockSharedPreferences(); |
| MockAlarmManager alarmMgr = new MockAlarmManager(mContext); |
| AlertsTable at = new AlertsTable(); |
| NotificationTestManager ntm = new NotificationTestManager(at.mAlerts, maxNotifications); |
| |
| // Current time - 5:00 |
| long currentTime = createTimeInMillis(5, 0); |
| |
| // Set up future alerts. The real query implementation sorts by descending start |
| // time so simulate that here with our order of adds to AlertsTable. |
| int id9 = at.addAlertRow(9, SCHEDULED, ACCEPTED, 0, createTimeInMillis(9, 0), |
| createTimeInMillis(10, 0), 0); |
| int id8 = at.addAlertRow(8, SCHEDULED, ACCEPTED, 0, createTimeInMillis(8, 0), |
| createTimeInMillis(9, 0), 0); |
| int id7 = at.addAlertRow(7, SCHEDULED, ACCEPTED, 0, createTimeInMillis(7, 0), |
| createTimeInMillis(8, 0), 0); |
| |
| // Set up concurrent alerts (that started recently). |
| int id6 = at.addAlertRow(6, SCHEDULED, ACCEPTED, 0, createTimeInMillis(5, 0), |
| createTimeInMillis(5, 40), 0); |
| int id5 = at.addAlertRow(5, SCHEDULED, ACCEPTED, 0, createTimeInMillis(4, 55), |
| createTimeInMillis(7, 30), 0); |
| int id4 = at.addAlertRow(4, SCHEDULED, ACCEPTED, 0, createTimeInMillis(4, 50), |
| createTimeInMillis(4, 50), 0); |
| |
| // Set up past alerts. |
| int id3 = at.addAlertRow(3, SCHEDULED, ACCEPTED, 0, createTimeInMillis(3, 0), |
| createTimeInMillis(4, 0), 0); |
| int id2 = at.addAlertRow(2, SCHEDULED, ACCEPTED, 0, createTimeInMillis(2, 0), |
| createTimeInMillis(3, 0), 0); |
| int id1 = at.addAlertRow(1, SCHEDULED, ACCEPTED, 0, createTimeInMillis(1, 0), |
| createTimeInMillis(2, 0), 0); |
| |
| // Check posted notifications. The order listed here is the order simulates the |
| // order in the real notification bar (last one posted appears on top), so these |
| // should be lowest start time on top. |
| ntm.expectTestNotification(6, id4, PRIORITY_HIGH); // concurrent |
| ntm.expectTestNotification(5, id5, PRIORITY_HIGH); // concurrent |
| ntm.expectTestNotification(4, id6, PRIORITY_HIGH); // concurrent |
| ntm.expectTestNotification(3, id7, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(2, id8, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(1, id9, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, |
| new int[] {id3, id2, id1}, PRIORITY_MIN); |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), |
| currentTime, maxNotifications); |
| ntm.validateNotificationsAndReset(); |
| |
| // Increase time by 15 minutes to check that some concurrent events dropped |
| // to the low priority bucket. |
| currentTime = createTimeInMillis(5, 15); |
| ntm.expectTestNotification(4, id5, PRIORITY_HIGH); // concurrent |
| ntm.expectTestNotification(3, id7, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(2, id8, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(1, id9, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, |
| new int[] {id6, id4, id3, id2, id1}, PRIORITY_MIN); |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), |
| currentTime, maxNotifications); |
| ntm.validateNotificationsAndReset(); |
| |
| // Increase time so some of the previously future ones change state. |
| currentTime = createTimeInMillis(8, 15); |
| ntm.expectTestNotification(1, id9, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, |
| new int[] {id8, id7, id6, id5, id4, id3, id2, id1}, PRIORITY_MIN); |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), |
| currentTime, maxNotifications); |
| ntm.validateNotificationsAndReset(); |
| } |
| |
| @SmallTest |
| public void testGenerateAlerts_maxAlerts() { |
| MockSharedPreferences prefs = new MockSharedPreferences(); |
| MockAlarmManager alarmMgr = new MockAlarmManager(mContext); |
| AlertsTable at = new AlertsTable(); |
| |
| // Current time - 5:00 |
| long currentTime = createTimeInMillis(5, 0); |
| |
| // Set up future alerts. The real query implementation sorts by descending start |
| // time so simulate that here with our order of adds to AlertsTable. |
| int id9 = at.addAlertRow(9, SCHEDULED, ACCEPTED, 0, createTimeInMillis(9, 0), |
| createTimeInMillis(10, 0), 0); |
| int id8 = at.addAlertRow(8, SCHEDULED, ACCEPTED, 0, createTimeInMillis(8, 0), |
| createTimeInMillis(9, 0), 0); |
| int id7 = at.addAlertRow(7, SCHEDULED, ACCEPTED, 0, createTimeInMillis(7, 0), |
| createTimeInMillis(8, 0), 0); |
| |
| // Set up concurrent alerts (that started recently). |
| int id6 = at.addAlertRow(6, SCHEDULED, ACCEPTED, 0, createTimeInMillis(5, 0), |
| createTimeInMillis(5, 40), 0); |
| int id5 = at.addAlertRow(5, SCHEDULED, ACCEPTED, 0, createTimeInMillis(4, 55), |
| createTimeInMillis(7, 30), 0); |
| int id4 = at.addAlertRow(4, SCHEDULED, ACCEPTED, 0, createTimeInMillis(4, 50), |
| createTimeInMillis(4, 50), 0); |
| |
| // Set up past alerts. |
| int id3 = at.addAlertRow(3, SCHEDULED, ACCEPTED, 0, createTimeInMillis(3, 0), |
| createTimeInMillis(4, 0), 0); |
| int id2 = at.addAlertRow(2, SCHEDULED, ACCEPTED, 0, createTimeInMillis(2, 0), |
| createTimeInMillis(3, 0), 0); |
| int id1 = at.addAlertRow(1, SCHEDULED, ACCEPTED, 0, createTimeInMillis(1, 0), |
| createTimeInMillis(2, 0), 0); |
| |
| // Test when # alerts = max. |
| int maxNotifications = 6; |
| NotificationTestManager ntm = new NotificationTestManager(at.mAlerts, maxNotifications); |
| ntm.expectTestNotification(6, id4, PRIORITY_HIGH); // concurrent |
| ntm.expectTestNotification(5, id5, PRIORITY_HIGH); // concurrent |
| ntm.expectTestNotification(4, id6, PRIORITY_HIGH); // concurrent |
| ntm.expectTestNotification(3, id7, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(2, id8, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(1, id9, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, |
| new int[] {id3, id2, id1}, PRIORITY_MIN); |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), |
| currentTime, maxNotifications); |
| ntm.validateNotificationsAndReset(); |
| |
| // Test when # alerts > max. |
| maxNotifications = 4; |
| ntm = new NotificationTestManager(at.mAlerts, maxNotifications); |
| ntm.expectTestNotification(4, id4, PRIORITY_HIGH); // concurrent |
| ntm.expectTestNotification(3, id5, PRIORITY_HIGH); // concurrent |
| ntm.expectTestNotification(2, id6, PRIORITY_HIGH); // concurrent |
| ntm.expectTestNotification(1, id7, PRIORITY_HIGH); // future |
| ntm.expectTestNotification(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, |
| new int[] {id9, id8, id3, id2, id1}, PRIORITY_MIN); |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), |
| currentTime, maxNotifications); |
| ntm.validateNotificationsAndReset(); |
| } |
| |
| /** |
| * Test that the SharedPreferences are only fetched once for each setting. |
| */ |
| @SmallTest |
| public void testGenerateAlerts_sharedPreferences() { |
| MockSharedPreferences prefs = new MockSharedPreferences(true /* strict mode */); |
| AlertsTable at = new AlertsTable(); |
| NotificationTestManager ntm = new NotificationTestManager(at.mAlerts, |
| AlertService.MAX_NOTIFICATIONS); |
| |
| // Current time - 5:00 |
| long currentTime = createTimeInMillis(5, 0); |
| |
| // Set up future alerts. The real query implementation sorts by descending start |
| // time so simulate that here with our order of adds to AlertsTable. |
| at.addAlertRow(3, SCHEDULED, ACCEPTED, 0, createTimeInMillis(9, 0), |
| createTimeInMillis(10, 0), 0); |
| at.addAlertRow(2, SCHEDULED, ACCEPTED, 0, createTimeInMillis(8, 0), |
| createTimeInMillis(9, 0), 0); |
| at.addAlertRow(1, SCHEDULED, ACCEPTED, 0, createTimeInMillis(7, 0), |
| createTimeInMillis(8, 0), 0); |
| |
| // If this does not result in a failure (MockSharedPreferences fails for duplicate |
| // queries), then test passes. |
| AlertService.generateAlerts(mContext, ntm, new MockAlarmManager(mContext), prefs, |
| at.getAlertCursor(), currentTime, AlertService.MAX_NOTIFICATIONS); |
| } |
| |
| public void testGenerateAlerts_refreshTime() { |
| AlertsTable at = new AlertsTable(); |
| MockSharedPreferences prefs = new MockSharedPreferences(); |
| MockAlarmManager alarmMgr = new MockAlarmManager(mContext); |
| NotificationTestManager ntm = new NotificationTestManager(at.mAlerts, |
| AlertService.MAX_NOTIFICATIONS); |
| |
| // Since AlertService.processQuery uses DateUtils.isToday instead of checking against |
| // the passed in currentTime (not worth allocating the extra Time objects to do so), use |
| // today's date for this test. |
| Time now = new Time(); |
| now.setToNow(); |
| int day = now.monthDay; |
| int month = now.month; |
| int year = now.year; |
| Time yesterday = new Time(); |
| yesterday.set(System.currentTimeMillis() - DateUtils.DAY_IN_MILLIS); |
| Time tomorrow = new Time(); |
| tomorrow.set(System.currentTimeMillis() + DateUtils.DAY_IN_MILLIS); |
| long allDayStart = Utils.createTimeInMillis(0, 0, 0, day, month, year, Time.TIMEZONE_UTC); |
| |
| /* today 10am - 10:30am */ |
| int id4 = at.addAlertRow(4, SCHEDULED, ACCEPTED, 0, |
| Utils.createTimeInMillis(0, 0, 10, day, month, year, Time.getCurrentTimezone()), |
| Utils.createTimeInMillis(0, 30, 10, day, month, year, Time.getCurrentTimezone()), |
| 0); |
| /* today 6am - 6am (0 duration event) */ |
| int id3 = at.addAlertRow(3, SCHEDULED, ACCEPTED, 0, |
| Utils.createTimeInMillis(0, 0, 6, day, month, year, Time.getCurrentTimezone()), |
| Utils.createTimeInMillis(0, 0, 6, day, month, year, Time.getCurrentTimezone()), 0); |
| /* today allDay */ |
| int id2 = at.addAlertRow(2, SCHEDULED, ACCEPTED, 1, allDayStart, |
| allDayStart + DateUtils.HOUR_IN_MILLIS * 24, 0); |
| /* yesterday 11pm - today 7am (multiday event) */ |
| int id1 = at.addAlertRow(1, SCHEDULED, ACCEPTED, 0, |
| Utils.createTimeInMillis(0, 0, 23, yesterday.monthDay, yesterday.month, |
| yesterday.year, Time.getCurrentTimezone()), |
| Utils.createTimeInMillis(0, 0, 7, day, month, year, Time.getCurrentTimezone()), 0); |
| |
| // Test at midnight - next refresh should be 15 min later (15 min into the all |
| // day event). |
| long currentTime = Utils.createTimeInMillis(0, 0, 0, day, month, year, |
| Time.getCurrentTimezone()); |
| alarmMgr.expectAlarmTime(AlarmManager.RTC, currentTime + 15 * DateUtils.MINUTE_IN_MILLIS); |
| ntm.expectTestNotification(4, id1, PRIORITY_HIGH); |
| ntm.expectTestNotification(3, id2, PRIORITY_HIGH); |
| ntm.expectTestNotification(2, id3, PRIORITY_HIGH); |
| ntm.expectTestNotification(1, id4, PRIORITY_HIGH); |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), |
| currentTime, AlertService.MAX_NOTIFICATIONS); |
| ntm.validateNotificationsAndReset(); |
| |
| // Test at 12:30am - next refresh should be 30 min later (1/4 into event 'id1'). |
| currentTime = Utils.createTimeInMillis(0, 30, 0, day, month, year, |
| Time.getCurrentTimezone()); |
| alarmMgr.expectAlarmTime(AlarmManager.RTC, currentTime + 30 * DateUtils.MINUTE_IN_MILLIS); |
| ntm.expectTestNotification(3, id1, PRIORITY_HIGH); |
| ntm.expectTestNotification(2, id3, PRIORITY_HIGH); |
| ntm.expectTestNotification(1, id4, PRIORITY_HIGH); |
| ntm.expectTestNotification(4, id2, PRIORITY_DEFAULT); |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), |
| currentTime, AlertService.MAX_NOTIFICATIONS); |
| ntm.validateNotificationsAndReset(); |
| |
| // Test at 5:55am - next refresh should be 20 min later (15 min after 'id3'). |
| currentTime = Utils.createTimeInMillis(0, 55, 5, day, month, year, |
| Time.getCurrentTimezone()); |
| alarmMgr.expectAlarmTime(AlarmManager.RTC, currentTime + 20 * DateUtils.MINUTE_IN_MILLIS); |
| ntm.expectTestNotification(2, id3, PRIORITY_HIGH); |
| ntm.expectTestNotification(1, id4, PRIORITY_HIGH); |
| ntm.expectTestNotification(3, id2, PRIORITY_DEFAULT); |
| ntm.expectTestNotification(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, id1, PRIORITY_MIN); |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), |
| currentTime, AlertService.MAX_NOTIFICATIONS); |
| ntm.validateNotificationsAndReset(); |
| |
| // Test at 10:14am - next refresh should be 1 min later (15 min into event 'id4'). |
| currentTime = Utils.createTimeInMillis(0, 14, 10, day, month, year, |
| Time.getCurrentTimezone()); |
| alarmMgr.expectAlarmTime(AlarmManager.RTC, currentTime + 1 * DateUtils.MINUTE_IN_MILLIS); |
| ntm.expectTestNotification(1, id4, PRIORITY_HIGH); |
| ntm.expectTestNotification(2, id2, PRIORITY_DEFAULT); |
| ntm.expectTestNotification(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, new int[] {id3, id1}, |
| PRIORITY_MIN); |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), |
| currentTime, AlertService.MAX_NOTIFICATIONS); |
| ntm.validateNotificationsAndReset(); |
| |
| // Test at 10:15am - next refresh should be tomorrow midnight (end of all day event 'id2'). |
| currentTime = Utils.createTimeInMillis(0, 15, 10, day, month, year, |
| Time.getCurrentTimezone()); |
| alarmMgr.expectAlarmTime(AlarmManager.RTC, Utils.createTimeInMillis(0, 0, 23, |
| tomorrow.monthDay, tomorrow.month, tomorrow.year, Time.getCurrentTimezone())); |
| ntm.expectTestNotification(1, id2, PRIORITY_DEFAULT); |
| ntm.expectTestNotification(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, |
| new int[] {id4, id3, id1}, PRIORITY_MIN); |
| AlertService.generateAlerts(mContext, ntm, alarmMgr, prefs, at.getAlertCursor(), |
| currentTime, AlertService.MAX_NOTIFICATIONS); |
| ntm.validateNotificationsAndReset(); |
| } |
| |
| private NotificationInfo createNotificationInfo(long eventId) { |
| return new NotificationInfo("eventName", "location", "description", 100L, 200L, eventId, |
| false, false); |
| } |
| |
| private static long createTimeInMillis(int hour, int minute) { |
| return Utils.createTimeInMillis(0 /* second */, minute, hour, 1 /* day */, 1 /* month */, |
| 2012 /* year */, Time.getCurrentTimezone()); |
| } |
| |
| @SmallTest |
| public void testProcessQuery_skipDeclinedDismissed() { |
| int declinedEventId = 1; |
| int dismissedEventId = 2; |
| int acceptedEventId = 3; |
| long acceptedStartTime = createTimeInMillis(10, 0); |
| long acceptedEndTime = createTimeInMillis(10, 30); |
| |
| AlertsTable at = new AlertsTable(); |
| at.addAlertRow(declinedEventId, SCHEDULED, DECLINED, 0, createTimeInMillis(9, 0), |
| createTimeInMillis(10, 0), 0); |
| at.addAlertRow(dismissedEventId, SCHEDULED, DISMISSED, 0, createTimeInMillis(9, 30), |
| createTimeInMillis(11, 0), 0); |
| at.addAlertRow(acceptedEventId, SCHEDULED, ACCEPTED, 1, acceptedStartTime, acceptedEndTime, |
| 0); |
| |
| ArrayList<NotificationInfo> highPriority = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> mediumPriority = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> lowPriority = new ArrayList<NotificationInfo>(); |
| long currentTime = createTimeInMillis(5, 0); |
| AlertService.processQuery(at.getAlertCursor(), mContext, currentTime, highPriority, |
| mediumPriority, lowPriority); |
| |
| assertEquals(0, lowPriority.size()); |
| assertEquals(0, mediumPriority.size()); |
| assertEquals(1, highPriority.size()); |
| assertEquals(acceptedEventId, highPriority.get(0).eventId); |
| assertEquals(acceptedStartTime, highPriority.get(0).startMillis); |
| assertEquals(acceptedEndTime, highPriority.get(0).endMillis); |
| assertTrue(highPriority.get(0).allDay); |
| } |
| |
| @SmallTest |
| public void testProcessQuery_newAlert() { |
| int scheduledAlertEventId = 1; |
| int firedAlertEventId = 2; |
| |
| AlertsTable at = new AlertsTable(); |
| at.addAlertRow(scheduledAlertEventId, SCHEDULED, ACCEPTED, 0, createTimeInMillis(9, 0), |
| createTimeInMillis(10, 0), 0); |
| at.addAlertRow(firedAlertEventId, FIRED, ACCEPTED, 0, createTimeInMillis(4, 0), |
| createTimeInMillis(10, 30), 0); |
| |
| ArrayList<NotificationInfo> highPriority = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> mediumPriority = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> lowPriority = new ArrayList<NotificationInfo>(); |
| long currentTime = createTimeInMillis(5, 0); |
| AlertService.processQuery(at.getAlertCursor(), mContext, currentTime, highPriority, |
| mediumPriority, lowPriority); |
| |
| assertEquals(0, lowPriority.size()); |
| assertEquals(0, mediumPriority.size()); |
| assertEquals(2, highPriority.size()); |
| assertEquals(scheduledAlertEventId, highPriority.get(0).eventId); |
| assertTrue("newAlert should be ON for scheduled alerts", highPriority.get(0).newAlert); |
| assertEquals(firedAlertEventId, highPriority.get(1).eventId); |
| assertFalse("newAlert should be OFF for fired alerts", highPriority.get(1).newAlert); |
| } |
| |
| @SmallTest |
| public void testProcessQuery_recurringEvent() { |
| int eventId = 1; |
| long earlierStartTime = createTimeInMillis(10, 0); |
| long laterStartTime = createTimeInMillis(11, 0); |
| |
| ArrayList<NotificationInfo> highPriority = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> mediumPriority = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> lowPriority = new ArrayList<NotificationInfo>(); |
| |
| AlertsTable at = new AlertsTable(); |
| at.addAlertRow(eventId, SCHEDULED, ACCEPTED, 0, laterStartTime, |
| laterStartTime + DateUtils.HOUR_IN_MILLIS, 0); |
| at.addAlertRow(eventId, FIRED, ACCEPTED, 0, earlierStartTime, |
| earlierStartTime + DateUtils.HOUR_IN_MILLIS, 0); |
| |
| // Both events in the future: the earliest one should be chosen. |
| long currentTime = earlierStartTime - DateUtils.DAY_IN_MILLIS * 5; |
| AlertService.processQuery(at.getAlertCursor(), mContext, currentTime, highPriority, |
| mediumPriority, lowPriority); |
| assertEquals(0, lowPriority.size()); |
| assertEquals(0, mediumPriority.size()); |
| assertEquals(1, highPriority.size()); |
| assertEquals("Recurring event with earlier start time expected", earlierStartTime, |
| highPriority.get(0).startMillis); |
| |
| // Increment time just past the earlier event: the earlier one should be chosen. |
| highPriority.clear(); |
| currentTime = earlierStartTime + DateUtils.MINUTE_IN_MILLIS * 10; |
| AlertService.processQuery(at.getAlertCursor(), mContext, currentTime, highPriority, |
| mediumPriority, lowPriority); |
| assertEquals(0, lowPriority.size()); |
| assertEquals(0, mediumPriority.size()); |
| assertEquals(1, highPriority.size()); |
| assertEquals("Recurring event with earlier start time expected", earlierStartTime, |
| highPriority.get(0).startMillis); |
| |
| // Increment time to 15 min past the earlier event: the later one should be chosen. |
| highPriority.clear(); |
| currentTime = earlierStartTime + DateUtils.MINUTE_IN_MILLIS * 15; |
| AlertService.processQuery(at.getAlertCursor(), mContext, currentTime, highPriority, |
| mediumPriority, lowPriority); |
| assertEquals(0, lowPriority.size()); |
| assertEquals(0, mediumPriority.size()); |
| assertEquals(1, highPriority.size()); |
| assertEquals("Recurring event with later start time expected", laterStartTime, |
| highPriority.get(0).startMillis); |
| |
| // Both events in the past: the later one should be chosen (in the low priority bucket). |
| highPriority.clear(); |
| currentTime = laterStartTime + DateUtils.DAY_IN_MILLIS * 5; |
| AlertService.processQuery(at.getAlertCursor(), mContext, currentTime, highPriority, |
| mediumPriority, lowPriority); |
| assertEquals(0, highPriority.size()); |
| assertEquals(0, mediumPriority.size()); |
| assertEquals(1, lowPriority.size()); |
| assertEquals("Recurring event with later start time expected", laterStartTime, |
| lowPriority.get(0).startMillis); |
| } |
| |
| @SmallTest |
| public void testProcessQuery_recurringAllDayEvent() { |
| int eventId = 1; |
| long day1 = Utils.createTimeInMillis(0, 0, 0, 1, 5, 2012, Time.TIMEZONE_UTC); |
| long day2 = Utils.createTimeInMillis(0, 0, 0, 2, 5, 2012, Time.TIMEZONE_UTC); |
| |
| ArrayList<NotificationInfo> highPriority = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> mediumPriority = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> lowPriority = new ArrayList<NotificationInfo>(); |
| |
| AlertsTable at = new AlertsTable(); |
| at.addAlertRow(eventId, SCHEDULED, ACCEPTED, 1, day2, day2 + DateUtils.HOUR_IN_MILLIS * 24, |
| 0); |
| at.addAlertRow(eventId, SCHEDULED, ACCEPTED, 1, day1, day1 + DateUtils.HOUR_IN_MILLIS * 24, |
| 0); |
| |
| // Both events in the future: the earliest one should be chosen. |
| long currentTime = day1 - DateUtils.DAY_IN_MILLIS * 3; |
| AlertService.processQuery(at.getAlertCursor(), mContext, currentTime, highPriority, |
| mediumPriority, lowPriority); |
| assertEquals(0, lowPriority.size()); |
| assertEquals(0, mediumPriority.size()); |
| assertEquals(1, highPriority.size()); |
| assertEquals("Recurring event with earlier start time expected", day1, |
| highPriority.get(0).startMillis); |
| |
| // Increment time just past the earlier event (to 12:10am). The earlier one should |
| // be chosen. |
| highPriority.clear(); |
| currentTime = Utils.createTimeInMillis(0, 10, 0, 1, 5, 2012, Time.getCurrentTimezone()); |
| AlertService.processQuery(at.getAlertCursor(), mContext, currentTime, highPriority, |
| mediumPriority, lowPriority); |
| assertEquals(0, lowPriority.size()); |
| assertEquals(0, mediumPriority.size()); |
| assertEquals(1, highPriority.size()); |
| assertEquals("Recurring event with earlier start time expected", day1, |
| highPriority.get(0).startMillis); |
| |
| // Increment time to 15 min past the earlier event: the later one should be chosen. |
| highPriority.clear(); |
| currentTime = Utils.createTimeInMillis(0, 15, 0, 1, 5, 2012, Time.getCurrentTimezone()); |
| AlertService.processQuery(at.getAlertCursor(), mContext, currentTime, highPriority, |
| mediumPriority, lowPriority); |
| assertEquals(0, lowPriority.size()); |
| assertEquals(0, mediumPriority.size()); |
| assertEquals(1, highPriority.size()); |
| assertEquals("Recurring event with earlier start time expected", day2, |
| highPriority.get(0).startMillis); |
| |
| // Both events in the past: the later one should be chosen (in the low priority bucket). |
| highPriority.clear(); |
| currentTime = day2 + DateUtils.DAY_IN_MILLIS * 1; |
| AlertService.processQuery(at.getAlertCursor(), mContext, currentTime, highPriority, |
| mediumPriority, lowPriority); |
| assertEquals(0, highPriority.size()); |
| assertEquals(0, mediumPriority.size()); |
| assertEquals(1, lowPriority.size()); |
| assertEquals("Recurring event with later start time expected", day2, |
| lowPriority.get(0).startMillis); |
| } |
| |
| @SmallTest |
| public void testRedistributeBuckets_withinLimits() throws Exception { |
| int maxNotifications = 3; |
| ArrayList<NotificationInfo> threeItemList = new ArrayList<NotificationInfo>(); |
| threeItemList.add(createNotificationInfo(5)); |
| threeItemList.add(createNotificationInfo(4)); |
| threeItemList.add(createNotificationInfo(3)); |
| |
| // Test when max notifications at high priority. |
| ArrayList<NotificationInfo> high = threeItemList; |
| ArrayList<NotificationInfo> medium = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> low = new ArrayList<NotificationInfo>(); |
| AlertService.redistributeBuckets(high, medium, low, maxNotifications); |
| assertEquals(3, high.size()); |
| assertEquals(0, medium.size()); |
| assertEquals(0, low.size()); |
| |
| // Test when max notifications at medium priority. |
| high = new ArrayList<NotificationInfo>(); |
| medium = threeItemList; |
| low = new ArrayList<NotificationInfo>(); |
| AlertService.redistributeBuckets(high, medium, low, maxNotifications); |
| assertEquals(0, high.size()); |
| assertEquals(3, medium.size()); |
| assertEquals(0, low.size()); |
| |
| // Test when max notifications at high and medium priority |
| high = new ArrayList<NotificationInfo>(threeItemList); |
| medium = new ArrayList<NotificationInfo>(); |
| medium.add(high.remove(1)); |
| low = new ArrayList<NotificationInfo>(); |
| AlertService.redistributeBuckets(high, medium, low, maxNotifications); |
| assertEquals(2, high.size()); |
| assertEquals(1, medium.size()); |
| assertEquals(0, low.size()); |
| } |
| |
| @SmallTest |
| public void testRedistributeBuckets_tooManyHighPriority() throws Exception { |
| ArrayList<NotificationInfo> high = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> medium = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> low = new ArrayList<NotificationInfo>(); |
| high.add(createNotificationInfo(5)); |
| high.add(createNotificationInfo(4)); |
| high.add(createNotificationInfo(3)); |
| high.add(createNotificationInfo(2)); |
| high.add(createNotificationInfo(1)); |
| |
| // Invoke the method under test. |
| int maxNotifications = 3; |
| AlertService.redistributeBuckets(high, medium, low, maxNotifications); |
| |
| // Verify some high priority were kicked out. |
| assertEquals(3, high.size()); |
| assertEquals(3, high.get(0).eventId); |
| assertEquals(2, high.get(1).eventId); |
| assertEquals(1, high.get(2).eventId); |
| |
| // Verify medium priority untouched. |
| assertEquals(0, medium.size()); |
| |
| // Verify the extras went to low priority. |
| assertEquals(2, low.size()); |
| assertEquals(5, low.get(0).eventId); |
| assertEquals(4, low.get(1).eventId); |
| } |
| |
| @SmallTest |
| public void testRedistributeBuckets_tooManyMediumPriority() throws Exception { |
| ArrayList<NotificationInfo> high = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> medium = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> low = new ArrayList<NotificationInfo>(); |
| high.add(createNotificationInfo(5)); |
| high.add(createNotificationInfo(4)); |
| medium.add(createNotificationInfo(3)); |
| medium.add(createNotificationInfo(2)); |
| medium.add(createNotificationInfo(1)); |
| |
| // Invoke the method under test. |
| int maxNotifications = 3; |
| AlertService.redistributeBuckets(high, medium, low, maxNotifications); |
| |
| // Verify high priority untouched. |
| assertEquals(2, high.size()); |
| assertEquals(5, high.get(0).eventId); |
| assertEquals(4, high.get(1).eventId); |
| |
| // Verify some medium priority were kicked out (the ones near the end of the |
| // list). |
| assertEquals(1, medium.size()); |
| assertEquals(3, medium.get(0).eventId); |
| |
| // Verify the extras went to low priority. |
| assertEquals(2, low.size()); |
| assertEquals(2, low.get(0).eventId); |
| assertEquals(1, low.get(1).eventId); |
| } |
| |
| @SmallTest |
| public void testRedistributeBuckets_tooManyHighMediumPriority() throws Exception { |
| ArrayList<NotificationInfo> high = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> medium = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> low = new ArrayList<NotificationInfo>(); |
| high.add(createNotificationInfo(8)); |
| high.add(createNotificationInfo(7)); |
| high.add(createNotificationInfo(6)); |
| high.add(createNotificationInfo(5)); |
| high.add(createNotificationInfo(4)); |
| medium.add(createNotificationInfo(3)); |
| medium.add(createNotificationInfo(2)); |
| medium.add(createNotificationInfo(1)); |
| |
| // Invoke the method under test. |
| int maxNotifications = 3; |
| AlertService.redistributeBuckets(high, medium, low, maxNotifications); |
| |
| // Verify high priority. |
| assertEquals(3, high.size()); |
| assertEquals(6, high.get(0).eventId); |
| assertEquals(5, high.get(1).eventId); |
| assertEquals(4, high.get(2).eventId); |
| |
| // Verify some medium priority. |
| assertEquals(0, medium.size()); |
| |
| // Verify low priority. |
| assertEquals(5, low.size()); |
| assertEquals(8, low.get(0).eventId); |
| assertEquals(7, low.get(1).eventId); |
| assertEquals(3, low.get(2).eventId); |
| assertEquals(2, low.get(3).eventId); |
| assertEquals(1, low.get(4).eventId); |
| } |
| } |
