From c4bddfd6f42496b78104ed417f8ba2338c2c66d9 Mon Sep 17 00:00:00 2001 From: youtaol Date: Fri, 3 Feb 2012 20:13:29 +0800 Subject: [PATCH] Make changes in DynamicSpeedTrackPathDescriptor : Add field: CriticalDifference Add helper method isDifferenceSignificant to test needsRedraw Add getSpeedMargin,setAverageMovingSpeed getAverageMovingSpeed methods Change some code style of DynamicSpeedTrackPathDescriptor Add test cases for FixedSpeedTrackPathDescriptor and DynamicSpeedTrackPathDescriptor --- .../maps/DynamicSpeedTrackPathDescriptor.java | 131 ++++++++----- .../DynamicSpeedTrackPathDescriptorTest.java | 176 +++++++++++++++++ .../FixedSpeedTrackPathDescriptorTest.java | 183 ++++++++++++++++++ 3 files changed, 443 insertions(+), 47 deletions(-) create mode 100644 MyTracksTest/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathDescriptorTest.java create mode 100644 MyTracksTest/src/com/google/android/apps/mytracks/maps/FixedSpeedTrackPathDescriptorTest.java diff --git a/MyTracks/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathDescriptor.java b/MyTracks/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathDescriptor.java index c480f345e..003b52473 100644 --- a/MyTracks/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathDescriptor.java +++ b/MyTracks/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathDescriptor.java @@ -22,34 +22,36 @@ import com.google.android.apps.mytracks.content.MyTracksProviderUtils; import com.google.android.apps.mytracks.content.Track; import com.google.android.apps.mytracks.stats.TripStatistics; import com.google.android.maps.mytracks.R; +import com.google.common.annotations.VisibleForTesting; import android.content.Context; import android.content.SharedPreferences; import android.content.SharedPreferences.OnSharedPreferenceChangeListener; import android.util.Log; - /** * A dynamic speed path descriptor. - * + * * @author Vangelis S. */ -public class DynamicSpeedTrackPathDescriptor - implements TrackPathDescriptor, OnSharedPreferenceChangeListener { - +public class DynamicSpeedTrackPathDescriptor implements TrackPathDescriptor, + OnSharedPreferenceChangeListener { + private int slowSpeed; private int normalSpeed; private int speedMargin; private final int speedMarginDefault; private double averageMovingSpeed; private final Context context; - - public DynamicSpeedTrackPathDescriptor(Context context){ + @VisibleForTesting + static final int CRITICAL_DIFFERENCE_PERCENTAGE = 20; + + public DynamicSpeedTrackPathDescriptor(Context context) { this.context = context; - speedMarginDefault = Integer.parseInt( - context.getString(R.string.color_mode_dynamic_percentage_default)); - SharedPreferences prefs = context.getSharedPreferences( - Constants.SETTINGS_NAME, Context.MODE_PRIVATE); + speedMarginDefault = Integer.parseInt(context + .getString(R.string.color_mode_dynamic_percentage_default)); + SharedPreferences prefs = context.getSharedPreferences(Constants.SETTINGS_NAME, + Context.MODE_PRIVATE); if (prefs == null) { speedMargin = speedMarginDefault; @@ -60,7 +62,8 @@ public class DynamicSpeedTrackPathDescriptor speedMargin = getSpeedMargin(prefs); } - private int getSpeedMargin(SharedPreferences sharedPreferences) { + @VisibleForTesting + int getSpeedMargin(SharedPreferences sharedPreferences) { try { return Integer.parseInt(sharedPreferences.getString( context.getString(R.string.track_color_mode_dynamic_speed_variation_key), @@ -72,34 +75,32 @@ public class DynamicSpeedTrackPathDescriptor /** * Get the slow speed calculated based on the % below the average speed. + * * @return The speed limit considered as slow. */ - public int getSlowSpeed() - { - slowSpeed = (int) (averageMovingSpeed - (averageMovingSpeed * speedMargin / 100)); + public int getSlowSpeed() { + slowSpeed = (int) (averageMovingSpeed - (averageMovingSpeed * speedMargin / 100)); return slowSpeed; } - + /** - * Get the medium speed calculated based on the % above the average speed. + * Gets the medium speed calculated based on the % above the average speed. + * * @return The speed limit considered as normal. */ - public int getNormalSpeed() - { - normalSpeed = (int) (averageMovingSpeed + (averageMovingSpeed * speedMargin / 100)); + public int getNormalSpeed() { + normalSpeed = (int) (averageMovingSpeed + (averageMovingSpeed * speedMargin / 100)); return normalSpeed; } - + @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { Log.d(TAG, "DynamicSpeedTrackPathDescriptor: onSharedPreferences changed " + key); - if (key == null - || !key.equals(context.getString(R.string.track_color_mode_dynamic_speed_variation_key))) { - return; - } - SharedPreferences prefs = context.getSharedPreferences( - Constants.SETTINGS_NAME, Context.MODE_PRIVATE); - + if (key == null + || !key.equals(context.getString(R.string.track_color_mode_dynamic_speed_variation_key))) { return; } + SharedPreferences prefs = context.getSharedPreferences(Constants.SETTINGS_NAME, + Context.MODE_PRIVATE); + if (prefs == null) { speedMargin = speedMarginDefault; return; @@ -110,33 +111,69 @@ public class DynamicSpeedTrackPathDescriptor @Override public boolean needsRedraw() { - SharedPreferences prefs = context.getSharedPreferences( - Constants.SETTINGS_NAME, Context.MODE_PRIVATE); + SharedPreferences prefs = context.getSharedPreferences(Constants.SETTINGS_NAME, + Context.MODE_PRIVATE); long currentTrackId = prefs.getLong(context.getString(R.string.selected_track_key), -1); - if(currentTrackId == -1) { - // Could not find track. - return false; + if (currentTrackId == -1) { + // Could not find track. + return false; } Track track = MyTracksProviderUtils.Factory.get(context).getTrack(currentTrackId); TripStatistics stats = track.getStatistics(); - double newaverageSpeed = (int) Math.floor(stats.getAverageMovingSpeed() * 3.6); - - if(averageMovingSpeed == 0) { - averageMovingSpeed = newaverageSpeed; - return true; - } - - double difference = Math.max(averageMovingSpeed, newaverageSpeed); + double newAverageMovingSpeed = (int) Math.floor(stats.getAverageMovingSpeed() * 3.6); - if (difference == 0.0) { - difference = 0.0; - } else { - difference = Math.abs(averageMovingSpeed - newaverageSpeed) / difference * 100; + return isDifferenceSignificant(averageMovingSpeed, newAverageMovingSpeed); + } + + /** + * Checks whether the old speed and the new speed differ significantly or not. + */ + public boolean isDifferenceSignificant(double oldAverageMovingSpeed, double newAverageMovingSpeed) { + if (oldAverageMovingSpeed == 0) { + if (newAverageMovingSpeed == 0) { + return false; + } else { + averageMovingSpeed = newAverageMovingSpeed; + return true; + } } - if(difference >= 20) { - averageMovingSpeed = newaverageSpeed; + + // Here, both oldAverageMovingSpeed and newAverageMovingSpeed are not zero. + double maxValue = Math.max(oldAverageMovingSpeed, newAverageMovingSpeed); + double differencePercentage = Math.abs(oldAverageMovingSpeed - newAverageMovingSpeed) + / maxValue * 100; + if (differencePercentage >= CRITICAL_DIFFERENCE_PERCENTAGE) { + averageMovingSpeed = newAverageMovingSpeed; return true; } return false; } + + /** + * Gets the value of variable speedMargin to check the result of test. + * @return the value of speedMargin. + */ + @VisibleForTesting + int getSpeedMargin() { + return speedMargin; + } + + /** + * Sets the value of newAverageMovingSpeed to test the method isDifferenceSignificant. + * @param newAverageMovingSpeed the value to set. + */ + @VisibleForTesting + void setAverageMovingSpeed(double newAverageMovingSpeed) { + averageMovingSpeed = newAverageMovingSpeed; + } + + /** + * Gets the value of averageMovingSpeed to check the result of test. + * + * @return the value of averageMovingSpeed + */ + @VisibleForTesting + double getAverageMovingSpeed() { + return averageMovingSpeed; + } } \ No newline at end of file diff --git a/MyTracksTest/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathDescriptorTest.java b/MyTracksTest/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathDescriptorTest.java new file mode 100644 index 000000000..ccbd0678a --- /dev/null +++ b/MyTracksTest/src/com/google/android/apps/mytracks/maps/DynamicSpeedTrackPathDescriptorTest.java @@ -0,0 +1,176 @@ +/* + * 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()} + * 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()} + * 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()} + * 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()} + * 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()); + } + } +} \ No newline at end of file diff --git a/MyTracksTest/src/com/google/android/apps/mytracks/maps/FixedSpeedTrackPathDescriptorTest.java b/MyTracksTest/src/com/google/android/apps/mytracks/maps/FixedSpeedTrackPathDescriptorTest.java new file mode 100644 index 000000000..7efc542fd --- /dev/null +++ b/MyTracksTest/src/com/google/android/apps/mytracks/maps/FixedSpeedTrackPathDescriptorTest.java @@ -0,0 +1,183 @@ +/* + * Copyright 2012 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ +package com.google.android.apps.mytracks.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()} + * 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()} + * 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()} + * 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()} + * 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()} + * 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()); + } +} \ No newline at end of file