Add a play option to play a track.

Check if Google Earth is installed, if not, ask the user
if he wants to install from the Market.

MyTracksTest/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathDescriptorTest.java

@@ -0,0 +1,180 @@
+/*
+ * 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.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.test.AndroidTestCase;
+
+/**
+ * Tests for the {@link DynamicSpeedTrackPathDescriptor}.
+ *
+ * @author Youtao Liu
+ */
+public class DynamicSpeedTrackPathDescriptorTest extends AndroidTestCase {
+
+  private Context context;
+  private SharedPreferences sharedPreferences;
+  private Editor sharedPreferencesEditor;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    context = getContext();
+    sharedPreferences = context.getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+    sharedPreferencesEditor = sharedPreferences.edit();
+  }
+
+  /**
+   * Tests the method {@link DynamicSpeedTrackPathDescriptor#getSpeedMargin()}
+   * with zero, normal and illegal value.
+   */
+  public void testGetSpeedMargin() {
+    String[] actuals = { "0", "50", "99", "" };
+    // The default value of speedMargin is 25.
+    int[] expectations = { 0, 50, 99, 25 };
+    // Test
+    for (int i = 0; i < expectations.length; i++) {
+      sharedPreferencesEditor.putString(
+          context.getString(R.string.track_color_mode_dynamic_speed_variation_key), actuals[i]);
+      sharedPreferencesEditor.commit();
+      DynamicSpeedTrackPathDescriptor dynamicSpeedTrackPathDescriptor = new DynamicSpeedTrackPathDescriptor(
+          context);
+      assertEquals(expectations[i],
+          dynamicSpeedTrackPathDescriptor.getSpeedMargin(sharedPreferences));
+    }
+  }
+
+  /**
+   * Tests {@link
+   * DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the key is null.
+   */
+  public void testOnSharedPreferenceChanged_nullKey() {
+    DynamicSpeedTrackPathDescriptor dynamicSpeedTrackPathDescriptor = new DynamicSpeedTrackPathDescriptor(
+        context);
+    int speedMargin = dynamicSpeedTrackPathDescriptor.getSpeedMargin(sharedPreferences);
+    // Change value in shared preferences.
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_dynamic_speed_variation_key),
+        Integer.toString(speedMargin + 2));
+    sharedPreferencesEditor.commit();
+
+    dynamicSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences, null);
+    assertEquals(speedMargin, dynamicSpeedTrackPathDescriptor.getSpeedMargin());
+  }
+
+  /**
+   * Tests {@link
+   * DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the key is not null, and not trackColorModeDynamicVariation.
+   */
+  public void testOnSharedPreferenceChanged_otherKey() {
+    DynamicSpeedTrackPathDescriptor dynamicSpeedTrackPathDescriptor = new DynamicSpeedTrackPathDescriptor(
+        context);
+    int speedMargin = dynamicSpeedTrackPathDescriptor.getSpeedMargin(sharedPreferences);
+    // Change value in shared preferences.
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_dynamic_speed_variation_key),
+        Integer.toString(speedMargin + 2));
+    sharedPreferencesEditor.commit();
+
+    dynamicSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences, "anyKey");
+    assertEquals(speedMargin, 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(sharedPreferences);
+    // Change value in shared preferences.
+    sharedPreferencesEditor.putString(
+        "trackColorModeDynamicVariation",
+        Integer.toString(speedMargin + 2));
+    sharedPreferencesEditor.commit();
+
+    dynamicSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences,
+        "trackColorModeDynamicVariation");
+    assertEquals(speedMargin + 2, dynamicSpeedTrackPathDescriptor.getSpeedMargin());
+  }
+
+  /**
+   * Tests {@link
+   * DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the values of speedMargin is "".
+   */
+  public void testOnSharedPreferenceChanged_emptyValue() {
+    DynamicSpeedTrackPathDescriptor dynamicSpeedTrackPathDescriptor = new DynamicSpeedTrackPathDescriptor(
+        context);
+    // Change value in shared preferences
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_dynamic_speed_variation_key), "");
+    sharedPreferencesEditor.commit();
+
+    dynamicSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences,
+        context.getString(R.string.track_color_mode_dynamic_speed_variation_key));
+    // The default value of speedMargin is 25.
+    assertEquals(25, dynamicSpeedTrackPathDescriptor.getSpeedMargin());
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#needsRedraw()} by wrong track
+   * id.
+   */
+  public void testNeedsRedraw_WrongTrackId() {
+    long trackId = -1;
+    sharedPreferencesEditor.putLong(context.getString(R.string.selected_track_key), trackId);
+    sharedPreferencesEditor.commit();
+    DynamicSpeedTrackPathDescriptor dynamicSpeedTrackPathDescriptor = new DynamicSpeedTrackPathDescriptor(
+        context);
+    assertEquals(false, dynamicSpeedTrackPathDescriptor.needsRedraw());
+  }
+
+  /**
+   * Tests {@link DynamicSpeedTrackPathDescriptor#needsRedraw()} 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 = { 20, 30, 30,
+        30 * (1 + (DynamicSpeedTrackPathDescriptor.CRITICAL_DIFFERENCE_PERCENTAGE / 100.00) * 2) };
+    // 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());
+    }
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/maps/FixedSpeedTrackPathDescriptorTest.java

@@ -0,0 +1,187 @@
+/*
+ * 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.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.test.AndroidTestCase;
+
+/**
+ * Tests for the {@link DynamicSpeedTrackPathDescriptor}.
+ *
+ * @author Youtao Liu
+ */
+public class FixedSpeedTrackPathDescriptorTest extends AndroidTestCase {
+  private Context context;
+  private SharedPreferences sharedPreferences;
+  private Editor sharedPreferencesEditor;
+  private int slowDefault;
+  private int normalDefault;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    context = getContext();
+    sharedPreferences = context.getSharedPreferences(Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+    sharedPreferencesEditor = sharedPreferences.edit();
+    // Get the default value
+    slowDefault = 9;
+    normalDefault = 15;
+  }
+
+  /**
+   * Tests the initialization of slowSpeed and normalSpeed in {@link
+   * DynamicSpeedTrackPathDescriptor#DynamicSpeedTrackPathDescriptor(Context)}.
+   */
+  public void testConstructor() {
+    String[] slowSpeedsInShPre = { "0", "1", "99", "" };
+    int[] slowSpeedExpectations = { 0, 1, 99, slowDefault };
+    String[] normalSpeedsInShPre = { "0", "1", "99", "" };
+    int[] normalSpeedExpectations = { 0, 1, 99, normalDefault };
+    for (int i = 0; i < slowSpeedsInShPre.length; i++) {
+      sharedPreferencesEditor.putString(
+          context.getString(R.string.track_color_mode_fixed_speed_slow_key), slowSpeedsInShPre[i]);
+      sharedPreferencesEditor.putString(
+          context.getString(R.string.track_color_mode_fixed_speed_medium_key),
+          normalSpeedsInShPre[i]);
+      sharedPreferencesEditor.commit();
+      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
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_fixed_speed_slow_key),
+        Integer.toString(slowSpeed + 2));
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_fixed_speed_medium_key),
+        Integer.toString(normalSpeed + 2));
+    sharedPreferencesEditor.commit();
+
+    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
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_fixed_speed_slow_key),
+        Integer.toString(slowSpeed + 2));
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_fixed_speed_medium_key),
+        Integer.toString(normalSpeed + 2));
+    sharedPreferencesEditor.commit();
+    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();
+    int normalSpeed = fixedSpeedTrackPathDescriptor.getNormalSpeed();
+    // Change value in shared preferences
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_fixed_speed_slow_key),
+        Integer.toString(slowSpeed + 2));
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_fixed_speed_medium_key),
+        Integer.toString(normalSpeed + 2));
+    sharedPreferencesEditor.commit();
+    fixedSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences,
+        context.getString(R.string.track_color_mode_fixed_speed_slow_key));
+    assertEquals(slowSpeed + 2, fixedSpeedTrackPathDescriptor.getSlowSpeed());
+    assertEquals(normalSpeed + 2, fixedSpeedTrackPathDescriptor.getNormalSpeed());
+  }
+
+  /**
+   * Tests {@link
+   * DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the key is normalSpeed.
+   */
+  public void testOnSharedPreferenceChanged_normalSpeedKey() {
+    FixedSpeedTrackPathDescriptor fixedSpeedTrackPathDescriptor = new FixedSpeedTrackPathDescriptor(
+        context);
+    int slowSpeed = fixedSpeedTrackPathDescriptor.getSlowSpeed();
+    int normalSpeed = fixedSpeedTrackPathDescriptor.getNormalSpeed();
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_fixed_speed_slow_key),
+        Integer.toString(slowSpeed + 4));
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_fixed_speed_medium_key),
+        Integer.toString(normalSpeed + 4));
+    sharedPreferencesEditor.commit();
+
+    fixedSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences,
+        context.getString(R.string.track_color_mode_fixed_speed_medium_key));
+    assertEquals(slowSpeed + 4, fixedSpeedTrackPathDescriptor.getSlowSpeed());
+    assertEquals(normalSpeed + 4, fixedSpeedTrackPathDescriptor.getNormalSpeed());
+  }
+
+  /**
+   * Tests {@link
+   * DynamicSpeedTrackPathDescriptor#onSharedPreferenceChanged(SharedPreferences,
+   * String)} when the values of slowSpeed and normalSpeed in SharedPreference
+   * is "". In such situation, the default value should get returned.
+   */
+  public void testOnSharedPreferenceChanged_emptyValue() {
+    FixedSpeedTrackPathDescriptor fixedSpeedTrackPathDescriptor = new FixedSpeedTrackPathDescriptor(
+        context);
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_fixed_speed_slow_key), "");
+    sharedPreferencesEditor.putString(
+        context.getString(R.string.track_color_mode_fixed_speed_medium_key), "");
+    sharedPreferencesEditor.commit();
+
+    fixedSpeedTrackPathDescriptor.onSharedPreferenceChanged(sharedPreferences,
+        context.getString(R.string.track_color_mode_fixed_speed_medium_key));
+    assertEquals(slowDefault, fixedSpeedTrackPathDescriptor.getSlowSpeed());
+    assertEquals(normalDefault, fixedSpeedTrackPathDescriptor.getNormalSpeed());
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/maps/TrackPathDescriptorDynamicSpeedTest.java

@@ -0,0 +1,52 @@
+/*
+ * 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;
+    Boolean alwaysVisible = true;
+    
+    assertNotNull(painter);
+    painter.updatePath(myTracksOverlay.getMapProjection(mockView), 
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, alwaysVisible,
+        myTracksOverlay.getPoints());
+    assertNotNull(myTracksOverlay.getTrackPathPainter().getLastPath());
+    painter.drawTrack(canvas);    
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/maps/TrackPathDescriptorFixedSpeedTest.java

@@ -0,0 +1,52 @@
+/*
+ * 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;
+    Boolean alwaysVisible = true;
+    
+    assertNotNull(painter);
+    painter.updatePath(myTracksOverlay.getMapProjection(mockView), 
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, alwaysVisible,
+        myTracksOverlay.getPoints());
+    assertNotNull(myTracksOverlay.getTrackPathPainter().getLastPath());
+    painter.drawTrack(canvas);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/maps/TrackPathPainterFactoryTest.java

@@ -0,0 +1,78 @@
+/*
+ * 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.Constants;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+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();
+    SharedPreferences prefs = context.getSharedPreferences(
+        Constants.SETTINGS_NAME, Context.MODE_PRIVATE);
+    if (prefs == null) {
+      return;
+    }
+
+    testTrackPathPainterFactorySpecific(context, prefs, R.string.display_track_color_value_none, 
+        SingleColorTrackPathPainter.class);
+    testTrackPathPainterFactorySpecific(context, prefs, R.string.display_track_color_value_fixed, 
+        DynamicSpeedTrackPathPainter.class);
+    testTrackPathPainterFactorySpecific(context, prefs, R.string.display_track_color_value_dynamic, 
+        DynamicSpeedTrackPathPainter.class);
+  }
+  
+  private <T> void testTrackPathPainterFactorySpecific(Context context, SharedPreferences prefs, 
+      int track_color_mode, Class <?> c) {
+    prefs.edit().putString(context.getString(R.string.track_color_mode_key), 
+        context.getString(track_color_mode)).apply();
+    
+    int startLocationIdx = 0;
+    Boolean alwaysVisible = true;
+    
+    TrackPathPainter painter = TrackPathPainterFactory.getTrackPathPainter(context);
+    myTracksOverlay.setTrackPathPainter(painter);
+    
+    assertNotNull(painter);
+    assertTrue(c.isInstance(painter));
+    
+    painter.updatePath(myTracksOverlay.getMapProjection(mockView), 
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, alwaysVisible,
+        myTracksOverlay.getPoints());
+    assertNotNull(myTracksOverlay.getTrackPathPainter().getLastPath());      
+    painter.drawTrack(canvas);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/maps/TrackPathPainterSingleColorTest.java

@@ -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 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;
+    Boolean alwaysVisible = true;
+    
+    assertNotNull(painter);
+    painter.updatePath(myTracksOverlay.getMapProjection(mockView), 
+        myTracksOverlay.getMapViewRect(mockView), startLocationIdx, alwaysVisible,
+        myTracksOverlay.getPoints());
+    assertNotNull(myTracksOverlay.getTrackPathPainter().getLastPath());
+    painter.drawTrack(canvas);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/maps/TrackPathPainterTestCase.java

@@ -0,0 +1,43 @@
+/*
+ * 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.MockMyTracksOverlay;
+import com.google.android.maps.MapView;
+
+import android.graphics.Canvas;
+import android.test.AndroidTestCase;
+
+/**
+ * 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;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    canvas = new Canvas();
+    myTracksOverlay = new MockMyTracksOverlay(getContext());
+    // Enable drawing.
+    myTracksOverlay.setTrackDrawingEnabled(true);
+    mockView = null;
+  }
+}