Handles interrupt and error cleanup during import

2013-09-05 13:02:03 -07:00
commit 429ebdbf3a
1119 changed files with 75233 additions and 0 deletions
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest;
+
+import android.os.Bundle;
+import android.test.InstrumentationTestRunner;
+import android.util.Log;
+
+/**
+ * A test runner can be used to run end-to-end test.
+ * 
+ * @author Youtao Liu
+ */
+public class EndToEndTestRunner extends InstrumentationTestRunner {
+
+  /**
+   * Gets the parameter port which is used to fix GPS signal to emulators.
+   */
+  @Override
+  public void onCreate(Bundle arguments) {
+    String portNumber = arguments.getString("port");
+    if (portNumber != null) {
+      try {
+        EndToEndTestUtils.emulatorPort = Integer.parseInt(portNumber);
+      } catch (Exception e) {
+        Log.e(EndToEndTestUtils.LOG_TAG, "Unable to get port parameter, use default value."
+            + EndToEndTestUtils.emulatorPort, e);
+      }
+    }
+
+    RunConfiguration.runStressTest = "true".equalsIgnoreCase(arguments.getString("stress"));
+    RunConfiguration.runSensorTest = "true".equalsIgnoreCase(arguments.getString("sensor"));
+    RunConfiguration.runResourceUsageTest = "true"
+        .equalsIgnoreCase(arguments.getString("resource"));
+
+    Log.d(EndToEndTestUtils.LOG_TAG, "Use port number when run test on emulator:"
+        + EndToEndTestUtils.emulatorPort);
+    Log.i(EndToEndTestUtils.LOG_TAG, "Run stress test:" + RunConfiguration.runStressTest);
+    Log.i(EndToEndTestUtils.LOG_TAG, "Run sensor test:" + RunConfiguration.runSensorTest);
+
+    super.onCreate(arguments);
+  }
+
+}
@@ -0,0 +1,431 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.io.gdata.GDataClientFactory;
+import com.google.android.apps.mytracks.io.gdata.maps.MapFeatureEntry;
+import com.google.android.apps.mytracks.io.gdata.maps.MapsClient;
+import com.google.android.apps.mytracks.io.gdata.maps.MapsConstants;
+import com.google.android.apps.mytracks.io.gdata.maps.MapsGDataConverter;
+import com.google.android.apps.mytracks.io.gdata.maps.MapsMapMetadata;
+import com.google.android.apps.mytracks.io.gdata.maps.XmlMapsGDataParserFactory;
+import com.google.android.apps.mytracks.io.sendtogoogle.SendToGoogleUtils;
+import com.google.android.apps.mytracks.io.spreadsheets.SendSpreadsheetsAsyncTask;
+import com.google.android.apps.mytracks.io.sync.SyncUtils;
+import com.google.android.common.gdata.AndroidXmlParserFactory;
+import com.google.android.maps.mytracks.R;
+import com.google.api.client.auth.oauth2.BearerToken;
+import com.google.api.client.auth.oauth2.Credential;
+import com.google.api.client.extensions.android.http.AndroidHttp;
+import com.google.api.client.googleapis.extensions.android.gms.auth.GoogleAccountCredential;
+import com.google.api.client.json.gson.GsonFactory;
+import com.google.api.services.drive.Drive;
+import com.google.api.services.drive.model.File;
+import com.google.api.services.drive.model.FileList;
+import com.google.api.services.fusiontables.Fusiontables;
+import com.google.api.services.fusiontables.model.Table;
+import com.google.gdata.client.spreadsheet.SpreadsheetService;
+import com.google.gdata.data.spreadsheet.ListEntry;
+import com.google.gdata.data.spreadsheet.ListFeed;
+import com.google.gdata.data.spreadsheet.WorksheetEntry;
+import com.google.gdata.data.spreadsheet.WorksheetFeed;
+import com.google.wireless.gdata.parser.GDataParser;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.app.Activity;
+import android.content.Context;
+import android.util.Log;
+
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Provides utilities to access Google Maps, Google Documents, Google Fusion
+ * Tables.
+ * 
+ * @author Youtao Liu
+ */
+public class GoogleUtils {
+
+  public static final String DOCUMENT_NAME_PREFIX = "My Tracks";
+  // This is the preferred account.
+  public static final String ACCOUNT_NAME_1 = "mytrackstest@gmail.com";
+  public static final String ACCOUNT_NAME_2 = "mytrackstest2@gmail.com";
+  public static final String SPREADSHEET_NAME = DOCUMENT_NAME_PREFIX + "-"
+      + EndToEndTestUtils.activityType;
+  private static final String WORK_SHEET_NAME = "Log";
+  private static final String TRANCK_NAME_COLUMN = "Name";
+
+  private static final String TEST_TRACKS_QUERY = "'root' in parents and title contains '"
+      + EndToEndTestUtils.TRACK_NAME_PREFIX + "' and trashed = false";
+
+  /**
+   * Gets the account to access Google Services.
+   * 
+   * @param context context used to get account
+   * @return the first account which is bound with current device
+   */
+  private static Account getAccount(Context context) {
+    return AccountManager.get(context).getAccountsByType(Constants.ACCOUNT_TYPE)[0];
+  }
+
+  /**
+   * Gets Google maps of a user.
+   * 
+   * @param context used to get maps
+   * @param mapsClient the client to access Google Maps
+   * @return true means set successfully
+   */
+  private static ArrayList<MapsMapMetadata> getMaps(Context context, MapsClient mapsClient) {
+    String authToken = null;
+    ArrayList<String> mapIds = new ArrayList<String>();
+    ArrayList<MapsMapMetadata> mapData = new ArrayList<MapsMapMetadata>();
+
+    try {
+      authToken = AccountManager.get(context).blockingGetAuthToken(getAccount(context),
+          MapsConstants.SERVICE_NAME, false);
+    } catch (Exception e) {
+      Log.d(EndToEndTestUtils.LOG_TAG, "Unable to get auth token", e);
+      return mapData;
+    }
+
+    GDataParser gDataParser = null;
+    try {
+      gDataParser = mapsClient.getParserForFeed(MapFeatureEntry.class, MapsClient.getMapsFeed(),
+          authToken);
+      gDataParser.init();
+      while (gDataParser.hasMoreData()) {
+        MapFeatureEntry entry = (MapFeatureEntry) gDataParser.readNextEntry(null);
+        mapIds.add(MapsGDataConverter.getMapidForEntry(entry));
+        mapData.add(MapsGDataConverter.getMapMetadataForEntry(entry));
+      }
+    } catch (Exception e) {
+      Log.d(EndToEndTestUtils.LOG_TAG, "Unable to get maps", e);
+    } finally {
+      if (gDataParser != null) {
+        gDataParser.close();
+      }
+    }
+
+    return mapData;
+  }
+
+  /**
+   * Searches a map in user's Google Maps.
+   * 
+   * @param title the title of map
+   * @param activity activity to get context
+   * @param isDelete whether delete the map of this track in the Google Maps
+   * @return true means find the map
+   */
+  private static boolean searchMapByTitle(String title, Activity activity, boolean isDelete) {
+    Context context = activity.getApplicationContext();
+    MapsClient mapsClient = new MapsClient(GDataClientFactory.getGDataClient(context),
+        new XmlMapsGDataParserFactory(new AndroidXmlParserFactory()));
+    ArrayList<MapsMapMetadata> mapData = getMaps(context, mapsClient);
+    for (MapsMapMetadata oneData : mapData) {
+      if (oneData.getDescription().indexOf(DOCUMENT_NAME_PREFIX) > -1
+          && oneData.getTitle().equals(title)) {
+        if (isDelete) {
+          try {
+            mapsClient.deleteEntry(oneData.getGDataEditUri(), AccountManager.get(context)
+                .blockingGetAuthToken(getAccount(context), MapsConstants.SERVICE_NAME, false));
+            return true;
+          } catch (Exception e) {
+            Log.d(EndToEndTestUtils.LOG_TAG, "Unable to drop map", e);
+            return false;
+          }
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Searches a map in user's Google Maps.
+   * 
+   * @param title the title of map
+   * @param activity activity to get context
+   * @return true means find the map
+   */
+  public static boolean searchMap(String title, Activity activity) {
+    return searchMapByTitle(title, activity, false);
+  }
+
+  /**
+   * Searches a map in user's Google Maps and then delete it.
+   * 
+   * @param title the title of map
+   * @param activity activity to get context
+   * @return true means find the map and delete it successfully
+   */
+  public static boolean deleteMap(String title, Activity activity) {
+    return searchMapByTitle(title, activity, true);
+  }
+
+  /**
+   * Removes old tracks created by MyTracks test.
+   * 
+   * @param activity
+   * @param accountName
+   */
+  public static void deleteTestTracksOnGoogleDrive(Activity activity, String accountName) {
+    try {
+      GoogleAccountCredential driveCredential = SendToGoogleUtils.getGoogleAccountCredential(
+          activity.getApplicationContext(), accountName, SendToGoogleUtils.DRIVE_SCOPE);
+      if (driveCredential == null) {
+        return;
+      }
+
+      Drive drive = SyncUtils.getDriveService(driveCredential);
+      com.google.api.services.drive.Drive.Files.List list = drive.files().list()
+          .setQ(TEST_TRACKS_QUERY);
+      List<File> files = list.execute().getItems();
+      for (Iterator<File> iterator = files.iterator(); iterator.hasNext();) {
+        File file = (File) iterator.next();
+        drive.files().delete(file.getId()).execute();
+      }
+    } catch (Exception e) {
+      Log.e(EndToEndTestUtils.LOG_TAG, "Delete test tracks failed.");
+    }
+  }
+
+  /**
+   * Removes old tracks on Google Maps created by MyTracks test.
+   * 
+   * @param activity
+   */
+  public static void deleteTracksOnGoogleMaps(Activity activity) {
+    Context context = activity.getApplicationContext();
+    MapsClient mapsClient = new MapsClient(GDataClientFactory.getGDataClient(context),
+        new XmlMapsGDataParserFactory(new AndroidXmlParserFactory()));
+    ArrayList<MapsMapMetadata> mapData = getMaps(context, mapsClient);
+    for (MapsMapMetadata oneData : mapData) {
+
+      try {
+        mapsClient.deleteEntry(oneData.getGDataEditUri(), AccountManager.get(context)
+            .blockingGetAuthToken(getAccount(context), MapsConstants.SERVICE_NAME, false));
+      } catch (Exception e) {
+        Log.d(EndToEndTestUtils.LOG_TAG, "Unable to drop map", e);
+      }
+    }
+  }
+
+  /**
+   * Delete spreadsheet which name is title.
+   * 
+   * @param title the name of spreadsheet
+   * @param activity to get context
+   * @param accountName the name of Google account
+   * @return true means delete successfully
+   */
+  public static boolean deleteSpreadsheetByTitle(String title, Activity activity, String accountName) {
+    try {
+      GoogleAccountCredential driveCredential = SendToGoogleUtils.getGoogleAccountCredential(
+          activity.getApplicationContext(), accountName, SendToGoogleUtils.DRIVE_SCOPE);
+      if (driveCredential == null) {
+        return false;
+      }
+
+      Drive drive = SyncUtils.getDriveService(driveCredential);
+      com.google.api.services.drive.Drive.Files.List list = drive.files().list()
+          .setQ(String.format(Locale.US, SendSpreadsheetsAsyncTask.GET_SPREADSHEET_QUERY, title));
+      List<File> files = list.execute().getItems();
+      for (Iterator<File> iterator = files.iterator(); iterator.hasNext();) {
+        File file = (File) iterator.next();
+        drive.files().delete(file.getId()).execute();
+      }
+      return true;
+    } catch (Exception e) {
+      Log.e(EndToEndTestUtils.LOG_TAG, "Search spreadsheet failed.");
+    }
+    return false;
+  }
+
+  /**
+   * Searches docs in user's Google Documents.
+   * 
+   * @param title the title of doc
+   * @param activity to get context
+   * @param accountName the name of Google account
+   * @return the file list of the document, null means can not find the
+   *         spreadsheets
+   */
+  public static List<File> searchAllSpreadsheetByTitle(String title, Activity activity,
+      String accountName) {
+    try {
+      GoogleAccountCredential driveCredential = SendToGoogleUtils.getGoogleAccountCredential(
+          activity.getApplicationContext(), accountName, SendToGoogleUtils.DRIVE_SCOPE);
+      if (driveCredential == null) {
+        return null;
+      }
+
+      Drive drive = SyncUtils.getDriveService(driveCredential);
+      com.google.api.services.drive.Drive.Files.List list = drive.files().list()
+          .setQ(String.format(Locale.US, SendSpreadsheetsAsyncTask.GET_SPREADSHEET_QUERY, title));
+      FileList result = list.execute();
+      return result.getItems();
+    } catch (Exception e) {
+      Log.e(EndToEndTestUtils.LOG_TAG, "Search spreadsheet failed.");
+    }
+    return null;
+  }
+
+  /**
+   * Searches a track title in a spreadsheet.
+   * 
+   * @param trackName the track name to search
+   * @param activity to get context
+   * @param spreadsheetTitle the title of spreadsheet
+   * @param isDelete whether delete the information of this track in the
+   *          document
+   * @param accountName the name of Google account
+   * @return true means find the track name in the spreadsheet
+   */
+  private static boolean searchTrackTitleInSpreadsheet(String trackName, Activity activity,
+      String spreadsheetTitle, boolean isDelete, String accountName) {
+    try {
+      // Get spreadsheet Id.
+      String spreadsheetId = searchAllSpreadsheetByTitle(spreadsheetTitle, activity, accountName)
+          .get(0).getId();
+
+      // Get spreadsheet service.
+      SpreadsheetService spreadsheetService = new SpreadsheetService(spreadsheetTitle);
+      Credential credential = new Credential(BearerToken.authorizationHeaderAccessMethod());
+      credential.setAccessToken(SendToGoogleUtils.getToken(activity.getApplicationContext(),
+          accountName, SendToGoogleUtils.SPREADSHEETS_SCOPE));
+      spreadsheetService.setOAuth2Credentials(credential);
+
+      // Get work sheet.
+      WorksheetFeed feed = spreadsheetService.getFeed(
+          new URL(String.format(Locale.US, SendSpreadsheetsAsyncTask.GET_WORKSHEETS_URI,
+              spreadsheetId)), WorksheetFeed.class);
+      List<WorksheetEntry> data = feed.getEntries();
+      for (Iterator<WorksheetEntry> iterator = data.iterator(); iterator.hasNext();) {
+        WorksheetEntry worksheetEntry = (WorksheetEntry) iterator.next();
+        String title = worksheetEntry.getTitle().getPlainText();
+        if (title.equals(WORK_SHEET_NAME)) {
+          URL listFeedUrl = worksheetEntry.getListFeedUrl();
+          List<ListEntry> listFeed = spreadsheetService.getFeed(listFeedUrl, ListFeed.class)
+              .getEntries();
+          for (Iterator<ListEntry> iterator2 = listFeed.iterator(); iterator2.hasNext();) {
+            ListEntry listEntry = (ListEntry) iterator2.next();
+            String name = listEntry.getCustomElements().getValue(TRANCK_NAME_COLUMN);
+            if (name.equals(trackName)) {
+              if (isDelete) {
+                listEntry.delete();
+              }
+              return true;
+            }
+          }
+        }
+      }
+    } catch (Exception e) {
+      Log.e(EndToEndTestUtils.LOG_TAG, "Search spreadsheet failed.");
+    }
+    return false;
+  }
+
+  /**
+   * Searches and deletes a track in spreadsheet.
+   * 
+   * @param title the track name to search
+   * @param activity to get context
+   * @return true means find and delete successfully
+   */
+  public static boolean deleteTrackInSpreadSheet(String title, Activity activity, String account) {
+    return searchTrackTitleInSpreadsheet(title, activity, GoogleUtils.SPREADSHEET_NAME, true,
+        account);
+  }
+
+  /**
+   * Searches a fusion table in user's Google tables.
+   * 
+   * @param tableName name of fusion table to search
+   * @param context android context
+   * @param accountName name of account
+   * @param isDelete whether delete this track
+   * @return true means find and delete fusion table
+   */
+  public static boolean searchFusionTableByTitle(String tableName, Context context,
+      String accountName, boolean isDelete) {
+    try {
+      GoogleAccountCredential credential = SendToGoogleUtils.getGoogleAccountCredential(context,
+          accountName, SendToGoogleUtils.FUSION_TABLES_SCOPE);
+      if (credential == null) {
+        return false;
+      }
+      Fusiontables fusiontables = new Fusiontables.Builder(AndroidHttp.newCompatibleTransport(),
+          new GsonFactory(), credential).build();
+      List<Table> tables = fusiontables.table().list().execute().getItems();
+      for (Iterator<Table> iterator = tables.iterator(); iterator.hasNext();) {
+        Table table = (Table) iterator.next();
+        String title = table.getName();
+        if (title.equals(tableName)) {
+          if (isDelete) {
+            fusiontables.table().delete(table.getTableId()).execute();
+          }
+          return true;
+        }
+      }
+
+    } catch (Exception e) {
+      Log.d(EndToEndTestUtils.LOG_TAG, "Failed when operate fusion table.", e);
+    }
+    return false;
+  }
+
+  /**
+   * Checks whether the status of account is right to use.
+   * 
+   * @return true means the status of account is good for sending
+   */
+  public static boolean isAccountAvailable() {
+    // Check whether no account is binded with this device.
+    if (EndToEndTestUtils.SOLO.waitForText(
+        EndToEndTestUtils.activityMytracks.getString(R.string.send_google_no_account_title), 1,
+        EndToEndTestUtils.SHORT_WAIT_TIME)) {
+      EndToEndTestUtils.getButtonOnScreen(
+          EndToEndTestUtils.activityMytracks.getString(R.string.generic_ok), true, true);
+      return false;
+    }
+
+    // Check whether need to choose account.
+    if (EndToEndTestUtils.SOLO.waitForText(
+        EndToEndTestUtils.activityMytracks.getString(R.string.send_google_choose_account_title), 1,
+        EndToEndTestUtils.SHORT_WAIT_TIME)) {
+      EndToEndTestUtils.SOLO.clickOnText(GoogleUtils.ACCOUNT_NAME_1);
+      EndToEndTestUtils.getButtonOnScreen(
+          EndToEndTestUtils.activityMytracks.getString(R.string.generic_ok), false, true);
+    }
+
+    // Check whether no account permission.
+    if (EndToEndTestUtils.SOLO.waitForText(
+        EndToEndTestUtils.activityMytracks.getString(R.string.send_google_no_account_permission),
+        1, EndToEndTestUtils.SHORT_WAIT_TIME)) {
+      return false;
+    }
+
+    return true;
+  }
+
+}
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2013 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest;
+
+import com.google.android.maps.mytracks.R;
+
+/**
+ * Places all the test configuration in this class.
+ * 
+ * @author Youtao Liu
+ */
+public class RunConfiguration {
+  private static RunConfiguration instance = null;
+  
+  /**
+   * Set to false as default. True to run the test. Default to false since this
+   * test can take a long time.
+   */
+  public static boolean runStressTest = true;
+  public static boolean runResourceUsageTest = true;
+  public static boolean runSensorTest = true;
+  public boolean runSyncTest = false;
+
+  private RunConfiguration() {
+    runSyncTest = canRunSyncTest();
+  }
+
+  public static RunConfiguration getInstance() {
+    if (instance == null) {
+      instance = new RunConfiguration();
+    }
+    return instance;
+  }
+
+  /**
+   * Runs sync tests when both test accounts are bound with the devices.
+   * 
+   * @return true means can run sync tests in this device
+   */
+  public static boolean canRunSyncTest() {
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.activityMytracks
+        .getString(R.string.settings_google));
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.activityMytracks
+        .getString(R.string.settings_google_account_title));
+    boolean canRunSyncE2ETest = EndToEndTestUtils.SOLO.waitForText(GoogleUtils.ACCOUNT_NAME_1, 1,
+        EndToEndTestUtils.SHORT_WAIT_TIME)
+        && EndToEndTestUtils.SOLO.waitForText(GoogleUtils.ACCOUNT_NAME_2, 1,
+            EndToEndTestUtils.TINY_WAIT_TIME);
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.activityMytracks
+        .getString(R.string.generic_cancel));
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.goBack();
+    return canRunSyncE2ETest;
+  }
+}
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.common;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+import android.view.KeyEvent;
+import android.widget.ListView;
+
+/**
+ * Tests creating a track with markers, and editing and sending send a track.
+ * 
+ * @author Youtao Liu
+ */
+public class CreateTrackTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Instrumentation instrumentation;
+  private TrackListActivity activityMyTracks;
+
+  public CreateTrackTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    activityMyTracks = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, activityMyTracks);
+  }
+
+  /**
+   * Tests editing a track.
+   */
+  public void testEditTrack() {
+    EndToEndTestUtils.createTrackIfEmpty(1, false);
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_edit), true);
+
+    String newTrackName = EndToEndTestUtils.TRACK_NAME_PREFIX + "_new" + System.currentTimeMillis();
+    String newType = EndToEndTestUtils.activityType;
+    String newDesc = "desc" + newTrackName;
+
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.rotateCurrentActivity();
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.generic_save));
+    sendKeys(KeyEvent.KEYCODE_DEL);
+
+    EndToEndTestUtils.enterTextAvoidSoftKeyBoard(0, newTrackName);
+    EndToEndTestUtils.enterTextAvoidSoftKeyBoard(1, newType);
+
+    EndToEndTestUtils.SOLO.clickOnView(EndToEndTestUtils.SOLO.getCurrentActivity().findViewById(
+        R.id.track_edit_activity_type_icon));
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.track_edit_activity_type_hint));
+    EndToEndTestUtils.SOLO.clickOnView(EndToEndTestUtils.SOLO.getImage(1));
+    // The test type should be replaced by the first type option.
+    assertFalse(EndToEndTestUtils.SOLO.searchText(newType));
+
+    EndToEndTestUtils.enterTextAvoidSoftKeyBoard(2, newDesc);
+    EndToEndTestUtils.SOLO.clickOnButton(activityMyTracks.getString(R.string.generic_save));
+    instrumentation.waitForIdleSync();
+    // Go back to track list.
+    EndToEndTestUtils.SOLO.goBack();
+    instrumentation.waitForIdleSync();
+    assertTrue(EndToEndTestUtils.SOLO.searchText(newTrackName));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(newDesc));
+  }
+
+  /**
+   * Creates one track with a two locations, a way point and a statistics point.
+   */
+  public void testCreateTrackWithMarkers() {
+    EndToEndTestUtils.startRecording();
+    instrumentation.waitForIdleSync();
+    // Send Gps before creating marker.
+    EndToEndTestUtils.sendGps(2);
+    if (EndToEndTestUtils.hasActionBar) {
+      // Check the title is Recording.
+      assertTrue(EndToEndTestUtils.SOLO.searchText(activityMyTracks
+          .getString(R.string.generic_recording)));
+    }
+
+    EndToEndTestUtils.createWaypoint(0);
+    EndToEndTestUtils.sendGps(2, 2);
+    // Back to tracks list.
+    EndToEndTestUtils.SOLO.goBack();
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.rotateCurrentActivity();
+    EndToEndTestUtils.stopRecording(false);
+    EndToEndTestUtils.trackName = EndToEndTestUtils.TRACK_NAME_PREFIX + System.currentTimeMillis();
+    EndToEndTestUtils.SOLO.enterText(0, EndToEndTestUtils.trackName);
+    EndToEndTestUtils.SOLO.enterText(1, EndToEndTestUtils.activityType);
+
+    EndToEndTestUtils.SOLO.clickOnButton(activityMyTracks.getString(R.string.generic_save));
+
+    instrumentation.waitForIdleSync();
+    // Check the new track
+    EndToEndTestUtils.SOLO.scrollUp();
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(EndToEndTestUtils.trackName, 1,
+        EndToEndTestUtils.NORMAL_WAIT_TIME, true, false));
+  }
+
+  /**
+   * Tests the display of track relative time.
+   */
+  public void testTrackRelativeTime() {
+    // Delete all track first.
+    EndToEndTestUtils.deleteAllTracks();
+    // Reset all settings.
+    EndToEndTestUtils.resetAllSettings(activityMyTracks, false);
+
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.track_list_empty_message)));
+    // Test should not show relative time.
+    EndToEndTestUtils.startRecording();
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.stopRecording(false);
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.getButtonOnScreen(activityMyTracks.getString(R.string.generic_save), true,
+        true);
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.goBack();
+    instrumentation.waitForIdleSync();
+    assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.RELATIVE_STARTTIME_POSTFIX, 1,
+        false, true));
+  }
+
+  /**
+   * Tests whether the split marker is created as setting.
+   */
+  public void testSplitSetting() {
+    EndToEndTestUtils.startRecording();
+
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_split_frequency), true);
+    boolean isFoundKM = EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.KM);
+    if (isFoundKM) {
+      EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.KM, 0);
+    } else {
+      EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.MILE, 0);
+    }
+
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+    // Send Gps to give a distance more than one kilometer or one mile.
+    EndToEndTestUtils.sendGps(50);
+    assertTrue(EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_markers),
+        true));
+    instrumentation.waitForIdleSync();
+    if (EndToEndTestUtils.hasGpsSingal) {
+      assertTrue(EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount() > 0);
+    } else {
+      assertTrue(EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount() == 0);
+    }
+    EndToEndTestUtils.SOLO.goBack();
+
+    EndToEndTestUtils.stopRecording(true);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    super.tearDown();
+  }
+
+}
@@ -0,0 +1,192 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.common;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+import android.widget.ListView;
+
+import java.util.ArrayList;
+
+/**
+ * Tests the delete of MyTracks.
+ * 
+ * @author Youtao Liu
+ */
+public class DeleteTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Instrumentation instrumentation;
+  private TrackListActivity activityMyTracks;
+
+  public DeleteTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    activityMyTracks = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, activityMyTracks);
+  }
+
+  /**
+   * Deletes all tracks.
+   */
+  public void testDeleteAllTracks() {
+    EndToEndTestUtils.createTrackIfEmpty(1, true);
+    instrumentation.waitForIdleSync();
+    // There is at least one track.
+    ArrayList<ListView> trackListView = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class);
+    assertTrue(trackListView.size() > 0);
+    assertTrue(trackListView.get(0).getCount() > 0);
+
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_delete_all), true);
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.rotateCurrentActivity();
+    EndToEndTestUtils.getButtonOnScreen(activityMyTracks.getString(R.string.generic_yes), true,
+        true);
+    EndToEndTestUtils.waitTextToDisappear(activityMyTracks
+        .getString(R.string.generic_progress_title));
+    instrumentation.waitForIdleSync();
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.track_list_empty_message)));
+    // There is no track now.
+    trackListView = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class);
+    assertEquals(0, trackListView.get(0).getCount());
+    // Export when there is no track.
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_export_all), true);
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.GPX.toUpperCase());
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+    EndToEndTestUtils.waitTextToDisappear(activityMyTracks
+        .getString(R.string.generic_progress_title));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.export_external_storage_no_track)));
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+  }
+
+  /**
+   * Deletes only one track.
+   */
+  public void testDeleteSingleTrack() {
+    EndToEndTestUtils.createTrackIfEmpty(1, true);
+    instrumentation.waitForIdleSync();
+    // Get the number of track( or tracks)
+    ArrayList<ListView> trackListView = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class);
+    int trackNumberOld = trackListView.get(0).getCount();
+
+    EndToEndTestUtils.SOLO.clickOnView(trackListView.get(0).getChildAt(0));
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.track_detail_chart_tab));
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_delete), true);
+    EndToEndTestUtils.getButtonOnScreen(activityMyTracks.getString(R.string.generic_yes), true,
+        true);
+    EndToEndTestUtils.waitTextToDisappear(activityMyTracks
+        .getString(R.string.generic_progress_title));
+    trackListView = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class);
+    int trackNumberNew = trackListView.get(0).getCount();
+    assertEquals(trackNumberOld - 1, trackNumberNew);
+  }
+
+  /**
+   * Deletes multiple tracks in {@link TrackListActivity}.
+   */
+  public void testMultipleDeleteInTrackList() {
+    if (!EndToEndTestUtils.hasActionBar) {
+      return;
+    }
+
+    // Get the number of track( or tracks)
+    ArrayList<ListView> trackListView = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class);
+    int trackNumber = trackListView.get(0).getCount();
+
+    if (trackNumber < 3) {
+      for (int i = 0; i < 3 - trackNumber; i++) {
+        EndToEndTestUtils.createSimpleTrack(0, true);
+
+      }
+    }
+
+    // Get the number of track( or tracks)
+    trackListView = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class);
+    int trackNumberOld = trackListView.get(0).getCount();
+
+    assertTrue(trackNumberOld > 2);
+
+    // Select 3 tracks.
+    EndToEndTestUtils.SOLO.clickLongOnView(trackListView.get(0).getChildAt(0));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(activityMyTracks.getString(
+        R.string.list_item_selected, 1)));
+    EndToEndTestUtils.SOLO.clickOnView(trackListView.get(0).getChildAt(1));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(activityMyTracks.getString(
+        R.string.list_item_selected, 2)));
+    EndToEndTestUtils.SOLO.clickOnView(trackListView.get(0).getChildAt(2));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(activityMyTracks.getString(
+        R.string.list_item_selected, 3)));
+
+    // Deselect the first one.
+    EndToEndTestUtils.SOLO.clickOnView(trackListView.get(0).getChildAt(0));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(activityMyTracks.getString(
+        R.string.list_item_selected, 2)));
+
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_delete), true);
+    EndToEndTestUtils.getButtonOnScreen(activityMyTracks.getString(R.string.generic_yes), true,
+        true);
+
+    EndToEndTestUtils.waitTextToDisappear(activityMyTracks
+        .getString(R.string.generic_progress_title));
+    EndToEndTestUtils.waitTextToDisappear(activityMyTracks
+        .getString(R.string.track_delete_progress_message));
+    int trackNumberNew = trackNumberOld;
+    long startTime = System.currentTimeMillis();
+    // Wait a few seconds for the delete.
+    while (trackNumberNew != trackNumberOld - 2
+        && (System.currentTimeMillis() - startTime) < EndToEndTestUtils.SHORT_WAIT_TIME) {
+      trackListView = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class);
+      trackNumberNew = trackListView.get(0).getCount();
+      EndToEndTestUtils.sleep(EndToEndTestUtils.VERY_SHORT_WAIT_TIME);
+    }
+    assertEquals(trackNumberOld - 2, trackNumberNew);
+  }
+
+  /**
+   * Deletes a track which is under recording.
+   */
+  public void testDeleteOneTrackUnderRecording() {
+    EndToEndTestUtils.startRecording();
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.checkUnderRecording();
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_delete), true);
+    EndToEndTestUtils.getButtonOnScreen(activityMyTracks.getString(R.string.generic_yes), true,
+        true);
+    EndToEndTestUtils.waitTextToDisappear(activityMyTracks
+        .getString(R.string.generic_progress_title));
+    EndToEndTestUtils.checkNotRecording();
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    super.tearDown();
+  }
+
+}
@@ -0,0 +1,501 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.common;
+
+import com.google.android.apps.mytracks.TrackDetailActivity;
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.util.FileUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Activity;
+import android.app.Instrumentation;
+import android.location.Location;
+import android.test.ActivityInstrumentationTestCase2;
+import android.util.Log;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+/**
+ * Tests the import and export of MyTracks.
+ * 
+ * @author Youtao Liu
+ */
+public class ExportAllAndImportAllTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Instrumentation instrumentation;
+  private TrackListActivity activityMyTracks;
+  private int trackNumber = 0;
+
+  private final static String tracksName = "testTrackName1373523959524";
+  private final static String maxAltitude = "33.3";
+  private final static String minAltitude = "22.2";
+
+  public ExportAllAndImportAllTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    activityMyTracks = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, activityMyTracks);
+    trackNumber = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount();
+    EndToEndTestUtils.createTrackIfEmpty(1, true);
+  }
+
+  /**
+   * Tests export and import tracks after creating a track with Gps signal and
+   * an empty track.
+   */
+  public void testExportAllAndImportAllTracks_GPX_KML() {
+    // Create a new track with 3 gps data.
+    EndToEndTestUtils.createTrackIfEmpty(3, true);
+    instrumentation.waitForIdleSync();
+
+    // Create a empty track.
+    EndToEndTestUtils.createSimpleTrack(0, true);
+    instrumentation.waitForIdleSync();
+    checkExportAndImport();
+  }
+
+  /**
+   * Tests saving tracks to SD card as a CSV files.
+   */
+  public void testExportAll_CSV() {
+    EndToEndTestUtils.saveAllTrackToSdCard(EndToEndTestUtils.CSV);
+    assertEquals(trackNumber, EndToEndTestUtils.getExportedFiles(EndToEndTestUtils.CSV).length);
+  }
+
+  /**
+   * Tests saving tracks to SD card as a TCX files.
+   */
+  public void testExportAll_TCX() {
+    EndToEndTestUtils.saveAllTrackToSdCard(EndToEndTestUtils.TCX);
+    assertEquals(trackNumber, EndToEndTestUtils.getExportedFiles(EndToEndTestUtils.TCX).length);
+  }
+
+  /**
+   * Tests export and import track. Then check the properties of this track.
+   */
+  public void testExportAllAndImportAllTrack_properties_GPX() {
+    EndToEndTestUtils.deleteAllTracks();
+
+    // Create a new track with two markers.
+    EndToEndTestUtils.startRecording();
+    instrumentation.waitForIdleSync();
+
+    // Send Gps before creating marker.
+    EndToEndTestUtils.sendGps(2);
+    EndToEndTestUtils.createWaypoint(0);
+    EndToEndTestUtils.sendGps(2, 2);
+    EndToEndTestUtils.createWaypoint(1);
+    EndToEndTestUtils.sendGps(2, 4);
+
+    // Back to tracks list.
+    EndToEndTestUtils.SOLO.goBack();
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.stopRecording(true);
+
+    // Export this track and then delete it.
+    EndToEndTestUtils.deleteExportedFiles(EndToEndTestUtils.GPX);
+
+    // Click to export tracks(At least one track) to Gpx files.
+    exportTracks(EndToEndTestUtils.GPX);
+    EndToEndTestUtils.deleteAllTracks();
+
+    // Import this tracks.
+    importTracks(EndToEndTestUtils.GPX);
+    EndToEndTestUtils.SOLO.waitForText(getImportSuccessMessage(1, EndToEndTestUtils.GPX));
+
+    /*
+     * Check import tracks should be equal with the sum of trackNumber and
+     * gpxFilesNumber;
+     */
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+    instrumentation.waitForIdleSync();
+
+    // Check the track name, activity and description.
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(EndToEndTestUtils.trackName));
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.trackName);
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.track_detail_chart_tab));
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_edit), true);
+    instrumentation.waitForIdleSync();
+    assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.trackName));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.activityType));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.trackDesc));
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.generic_cancel));
+
+    if (EndToEndTestUtils.hasGpsSingal) {
+      // Check the markers.
+      EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_markers), true);
+
+      // The first marker.
+      assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.WAYPOINT_NAME + 1));
+      assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.WAYPOINT_TYPE + 1));
+      assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.WAYPOINT_DESC + 1));
+
+      // The second marker.
+      assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.WAYPOINT_NAME + 2));
+      assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.WAYPOINT_TYPE + 2));
+      assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.WAYPOINT_DESC + 2));
+    }
+  }
+
+  /**
+   * Tests export and import tracks after creating a track with Gps signal and
+   * an empty track. Both tracks are paused during recording.
+   */
+  public void testExportAllAndImportAllTracks_pausedTrack_GPX_KML() {
+    EndToEndTestUtils.deleteAllTracks();
+    // Create a new track with 3 gps data.
+    EndToEndTestUtils.createTrackWithPause(3);
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.goBack();
+
+    // Create an empty track.
+    EndToEndTestUtils.createTrackWithPause(0);
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.goBack();
+    instrumentation.waitForIdleSync();
+    checkExportAndImport();
+  }
+
+  /**
+   * Tests export and import tracks.
+   * <ul>
+   * <li>Create two tracks, one of them is empty(Have no Gps data).</li>
+   * <li>Tests import when there is no track file.</li>
+   * <li>Tests export tracks to Gpx files.</li>
+   * <li>Tests import Gpx files to tracks.</li>
+   * <li>Tests export tracks to Kml files.</li>
+   * </ul>
+   */
+  private void checkExportAndImport() {
+    // Delete all exported gpx and kml tracks.
+    EndToEndTestUtils.deleteExportedFiles(EndToEndTestUtils.GPX);
+    EndToEndTestUtils.deleteExportedFiles(EndToEndTestUtils.KML);
+    int gpxFilesNumber = 0;
+    File[] allGpxFiles = EndToEndTestUtils.getExportedFiles(EndToEndTestUtils.GPX);
+
+    // For the first export, there is no MyTracks folder.
+    if (allGpxFiles != null) {
+      gpxFilesNumber = EndToEndTestUtils.getExportedFiles(EndToEndTestUtils.GPX).length;
+    }
+
+    // Get track number in current track list of MyTracks.
+    trackNumber = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount();
+
+    // No Gpx file to imported.
+    importTracks(EndToEndTestUtils.GPX);
+    EndToEndTestUtils.SOLO.waitForText(getImportErrorMessage(0, 0, EndToEndTestUtils.GPX));
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+
+    // Click to export tracks(At least one track) to Gpx files.
+    exportTracks(EndToEndTestUtils.GPX);
+
+    // Check export Gpx file.
+    assertEquals(gpxFilesNumber + trackNumber,
+        EndToEndTestUtils.getExportedFiles(EndToEndTestUtils.GPX).length);
+    instrumentation.waitForIdleSync();
+
+    // Click to import Gpx track.
+    gpxFilesNumber = EndToEndTestUtils.getExportedFiles(EndToEndTestUtils.GPX).length;
+    trackNumber = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount();
+
+    importTracks(EndToEndTestUtils.GPX);
+    EndToEndTestUtils.rotateCurrentActivity();
+    checkImport();
+
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(EndToEndTestUtils.trackName));
+    assertEquals(trackNumber + gpxFilesNumber,
+        EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount());
+
+    // Click to export tracks(At least two tracks) to KML files.
+    gpxFilesNumber = EndToEndTestUtils.getExportedFiles(EndToEndTestUtils.GPX).length;
+    trackNumber = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount();
+
+    exportTracks(EndToEndTestUtils.KML);
+
+    // Check export files.
+    assertEquals(gpxFilesNumber, EndToEndTestUtils.getExportedFiles(EndToEndTestUtils.GPX).length);
+    assertEquals(trackNumber, EndToEndTestUtils.getExportedFiles(EndToEndTestUtils.KML).length);
+
+    // Click to import KML track.
+    int KMLFilesNumber = EndToEndTestUtils.getExportedFiles(EndToEndTestUtils.KML).length;
+    instrumentation.waitForIdleSync();
+    trackNumber = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount();
+
+    importTracks(EndToEndTestUtils.KML);
+    checkImport();
+    EndToEndTestUtils.SOLO.waitForActivity(TrackListActivity.class);
+
+    assertEquals(trackNumber + KMLFilesNumber,
+        EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount());
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    super.tearDown();
+  }
+
+  private String getSaveSuccessMessage(int count, String type) {
+    String tracks = activityMyTracks.getResources().getQuantityString(R.plurals.tracks, count,
+        count);
+    String directoryDisplayName = FileUtils.getDirectoryDisplayName(type);
+    return activityMyTracks.getString(R.string.export_external_storage_success, tracks,
+        directoryDisplayName);
+  }
+
+  private String getImportSuccessMessage(int count, String type) {
+    String files = activityMyTracks.getResources().getQuantityString(R.plurals.files, count, count);
+    String directoryDisplayName = FileUtils.getDirectoryDisplayName(type);
+    return activityMyTracks.getString(R.string.import_success, files, directoryDisplayName);
+  }
+
+  private String getImportErrorMessage(int count, int total, String type) {
+    String files = activityMyTracks.getResources().getQuantityString(R.plurals.files, total, total);
+    String directoryDisplayName = FileUtils.getDirectoryDisplayName(type);
+    return activityMyTracks.getString(R.string.import_error, count, files, directoryDisplayName);
+  }
+
+  /**
+   * Imports tracks from external storage.
+   * 
+   * @param fileType the file type, can be GPX and KML currently
+   */
+  private void importTracks(String fileType) {
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_import_all), true);
+    EndToEndTestUtils.SOLO.clickOnText(fileType.toUpperCase());
+    EndToEndTestUtils.getButtonOnScreen(
+        EndToEndTestUtils.activityMytracks.getString(R.string.generic_ok), true, true);
+  }
+
+  /**
+   * Exports tracks to external storage.
+   * 
+   * @param fileType the file type, can be GPX/KML/TCX/CSV currently
+   */
+  private void exportTracks(String fileType) {
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_export_all), true);
+    EndToEndTestUtils.SOLO.clickOnText(fileType.toUpperCase());
+    EndToEndTestUtils.getButtonOnScreen(
+        EndToEndTestUtils.activityMytracks.getString(R.string.generic_ok), true, true);
+    EndToEndTestUtils.SOLO.waitForText(getSaveSuccessMessage(2, fileType));
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+  }
+
+  /**
+   * Test export/import one track and checks the detail of this track.
+   */
+  public void testExportImport_checkTrackDetails() {
+    EndToEndTestUtils.deleteAllTracks();
+    EndToEndTestUtils.deleteExportedFiles(EndToEndTestUtils.GPX);
+    EndToEndTestUtils.deleteExportedFiles(EndToEndTestUtils.KML);
+    EndToEndTestUtils.deleteExportedFiles(EndToEndTestUtils.TCX);
+    EndToEndTestUtils.deleteExportedFiles(EndToEndTestUtils.CSV);
+    writeGPXTrackFile();
+
+    importTracks(EndToEndTestUtils.GPX);
+    checkImport();
+    checkSingleTrack();
+    EndToEndTestUtils.deleteExportedFiles(EndToEndTestUtils.GPX);
+
+    exportTracks(EndToEndTestUtils.KML);
+    exportTracks(EndToEndTestUtils.GPX);
+    exportTracks(EndToEndTestUtils.TCX);
+    exportTracks(EndToEndTestUtils.CSV);
+
+    EndToEndTestUtils.deleteAllTracks();
+    importTracks(EndToEndTestUtils.GPX);
+    checkImport();
+    checkSingleTrack();
+    EndToEndTestUtils.deleteAllTracks();
+    importTracks(EndToEndTestUtils.KML);
+    checkImport();
+    checkSingleTrack();
+  }
+
+  /**
+   * Checks the status of import.
+   */
+  private void checkImport() {
+    /*
+     * Wait for the prefix of import success string is much faster than wait the
+     * whole string.
+     */
+    EndToEndTestUtils.waitTextToDisappear(activityMyTracks
+        .getString(R.string.generic_progress_title));
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.import_success).split(
+        "%")[0]);
+
+    /*
+     * Check import KML tracks should be equal with the sum of trackNumber and
+     * KMLFilesNumber;
+     */
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+    instrumentation.waitForIdleSync();
+  }
+
+  /**
+   * Checks the detail of one track.
+   */
+  private void checkSingleTrack() {
+    if (!PreferencesUtils.isMetricUnits(activityMyTracks)) {
+      EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+          .getString(R.string.track_detail_stats_tab));
+      assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+          .getString(R.string.settings_stats_units_title)));
+
+      // Change preferred units.
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+          .getString(R.string.settings_stats_units_title));
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.unit_kilometer));
+      EndToEndTestUtils.SOLO.goBack();
+      EndToEndTestUtils.SOLO.goBack();
+    }
+    PreferencesUtils.setBoolean(activityMyTracks, R.string.stats_show_grade_elevation_key, true);
+
+    EndToEndTestUtils.SOLO.clickOnText(tracksName);
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.waitForActivity(TrackDetailActivity.class,
+        EndToEndTestUtils.LONG_WAIT_TIME);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_stats_tab));
+    instrumentation.waitForIdleSync();
+
+    float acceptDeviation = 0.1f;
+    Activity detailActivity = EndToEndTestUtils.SOLO.getCurrentActivity();
+    float minAltitudeActual = Float.parseFloat(((TextView) detailActivity.findViewById(
+        R.id.stats_elevation_min).findViewById(R.id.stats_value)).getText().toString());
+    float maxAltitudeActual = Float.parseFloat(((TextView) detailActivity.findViewById(
+        R.id.stats_elevation_max).findViewById(R.id.stats_value)).getText().toString());
+    float distanceActual = Float.parseFloat(((TextView) detailActivity.findViewById(
+        R.id.stats_distance).findViewById(R.id.stats_value)).getText().toString());
+    float averageSpeedActual = Float.parseFloat(((TextView) detailActivity.findViewById(
+        R.id.stats_average_speed).findViewById(R.id.stats_value)).getText().toString());
+    // Seconds.
+    int timeSpan = 9;
+
+    float distance = 0;
+    double initialLat = 39.30;
+    double initialLng = 116;
+    Location start = new Location("gps");
+    start.setLatitude(initialLat);
+    start.setLongitude(initialLng);
+    for (int i = 1; i < 10; i++) {
+      Location end = new Location("gps");
+      end.setLatitude(initialLat - 0.0005 * i);
+      end.setLongitude(initialLng + 0.0005 * i);
+      distance = distance + end.distanceTo(start) / 1000;
+      start = end;
+    }
+
+    // KM/H
+    float averageSpeed = distance * 3600 / timeSpan;
+    assertEquals(Float.parseFloat(minAltitude), minAltitudeActual);
+    assertEquals(Float.parseFloat(maxAltitude), maxAltitudeActual);
+    Log.i(EndToEndTestUtils.LOG_TAG, distance + ":" + distanceActual);
+    assertTrue((distance - distanceActual) / distance < acceptDeviation);
+    assertTrue((averageSpeed - averageSpeedActual) / averageSpeed < acceptDeviation);
+
+    EndToEndTestUtils.SOLO.goBack();
+  }
+
+  /**
+   * Writes a GPX track file to MyTracks folder.
+   */
+  private void writeGPXTrackFile() {
+    String fileName = tracksName + ".gpx";
+    String fileContent = "<?xml version=\"1.0\" encoding=\"UTF-8\"?> "
+        + "<gpx "
+        + "version=\"1.1\" "
+        + "creator=\"Created by Google My Tracks on Android.\" "
+        + "xmlns=\"http://www.topografix.com/GPX/1/1\" "
+        + "xmlns:topografix=\"http://www.topografix.com/GPX/Private/TopoGrafix/0/1\" "
+        + "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
+        + "xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd http://www.topografix.com/GPX/Private/TopoGrafix/0/1 http://www.topografix.com/GPX/Private/TopoGrafix/0/1/topografix.xsd\"> "
+        + "<metadata> " + "<name><![CDATA[testTrackName1373523959524]]></name> "
+        + "<desc><![CDATA[testTrackDesc1373523959524]]></desc> " + "</metadata> " + "<trk> "
+        + "<name><![CDATA[testTrackName1373523959524]]></name> "
+        + "<desc><![CDATA[testTrackDesc1373523959524]]></desc> "
+        + "<type><![CDATA[TestActivity]]></type> "
+        + "<extensions><topografix:color>c0c0c0</topografix:color></extensions> " + "<trkseg> "
+        + "<trkpt lat=\"39.30\" lon=\"116\"> " + "<time>2013-07-10T08:00:00.000Z</time> <ele>"
+        + minAltitude
+        + "</ele>"
+        + "</trkpt> "
+        + "<trkpt lat=\"39.2995\" lon=\"116.0005\"> "
+        + "<time>2013-07-10T08:00:01.000Z</time> "
+        + "</trkpt> "
+        + "<trkpt lat=\"39.299\" lon=\"116.001\"> "
+        + "<time>2013-07-10T08:00:02.000Z</time> "
+        + "</trkpt> "
+        + "<trkpt lat=\"39.2985\" lon=\"116.0015\"> "
+        + "<time>2013-07-10T08:00:03.000Z</time> "
+        + "</trkpt> "
+        + "<trkpt lat=\"39.298\" lon=\"116.002\"> "
+        + "<time>2013-07-10T08:00:04.000Z</time> "
+        + "</trkpt> "
+        + "<trkpt lat=\"39.2975\" lon=\"116.0025\"> "
+        + "<time>2013-07-10T08:00:05.000Z</time> "
+        + "</trkpt> "
+        + "<trkpt lat=\"39.297\" lon=\"116.003\"> "
+        + "<time>2013-07-10T08:00:06.000Z</time> "
+        + "</trkpt> "
+        + "<trkpt lat=\"39.2965\" lon=\"116.0035\"> "
+        + "<time>2013-07-10T08:00:07.000Z</time> "
+        + "</trkpt> "
+        + "<trkpt lat=\"39.296\" lon=\"116.004\"> "
+        + "<time>2013-07-10T08:00:08.000Z</time> "
+        + "</trkpt> "
+        + "<trkpt lat=\"39.2955\" lon=\"116.0045\"> "
+        + "<time>2013-07-10T08:00:09.000Z</time> <ele>"
+        + maxAltitude
+        + "</ele>"
+        + "</trkpt> "
+        + "</trkseg> " + "</trk> " + "</gpx>";
+
+    try {
+      File file = new File(FileUtils.getDirectoryPath(EndToEndTestUtils.GPX.toLowerCase())
+          + File.separator + fileName);
+      FileOutputStream fop = new FileOutputStream(file);
+      // if file doesnt exists, then create it
+      if (!file.exists()) {
+        file.createNewFile();
+      }
+      // get the content in bytes
+      byte[] contentInBytes = fileContent.getBytes();
+      fop.write(contentInBytes);
+      fop.flush();
+      fop.close();
+      Log.i(EndToEndTestUtils.LOG_TAG, file.getAbsolutePath());
+    } catch (IOException e) {
+      fail();
+    }
+  }
+}
@@ -0,0 +1,192 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.common;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.endtoendtest.GoogleUtils;
+import com.google.android.maps.mytracks.R;
+import com.google.api.services.drive.model.File;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+
+import java.util.List;
+
+/**
+ * Tests export single track to Google. Each test would export one track to
+ * Google Maps, Google Fusion Tables and Google Spreadsheets.
+ * 
+ * @author youtaol
+ */
+public class ExportSingleTrackTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Instrumentation instrumentation;
+  private TrackListActivity activityMyTracks;
+
+  public ExportSingleTrackTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    activityMyTracks = getActivity();
+
+    GoogleUtils.deleteTracksOnGoogleMaps(activityMyTracks);
+    GoogleUtils.deleteTestTracksOnGoogleDrive(activityMyTracks, GoogleUtils.ACCOUNT_NAME_1);
+    EndToEndTestUtils.setupForAllTest(instrumentation, activityMyTracks);
+  }
+
+  /**
+   * Checks all services and send to google.
+   */
+  public void testCreateAndSendTrack_send() {
+    // Create a new track.
+    EndToEndTestUtils.createSimpleTrack(1, false);
+    instrumentation.waitForIdleSync();
+    checkSendTrackToGoogle();
+  }
+
+  /**
+   * Checks all services and send to google.
+   */
+  public void testCreateAndSendTrack_sendPausedTrack() {
+    EndToEndTestUtils.deleteAllTracks();
+    EndToEndTestUtils.createTrackWithPause(3);
+    instrumentation.waitForIdleSync();
+    checkSendTrackToGoogle();
+  }
+
+  /**
+   * Sends two tracks with same activity. Two tracks should be in the same
+   * spreadsheet.
+   */
+  public void testSendTwoTracksWithSameActivity() {
+    String testActivity = "(TestActivity)";
+    EndToEndTestUtils.activityType = testActivity;
+    GoogleUtils.deleteSpreadsheetByTitle("My Tracks-" + EndToEndTestUtils.activityType,
+        EndToEndTestUtils.activityMytracks, GoogleUtils.ACCOUNT_NAME_1);
+    EndToEndTestUtils.createSimpleTrack(1, false);
+    boolean result = sendToGoogle(activityMyTracks.getString(R.string.export_google_maps))
+        && sendToGoogle(activityMyTracks.getString(R.string.export_google_fusion_tables))
+        && sendToGoogle(activityMyTracks.getString(R.string.export_google_spreadsheets));
+    result = result && sendToGoogle(activityMyTracks.getString(R.string.export_google_maps))
+        && sendToGoogle(activityMyTracks.getString(R.string.export_google_fusion_tables))
+        && sendToGoogle(activityMyTracks.getString(R.string.export_google_spreadsheets));
+
+    // Result is true mean has account bound with this device and send
+    // successful.
+    if (result) {
+      List<File> fileList = GoogleUtils.searchAllSpreadsheetByTitle(
+          GoogleUtils.DOCUMENT_NAME_PREFIX + "-" + EndToEndTestUtils.activityType,
+          activityMyTracks, GoogleUtils.ACCOUNT_NAME_1);
+      assertEquals(1, fileList.size());
+    }
+  }
+
+  /**
+   * Checks the process of sending track to google.
+   */
+  private void checkSendTrackToGoogle() {
+    if (!sendToGoogle(activityMyTracks.getString(R.string.export_google_maps))
+        || !sendToGoogle(activityMyTracks.getString(R.string.export_google_fusion_tables))
+        || !sendToGoogle(activityMyTracks.getString(R.string.export_google_spreadsheets))) {
+      return;
+    }
+    // Check whether all data is correct on Google Drive, Maps, Documents, and
+    // Spreadsheet.
+    // assertTrue(SyncTestUtils.checkFile(EndToEndTestUtils.trackName, true,
+    // SyncTestUtils.getGoogleDrive(activityMyTracks.getApplicationContext())));
+    assertTrue(GoogleUtils.deleteMap(EndToEndTestUtils.trackName, activityMyTracks));
+    assertTrue(GoogleUtils.searchFusionTableByTitle(EndToEndTestUtils.trackName, activityMyTracks,
+        GoogleUtils.ACCOUNT_NAME_1, true));
+    assertTrue(GoogleUtils.deleteTrackInSpreadSheet(EndToEndTestUtils.trackName, activityMyTracks,
+        GoogleUtils.ACCOUNT_NAME_1));
+  }
+
+  /**
+   * Sends a track to Google.
+   * 
+   * @param exportDestination destination to export
+   * @return true means send successfully
+   */
+  private boolean sendToGoogle(String exportDestination) {
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_export), true);
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.export_title));
+    instrumentation.waitForIdleSync();
+
+    EndToEndTestUtils.SOLO.clickOnText(exportDestination);
+
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.getButtonOnScreen(activityMyTracks.getString(R.string.menu_export), true,
+        true);
+
+    instrumentation.waitForIdleSync();
+    if (!GoogleUtils.isAccountAvailable()) {
+      return false;
+    }
+
+    // Following check the process of "Send to Google", the second condition is
+    // in case the export has done.
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.generic_progress_title))
+        || EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+            .getString(R.string.generic_success_title)));
+
+    // Waiting the send is finish. Should double check it for the progress
+    // dialog may disappear and display again while switch to next send(There
+    // are four sends currently, there are send to drive, maps, fusion table and
+    // spreadsheet).
+    while (EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.generic_progress_title), 1,
+        EndToEndTestUtils.SHORT_WAIT_TIME)
+        || EndToEndTestUtils.SOLO.waitForText(
+            activityMyTracks.getString(R.string.generic_progress_title), 1,
+            EndToEndTestUtils.SHORT_WAIT_TIME)) {}
+
+    if (exportDestination.endsWith(activityMyTracks.getString(R.string.export_google_maps))) {
+      // Check whether the result dialog is display.
+      assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+          .getString(R.string.share_track_share_url)));
+    } else {
+      assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+          .getString(R.string.generic_success_title)));
+    }
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+    return true;
+  }
+
+  /**
+   * Sends a large track to Google.
+   */
+  public void testSendLargeTrackToGoogle() {
+    EndToEndTestUtils.deleteAllTracks();
+    EndToEndTestUtils.createSimpleTrack(200, false);
+    instrumentation.waitForIdleSync();
+    checkSendTrackToGoogle();
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    EndToEndTestUtils.activityType = EndToEndTestUtils.DEFAULTACTIVITYTYPE;
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    super.tearDown();
+  }
+
+}
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.common;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.util.GoogleLocationUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+
+
+/**
+ * Tests the function of go to my location.
+ * 
+ * @author Youtao Liu
+ */
+public class GoToMyLocationTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Instrumentation instrumentation;
+  private TrackListActivity activityMyTracks;
+
+  public GoToMyLocationTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    activityMyTracks = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, activityMyTracks);
+  }
+
+  /**
+   * Tests the menu My Location.
+   */
+  public void testGotoMyLocation() {
+    EndToEndTestUtils.findAndClickMyLocation(activityMyTracks);
+    if (EndToEndTestUtils.isEmulator) {
+      String setting = activityMyTracks.getString(
+          GoogleLocationUtils.isAvailable(activityMyTracks) ? R.string.gps_google_location_settings
+              : R.string.gps_location_access);
+      EndToEndTestUtils.SOLO.waitForText(
+          activityMyTracks.getString(R.string.my_location_no_gps, setting), 1,
+          EndToEndTestUtils.SHORT_WAIT_TIME);
+    } else {
+      // TODO How to verify the location is shown on the map.
+    }
+  }
+  
+  @Override
+  protected void tearDown() throws Exception {
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    super.tearDown();
+  }
+
+}
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.common;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+import android.view.KeyEvent;
+import android.widget.ListView;
+
+/**
+ * Tests some menu items of MyTracks.
+ * 
+ * @author Youtao Liu
+ */
+public class MenuItemsTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Instrumentation instrumentation;
+  private TrackListActivity activityMyTracks;
+
+  public MenuItemsTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    activityMyTracks = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, activityMyTracks);
+  }
+
+  /**
+   * Tests following items in More menu.
+   * <ul>
+   * <li>Tests the aggregated statistics activity.</li>
+   * <li>Tests the Sensor state activity.</li>
+   * <li>Tests the help menu.</li>
+   * </ul>
+   */
+  public void testSomeMenuItems() {
+    // Menu in TrackListActivity.
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_aggregated_statistics),
+        true);
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.stats_distance));
+    EndToEndTestUtils.SOLO.goBack();
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.createTrackIfEmpty(1, false);
+    instrumentation.waitForIdleSync();
+    // Menu in TrackDetailActivity.
+    // When there is no sensor connected this menu will be hidden.
+    if (EndToEndTestUtils
+        .findMenuItem(activityMyTracks.getString(R.string.menu_sensor_state), true)) {
+      EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+          .getString(R.string.sensor_state_last_sensor_time));
+    }
+
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_help), true);
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.help_about), true, true);
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+  }
+
+  /**
+   * Tests search menu item. Checks the display and hide of record controller
+   * during search.
+   */
+  public void testSearch() {
+    EndToEndTestUtils.createSimpleTrack(0, true);
+    assertTrue(isControllerShown());
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_search), true);
+    assertFalse(isControllerShown());
+    EndToEndTestUtils.enterTextAvoidSoftKeyBoard(0, EndToEndTestUtils.trackName);
+    sendKeys(KeyEvent.KEYCODE_ENTER);
+    instrumentation.waitForIdleSync();
+    assertEquals(1, EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).size());
+    EndToEndTestUtils.SOLO.goBack();
+    assertTrue(isControllerShown());
+  }
+
+  /**
+   * Gets the status whether is controller is shown.
+   * 
+   * @return true mean the controller is display and false mean it is disappear
+   */
+  private boolean isControllerShown() {
+    return activityMyTracks.findViewById(R.id.track_controler_container).isShown();
+  }
+
+  /**
+   * Checks the voice frequency and split frequency menus during recording. When
+   * recording, they should be in both the menu and the recording settings. When
+   * not recording, they should only be in the recording settings.
+   */
+  public void testFrequencyMenu() {
+    EndToEndTestUtils.startRecording();
+
+    assertTrue(EndToEndTestUtils.findMenuItem(
+        activityMyTracks.getString(R.string.menu_voice_frequency), false));
+    assertTrue(EndToEndTestUtils.findMenuItem(
+        activityMyTracks.getString(R.string.menu_split_frequency), false));
+
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_recording));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(
+        activityMyTracks.getString(R.string.menu_voice_frequency), 1, true, true));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(
+        activityMyTracks.getString(R.string.menu_split_frequency), 1, true, true));
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.goBack();
+
+    EndToEndTestUtils.stopRecording(true);
+
+    assertFalse(EndToEndTestUtils.findMenuItem(
+        activityMyTracks.getString(R.string.menu_voice_frequency), false));
+    assertFalse(EndToEndTestUtils.findMenuItem(
+        activityMyTracks.getString(R.string.menu_split_frequency), false));
+
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_recording));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(
+        activityMyTracks.getString(R.string.menu_voice_frequency), 1, true, true));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(
+        activityMyTracks.getString(R.string.menu_split_frequency), 1, true, true));
+  }
+
+  /**
+   * Tests starting and stopping GPS.
+   */
+  public void testGPSMenu() {
+    boolean GPSStatus = EndToEndTestUtils.findMenuItem(
+        activityMyTracks.getString(R.string.menu_stop_gps), false);
+
+    // Following starting/stopping or stopping/starting GPS.
+    EndToEndTestUtils.findMenuItem(GPSStatus ? activityMyTracks.getString(R.string.menu_stop_gps)
+        : activityMyTracks.getString(R.string.menu_start_gps), true);
+    GPSStatus = !GPSStatus;
+    EndToEndTestUtils.waitTextToDisappear(GPSStatus ? activityMyTracks
+        .getString(R.string.menu_start_gps) : activityMyTracks.getString(R.string.menu_stop_gps));
+    assertEquals(GPSStatus,
+        EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_stop_gps), false));
+
+    EndToEndTestUtils.findMenuItem(GPSStatus ? activityMyTracks.getString(R.string.menu_stop_gps)
+        : activityMyTracks.getString(R.string.menu_start_gps), true);
+    GPSStatus = !GPSStatus;
+    EndToEndTestUtils.waitTextToDisappear(GPSStatus ? activityMyTracks
+        .getString(R.string.menu_start_gps) : activityMyTracks.getString(R.string.menu_stop_gps));
+    assertEquals(GPSStatus,
+        EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_stop_gps), false));
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    super.tearDown();
+  }
+
+}
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.common;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationIterator;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.services.TrackRecordingService;
+
+import android.app.Instrumentation;
+import android.location.Location;
+import android.test.ActivityInstrumentationTestCase2;
+
+
+/**
+ * Tests the pause and resume of recording.
+ * 
+ * @author Youtao Liu
+ */
+public class PauseRecordingTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Instrumentation instrumentation;
+  private TrackListActivity activityMyTracks;
+
+  public PauseRecordingTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    activityMyTracks = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, activityMyTracks);
+  }
+
+  /**
+   * Tests the pause recording feature. Stops the recording after pause.
+   */
+  public void testPauseRecording_stopAfterPause() {
+    int gpsSignalNumber = 3;
+
+    EndToEndTestUtils.checkNotRecording();
+    // Start recording
+    EndToEndTestUtils.startRecording();
+    EndToEndTestUtils.checkUnderRecording();
+    EndToEndTestUtils.sendGps(gpsSignalNumber);
+
+    // Pause
+    EndToEndTestUtils.pauseRecording();
+    EndToEndTestUtils.checkUnderPaused();
+    EndToEndTestUtils.sendGps(gpsSignalNumber, gpsSignalNumber);
+
+    // Stop
+    EndToEndTestUtils.stopRecording(true);
+    checkPointsInPausedTrack(gpsSignalNumber, 1, 0);
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.checkNotRecording();
+  }
+
+  /**
+   * Tests the pause recording feature. Stops the recording after resume.
+   */
+  public void testPauseRecording_stopAfterResume() {
+    int gpsSignalNumber = 3;
+
+    EndToEndTestUtils.checkNotRecording();
+    // Start recording
+    EndToEndTestUtils.startRecording();
+    EndToEndTestUtils.checkUnderRecording();
+    EndToEndTestUtils.sendGps(gpsSignalNumber);
+
+    // Pause
+    EndToEndTestUtils.pauseRecording();
+    EndToEndTestUtils.checkUnderPaused();
+
+    // Send Gps signal after pause.
+    // Add 10 to make these signals are apparently different.
+    EndToEndTestUtils.sendGps(gpsSignalNumber, gpsSignalNumber + 10, 10);
+
+    // Resume
+    EndToEndTestUtils.resumeRecording();
+    EndToEndTestUtils.checkUnderRecording();
+    EndToEndTestUtils.sendGps(gpsSignalNumber, gpsSignalNumber);
+
+    // Stop
+    EndToEndTestUtils.stopRecording(true);
+    checkPointsInPausedTrack(gpsSignalNumber * 2, 1, 1);
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.checkNotRecording();
+  }
+
+  /**
+   * Check the points in the last track.
+   * 
+   * @param expectPointNumber the number of location points
+   * @param expectPauseNumber the number of pause points
+   * @param expectResumeNumber the number of resume points
+   */
+  private void checkPointsInPausedTrack(int expectPointNumber, int expectPauseNumber,
+      int expectResumeNumber) {
+    if (EndToEndTestUtils.isEmulator) {
+      int numberOfPoints = 0;
+      int numberOfPausePoint = 0;
+      int numberOfResumePoint = 0;
+
+      MyTracksProviderUtils providerUtils = MyTracksProviderUtils.Factory.get(activityMyTracks
+          .getApplicationContext());
+      long trackId = providerUtils.getLastTrack().getId();
+      LocationIterator points = providerUtils.getTrackPointLocationIterator(trackId, 0, false,
+          MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+      while (points.hasNext()) {
+        Location onePoint = points.next();
+        double latitude = onePoint.getLatitude();
+        double longitude = onePoint.getLongitude();
+        if (latitude == TrackRecordingService.PAUSE_LATITUDE) {
+          numberOfPausePoint++;
+        } else if (latitude == TrackRecordingService.RESUME_LATITUDE) {
+          numberOfResumePoint++;
+        } else {
+          assertEquals(numberOfPoints, (int) ((latitude - EndToEndTestUtils.START_LATITUDE)
+              / EndToEndTestUtils.DELTA_LADITUDE + 0.5));
+          assertEquals(numberOfPoints, (int) ((longitude - EndToEndTestUtils.START_LONGITUDE)
+              / EndToEndTestUtils.DELTA_LONGITUDE + 0.5));
+          numberOfPoints++;
+        }
+      }
+
+      assertEquals(expectPointNumber, numberOfPoints);
+      assertEquals(expectPauseNumber, numberOfPausePoint);
+      assertEquals(expectResumeNumber, numberOfResumePoint);
+    }
+  }
+  
+  @Override
+  protected void tearDown() throws Exception {
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    super.tearDown();
+  }
+
+}
@@ -0,0 +1,483 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.common;
+
+import com.google.android.apps.mytracks.ChartView;
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.endtoendtest.GoogleUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Instrumentation;
+import android.content.Context;
+import android.test.ActivityInstrumentationTestCase2;
+import android.util.Log;
+import android.widget.CheckBox;
+import android.widget.ListView;
+
+import java.util.ArrayList;
+
+/**
+ * Tests the setting of MyTracks.
+ * 
+ * @author Youtao Liu
+ */
+public class SettingTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Instrumentation instrumentation;
+  private TrackListActivity activityMyTracks;
+
+  public SettingTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    activityMyTracks = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, activityMyTracks);
+  }
+
+  /**
+   * Changes some settings and then reset them. This test case tests three
+   * points:
+   * <ul>
+   * <li>Resets all settings.</li>
+   * <li>Changes the setting of Display.</li>
+   * <li>Changes the setting of Sharing.</li>
+   * </ul>
+   */
+  public void testChangeAndReset() {
+    // Reset all settings.
+    EndToEndTestUtils.resetAllSettings(activityMyTracks, true);
+    // Change a setting of Map.
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_stats_tab));
+    instrumentation.waitForIdleSync();
+
+    // Rotate on a sub setting page.
+    EndToEndTestUtils.rotateCurrentActivity();
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.settings_stats_units_title));
+    ArrayList<CheckBox> displayCheckBoxs = EndToEndTestUtils.SOLO.getCurrentViews(CheckBox.class);
+    boolean useMetric = displayCheckBoxs.get(0).isChecked();
+    EndToEndTestUtils.SOLO.clickOnCheckBox(0);
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.goBack();
+
+    // Change a setting of sharing.
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_sharing));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.settings_sharing_allow_access), 1,
+        EndToEndTestUtils.NORMAL_WAIT_TIME));
+    ArrayList<CheckBox> sharingCheckBoxs = EndToEndTestUtils.SOLO.getCurrentViews(CheckBox.class);
+    boolean newMapsPublic = sharingCheckBoxs.get(0).isChecked();
+    EndToEndTestUtils.SOLO.clickOnCheckBox(0);
+    instrumentation.waitForIdleSync();
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.settings_sharing_allow_access_confirm_message), 1,
+        EndToEndTestUtils.NORMAL_WAIT_TIME));
+    EndToEndTestUtils.SOLO.clickOnButton(activityMyTracks.getString(R.string.generic_yes));
+    instrumentation.waitForIdleSync();
+    assertEquals(!newMapsPublic, EndToEndTestUtils.SOLO.getCurrentViews(CheckBox.class).get(0)
+        .isChecked());
+    EndToEndTestUtils.SOLO.goBack();
+
+    // Reset all settings.
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_backup_reset));
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_reset));
+    EndToEndTestUtils.getButtonOnScreen(activityMyTracks.getString(R.string.generic_yes), true,
+        true);
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.settings_reset_done), 1,
+        EndToEndTestUtils.SHORT_WAIT_TIME);
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.goBack();
+
+    // Check settings.
+    // Add following scroll up for a bug of Robotium.
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.track_detail_stats_tab),
+        1, EndToEndTestUtils.NORMAL_WAIT_TIME);
+    EndToEndTestUtils.SOLO.scrollUp();
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_stats_tab));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.settings_stats_units_title), 1,
+        EndToEndTestUtils.LONG_WAIT_TIME));
+    displayCheckBoxs = EndToEndTestUtils.SOLO.getCurrentViews(CheckBox.class);
+    Log.i(EndToEndTestUtils.LOG_TAG, "useMetric:" + useMetric);
+    assertEquals(useMetric, displayCheckBoxs.get(0).isChecked());
+
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_sharing));
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.settings_sharing_allow_access));
+    sharingCheckBoxs = EndToEndTestUtils.SOLO.getCurrentViews(CheckBox.class);
+    assertEquals(newMapsPublic, sharingCheckBoxs.get(0).isChecked());
+  }
+
+  /**
+   * Tests the change of preferred units.
+   */
+  public void testChangePreferredUnits() {
+    EndToEndTestUtils.createTrackIfEmpty(5, false);
+
+    // Change it and verify it.
+    ChangePreferredUnits();
+
+    // Change it back and verify it.
+    ChangePreferredUnits();
+  }
+
+  /**
+   * Tests the change of stats settings during recording on chart view.
+   */
+  public void testChangeStatsSettings_underRecording_chart() {
+    EndToEndTestUtils.startRecording();
+
+    // Test just change preferred units when display CHART tab.
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_chart_tab));
+    EndToEndTestUtils.sendGps(3);
+    ChangeStatsSettings(true, false, false, false);
+    EndToEndTestUtils.sendGps(3, 3);
+    EndToEndTestUtils.stopRecording(true);
+
+  }
+
+  /**
+   * Tests the change of stats settings during recording on stats tab.
+   */
+  public void testChangeStatsSettings_underRecording_stats() {
+    EndToEndTestUtils.startRecording();
+    // Test change preferred units and preferred rate when display STATS tab.
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_stats_tab));
+    EndToEndTestUtils.sendGps(3);
+    ChangeStatsSettings(true, true, false, false);
+    EndToEndTestUtils.sendGps(3, 3);
+    EndToEndTestUtils.stopRecording(true);
+
+  }
+
+  /**
+   * Tests displaying elevation, grade and latitude and longitude information in
+   * Stats tab.
+   */
+  public void testChangeStatsSettings_showExtraInfos() {
+    EndToEndTestUtils.resetAllSettings(activityMyTracks, false);
+    ChangeStatsSettings(false, false, true, true);
+    EndToEndTestUtils.startRecording();
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_stats_tab));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.stats_elevation), 1,
+        EndToEndTestUtils.NORMAL_WAIT_TIME, true));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.stats_grade)));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.stats_latitude)));
+
+    EndToEndTestUtils.stopRecording(true);
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.stats_elevation), 1,
+        EndToEndTestUtils.NORMAL_WAIT_TIME, true));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.stats_grade)));
+    assertFalse(EndToEndTestUtils.SOLO.searchText(activityMyTracks
+        .getString(R.string.stats_latitude)));
+  }
+
+  /**
+   * Changes settings of preferred units and preferred rate.
+   * 
+   * @param changeUnits is change the preferred unit
+   * @param changeRate is change the preferred rate
+   * @param changeGradeElevation is change the grade and elevation
+   * @param changeLatLong is change the latitude and longitude
+   */
+  private void ChangeStatsSettings(boolean changeUnits, boolean changeRate,
+      boolean changeGradeElevation, boolean changeLatLong) {
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_stats_tab));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.settings_stats_units_title)));
+
+    // Change preferred units.
+    if (changeUnits) {
+      boolean isImperial = EndToEndTestUtils.findTextViewInView(
+          activityMyTracks.getString(R.string.settings_stats_units_imperial),
+          EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0)) != null;
+
+      // Change preferred units.
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+          .getString(R.string.settings_stats_units_title));
+      if (isImperial) {
+        EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.unit_kilometer));
+      } else {
+        EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.unit_feet));
+      }
+    }
+    if (changeRate) {
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+          .getString(R.string.settings_stats_rate_title));
+    }
+    if (changeGradeElevation) {
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+          .getString(R.string.settings_stats_grade_elevation));
+    }
+    if (changeLatLong) {
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+          .getString(R.string.settings_stats_coordinate));
+    }
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.goBack();
+  }
+
+  /**
+   * Changes PreferredUnits and verifies the change.
+   */
+  private void ChangePreferredUnits() {
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_stats_tab));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.settings_stats_units_title)));
+
+    boolean isImperial = EndToEndTestUtils.findTextViewInView(activityMyTracks
+        .getString(R.string.settings_stats_units_imperial),
+        EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0)) != null;
+
+    // Change preferred units.
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_stats_units_title));
+    if (isImperial) {
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.unit_kilometer));
+    } else {
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.unit_feet));
+    }
+    isImperial = !isImperial;
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_chart_tab));
+    instrumentation.waitForIdleSync();
+    ChartView chartView = EndToEndTestUtils.getChartView();
+    assertEquals(!isImperial, chartView.isMetricUnits());
+  }
+
+  /**
+   * Tests the backup.
+   */
+  public void testBackup() {
+    // Delete all backup at first.
+    EndToEndTestUtils.deleteExportedFiles(EndToEndTestUtils.BACKUPS);
+    EndToEndTestUtils.createTrackIfEmpty(3, true);
+
+    // Write to SD card.
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_backup_reset));
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_backup));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.settings_backup_now_success), 0,
+        EndToEndTestUtils.SUPER_LONG_WAIT_TIME));
+    instrumentation.waitForIdleSync();
+
+    // Delete all tracks.
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.deleteAllTracks();
+    instrumentation.waitForIdleSync();
+
+    // Read from SD card.
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_backup_reset));
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_backup));
+    EndToEndTestUtils.SOLO
+        .clickOnText(activityMyTracks.getString(R.string.settings_backup_restore));
+    EndToEndTestUtils.getButtonOnScreen(activityMyTracks.getString(R.string.generic_yes), true,
+        true);
+
+    // Now there should be 2 backups.
+    instrumentation.waitForIdleSync();
+    assertEquals(2, EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount());
+
+    // Click the first one.
+    EndToEndTestUtils.SOLO.clickOnView(EndToEndTestUtils.SOLO.getCurrentViews(ListView.class)
+        .get(0).getChildAt(0));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.settings_backup_restore_success), 0,
+        EndToEndTestUtils.SUPER_LONG_WAIT_TIME));
+
+    // Check restore track.
+    instrumentation.waitForIdleSync();
+    boolean isContainTrack = EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.trackName);
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_backup_reset));
+    EndToEndTestUtils.SOLO
+        .clickOnText(activityMyTracks.getString(R.string.settings_backup_restore));
+    EndToEndTestUtils.getButtonOnScreen(activityMyTracks.getString(R.string.generic_yes), true,
+        true);
+    instrumentation.waitForIdleSync();
+
+    // Click the second one.
+    EndToEndTestUtils.SOLO.clickOnView(EndToEndTestUtils.SOLO.getCurrentViews(ListView.class)
+        .get(0).getChildAt(1));
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.settings_backup_restore_success), 0,
+        EndToEndTestUtils.SUPER_LONG_WAIT_TIME));
+
+    // For the older backup contains tracks and the newer backup is empty. The
+    // search result of twice must be different.
+    instrumentation.waitForIdleSync();
+    assertTrue(isContainTrack != EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.trackName));
+  }
+
+  /**
+   * Tests the setting of recording. This test changes the default name and
+   * activity of tracks, and the creates a new track to check it.
+   */
+  public void testRecording() {
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_recording));
+
+    // Changes the setting of recording name.
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_recording_track_name_title));
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_recording_track_name_number_option));
+
+    // Changes the setting of default activity.
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_recording_default_activity_title));
+    EndToEndTestUtils.enterTextAvoidSoftKeyBoard(0, EndToEndTestUtils.activityType);
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.goBack();
+
+    EndToEndTestUtils.startRecording();
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.stopRecording(false);
+    instrumentation.waitForIdleSync();
+    assertTrue(EndToEndTestUtils.SOLO.searchText(activityMyTracks.getString(
+        R.string.track_name_format).split(" ")[0]));
+    assertTrue(EndToEndTestUtils.SOLO.searchText(EndToEndTestUtils.activityType));
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.generic_save));
+  }
+
+  /**
+   * Tests the setting of fixed track color settings.
+   */
+  public void testTrackColorSettings_fixed() {
+    Context context = activityMyTracks.getApplicationContext();
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.menu_map));
+    String errorString = "error";
+
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_map_track_color_mode));
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_map_track_color_mode_fixed));
+    EndToEndTestUtils.waitTextToDisappear(activityMyTracks
+        .getString(R.string.settings_map_track_color_mode_dynamic_value));
+    assertEquals(activityMyTracks.getString(R.string.settings_map_track_color_mode_fixed_value),
+        PreferencesUtils.getString(context, R.string.track_color_mode_key, errorString));
+  }
+
+  /**
+   * Tests the setting of dynamic track color settings.
+   */
+  public void testTrackColorSettings_dynamic() {
+    Context context = activityMyTracks.getApplicationContext();
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.menu_map));
+    String errorString = "error";
+
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_map_track_color_mode));
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_map_track_color_mode_dynamic));
+    EndToEndTestUtils.waitTextToDisappear(activityMyTracks
+        .getString(R.string.settings_map_track_color_mode_dynamic_value));
+    assertEquals(activityMyTracks.getString(R.string.settings_map_track_color_mode_dynamic_value),
+        PreferencesUtils.getString(context, R.string.track_color_mode_key, errorString));
+  }
+
+  /**
+   * Tests the setting of single track color settings.
+   */
+  public void testTrackColorSettings_single() {
+    Context context = activityMyTracks.getApplicationContext();
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.menu_map));
+    String errorString = "error";
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_map_track_color_mode));
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_map_track_color_mode_single));
+    EndToEndTestUtils.waitTextToDisappear(activityMyTracks
+        .getString(R.string.settings_map_track_color_mode_dynamic_value));
+    assertEquals(activityMyTracks.getString(R.string.settings_map_track_color_mode_single_value),
+        PreferencesUtils.getString(context, R.string.track_color_mode_key, errorString));
+  }
+
+  /**
+   * Tests the setting and menu item of sync.
+   */
+  public void testSyncNowMenu() {
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.settings_google));
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks
+        .getString(R.string.settings_google_account_title));
+
+    // Whether test account is bound.
+    if (EndToEndTestUtils.SOLO.waitForText(GoogleUtils.ACCOUNT_NAME_1, 1,
+        EndToEndTestUtils.TINY_WAIT_TIME)) {
+      EndToEndTestUtils.SOLO.clickOnText(GoogleUtils.ACCOUNT_NAME_1);
+      instrumentation.waitForIdleSync();
+      EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.menu_sync_drive));
+      assertTrue(EndToEndTestUtils.findTextView(
+          activityMyTracks.getString(R.string.menu_sync_drive)).isEnabled());
+    } else {
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.value_none));
+      instrumentation.waitForIdleSync();
+      EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.menu_sync_drive));
+      assertFalse(EndToEndTestUtils.findTextView(
+          activityMyTracks.getString(R.string.menu_sync_drive)).isEnabled());
+      return;
+    }
+
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.menu_sync_drive));
+
+    boolean isSyncChecked = false;
+    if (EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.sync_drive_confirm_message).split("%")[0], 1,
+        EndToEndTestUtils.SHORT_WAIT_TIME)) {
+      isSyncChecked = true;
+    } else {
+      isSyncChecked = false;
+    }
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.generic_yes));
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.goBack();
+    assertEquals(isSyncChecked,
+        EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_refresh), false));
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    super.tearDown();
+  }
+
+}
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2013 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.common;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.endtoendtest.GoogleUtils;
+import com.google.android.apps.mytracks.endtoendtest.sync.SyncTestUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+import android.widget.CheckBox;
+
+import java.util.ArrayList;
+
+/**
+ * Tests the share feature.
+ * 
+ * @author youtaol
+ */
+public class ShareTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Instrumentation instrumentation;
+  private TrackListActivity activityMyTracks;
+
+  public ShareTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    activityMyTracks = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, activityMyTracks);
+  }
+
+  /**
+   * Tests the share one track.
+   */
+  public void testShare() {
+    EndToEndTestUtils.resetAllSettings(activityMyTracks, false);
+    EndToEndTestUtils.createTrackIfEmpty(0, false);
+
+    // Click share again and confirm the share.
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_share), true);
+    // Whether can found any account.
+    if (EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.send_google_no_account_title), 1,
+        EndToEndTestUtils.VERY_SHORT_WAIT_TIME)) {
+      EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.generic_ok));
+      return;
+    }
+
+    boolean isAccount2Bound = false;
+    // If Choose account dialog prompt, choose the first account.
+    if (EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.send_google_choose_account_title), 1,
+        EndToEndTestUtils.SHORT_WAIT_TIME)) {
+      // Whether can found account2.
+      if (EndToEndTestUtils.SOLO.waitForText(GoogleUtils.ACCOUNT_NAME_2, 1,
+          EndToEndTestUtils.VERY_SHORT_WAIT_TIME)) {
+        isAccount2Bound = true;
+      }
+      EndToEndTestUtils.SOLO.clickOnText(GoogleUtils.ACCOUNT_NAME_1);
+      EndToEndTestUtils.getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true,
+          true);
+    }
+
+    // Check all check boxes.
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.share_track_title)));
+    ArrayList<CheckBox> checkBoxs = EndToEndTestUtils.SOLO.getCurrentViews(CheckBox.class);
+    for (int i = 0; i < checkBoxs.size(); i++) {
+      if (!checkBoxs.get(i).isChecked()) {
+        EndToEndTestUtils.SOLO.clickOnView(checkBoxs.get(i));
+        instrumentation.waitForIdleSync();
+      }
+    }
+
+    // Input account to share and click OK button.
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(activityMyTracks
+        .getString(R.string.share_track_emails_hint)));
+    EndToEndTestUtils.enterTextAvoidSoftKeyBoard(0, GoogleUtils.ACCOUNT_NAME_2);
+    EndToEndTestUtils
+        .getButtonOnScreen(activityMyTracks.getString(R.string.generic_ok), true, true);
+
+    // Waiting the send is finish.
+    while (EndToEndTestUtils.SOLO.waitForText(
+        activityMyTracks.getString(R.string.generic_progress_title), 1,
+        EndToEndTestUtils.SHORT_WAIT_TIME)) {}
+
+    assertTrue(EndToEndTestUtils.SOLO.waitForText(EndToEndTestUtils.SOLO
+        .getString(R.string.share_track_share_url_title)));
+    EndToEndTestUtils.SOLO.goBack();
+
+    // Make more checks if the second account is also bound with this device.
+    if (isAccount2Bound) {
+      EndToEndTestUtils.SOLO.goBack();
+      SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_2);
+      EndToEndTestUtils.findMenuItem(
+          EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+
+      assertTrue(EndToEndTestUtils.SOLO.waitForText(
+          activityMyTracks.getString(R.string.track_list_shared_with_me), 1,
+          EndToEndTestUtils.SUPER_LONG_WAIT_TIME));
+      assertTrue(EndToEndTestUtils.SOLO.waitForText(EndToEndTestUtils.trackName, 1,
+          EndToEndTestUtils.SUPER_LONG_WAIT_TIME));
+    }
+  }
+}
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.common;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.fragments.MyTracksMapFragment;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Instrumentation;
+import android.graphics.Point;
+import android.os.Build;
+import android.test.ActivityInstrumentationTestCase2;
+import android.util.Log;
+import android.view.Display;
+import android.view.View;
+import android.widget.TextView;
+
+import junit.framework.Assert;
+
+/**
+ * Tests switching views and the menu list of each view.
+ * 
+ * @author Youtao Liu
+ */
+public class ViewsTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Instrumentation instrumentation;
+  private TrackListActivity activityMyTracks;
+
+  public ViewsTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    activityMyTracks = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, activityMyTracks);
+  }
+
+  /**
+   * Switches view from {@link MyTracksMapFragment} to @ ChartFragment} , then
+   * changes to @ StatsFragment} . Finally back to {@link MyTracksMapFragment}.
+   * And check some menus in these views. In MapFragment, the menu should
+   * contain satellite/map mode. In ChartFragment and StatsFragment, the menu
+   * should not contain satellite/map mode.
+   */
+  public void testSwitchViewsAndMenusOfView() {
+    EndToEndTestUtils.createTrackIfEmpty(3, true);
+
+    EndToEndTestUtils.SOLO.scrollUp();
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.trackName, 1, true);
+
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_chart_tab));
+    EndToEndTestUtils.rotateCurrentActivity();
+
+    assertTrue(EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings),
+        false));
+    assertFalse(EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_map_layer),
+        false));
+
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_stats_tab));
+    assertTrue(EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings),
+        false));
+    assertFalse(EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_map_layer),
+        false));
+
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.track_detail_map_tab));
+    EndToEndTestUtils.rotateCurrentActivity();
+    assertTrue(EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_settings),
+        false));
+    assertTrue(EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_map_layer),
+        false));
+  }
+
+  /**
+   * Tests the switch between satellite mode and map mode.
+   */
+  public void testSatelliteAndMapView() {
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.createTrackIfEmpty(1, false);
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.track_detail_chart_tab));
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_map_layer), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.menu_terrain));
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.track_detail_chart_tab));
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_map_layer), true);
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.menu_satellite));
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.waitForText(activityMyTracks.getString(R.string.track_detail_chart_tab));
+    EndToEndTestUtils.findMenuItem(activityMyTracks.getString(R.string.menu_map_layer), true);
+    // But in some languages only has one match(Such as French).
+    EndToEndTestUtils.SOLO.clickOnText(activityMyTracks.getString(R.string.menu_map));
+    // The first match maybe a noise(The title of the radio dialog) for some
+    // language(Such as English), we should click the second one.
+    TextView text = EndToEndTestUtils.findTextViewByIndex(
+        activityMyTracks.getString(R.string.menu_map), 2);
+    if (text != null) {
+      EndToEndTestUtils.SOLO.clickOnView(text);
+    }
+  }
+
+  /**
+   * Tests the position of track controller in landscape view and portrait view
+   * on different activities.
+   */
+  public void testTrackControllerPostion() {
+    checkTrackController();
+    EndToEndTestUtils.rotateCurrentActivity();
+    instrumentation.waitForIdleSync();
+    checkTrackController();
+
+    EndToEndTestUtils.startRecording();
+    instrumentation.waitForIdleSync();
+    checkTrackController();
+    EndToEndTestUtils.rotateCurrentActivity();
+    instrumentation.waitForIdleSync();
+    checkTrackController();
+
+    EndToEndTestUtils.stopRecording(true);
+  }
+
+  /**
+   * Checks the position of track controller in landscape view and portrait
+   * view.
+   */
+  @SuppressWarnings("deprecation")
+  private void checkTrackController() {
+    View controller = EndToEndTestUtils.SOLO.getCurrentActivity().findViewById(
+        R.id.track_controler_container);
+
+    Display display = EndToEndTestUtils.SOLO.getCurrentActivity().getWindowManager()
+        .getDefaultDisplay();
+    Point size = new Point();
+    if (Build.VERSION.SDK_INT >= 13) {
+      display.getSize(size);
+    } else {
+      size.x = display.getWidth();
+      size.y = display.getHeight();
+    }
+    int width = size.x;
+    int height = size.y;
+
+    Log.i(EndToEndTestUtils.LOG_TAG, width + ":" + height);
+
+    // In landscape view
+    if (width > height) {
+      Assert.assertTrue(controller.getWidth() < controller.getHeight());
+      Assert.assertTrue(controller.getTop() < height / 2);
+      Assert.assertTrue(controller.getRight() < width / 2);
+    }
+
+    // In portrait view
+    else {
+      Assert.assertTrue(controller.getWidth() > controller.getHeight());
+      Log.i(EndToEndTestUtils.LOG_TAG, controller.getTop() + ":" + controller.getRight());
+
+      Assert.assertTrue(controller.getTop() > height / 2);
+      Assert.assertTrue(controller.getRight() > width / 2);
+    }
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    super.tearDown();
+  }
+
+}
@@ -0,0 +1,153 @@
+package com.google.android.apps.mytracks.endtoendtest.others;
+
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.ActivityManager.RunningAppProcessInfo;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Environment;
+import android.util.Log;
+import android.view.Window;
+import android.view.WindowManager.LayoutParams;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStreamWriter;
+import java.util.Date;
+import java.util.List;
+
+import junit.framework.Assert;
+
+/**
+ * A utility to support the big test cases, such as sensor test, stress test and
+ * so forth which under the package
+ * {@link com.google.android.apps.mytracks.endtoendtest.others}.
+ * 
+ * @author Youtao Liu
+ */
+public class BigTestUtils {
+
+  public static final String DISABLE_MESSAGE = "This test is disabled";
+  public static final String MYTRACKS_PROCESS_NAME = "com.google.android.maps.mytracks";
+  public static final String MYTRACKS_TEST_INFO_FILE = "MyTracksTestInfo.txt";
+
+  /**
+   * Gets the memory usage of MyTracks process. This method would get the Pss
+   * memory. Pss is the amount of memory shared with other processes, accounted
+   * in a way that the amount is divided evenly between the processes that share
+   * it. This is memory that would not be released if the process was
+   * terminated, but is indicative of the amount that this process is
+   * "contributing" to the overall memory load.
+   * 
+   * @param context
+   */
+  public static String getMyTracksPssMemoryInfo(Context context) {
+    int MyTracksProcessId = -1;
+    ActivityManager activityManager = (ActivityManager) context
+        .getSystemService(Activity.ACTIVITY_SERVICE);
+    List<RunningAppProcessInfo> runningAppProcesses = activityManager.getRunningAppProcesses();
+
+    for (RunningAppProcessInfo runningAppProcessInfo : runningAppProcesses) {
+      if (runningAppProcessInfo.processName.equalsIgnoreCase(MYTRACKS_PROCESS_NAME)) {
+        MyTracksProcessId = runningAppProcessInfo.pid;
+        break;
+      }
+    }
+    if (MyTracksProcessId == -1) {
+      Assert.fail();
+    }
+    int pids[] = { MyTracksProcessId };
+    android.os.Debug.MemoryInfo[] memoryInfoArray = activityManager.getProcessMemoryInfo(pids);
+    int memoryUsage = memoryInfoArray[0].getTotalPss();
+    return String.format(" MyTracks TotalPss Memory: %d (kB) ", memoryUsage);
+  }
+
+  /**
+   * Gets the battery info of device, and then writes it to a file.
+   * 
+   * @param context the context of application
+   */
+  public static String getBatteryUsageInfo(Context context) {
+    Intent batteryIntent = context.getApplicationContext().registerReceiver(null,
+        new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
+    int rawlevel = batteryIntent.getIntExtra("level", -1);
+    double scale = batteryIntent.getIntExtra("scale", -1);
+    return String.format("Device has %s of %s battery left", rawlevel, scale);
+  }
+
+  /**
+   * Writes a string to battery info file. This method would add a time string
+   * before the given value.
+   * 
+   * @param string string to write
+   * @param isAppend true means append to file
+   */
+  public static void writeToFile(String string, boolean isAppend) {
+    String path = Environment.getExternalStorageDirectory() + File.separator
+        + MYTRACKS_TEST_INFO_FILE;
+    try {
+      FileOutputStream fileOutputStream = new FileOutputStream(new File(path), isAppend);
+      OutputStreamWriter osw = new OutputStreamWriter(fileOutputStream);
+
+      try {
+        // Write the string to the file
+        osw.write(string);
+      } finally {
+        osw.flush();
+        osw.close();
+      }
+    } catch (Exception e) {
+      Log.i(EndToEndTestUtils.LOG_TAG, "Meet error when write test info to file.");
+    }
+    return;
+  }
+
+  /**
+   * Monitors the battery and memory usage during test, and writes the usage
+   * info to a local file.
+   * 
+   * @param context application context
+   * @param interval the milliseconds to get usage info
+   * @param testTime the total test milliseconds
+   */
+  public static void moniterTest(Context context, int interval, int testTime) {
+    long startTime = System.currentTimeMillis();
+
+    while ((System.currentTimeMillis() - startTime) < testTime) {
+      String memoryUsageString = getMyTracksPssMemoryInfo(context);
+      String batteryUsageString = getBatteryUsageInfo(context);
+      String oneInfo = String.format("{%s: memory use %s, battery left %s. \r\n",
+          String.format("{%1$tm/%1$td/%1$tY %1$tH:%1$tM:%1$tS", new Date()), memoryUsageString,
+          batteryUsageString);
+      writeToFile(oneInfo, true);
+      Log.i(EndToEndTestUtils.LOG_TAG, oneInfo);
+      EndToEndTestUtils.sleep(interval);
+    }
+  }
+
+  /**
+   * Unlocks and wakes up the device.
+   */
+  public static void unlockAndWakeupDevice() {
+    // The menu item of setting should be found if the screen is not locked.
+    try {
+      EndToEndTestUtils.SOLO.getCurrentActivity().runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+          Window wind = EndToEndTestUtils.SOLO.getCurrentActivity().getWindow();
+          wind.addFlags(LayoutParams.FLAG_DISMISS_KEYGUARD);
+          wind.addFlags(LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+          wind.addFlags(LayoutParams.FLAG_TURN_SCREEN_ON);
+        }
+      });
+
+    } catch (Exception e) {
+      Log.i(EndToEndTestUtils.LOG_TAG,
+          "Meet error when unlock device screen, may the device is not locked.");
+    }
+  }
+
+}
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.others;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.endtoendtest.RunConfiguration;
+import com.google.android.maps.mytracks.R;
+
+import android.app.AlertDialog;
+import android.app.Instrumentation;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.test.ActivityInstrumentationTestCase2;
+import android.util.Log;
+
+/**
+ * Tests the battery and memory usage of long tracks. As this test may be run a
+ * long time test and without connect to desktop computer during test. The test
+ * result will be recorded to a file. And at the beginning of test, it need
+ * user's confirm by click a button.
+ * 
+ * @author Youtao Liu
+ */
+public class ResourceUsageTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  public ResourceUsageTest() {
+    super(TrackListActivity.class);
+  }
+
+  private Instrumentation instrumentation;
+  private TrackListActivity trackListActivity;
+  private boolean runTest = false;
+  private static boolean isUserConfirmed = false;
+  private Context context;
+  /**
+   * Default duration for each test is half one hour.
+   */
+  private int TEST_DURATION_IN_MILLISECONDS = 30 * 60 * 1000;
+  private int INTERVALE_TO_CHECK = 5 * 60 * 1000;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    runTest = RunConfiguration.runResourceUsageTest;
+    if (!runTest) {
+      return;
+    }
+    instrumentation = getInstrumentation();
+    trackListActivity = getActivity();
+    context = trackListActivity.getApplicationContext();
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.setupForDebug(instrumentation, trackListActivity);
+    BigTestUtils.unlockAndWakeupDevice();
+    if (!isUserConfirmed) {
+      confirmTest();
+    }
+    BigTestUtils.writeToFile("Test case start:" + getName() + "\r\n", true);
+  }
+
+  /**
+   * Prompts a dialog to make user confirm whether start the test.
+   */
+  private void confirmTest() {
+    try {
+      trackListActivity.runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+          new AlertDialog.Builder(EndToEndTestUtils.SOLO.getCurrentActivity())
+              .setTitle("Confirm long time test.")
+              .setMessage(
+                  String
+                      .format(
+                          "Please disconnect the power cord of your device and click 'Start' button. Each case need run %d minutes, and the battery/memory usage will be recorded in every %d minutes.",
+                          TEST_DURATION_IN_MILLISECONDS / 1000 / 60, INTERVALE_TO_CHECK / 60 / 1000))
+              .setPositiveButton("Start Test", new DialogInterface.OnClickListener() {
+                public void onClick(DialogInterface dialog, int which) {
+                  isUserConfirmed = true;
+                  runTest = true;
+                  BigTestUtils.writeToFile("Test start:\r\n", false);
+                }
+              }).setNegativeButton("Cancel Test", new DialogInterface.OnClickListener() {
+                public void onClick(DialogInterface dialog, int which) {
+                  isUserConfirmed = true;
+                  runTest = false;
+                  fail();
+                }
+              }).show();
+        }
+      });
+    } catch (Throwable e) {
+      Log.i(EndToEndTestUtils.LOG_TAG, "Meet error when create confirm dialog.");
+    }
+    // Waiting user confirm the testing
+    while (!isUserConfirmed) {
+      EndToEndTestUtils.sleep(EndToEndTestUtils.TINY_WAIT_TIME);
+    }
+  }
+
+  /**
+   * Tests the resource usage when display track list activity during recording.
+   */
+  public void testBatteryUsage_showTrackList() {
+    recordingLongTrack(true, R.string.track_detail_map_tab);
+  }
+
+  /**
+   * Tests the resource usage when display map view during recording.
+   */
+  public void testBatteryUsage_showMapView() {
+    recordingLongTrack(false, R.string.track_detail_map_tab);
+  }
+
+  /**
+   * Tests the resource usage when display chart view during recording.
+   */
+  public void testBatteryUsage_showChartView() {
+    recordingLongTrack(false, R.string.track_detail_chart_tab);
+  }
+
+  /**
+   * Tests the resource usage when display stats view during recording.
+   */
+  public void testBatteryUsage_showStatsView() {
+    recordingLongTrack(false, R.string.track_detail_stats_tab);
+  }
+
+  /**
+   * Records a long time track and keeps in the specified tab or in tracks list
+   * during recording.
+   * 
+   * @param isShowTracksList true means show tracks list
+   * @param tabNameId the name string id of tab, it's useless when the first
+   *          parameter is true.
+   */
+  public void recordingLongTrack(boolean isShowTracksList, int tabNameId) {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+
+    EndToEndTestUtils.startRecording();
+    if (isShowTracksList) {
+      EndToEndTestUtils.SOLO.goBack();
+    } else {
+      EndToEndTestUtils.SOLO.clickOnText(trackListActivity.getString(tabNameId));
+    }
+    BigTestUtils.moniterTest(context, INTERVALE_TO_CHECK, TEST_DURATION_IN_MILLISECONDS);
+    BigTestUtils.unlockAndWakeupDevice();
+    EndToEndTestUtils.stopRecording(true);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    if (!runTest) {
+      return;
+    }
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    BigTestUtils.writeToFile("Test case done:" + getName() + "\r\n\r\n", true);
+    super.tearDown();
+  }
+}
@@ -0,0 +1,245 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.others;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.endtoendtest.RunConfiguration;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+import android.util.Log;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import java.util.ArrayList;
+
+/**
+ * Tests connecting to sensors.
+ * 
+ * @author Youtao Liu
+ */
+public class SensorTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  public SensorTest() {
+    super(TrackListActivity.class);
+  }
+
+  private Instrumentation instrumentation;
+  private TrackListActivity trackListActivity;
+  private boolean runTest = false;
+  private static final String ZEPHYR_NAME = "HXM";
+  private static final String POLAR_NAME = "Polar";
+
+  @Override
+  protected void setUp() throws Exception {
+    runTest = RunConfiguration.runSensorTest;
+    super.setUp();
+    if (!runTest) {
+      return;
+    }
+    instrumentation = getInstrumentation();
+    trackListActivity = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, trackListActivity);
+  }
+
+  /**
+   * Tests connecting to a Zephyr Bluetooth sensor while not recording. Before this test, a Zephyr
+   * sensor must be paired with the device.
+   */
+  public void testConnectZephyrBluetoothSensor_notRecording() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    bluetoothSensorTest(R.string.settings_sensor_type_zephyr, ZEPHYR_NAME, false);
+  }
+  
+  /**
+   * Tests connecting to a Zephyr Bluetooth sensor while under recording. Before this test, a Zephyr
+   * sensor must be paired with the device.
+   */
+  public void testConnectZephyrBluetoothSensor_underRecording() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    bluetoothSensorTest(R.string.settings_sensor_type_zephyr, ZEPHYR_NAME, true);
+  }
+
+  /**
+   * Tests connecting to a Polar Bluetooth sensor while not recording. Before this test, a Polar
+   * sensor must be paired with the device.
+   */
+  public void testConnectPolarBluetoothSensor_notRecording() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    bluetoothSensorTest(R.string.settings_sensor_type_polar, POLAR_NAME, false);
+  }
+  
+  /**
+   * Tests connecting to a Polar Bluetooth sensor while under recording. Before this test, a Polar
+   * sensor must be paired with the device.
+   */
+  public void testConnectPolarBluetoothSensor_underRecording() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    bluetoothSensorTest(R.string.settings_sensor_type_polar, POLAR_NAME, true);
+  }
+
+  /**
+   * Set the paired sensor.
+   * 
+   * @param sensorTypeStringId the string id of paired sensors type
+   * @param nameString part of the sensor name string which can distinguish
+   *          different Bluetooth sensors
+   * @param isUnderRecording true means test under recording
+   */
+  private void bluetoothSensorTest(int sensorTypeStringId, String nameString,
+      boolean isUnderRecording) {
+    EndToEndTestUtils.findMenuItem(trackListActivity.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(trackListActivity.getString(R.string.settings_sensor));
+    EndToEndTestUtils.SOLO.clickOnText(trackListActivity.getString(R.string.settings_sensor_type));
+    EndToEndTestUtils.SOLO.clickOnText(trackListActivity.getString(sensorTypeStringId));
+    checkPairedSensorsNumber(nameString);
+    // Set the paired sensor.
+    EndToEndTestUtils.SOLO.clickOnText(nameString);
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.goBack();
+    if (isUnderRecording) {
+      assertTrue(checkSensorsStatus_underRecording());
+    } else {
+      assertTrue(checkSensorsStatus_notRecording());
+    }
+  }
+
+  /**
+   * Checks the number of paired sensors.
+   */
+  private void checkPairedSensorsNumber(String nameString) {
+    EndToEndTestUtils.SOLO.clickOnText(trackListActivity
+        .getString(R.string.settings_sensor_bluetooth_sensor));
+    instrumentation.waitForIdleSync();
+    ArrayList<ListView> allListViews = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class);
+    int number = allListViews.get(0).getCount();
+    if (number > 0
+        && EndToEndTestUtils.SOLO.waitForText(nameString, 1, EndToEndTestUtils.SHORT_WAIT_TIME)) {
+      return;
+    }
+
+    Log.i(EndToEndTestUtils.LOG_TAG, "No sensor is paried");
+    fail("No bluetooth sensor is paired. Please pair at Settings->Bluetooth before running the test.");
+  }
+
+  /**
+   * Tests connecting to a cadence ANT+ sensor.
+   */
+  public void testConnectANTSensor_Cadence() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    useANTSeonsor();
+    assertTrue(checkSensorsStatus_notRecording());
+    checkANTSensorsStatus(R.id.sensor_state_cadence);
+  }
+
+  /**
+   * Tests connecting to cadence and heart rate ANT+ sensors at the same time.
+   */
+  public void testConnectTwoANTSensors() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    useANTSeonsor();
+    assertTrue(checkSensorsStatus_notRecording());
+    checkANTSensorsStatus(R.id.sensor_state_cadence);
+    checkANTSensorsStatus(R.id.sensor_state_heart_rate);
+  }
+
+  /**
+   * Sets the setting to use ANT+ sensor
+   */
+  private void useANTSeonsor() {
+    EndToEndTestUtils.findMenuItem(trackListActivity.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(trackListActivity.getString(R.string.settings_sensor));
+    EndToEndTestUtils.SOLO.clickOnText(trackListActivity.getString(R.string.settings_sensor_type));
+    EndToEndTestUtils.SOLO.clickOnText(trackListActivity
+        .getString(R.string.settings_sensor_type_ant));
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.goBack();
+  }
+
+  /**
+   * Checks whether the ANT+ sensor is connected with MyTracks.
+   * 
+   * @param viewID the id to check which is not equal with None
+   */
+  private void checkANTSensorsStatus(int viewID) {
+    TextView sensorValueText = ((TextView) EndToEndTestUtils.SOLO.getCurrentActivity()
+        .findViewById(viewID));
+    assertNotNull(sensorValueText);
+    String realValue = sensorValueText.getText().toString();
+    String noneValue = trackListActivity.getString(R.string.value_none);
+    assertNotSame(realValue, noneValue);
+  }
+  
+  /**
+   * Checks whether the sensor is connected with MyTracks during recording.
+   * 
+   * @return true means the sensor is connected with MyTracks
+   */
+  private boolean checkSensorsStatus_underRecording() {
+    EndToEndTestUtils.instrumentation.waitForIdleSync();
+    EndToEndTestUtils.startRecording();
+    EndToEndTestUtils.findMenuItem(trackListActivity.getString(R.string.menu_sensor_state), true);
+    boolean result = EndToEndTestUtils.SOLO.waitForText(
+        trackListActivity.getString(R.string.sensor_state_connected), 1,
+        EndToEndTestUtils.LONG_WAIT_TIME);
+    EndToEndTestUtils.stopRecording(true);
+    return result;
+  }
+
+  /**
+   * Checks whether the sensor is connected with MyTracks while not under recording.
+   * 
+   * @return true means the sensor is connected with MyTracks
+   */
+  private boolean checkSensorsStatus_notRecording() {
+    EndToEndTestUtils.instrumentation.waitForIdleSync();
+    EndToEndTestUtils.createTrackIfEmpty(0, false);
+    EndToEndTestUtils.findMenuItem(trackListActivity.getString(R.string.menu_sensor_state), true);
+    return EndToEndTestUtils.SOLO.waitForText(
+        trackListActivity.getString(R.string.sensor_state_connected), 1,
+        EndToEndTestUtils.LONG_WAIT_TIME);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    if (!runTest) {
+      return;
+    }
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+    super.tearDown();
+  }
+
+}
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2012 Google Inc.
+ * 
+ * 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.google.android.apps.mytracks.endtoendtest.others;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.endtoendtest.RunConfiguration;
+import com.google.android.maps.mytracks.R;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+import android.util.Log;
+import android.widget.ListView;
+
+/**
+ * Stress test of MyTracks.
+ * 
+ * @author Youtao Liu
+ */
+public class StressTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private static final int TEST_DURATION_IN_MILLISECONDS = 30 * 60 * 1000;
+  private static final int MAX_TRACK_NUMBER = 30;
+  private boolean runTest = false;
+
+  private long startTime = 0;
+  private int numberOfTracks;
+
+  public StressTest() {
+    super(TrackListActivity.class);
+  }
+
+  private Instrumentation instrumentation;
+  private TrackListActivity trackListActivity;
+
+  @Override
+  protected void setUp() throws Exception {
+    runTest = RunConfiguration.runStressTest;
+    super.setUp();
+    if (!runTest) {
+      return;
+    }
+    instrumentation = getInstrumentation();
+    trackListActivity = getActivity();
+    EndToEndTestUtils.setupForAllTest(instrumentation, trackListActivity);
+    BigTestUtils.unlockAndWakeupDevice();
+    startTime = System.currentTimeMillis();
+  }
+
+  /**
+   * Records tracks and deletes them when there are more than
+   * {@link #MAX_TRACK_NUMBER} tracks. Keeps sending different GPS locations in
+   * each track, making it closer to the real stress.
+   */
+  public void testRecordAndDeleteTracks() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    for (int i = 0; (System.currentTimeMillis() - startTime) < TEST_DURATION_IN_MILLISECONDS; i++) {
+      EndToEndTestUtils.startRecording();
+      // Points in a tracks keep increasing.
+      EndToEndTestUtils.sendGps(i * 10, 0, 10);
+      EndToEndTestUtils.stopRecording(true);
+      EndToEndTestUtils.SOLO.goBack();
+      EndToEndTestUtils.instrumentation.waitForIdleSync();
+      numberOfTracks = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount();
+      if (numberOfTracks > MAX_TRACK_NUMBER) {
+        EndToEndTestUtils.deleteAllTracks();
+      }
+      logStatus(i);
+    }
+  }
+
+  /**
+   * Rotates screen when display map view. Keeps sending different GPS locations
+   * in each track, making it closer to the real stress.
+   */
+  public void testRotateMapViewInTrackDetailActivity() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    EndToEndTestUtils.startRecording();
+    for (int i = 0; (System.currentTimeMillis() - startTime) < TEST_DURATION_IN_MILLISECONDS; i++) {
+      EndToEndTestUtils.sendGps(10, i * 10);
+      EndToEndTestUtils.rotateCurrentActivity();
+      Log.i(EndToEndTestUtils.LOG_TAG, String.format("Totate %d times in %d minutes!", i,
+          (System.currentTimeMillis() - startTime) / 1000 / 60));
+    }
+  }
+
+  /**
+   * Switches view between MAP, CHART and STAT.
+   */
+  public void testSwitchTabs() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    EndToEndTestUtils.startRecording();
+    int i = 0;
+    while ((System.currentTimeMillis() - startTime) < TEST_DURATION_IN_MILLISECONDS) {
+      EndToEndTestUtils.SOLO
+          .clickOnText(trackListActivity.getString(R.string.track_detail_map_tab));
+      instrumentation.waitForIdleSync();
+      EndToEndTestUtils.SOLO.clickOnText(trackListActivity
+          .getString(R.string.track_detail_chart_tab));
+      instrumentation.waitForIdleSync();
+      EndToEndTestUtils.SOLO.clickOnText(trackListActivity
+          .getString(R.string.track_detail_stats_tab));
+      instrumentation.waitForIdleSync();
+      logStatus(++i);
+    }
+    EndToEndTestUtils.stopRecording(true);
+  }
+
+  /**
+   * Records a long track.
+   */
+  public void testRecordLongTrack() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    EndToEndTestUtils.startRecording();
+    int gpsNumber = 5000;
+    for (int i = 0; i < gpsNumber / 10; i++) {
+      EndToEndTestUtils.sendGps(10, i * 10);
+    }
+    EndToEndTestUtils.stopRecording(true);
+  }
+
+  /**
+   * Switches view between MAP, CHART and STAT. And create way points, pause and
+   * resume the track during recording.
+   */
+  public void testSwitchTabs_wayPoints() {
+    if (!runTest) {
+      Log.i(EndToEndTestUtils.LOG_TAG, BigTestUtils.DISABLE_MESSAGE);
+      return;
+    }
+    EndToEndTestUtils.startRecording();
+
+    int i = 0;
+    while ((System.currentTimeMillis() - startTime) < TEST_DURATION_IN_MILLISECONDS) {
+      // Create one way points.
+      EndToEndTestUtils.sendGps(10, 10 * i);
+      EndToEndTestUtils.createWaypoint(i);
+      instrumentation.waitForIdleSync();
+      EndToEndTestUtils.SOLO.waitForText(trackListActivity.getString(R.string.generic_recording));
+      EndToEndTestUtils.pauseRecording();
+
+      EndToEndTestUtils.SOLO
+          .clickOnText(trackListActivity.getString(R.string.track_detail_map_tab));
+      instrumentation.waitForIdleSync();
+      EndToEndTestUtils.SOLO.clickOnText(trackListActivity
+          .getString(R.string.track_detail_chart_tab));
+      instrumentation.waitForIdleSync();
+      EndToEndTestUtils.SOLO.clickOnText(trackListActivity
+          .getString(R.string.track_detail_stats_tab));
+      instrumentation.waitForIdleSync();
+      EndToEndTestUtils.SOLO.waitForText(trackListActivity.getString(R.string.generic_paused));
+      EndToEndTestUtils.resumeRecording();
+      logStatus(++i);
+    }
+    EndToEndTestUtils.stopRecording(true);
+  }
+
+  /**
+   * Logs status.
+   * 
+   * @param times the number of times this test has been run
+   */
+  private void logStatus(int times) {
+    int minutes = (int) (TEST_DURATION_IN_MILLISECONDS - (System.currentTimeMillis() - startTime)) / 60 / 1000;
+    Log.i(EndToEndTestUtils.LOG_TAG, String.format(
+        "This test has run %d times and will be finished in %d minutes!", times, minutes));
+    Log.i(EndToEndTestUtils.LOG_TAG, String.format("There are %d tracks!", numberOfTracks));
+  }
+}
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * 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.google.android.apps.mytracks.endtoendtest.sync;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.endtoendtest.GoogleUtils;
+import com.google.android.apps.mytracks.endtoendtest.RunConfiguration;
+import com.google.android.maps.mytracks.R;
+import com.google.api.services.drive.Drive;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+import android.widget.ListView;
+
+/**
+ * Tests the situation when user use multiple account in MyTracks.
+ * 
+ * @author Youtao Liu
+ */
+public class MultiAccountsSyncTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Drive drive;
+  private Instrumentation instrumentation;
+  private TrackListActivity trackListActivity;
+
+  public MultiAccountsSyncTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    trackListActivity = getActivity();
+    SyncTestUtils.setUpForSyncTest(instrumentation, trackListActivity);
+    SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_1);
+    drive = SyncTestUtils
+        .getGoogleDrive(EndToEndTestUtils.activityMytracks.getApplicationContext());
+  }
+
+  /**
+   * Tests sync tracks with Google Drive of two accounts with following
+   * sequence:
+   * <ul>
+   * <li>1. Enable sync with account1.</li>
+   * <li>2. Create a track.</li>
+   * <li>3. Enable sync with account2.</li>
+   * <li>4. Create a track.</li>
+   * <li>5. Sync and check</li>
+   * <li>6. Enable sync with account1.</li>
+   * <li>7. Sync and check</li>
+   * <li>8. Enable sync with account2.</li>
+   * <li>9. Check</li>
+   * </ul>
+   */
+  public void testSyncTracksWithMultiAccounts() throws Exception {
+    if (!RunConfiguration.getInstance().runSyncTest) {
+      return;
+    }
+    SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_1);
+    // Create tracks with first track.
+    EndToEndTestUtils.createSimpleTrack(0, true);
+
+    // Create tracks with second track.
+    SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_2);
+    EndToEndTestUtils.createSimpleTrack(0, true);
+
+    // Sync with Google Drive and then check it of the second account.
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    drive = SyncTestUtils.getGoogleDrive(trackListActivity.getApplicationContext());
+    SyncTestUtils.checkFilesNumber(drive);
+
+    // Check Google Drive of the first account.
+    SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_1);
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    drive = SyncTestUtils.getGoogleDrive(trackListActivity.getApplicationContext());
+    SyncTestUtils.checkFilesNumber(drive);
+
+    // Back to account1 change check that files are still existed.
+    SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_2);
+    drive = SyncTestUtils.getGoogleDrive(trackListActivity.getApplicationContext());
+    SyncTestUtils.checkFilesNumber(drive);
+  }
+
+  /**
+   * Tests the behavior of MyTracks about delete operation and switch accounts
+   * with following sequence.:
+   * <ul>
+   * <li>1. Create 3 tracks.</li>
+   * <li>2. Delete 1 track.</li>
+   * <li>3. Sync with account2(account2 should have 2 files).</li>
+   * <li>4. Delete 1 track (account2 should have 1 file).</li>
+   * <li>5. Sync with account 1 (account 1 should have 1 file, account2 should
+   * also have 1 file).</li>
+   * </ul>
+   */
+  public void testDeleteTracksWithMultiAccounts() throws Exception {
+    if (!RunConfiguration.getInstance().runSyncTest) {
+      return;
+    }
+    EndToEndTestUtils.createSimpleTrack(0, true);
+    EndToEndTestUtils.createSimpleTrack(0, true);
+    EndToEndTestUtils.createSimpleTrack(0, true);
+
+    // Delete one track.
+    EndToEndTestUtils.SOLO.clickOnView(EndToEndTestUtils.SOLO.getCurrentViews(ListView.class)
+        .get(0).getChildAt(0));
+    EndToEndTestUtils.instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.clickOnMenuItem(EndToEndTestUtils.activityMytracks
+        .getString(R.string.menu_delete));
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.activityMytracks
+        .getString(R.string.generic_yes));
+
+    // Switch account and delete another track.
+    SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_2);
+    EndToEndTestUtils.SOLO.clickOnView(EndToEndTestUtils.SOLO.getCurrentViews(ListView.class)
+        .get(0).getChildAt(0));
+    EndToEndTestUtils.SOLO.clickOnMenuItem(EndToEndTestUtils.activityMytracks
+        .getString(R.string.menu_delete));
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.activityMytracks
+        .getString(R.string.generic_yes));
+
+    // Check Google Drive of the first account.
+    SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_1);
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    drive = SyncTestUtils.getGoogleDrive(trackListActivity.getApplicationContext());
+    SyncTestUtils.checkFilesNumber(drive);
+
+    // Check Google Drive of the second account.
+    SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_2);
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    drive = SyncTestUtils.getGoogleDrive(trackListActivity.getApplicationContext());
+    SyncTestUtils.checkFilesNumber(drive);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    super.tearDown();
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+  }
+}
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * 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.google.android.apps.mytracks.endtoendtest.sync;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.endtoendtest.GoogleUtils;
+import com.google.android.apps.mytracks.endtoendtest.RunConfiguration;
+import com.google.android.maps.mytracks.R;
+import com.google.api.services.drive.Drive;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+import android.view.KeyEvent;
+
+import java.io.IOException;
+
+/**
+ * Tests making changes on Google Drive when syncing My Tracks with Google
+ * Drive.
+ * 
+ * @author Youtao Liu
+ */
+public class SyncDriveWithMyTracksTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Drive drive;
+  private Instrumentation instrumentation;
+  private TrackListActivity trackListActivity;
+
+  public SyncDriveWithMyTracksTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    trackListActivity = getActivity();
+    SyncTestUtils.setUpForSyncTest(instrumentation, trackListActivity);
+    SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_1);
+    drive = SyncTestUtils
+        .getGoogleDrive(EndToEndTestUtils.activityMytracks.getApplicationContext());
+  }
+
+  /**
+   * Deletes all tracks in MyTracks and checks in Google Drive.
+   * 
+   * @throws IOException
+   */
+  public void testDeleteAllTracksInMyTracks() throws IOException {
+    if (!RunConfiguration.getInstance().runSyncTest) {
+      return;
+    }
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    SyncTestUtils.checkFilesNumber(drive);
+  }
+
+  /**
+   * Deletes one track in MyTracks and checks it in Google Drive.
+   * 
+   * @throws IOException
+   */
+  public void testDeleteOneTracksInMyTracks() throws IOException {
+    if (!RunConfiguration.getInstance().runSyncTest) {
+      return;
+    }
+    EndToEndTestUtils.createTrackIfEmpty(2, false);
+    EndToEndTestUtils.SOLO.clickOnMenuItem(EndToEndTestUtils.activityMytracks
+        .getString(R.string.menu_delete));
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.activityMytracks
+        .getString(R.string.generic_yes));
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    SyncTestUtils.checkFile(EndToEndTestUtils.trackName, false, drive);
+  }
+
+  /**
+   * Creates one empty track and one non-empty track in MyTracks and then check
+   * them in Google Drive.
+   * 
+   * @throws IOException
+   */
+  public void testCreateTracksInMyTracks() throws IOException {
+    if (!RunConfiguration.getInstance().runSyncTest) {
+      return;
+    }
+    EndToEndTestUtils.createSimpleTrack(0, true);
+    EndToEndTestUtils.createSimpleTrack(3, true);
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    SyncTestUtils.checkFilesNumber(drive);
+  }
+
+  /**
+   * Edits a tracks in MyTracks and checks it on Google Drive after sync.
+   * 
+   * @throws IOException
+   */
+  public void testEditTrackInMyTracks() throws IOException {
+    if (!RunConfiguration.getInstance().runSyncTest) {
+      return;
+    }
+    EndToEndTestUtils.createTrackIfEmpty(3, true);
+
+    // Sync this track.
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    SyncTestUtils.checkFile(EndToEndTestUtils.trackName, true, drive);
+    String oldTrack = SyncTestUtils.getContentOfFile(
+        SyncTestUtils.getFile(EndToEndTestUtils.trackName, drive), drive);
+
+    String oldTrackName = EndToEndTestUtils.trackName;
+
+    // Edit this track.
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.trackName);
+    EndToEndTestUtils.findMenuItem(trackListActivity.getString(R.string.menu_edit), true);
+    String newTrackName = EndToEndTestUtils.TRACK_NAME_PREFIX + "_new" + System.currentTimeMillis();
+    String newType = EndToEndTestUtils.activityType + newTrackName;
+    String newDesc = "desc" + newTrackName;
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.waitForText(trackListActivity.getString(R.string.generic_save));
+    sendKeys(KeyEvent.KEYCODE_DEL);
+    EndToEndTestUtils.enterTextAvoidSoftKeyBoard(0, newTrackName);
+    EndToEndTestUtils.enterTextAvoidSoftKeyBoard(1, newType);
+    EndToEndTestUtils.enterTextAvoidSoftKeyBoard(2, newDesc);
+    EndToEndTestUtils.SOLO.clickOnButton(trackListActivity.getString(R.string.generic_save));
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.SOLO.goBack();
+    instrumentation.waitForIdleSync();
+
+    // Sync again.
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+
+    // Check.
+    SyncTestUtils.checkFile(oldTrackName, false, drive);
+    SyncTestUtils.checkFile(newTrackName, true, drive);
+    String newTrack = SyncTestUtils.getContentOfFile(SyncTestUtils.getFile(newTrackName, drive),
+        drive);
+    assertNotSame(oldTrack, newTrack);
+    assertTrue(newTrack.indexOf(newTrackName) > 0);
+    assertTrue(newTrack.indexOf(newType) > 0);
+    assertTrue(newTrack.indexOf(newDesc) > 0);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    super.tearDown();
+    EndToEndTestUtils.SOLO.finishOpenedActivities();
+  }
+}
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * 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.google.android.apps.mytracks.endtoendtest.sync;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.endtoendtest.GoogleUtils;
+import com.google.android.apps.mytracks.endtoendtest.RunConfiguration;
+import com.google.android.apps.mytracks.io.sync.SyncUtils;
+import com.google.android.maps.mytracks.R;
+import com.google.api.services.drive.Drive;
+import com.google.api.services.drive.model.File;
+
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+
+import java.io.IOException;
+
+/**
+ * Tests making changes on My Tracks when syncing My Tracks with Google Drive.
+ * 
+ * @author Youtao Liu
+ */
+public class SyncMyTracksWithDriveTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
+
+  private Drive drive;
+  private Instrumentation instrumentation;
+  private TrackListActivity trackListActivity;
+
+  public SyncMyTracksWithDriveTest() {
+    super(TrackListActivity.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    instrumentation = getInstrumentation();
+    trackListActivity = getActivity();
+    SyncTestUtils.setUpForSyncTest(instrumentation, trackListActivity);
+    SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_1);
+    drive = SyncTestUtils
+        .getGoogleDrive(EndToEndTestUtils.activityMytracks.getApplicationContext());
+  }
+
+  /**
+   * Deletes all tracks on Google Drive and checks in MyTracks.
+   * 
+   * @throws IOException
+   */
+  public void testDeleteAllTracksOnDrive() throws IOException {
+    if (!RunConfiguration.getInstance().runSyncTest) {
+      return;
+    }
+    EndToEndTestUtils.createTrackIfEmpty(0, true);
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    SyncTestUtils.checkFilesNumber(drive);
+
+    SyncTestUtils.removeKMLFiles(drive);
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    SyncTestUtils.checkTracksNumber(0);
+  }
+
+  /**
+   * Deletes one file on Google Drive and checks it in MyTracks.
+   * 
+   * @throws IOException
+   */
+  public void testDeleteOneFileOnDrive() throws IOException {
+    if (!RunConfiguration.getInstance().runSyncTest) {
+      return;
+    }
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.createSimpleTrack(0, true);
+    EndToEndTestUtils.createSimpleTrack(0, true);
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    SyncTestUtils.checkFilesNumber(drive);
+
+    // Remove one track from Google Drive
+    File file = SyncTestUtils.getFile(EndToEndTestUtils.trackName, drive);
+    SyncTestUtils.removeFile(file, drive);
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    SyncTestUtils.checkFilesNumber(drive);
+    SyncTestUtils.checkTracksNumber(1);
+  }
+
+  /**
+   * Tests deleting and creating MyTracks folder on Google Dive by MyTracks.
+   * 
+   * @throws IOException
+   */
+  public void testCreateMyTracksOnDrive() throws IOException {
+    if (!RunConfiguration.getInstance().runSyncTest) {
+      return;
+    }
+    instrumentation.waitForIdleSync();
+    EndToEndTestUtils.createSimpleTrack(0, true);
+    EndToEndTestUtils.createSimpleTrack(0, true);
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    instrumentation.waitForIdleSync();
+    SyncTestUtils.checkFilesNumber(drive);
+    File folder = SyncUtils.getMyTracksFolder(trackListActivity.getApplicationContext(), drive);
+    assertNotNull(folder);
+
+    SyncTestUtils.removeFile(folder, drive);
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+    SyncTestUtils.checkFilesNumber(drive);
+  }
+}
@@ -0,0 +1,312 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * 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.google.android.apps.mytracks.endtoendtest.sync;
+
+import com.google.android.apps.mytracks.TrackListActivity;
+import com.google.android.apps.mytracks.endtoendtest.EndToEndTestUtils;
+import com.google.android.apps.mytracks.endtoendtest.GoogleUtils;
+import com.google.android.apps.mytracks.endtoendtest.RunConfiguration;
+import com.google.android.apps.mytracks.io.sendtogoogle.SendToGoogleUtils;
+import com.google.android.apps.mytracks.io.sync.SyncUtils;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.gms.auth.GoogleAuthException;
+import com.google.android.maps.mytracks.R;
+import com.google.api.client.googleapis.extensions.android.gms.auth.GoogleAccountCredential;
+import com.google.api.client.googleapis.json.GoogleJsonResponseException;
+import com.google.api.client.http.GenericUrl;
+import com.google.api.client.http.HttpResponse;
+import com.google.api.services.drive.Drive;
+import com.google.api.services.drive.model.File;
+
+import android.app.Instrumentation;
+import android.content.Context;
+import android.util.Log;
+import android.widget.CheckBox;
+import android.widget.ListView;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+import junit.framework.Assert;
+
+/**
+ * Utilites for Google Drive sync endtoend test.
+ * 
+ * @author Youtao Liu
+ */
+public class SyncTestUtils {
+
+  public static boolean isCheckedRunSyncTest = false;
+  public static final String KML_FILE_POSTFIX = ".kml";
+  public static final long MAX_TIME_TO_WAIT_SYNC = 100000;
+
+  /**
+   * Sets up sync tests.
+   * 
+   * @param instrumentation the instrumentation is used for test
+   * @param trackListActivity the startup activity
+   * @return a Google Drive object
+   */
+  public static Drive setUpForSyncTest(Instrumentation instrumentation,
+      TrackListActivity trackListActivity) throws IOException, GoogleAuthException {
+    if (!isCheckedRunSyncTest || RunConfiguration.getInstance().runSyncTest) {
+      EndToEndTestUtils.setupForAllTest(instrumentation, trackListActivity);
+    }
+    if (!isCheckedRunSyncTest) {
+      isCheckedRunSyncTest = true;
+    }
+    if (RunConfiguration.getInstance().runSyncTest) {
+      SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_1);
+      Drive drive1 = SyncTestUtils.getGoogleDrive(EndToEndTestUtils.activityMytracks
+          .getApplicationContext());
+      removeKMLFiles(drive1);
+      EndToEndTestUtils.deleteAllTracks();
+      SyncTestUtils.enableSync(GoogleUtils.ACCOUNT_NAME_2);
+      Drive drive2 = SyncTestUtils.getGoogleDrive(EndToEndTestUtils.activityMytracks
+          .getApplicationContext());
+      removeKMLFiles(drive2);
+      EndToEndTestUtils.deleteAllTracks();
+      return drive2;
+    }
+    return null;
+  }
+
+  /**
+   * Gets drive object of Google Drive.
+   * 
+   * @param context the context of application
+   * @return a Google Drive object
+   */
+  public static Drive getGoogleDrive(Context context) throws IOException, GoogleAuthException {
+    String googleAccount = PreferencesUtils.getString(context, R.string.google_account_key,
+        PreferencesUtils.GOOGLE_ACCOUNT_DEFAULT);
+    GoogleAccountCredential credential = SendToGoogleUtils.getGoogleAccountCredential(context,
+        googleAccount, SendToGoogleUtils.DRIVE_SCOPE);
+    return SyncUtils.getDriveService(credential);
+  }
+
+  /**
+   * Gets KML files from Google Drive of current account.
+   * 
+   * @param context the context of application
+   * @param drive a Google Drive object
+   * @return KML file on Google drive
+   * @throws IOException
+   */
+  public static List<File> getDriveFiles(Context context, Drive drive) throws IOException {
+    File folder = SyncUtils.getMyTracksFolder(context, drive);
+    if (folder == null) {
+      return new ArrayList<File>();
+    }
+    String folderId = folder.getId();
+    return drive.files().list()
+        .setQ(String.format(Locale.US, SyncUtils.MY_TRACKS_FOLDER_FILES_QUERY, folderId)).execute()
+        .getItems();
+  }
+
+  /**
+   * Finds whether a file is existed by the name of track.
+   * 
+   * @param trackName name of track
+   * @param drive a Google Drive object
+   * @return the file be found
+   * @throws IOException
+   */
+  public static File getFile(String trackName, Drive drive) throws IOException {
+    List<File> files = getDriveFiles(EndToEndTestUtils.activityMytracks.getApplicationContext(),
+        drive);
+    for (int i = 0; i < files.size(); i++) {
+      File file = files.get(i);
+      String title = file.getTitle();
+      if (title.equals(trackName + KML_FILE_POSTFIX)) {
+        return file;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Removes all KML files on Google Drive.
+   * 
+   * @param drive a Google Drive object
+   * @throws IOException
+   */
+  public static void removeKMLFiles(Drive drive) throws IOException {
+    List<File> files = SyncTestUtils.getDriveFiles(
+        EndToEndTestUtils.activityMytracks.getApplicationContext(), drive);
+    for (int i = 0; i < files.size(); i++) {
+      File file = files.get(i);
+      removeFile(file, drive);
+    }
+  }
+
+  /**
+   * Removes one file on Google Drive.
+   * 
+   * @param file the file to remove
+   * @param drive a Google Drive object
+   * @throws IOException
+   */
+  public static void removeFile(File file, Drive drive) throws IOException {
+    drive.files().trash(file.getId()).execute();
+  }
+
+  /**
+   * Enables sync feature in MyTracks settings.
+   * 
+   * @param accountName the account which is used to sync with
+   */
+  public static void enableSync(String accountName) {
+    EndToEndTestUtils.instrumentation.waitForIdleSync();
+    EndToEndTestUtils.findMenuItem(
+        EndToEndTestUtils.activityMytracks.getString(R.string.menu_settings), true);
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.activityMytracks
+        .getString(R.string.settings_google));
+    EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.activityMytracks
+        .getString(R.string.settings_google_account_title));
+    EndToEndTestUtils.instrumentation.waitForIdleSync();
+
+    // Whether test account is bound.
+    if (EndToEndTestUtils.SOLO.waitForText(accountName, 1, EndToEndTestUtils.SHORT_WAIT_TIME)) {
+      EndToEndTestUtils.SOLO.clickOnText(accountName);
+      EndToEndTestUtils.instrumentation.waitForIdleSync();
+      if (EndToEndTestUtils.SOLO.waitForText(EndToEndTestUtils.activityMytracks.getString(
+          R.string.settings_google_account_confirm_title), 1, EndToEndTestUtils.SHORT_WAIT_TIME)) {
+        EndToEndTestUtils.SOLO.clickOnText(
+            EndToEndTestUtils.activityMytracks.getString(R.string.generic_yes));
+      }
+    } else {
+      Assert.fail();
+      return;
+    }
+
+    EndToEndTestUtils.SOLO.waitForDialogToClose(EndToEndTestUtils.SHORT_WAIT_TIME);
+    EndToEndTestUtils.instrumentation.waitForIdleSync();
+    CheckBox syncCheckBox = EndToEndTestUtils.SOLO.getCurrentViews(CheckBox.class).get(0);
+    if (!syncCheckBox.isChecked()) {
+      EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.activityMytracks
+          .getString(R.string.menu_sync_drive));
+
+      EndToEndTestUtils.SOLO.waitForText(
+          EndToEndTestUtils.activityMytracks.getString(R.string.sync_drive_confirm_message).split(
+              "%")[0], 1, EndToEndTestUtils.SHORT_WAIT_TIME);
+      Assert.assertTrue(EndToEndTestUtils.SOLO.searchText(accountName, true));
+      EndToEndTestUtils.SOLO.clickOnText(EndToEndTestUtils.activityMytracks
+          .getString(R.string.generic_yes));
+    }
+
+    // Add this sleep to work around a exception after switch account.
+    EndToEndTestUtils.sleep(15000);
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.SOLO.goBack();
+    EndToEndTestUtils.instrumentation.waitForIdleSync();
+  }
+
+  /**
+   * Checks the files number on Google Drive
+   * 
+   * @param drive a Google Drive object
+   * @throws IOException
+   */
+  public static void checkFilesNumber(Drive drive) throws IOException {
+    EndToEndTestUtils.instrumentation.waitForIdleSync();
+    long startTime = System.currentTimeMillis();
+    int trackNumber = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount();
+    List<File> files = getDriveFiles(EndToEndTestUtils.activityMytracks.getApplicationContext(),
+        drive);
+    while (System.currentTimeMillis() - startTime < MAX_TIME_TO_WAIT_SYNC) {
+      try {
+        if (files.size() == trackNumber) {
+          return;
+        }
+        trackNumber = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount();
+        files = getDriveFiles(EndToEndTestUtils.activityMytracks.getApplicationContext(), drive);
+        EndToEndTestUtils.sleep(EndToEndTestUtils.SHORT_WAIT_TIME);
+        EndToEndTestUtils.findMenuItem(
+            EndToEndTestUtils.activityMytracks.getString(R.string.menu_refresh), true);
+      } catch (GoogleJsonResponseException e) {
+        Log.i(EndToEndTestUtils.LOG_TAG, e.getMessage());
+      }
+    }
+    Assert.assertEquals(files.size(), trackNumber);
+  }
+
+  /**
+   * Checks the files number on Google Drive
+   * 
+   * @param number number of files on Google Drive
+   */
+  public static void checkTracksNumber(int number) {
+    long startTime = System.currentTimeMillis();
+    int trackNumber = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount();
+    while (System.currentTimeMillis() - startTime < MAX_TIME_TO_WAIT_SYNC) {
+      if (trackNumber == number) {
+        return;
+      }
+      trackNumber = EndToEndTestUtils.SOLO.getCurrentViews(ListView.class).get(0).getCount();
+      Log.i(EndToEndTestUtils.LOG_TAG, trackNumber + ":" + number);
+    }
+    Assert.assertEquals(trackNumber, number);
+  }
+
+  /**
+   * Checks one file on Google Drive
+   * 
+   * @param trackName the name of track
+   * @param shouldExist true means this track should be existed
+   * @param drive a Google Drive object
+   * @return true means the actual result is same as expectation
+   * @throws IOException
+   */
+  public static boolean checkFile(String trackName, boolean shouldExist, Drive drive)
+      throws IOException {
+    long startTime = System.currentTimeMillis();
+    while (System.currentTimeMillis() - startTime < MAX_TIME_TO_WAIT_SYNC) {
+      boolean exist = getFile(trackName, drive) != null;
+      if (exist == shouldExist) {
+        return true;
+      }
+    }
+    Assert.fail();
+    return false;
+  }
+
+  /**
+   * Gets the content of a file on Google Drive.
+   * 
+   * @param file file to read
+   * @param drive a Google Drive object
+   * @return the string content of the file
+   * @throws IOException
+   */
+  public static String getContentOfFile(File file, Drive drive) throws IOException {
+    HttpResponse resp = drive.getRequestFactory()
+        .buildGetRequest(new GenericUrl(file.getDownloadUrl())).execute();
+    BufferedReader br = new BufferedReader(new InputStreamReader(resp.getContent()));
+    StringBuilder sb = new StringBuilder();
+    String line;
+    while ((line = br.readLine()) != null) {
+      sb.append(line);
+    }
+    String fileContent = sb.toString();
+    br.close();
+    return fileContent;
+  }
+}