tests/src/com/android/providers/calendar/CalendarSyncTestingBase.java - platform/packages/providers/CalendarProvider - Git at Google

 /*
  * Copyright (C) 2009 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.providers.calendar;

 import android.accounts.Account;
 import android.accounts.AccountManager;
 import android.content.ContentResolver;
 import android.content.ContentUris;
 import android.content.ContentValues;
 import android.content.Context;
 import android.database.Cursor;
 import android.net.Uri;
 import android.os.SystemClock;
 import android.provider.CalendarContract;
 import android.test.SyncBaseInstrumentation;
 import android.text.format.DateUtils;
 import android.text.format.Time;
 import android.util.Log;

 import com.google.android.collect.Maps;

 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;

 public class CalendarSyncTestingBase extends SyncBaseInstrumentation {
     protected AccountManager mAccountManager;
     protected Context mTargetContext;
     protected String mAccount;
     protected ContentResolver mResolver;
     protected Uri mEventsUri = CalendarContract.Events.CONTENT_URI;

     static final String TAG = "calendar";
     static final String DEFAULT_TIMEZONE = "America/Los_Angeles";
     static final Set<String> EVENT_COLUMNS_TO_SKIP = new HashSet<String>();
     static final Set<String> ATTENDEES_COLUMNS_TO_SKIP = new HashSet<String>();
     static final Set<String> CALENDARS_COLUMNS_TO_SKIP = new HashSet<String>();
     static final Set<String> INSTANCES_COLUMNS_TO_SKIP = new HashSet<String>();

     static {
         EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events._ID);
         EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events.SYNC_DATA5);
         EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events.SYNC_DATA4);
         EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events.SYNC_DATA2);
         EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events.DIRTY);
         EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events.SYNC_DATA8);
         ATTENDEES_COLUMNS_TO_SKIP.add(CalendarContract.Attendees._ID);
         CALENDARS_COLUMNS_TO_SKIP.add(CalendarContract.Calendars._ID);
         CALENDARS_COLUMNS_TO_SKIP.add(CalendarContract.Calendars.CAL_SYNC8);
         CALENDARS_COLUMNS_TO_SKIP.add(CalendarContract.Calendars.CAL_SYNC7);
         CALENDARS_COLUMNS_TO_SKIP.add(CalendarContract.Calendars.DIRTY);
         CALENDARS_COLUMNS_TO_SKIP.add(CalendarContract.Calendars.CAL_SYNC6);
         INSTANCES_COLUMNS_TO_SKIP.add(CalendarContract.Instances._ID);
     }

     @Override
     protected void setUp() throws Exception {
         super.setUp();
         mTargetContext = getInstrumentation().getTargetContext();

         mAccountManager = AccountManager.get(mTargetContext);
         mAccount = getAccount();
         mResolver = mTargetContext.getContentResolver();
     }

     /**
      * A simple method that syncs the calendar provider.
      * @throws Exception
      */
     protected void syncCalendar() throws Exception {
         cancelSyncsandDisableAutoSync();
         syncProvider(CalendarContract.CONTENT_URI, mAccount, CalendarContract.AUTHORITY);
     }

     /**
      * Creates a new event in the default calendar.
      * @param event Event to be created.
      * @return Uri of the created event.
      * @throws Exception
      */
     protected Uri insertEvent(EventInfo event) throws Exception {
         return insertEvent(getDefaultCalendarId(), event);
     }

     /**
      * Creates a new event in the given calendarId.
      * @param calendarId Calendar to be used.
      * @param event Event to be created.
      * @return Uri of the event created.
      * @throws Exception
      */
     protected Uri insertEvent(int calendarId, EventInfo event) throws Exception{
         ContentValues m = new ContentValues();
         m.put(CalendarContract.Events.CALENDAR_ID, calendarId);
         m.put(CalendarContract.Events.TITLE, event.mTitle);
         m.put(CalendarContract.Events.DTSTART, event.mDtstart);
         m.put(CalendarContract.Events.ALL_DAY, event.mAllDay ? 1 : 0);

         if (event.mRrule == null) {
             // This is a normal event
             m.put(CalendarContract.Events.DTEND, event.mDtend);
         } else {
             // This is a repeating event
             m.put(CalendarContract.Events.RRULE, event.mRrule);
             m.put(CalendarContract.Events.DURATION, event.mDuration);
         }

         if (event.mDescription != null) {
             m.put(CalendarContract.Events.DESCRIPTION, event.mDescription);
         }
         if (event.mTimezone != null) {
             m.put(CalendarContract.Events.EVENT_TIMEZONE, event.mTimezone);
         }

         Uri url = mResolver.insert(mEventsUri, m);
         syncCalendar();
         return url;
     }

     /**
      * Edits the given event.
      * @param eventId EventID of the event to be edited.
      * @param event Edited event details.
      * @throws Exception
      */
     protected void editEvent(long eventId, EventInfo event) throws Exception {
         ContentValues values = new ContentValues();
         values.put(CalendarContract.Events.TITLE, event.mTitle);
         values.put(CalendarContract.Events.DTSTART, event.mDtstart);
         values.put(CalendarContract.Events.DTEND, event.mDtend);
         values.put(CalendarContract.Events.ALL_DAY, event.mAllDay ? 1 : 0);

         if (event.mDescription != null) {
             values.put(CalendarContract.Events.DESCRIPTION, event.mDescription);
         }

         Uri uri = ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId);
         mResolver.update(uri, values, null, null);
         syncCalendar();
     }

     /**
      * Deletes a given event.
      * @param uri
      * @throws Exception
      */
     protected void deleteEvent(Uri uri) throws Exception {
         mResolver.delete(uri, null, null);
         syncCalendar();
     }

     /**
      * Inserts a new calendar.
      * @param name
      * @param timezone
      * @param calendarUrl
      * @throws Exception
      */
     protected void insertCalendar(String name, String timezone, String calendarUrl)
             throws Exception {
         ContentValues values = new ContentValues();

         values.put(CalendarContract.Calendars.ACCOUNT_NAME, getAccount());
         values.put(CalendarContract.Calendars.CAL_SYNC1, calendarUrl);
         values.put(CalendarContract.Calendars.NAME, name);
         values.put(CalendarContract.Calendars.CALENDAR_DISPLAY_NAME, name);

         values.put(CalendarContract.Calendars.SYNC_EVENTS, 1);
         values.put(CalendarContract.Calendars.VISIBLE, 1);
         values.put(CalendarContract.Calendars.CALENDAR_COLOR, -14069085 /* blue */);
         values.put(CalendarContract.Calendars.CALENDAR_ACCESS_LEVEL,
                 CalendarContract.Calendars.CAL_ACCESS_OWNER);

         values.put(CalendarContract.Calendars.CALENDAR_COLOR, "0xff123456");
         values.put(CalendarContract.Calendars.CALENDAR_TIME_ZONE, timezone);
         mResolver.insert(CalendarContract.Calendars.CONTENT_URI, values);
         syncCalendar();
     }

     /**
      * Returns a fresh count of events.
      * @return
      */
     protected int getEventsCount() {
         Cursor cursor;
         cursor = mResolver.query(mEventsUri, null, null, null, null);
         return cursor.getCount();
     }

     /**
      * Returns the ID of the default calendar.
      * @return
      */
     protected int getDefaultCalendarId() {
         Cursor calendarsCursor;
         calendarsCursor = mResolver.query(CalendarContract.Calendars.CONTENT_URI, null, null, null,
                 null);
         calendarsCursor.moveToNext();
         return calendarsCursor.getInt(calendarsCursor.getColumnIndex("_id"));
     }

     /**
      * This class stores all the useful information about an event.
      */
     protected class EventInfo {
         String mTitle;
         String mDescription;
         String mTimezone;
         boolean mAllDay;
         long mDtstart;
         long mDtend;
         String mRrule;
         String mDuration;
         String mOriginalTitle;
         long mOriginalInstance;
         int mSyncId;

         // Constructor for normal events, using the default timezone
         public EventInfo(String title, String startDate, String endDate,
                 boolean allDay) {
             init(title, startDate, endDate, allDay, DEFAULT_TIMEZONE);
         }

         public EventInfo(String title, long startDate, long endDate,
                 boolean allDay) {
             mTitle = title;
             mTimezone = DEFAULT_TIMEZONE;
             mDtstart = startDate;
             mDtend = endDate;
             mDuration = null;
             mRrule = null;
             mAllDay = allDay;
         }

         public EventInfo(String title, long startDate, long endDate,
                 boolean allDay, String description) {
             mTitle = title;
             mTimezone = DEFAULT_TIMEZONE;
             mDtstart = startDate;
             mDtend = endDate;
             mDuration = null;
             mRrule = null;
             mAllDay = allDay;
             mDescription = description;
         }

         // Constructor for normal events, specifying the timezone
         public EventInfo(String title, String startDate, String endDate,
                 boolean allDay, String timezone) {
             init(title, startDate, endDate, allDay, timezone);
         }

         public void init(String title, String startDate, String endDate,
                 boolean allDay, String timezone) {
             mTitle = title;
             Time time = new Time();
             if (allDay) {
                 time.timezone = Time.TIMEZONE_UTC;
             } else if (timezone != null) {
                 time.timezone = timezone;
             }
             mTimezone = time.timezone;
             time.parse3339(startDate);
             mDtstart = time.toMillis(false /* use isDst */);
             time.parse3339(endDate);
             mDtend = time.toMillis(false /* use isDst */);
             mDuration = null;
             mRrule = null;
             mAllDay = allDay;
         }

         // Constructor for repeating events, using the default timezone
         public EventInfo(String title, String description, String startDate, String endDate,
                 String rrule, boolean allDay) {
             init(title, description, startDate, endDate, rrule, allDay, DEFAULT_TIMEZONE);
         }

         // Constructor for repeating events, specifying the timezone
         public EventInfo(String title, String description, String startDate, String endDate,
                 String rrule, boolean allDay, String timezone) {
             init(title, description, startDate, endDate, rrule, allDay, timezone);
         }

         public void init(String title, String description, String startDate, String endDate,
                 String rrule, boolean allDay, String timezone) {
             mTitle = title;
             mDescription = description;
             Time time = new Time();
             if (allDay) {
                 time.timezone = Time.TIMEZONE_UTC;
             } else if (timezone != null) {
                 time.timezone = timezone;
             }
             mTimezone = time.timezone;
             time.parse3339(startDate);
             mDtstart = time.toMillis(false /* use isDst */);
             if (endDate != null) {
                 time.parse3339(endDate);
                 mDtend = time.toMillis(false /* use isDst */);
             }
             if (allDay) {
                 long days = 1;
                 if (endDate != null) {
                     days = (mDtend - mDtstart) / DateUtils.DAY_IN_MILLIS;
                 }
                 mDuration = "P" + days + "D";
             } else {
                 long seconds = (mDtend - mDtstart) / DateUtils.SECOND_IN_MILLIS;
                 mDuration = "P" + seconds + "S";
             }
             mRrule = rrule;
             mAllDay = allDay;
         }

         // Constructor for recurrence exceptions, using the default timezone
         public EventInfo(String originalTitle, String originalInstance, String title,
                 String description, String startDate, String endDate, boolean allDay) {
             init(originalTitle, originalInstance,
                     title, description, startDate, endDate, allDay, DEFAULT_TIMEZONE);
         }

         public void init(String originalTitle, String originalInstance,
                 String title, String description, String startDate, String endDate,
                 boolean allDay, String timezone) {
             mOriginalTitle = originalTitle;
             Time time = new Time(timezone);
             time.parse3339(originalInstance);
             mOriginalInstance = time.toMillis(false /* use isDst */);
             init(title, description, startDate, endDate, null /* rrule */, allDay, timezone);
         }
     }

     /**
      * Returns the default account on the device.
      * @return
      */
     protected String getAccount() {
         Account[] accounts = mAccountManager.getAccountsByType("com.google");

         assertTrue("Didn't find any Google accounts", accounts.length > 0);

         Account account = accounts[accounts.length - 1];
         Log.v(TAG, "Found " + accounts.length + " accounts; using the last one, " + account.name);
         return account.name;
     }

     /**
      * Compares two cursors
      */
     protected void compareCursors(Cursor cursor1, Cursor cursor2,
                                   Set<String> columnsToSkip, String tableName) {
         String[] cols = cursor1.getColumnNames();
         int length = cols.length;

         assertEquals(tableName + " count failed to match", cursor1.getCount(),
                 cursor2.getCount());
         Map<String, String> row = Maps.newHashMap();
         while (cursor1.moveToNext() && cursor2.moveToNext()) {
             for (int i = 0; i < length; i++) {
                 String col = cols[i];
                 if (columnsToSkip != null && columnsToSkip.contains(col)) {
                     continue;
                 }
                 row.put(col, cursor1.getString(i));

                 assertEquals("Row: " + row + " Table: " + tableName + ": " + cols[i] +
                         " failed to match", cursor1.getString(i),
                         cursor2.getString(i));
             }
         }
     }
 }
	/*
	* Copyright (C) 2009 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.providers.calendar;

	import android.accounts.Account;
	import android.accounts.AccountManager;
	import android.content.ContentResolver;
	import android.content.ContentUris;
	import android.content.ContentValues;
	import android.content.Context;
	import android.database.Cursor;
	import android.net.Uri;
	import android.os.SystemClock;
	import android.provider.CalendarContract;
	import android.test.SyncBaseInstrumentation;
	import android.text.format.DateUtils;
	import android.text.format.Time;
	import android.util.Log;

	import com.google.android.collect.Maps;

	import java.util.HashSet;
	import java.util.Map;
	import java.util.Set;

	public class CalendarSyncTestingBase extends SyncBaseInstrumentation {
	protected AccountManager mAccountManager;
	protected Context mTargetContext;
	protected String mAccount;
	protected ContentResolver mResolver;
	protected Uri mEventsUri = CalendarContract.Events.CONTENT_URI;

	static final String TAG = "calendar";
	static final String DEFAULT_TIMEZONE = "America/Los_Angeles";
	static final Set<String> EVENT_COLUMNS_TO_SKIP = new HashSet<String>();
	static final Set<String> ATTENDEES_COLUMNS_TO_SKIP = new HashSet<String>();
	static final Set<String> CALENDARS_COLUMNS_TO_SKIP = new HashSet<String>();
	static final Set<String> INSTANCES_COLUMNS_TO_SKIP = new HashSet<String>();

	static {
	EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events._ID);
	EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events.SYNC_DATA5);
	EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events.SYNC_DATA4);
	EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events.SYNC_DATA2);
	EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events.DIRTY);
	EVENT_COLUMNS_TO_SKIP.add(CalendarContract.Events.SYNC_DATA8);
	ATTENDEES_COLUMNS_TO_SKIP.add(CalendarContract.Attendees._ID);
	CALENDARS_COLUMNS_TO_SKIP.add(CalendarContract.Calendars._ID);
	CALENDARS_COLUMNS_TO_SKIP.add(CalendarContract.Calendars.CAL_SYNC8);
	CALENDARS_COLUMNS_TO_SKIP.add(CalendarContract.Calendars.CAL_SYNC7);
	CALENDARS_COLUMNS_TO_SKIP.add(CalendarContract.Calendars.DIRTY);
	CALENDARS_COLUMNS_TO_SKIP.add(CalendarContract.Calendars.CAL_SYNC6);
	INSTANCES_COLUMNS_TO_SKIP.add(CalendarContract.Instances._ID);
	}

	@Override
	protected void setUp() throws Exception {
	super.setUp();
	mTargetContext = getInstrumentation().getTargetContext();

	mAccountManager = AccountManager.get(mTargetContext);
	mAccount = getAccount();
	mResolver = mTargetContext.getContentResolver();
	}

	/**
	* A simple method that syncs the calendar provider.
	* @throws Exception
	*/
	protected void syncCalendar() throws Exception {
	cancelSyncsandDisableAutoSync();
	syncProvider(CalendarContract.CONTENT_URI, mAccount, CalendarContract.AUTHORITY);
	}

	/**
	* Creates a new event in the default calendar.
	* @param event Event to be created.
	* @return Uri of the created event.
	* @throws Exception
	*/
	protected Uri insertEvent(EventInfo event) throws Exception {
	return insertEvent(getDefaultCalendarId(), event);
	}

	/**
	* Creates a new event in the given calendarId.
	* @param calendarId Calendar to be used.
	* @param event Event to be created.
	* @return Uri of the event created.
	* @throws Exception
	*/
	protected Uri insertEvent(int calendarId, EventInfo event) throws Exception{
	ContentValues m = new ContentValues();
	m.put(CalendarContract.Events.CALENDAR_ID, calendarId);
	m.put(CalendarContract.Events.TITLE, event.mTitle);
	m.put(CalendarContract.Events.DTSTART, event.mDtstart);
	m.put(CalendarContract.Events.ALL_DAY, event.mAllDay ? 1 : 0);

	if (event.mRrule == null) {
	// This is a normal event
	m.put(CalendarContract.Events.DTEND, event.mDtend);
	} else {
	// This is a repeating event
	m.put(CalendarContract.Events.RRULE, event.mRrule);
	m.put(CalendarContract.Events.DURATION, event.mDuration);
	}

	if (event.mDescription != null) {
	m.put(CalendarContract.Events.DESCRIPTION, event.mDescription);
	}
	if (event.mTimezone != null) {
	m.put(CalendarContract.Events.EVENT_TIMEZONE, event.mTimezone);
	}

	Uri url = mResolver.insert(mEventsUri, m);
	syncCalendar();
	return url;
	}

	/**
	* Edits the given event.
	* @param eventId EventID of the event to be edited.
	* @param event Edited event details.
	* @throws Exception
	*/
	protected void editEvent(long eventId, EventInfo event) throws Exception {
	ContentValues values = new ContentValues();
	values.put(CalendarContract.Events.TITLE, event.mTitle);
	values.put(CalendarContract.Events.DTSTART, event.mDtstart);
	values.put(CalendarContract.Events.DTEND, event.mDtend);
	values.put(CalendarContract.Events.ALL_DAY, event.mAllDay ? 1 : 0);

	if (event.mDescription != null) {
	values.put(CalendarContract.Events.DESCRIPTION, event.mDescription);
	}

	Uri uri = ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId);
	mResolver.update(uri, values, null, null);
	syncCalendar();
	}

	/**
	* Deletes a given event.
	* @param uri
	* @throws Exception
	*/
	protected void deleteEvent(Uri uri) throws Exception {
	mResolver.delete(uri, null, null);
	syncCalendar();
	}

	/**
	* Inserts a new calendar.
	* @param name
	* @param timezone
	* @param calendarUrl
	* @throws Exception
	*/
	protected void insertCalendar(String name, String timezone, String calendarUrl)
	throws Exception {
	ContentValues values = new ContentValues();

	values.put(CalendarContract.Calendars.ACCOUNT_NAME, getAccount());
	values.put(CalendarContract.Calendars.CAL_SYNC1, calendarUrl);
	values.put(CalendarContract.Calendars.NAME, name);
	values.put(CalendarContract.Calendars.CALENDAR_DISPLAY_NAME, name);

	values.put(CalendarContract.Calendars.SYNC_EVENTS, 1);
	values.put(CalendarContract.Calendars.VISIBLE, 1);
	values.put(CalendarContract.Calendars.CALENDAR_COLOR, -14069085 /* blue */);
	values.put(CalendarContract.Calendars.CALENDAR_ACCESS_LEVEL,
	CalendarContract.Calendars.CAL_ACCESS_OWNER);

	values.put(CalendarContract.Calendars.CALENDAR_COLOR, "0xff123456");
	values.put(CalendarContract.Calendars.CALENDAR_TIME_ZONE, timezone);
	mResolver.insert(CalendarContract.Calendars.CONTENT_URI, values);
	syncCalendar();
	}

	/**
	* Returns a fresh count of events.
	* @return
	*/
	protected int getEventsCount() {
	Cursor cursor;
	cursor = mResolver.query(mEventsUri, null, null, null, null);
	return cursor.getCount();
	}

	/**
	* Returns the ID of the default calendar.
	* @return
	*/
	protected int getDefaultCalendarId() {
	Cursor calendarsCursor;
	calendarsCursor = mResolver.query(CalendarContract.Calendars.CONTENT_URI, null, null, null,
	null);
	calendarsCursor.moveToNext();
	return calendarsCursor.getInt(calendarsCursor.getColumnIndex("_id"));
	}

	/**
	* This class stores all the useful information about an event.
	*/
	protected class EventInfo {
	String mTitle;
	String mDescription;
	String mTimezone;
	boolean mAllDay;
	long mDtstart;
	long mDtend;
	String mRrule;
	String mDuration;
	String mOriginalTitle;
	long mOriginalInstance;
	int mSyncId;

	// Constructor for normal events, using the default timezone
	public EventInfo(String title, String startDate, String endDate,
	boolean allDay) {
	init(title, startDate, endDate, allDay, DEFAULT_TIMEZONE);
	}

	public EventInfo(String title, long startDate, long endDate,
	boolean allDay) {
	mTitle = title;
	mTimezone = DEFAULT_TIMEZONE;
	mDtstart = startDate;
	mDtend = endDate;
	mDuration = null;
	mRrule = null;
	mAllDay = allDay;
	}

	public EventInfo(String title, long startDate, long endDate,
	boolean allDay, String description) {
	mTitle = title;
	mTimezone = DEFAULT_TIMEZONE;
	mDtstart = startDate;
	mDtend = endDate;
	mDuration = null;
	mRrule = null;
	mAllDay = allDay;
	mDescription = description;
	}

	// Constructor for normal events, specifying the timezone
	public EventInfo(String title, String startDate, String endDate,
	boolean allDay, String timezone) {
	init(title, startDate, endDate, allDay, timezone);
	}

	public void init(String title, String startDate, String endDate,
	boolean allDay, String timezone) {
	mTitle = title;
	Time time = new Time();
	if (allDay) {
	time.timezone = Time.TIMEZONE_UTC;
	} else if (timezone != null) {
	time.timezone = timezone;
	}
	mTimezone = time.timezone;
	time.parse3339(startDate);
	mDtstart = time.toMillis(false /* use isDst */);
	time.parse3339(endDate);
	mDtend = time.toMillis(false /* use isDst */);
	mDuration = null;
	mRrule = null;
	mAllDay = allDay;
	}

	// Constructor for repeating events, using the default timezone
	public EventInfo(String title, String description, String startDate, String endDate,
	String rrule, boolean allDay) {
	init(title, description, startDate, endDate, rrule, allDay, DEFAULT_TIMEZONE);
	}

	// Constructor for repeating events, specifying the timezone
	public EventInfo(String title, String description, String startDate, String endDate,
	String rrule, boolean allDay, String timezone) {
	init(title, description, startDate, endDate, rrule, allDay, timezone);
	}

	public void init(String title, String description, String startDate, String endDate,
	String rrule, boolean allDay, String timezone) {
	mTitle = title;
	mDescription = description;
	Time time = new Time();
	if (allDay) {
	time.timezone = Time.TIMEZONE_UTC;
	} else if (timezone != null) {
	time.timezone = timezone;
	}
	mTimezone = time.timezone;
	time.parse3339(startDate);
	mDtstart = time.toMillis(false /* use isDst */);
	if (endDate != null) {
	time.parse3339(endDate);
	mDtend = time.toMillis(false /* use isDst */);
	}
	if (allDay) {
	long days = 1;
	if (endDate != null) {
	days = (mDtend - mDtstart) / DateUtils.DAY_IN_MILLIS;
	}
	mDuration = "P" + days + "D";
	} else {
	long seconds = (mDtend - mDtstart) / DateUtils.SECOND_IN_MILLIS;
	mDuration = "P" + seconds + "S";
	}
	mRrule = rrule;
	mAllDay = allDay;
	}

	// Constructor for recurrence exceptions, using the default timezone
	public EventInfo(String originalTitle, String originalInstance, String title,
	String description, String startDate, String endDate, boolean allDay) {
	init(originalTitle, originalInstance,
	title, description, startDate, endDate, allDay, DEFAULT_TIMEZONE);
	}

	public void init(String originalTitle, String originalInstance,
	String title, String description, String startDate, String endDate,
	boolean allDay, String timezone) {
	mOriginalTitle = originalTitle;
	Time time = new Time(timezone);
	time.parse3339(originalInstance);
	mOriginalInstance = time.toMillis(false /* use isDst */);
	init(title, description, startDate, endDate, null /* rrule */, allDay, timezone);
	}
	}

	/**
	* Returns the default account on the device.
	* @return
	*/
	protected String getAccount() {
	Account[] accounts = mAccountManager.getAccountsByType("com.google");

	assertTrue("Didn't find any Google accounts", accounts.length > 0);

	Account account = accounts[accounts.length - 1];
	Log.v(TAG, "Found " + accounts.length + " accounts; using the last one, " + account.name);
	return account.name;
	}

	/**
	* Compares two cursors
	*/
	protected void compareCursors(Cursor cursor1, Cursor cursor2,
	Set<String> columnsToSkip, String tableName) {
	String[] cols = cursor1.getColumnNames();
	int length = cols.length;

	assertEquals(tableName + " count failed to match", cursor1.getCount(),
	cursor2.getCount());
	Map<String, String> row = Maps.newHashMap();
	while (cursor1.moveToNext() && cursor2.moveToNext()) {
	for (int i = 0; i < length; i++) {
	String col = cols[i];
	if (columnsToSkip != null && columnsToSkip.contains(col)) {
	continue;
	}
	row.put(col, cursor1.getString(i));

	assertEquals("Row: " + row + " Table: " + tableName + ": " + cols[i] +
	" failed to match", cursor1.getString(i),
	cursor2.getString(i));
	}
	}
	}
	}