Add test case for SendMapsAsyncTask, and change SendMapsAsyncTask to make it testable.

MyTracks/src/com/google/android/apps/mytracks/io/maps/SendMapsAsyncTask.java

@@ -34,6 +34,7 @@ import com.google.android.apps.mytracks.util.LocationUtils;
 import com.google.android.apps.mytracks.util.UnitConversions;
 import com.google.android.common.gdata.AndroidXmlParserFactory;
 import com.google.android.maps.mytracks.R;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.wireless.gdata.client.GDataClient;
 import com.google.wireless.gdata.client.HttpException;
 import com.google.wireless.gdata.parser.ParseException;
@@ -73,8 +74,10 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
   private static final int MAX_POINTS_PER_UPLOAD = 500;
 
   private static final int PROGRESS_FETCH_MAP_ID = 5;
-  private static final int PROGRESS_UPLOAD_DATA_MIN = 10;
+  @VisibleForTesting
-  private static final int PROGRESS_UPLOAD_DATA_MAX = 90;
+  static final int PROGRESS_UPLOAD_DATA_MIN = 10;
+  @VisibleForTesting
+  static final int PROGRESS_UPLOAD_DATA_MAX = 90;
   private static final int PROGRESS_UPLOAD_WAYPOINTS = 95;
   private static final int PROGRESS_COMPLETE = 100;
 
@@ -83,8 +86,8 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
   private final long trackId;
   private final Account account;
   private final String chooseMapId;
-  private final Context context;
   private final MyTracksProviderUtils myTracksProviderUtils;
+  private final Context context;
   private final GDataClient gDataClient;
   private final MapsClient mapsClient;
 
@@ -94,15 +97,25 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
   private String mapId;
   int currentSegment;
 
+  public SendMapsAsyncTask(SendMapsActivity activity, long trackId, Account account,
+      String chooseMapId) {
+    this(activity, trackId, account, chooseMapId, MyTracksProviderUtils.Factory.get(activity
+        .getApplicationContext()));
+  }
+  
+  /**
+   * This constructor is created for test.
+   */
+  @VisibleForTesting
   public SendMapsAsyncTask (
-      SendMapsActivity activity, long trackId, Account account, String chooseMapId) {
+      SendMapsActivity activity, long trackId, Account account, String chooseMapId, MyTracksProviderUtils myTracksProviderUtils) {
     super(activity);
     this.trackId = trackId;
     this.account = account;
     this.chooseMapId = chooseMapId;
-
+    this.myTracksProviderUtils = myTracksProviderUtils;
     context = activity.getApplicationContext();
-    myTracksProviderUtils = MyTracksProviderUtils.Factory.get(context);
+    
     gDataClient = GDataClientFactory.getGDataClient(context);
     mapsClient = new MapsClient(
         gDataClient, new XmlMapsGDataParserFactory(new AndroidXmlParserFactory()));
@@ -201,7 +214,8 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
    * @param track the Track
    * @return true if able to fetch the mapId variable.
    */
-  private boolean fetchSendMapId(Track track) {
+  @VisibleForTesting
+  boolean fetchSendMapId(Track track) {
     if (isCancelled()) {
       return false;
     }
@@ -239,7 +253,8 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
    * @param track the track
    * @return true if success.
    */
-  private boolean uploadAllTrackPoints(Track track) {
+  @VisibleForTesting
+  boolean uploadAllTrackPoints(Track track) {
     Cursor locationsCursor = null;
     try {
       SharedPreferences prefs = context.getSharedPreferences(
@@ -313,9 +328,8 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
       if (lastLocation != null) {
         distances.add(tripStatisticsBuilder.getStatistics().getTotalDistance());
         elevations.add(elevationBuffer.getAverage());
-        DescriptionGenerator descriptionGenerator = new DescriptionGeneratorImpl(context);
+        
-        track.setDescription("<p>" + track.getDescription() + "</p><p>"
+        track.setDescription(getTrackDescription(track, distances, elevations));
-            + descriptionGenerator.generateTrackDescription(track, distances, elevations) + "</p>");
         if (!uploadMarker(context.getString(R.string.marker_label_end, track.getName()),
             track.getDescription(), END_ICON_URL, lastLocation)) {
           Log.d(TAG, "Unable to create an end marker");
@@ -330,6 +344,21 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
     }
   }
   
+  /**
+   * Gets the description of a track.
+   * 
+   * @param track the track
+   * @param distances distance vectors
+   * @param elevations elevation vectors
+   * @return the description of a track.
+   */
+  @VisibleForTesting
+  String getTrackDescription(Track track, Vector<Double> distances, Vector<Double> elevations) {
+    DescriptionGenerator descriptionGenerator = new DescriptionGeneratorImpl(context);
+    return "<p>" + track.getDescription() + "</p><p>"
+        + descriptionGenerator.generateTrackDescription(track, distances, elevations) + "</p>";
+  }
+  
   /**
    * Prepares and uploads a list of locations from a track.
    *
@@ -338,7 +367,8 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
    * @param lastBatch true if it is the last batch of locations
    * @return true if success.
    */
-  private boolean prepareAndUploadPoints(Track track, List<Location> locations, boolean lastBatch) {
+  @VisibleForTesting
+  boolean prepareAndUploadPoints(Track track, List<Location> locations, boolean lastBatch) {
     // Prepare locations
     ArrayList<Track> splitTracks = SendToGoogleUtils.prepareLocations(track, locations);
 
@@ -367,7 +397,8 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
    * @param location marker location
    * @return true if success.
    */
-  private boolean uploadMarker(
+  @VisibleForTesting
+  boolean uploadMarker(
       String title, String description, String iconUrl, Location location) {
     if (isCancelled()) {
       return false;
@@ -426,7 +457,8 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
    *
    * @return true if success.
    */
-  private boolean uploadWaypoints() {
+  @VisibleForTesting
+  boolean uploadWaypoints() {
     Cursor cursor = null;
     try {
       cursor = myTracksProviderUtils.getWaypointsCursor(
@@ -471,10 +503,43 @@ public class SendMapsAsyncTask extends AbstractSendAsyncTask {
    * @param uploaded the number of uploaded locations
    * @param total the number of total locations
    */
-  private void updateProgress(int uploaded, int total) {
+  @VisibleForTesting
+  void updateProgress(int uploaded, int total) {
+    publishProgress(getPercentage(uploaded, total));
+  }
+  
+  
+  /**
+   * Count the percentage of the number of locations uploaded.
+   *
+   * @param uploaded the number of uploaded locations
+   * @param total the number of total locations
+   */
+  @VisibleForTesting
+  static int getPercentage(int uploaded, int total) {
     double totalPercentage = (double) uploaded / total;
-    double scaledPercentage =  totalPercentage
+    double scaledPercentage = totalPercentage
         * (PROGRESS_UPLOAD_DATA_MAX - PROGRESS_UPLOAD_DATA_MIN) + PROGRESS_UPLOAD_DATA_MIN;
-    publishProgress((int) scaledPercentage);
+    return (int) scaledPercentage;
+  }
+  
+  /**
+   * Gets the mapID.
+   * 
+   * @return mapId
+   */
+  @VisibleForTesting
+  String getMapId() {
+    return mapId;
+  }
+   
+  /**
+   * Sets the value of mapsGDataConverter.
+   * 
+   * @param mapsGDataConverter new value of mapsGDataConverter
+   */
+  @VisibleForTesting
+  void setMapsGDataConverter(MapsGDataConverter mapsGDataConverter) {
+    this.mapsGDataConverter = mapsGDataConverter;
   }
 }

MyTracksTest/src/com/google/android/apps/mytracks/io/maps/SendMapsAsyncTaskTest.java

@@ -0,0 +1,356 @@
+/*
+ * 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.io.maps;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.TrackStubUtils;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.io.gdata.maps.MapsGDataConverter;
+import com.google.android.apps.mytracks.io.sendtogoogle.SendRequest;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.accounts.Account;
+import android.database.Cursor;
+import android.location.Location;
+import android.test.AndroidTestCase;
+
+import java.util.List;
+
+import org.xmlpull.v1.XmlPullParserException;
+
+/**
+ * Tests {@link SendMapsAsyncTask}.
+ * 
+ * @author Youtao Liu
+ */
+public class SendMapsAsyncTaskTest extends AndroidTestCase {
+
+  private static final long TRACK_ID = 1;
+  private static final String MAP_ID = "MapID_1";
+  // Records the run times of {@link SendMapsAsyncTaskMock#uploadMarker(String,
+  // String, String, Location)}
+  private int uploadMarkerCounter = 0;
+  // Records the run times of {@link
+  // SendMapsAsyncTaskMock#prepareAndUploadPoints(Track, List<Location>,
+  // boolean)}
+  private int prepareAndUploadPointsCounter = 0;
+
+  private SendMapsActivity sendMapsActivityMock;
+  private MyTracksProviderUtils myTracksProviderUtilsMock;
+  private SendRequest sendRequest;
+
+  private class SendMapsAsyncTaskMock extends SendMapsAsyncTask {
+
+    private boolean[] uploadMarkerResult = { false, false };
+    private boolean prepareAndUploadPointsResult = false;
+
+    private SendMapsAsyncTaskMock(SendMapsActivity activity, long trackId, Account account,
+        String chooseMapId, MyTracksProviderUtils myTracksProviderUtils) {
+      super(activity, trackId, account, chooseMapId, myTracksProviderUtils);
+    }
+
+    @Override
+    boolean uploadMarker(String title, String description, String iconUrl, Location location) {
+      int runTimes = uploadMarkerCounter++;
+      return uploadMarkerResult[runTimes];
+    }
+
+    @Override
+    boolean prepareAndUploadPoints(Track track, List<Location> locations, boolean lastBatch) {
+      prepareAndUploadPointsCounter++;
+      return prepareAndUploadPointsResult;
+    }
+  }
+
+  @Override
+  @UsesMocks({ SendMapsActivity.class, MyTracksProviderUtils.class })
+  protected void setUp() throws Exception {
+    super.setUp();
+    uploadMarkerCounter = 0;
+    prepareAndUploadPointsCounter = 0;
+    sendMapsActivityMock = AndroidMock.createMock(SendMapsActivity.class);
+    myTracksProviderUtilsMock = AndroidMock.createMock(MyTracksProviderUtils.class);
+    sendRequest = new SendRequest(TRACK_ID, false, true, false);
+    AndroidMock.expect(sendMapsActivityMock.getApplicationContext()).andReturn(getContext());
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#saveResult()}and makes sure the
+   * track is updated.
+   */
+  public void testSaveResult() {
+    Track track = TrackStubUtils.createTrack(1);
+    track.setMapId(null);
+    AndroidMock.expect(myTracksProviderUtilsMock.getTrack(TRACK_ID)).andReturn(track);
+    myTracksProviderUtilsMock.updateTrack(track);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), sendRequest.getMapId(),
+        myTracksProviderUtilsMock);
+    sendMapsAsyncTask.saveResult();
+    assertEquals(sendRequest.getMapId(), track.getMapId());
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock);
+  }
+
+  /**
+   * Tests {@link SendMapsAsyncTask#fetchSendMapId(Track)} when chooseMapId is
+   * null and makes sure it returns false.
+   */
+  public void testFetchSendMapId_nullMapID() {
+    Track track = TrackStubUtils.createTrack(1);
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock);
+    // Makes chooseMapId to null.
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), null, myTracksProviderUtilsMock);
+    // Returns false for an exception would be thrown.
+    assertFalse(sendMapsAsyncTask.fetchSendMapId(track));
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#fetchSendMapId(Track)} when
+   * chooseMapId is not null. And makes sure it returns false.
+   */
+  public void testFetchSendMapId_notNullMapID() {
+    Track track = TrackStubUtils.createTrack(1);
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    assertTrue(sendMapsAsyncTask.fetchSendMapId(track));
+    assertEquals(MAP_ID, sendMapsAsyncTask.getMapId());
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadAllTrackPoints(Track)} when
+   * cursor is null. And makes sure it returns false.
+   */
+  public void testUploadAllTrackPoints_nullCursor() {
+    Track track = TrackStubUtils.createTrack(1);
+    AndroidMock.expect(myTracksProviderUtilsMock.getLocationsCursor(TRACK_ID, 0, -1, false))
+        .andReturn(null);
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    assertFalse(sendMapsAsyncTask.uploadAllTrackPoints(track));
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadAllTrackPoints(Track)} when
+   * uploads the first marker is failed.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadAllTrackPoints_uploadFirstMarkerFailed() {
+    Track track = TrackStubUtils.createTrack(1);
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    AndroidMock.expect(cursorMock.getCount()).andReturn(2);
+    AndroidMock.expect(cursorMock.moveToPosition(0)).andReturn(true);
+    cursorMock.close();
+    AndroidMock.expect(myTracksProviderUtilsMock.createLocation(cursorMock)).andReturn(
+        new Location("1"));
+    AndroidMock.expect(myTracksProviderUtilsMock.getLocationsCursor(TRACK_ID, 0, -1, false))
+        .andReturn(cursorMock);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTaskMock sendMapsAsyncTask = new SendMapsAsyncTaskMock(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    sendMapsAsyncTask.uploadMarkerResult[0] = false;
+    assertFalse(sendMapsAsyncTask.uploadAllTrackPoints(track));
+    assertEquals(1, uploadMarkerCounter);
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadAllTrackPoints(Track)} when
+   * uploads the two markers is successful but failed when
+   * prepareAndUploadPoints.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadAllTrackPoints_prepareAndUploadPointsFailed() {
+    Track track = TrackStubUtils.createTrack(1);
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    AndroidMock.expect(cursorMock.getCount()).andReturn(2);
+    AndroidMock.expect(cursorMock.moveToPosition(0)).andReturn(true);
+    AndroidMock.expect(cursorMock.moveToPosition(1)).andReturn(true);
+    cursorMock.close();
+    AndroidMock.expect(myTracksProviderUtilsMock.createLocation(cursorMock))
+        .andReturn(new Location("1")).times(2);
+    AndroidMock.expect(myTracksProviderUtilsMock.getLocationsCursor(TRACK_ID, 0, -1, false))
+        .andReturn(cursorMock);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTaskMock sendMapsAsyncTask = new SendMapsAsyncTaskMock(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    // For will be failed when run prepareAndUploadPoints, it no require to
+    // set uploadMarkerResult[1].
+    sendMapsAsyncTask.uploadMarkerResult[0] = true;
+    sendMapsAsyncTask.prepareAndUploadPointsResult = false;
+    assertFalse(sendMapsAsyncTask.uploadAllTrackPoints(track));
+    assertEquals(1, uploadMarkerCounter);
+    assertEquals(1, prepareAndUploadPointsCounter);
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadAllTrackPoints(Track)} when
+   * uploads the last marker is failed.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadAllTrackPoints_uploadLastMarkerFailed() {
+    Track track = TrackStubUtils.createTrack(1);
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    AndroidMock.expect(cursorMock.getCount()).andReturn(2);
+    AndroidMock.expect(cursorMock.moveToPosition(0)).andReturn(true);
+    AndroidMock.expect(cursorMock.moveToPosition(1)).andReturn(true);
+    cursorMock.close();
+    AndroidMock.expect(myTracksProviderUtilsMock.createLocation(cursorMock))
+        .andReturn(new Location("1")).times(2);
+    AndroidMock.expect(myTracksProviderUtilsMock.getLocationsCursor(TRACK_ID, 0, -1, false))
+        .andReturn(cursorMock);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTaskMock sendMapsAsyncTask = new SendMapsAsyncTaskMock(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    sendMapsAsyncTask.uploadMarkerResult[0] = true;
+    sendMapsAsyncTask.uploadMarkerResult[1] = false;
+    sendMapsAsyncTask.prepareAndUploadPointsResult = true;
+    assertFalse(sendMapsAsyncTask.uploadAllTrackPoints(track));
+    assertEquals(2, uploadMarkerCounter);
+    assertEquals(1, prepareAndUploadPointsCounter);
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadAllTrackPoints(Track)} when
+   * return true.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadAllTrackPoints_success() {
+    Track track = TrackStubUtils.createTrack(1);
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    AndroidMock.expect(cursorMock.getCount()).andReturn(2);
+    AndroidMock.expect(cursorMock.moveToPosition(0)).andReturn(true);
+    AndroidMock.expect(cursorMock.moveToPosition(1)).andReturn(true);
+    cursorMock.close();
+    AndroidMock.expect(myTracksProviderUtilsMock.createLocation(cursorMock))
+        .andReturn(new Location("1")).times(2);
+    AndroidMock.expect(myTracksProviderUtilsMock.getLocationsCursor(TRACK_ID, 0, -1, false))
+        .andReturn(cursorMock);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTaskMock sendMapsAsyncTask = new SendMapsAsyncTaskMock(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    sendMapsAsyncTask.uploadMarkerResult[0] = true;
+    sendMapsAsyncTask.uploadMarkerResult[1] = true;
+    sendMapsAsyncTask.prepareAndUploadPointsResult = true;
+    assertTrue(sendMapsAsyncTask.uploadAllTrackPoints(track));
+    assertEquals(2, uploadMarkerCounter);
+    assertEquals(1, prepareAndUploadPointsCounter);
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadWaypoints()} when cursor is
+   * null.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadWaypoints_nullCursor() {
+    AndroidMock.expect(
+        myTracksProviderUtilsMock.getWaypointsCursor(TRACK_ID, 0,
+            Constants.MAX_LOADED_WAYPOINTS_POINTS)).andReturn(null);
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    assertTrue(sendMapsAsyncTask.uploadWaypoints());
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadWaypoints()} when there is
+   * only one point.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadWaypoints_onePoint() {
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    AndroidMock.expect(cursorMock.moveToFirst()).andReturn(true);
+    // Only one point, so next is null.
+    AndroidMock.expect(cursorMock.moveToNext()).andReturn(false);
+    cursorMock.close();
+
+    AndroidMock.expect(
+        myTracksProviderUtilsMock.getWaypointsCursor(TRACK_ID, 0,
+            Constants.MAX_LOADED_WAYPOINTS_POINTS)).andReturn(cursorMock);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+
+    assertTrue(sendMapsAsyncTask.uploadWaypoints());
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadWaypoints()}. Makes sure a cursor is created and
+   * a way point is created with such cursor.
+   * 
+   * @throws XmlPullParserException
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadWaypoints() throws XmlPullParserException {
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    MapsGDataConverter mapsGDataConverterMock = new MapsGDataConverter();
+
+    AndroidMock.expect(cursorMock.moveToFirst()).andReturn(true);
+    AndroidMock.expect(cursorMock.moveToNext()).andReturn(true);
+    cursorMock.close();
+
+    AndroidMock.expect(
+        myTracksProviderUtilsMock.getWaypointsCursor(TRACK_ID, 0,
+            Constants.MAX_LOADED_WAYPOINTS_POINTS)).andReturn(cursorMock);
+    Waypoint waypoint = new Waypoint();
+    waypoint.setLocation(TrackStubUtils.createMyTracksLocation());
+    AndroidMock.expect(myTracksProviderUtilsMock.createWaypoint(cursorMock)).andReturn(waypoint)
+        .times(1);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    sendMapsAsyncTask.setMapsGDataConverter(mapsGDataConverterMock);
+    // Would be failed for there is no source for uploading.
+    assertFalse(sendMapsAsyncTask.uploadWaypoints());
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#getPercentage(int, int)}.
+   */
+  public void testCountPercentage() {
+    assertEquals(SendMapsAsyncTask.PROGRESS_UPLOAD_DATA_MIN, SendMapsAsyncTask.getPercentage(0, 5));
+    assertEquals(SendMapsAsyncTask.PROGRESS_UPLOAD_DATA_MAX,
+        SendMapsAsyncTask.getPercentage(50, 50));
+    assertEquals(
+        (int) ((double) 5
+            / 11
+            * (SendMapsAsyncTask.PROGRESS_UPLOAD_DATA_MAX - SendMapsAsyncTask.PROGRESS_UPLOAD_DATA_MIN) + SendMapsAsyncTask.PROGRESS_UPLOAD_DATA_MIN),
+            SendMapsAsyncTask.getPercentage(5, 11));
+  }
+
+}