Add a class EndToEndTestRunner which extends InstrumentationTestRunner and can get the port of emulator. Then test can be run on more than one emulators at the same time.

2012-08-01 17:25:21 +08:00
commit 8796318335
690 changed files with 64632 additions and 0 deletions
@@ -0,0 +1,129 @@
+/*
+ * 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.maps;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.test.AndroidTestCase;
+
+/**
+ * Tests for the {@link DynamicSpeedTrackPathDescriptor}.
+ * 
+ * @author Youtao Liu
+ */
+public class DynamicSpeedTrackPathDescriptorTest extends AndroidTestCase {
+
+  private Context context;
+  private SharedPreferences sharedPreferences;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    context = getContext();
+    sharedPreferences = context.getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+  }
+
+  /**
+   * Tests the method {@link DynamicSpeedTrackPathDescriptor#getSpeedMargin()}
+   * with zero, normal and illegal value.
+   */
+  public void testGetSpeedMargin() {
+    // The default value of speedMargin is 25.
+    int[] expectations = { 0, 50, 99, 25 };
+    // Test
+    for (int i = 0; i < expectations.length; i++) {
+      PreferencesUtils.setInt(context, R.string.track_color_mode_percentage_key, expectations[i]);
+      DynamicSpeedTrackPathDescriptor dynamicSpeedTrackPathDescriptor = new DynamicSpeedTrackPathDescriptor(
+          context);
+      assertEquals(expectations[i], dynamicSpeedTrackPathDescriptor.getSpeedMargin());
+    }
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the key is trackColorModeDynamicVariation.
+   */
+  public void testOnSharedPreferenceChanged_trackColorModeDynamicVariationKey() {
+    DynamicSpeedTrackPathDescriptor dynamicSpeedTrackPathDescriptor = new DynamicSpeedTrackPathDescriptor(
+        context);
+    int speedMargin = dynamicSpeedTrackPathDescriptor.getSpeedMargin();
+    // Change value in shared preferences.
+    PreferencesUtils.setInt(context, R.string.track_color_mode_percentage_key, speedMargin + 2);
+
+    dynamicSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences,
+        PreferencesUtils.getKey(context, R.string.track_color_mode_percentage_key));
+    assertEquals(speedMargin + 2, dynamicSpeedTrackPathDescriptor.getSpeedMargin());
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the values of speedMargin is the default value.
+   */
+  public void testOnSharedPreferenceChanged_defaultValue() {
+    DynamicSpeedTrackPathDescriptor dynamicSpeedTrackPathDescriptor = new DynamicSpeedTrackPathDescriptor(
+        context);
+    // Change value in shared preferences
+    PreferencesUtils.setInt(context, R.string.track_color_mode_percentage_key,
+        PreferencesUtils.TRACK_COLOR_MODE_PERCENTAGE_DEFAULT);
+    dynamicSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences,
+        PreferencesUtils.getKey(context, R.string.track_color_mode_percentage_key));
+    // The default value of speedMargin is 25.
+    assertEquals(PreferencesUtils.TRACK_COLOR_MODE_PERCENTAGE_DEFAULT,
+        dynamicSpeedTrackPathDescriptor.getSpeedMargin());
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#updateState()} by wrong track
+   * id.
+   */
+  public void testNeedsRedraw_WrongTrackId() {
+    PreferencesUtils.setLong(
+        context, R.string.selected_track_id_key, PreferencesUtils.SELECTED_TRACK_ID_DEFAULT);
+    DynamicSpeedTrackPathDescriptor dynamicSpeedTrackPathDescriptor = new DynamicSpeedTrackPathDescriptor(
+        context);
+    assertEquals(false, dynamicSpeedTrackPathDescriptor.updateState());
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#updateState()} by different
+   * averageMovingSpeed.
+   */
+  public void testIsDiffereceSignificant() {
+    DynamicSpeedTrackPathDescriptor dynamicSpeedTrackPathDescriptor = new DynamicSpeedTrackPathDescriptor(
+        context);
+    double[] averageMovingSpeeds = { 0, 30, 30, 30 };
+    double[] newAverageMovingSpeed = { 20, 30,
+    // Difference is less than CRITICAL_DIFFERENCE_PERCENTAGE
+        30 * (1 + (DynamicSpeedTrackPathDescriptor.CRITICAL_DIFFERENCE_PERCENTAGE / 100) / 2),
+    // Difference is more than CRITICAL_DIFFERENCE_PERCENTAGE
+        30 * (1 + (DynamicSpeedTrackPathDescriptor.CRITICAL_DIFFERENCE_PERCENTAGE / 100.00) * 2) };
+    boolean[] expectedValues = { true, false, false, true };
+    double[] expectedAverageMovingSpeed = { 0, 30, 30, 30 };
+    // Test
+    for (int i = 0; i < newAverageMovingSpeed.length; i++) {
+      dynamicSpeedTrackPathDescriptor.setAverageMovingSpeed(averageMovingSpeeds[i]);
+      assertEquals(expectedValues[i], dynamicSpeedTrackPathDescriptor.isDifferenceSignificant(
+          averageMovingSpeeds[i], newAverageMovingSpeed[i]));
+      assertEquals(
+          expectedAverageMovingSpeed[i], dynamicSpeedTrackPathDescriptor.getAverageMovingSpeed());
+    }
+  }
+}
@@ -0,0 +1,165 @@
+/*
+ * 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.maps;
+
+import com.google.android.apps.mytracks.ColoredPath;
+import com.google.android.apps.mytracks.MapOverlay.CachedLocation;
+import com.google.android.apps.mytracks.TrackStubUtils;
+import com.google.android.maps.mytracks.R;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import java.util.List;
+
+/**
+ * Tests for the {@link DynamicSpeedTrackPathPainter}.
+ * 
+ * @author Youtao Liu
+ */
+public class DynamicSpeedTrackPathPainterTest extends TrackPathPainterTestCase {
+
+  private DynamicSpeedTrackPathPainter dynamicSpeedTrackPathPainter;
+  private TrackPathDescriptor trackPathDescriptor;
+  // This number must bigger than 10 to meet the requirement of test.
+  private static final int NUMBER_OF_LOCATIONS = 100;
+  private static final int LOCATIONS_PER_SEGMENT = 25;
+  // The maximum speed(KM/H) which is considered slow.
+  private static final int SLOW_SPEED_KMH = 30;
+  // The maximum speed(KM/H) which is considered normal.
+  private static final int NORMAL_SPEED_KMH = 50;
+
+  // Convert from kilometers per hour to meters per second
+  private static final double KMH_TO_MS = 1 / 3.6;
+  private static final int SLOW_SPEED_MS = (int) (SLOW_SPEED_KMH * KMH_TO_MS);
+  private static final int NORMAL_SPEED_MS = (int) (NORMAL_SPEED_KMH * KMH_TO_MS);
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    initialTrackPathDescriptorMock();
+    dynamicSpeedTrackPathPainter = new DynamicSpeedTrackPathPainter(getContext(),
+        trackPathDescriptor);
+  }
+
+  /**
+   * Tests the method
+   * {@link DynamicSpeedTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, java.util.List)}
+   * when all locations are invalid.
+   */
+  public void testUpdatePath_AllInvalidLocation() {
+    List<CachedLocation> points = createCachedLocations(NUMBER_OF_LOCATIONS, INVALID_LATITUDE, -1);
+    dynamicSpeedTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), 1, points);
+    AndroidMock.verify(trackPathDescriptor);
+    // Should be zero for there is no valid locations.
+    assertEquals(0, dynamicSpeedTrackPathPainter.getColoredPaths().size());
+  }
+
+  /**
+   * Tests the
+   * {@link DynamicSpeedTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, java.util.List)}
+   * when all locations are valid.
+   */
+  public void testUpdatePath_AllValidLocation() {
+    List<CachedLocation> points = createCachedLocations(NUMBER_OF_LOCATIONS,
+        TrackStubUtils.INITIAL_LATITUDE, -1);
+
+    // Gets a number as the start index of points.
+    int startLocationIdx = NUMBER_OF_LOCATIONS / 2;
+    dynamicSpeedTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, points);
+
+    AndroidMock.verify(trackPathDescriptor);
+    assertEquals(NUMBER_OF_LOCATIONS - startLocationIdx, dynamicSpeedTrackPathPainter
+        .getColoredPaths().size());
+  }
+
+  /**
+   * Tests the
+   * {@link DynamicSpeedTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, java.util.List)}
+   * when all locations are valid. This test setups 4 segments with 25 points
+   * each. The first segment has slow speed, the second segment has normal
+   * speed, the third segment has fast speed, and the fourth segment has slow
+   * speed.
+   */
+  public void testUpdatePath_CheckColoredPath() {
+    // Gets the slow speed. Divide SLOW_SPEED by 2 to make it smaller than
+    // SLOW_SPEED. Speed in MyTracksLocation use MS, but speed in CachedLocation
+    // use KMH.
+    int slowSpeed = SLOW_SPEED_MS / 2;
+    // Gets the normal speed. Makes it smaller than SLOW_SPEED and bigger than
+    // NORMAL_SPEED. Speed in MyTracksLocation use MS, but speed in
+    // CachedLocation use KMH.
+    int normalSpeed = (SLOW_SPEED_MS + NORMAL_SPEED_MS) / 2;
+    // Gets the fast speed. Multiply it by 2 to make it bigger than
+    // NORMAL_SPEED. Speed in MyTracksLocation use MS, but speed in
+    // CachedLocation use KMH.
+    int fastSpeed = NORMAL_SPEED_MS * 2;
+
+    // Get a number of startLocationIdx. And divide NUMBER_OF_LOCATIONS by 8 to
+    // make sure it is less than numberOfFirstThreeSegments.
+    int startLocationIdx = LOCATIONS_PER_SEGMENT / 2;
+
+    List<CachedLocation> points = createCachedLocations(LOCATIONS_PER_SEGMENT,
+        TrackStubUtils.INITIAL_LATITUDE, slowSpeed);
+    points.addAll(createCachedLocations(LOCATIONS_PER_SEGMENT, TrackStubUtils.INITIAL_LATITUDE,
+        normalSpeed));
+    points.addAll(createCachedLocations(LOCATIONS_PER_SEGMENT, TrackStubUtils.INITIAL_LATITUDE,
+        fastSpeed));
+    points.addAll(createCachedLocations(LOCATIONS_PER_SEGMENT, TrackStubUtils.INITIAL_LATITUDE,
+        slowSpeed));
+
+    dynamicSpeedTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, points);
+
+    AndroidMock.verify(trackPathDescriptor);
+    List<ColoredPath> coloredPath = dynamicSpeedTrackPathPainter.getColoredPaths();
+    assertEquals(NUMBER_OF_LOCATIONS - startLocationIdx, coloredPath.size());
+
+    // Checks different speeds with different color in the coloredPath.
+    for (int i = 0; i < NUMBER_OF_LOCATIONS - startLocationIdx; i++) {
+      if (i < LOCATIONS_PER_SEGMENT - startLocationIdx) {
+        // Slow.
+        assertEquals(getContext().getResources().getColor(R.color.slow_path), coloredPath.get(i)
+            .getPathPaint().getColor());
+      } else if (i < LOCATIONS_PER_SEGMENT * 2 - startLocationIdx) {
+        // Normal.
+        assertEquals(getContext().getResources().getColor(R.color.normal_path), coloredPath.get(i)
+            .getPathPaint().getColor());
+      } else if (i < LOCATIONS_PER_SEGMENT * 3 - startLocationIdx) {
+        // Fast.
+        assertEquals(getContext().getResources().getColor(R.color.fast_path), coloredPath.get(i)
+            .getPathPaint().getColor());
+      } else {
+        // Slow.
+        assertEquals(getContext().getResources().getColor(R.color.slow_path), coloredPath.get(i)
+            .getPathPaint().getColor());
+      }
+    }
+  }
+
+  /**
+   * Initials a mocked TrackPathDescriptor object.
+   */
+  @UsesMocks(TrackPathDescriptor.class)
+  private void initialTrackPathDescriptorMock() {
+    trackPathDescriptor = AndroidMock.createMock(TrackPathDescriptor.class);
+    AndroidMock.expect(trackPathDescriptor.getSlowSpeed()).andReturn(SLOW_SPEED_KMH);
+    AndroidMock.expect(trackPathDescriptor.getNormalSpeed()).andReturn(NORMAL_SPEED_KMH);
+    AndroidMock.replay(trackPathDescriptor);
+  }
+
+}
@@ -0,0 +1,144 @@
+/*
+ * 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.maps;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.test.AndroidTestCase;
+
+/**
+ * Tests for the {@link DynamicSpeedTrackPathDescriptor}.
+ * 
+ * @author Youtao Liu
+ */
+public class FixedSpeedTrackPathDescriptorTest extends AndroidTestCase {
+
+  private Context context;
+  private SharedPreferences sharedPreferences;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    context = getContext();
+    sharedPreferences = context.getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+  }
+
+  /**
+   * Tests the initialization of slowSpeed and normalSpeed in {@link DynamicSpeedTrackPathDescriptor#DynamicSpeedTrackPathDescriptor(Context)}
+   * .
+   */
+  public void testConstructor() {
+    int[] slowSpeedExpectations = { 0, 1, 99, PreferencesUtils.TRACK_COLOR_MODE_SLOW_DEFAULT };
+    int[] normalSpeedExpectations = { 0, 1, 99, PreferencesUtils.TRACK_COLOR_MODE_MEDIUM_DEFAULT };
+    for (int i = 0; i < slowSpeedExpectations.length; i++) {
+      PreferencesUtils.setInt(
+          context, R.string.track_color_mode_slow_key, slowSpeedExpectations[i]);
+      PreferencesUtils.setInt(
+          context, R.string.track_color_mode_medium_key, normalSpeedExpectations[i]);
+      FixedSpeedTrackPathDescriptor fixedSpeedTrackPathDescriptor = new FixedSpeedTrackPathDescriptor(
+          context);
+      assertEquals(slowSpeedExpectations[i], fixedSpeedTrackPathDescriptor.getSlowSpeed());
+      assertEquals(normalSpeedExpectations[i], fixedSpeedTrackPathDescriptor.getNormalSpeed());
+    }
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the key is null.
+   */
+  public void testOnSharedPreferenceChanged_null_key() {
+    FixedSpeedTrackPathDescriptor fixedSpeedTrackPathDescriptor = new FixedSpeedTrackPathDescriptor(
+        context);
+    int slowSpeed = fixedSpeedTrackPathDescriptor.getSlowSpeed();
+    int normalSpeed = fixedSpeedTrackPathDescriptor.getNormalSpeed();
+    // Change value in shared preferences
+    PreferencesUtils.setInt(context, R.string.track_color_mode_slow_key, slowSpeed + 2);
+    PreferencesUtils.setInt(context, R.string.track_color_mode_medium_key, normalSpeed + 2);
+    fixedSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences, null);
+    assertEquals(slowSpeed, fixedSpeedTrackPathDescriptor.getSlowSpeed());
+    assertEquals(normalSpeed, fixedSpeedTrackPathDescriptor.getNormalSpeed());
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the key is not null, and not slowSpeed and not normalSpeed.
+   */
+  public void testOnSharedPreferenceChanged_other_key() {
+    FixedSpeedTrackPathDescriptor fixedSpeedTrackPathDescriptor = new FixedSpeedTrackPathDescriptor(
+        context);
+    int slowSpeed = fixedSpeedTrackPathDescriptor.getSlowSpeed();
+    int normalSpeed = fixedSpeedTrackPathDescriptor.getNormalSpeed();
+    // Change value in shared preferences
+    PreferencesUtils.setInt(context, R.string.track_color_mode_slow_key, slowSpeed + 2);
+    PreferencesUtils.setInt(context, R.string.track_color_mode_medium_key, normalSpeed + 2);
+    fixedSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences, "anyKey");
+    assertEquals(slowSpeed, fixedSpeedTrackPathDescriptor.getSlowSpeed());
+    assertEquals(normalSpeed, fixedSpeedTrackPathDescriptor.getNormalSpeed());
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the key is slowSpeed.
+   */
+  public void testOnSharedPreferenceChanged_slowSpeedKey() {
+    FixedSpeedTrackPathDescriptor fixedSpeedTrackPathDescriptor = new FixedSpeedTrackPathDescriptor(
+        context);
+    int slowSpeed = fixedSpeedTrackPathDescriptor.getSlowSpeed();
+    // Change value in shared preferences
+    PreferencesUtils.setInt(context, R.string.track_color_mode_slow_key, slowSpeed + 2);
+    fixedSpeedTrackPathDescriptor.onSharedPreferenceChanged(
+        sharedPreferences, context.getString(R.string.track_color_mode_slow_key));
+    assertEquals(slowSpeed + 2, fixedSpeedTrackPathDescriptor.getSlowSpeed());
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the key is normalSpeed.
+   */
+  public void testOnSharedPreferenceChanged_normalSpeedKey() {
+    FixedSpeedTrackPathDescriptor fixedSpeedTrackPathDescriptor = new FixedSpeedTrackPathDescriptor(
+        context);
+    int normalSpeed = fixedSpeedTrackPathDescriptor.getNormalSpeed();
+    PreferencesUtils.setInt(context, R.string.track_color_mode_medium_key, normalSpeed + 4);
+    fixedSpeedTrackPathDescriptor.onSharedPreferenceChanged(
+        sharedPreferences, context.getString(R.string.track_color_mode_medium_key));
+    assertEquals(normalSpeed + 4, fixedSpeedTrackPathDescriptor.getNormalSpeed());
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the values of slowSpeed and normalSpeed in SharedPreference
+   * are the default values.
+   */
+  public void testOnSharedPreferenceChanged_defaultValue() {
+    FixedSpeedTrackPathDescriptor fixedSpeedTrackPathDescriptor = new FixedSpeedTrackPathDescriptor(
+        context);
+    PreferencesUtils.setInt(context, R.string.track_color_mode_slow_key,
+        PreferencesUtils.TRACK_COLOR_MODE_SLOW_DEFAULT);
+    PreferencesUtils.setInt(context, R.string.track_color_mode_medium_key,
+        PreferencesUtils.TRACK_COLOR_MODE_MEDIUM_DEFAULT);
+    fixedSpeedTrackPathDescriptor.onSharedPreferenceChanged(
+        sharedPreferences, context.getString(R.string.track_color_mode_medium_key));
+    assertEquals(PreferencesUtils.TRACK_COLOR_MODE_SLOW_DEFAULT,
+        fixedSpeedTrackPathDescriptor.getSlowSpeed());
+    assertEquals(PreferencesUtils.TRACK_COLOR_MODE_MEDIUM_DEFAULT,
+        fixedSpeedTrackPathDescriptor.getNormalSpeed());
+  }
+}
@@ -0,0 +1,126 @@
+/*
+ * 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.maps;
+
+import com.google.android.apps.mytracks.MapOverlay.CachedLocation;
+import com.google.android.apps.mytracks.TrackStubUtils;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.graphics.Path;
+
+import java.util.List;
+
+/**
+ * Tests for the {@link SingleColorTrackPathPainter}.
+ * 
+ * @author Youtao Liu
+ */
+public class SingleColorTrackPathPainterTest extends TrackPathPainterTestCase {
+
+  private static final int NUMBER_OF_LOCATIONS = 10;
+  private SingleColorTrackPathPainter singleColorTrackPathPainter;
+  private Path pathMock;
+
+
+  /**
+   * Initials a mocked TrackPathDescriptor object and
+   * singleColorTrackPathPainter.
+   */
+  @Override
+  @UsesMocks(Path.class)
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    singleColorTrackPathPainter = new SingleColorTrackPathPainter(getContext());
+    pathMock = AndroidMock.createStrictMock(Path.class);
+  }
+
+  /**
+   * Tests the
+   * {@link SingleColorTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, List, Path)}
+   * method when all locations are valid.
+   */
+  public void testUpdatePath_AllValidLocation() {
+    // Gets a number as the start index of points.
+    int startLocationIdx = NUMBER_OF_LOCATIONS / 2;
+    
+    pathMock.incReserve(NUMBER_OF_LOCATIONS - startLocationIdx);
+    List<CachedLocation> points = createCachedLocations(NUMBER_OF_LOCATIONS,
+        TrackStubUtils.INITIAL_LATITUDE, -1);
+
+    for (int i = startLocationIdx; i < NUMBER_OF_LOCATIONS; i++) {
+      pathMock.lineTo(0, 0);
+    }
+
+    AndroidMock.replay(pathMock);
+    singleColorTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, points, pathMock);
+    AndroidMock.verify(pathMock);
+  }
+
+  /**
+   * Tests the
+   * {@link SingleColorTrackPathPainter#updatePath(com.google.android.maps.Projection, android.graphics.Rect, int, Boolean, List, Path)}
+   * method when all locations are invalid.
+   */
+  public void testUpdatePath_AllInvalidLocation() {
+    int startLocationIdx = NUMBER_OF_LOCATIONS / 2;
+    pathMock.incReserve(NUMBER_OF_LOCATIONS - startLocationIdx);
+    List<CachedLocation> points = createCachedLocations(NUMBER_OF_LOCATIONS, INVALID_LATITUDE, -1);
+    // Gets a random number from 1 to numberOfLocations.
+    AndroidMock.replay(pathMock);
+    singleColorTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, points, pathMock);
+    AndroidMock.verify(pathMock);
+  }
+
+  /**
+   * Tests the {@link SingleColorTrackPathPainter#updatePath(com.google.android.maps.Projection,
+   * android.graphics.Rect, int, Boolean, List, Path)} method when there are
+   * three segments.
+   */
+  public void testUpdatePath_ThreeSegments() {
+    // First segment.
+    List<CachedLocation> points = createCachedLocations(NUMBER_OF_LOCATIONS,
+        TrackStubUtils.INITIAL_LATITUDE, -1);
+    points.addAll(createCachedLocations(1, INVALID_LATITUDE, -1));
+    // Second segment.
+    points.addAll(createCachedLocations(NUMBER_OF_LOCATIONS, TrackStubUtils.INITIAL_LATITUDE, -1));
+    points.addAll(createCachedLocations(1, INVALID_LATITUDE, -1));
+    // Third segment.
+    points.addAll(createCachedLocations(NUMBER_OF_LOCATIONS, TrackStubUtils.INITIAL_LATITUDE, -1));
+    // Gets a random number from 1 to numberOfLocations.
+    int startLocationIdx = NUMBER_OF_LOCATIONS / 2;
+    pathMock.incReserve(NUMBER_OF_LOCATIONS *3 + 1 +1 - startLocationIdx);
+    for (int i = 0; i < NUMBER_OF_LOCATIONS - startLocationIdx; i++) {
+      pathMock.lineTo(0, 0);
+    }
+    pathMock.moveTo(0, 0);
+    for (int i = 0; i < NUMBER_OF_LOCATIONS - 1; i++) {
+      pathMock.lineTo(0, 0);
+    }
+    pathMock.moveTo(0, 0);
+    for (int i = 0; i < NUMBER_OF_LOCATIONS - 1; i++) {
+      pathMock.lineTo(0, 0);
+    }
+
+    AndroidMock.replay(pathMock);
+    singleColorTrackPathPainter.updatePath(myTracksOverlay.getMapProjection(mockView),
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, points, pathMock);
+    AndroidMock.verify(pathMock);
+  }
+}
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2011 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.maps;
+
+import android.location.Location;
+
+/**
+ * Tests for the MyTracks track path descriptors and painters.
+ * 
+ * @author Vangelis S.
+ */
+public class TrackPathDescriptorDynamicSpeedTest extends TrackPathPainterTestCase {
+  
+  public void testDynamicSpeedTrackPathDescriptor() throws Exception {
+    Location location = new Location("gps");
+    location.setLatitude(10);
+    
+    for (int i = 0; i < 100; ++i) {
+      location = new Location("gps");
+      location.setLatitude(20 + i / 2);
+      location.setLongitude(150 - i);
+      myTracksOverlay.addLocation(location);
+    }
+    
+    TrackPathPainter painter = new DynamicSpeedTrackPathPainter(
+        getContext(), new DynamicSpeedTrackPathDescriptor(getContext()));
+    myTracksOverlay.setTrackPathPainter(painter);
+    
+    int startLocationIdx = 0;
+
+    assertNotNull(painter);
+    painter.updatePath(myTracksOverlay.getMapProjection(mockView), 
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx,
+        myTracksOverlay.getPoints());
+    assertNotNull(myTracksOverlay.getTrackPathPainter().hasPath());
+    painter.drawPath(canvas);    
+  }
+}
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2011 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.maps;
+
+import android.location.Location;
+
+/**
+ * Tests for the MyTracks track path descriptors and painters.
+ * 
+ * @author Vangelis S.
+ */
+public class TrackPathDescriptorFixedSpeedTest extends TrackPathPainterTestCase {
+
+  public void testFixedSpeedTrackPathDescriptor() throws Exception {
+    Location location = new Location("gps");
+    location.setLatitude(10);
+
+    for (int i = 0; i < 100; ++i) {
+      location = new Location("gps");
+      location.setLatitude(20 + i / 2);
+      location.setLongitude(150 - i);
+      myTracksOverlay.addLocation(location);
+    }
+    
+    TrackPathPainter painter = new DynamicSpeedTrackPathPainter(
+        getContext(), new FixedSpeedTrackPathDescriptor(getContext()));
+    myTracksOverlay.setTrackPathPainter(painter);
+    
+    int startLocationIdx = 0;
+
+    assertNotNull(painter);
+    painter.updatePath(myTracksOverlay.getMapProjection(mockView), 
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, myTracksOverlay.getPoints());
+    assertNotNull(myTracksOverlay.getTrackPathPainter().hasPath());
+    painter.drawPath(canvas);
+  }
+}
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2011 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.maps;
+
+import com.google.android.apps.mytracks.util.PreferencesUtils;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.location.Location;
+
+/**
+ * Tests for the MyTracks track path painter factory.
+ * 
+ * @author Vangelis S.
+ */
+public class TrackPathPainterFactoryTest extends TrackPathPainterTestCase {
+  
+  public void testTrackPathPainterFactory() throws Exception {
+    Location location = new Location("gps");
+    location.setLatitude(10);
+    
+    for (int i = 0; i < 100; ++i) {
+      location = new Location("gps");
+      location.setLatitude(20 + i / 2);
+      location.setLongitude(150 - i);
+      myTracksOverlay.addLocation(location);
+    }
+    
+    Context context = getContext();
+
+    testTrackPathPainterFactorySpecific(context,
+        R.string.settings_map_track_color_mode_single_value, SingleColorTrackPathPainter.class);
+    testTrackPathPainterFactorySpecific(context, R.string.settings_map_track_color_mode_fixed_value,
+        DynamicSpeedTrackPathPainter.class);
+    testTrackPathPainterFactorySpecific(context,
+        R.string.settings_map_track_color_mode_dynamic_value, DynamicSpeedTrackPathPainter.class);
+  }
+  
+  private <T> void testTrackPathPainterFactorySpecific(
+      Context context, int track_color_mode, Class<?> c) {
+    PreferencesUtils.setString(
+        context, R.string.track_color_mode_key, context.getString(track_color_mode));
+
+    int startLocationIdx = 0;
+
+    TrackPathPainter painter = TrackPathPainterFactory.getTrackPathPainter(context);
+    myTracksOverlay.setTrackPathPainter(painter);
+    
+    assertNotNull(painter);
+    assertTrue(c.isInstance(painter));
+    
+    painter.updatePath(myTracksOverlay.getMapProjection(mockView), 
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx,
+        myTracksOverlay.getPoints());
+    assertNotNull(myTracksOverlay.getTrackPathPainter().hasPath());      
+    painter.drawPath(canvas);
+  }
+}
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2011 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.maps;
+
+import android.location.Location;
+
+/**
+ * Tests for the MyTracks track path descriptors and painters.
+ * 
+ * @author Vangelis S.
+ */
+public class TrackPathPainterSingleColorTest extends TrackPathPainterTestCase {
+
+  public void testSimpeColorTrackPathPainter() throws Exception {
+    Location location = new Location("gps");
+    location.setLatitude(10);
+
+    for (int i = 0; i < 100; ++i) {
+      location = new Location("gps");
+      location.setLatitude(20 + i / 2);
+      location.setLongitude(150 - i);
+      myTracksOverlay.addLocation(location);
+    }
+    
+    TrackPathPainter painter = new SingleColorTrackPathPainter(getContext());
+    myTracksOverlay.setTrackPathPainter(painter);
+    
+    int startLocationIdx = 0;
+    
+    assertNotNull(painter);
+    painter.updatePath(myTracksOverlay.getMapProjection(mockView), 
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx,
+        myTracksOverlay.getPoints());
+    assertNotNull(myTracksOverlay.getTrackPathPainter().hasPath());
+    painter.drawPath(canvas);
+  }
+}
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2011 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.maps;
+
+import com.google.android.apps.mytracks.MapOverlay;
+import com.google.android.apps.mytracks.MapOverlay.CachedLocation;
+import com.google.android.apps.mytracks.MockMyTracksOverlay;
+import com.google.android.apps.mytracks.TrackStubUtils;
+import com.google.android.maps.MapView;
+
+import android.graphics.Canvas;
+import android.location.Location;
+import android.test.AndroidTestCase;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Tests for the MyTracks track path descriptors and painters.
+ * 
+ * @author Vangelis S.
+ */
+public class TrackPathPainterTestCase extends AndroidTestCase {
+  
+  protected Canvas canvas;
+  protected MockMyTracksOverlay myTracksOverlay;
+  protected MapView mockView;
+
+  final int INVALID_LATITUDE = 100;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    canvas = new Canvas();
+    myTracksOverlay = new MockMyTracksOverlay(getContext());
+    // Enable drawing.
+    myTracksOverlay.setTrackDrawingEnabled(true);
+    mockView = null;
+  }
+
+  /**
+   * Creates a list of CachedLocations.
+   * 
+   * @param number the number of locations
+   * @param latitude the latitude value of locations.
+   * @param speed the speed(meter per second) of locations, and will give a default valid value if
+   *          less than zero
+   * @return the simulated locations
+   */
+  List<CachedLocation> createCachedLocations(int number, double latitude, float speed) {
+    List<CachedLocation> points = new ArrayList<MapOverlay.CachedLocation>();
+    for (int i = 0; i < number; ++i) {
+      Location location = TrackStubUtils.createMyTracksLocation(latitude,
+          TrackStubUtils.INITIAL_LONGITUDE, TrackStubUtils.INITIAL_ALTITUDE);
+      if (speed > 0) {
+        location.setSpeed(speed);
+      }
+      CachedLocation cachedLocation = new CachedLocation(location);
+      points.add(cachedLocation);
+    }
+    return points;
+  }
+}