/*
 * Copyright (C) 2010 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.event;

import android.content.ContentProvider;
import android.content.ContentProviderOperation;
import android.content.ContentProviderResult;
import android.content.ContentValues;
import android.content.res.Resources;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.net.Uri;
import android.provider.CalendarContract.Attendees;
import android.provider.CalendarContract.Events;
import android.provider.CalendarContract.Reminders;
import android.test.AndroidTestCase;
import android.test.mock.MockResources;
import android.test.suitebuilder.annotation.SmallTest;
import android.test.suitebuilder.annotation.Smoke;
import android.text.format.DateUtils;
import android.text.format.Time;
import android.text.util.Rfc822Token;

import com.android.calendar.AbstractCalendarActivity;
import com.android.calendar.AsyncQueryService;
import com.android.calendar.CalendarEventModel;
import com.android.calendar.CalendarEventModel.ReminderEntry;
import com.android.calendar.R;
import com.android.calendar.Utils;
import com.android.common.Rfc822Validator;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.LinkedHashSet;
import java.util.TimeZone;

public class EditEventHelperTest extends AndroidTestCase {
    private static final int TEST_EVENT_ID = 1;
    private static final int TEST_EVENT_INDEX_ID = 0;
    private static final long TEST_END = 1272931200000L;
    private static long TEST_END2 = 1272956400000L;
    private static final long TEST_START = 1272844800000L;
    private static long TEST_START2 = 1272870000000L;
    private static final String LOCAL_TZ = TimeZone.getDefault().getID();

    private static final int SAVE_EVENT_NEW_EVENT = 1;
    private static final int SAVE_EVENT_MOD_RECUR = 2;
    private static final int SAVE_EVENT_RECUR_TO_NORECUR = 3;
    private static final int SAVE_EVENT_NORECUR_TO_RECUR= 4;
    private static final int SAVE_EVENT_MOD_NORECUR = 5;
    private static final int SAVE_EVENT_MOD_INSTANCE = 6;
    private static final int SAVE_EVENT_ALLFOLLOW_TO_NORECUR = 7;
    private static final int SAVE_EVENT_FIRST_TO_NORECUR = 8;
    private static final int SAVE_EVENT_FIRST_TO_RECUR = 9;
    private static final int SAVE_EVENT_ALLFOLLOW_TO_RECUR = 10;

    /* These should match up with EditEventHelper.EVENT_PROJECTION.
     * Note that spaces and commas have been removed to allow for easier sanitation.
     */
    private static String[] TEST_CURSOR_DATA = new String[] {
            Integer.toString(TEST_EVENT_ID), // 0 _id
            "The_Question", // 1 title
            "Evaluating_Life_the_Universe_and_Everything", // 2 description
            "Earth_Mk2", // 3 location
            "1", // 4 All Day
            "0", // 5 Has alarm
            "2", // 6 Calendar id
            "1272844800000", // 7 dtstart, Monday, May 3rd midnight UTC
            "1272931200000", // 8 dtend, Tuesday, May 4th midnight UTC
            "P3652421990D", // 9 duration, (10 million years)
            "UTC", // 10 event timezone
            "FREQ=DAILY;WKST=SU", // 11 rrule
            "unique_per_calendar_stuff", // 12 sync id
            "0", // 13 transparency/availability
            "3", // 14 visibility/access level
            "steve@gmail.com", // 15 owner account
            "1", // 16 has attendee data
            null, //17 originalSyncId
            "organizer@gmail.com", // 18 organizer
            "0", // 19 guest can modify
            "-1", // 20 original id
            "1", // 21 event status
            "-339611", // 22 calendar color
            "-2350809", // 23 event color
            "11" // 24 event color key
    };

    private static final String AUTHORITY_URI = "content://EditEventHelperAuthority/";
    private static final String AUTHORITY = "EditEventHelperAuthority";

    private static final String TEST_ADDRESSES =
            "no good, ad1@email.com, \"First Last\" <first@email.com> (comment), " +
            "one.two.three@email.grue";
    private static final String TEST_ADDRESSES2 =
            "no good, ad1@email.com, \"First Last\" <first@email.com> (comment), " +
            "different@email.bit";
    private static final String TEST_ADDRESSES3 =
            "ad1@email.com, \"First Last\" <first@email.com> (comment), " +
            "different@email.bit";
    private static final String TEST_ADDRESSES4 =
            "ad1@email.com, \"First Last\" <first@email.com> (comment), " +
            "one.two.three@email.grue";


    private static final String TAG = "EEHTest";

    private Rfc822Validator mEmailValidator;
    private CalendarEventModel mModel1;
    private CalendarEventModel mModel2;

    private ContentValues mValues;
    private ContentValues mExpectedValues;

    private EditEventHelper mHelper;
    private AbstractCalendarActivity mActivity;
    private int mCurrentSaveTest = 0;

    @Override
    public void setUp() {
        Time time = new Time(Time.TIMEZONE_UTC);
        time.set(TEST_START);
        time.timezone = LOCAL_TZ;
        TEST_START2 = time.normalize(true);

        time.timezone = Time.TIMEZONE_UTC;
        time.set(TEST_END);
        time.timezone = LOCAL_TZ;
        TEST_END2 = time.normalize(true);

        mEmailValidator = new Rfc822Validator(null);
    }

    private class MockAbsCalendarActivity extends AbstractCalendarActivity {
        @Override
        public AsyncQueryService getAsyncQueryService() {
            if (mService == null) {
                mService = new AsyncQueryService(this) {
                    @Override
                    public void startBatch(int token, Object cookie, String authority,
                            ArrayList<ContentProviderOperation> cpo, long delayMillis) {
                        mockApplyBatch(authority, cpo);
                    }
                };
            }
            return mService;
        }

        @Override
        public Resources getResources() {
            Resources res = new MockResources() {
                @Override
                // The actual selects singular vs plural as well and in the given language
                public String getQuantityString(int id, int quantity) {
                    if (id == R.plurals.Nmins) {
                        return quantity + " mins";
                    }
                    if (id == R.plurals.Nminutes) {
                        return quantity + " minutes";
                    }
                    if (id == R.plurals.Nhours) {
                        return quantity + " hours";
                    }
                    if (id == R.plurals.Ndays) {
                        return quantity + " days";
                    }
                    return id + " " + quantity;
                }
            };
            return res;
        }
    }

    private AbstractCalendarActivity buildTestContext() {
        MockAbsCalendarActivity context = new MockAbsCalendarActivity();
        return context;
    }

    private ContentProviderResult[] mockApplyBatch(String authority,
            ArrayList<ContentProviderOperation> operations) {
        switch (mCurrentSaveTest) {
            case SAVE_EVENT_NEW_EVENT:
                // new recurring event
                verifySaveEventNewEvent(operations);
                break;
            case SAVE_EVENT_MOD_RECUR:
                // update to recurring event
                verifySaveEventModifyRecurring(operations);
                break;
            case SAVE_EVENT_RECUR_TO_NORECUR:
                // replace recurring event with non-recurring event
                verifySaveEventRecurringToNonRecurring(operations);
                break;
            case SAVE_EVENT_NORECUR_TO_RECUR:
                // update non-recurring event with recurring event
                verifySaveEventNonRecurringToRecurring(operations);
                break;
            case SAVE_EVENT_MOD_NORECUR:
                // update to non-recurring
                verifySaveEventUpdateNonRecurring(operations);
                break;
            case SAVE_EVENT_MOD_INSTANCE:
                // update to single instance of recurring event
                verifySaveEventModifySingleInstance(operations);
                break;
            case SAVE_EVENT_ALLFOLLOW_TO_NORECUR:
                // update all following with non-recurring event
                verifySaveEventModifyAllFollowingWithNonRecurring(operations);
                break;
            case SAVE_EVENT_FIRST_TO_NORECUR:
                // update all following with non-recurring event on first event in series
                verifySaveEventModifyAllFollowingFirstWithNonRecurring(operations);
                break;
            case SAVE_EVENT_FIRST_TO_RECUR:
                // update all following with recurring event on first event in series
                verifySaveEventModifyAllFollowingFirstWithRecurring(operations);
                break;
            case SAVE_EVENT_ALLFOLLOW_TO_RECUR:
                // update all following with recurring event on second event in series
                verifySaveEventModifyAllFollowingWithRecurring(operations);
                break;
        }
        return new ContentProviderResult[] {new ContentProviderResult(5)};
    }

    private void addOwnerAttendeeToOps(ArrayList<ContentProviderOperation> expectedOps, int id) {
        addOwnerAttendee();
        ContentProviderOperation.Builder b;
        b = ContentProviderOperation.newInsert(Attendees.CONTENT_URI).withValues(mExpectedValues);
        b.withValueBackReference(Reminders.EVENT_ID, id);
        expectedOps.add(b.build());
    }

    private void addOwnerAttendeeToOps(ArrayList<ContentProviderOperation> expectedOps) {
        addOwnerAttendee();
        mExpectedValues.put(Attendees.EVENT_ID, TEST_EVENT_ID);
        ContentProviderOperation.Builder b;
        b = ContentProviderOperation.newInsert(Attendees.CONTENT_URI).withValues(mExpectedValues);
        expectedOps.add(b.build());
    }


    // Some tests set the time values to one day later, this does that move in the values
    private void moveExpectedTimeValuesForwardOneDay() {
        long dayInMs = EditEventHelper.DAY_IN_SECONDS*1000;
        mExpectedValues.put(Events.DTSTART, TEST_START + dayInMs);
        mExpectedValues.put(Events.DTEND, TEST_END + dayInMs);
    }

    // Duplicates the delete and add for changing a single email address
    private void addAttendeeChangesOps(ArrayList<ContentProviderOperation> expectedOps) {
        ContentProviderOperation.Builder b =
            ContentProviderOperation.newDelete(Attendees.CONTENT_URI);
        b.withSelection(EditEventHelper.ATTENDEES_DELETE_PREFIX + "?)",
                new String[] {"one.two.three@email.grue"});
        expectedOps.add(b.build());

        mExpectedValues.clear();
        mExpectedValues.put(Attendees.ATTENDEE_NAME, "different@email.bit");
        mExpectedValues.put(Attendees.ATTENDEE_EMAIL, "different@email.bit");
        mExpectedValues.put(Attendees.ATTENDEE_RELATIONSHIP, Attendees.RELATIONSHIP_ATTENDEE);
        mExpectedValues.put(Attendees.ATTENDEE_TYPE, Attendees.TYPE_REQUIRED);
        mExpectedValues.put(Attendees.ATTENDEE_STATUS, Attendees.ATTENDEE_STATUS_NONE);
        mExpectedValues.put(Attendees.EVENT_ID, TEST_EVENT_ID);
        b = ContentProviderOperation
                .newInsert(Attendees.CONTENT_URI)
                .withValues(mExpectedValues);
        expectedOps.add(b.build());
    }

    // This is a commonly added set of values
    private void addOwnerAttendee() {
        mExpectedValues.clear();
        mExpectedValues.put(Attendees.ATTENDEE_EMAIL, mModel1.mOwnerAccount);
        mExpectedValues.put(Attendees.ATTENDEE_RELATIONSHIP, Attendees.RELATIONSHIP_ORGANIZER);
        mExpectedValues.put(Attendees.ATTENDEE_TYPE, Attendees.TYPE_REQUIRED);
        mExpectedValues.put(Attendees.ATTENDEE_STATUS, Attendees.ATTENDEE_STATUS_ACCEPTED);
    }

    /** Some tests add all the attendees to the db, the names and emails should match
     * with {@link #TEST_ADDRESSES2} minus the 'no good'
     */
    private void addTestAttendees(ArrayList<ContentProviderOperation> ops,
            boolean newEvent, int id) {
        ContentProviderOperation.Builder b;
        mExpectedValues.clear();
        mExpectedValues.put(Attendees.ATTENDEE_NAME, "ad1@email.com");
        mExpectedValues.put(Attendees.ATTENDEE_EMAIL, "ad1@email.com");
        mExpectedValues.put(Attendees.ATTENDEE_RELATIONSHIP, Attendees.RELATIONSHIP_ATTENDEE);
        mExpectedValues.put(Attendees.ATTENDEE_TYPE, Attendees.TYPE_REQUIRED);
        mExpectedValues.put(Attendees.ATTENDEE_STATUS, Attendees.ATTENDEE_STATUS_NONE);

        if (newEvent) {
            b = ContentProviderOperation
                    .newInsert(Attendees.CONTENT_URI)
                    .withValues(mExpectedValues);
            b.withValueBackReference(Attendees.EVENT_ID, id);
        } else {
            mExpectedValues.put(Attendees.EVENT_ID, id);
            b = ContentProviderOperation
                    .newInsert(Attendees.CONTENT_URI)
                    .withValues(mExpectedValues);
        }
        ops.add(b.build());

        mExpectedValues.clear();
        mExpectedValues.put(Attendees.ATTENDEE_NAME, "First Last");
        mExpectedValues.put(Attendees.ATTENDEE_EMAIL, "first@email.com");
        mExpectedValues.put(Attendees.ATTENDEE_RELATIONSHIP, Attendees.RELATIONSHIP_ATTENDEE);
        mExpectedValues.put(Attendees.ATTENDEE_TYPE, Attendees.TYPE_REQUIRED);
        mExpectedValues.put(Attendees.ATTENDEE_STATUS, Attendees.ATTENDEE_STATUS_NONE);

        if (newEvent) {
            b = ContentProviderOperation
                    .newInsert(Attendees.CONTENT_URI)
                    .withValues(mExpectedValues);
            b.withValueBackReference(Attendees.EVENT_ID, id);
        } else {
            mExpectedValues.put(Attendees.EVENT_ID, id);
            b = ContentProviderOperation
                    .newInsert(Attendees.CONTENT_URI)
                    .withValues(mExpectedValues);
        }
        ops.add(b.build());

        mExpectedValues.clear();
        mExpectedValues.put(Attendees.ATTENDEE_NAME, "different@email.bit");
        mExpectedValues.put(Attendees.ATTENDEE_EMAIL, "different@email.bit");
        mExpectedValues.put(Attendees.ATTENDEE_RELATIONSHIP, Attendees.RELATIONSHIP_ATTENDEE);
        mExpectedValues.put(Attendees.ATTENDEE_TYPE, Attendees.TYPE_REQUIRED);
        mExpectedValues.put(Attendees.ATTENDEE_STATUS, Attendees.ATTENDEE_STATUS_NONE);

        if (newEvent) {
            b = ContentProviderOperation
                    .newInsert(Attendees.CONTENT_URI)
                    .withValues(mExpectedValues);
            b.withValueBackReference(Attendees.EVENT_ID, id);
        } else {
            mExpectedValues.put(Attendees.EVENT_ID, id);
            b = ContentProviderOperation
                    .newInsert(Attendees.CONTENT_URI)
                    .withValues(mExpectedValues);
        }
        ops.add(b.build());
    }

    @Smoke
    @SmallTest
    public void testSaveEventFailures() {
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();

        // saveEvent should return false early if:
        // -it was set to not ok
        // -the model was null
        // -the event doesn't represent the same event as the original event
        // -there's a uri but an original event is not provided
        mHelper.mEventOk = false;
        assertFalse(mHelper.saveEvent(null, null, 0));
        mHelper.mEventOk = true;
        assertFalse(mHelper.saveEvent(null, null, 0));
        mModel2.mId = 13;
        assertFalse(mHelper.saveEvent(mModel1, mModel2, 0));
        mModel2.mId = mModel1.mId;
        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        mModel2.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        assertFalse(mHelper.saveEvent(mModel1, null, 0));
    }

    @Smoke
    @SmallTest
    public void testSaveEventNewEvent() {
        // Creates a model of a new event for saving
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel1.addAttendees(TEST_ADDRESSES2, mEmailValidator);
        mCurrentSaveTest = SAVE_EVENT_NEW_EVENT;

        assertTrue(mHelper.saveEvent(mModel1, null, 0));
    }

    private boolean verifySaveEventNewEvent(ArrayList<ContentProviderOperation> ops) {
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        int br_id = 0;
        mExpectedValues = buildTestValues();
        mExpectedValues.put(Events.HAS_ALARM, 0);
        mExpectedValues.put(Events.HAS_ATTENDEE_DATA, 1);
        ContentProviderOperation.Builder b = ContentProviderOperation
                .newInsert(Events.CONTENT_URI)
                .withValues(mExpectedValues);
        expectedOps.add(b.build());

        // This call has a separate unit test so we'll use it to simplify making the expected vals
        mHelper.saveRemindersWithBackRef(expectedOps, br_id, mModel1.mReminders,
                new ArrayList<ReminderEntry>(), true);

        addOwnerAttendeeToOps(expectedOps, br_id);

        addTestAttendees(expectedOps, true, br_id);

        assertEquals(expectedOps, ops);
        return true;
    }

    @Smoke
    @SmallTest
    public void testSaveEventModifyRecurring() {
        // Creates an original and an updated recurring event model
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel1.addAttendees(TEST_ADDRESSES2, mEmailValidator);

        // Updating a recurring event with a new attendee list
        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        // And a new start time to ensure the time fields aren't removed
        mModel1.mOriginalStart = TEST_START;

        // The original model is assumed correct so drop the no good bit
        mModel2.addAttendees(TEST_ADDRESSES4, null);
        mCurrentSaveTest = SAVE_EVENT_MOD_RECUR;

        assertTrue(mHelper.saveEvent(mModel1, mModel2, EditEventHelper.MODIFY_ALL));
    }

    private boolean verifySaveEventModifyRecurring(ArrayList<ContentProviderOperation> ops) {
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        int br_id = 0;
        mExpectedValues = buildTestValues();
        mExpectedValues.put(Events.HAS_ALARM, 0);
        // This is tested elsewhere, used for convenience here
        mHelper.checkTimeDependentFields(mModel2, mModel1, mExpectedValues,
                EditEventHelper.MODIFY_ALL);

        expectedOps.add(ContentProviderOperation.newUpdate(Uri.parse(mModel1.mUri)).withValues(
                mExpectedValues).build());

        // This call has a separate unit test so we'll use it to simplify making the expected vals
        mHelper.saveReminders(expectedOps, TEST_EVENT_ID, mModel1.mReminders,
                mModel2.mReminders, false);

        addOwnerAttendeeToOps(expectedOps);
        addAttendeeChangesOps(expectedOps);

        assertEquals(expectedOps, ops);
        return true;
    }

    @Smoke
    @SmallTest
    public void testSaveEventRecurringToNonRecurring() {
        // Creates an original and an updated recurring event model
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel1.addAttendees(TEST_ADDRESSES2, mEmailValidator);

        // Updating a recurring event with a new attendee list
        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        // And a new start time to ensure the time fields aren't removed
        mModel1.mOriginalStart = TEST_START;

        // The original model is assumed correct so drop the no good bit
        mModel2.addAttendees(TEST_ADDRESSES4, null);

        // Replace an existing recurring event with a non-recurring event
        mModel1.mRrule = null;
        mModel1.mEnd = TEST_END;
        mCurrentSaveTest = SAVE_EVENT_RECUR_TO_NORECUR;

        assertTrue(mHelper.saveEvent(mModel1, mModel2, EditEventHelper.MODIFY_ALL));
    }

    private boolean verifySaveEventRecurringToNonRecurring(ArrayList<ContentProviderOperation> ops)
            {
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        int id = 0;
        mExpectedValues = buildNonRecurringTestValues();
        mExpectedValues.put(Events.HAS_ALARM, 0);
        // This is tested elsewhere, used for convenience here
        mHelper.checkTimeDependentFields(mModel1, mModel1, mExpectedValues,
                EditEventHelper.MODIFY_ALL);

        expectedOps.add(ContentProviderOperation.newDelete(Uri.parse(mModel1.mUri)).build());
        id = expectedOps.size();
        expectedOps.add(ContentProviderOperation
                        .newInsert(Events.CONTENT_URI)
                        .withValues(mExpectedValues)
                        .build());

        mHelper.saveRemindersWithBackRef(expectedOps, id, mModel1.mReminders,
                mModel2.mReminders, true);

        addOwnerAttendeeToOps(expectedOps, id);

        addTestAttendees(expectedOps, true, id);

        assertEquals(expectedOps, ops);
        return true;
    }

    @Smoke
    @SmallTest
    public void testSaveEventNonRecurringToRecurring() {
        // Creates an original non-recurring and an updated recurring event model
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel1.addAttendees(TEST_ADDRESSES2, mEmailValidator);

        // Updating a recurring event with a new attendee list
        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        // And a new start time to ensure the time fields aren't removed
        mModel1.mOriginalStart = TEST_START;

        // The original model is assumed correct so drop the no good bit
        mModel2.addAttendees(TEST_ADDRESSES4, null);

        mModel2.mRrule = null;
        mModel2.mEnd = TEST_END;
        mCurrentSaveTest = SAVE_EVENT_NORECUR_TO_RECUR;

        assertTrue(mHelper.saveEvent(mModel1, mModel2, EditEventHelper.MODIFY_ALL));
    }

    private boolean verifySaveEventNonRecurringToRecurring(ArrayList<ContentProviderOperation> ops)
            {
        // Changing a non-recurring event to a recurring event should generate the same operations
        // as just modifying a recurring event.
        return verifySaveEventModifyRecurring(ops);
    }

    @Smoke
    @SmallTest
    public void testSaveEventUpdateNonRecurring() {
        // Creates an original non-recurring and an updated recurring event model
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel1.addAttendees(TEST_ADDRESSES2, mEmailValidator);

        // Updating a recurring event with a new attendee list
        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        // And a new start time to ensure the time fields aren't removed
        mModel1.mOriginalStart = TEST_START;

        // The original model is assumed correct so drop the no good bit
        mModel2.addAttendees(TEST_ADDRESSES4, null);

        mModel2.mRrule = null;
        mModel2.mEnd = TEST_END2;
        mModel1.mRrule = null;
        mModel1.mEnd = TEST_END2;
        mCurrentSaveTest = SAVE_EVENT_MOD_NORECUR;

        assertTrue(mHelper.saveEvent(mModel1, mModel2, EditEventHelper.MODIFY_ALL));
    }

    private boolean verifySaveEventUpdateNonRecurring(ArrayList<ContentProviderOperation> ops) {
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        int id = TEST_EVENT_ID;
        mExpectedValues = buildNonRecurringTestValues();
        mExpectedValues.put(Events.HAS_ALARM, 0);
        // This is tested elsewhere, used for convenience here
        mHelper.checkTimeDependentFields(mModel1, mModel1, mExpectedValues,
                EditEventHelper.MODIFY_ALL);
        expectedOps.add(ContentProviderOperation.newUpdate(Uri.parse(mModel1.mUri)).withValues(
                mExpectedValues).build());
        // This call has a separate unit test so we'll use it to simplify making the expected vals
        mHelper.saveReminders(expectedOps, TEST_EVENT_ID, mModel1.mReminders,
                mModel2.mReminders, false);
        addOwnerAttendeeToOps(expectedOps);
        addAttendeeChangesOps(expectedOps);

        assertEquals(expectedOps, ops);
        return true;
    }

    @Smoke
    @SmallTest
    public void testSaveEventModifySingleInstance() {
        // Creates an original non-recurring and an updated recurring event model
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel1.addAttendees(TEST_ADDRESSES2, mEmailValidator);

        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        // And a new start time to ensure the time fields aren't removed
        mModel1.mOriginalStart = TEST_START;

        // The original model is assumed correct so drop the no good bit
        mModel2.addAttendees(TEST_ADDRESSES4, null);

        // Modify the second instance of the event
        long dayInMs = EditEventHelper.DAY_IN_SECONDS*1000;
        mModel1.mRrule = null;
        mModel1.mEnd = TEST_END + dayInMs;
        mModel1.mStart += dayInMs;
        mModel1.mOriginalStart = mModel1.mStart;

        mCurrentSaveTest = SAVE_EVENT_MOD_INSTANCE;
        // Only modify this instance
        assertTrue(mHelper.saveEvent(mModel1, mModel2, EditEventHelper.MODIFY_SELECTED));
    }

    private boolean verifySaveEventModifySingleInstance(ArrayList<ContentProviderOperation> ops) {
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        int id = 0;
        mExpectedValues = buildNonRecurringTestValues();
        mExpectedValues.put(Events.HAS_ALARM, 0);
        // This is tested elsewhere, used for convenience here
        mHelper.checkTimeDependentFields(mModel1, mModel1, mExpectedValues,
                EditEventHelper.MODIFY_ALL);

        moveExpectedTimeValuesForwardOneDay();
        mExpectedValues.put(Events.ORIGINAL_SYNC_ID, mModel2.mSyncId);
        mExpectedValues.put(Events.ORIGINAL_INSTANCE_TIME, mModel1.mOriginalStart);
        mExpectedValues.put(Events.ORIGINAL_ALL_DAY, 1);

        ContentProviderOperation.Builder b = ContentProviderOperation
                .newInsert(Events.CONTENT_URI)
                .withValues(mExpectedValues);
        expectedOps.add(b.build());

        mHelper.saveRemindersWithBackRef(expectedOps, id, mModel1.mReminders,
                mModel2.mReminders, true);

        addOwnerAttendeeToOps(expectedOps, id);

        addTestAttendees(expectedOps, true, id);

        assertEquals(expectedOps, ops);
        return true;
    }

    @Smoke
    @SmallTest
    public void testSaveEventModifyAllFollowingWithNonRecurring() {
        // Creates an original and an updated recurring event model. The update starts on the 2nd
        // instance of the original.
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel1.addAttendees(TEST_ADDRESSES2, mEmailValidator);

        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        mModel2.mUri = (AUTHORITY_URI + TEST_EVENT_ID);

        // The original model is assumed correct so drop the no good bit
        mModel2.addAttendees(TEST_ADDRESSES4, null);

        // Modify the second instance of the event
        long dayInMs = EditEventHelper.DAY_IN_SECONDS*1000;
        mModel1.mRrule = null;
        mModel1.mEnd = TEST_END + dayInMs;
        mModel1.mStart += dayInMs;
        mModel1.mOriginalStart = mModel1.mStart;

        mCurrentSaveTest = SAVE_EVENT_ALLFOLLOW_TO_NORECUR;
        // Only modify this instance
        assertTrue(mHelper.saveEvent(mModel1, mModel2, EditEventHelper.MODIFY_ALL_FOLLOWING));
    }

    private boolean verifySaveEventModifyAllFollowingWithNonRecurring(
            ArrayList<ContentProviderOperation> ops) {
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        int id = 0;
        mExpectedValues = buildNonRecurringTestValues();
        mExpectedValues.put(Events.HAS_ALARM, 0);
        moveExpectedTimeValuesForwardOneDay();
        // This has a separate test
        mHelper.updatePastEvents(expectedOps, mModel2, mModel1.mOriginalStart);
        id = expectedOps.size();
        expectedOps.add(ContentProviderOperation
                .newInsert(Events.CONTENT_URI)
                .withValues(mExpectedValues)
                .build());

        mHelper.saveRemindersWithBackRef(expectedOps, id, mModel1.mReminders,
                mModel2.mReminders, true);

        addOwnerAttendeeToOps(expectedOps, id);

        addTestAttendees(expectedOps, true, id);

        assertEquals(expectedOps, ops);
        return true;
    }

    @Smoke
    @SmallTest
    public void testSaveEventModifyAllFollowingFirstWithNonRecurring() {
        // Creates an original recurring and an updated non-recurring event model for the first
        // instance. This should replace the original event with a non-recurring event.
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel1.addAttendees(TEST_ADDRESSES2, mEmailValidator);

        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        mModel2.mUri = mModel1.mUri;
        // And a new start time to ensure the time fields aren't removed
        mModel1.mOriginalStart = TEST_START;

        // The original model is assumed correct so drop the no good bit
        mModel2.addAttendees(TEST_ADDRESSES3, null);

        // Move the event one day but keep original start set to the first instance
        long dayInMs = EditEventHelper.DAY_IN_SECONDS*1000;
        mModel1.mRrule = null;
        mModel1.mEnd = TEST_END + dayInMs;
        mModel1.mStart += dayInMs;

        mCurrentSaveTest = SAVE_EVENT_FIRST_TO_NORECUR;
        // Only modify this instance
        assertTrue(mHelper.saveEvent(mModel1, mModel2, EditEventHelper.MODIFY_ALL_FOLLOWING));
    }

    private boolean verifySaveEventModifyAllFollowingFirstWithNonRecurring(
            ArrayList<ContentProviderOperation> ops) {

        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        int id = 0;
        mExpectedValues = buildNonRecurringTestValues();
        mExpectedValues.put(Events.HAS_ALARM, 0);
        moveExpectedTimeValuesForwardOneDay();

        expectedOps.add(ContentProviderOperation.newDelete(Uri.parse(mModel1.mUri)).build());
        id = expectedOps.size();
        expectedOps.add(ContentProviderOperation
                        .newInsert(Events.CONTENT_URI)
                        .withValues(mExpectedValues)
                        .build());

        mHelper.saveRemindersWithBackRef(expectedOps, id, mModel1.mReminders,
                mModel2.mReminders, true);

        addOwnerAttendeeToOps(expectedOps, id);

        addTestAttendees(expectedOps, true, id);

        assertEquals(expectedOps, ops);
        return true;
    }

    @Smoke
    @SmallTest
    public void testSaveEventModifyAllFollowingFirstWithRecurring() {
        // Creates an original recurring and an updated recurring event model for the first instance
        // This should replace the original event with a new recurrence
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel1.addAttendees(TEST_ADDRESSES2, mEmailValidator);

        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        mModel2.mUri = mModel1.mUri;
        // And a new start time to ensure the time fields aren't removed
        mModel1.mOriginalStart = TEST_START;

        // The original model is assumed correct so drop the no good bit
        mModel2.addAttendees(TEST_ADDRESSES4, null);

        // Move the event one day but keep original start set to the first instance
        long dayInMs = EditEventHelper.DAY_IN_SECONDS*1000;
        mModel1.mStart += dayInMs;

        mCurrentSaveTest = SAVE_EVENT_FIRST_TO_RECUR;
        // Only modify this instance
        assertTrue(mHelper.saveEvent(mModel1, mModel2, EditEventHelper.MODIFY_ALL_FOLLOWING));
    }

    private boolean verifySaveEventModifyAllFollowingFirstWithRecurring(
            ArrayList<ContentProviderOperation> ops) {
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        int br_id = 0;
        mExpectedValues = buildTestValues();
        mExpectedValues.put(Events.HAS_ALARM, 0);
        moveExpectedTimeValuesForwardOneDay();
        mExpectedValues.put(Events.DTEND, (Long)null);
        // This is tested elsewhere, used for convenience here
        mHelper.checkTimeDependentFields(mModel2, mModel1, mExpectedValues,
                EditEventHelper.MODIFY_ALL_FOLLOWING);

        expectedOps.add(ContentProviderOperation.newUpdate(Uri.parse(mModel1.mUri)).withValues(
                mExpectedValues).build());

        // This call has a separate unit test so we'll use it to simplify making the expected vals
        mHelper.saveReminders(expectedOps, TEST_EVENT_ID, mModel1.mReminders,
                mModel2.mReminders, true);

        addOwnerAttendeeToOps(expectedOps);
        addAttendeeChangesOps(expectedOps);

        assertEquals(expectedOps, ops);
        return true;
    }

    @Smoke
    @SmallTest
    public void testSaveEventModifyAllFollowingWithRecurring() {
        // Creates an original recurring and an updated recurring event model
        // for the second instance. This should end the original recurrence and add a new
        // recurrence.
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel1.addAttendees(TEST_ADDRESSES2, mEmailValidator);

        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        mModel2.mUri = (AUTHORITY_URI + TEST_EVENT_ID);

        // The original model is assumed correct so drop the no good bit
        mModel2.addAttendees(TEST_ADDRESSES4, null);

        // Move the event one day and the original start so it references the second instance
        long dayInMs = EditEventHelper.DAY_IN_SECONDS*1000;
        mModel1.mStart += dayInMs;
        mModel1.mOriginalStart = mModel1.mStart;

        mCurrentSaveTest = SAVE_EVENT_ALLFOLLOW_TO_RECUR;
        // Only modify this instance
        assertTrue(mHelper.saveEvent(mModel1, mModel2, EditEventHelper.MODIFY_ALL_FOLLOWING));
    }

    private boolean verifySaveEventModifyAllFollowingWithRecurring(
            ArrayList<ContentProviderOperation> ops) {
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        int br_id = 0;
        mExpectedValues = buildTestValues();
        mExpectedValues.put(Events.HAS_ALARM, 0);
        moveExpectedTimeValuesForwardOneDay();
        mExpectedValues.put(Events.DTEND, (Long)null);
        // This is tested elsewhere, used for convenience here
        mHelper.updatePastEvents(expectedOps, mModel2, mModel1.mOriginalStart);

        br_id = expectedOps.size();
        expectedOps.add(ContentProviderOperation
                .newInsert(Events.CONTENT_URI)
                .withValues(mExpectedValues)
                .build());

        // This call has a separate unit test so we'll use it to simplify making the expected vals
        mHelper.saveRemindersWithBackRef(expectedOps, br_id, mModel1.mReminders,
                mModel2.mReminders, true);

        addOwnerAttendeeToOps(expectedOps, br_id);

        addTestAttendees(expectedOps, true, br_id);

        assertEquals(expectedOps, ops);
        return true;
    }

    @Smoke
    @SmallTest
    public void testGetAddressesFromList() {
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        LinkedHashSet<Rfc822Token> expected = new LinkedHashSet<Rfc822Token>();
        expected.add(new Rfc822Token(null, "ad1@email.com", ""));
        expected.add(new Rfc822Token("First Last", "first@email.com", "comment"));
        expected.add(new Rfc822Token(null, "one.two.three@email.grue", ""));

        LinkedHashSet<Rfc822Token> actual = mHelper.getAddressesFromList(TEST_ADDRESSES,
                new Rfc822Validator(null));
        assertEquals(expected, actual);
    }

    @Smoke
    @SmallTest
    public void testConstructDefaultStartTime() {
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        long now = 0;
        long expected = now + 30 * DateUtils.MINUTE_IN_MILLIS;
        assertEquals(expected, mHelper.constructDefaultStartTime(now));

        // 2:00 -> 2:30
        now = 1262340000000L; // Fri Jan 01 2010 02:00:00 GMT-0800 (PST)
        expected = now + 30 * DateUtils.MINUTE_IN_MILLIS;
        assertEquals(expected, mHelper.constructDefaultStartTime(now));

        // 2:01 -> 2:30
        now += DateUtils.MINUTE_IN_MILLIS;
        assertEquals(expected, mHelper.constructDefaultStartTime(now));

        // 2:02 -> 2:30
        now += DateUtils.MINUTE_IN_MILLIS;
        assertEquals(expected, mHelper.constructDefaultStartTime(now));

        // 2:32 -> 3:00
        now += 30 * DateUtils.MINUTE_IN_MILLIS;
        expected += 30 * DateUtils.MINUTE_IN_MILLIS;
        assertEquals(expected, mHelper.constructDefaultStartTime(now));

        // 2:33 -> 3:00
        now += DateUtils.MINUTE_IN_MILLIS;
        assertEquals(expected, mHelper.constructDefaultStartTime(now));

    }

    @Smoke
    @SmallTest
    public void testConstructDefaultEndTime() {
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        long start = 1262340000000L;
        long expected = start + DateUtils.HOUR_IN_MILLIS;
        assertEquals(expected, mHelper.constructDefaultEndTime(start));
    }

    @Smoke
    @SmallTest
    public void testCheckTimeDependentFieldsNoChanges() {
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel2.mRrule = null;

        mValues = buildTestValues();
        mExpectedValues = buildTestValues();

        // if any time/recurrence vals are different but there's no new rrule it
        // shouldn't change
        mHelper.checkTimeDependentFields(mModel1, mModel2, mValues, EditEventHelper.MODIFY_ALL);
        assertEquals(mExpectedValues, mValues);

        // also, if vals are different and it's not modifying all it shouldn't
        // change.
        mModel2.mRrule = "something else";
        mHelper.checkTimeDependentFields(mModel1, mModel2, mValues,
                EditEventHelper.MODIFY_SELECTED);
        assertEquals(mExpectedValues, mValues);

        // if vals changed and modify all is selected dtstart should be updated
        // by the difference
        // between originalStart and start
        mModel2.mOriginalStart = mModel2.mStart + 60000; // set the old time to
                                                         // one minute later
        mModel2.mStart += 120000; // move the event another 1 minute.

        // shouldn't change for an allday event
        // expectedVals.put(Events.DTSTART, mModel1.mStart + 60000); // should
        // now be 1 minute later
        // dtstart2 shouldn't change since it gets rezeroed in the local
        // timezone for allDay events

        mHelper.checkTimeDependentFields(mModel1, mModel2, mValues,
                EditEventHelper.MODIFY_SELECTED);
        assertEquals(mExpectedValues, mValues);
    }

    @Smoke
    @SmallTest
    public void testCheckTimeDependentFieldsChanges() {
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mModel1 = buildTestModel();
        mModel2 = buildTestModel();
        mModel2.mRrule = null;

        mValues = buildTestValues();
        mExpectedValues = buildTestValues();

        // if all the time values are the same it should remove them from vals
        mModel2.mRrule = mModel1.mRrule;
        mModel2.mStart = mModel1.mStart;
        mModel2.mOriginalStart = mModel2.mStart;

        mExpectedValues.remove(Events.DTSTART);
        mExpectedValues.remove(Events.DTEND);
        mExpectedValues.remove(Events.DURATION);
        mExpectedValues.remove(Events.ALL_DAY);
        mExpectedValues.remove(Events.RRULE);
        mExpectedValues.remove(Events.EVENT_TIMEZONE);

        mHelper.checkTimeDependentFields(mModel1, mModel2, mValues,
                EditEventHelper.MODIFY_SELECTED);
        assertEquals(mExpectedValues, mValues);

    }

    @Smoke
    @SmallTest
    public void testUpdatePastEvents() {
        ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        long initialBeginTime = 1472864400000L; // Sep 3, 2016, 12AM UTC time
        mValues = new ContentValues();

        mModel1 = buildTestModel();
        mModel1.mUri = (AUTHORITY_URI + TEST_EVENT_ID);
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);

        mValues.put(Events.RRULE, "FREQ=DAILY;UNTIL=20160903;WKST=SU"); // yyyymmddThhmmssZ
        mValues.put(Events.DTSTART, TEST_START);

        ContentProviderOperation.Builder b = ContentProviderOperation.newUpdate(
                Uri.parse(mModel1.mUri)).withValues(mValues);
        expectedOps.add(b.build());

        mHelper.updatePastEvents(ops, mModel1, initialBeginTime);
        assertEquals(expectedOps, ops);

        mModel1.mAllDay = false;

        mValues.put(Events.RRULE, "FREQ=DAILY;UNTIL=20160903T005959Z;WKST=SU"); // yyyymmddThhmmssZ

        expectedOps.clear();
        b = ContentProviderOperation.newUpdate(Uri.parse(mModel1.mUri)).withValues(mValues);
        expectedOps.add(b.build());

        ops.clear();
        mHelper.updatePastEvents(ops, mModel1, initialBeginTime);
        assertEquals(expectedOps, ops);
    }

    @Smoke
    @SmallTest
    public void testConstructReminderLabel() {
        mActivity = buildTestContext();

        String label = EventViewUtils.constructReminderLabel(mActivity, 35, true);
        assertEquals("35 mins", label);

        label = EventViewUtils.constructReminderLabel(mActivity, 72, false);
        assertEquals("72 minutes", label);

        label = EventViewUtils.constructReminderLabel(mActivity, 60, true);
        assertEquals("1 hours", label);

        label = EventViewUtils.constructReminderLabel(mActivity, 60 * 48, true);
        assertEquals("2 days", label);
    }

    @Smoke
    @SmallTest
    public void testIsSameEvent() {
        mModel1 = new CalendarEventModel();
        mModel2 = new CalendarEventModel();

        mModel1.mId = 1;
        mModel1.mCalendarId = 1;
        mModel2.mId = 1;
        mModel2.mCalendarId = 1;

        // considered the same if the event and calendar ids both match
        assertTrue(EditEventHelper.isSameEvent(mModel1, mModel2));

        mModel2.mId = 2;
        assertFalse(EditEventHelper.isSameEvent(mModel1, mModel2));

        mModel2.mId = 1;
        mModel2.mCalendarId = 2;
        assertFalse(EditEventHelper.isSameEvent(mModel1, mModel2));
    }

    @Smoke
    @SmallTest
    public void testSaveReminders() {
        ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        long eventId = TEST_EVENT_ID;
        ArrayList<ReminderEntry> reminders = new ArrayList<ReminderEntry>();
        ArrayList<ReminderEntry> originalReminders = new ArrayList<ReminderEntry>();
        boolean forceSave = true;
        boolean result;
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);
        assertNotNull(mHelper);

        // First test forcing a delete with no reminders.
        String where = Reminders.EVENT_ID + "=?";
        String[] args = new String[] {Long.toString(eventId)};
        ContentProviderOperation.Builder b =
                ContentProviderOperation.newDelete(Reminders.CONTENT_URI);
        b.withSelection(where, args);
        expectedOps.add(b.build());

        result = mHelper.saveReminders(ops, eventId, reminders, originalReminders, forceSave);
        assertTrue(result);
        assertEquals(expectedOps, ops);

        // Now test calling save with identical reminders and no forcing
        reminders.add(ReminderEntry.valueOf(5));
        reminders.add(ReminderEntry.valueOf(10));
        reminders.add(ReminderEntry.valueOf(15));

        originalReminders.add(ReminderEntry.valueOf(5));
        originalReminders.add(ReminderEntry.valueOf(10));
        originalReminders.add(ReminderEntry.valueOf(15));

        forceSave = false;

        ops.clear();

        // Should fail to create any ops since nothing changed
        result = mHelper.saveReminders(ops, eventId, reminders, originalReminders, forceSave);
        assertFalse(result);
        assertEquals(0, ops.size());

        //Now test adding a single reminder
        originalReminders.remove(2);

        addExpectedMinutes(expectedOps);

        result = mHelper.saveReminders(ops, eventId, reminders, originalReminders, forceSave);
        assertTrue(result);
        assertEquals(expectedOps, ops);
    }

    @Smoke
    @SmallTest
    public void testSaveRemindersWithBackRef() {
        ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();
        ArrayList<ContentProviderOperation> expectedOps = new ArrayList<ContentProviderOperation>();
        long eventId = TEST_EVENT_ID;
        ArrayList<ReminderEntry> reminders = new ArrayList<ReminderEntry>();
        ArrayList<ReminderEntry> originalReminders = new ArrayList<ReminderEntry>();
        boolean forceSave = true;
        boolean result;
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);
        assertNotNull(mHelper);

        // First test forcing a delete with no reminders.
        ContentProviderOperation.Builder b =
                ContentProviderOperation.newDelete(Reminders.CONTENT_URI);
        b.withSelection(Reminders.EVENT_ID + "=?", new String[1]);
        b.withSelectionBackReference(0, TEST_EVENT_INDEX_ID);
        expectedOps.add(b.build());

        result =
                mHelper.saveRemindersWithBackRef(ops, TEST_EVENT_INDEX_ID, reminders,
                        originalReminders, forceSave);
        assertTrue(result);
        assertEquals(expectedOps, ops);

        // Now test calling save with identical reminders and no forcing
        reminders.add(ReminderEntry.valueOf(5));
        reminders.add(ReminderEntry.valueOf(10));
        reminders.add(ReminderEntry.valueOf(15));

        originalReminders.add(ReminderEntry.valueOf(5));
        originalReminders.add(ReminderEntry.valueOf(10));
        originalReminders.add(ReminderEntry.valueOf(15));

        forceSave = false;

        ops.clear();

        result = mHelper.saveRemindersWithBackRef(ops, ops.size(), reminders, originalReminders,
                        forceSave);
        assertFalse(result);
        assertEquals(0, ops.size());

        //Now test adding a single reminder
        originalReminders.remove(2);

        addExpectedMinutesWithBackRef(expectedOps);

        result = mHelper.saveRemindersWithBackRef(ops, ops.size(), reminders, originalReminders,
                        forceSave);
        assertTrue(result);
        assertEquals(expectedOps, ops);
    }

    @Smoke
    @SmallTest
    public void testIsFirstEventInSeries() {
        mModel1 = new CalendarEventModel();
        mModel2 = new CalendarEventModel();

        // It's considered the first event if the original start of the new model matches the
        // start of the old model
        mModel1.mOriginalStart = 100;
        mModel1.mStart = 200;
        mModel2.mOriginalStart = 100;
        mModel2.mStart = 100;

        assertTrue(EditEventHelper.isFirstEventInSeries(mModel1, mModel2));

        mModel1.mOriginalStart = 80;
        assertFalse(EditEventHelper.isFirstEventInSeries(mModel1, mModel2));
    }

    @Smoke
    @SmallTest
    public void testAddRecurrenceRule() {
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);
        mValues = new ContentValues();
        mExpectedValues = new ContentValues();
        mModel1 = new CalendarEventModel();

        mExpectedValues.put(Events.RRULE, "Weekly, Monday");
        mExpectedValues.put(Events.DURATION, "P60S");
        mExpectedValues.put(Events.DTEND, (Long) null);

        mModel1.mRrule = "Weekly, Monday";
        mModel1.mStart = 1;
        mModel1.mEnd = 60001;
        mModel1.mAllDay = false;

        mHelper.addRecurrenceRule(mValues, mModel1);
        assertEquals(mExpectedValues, mValues);

        mExpectedValues.put(Events.DURATION, "P1D");

        mModel1.mAllDay = true;
        mValues.clear();

        mHelper.addRecurrenceRule(mValues, mModel1);
        assertEquals(mExpectedValues, mValues);

    }

    @Smoke
    @SmallTest
    public void testUpdateRecurrenceRule() {
        int selection = EditEventHelper.DOES_NOT_REPEAT;
        int weekStart = Calendar.SUNDAY;
        mModel1 = new CalendarEventModel();
        mModel1.mTimezone = Time.TIMEZONE_UTC;
        mModel1.mStart = 1272665741000L; // Fri, April 30th ~ 3:17PM

        mModel1.mRrule = "This should go away";

        EditEventHelper.updateRecurrenceRule(selection, mModel1, weekStart);
        assertNull(mModel1.mRrule);

        mModel1.mRrule = "This shouldn't change";
        selection = EditEventHelper.REPEATS_CUSTOM;

        EditEventHelper.updateRecurrenceRule(selection, mModel1, weekStart);
        assertEquals("This shouldn't change", mModel1.mRrule);

        selection = EditEventHelper.REPEATS_DAILY;

        EditEventHelper.updateRecurrenceRule(selection, mModel1, weekStart);
        assertEquals("FREQ=DAILY;WKST=SU", mModel1.mRrule);

        selection = EditEventHelper.REPEATS_EVERY_WEEKDAY;

        EditEventHelper.updateRecurrenceRule(selection, mModel1, weekStart);
        assertEquals("FREQ=WEEKLY;WKST=SU;BYDAY=MO,TU,WE,TH,FR", mModel1.mRrule);

        selection = EditEventHelper.REPEATS_WEEKLY_ON_DAY;

        EditEventHelper.updateRecurrenceRule(selection, mModel1, weekStart);
        assertEquals("FREQ=WEEKLY;WKST=SU;BYDAY=FR", mModel1.mRrule);

        selection = EditEventHelper.REPEATS_MONTHLY_ON_DAY;

        EditEventHelper.updateRecurrenceRule(selection, mModel1, weekStart);
        assertEquals("FREQ=MONTHLY;WKST=SU;BYMONTHDAY=30", mModel1.mRrule);

        selection = EditEventHelper.REPEATS_MONTHLY_ON_DAY_COUNT;

        EditEventHelper.updateRecurrenceRule(selection, mModel1, weekStart);
        assertEquals("FREQ=MONTHLY;WKST=SU;BYDAY=-1FR", mModel1.mRrule);

        selection = EditEventHelper.REPEATS_YEARLY;

        EditEventHelper.updateRecurrenceRule(selection, mModel1, weekStart);
        assertEquals("FREQ=YEARLY;WKST=SU", mModel1.mRrule);
    }

    @Smoke
    @SmallTest
    public void testSetModelFromCursor() {
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);
        MatrixCursor c = new MatrixCursor(EditEventHelper.EVENT_PROJECTION);
        c.addRow(TEST_CURSOR_DATA);

        mModel1 = new CalendarEventModel();
        mModel2 = buildTestModel();

        EditEventHelper.setModelFromCursor(mModel1, c);
        assertEquals(mModel1, mModel2);

        TEST_CURSOR_DATA[EditEventHelper.EVENT_INDEX_ALL_DAY] = "0";
        c.close();
        c = new MatrixCursor(EditEventHelper.EVENT_PROJECTION);
        c.addRow(TEST_CURSOR_DATA);

        mModel2.mAllDay = false;
        mModel2.mStart = TEST_START; // UTC time

        EditEventHelper.setModelFromCursor(mModel1, c);
        assertEquals(mModel1, mModel2);

        TEST_CURSOR_DATA[EditEventHelper.EVENT_INDEX_RRULE] = null;
        c.close();
        c = new MatrixCursor(EditEventHelper.EVENT_PROJECTION);
        c.addRow(TEST_CURSOR_DATA);

        mModel2.mRrule = null;
        mModel2.mEnd = TEST_END;
        mModel2.mDuration = null;

        EditEventHelper.setModelFromCursor(mModel1, c);
        assertEquals(mModel1, mModel2);

        TEST_CURSOR_DATA[EditEventHelper.EVENT_INDEX_ALL_DAY] = "1";
        c.close();
        c = new MatrixCursor(EditEventHelper.EVENT_PROJECTION);
        c.addRow(TEST_CURSOR_DATA);

        mModel2.mAllDay = true;
        mModel2.mStart = TEST_START; // Monday, May 3rd, midnight
        mModel2.mEnd = TEST_END; // Tuesday, May 4th, midnight

        EditEventHelper.setModelFromCursor(mModel1, c);
        assertEquals(mModel1, mModel2);
    }

    @Smoke
    @SmallTest
    public void testGetContentValuesFromModel() {
        mActivity = buildTestContext();
        mHelper = new EditEventHelper(mActivity, null);
        mExpectedValues = buildTestValues();
        mModel1 = buildTestModel();

        ContentValues values = mHelper.getContentValuesFromModel(mModel1);
        assertEquals(mExpectedValues, values);

        mModel1.mRrule = null;
        mModel1.mEnd = TEST_END;

        mExpectedValues.put(Events.RRULE, (String) null);
        mExpectedValues.put(Events.DURATION, (String) null);
        mExpectedValues.put(Events.DTEND, TEST_END); // UTC time

        values = mHelper.getContentValuesFromModel(mModel1);
        assertEquals(mExpectedValues, values);

        mModel1.mAllDay = false;

        mExpectedValues.put(Events.ALL_DAY, 0);
        mExpectedValues.put(Events.DTSTART, TEST_START);
        mExpectedValues.put(Events.DTEND, TEST_END);
        // not an allday event so timezone isn't modified
        mExpectedValues.put(Events.EVENT_TIMEZONE, "UTC");

        values = mHelper.getContentValuesFromModel(mModel1);
        assertEquals(mExpectedValues, values);
    }

    @Smoke
    @SmallTest
    public void testExtractDomain() {
        String domain = EditEventHelper.extractDomain("test.email@gmail.com");
        assertEquals("gmail.com", domain);

        domain = EditEventHelper.extractDomain("bademail.no#$%at symbol");
        assertNull(domain);
    }

    private void addExpectedMinutes(ArrayList<ContentProviderOperation> expectedOps) {
        ContentProviderOperation.Builder b;
        mValues = new ContentValues();

        mValues.clear();
        mValues.put(Reminders.MINUTES, 5);
        mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
        mValues.put(Reminders.EVENT_ID, TEST_EVENT_ID);
        b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
        expectedOps.add(b.build());

        mValues.clear();
        mValues.put(Reminders.MINUTES, 10);
        mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
        mValues.put(Reminders.EVENT_ID, TEST_EVENT_ID);
        b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
        expectedOps.add(b.build());

        mValues.clear();
        mValues.put(Reminders.MINUTES, 15);
        mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
        mValues.put(Reminders.EVENT_ID, TEST_EVENT_ID);
        b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
        expectedOps.add(b.build());
    }

    private void addExpectedMinutesWithBackRef(ArrayList<ContentProviderOperation> expectedOps) {
        ContentProviderOperation.Builder b;
        mValues = new ContentValues();

        mValues.clear();
        mValues.put(Reminders.MINUTES, 5);
        mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
        b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
        b.withValueBackReference(Reminders.EVENT_ID, TEST_EVENT_INDEX_ID);
        expectedOps.add(b.build());

        mValues.clear();
        mValues.put(Reminders.MINUTES, 10);
        mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
        b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
        b.withValueBackReference(Reminders.EVENT_ID, TEST_EVENT_INDEX_ID);
        expectedOps.add(b.build());

        mValues.clear();
        mValues.put(Reminders.MINUTES, 15);
        mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
        b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
        b.withValueBackReference(Reminders.EVENT_ID, TEST_EVENT_INDEX_ID);
        expectedOps.add(b.build());
    }

    private static void assertEquals(ArrayList<ContentProviderOperation> expected,
            ArrayList<ContentProviderOperation> actual) {
        if (expected == null) {
            assertNull(actual);
        }
        int size = expected.size();

        assertEquals(size, actual.size());

        for (int i = 0; i < size; i++) {
            assertTrue("At index " + i + ", expected:\n" + String.valueOf(expected.get(i)) +
                    "\nActual:\n" + String.valueOf(actual.get(i)),
                    cpoEquals(expected.get(i), actual.get(i)));
        }

    }

    private static boolean cpoEquals(ContentProviderOperation cpo1, ContentProviderOperation cpo2) {
        if (cpo1 == null && cpo2 != null) {
            return false;
        }
        if (cpo1 == cpo2) {
            return true;
        }
        if (cpo2 == null) {
            return false;
        }

        // It turns out we can't trust the toString() of the ContentProviderOperations to be
        // consistent, so we have to do the comparison manually.
        //
        // Start by splitting by commas, so that we can compare each key-value pair individually.
        String[] operations1 = cpo1.toString().split(",");
        String[] operations2 = cpo2.toString().split(",");
        // The two numbers of operations must be equal.
        if (operations1.length != operations2.length) {
            return false;
        }
        // Iterate through the key-value pairs and separate out the key and value.
        // The value may be either a single string, or a series of further key-value pairs
        // that are separated by " ", with a "=" between the key and value.
        for (int i = 0; i < operations1.length; i++) {
            String operation1 = operations1[i];
            String operation2 = operations2[i];
            // Limit the array to length 2 in case a ":" appears in the value.
            String[] keyValue1 = operation1.split(":", 2);
            String[] keyValue2 = operation2.split(":", 2);
            // If the key doesn't match, return false.
            if (!keyValue1[0].equals(keyValue2[0])) {
                return false;
            }
            // First just check if the value matches up. If so, we're good to go.
            if (keyValue1[1].equals(keyValue2[1])) {
                continue;
            }
            // If not, we need to try splitting the value by " " and sorting those keyvalue pairs.
            // Note that these are trimmed first to ensure we're not thrown off by extra whitespace.
            String[] valueKeyValuePairs1 = keyValue1[1].trim().split(" ");
            String[] valueKeyValuePairs2 = keyValue2[1].trim().split(" ");
            // Sort the value's keyvalue pairs alphabetically, and now compare them to each other.
            Arrays.sort(valueKeyValuePairs1);
            Arrays.sort(valueKeyValuePairs2);
            for (int j = 0; j < valueKeyValuePairs1.length; j++) {
                if (!valueKeyValuePairs1[j].equals(valueKeyValuePairs2[j])) {
                    return false;
                }
            }
        }

        // If we make it all the way through without finding anything different, return true.
        return true;
    }

    // Generates a default model for testing. Should match up with
    // generateTestValues
    private CalendarEventModel buildTestModel() {
        CalendarEventModel model = new CalendarEventModel();
        model.mId = TEST_EVENT_ID;
        model.mTitle = "The_Question";
        model.mDescription = "Evaluating_Life_the_Universe_and_Everything";
        model.mLocation = "Earth_Mk2";
        model.mAllDay = true;
        model.mHasAlarm = false;
        model.mCalendarId = 2;
        model.mStart = TEST_START; // Monday, May 3rd, local Time
        model.mDuration = "P3652421990D";
        // The model uses the local timezone for allday
        model.mTimezone = "UTC";
        model.mRrule = "FREQ=DAILY;WKST=SU";
        model.mSyncId = "unique_per_calendar_stuff";
        model.mAvailability = 0;
        model.mAccessLevel = 2; // This is one less than the values written if >0
        model.mOwnerAccount = "steve@gmail.com";
        model.mHasAttendeeData = true;
        model.mOrganizer = "organizer@gmail.com";
        model.mIsOrganizer = false;
        model.mGuestsCanModify = false;
        model.mEventStatus = Events.STATUS_CONFIRMED;
        int displayColor = Utils.getDisplayColorFromColor(-2350809);
        model.setEventColor(displayColor);
        model.mCalendarAccountName = "steve.owner@gmail.com";
        model.mCalendarAccountType = "gmail.com";
        EventColorCache cache = new EventColorCache();
        cache.insertColor("steve.owner@gmail.com", "gmail.com", displayColor, 12);
        model.mEventColorCache = cache;
        model.mModelUpdatedWithEventCursor = true;
        return model;
    }

    // Generates a default set of values for testing. Should match up with
    // generateTestModel
    private ContentValues buildTestValues() {
        ContentValues values = new ContentValues();

        values.put(Events.CALENDAR_ID, 2L);
        values.put(Events.EVENT_TIMEZONE, "UTC"); // Allday events are converted
                                                  // to UTC for the db
        values.put(Events.TITLE, "The_Question");
        values.put(Events.ALL_DAY, 1);
        values.put(Events.DTSTART, TEST_START); // Monday, May 3rd, midnight UTC time
        values.put(Events.HAS_ATTENDEE_DATA, 1);

        values.put(Events.RRULE, "FREQ=DAILY;WKST=SU");
        values.put(Events.DURATION, "P3652421990D");
        values.put(Events.DTEND, (Long) null);
        values.put(Events.DESCRIPTION, "Evaluating_Life_the_Universe_and_Everything");
        values.put(Events.EVENT_LOCATION, "Earth_Mk2");
        values.put(Events.AVAILABILITY, 0);
        values.put(Events.STATUS, Events.STATUS_CONFIRMED);
        values.put(Events.ACCESS_LEVEL, 3); // This is one more than the model if
                                          // >0
        values.put(Events.EVENT_COLOR_KEY, 12);

        return values;
    }

    private ContentValues buildNonRecurringTestValues() {
        ContentValues values = buildTestValues();
        values.put(Events.DURATION, (String)null);
        values.put(Events.DTEND, TEST_END);
        values.put(Events.RRULE, (String)null);
        return values;
    }

    // This gets called by EditEventHelper to read or write the data
    class TestProvider extends ContentProvider {
        int index = 0;

        public TestProvider() {
        }

        @Override
        public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
                String orderBy) {
            return null;
        }

        @Override
        public int delete(Uri uri, String selection, String[] selectionArgs) {
            return 0;
        }

        @Override
        public String getType(Uri uri) {
            return null;
        }

        @Override
        public boolean onCreate() {
            return false;
        }

        @Override
        public Uri insert(Uri uri, ContentValues values) {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
            // TODO Auto-generated method stub
            return 0;
        }
    }

}