diff --git a/MyTracks/src/com/google/android/apps/mytracks/io/maps/SendMapsAsyncTask.java b/MyTracks/src/com/google/android/apps/mytracks/io/maps/SendMapsAsyncTask.java index 00c866922..0bf3d098a 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/io/maps/SendMapsAsyncTask.java +++ b/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; - private static final int PROGRESS_UPLOAD_DATA_MAX = 90; + @VisibleForTesting + 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("

" + track.getDescription() + "

" - + descriptionGenerator.generateTrackDescription(track, distances, elevations) + "

"); + + track.setDescription(getTrackDescription(track, distances, elevations)); 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 distances, Vector elevations) { + DescriptionGenerator descriptionGenerator = new DescriptionGeneratorImpl(context); + return "

" + track.getDescription() + "

" + + descriptionGenerator.generateTrackDescription(track, distances, elevations) + "

"; + } + /** * 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 locations, boolean lastBatch) { + @VisibleForTesting + boolean prepareAndUploadPoints(Track track, List locations, boolean lastBatch) { // Prepare locations ArrayList 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) { - double totalPercentage = (double) uploaded / total; - double scaledPercentage = totalPercentage - * (PROGRESS_UPLOAD_DATA_MAX - PROGRESS_UPLOAD_DATA_MIN) + PROGRESS_UPLOAD_DATA_MIN; - publishProgress((int) scaledPercentage); + @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 + * (PROGRESS_UPLOAD_DATA_MAX - PROGRESS_UPLOAD_DATA_MIN) + PROGRESS_UPLOAD_DATA_MIN; + 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; + } +} \ No newline at end of file diff --git a/MyTracksTest/src/com/google/android/apps/mytracks/io/maps/SendMapsAsyncTaskTest.java b/MyTracksTest/src/com/google/android/apps/mytracks/io/maps/SendMapsAsyncTaskTest.java new file mode 100644 index 000000000..65f4fd92c --- /dev/null +++ b/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, + // 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 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)); + } + +} \ No newline at end of file