Issue 45: Add ImportAllTracks to import GPX files from /sdcard/MyTracks/gpx

ImportAllTracks is essentially just a modification of ExportAllTracks that
uses the existing GpxImporter to import all GPX files found in
/sdcard/MyTracks/gpx. So that the import functionality can always be accessed,
the MyTracks Activity's MenuManager is altered so that the Tracks button shows
regardless of whether there are any tracks in the database (ImportAllTracks is
launched by a button in the lower right of the MyTracksList activity).

A Toast message shows if no GPX files are found; this serves as a hint to
users on where to put GPX files for import so that this addition should be
discoverable and useable without documentation.

Im

MyTracksTest/src/com/google/android/apps/mytracks/ChartValueSeriesTest.java

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2010 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;
+
+import com.google.android.apps.mytracks.ChartValueSeries.ZoomSettings;
+import com.google.android.maps.mytracks.R;
+
+import android.graphics.Paint.Style;
+import android.test.AndroidTestCase;
+
+/**
+ * @author Sandor Dornbush
+ */
+public class ChartValueSeriesTest extends AndroidTestCase {
+  private ChartValueSeries series;
+ 
+  @Override
+  protected void setUp() throws Exception {
+    series = new ChartValueSeries(getContext(),
+        "###,###",
+        R.color.elevation_fill,
+        R.color.elevation_border,
+        new ZoomSettings(5, new int[] {100}),
+        R.string.elevation);
+  }
+
+  public void testInitialConditions() {
+    assertEquals(0, series.getInterval());
+    assertEquals(1, series.getMaxLabelLength());
+    assertEquals(0, series.getMin());
+    assertEquals(0, series.getMax());
+    assertEquals(0.0, series.getSpread());
+    assertEquals(Style.STROKE, series.getPaint().getStyle());
+    assertEquals(getContext().getString(R.string.elevation),
+        series.getTitle());
+    assertTrue(series.isEnabled());
+  }
+
+  public void testEnabled() {
+    series.setEnabled(false);
+    assertFalse(series.isEnabled());
+  }
+  
+  public void testSmallUpdates() {
+    series.update(0);
+    series.update(10);
+    series.updateDimension();
+    assertEquals(100, series.getInterval());
+    assertEquals(3, series.getMaxLabelLength());
+    assertEquals(0, series.getMin());
+    assertEquals(100, series.getMax());
+    assertEquals(100.0, series.getSpread());
+  }
+
+  public void testBigUpdates() {
+    series.update(0);
+    series.update(901);
+    series.updateDimension();
+    assertEquals(100, series.getInterval());
+    assertEquals(5, series.getMaxLabelLength());
+    assertEquals(0, series.getMin());
+    assertEquals(1000, series.getMax());
+    assertEquals(1000.0, series.getSpread());
+  }
+
+  public void testNotZeroBasedUpdates() {
+    series.update(500);
+    series.update(1401);
+    series.updateDimension();
+    assertEquals(100, series.getInterval());
+    assertEquals(5, series.getMaxLabelLength());
+    assertEquals(500, series.getMin());
+    assertEquals(1500, series.getMax());
+    assertEquals(1000.0, series.getSpread());
+  }
+
+  public void testZoomSettings_invalidArgs() {
+    try {
+      new ZoomSettings(0, new int[] {10, 50, 100});
+      fail("Expected IllegalArgumentException");
+    } catch (IllegalArgumentException e) {
+      // OK.
+    }
+    try {
+      new ZoomSettings(1, null);
+      fail("Expected IllegalArgumentException");
+    } catch (IllegalArgumentException e) {
+      // OK.
+    }
+    try {
+      new ZoomSettings(1, new int[] {});
+      fail("Expected IllegalArgumentException");
+    } catch (IllegalArgumentException e) {
+      // OK.
+    }
+    try {
+      new ZoomSettings(1, new int[] {1, 3, 2});
+      fail("Expected IllegalArgumentException");
+    } catch (IllegalArgumentException e) {
+      // OK.
+    }
+  }
+  
+  public void testZoomSettings_minAligned() {
+    ZoomSettings settings = new ZoomSettings(5, new int[] {10, 50, 100});
+    assertEquals(10, settings.calculateInterval(0, 15));
+    assertEquals(10, settings.calculateInterval(0, 50));
+    assertEquals(50, settings.calculateInterval(0, 111));
+    assertEquals(50, settings.calculateInterval(0, 250));
+    assertEquals(100, settings.calculateInterval(0, 251));
+    assertEquals(100, settings.calculateInterval(0, 10000));
+  }
+
+  public void testZoomSettings_minNotAligned() {
+    ZoomSettings settings = new ZoomSettings(5, new int[] {10, 50, 100});
+    assertEquals(50, settings.calculateInterval(5, 55));
+    assertEquals(10, settings.calculateInterval(10, 60));
+    assertEquals(50, settings.calculateInterval(7, 250));
+    assertEquals(100, settings.calculateInterval(7, 257));
+    assertEquals(100, settings.calculateInterval(11, 10000));
+    
+    // A regression test.
+    settings = new ZoomSettings(5, new int[] {5, 10, 20});
+    assertEquals(10, settings.calculateInterval(-37.14, -11.89));
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/DialogManagerTest.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2010 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;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.ProgressDialog;
+import android.test.ActivityInstrumentationTestCase2;
+
+/**
+ * @author Sandor Dornbush
+ */
+public class DialogManagerTest
+    extends ActivityInstrumentationTestCase2<MyTracks> {
+
+  public DialogManagerTest() {
+    super(MyTracks.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    MyTracks.clearInstance();
+    assertNull(MyTracks.getInstance());
+  }
+
+  public void test_onCreateChartSettings() {
+    Dialog d =
+        getActivity().onCreateDialog(DialogManager.DIALOG_CHART_SETTINGS, null);
+    assertNotNull(d);
+    assertTrue(d instanceof ChartSettingsDialog);
+  }
+
+  public void test_onCreateImportProgress() {
+    Dialog d =
+        getActivity().onCreateDialog(
+            DialogManager.DIALOG_IMPORT_PROGRESS, null);
+    assertNotNull(d);
+    assertTrue(d instanceof ProgressDialog);
+  }
+
+  public void test_onCreateProgress() {
+    Dialog d =
+        getActivity().onCreateDialog(DialogManager.DIALOG_PROGRESS, null);
+    assertNotNull(d);
+    assertTrue(d instanceof ProgressDialog);
+    ProgressDialog pd = (ProgressDialog) d;
+    assertEquals(100, pd.getMax());
+    assertEquals(10, pd.getProgress());
+  }
+
+  public void test_onCreateSendToGoogle() {
+    Dialog d =
+        getActivity().onCreateDialog(DialogManager.DIALOG_SEND_TO_GOOGLE, null);
+    assertNotNull(d);
+    assertTrue(d instanceof SendToGoogleDialog);
+  }
+
+  public void test_onCreateSendToGoogleResult() {
+    Dialog d =
+        getActivity().onCreateDialog(
+            DialogManager.DIALOG_SEND_TO_GOOGLE_RESULT, null);
+    assertNotNull(d);
+    assertTrue(d instanceof AlertDialog);
+  }
+
+  public void test_onCreateWriteProgress() {
+    Dialog d =
+        getActivity().onCreateDialog(
+            DialogManager.DIALOG_WRITE_PROGRESS, null);
+    assertNotNull(d);
+    assertTrue(d instanceof ProgressDialog);
+  }
+
+}

MyTracksTest/src/com/google/android/apps/mytracks/MyTracksOverlayTest.java

@@ -0,0 +1,243 @@
+/*
+ * Copyright 2010 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;
+
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.maps.GeoPoint;
+import com.google.android.maps.MapView;
+import com.google.android.maps.Projection;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Path;
+import android.graphics.Point;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.location.Location;
+import android.test.AndroidTestCase;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Tests for the MyTracks map overlay.
+ * 
+ * @author Bartlomiej Niechwiej
+ */
+public class MyTracksOverlayTest extends AndroidTestCase {
+  private Canvas canvas;
+  private MockMyTracksOverlay myTracksOverlay;
+  private MapView mockView;
+  private Projection mockProjection;
+  
+  /**
+   * A mock version of {@code MyTracksOverlay} that does not use
+   * {@class MapView}. 
+   */
+  private class MockMyTracksOverlay extends MyTracksOverlay {
+    public MockMyTracksOverlay(Context context) {
+      super(context);
+    }
+    @Override
+    Projection getMapProjection(MapView mapView) {
+      return mockProjection;
+    }
+    @Override
+    Rect getMapViewRect(MapView mapView) {
+      return new Rect(0, 0, 100, 100);
+    }
+    @Override
+    Path newPath() {
+      return new MockPath();
+    }
+  }
+  
+  /**
+   * A mock class that intercepts {@code Path}'s and records calls to
+   * {@code #moveTo()} and {@code #lineTo()}.
+   */
+  private static class MockPath extends Path {
+    /** A list of disjoined path segments. */
+    public final List<List<PointF>> segments = new LinkedList<List<PointF>>();
+    /** The total number of points in this path. */
+    public int totalPoints;
+    
+    private List<PointF> currentSegment;
+
+    @Override
+    public void lineTo(float x, float y) {
+      super.lineTo(x, y);
+      assertNotNull(currentSegment);
+      currentSegment.add(new PointF(x, y));
+      totalPoints++;
+    }
+    @Override
+    public void moveTo(float x, float y) {
+      super.moveTo(x, y);
+      segments.add(currentSegment =
+          new ArrayList<PointF>(Arrays.asList(new PointF(x, y))));
+      totalPoints++;
+    }
+  }
+
+  /**
+   * A mock {@code Projection} that acts as the identity matrix.
+   */
+  private static class MockProjection implements Projection {
+    @Override
+    public Point toPixels(GeoPoint in, Point out) {
+      return out;
+    }
+    @Override
+    public float metersToEquatorPixels(float meters) {
+      return meters;
+    }
+    @Override
+    public GeoPoint fromPixels(int x, int y) {
+      return new GeoPoint(y, x);
+    }
+  }
+  
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    canvas = new Canvas();
+    myTracksOverlay = new MockMyTracksOverlay(getContext());
+    // Enable drawing.
+    myTracksOverlay.setTrackDrawingEnabled(true);
+    mockView = null;
+    mockProjection = new MockProjection();
+  }
+
+  public void testAddLocation() throws Exception {
+    Location location = new Location("gps");
+    location.setLatitude(10);
+    location.setLongitude(20);
+    myTracksOverlay.addLocation(location);
+    assertEquals(1, myTracksOverlay.getNumLocations());
+    assertEquals(0, myTracksOverlay.getNumWaypoints());
+    
+    location.setLatitude(20);
+    location.setLongitude(30);
+    myTracksOverlay.addLocation(location);
+    assertEquals(2, myTracksOverlay.getNumLocations());
+    assertEquals(0, myTracksOverlay.getNumWaypoints());
+    assertNull(myTracksOverlay.getLastPath());
+    
+    // Draw and make sure that we don't lose any point.
+    myTracksOverlay.draw(canvas, mockView, false);
+    assertEquals(2, myTracksOverlay.getNumLocations());
+    assertEquals(0, myTracksOverlay.getNumWaypoints());
+    assertNotNull(myTracksOverlay.getLastPath());
+    assertEquals(2, ((MockPath)myTracksOverlay.getLastPath()).totalPoints);
+    
+    myTracksOverlay.draw(canvas, mockView, true);
+    assertEquals(2, myTracksOverlay.getNumLocations());
+    assertEquals(0, myTracksOverlay.getNumWaypoints());
+    assertNotNull(myTracksOverlay.getLastPath());
+  }
+  
+  public void testClearPoints() throws Exception {
+    Location location = new Location("gps");
+    location.setLatitude(10);
+    location.setLongitude(20);
+    myTracksOverlay.addLocation(location);
+    assertEquals(1, myTracksOverlay.getNumLocations());
+    myTracksOverlay.clearPoints();
+    assertEquals(0, myTracksOverlay.getNumLocations());
+
+    // Same after drawing on canvas.
+    final int locations = 100;
+    for (int i = 0; i < locations; ++i) {
+      myTracksOverlay.addLocation(location);
+    }
+    assertEquals(locations, myTracksOverlay.getNumLocations());
+    myTracksOverlay.draw(canvas, mockView, false);
+    myTracksOverlay.draw(canvas, mockView, true);
+    myTracksOverlay.clearPoints();
+    assertEquals(0, myTracksOverlay.getNumLocations());
+  }
+
+  public void testAddWaypoint() throws Exception {
+    Location location = new Location("gps");
+    location.setLatitude(10);
+    location.setLongitude(20);
+    Waypoint waypoint = new Waypoint();
+    waypoint.setLocation(location);
+    myTracksOverlay.addWaypoint(waypoint);
+    assertEquals(1, myTracksOverlay.getNumWaypoints());
+    assertEquals(0, myTracksOverlay.getNumLocations());
+    assertNull(myTracksOverlay.getLastPath());
+    
+    final int waypoints = 10;
+    for (int i = 0; i < waypoints; ++i) {
+      waypoint = new Waypoint();
+      waypoint.setLocation(location);
+      myTracksOverlay.addWaypoint(waypoint);
+    }
+    assertEquals(1 + waypoints, myTracksOverlay.getNumWaypoints());
+    assertEquals(0, myTracksOverlay.getNumLocations());
+    assertNull(myTracksOverlay.getLastPath());
+  }
+
+  public void testClearWaypoints() throws Exception {
+    Location location = new Location("gps");
+    location.setLatitude(10);
+    location.setLongitude(20);
+    Waypoint waypoint = new Waypoint();
+    waypoint.setLocation(location);
+    myTracksOverlay.addWaypoint(waypoint);
+    assertEquals(1, myTracksOverlay.getNumWaypoints());
+    myTracksOverlay.clearWaypoints();
+    assertEquals(0, myTracksOverlay.getNumWaypoints());
+  }
+  
+  public void testDrawing() {
+    Location location = new Location("gps");
+    location.setLatitude(10);
+    for (int i = 0; i < 40; ++i) {
+      location.setLongitude(20 + i);
+      Waypoint waypoint = new Waypoint();
+      waypoint.setLocation(location);
+      myTracksOverlay.addWaypoint(waypoint);
+    }
+    for (int i = 0; i < 100; ++i) {
+      location = new Location("gps");
+      location.setLatitude(20 + i / 2);
+      location.setLongitude(150 - i);
+      myTracksOverlay.addLocation(location);
+    }
+    
+    // Shadow.
+    myTracksOverlay.draw(canvas, mockView, true);
+    // We don't expect to do anything if  
+    assertNull(myTracksOverlay.getLastPath());
+    assertEquals(40, myTracksOverlay.getNumWaypoints());
+    assertEquals(100, myTracksOverlay.getNumLocations());
+
+    // No shadow.
+    myTracksOverlay.draw(canvas, mockView, false);
+    assertNotNull(myTracksOverlay.getLastPath());
+    assertTrue(myTracksOverlay.getLastPath() instanceof MockPath);
+    MockPath path = (MockPath) myTracksOverlay.getLastPath();
+    assertEquals(40, myTracksOverlay.getNumWaypoints());
+    assertEquals(100, myTracksOverlay.getNumLocations());
+    assertEquals(100, path.totalPoints);
+    // TODO: Check the points from the path (and the segments).
+  }
+}

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

@@ -0,0 +1,250 @@
+/*
+ * Copyright 2010 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;
+
+import com.google.android.maps.mytracks.R;
+
+import android.app.Activity;
+import android.app.Instrumentation.ActivityMonitor;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.net.Uri;
+import android.test.ActivityInstrumentationTestCase2;
+import android.widget.Button;
+
+import java.io.File;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * A unit test for {@link MyTracks} activity.
+ * 
+ * @author Bartlomiej Niechwiej
+ */
+public class MyTracksTest extends ActivityInstrumentationTestCase2<MyTracks>{
+  public MyTracksTest() {
+    super(MyTracks.class);
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    MyTracks.clearInstance();
+    assertNull(MyTracks.getInstance());
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    clearSelectedAndRecordingTracks();
+    waitForIdle();
+    super.tearDown();
+  }
+  
+  public void testInitialization_mainAction() {
+    // Make sure we can start MyTracks and the activity doesn't start recording.
+    assertNotNull(getActivity());
+    assertNotNull(MyTracks.getInstance());
+    assertNotNull(getActivity().getSharedPreferences());
+    
+    // Check if not recording.
+    assertFalse(getActivity().isRecording());
+    assertEquals(-1, getActivity().getRecordingTrackId());
+    long selectedTrackId = getActivity().getSharedPreferences().getLong(
+        getActivity().getString(R.string.selected_track_key), -1);
+    assertEquals(selectedTrackId, getActivity().getSelectedTrackId());
+  }
+  
+  public void testInitialization_viewActionWithNoData() {
+    // Simulate start with ACTION_VIEW intent.
+    Intent startIntent = new Intent();
+    startIntent.setAction(Intent.ACTION_VIEW);
+    setActivityIntent(startIntent);
+    
+    assertNotNull(getActivity());
+    assertNotNull(MyTracks.getInstance());
+    assertNotNull(getActivity().getSharedPreferences());
+    
+    // Check if not recording.
+    assertFalse(getActivity().isRecording());
+    assertEquals(-1, getActivity().getRecordingTrackId());
+    long selectedTrackId = getActivity().getSharedPreferences().getLong(
+        getActivity().getString(R.string.selected_track_key), -1);
+    assertEquals(selectedTrackId, getActivity().getSelectedTrackId());
+  }
+  
+  public void testInitialization_viewActionWithValidData() throws Exception {
+    // Simulate start with ACTION_VIEW intent.
+    Intent startIntent = new Intent();
+    startIntent.setAction(Intent.ACTION_VIEW);
+    Uri uri = Uri.fromFile(File.createTempFile("valid", ".gpx"));
+
+    // TODO: Add a valid GPX.
+    
+    startIntent.setData(uri);
+    setActivityIntent(startIntent);
+    
+    assertNotNull(getActivity());
+    assertNotNull(MyTracks.getInstance());
+    assertNotNull(getActivity().getSharedPreferences());
+    
+    // Check if not recording.
+    assertFalse(getActivity().isRecording());
+    assertEquals(-1, getActivity().getRecordingTrackId());
+    long selectedTrackId = getActivity().getSharedPreferences().getLong(
+        getActivity().getString(R.string.selected_track_key), -1);
+    assertEquals(selectedTrackId, getActivity().getSelectedTrackId());
+    
+   // TODO: Finish this test.
+  }
+  
+  public void testInitialization_viewActionWithInvalidData() throws Exception {
+    // Simulate start with ACTION_VIEW intent.
+    Intent startIntent = new Intent();
+    startIntent.setAction(Intent.ACTION_VIEW);
+    Uri uri = Uri.fromFile(File.createTempFile("invalid", ".gpx"));
+    startIntent.setData(uri);
+    setActivityIntent(startIntent);
+    
+    assertNotNull(getActivity());
+    assertNotNull(MyTracks.getInstance());
+    assertNotNull(getActivity().getSharedPreferences());
+    
+    // Check if not recording.
+    assertFalse(getActivity().isRecording());
+    assertEquals(-1, getActivity().getRecordingTrackId());
+    long selectedTrackId = getActivity().getSharedPreferences().getLong(
+        getActivity().getString(R.string.selected_track_key), -1);
+    assertEquals(selectedTrackId, getActivity().getSelectedTrackId());
+    
+    // TODO: Finish this test.
+  }
+  
+  public void testRecording_startAndStop() throws Exception {
+    // Make sure we can start MyTracks and the activity doesn't start recording.
+    assertNotNull(getActivity());
+    assertNotNull(MyTracks.getInstance());
+    assertNotNull(getActivity().getSharedPreferences());
+
+    // Check if not recording.
+    clearSelectedAndRecordingTracks();    
+    waitForIdle();
+
+    assertFalse(getActivity().isRecording());
+    assertEquals(-1, getActivity().getRecordingTrackId());
+    long selectedTrackId = getActivity().getSharedPreferences().getLong(
+        getActivity().getString(R.string.selected_track_key), -1);
+    assertEquals(selectedTrackId, getActivity().getSelectedTrackId());
+
+    // Start a new track.
+    getActivity().startRecording();
+    long recordingTrackId = awaitRecordingStatus(5000, true);
+    assertTrue(recordingTrackId >= 0);
+    
+    // Wait until we are done and make sure that selectedTrack = recordingTrack.
+    waitForIdle();
+    assertEquals(recordingTrackId, getActivity().getSharedPreferences().getLong(
+        getActivity().getString(R.string.recording_track_key), -1));
+    selectedTrackId = getActivity().getSharedPreferences().getLong(
+        getActivity().getString(R.string.selected_track_key), -1);
+    assertEquals(recordingTrackId, selectedTrackId);
+    assertEquals(selectedTrackId, getActivity().getSelectedTrackId());
+    
+    // Watch for MyTracksDetails activity. 
+    ActivityMonitor monitor = getInstrumentation().addMonitor(
+        MyTracksDetails.class.getName(), null, false);
+
+    // Now, stop the track and make sure that it is still selected, but
+    // no longer recording.
+    getActivity().stopRecording();
+    
+    // Check if we got back MyTracksDetails activity. 
+    Activity activity = getInstrumentation().waitForMonitor(monitor);
+    assertTrue(activity instanceof MyTracksDetails);
+    
+    // TODO: Update track name and other properties and test if they were
+    // properly saved.
+    
+    // Simulate a click on Save button.
+    Button save = (Button) activity.findViewById(R.id.trackdetails_save);
+    save.performClick();
+
+    // Check the remaining properties.
+    recordingTrackId = awaitRecordingStatus(5000, false);
+    assertEquals(-1, recordingTrackId);
+    assertEquals(recordingTrackId, getActivity().getRecordingTrackId());
+    assertEquals(recordingTrackId, getActivity().getSharedPreferences().getLong(
+        getActivity().getString(R.string.recording_track_key), -1));
+    // Make sure this is the same track as the last recording track ID.
+    assertEquals(selectedTrackId, getActivity().getSelectedTrackId());
+  }
+  
+  /**
+   * Waits until the UI thread becomes idle.
+   */
+  private void waitForIdle() throws InterruptedException {
+    // Note: We can't use getInstrumentation().waitForIdleSync() here.  
+    final Object semaphore = new Object();
+    synchronized (semaphore) {
+      final AtomicBoolean isIdle = new AtomicBoolean();
+      getInstrumentation().waitForIdle(new Runnable() {
+        @Override
+        public void run() {
+          synchronized (semaphore) {
+            isIdle.set(true);
+            semaphore.notify();
+          }
+        }
+      });
+      while (!isIdle.get()) {
+        semaphore.wait();
+      }
+    }
+  }
+
+  /**
+   * Clears {selected,recording}TrackId in the {@link SharedPreferences}.
+   */
+  private void clearSelectedAndRecordingTracks() {
+    Editor editor = getActivity().getSharedPreferences().edit();
+    editor.putLong(getActivity().getString(R.string.selected_track_key), -1);
+    editor.putLong(getActivity().getString(R.string.recording_track_key), -1);
+    
+    editor.clear();
+    editor.commit();
+  }
+  
+  /**
+   * Waits until the recording state changes to the given status.
+   * 
+   * @param timeout the maximum time to wait, in milliseconds.
+   * @param isRecording the final status to await.
+   * @return the recording track ID.
+   */
+  private long awaitRecordingStatus(long timeout, boolean isRecording)
+      throws TimeoutException, InterruptedException {
+    long startTime = System.nanoTime();
+    while (getActivity().isRecording() != isRecording) {
+      if (System.nanoTime() - startTime > timeout * 1000000) {
+        throw new TimeoutException("Timeout while waiting for recording!");
+      }
+      Thread.sleep(20);
+    }
+    waitForIdle();
+    assertEquals(isRecording, getActivity().isRecording());
+    return getActivity().getRecordingTrackId();
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/content/MyTracksProviderUtilsImplTest.java

@@ -0,0 +1,171 @@
+/*
+ * Copyright 2010 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.content;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationFactory;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.LocationIterator;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceTest.MockContext;
+
+import android.content.Context;
+import android.location.Location;
+import android.test.AndroidTestCase;
+import android.test.RenamingDelegatingContext;
+import android.test.mock.MockContentResolver;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * A unit test for {@link MyTracksProviderUtilsImpl}.
+ *
+ * @author Bartlomiej Niechwiej
+ */
+public class MyTracksProviderUtilsImplTest extends AndroidTestCase {
+  private Context context;
+  private MyTracksProviderUtils providerUtils;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    
+    MockContentResolver mockContentResolver = new MockContentResolver();
+    RenamingDelegatingContext targetContext = new RenamingDelegatingContext(
+        getContext(), getContext(), "test.");
+    context = new MockContext(mockContentResolver, targetContext);
+    MyTracksProvider provider = new MyTracksProvider();
+    provider.attachInfo(context, null);
+    mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, provider);
+    setContext(context);
+
+    providerUtils = MyTracksProviderUtils.Factory.get(context);
+  }
+
+  public void testLocationIterator_noPoints() {
+    testIterator(1, 0, 1, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+
+  public void testLocationIterator_customFactory() {
+    final Location location = new Location("test_location");
+    final AtomicInteger counter = new AtomicInteger();
+    testIterator(1, 15, 4, false, new LocationFactory() {
+      @Override
+      public Location createLocation() {
+        counter.incrementAndGet();
+        return location;
+      }
+    });
+    // Make sure we were called exactly as many times as we had track points.
+    assertEquals(15, counter.get());
+  }
+  
+  public void testLocationIterator_nullFactory() {
+    try {
+      testIterator(1, 15, 4, false, null);
+      fail("Expecting IllegalArgumentException");
+    } catch (IllegalArgumentException e) {
+      // Expected.
+    }
+  }
+
+  public void testLocationIterator_noBatchAscending() {
+    testIterator(1, 50, 100, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    testIterator(2, 50, 50, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+  
+  public void testLocationIterator_noBatchDescending() {
+    testIterator(1, 50, 100, true, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    testIterator(2, 50, 50, true, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+ 
+  public void testLocationIterator_batchAscending() {
+    testIterator(1, 50, 11, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    testIterator(2, 50, 25, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+ 
+  public void testLocationIterator_batchDescending() {
+    testIterator(1, 50, 11, true, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    testIterator(2, 50, 25, true, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+  
+  public void testLocationIterator_largeTrack() {
+    testIterator(1, 20000, 2000, false, MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+  }
+
+  private List<Location> testIterator(long trackId, int numPoints, int batchSize,
+      boolean descending, LocationFactory locationFactory) {
+    long lastPointId = initializeTrack(trackId, numPoints);
+    ((MyTracksProviderUtilsImpl) providerUtils).setDefaultCursorBatchSize(batchSize);
+    List<Location> locations = new ArrayList<Location>(numPoints);
+    LocationIterator it = providerUtils.getLocationIterator(trackId, -1, descending, locationFactory);
+    try {
+      while (it.hasNext()) {
+        Location loc = it.next();
+        assertNotNull(loc);
+        locations.add(loc);
+        // Make sure the IDs are returned in the right order.
+        assertEquals(descending ? lastPointId - locations.size() + 1
+            : lastPointId - numPoints + locations.size(), it.getLocationId());
+      }
+      assertEquals(numPoints, locations.size());
+    } finally {
+      it.close();
+    }
+    return locations;
+  }
+  
+  private long initializeTrack(long id, int numPoints) {
+    Track track = new Track();
+    track.setId(id);
+    track.setName("Test: " + id);
+    track.setNumberOfPoints(numPoints);
+    providerUtils.insertTrack(track);
+    track = providerUtils.getTrack(id);
+    assertNotNull(track);
+    
+    Location[] locations = new Location[numPoints];
+    for (int i = 0; i < numPoints; ++i) {
+      Location loc = new Location("test");
+      loc.setLatitude(37.0 + (double) i / 10000.0);
+      loc.setLongitude(57.0 - (double) i / 10000.0);
+      loc.setAccuracy((float) i / 100.0f);
+      loc.setAltitude(i * 2.5);
+      locations[i] = loc;
+    }
+    providerUtils.bulkInsertTrackPoints(locations, numPoints, id);
+    
+    // Load all inserted locations. 
+    long lastPointId = -1;
+    int counter = 0;
+    LocationIterator it = providerUtils.getLocationIterator(id, -1, false,
+        MyTracksProviderUtils.DEFAULT_LOCATION_FACTORY);
+    try {
+      while (it.hasNext()) {
+        it.next();
+        lastPointId = it.getLocationId();
+        counter++;
+      }
+    } finally {
+      it.close();
+    }
+
+    assertTrue(numPoints == 0 || lastPointId > 0);
+    assertEquals(numPoints, track.getNumberOfPoints());
+    assertEquals(numPoints, counter);
+    
+    return lastPointId;
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/content/WaypointCreationRequestTest.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2010 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.content;
+
+import com.google.android.apps.mytracks.content.WaypointCreationRequest.WaypointType;
+
+import android.os.Parcel;
+import android.test.AndroidTestCase;
+
+/**
+ * Tests for the WaypointCreationRequest class.
+ * {@link WaypointCreationRequest}
+ *
+ * @author Sandor Dornbush
+ */
+public class WaypointCreationRequestTest extends AndroidTestCase {
+
+  public void testTypeParceling() {
+    WaypointCreationRequest original = WaypointCreationRequest.DEFAULT_MARKER;
+    Parcel p = Parcel.obtain();
+    original.writeToParcel(p, 0);
+    p.setDataPosition(0);
+    WaypointCreationRequest copy = WaypointCreationRequest.CREATOR.createFromParcel(p);
+    assertEquals(original.getType(), copy.getType());
+    assertNull(copy.getName());
+    assertNull(copy.getDescription());
+    assertNull(copy.getIconUrl());
+  }
+
+  public void testAllAttributesParceling() {
+    WaypointCreationRequest original =
+      new WaypointCreationRequest(WaypointType.MARKER, "name", "description", "img.png");
+    Parcel p = Parcel.obtain();
+    original.writeToParcel(p, 0);
+    p.setDataPosition(0);
+    WaypointCreationRequest copy = WaypointCreationRequest.CREATOR.createFromParcel(p);
+    assertEquals(original.getType(), copy.getType());
+    assertEquals("name", copy.getName());
+    assertEquals("description", copy.getDescription());
+    assertEquals("img.png", copy.getIconUrl());
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/CsvTrackWriterTest.java

@@ -0,0 +1,12 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+
+package com.google.android.apps.mytracks.io;
+
+/**
+ * Tests for the CSV track exporter.
+ *
+ * @author Rodrigo Damazio
+ */
+public class CsvTrackWriterTest extends TrackFormatWriterTest {
+
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/GpxImporterTest.java

@@ -0,0 +1,300 @@
+/*
+ * Copyright 2010 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;
+
+import static com.google.android.testing.mocking.AndroidMock.eq;
+import static com.google.android.testing.mocking.AndroidMock.expect;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.TracksColumns;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.Factory;
+import com.google.android.apps.mytracks.testing.TestingProviderUtilsFactory;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.content.ContentUris;
+import android.location.Location;
+import android.location.LocationManager;
+import android.net.Uri;
+import android.test.AndroidTestCase;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.SimpleTimeZone;
+
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.easymock.Capture;
+import org.easymock.IArgumentMatcher;
+import org.xml.sax.SAXException;
+
+/**
+ * Tests for the GPX importer.
+ * 
+ * @author Steffen Horlacher
+ */
+public class GpxImporterTest extends AndroidTestCase {
+
+  private static final String TRACK_NAME = "blablub";
+  private static final String TRACK_DESC = "s'Laebe isch koi Schlotzer";
+
+  private static final String TRACK_LAT_1 = "48.768364";
+  private static final String TRACK_LON_1 = "9.177886";
+  private static final String TRACK_ELE_1 = "324.0";
+  private static final String TRACK_TIME_1 = "2010-04-22T18:21:00Z";
+
+  private static final String TRACK_LAT_2 = "48.768374";
+  private static final String TRACK_LON_2 = "9.177816";
+  private static final String TRACK_ELE_2 = "333.0";
+  private static final String TRACK_TIME_2 = "2010-04-22T18:21:50.123";
+
+  private static final SimpleDateFormat DATE_FORMAT1 =
+      new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");
+  private static final SimpleDateFormat DATE_FORMAT2 =
+      new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss'Z'");
+  static {
+    // We can't omit the timezones in the test, otherwise it'll use the local
+    // timezone and fail depending on where the test runner is.
+    SimpleTimeZone utc = new SimpleTimeZone(0, "UTC");
+    DATE_FORMAT1.setTimeZone(utc);
+    DATE_FORMAT2.setTimeZone(utc);
+  }
+
+  // TODO: use real files from different sources with more track points.
+  private static final String VALID_TEST_GPX = "<gpx><trk><name><![CDATA["
+      + TRACK_NAME + "]]></name><desc><![CDATA[" + TRACK_DESC
+      + "]]></desc><trkseg>" + "<trkpt lat=\"" + TRACK_LAT_1 + "\" lon=\""
+      + TRACK_LON_1 + "\"><ele>" + TRACK_ELE_1 + "</ele><time>" + TRACK_TIME_1
+      + "</time></trkpt> +" + "<trkpt lat=\"" + TRACK_LAT_2 + "\" lon=\""
+      + TRACK_LON_2 + "\"><ele>" + TRACK_ELE_2 + "</ele><time>" + TRACK_TIME_2
+      + "</time></trkpt>" + "</trkseg></trk></gpx>";
+
+  // invalid xml
+  private static final String INVALID_XML_TEST_GPX = VALID_TEST_GPX.substring(
+      0, VALID_TEST_GPX.length() - 50);
+  private static final String INVALID_LOCATION_TEST_GPX = VALID_TEST_GPX
+      .replaceAll(TRACK_LAT_1, "1000.0");
+  private static final String INVALID_TIME_TEST_GPX = VALID_TEST_GPX
+      .replaceAll(TRACK_TIME_1, "invalid");
+  private static final String INVALID_ALTITUDE_TEST_GPX = VALID_TEST_GPX
+      .replaceAll(TRACK_ELE_1, "invalid");
+  private static final String INVALID_LATITUDE_TEST_GPX = VALID_TEST_GPX
+      .replaceAll(TRACK_LAT_1, "invalid");
+  private static final String INVALID_LONGITUDE_TEST_GPX = VALID_TEST_GPX
+      .replaceAll(TRACK_LON_1, "invalid");
+
+  private static final long TRACK_ID = 1;
+  private static final long TRACK_POINT_ID_1 = 1;
+  private static final long TRACK_POINT_ID_2 = 2;
+
+  private static final Uri TRACK_ID_URI = ContentUris.appendId(
+      TracksColumns.CONTENT_URI.buildUpon(), TRACK_ID).build();
+
+  private MyTracksProviderUtils providerUtils;
+
+  private Factory oldProviderUtilsFactory;
+
+  @UsesMocks(MyTracksProviderUtils.class)
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    providerUtils = AndroidMock.createMock(MyTracksProviderUtils.class);
+    oldProviderUtilsFactory =
+        TestingProviderUtilsFactory.installWithInstance(providerUtils);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    TestingProviderUtilsFactory.restoreOldFactory(oldProviderUtilsFactory);
+    super.tearDown();
+  }
+
+  /**
+   * Test import success.
+   */
+  public void testImportSuccess() throws Exception {
+    Capture<Track> trackParam = new Capture<Track>();
+
+    Location loc1 = new Location(LocationManager.GPS_PROVIDER);
+    loc1.setTime(DATE_FORMAT2.parse(TRACK_TIME_1).getTime());
+    loc1.setLatitude(Double.parseDouble(TRACK_LAT_1));
+    loc1.setLongitude(Double.parseDouble(TRACK_LON_1));
+    loc1.setAltitude(Double.parseDouble(TRACK_ELE_1));
+
+    Location loc2 = new Location(LocationManager.GPS_PROVIDER);
+    loc2.setTime(DATE_FORMAT1.parse(TRACK_TIME_2).getTime());
+    loc2.setLatitude(Double.parseDouble(TRACK_LAT_2));
+    loc2.setLongitude(Double.parseDouble(TRACK_LON_2));
+    loc2.setAltitude(Double.parseDouble(TRACK_ELE_2));
+
+    expect(providerUtils.insertTrack(AndroidMock.capture(trackParam)))
+        .andReturn(TRACK_ID_URI);
+
+    expect(providerUtils.getLastLocationId(TRACK_ID)).andReturn(TRACK_POINT_ID_1).andReturn(TRACK_POINT_ID_2);
+
+    // A flush happens after the first insertion to get the starting point ID,
+    // which is why we get two calls
+    expect(providerUtils.bulkInsertTrackPoints(LocationsMatcher.eqLoc(loc1),
+        eq(1), eq(TRACK_ID))).andReturn(1);
+    expect(providerUtils.bulkInsertTrackPoints(LocationsMatcher.eqLoc(loc2),
+        eq(1), eq(TRACK_ID))).andReturn(1);
+
+    providerUtils.updateTrack(AndroidMock.capture(trackParam));
+
+    AndroidMock.replay(providerUtils);
+
+    InputStream is = new ByteArrayInputStream(VALID_TEST_GPX.getBytes());
+    GpxImporter.importGPXFile(is, providerUtils);
+
+    AndroidMock.verify(providerUtils);
+
+    // verify track parameter
+    Track track = trackParam.getValue();
+    assertEquals(TRACK_NAME, track.getName());
+    assertEquals(TRACK_DESC, track.getDescription());
+    assertEquals(DATE_FORMAT2.parse(TRACK_TIME_1).getTime(), track.getStatistics()
+        .getStartTime());
+    assertNotSame(-1, track.getStartId());
+    assertNotSame(-1, track.getStopId());
+  }
+
+  /**
+   * Test with invalid location - track should be deleted.
+   */
+  public void testImportLocationFailure() throws ParserConfigurationException,
+      SAXException, IOException {
+    testInvalidXML(INVALID_LOCATION_TEST_GPX);
+  }
+
+  /**
+   * Test with invalid time - track should be deleted.
+   */
+  public void testImportTimeFailure() throws ParserConfigurationException,
+      SAXException, IOException {
+    testInvalidXML(INVALID_TIME_TEST_GPX);
+  }
+
+  /**
+   * Test with invalid xml - track should be deleted.
+   */
+  public void testImportXMLFailure() throws ParserConfigurationException,
+      SAXException, IOException {
+    testInvalidXML(INVALID_XML_TEST_GPX);
+  }
+  
+  /**
+   * Test with invalid altitude - track should be deleted.
+   */
+  public void testImportInvalidAltitude() throws ParserConfigurationException,
+      SAXException, IOException {
+    testInvalidXML(INVALID_ALTITUDE_TEST_GPX);
+  }
+
+  /**
+   * Test with invalid latitude - track should be deleted.
+   */
+  public void testImportInvalidLatitude() throws ParserConfigurationException,
+      SAXException, IOException {
+    testInvalidXML(INVALID_LATITUDE_TEST_GPX);
+  }
+  
+  /**
+   * Test with invalid longitude - track should be deleted.
+   */
+  public void testImportInvalidLongitude() throws ParserConfigurationException,
+      SAXException, IOException {
+    testInvalidXML(INVALID_LONGITUDE_TEST_GPX);
+  }
+  
+  private void testInvalidXML(String xml) throws ParserConfigurationException,
+      IOException {
+    expect(providerUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_URI);
+
+    expect(providerUtils.bulkInsertTrackPoints((Location[]) AndroidMock.anyObject(),
+        AndroidMock.anyInt(), AndroidMock.anyLong())).andStubReturn(1);
+    expect(providerUtils.getLastLocationId(TRACK_ID)).andStubReturn(TRACK_POINT_ID_1);
+
+    providerUtils.deleteTrack(TRACK_ID);
+
+    AndroidMock.replay(providerUtils);
+
+    InputStream is = new ByteArrayInputStream(xml.getBytes());
+    try {
+      GpxImporter.importGPXFile(is, providerUtils);
+    } catch (SAXException e) {
+      // expected exception
+    }
+
+    AndroidMock.verify(providerUtils);
+  }
+
+  /**
+   * Workaround because of capture bug 2617107 in easymock:
+   * http://sourceforge.net
+   * /tracker/?func=detail&aid=2617107&group_id=82958&atid=567837
+   */
+  private static class LocationsMatcher implements IArgumentMatcher {
+    private final Location[] matchLocs;
+
+    private LocationsMatcher(Location[] expected) {
+      this.matchLocs = expected;
+    }
+
+    public static Location[] eqLoc(Location[] expected) {
+      IArgumentMatcher matcher = new LocationsMatcher(expected);
+      AndroidMock.reportMatcher(matcher);
+      return null;
+    }
+
+    public static Location[] eqLoc(Location expected) {
+      return eqLoc(new Location[] { expected});
+    }
+
+    @Override
+    public void appendTo(StringBuffer buf) {
+      buf.append("eqLoc(").append(Arrays.toString(matchLocs)).append(")");
+    }
+
+    @Override
+    public boolean matches(Object obj) {
+      if (! (obj instanceof Location[])) { return false; }
+      Location[] locs = (Location[]) obj;
+      if (locs.length < matchLocs.length) { return false; }
+
+      // Only check the first elements (those that will be taken into account)
+      for (int i = 0; i < matchLocs.length; i++) {
+        if (!locationsMatch(locs[i], matchLocs[i])) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    private boolean locationsMatch(Location loc1, Location loc2) {
+      return (loc1.getTime() == loc2.getTime()) &&
+             (loc1.getLatitude() == loc2.getLatitude()) &&
+             (loc1.getLongitude() == loc2.getLongitude()) &&
+             (loc1.getAltitude() == loc2.getAltitude());
+    }
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/GpxTrackWriterTest.java

@@ -0,0 +1,70 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+package com.google.android.apps.mytracks.io;
+
+import com.google.android.apps.mytracks.content.Waypoint;
+
+import android.location.Location;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import java.util.Date;
+import java.util.List;
+
+/**
+ * Tests for the GPX track exporter.
+ *
+ * @author Rodrigo Damazio
+ */
+public class GpxTrackWriterTest extends TrackFormatWriterTest {
+
+  public void testXmlOutput() throws Exception {
+    TrackFormatWriter writer = new GpxTrackWriter();
+    String result = writeTrack(writer);
+    Document doc = parseXmlDocument(result);
+
+    Element gpxTag = getChildElement(doc, "gpx");
+    Element trackTag = getChildElement(gpxTag, "trk");
+    assertEquals(TRACK_NAME, getChildTextValue(trackTag, "name"));
+    assertEquals(TRACK_DESCRIPTION, getChildTextValue(trackTag, "desc"));
+    assertEquals(Long.toString(TRACK_ID),
+        getChildTextValue(trackTag, "number"));
+    List<Element> segmentTags = getChildElements(trackTag, "trkseg", 2);
+    List<Element> segPointTags = getChildElements(segmentTags.get(0), "trkpt", 2);
+    assertTagMatchesLocation(segPointTags.get(0),
+        "0", "0", "1970-01-01T02:46:40Z", "0");
+    assertTagMatchesLocation(segPointTags.get(1),
+        "1", "-1", "1970-01-01T02:46:41Z", "5000000");
+
+    segPointTags = getChildElements(segmentTags.get(1), "trkpt", 2);
+    assertTagMatchesLocation(segPointTags.get(0),
+        "2", "-2", "1970-01-01T02:46:42Z", "10000000");
+    assertTagMatchesLocation(segPointTags.get(1),
+        "3", "-3", "1970-01-01T02:46:43Z", "15000000");
+
+    List<Element> waypointTags = getChildElements(gpxTag, "wpt", 2);
+    Element wptTag = waypointTags.get(0);
+    assertEquals(WAYPOINT1_NAME, getChildTextValue(wptTag, "name"));
+    assertEquals(WAYPOINT1_DESCRIPTION, getChildTextValue(wptTag, "desc"));
+    assertTagMatchesLocation(wptTag,
+        "1", "-1", "1970-01-01T02:46:41Z", "5000000");
+
+    wptTag = waypointTags.get(1);
+    assertEquals(WAYPOINT2_NAME, getChildTextValue(wptTag, "name"));
+    assertEquals(WAYPOINT2_DESCRIPTION, getChildTextValue(wptTag, "desc"));
+    assertTagMatchesLocation(wptTag,
+        "2", "-2", "1970-01-01T02:46:42Z", "10000000");
+  }
+
+  /**
+   * Asserts that the given tag describes the location given by the
+   * Strings lat, lon, time, and ele.
+   */
+  private void assertTagMatchesLocation(Element tag, String lat,
+      String lon, String time, String ele) {
+    assertEquals(lat, tag.getAttribute("lat"));
+    assertEquals(lon, tag.getAttribute("lon"));
+    assertEquals(time, getChildTextValue(tag, "time"));
+    assertEquals(ele, getChildTextValue(tag, "ele"));
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/KmlTrackWriterTest.java

@@ -0,0 +1,113 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+package com.google.android.apps.mytracks.io;
+
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.util.StringUtils;
+
+import android.location.Location;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import java.util.List;
+import java.util.Vector;
+
+/**
+ * Tests for the KML track exporter.
+ *
+ * @author Rodrigo Damazio
+ */
+public class KmlTrackWriterTest extends TrackFormatWriterTest {
+  private static final String FULL_TRACK_DESCRIPTION = "full track description";
+
+  /**
+   * A fake version of {@link StringUtils} which returns a fixed track
+   * description, thus not depending on the context.
+   */
+  private class FakeStringUtils extends StringUtils {
+    public FakeStringUtils() {
+      super(null);
+    }
+
+    @Override
+    public String generateTrackDescription(Track track,
+        Vector<Double> distances, Vector<Double> elevations) {
+      assertSame(KmlTrackWriterTest.super.track, track);
+      assertTrue(distances.isEmpty());
+      assertTrue(elevations.isEmpty());
+      return FULL_TRACK_DESCRIPTION;
+    }
+  }
+
+  public void testXmlOutput() throws Exception {
+    KmlTrackWriter writer = new KmlTrackWriter(new FakeStringUtils());
+    String result = writeTrack(writer);
+    Document doc = parseXmlDocument(result);
+
+    Element kmlTag = getChildElement(doc, "kml");
+    Element docTag = getChildElement(kmlTag, "Document");
+    assertEquals(TRACK_NAME, getChildTextValue(docTag, "name"));
+    assertEquals(TRACK_DESCRIPTION, getChildTextValue(docTag, "description"));
+
+    // There are 5 placemarks - start, segments, end, waypoint 1, waypoint 2
+    List<Element> placemarkTags = getChildElements(docTag, "Placemark", 5);
+    assertTagIsPlacemark(placemarkTags.get(0),
+        "(Start)", TRACK_DESCRIPTION, location1);
+    assertTagIsPlacemark(placemarkTags.get(2),
+        "(End)", FULL_TRACK_DESCRIPTION, location4);
+    assertTagIsPlacemark(placemarkTags.get(3),
+        WAYPOINT1_NAME, WAYPOINT1_DESCRIPTION, location2);
+    assertTagIsPlacemark(placemarkTags.get(4),
+        WAYPOINT2_NAME, WAYPOINT2_DESCRIPTION, location3);
+
+    Element trackPlacemarkTag = placemarkTags.get(1);
+    assertEquals(TRACK_NAME, getChildTextValue(trackPlacemarkTag, "name"));
+    assertEquals(TRACK_DESCRIPTION,
+        getChildTextValue(trackPlacemarkTag, "description"));
+    Element geometryTag = getChildElement(trackPlacemarkTag, "MultiGeometry");
+    List<Element> segmentTags = getChildElements(geometryTag, "LineString", 2);
+    assertTagHasPoints(segmentTags.get(0), location1, location2);
+    assertTagHasPoints(segmentTags.get(1), location3, location4);
+  }
+
+  /**
+   * Asserts that the given XML tag is a placemark with the given properties.
+   *
+   * @param tag the tag to analyze
+   * @param name the expected name for the placemark
+   * @param description the expected description for the placemark
+   * @param location the expected location of the placemark
+   */
+  private void assertTagIsPlacemark(Element tag, String name,
+      String description, Location location) {
+    assertEquals(name, getChildTextValue(tag, "name"));
+    assertEquals(description, getChildTextValue(tag, "description"));
+    Element pointTag = getChildElement(tag, "Point");
+    String expectedCoords =
+        location.getLongitude() + "," + location.getLatitude();
+    String actualCoords = getChildTextValue(pointTag, "coordinates");
+    assertEquals(expectedCoords, actualCoords);
+  }
+
+  /**
+   * Asserts that the given tag has a "coordinates" subtag with the given
+   * locations.
+   *
+   * @param tag the tag to analyze
+   * @param locs the locations to expect in the coordinates
+   */
+  private void assertTagHasPoints(Element tag, Location... locs) {
+    StringBuilder expectedBuilder = new StringBuilder();
+    for (Location loc : locs) {
+      expectedBuilder.append(loc.getLongitude());
+      expectedBuilder.append(',');
+      expectedBuilder.append(loc.getLatitude());
+      expectedBuilder.append(',');
+      expectedBuilder.append(loc.getAltitude());
+      expectedBuilder.append(' ');
+    }
+    String expectedCoordinates = expectedBuilder.toString().trim();
+    String actualCoordinates = getChildTextValue(tag, "coordinates").trim();
+    assertEquals(expectedCoordinates, actualCoordinates);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/TcxTrackWriterTest.java

@@ -0,0 +1,78 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+package com.google.android.apps.mytracks.io;
+
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.Sensor;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import java.util.Date;
+import java.util.List;
+
+/**
+ * Tests for the GPX track exporter.
+ *
+ * @author Sandor Dornbush
+ */
+public class TcxTrackWriterTest extends TrackFormatWriterTest {
+
+  public void testXmlOutput() throws Exception {
+    TrackFormatWriter writer = new TcxTrackWriter();
+    String result = writeTrack(writer);
+    Document doc = parseXmlDocument(result);
+
+    Element root = getChildElement(doc, "TrainingCenterDatabase");
+    Element activitiesTag = getChildElement(root, "Activities");
+    Element activityTag = getChildElement(activitiesTag, "Activity");
+    Element lapTag = getChildElement(activityTag, "Lap");
+
+    List<Element> segmentTags = getChildElements(lapTag, "Track", 2);
+    Element segment1Tag = segmentTags.get(0);
+    Element segment2Tag = segmentTags.get(1);
+    List<Element> seg1PointTags = getChildElements(segment1Tag, "Trackpoint", 2);
+    List<Element> seg2PointTags = getChildElements(segment2Tag, "Trackpoint", 2);
+    assertTagsMatchPoints(seg1PointTags, location1, location2);
+    assertTagsMatchPoints(seg2PointTags, location3, location4);
+  }
+
+  /**
+   * Asserts that the given tags describe the given points, in the same order.
+   */
+  private void assertTagsMatchPoints(List<Element> tags, MyTracksLocation... locs) {
+    assertEquals(locs.length, tags.size());
+    for (int i = 0; i < locs.length; i++) {
+      Element tag = tags.get(i);
+      MyTracksLocation loc = locs[i];
+
+      assertTagMatchesLocation(tag, loc);
+    }
+  }
+
+  /**
+   * Asserts that the given tag describes the given location.
+   */
+  private void assertTagMatchesLocation(Element tag, MyTracksLocation loc) {
+    Element posTag = getChildElement(tag, "Position");
+    assertEquals(Double.toString(loc.getLatitude()),
+        getChildTextValue(posTag, "LatitudeDegrees"));
+    assertEquals(Double.toString(loc.getLongitude()),
+        getChildTextValue(posTag, "LongitudeDegrees"));
+    assertEquals(
+        TcxTrackWriter.TIMESTAMP_FORMAT.format(new Date(loc.getTime())),
+        getChildTextValue(tag, "Time"));
+    assertEquals(Double.toString(loc.getAltitude()),
+        getChildTextValue(tag, "AltitudeMeters"));
+    assertTrue(loc.getSensorDataSet() != null);
+    Sensor.SensorDataSet sds = loc.getSensorDataSet();
+
+    List<Element> bpm = getChildElements(tag, "HeartRateBpm", 1);
+    assertEquals(Integer.toString(sds.getHeartRate().getValue()),
+        getChildTextValue(bpm.get(0), "Value"));
+
+    List<Element> ext = getChildElements(tag, "Extensions", 1);
+    List<Element> tpx = getChildElements(ext.get(0), "TPX", 1);
+    assertEquals(Integer.toString(sds.getPower().getValue()),
+        getChildTextValue(tpx.get(0), "Watts"));
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/TempFileCleanerTest.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2010 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;
+
+import static com.google.android.testing.mocking.AndroidMock.expect;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.test.AndroidTestCase;
+
+import java.io.File;
+
+/**
+ * @author Sandor Dornbush
+ */
+public class TempFileCleanerTest extends AndroidTestCase {
+  
+  @UsesMocks({
+    File.class,
+  })
+
+  public void test_noDir() {
+    File dir = AndroidMock.createMock(File.class, "/no_file");
+    TempFileCleaner cleaner = new TempFileCleaner(0);
+    expect(dir.exists()).andStubReturn(false);
+    AndroidMock.replay(dir);
+    assertEquals(0, cleaner.cleanTmpDirectory(dir));
+    AndroidMock.verify(dir);
+  }
+
+  public void test_emptyDir() {
+    File dir = AndroidMock.createMock(File.class, "/no_file");
+    TempFileCleaner cleaner = new TempFileCleaner(0);
+    expect(dir.exists()).andStubReturn(true);
+    expect(dir.listFiles()).andStubReturn(new File[0]);
+    AndroidMock.replay(dir);
+    assertEquals(0, cleaner.cleanTmpDirectory(dir));
+    AndroidMock.verify(dir);
+  }
+
+  public void test_newFile() {
+    File dir = AndroidMock.createMock(File.class, "/no_file");
+    long now = 100000000;
+    TempFileCleaner cleaner = new TempFileCleaner(now);
+    expect(dir.exists()).andStubReturn(true);
+    File file = AndroidMock.createMock(File.class, "/no_file/foo");
+    expect(file.lastModified()).andStubReturn(now);
+    File[] list = { file };
+    expect(dir.listFiles()).andStubReturn(list);
+    
+    AndroidMock.replay(dir, file);
+    assertEquals(0, cleaner.cleanTmpDirectory(dir));
+    AndroidMock.verify(dir, file);
+  }
+
+  public void test_oldFile() {
+    File dir = AndroidMock.createMock(File.class, "/no_file");
+    long now = 100000000;
+    TempFileCleaner cleaner = new TempFileCleaner(now);
+    expect(dir.exists()).andStubReturn(true);
+    File file = AndroidMock.createMock(File.class, "/no_file/foo");
+    expect(file.lastModified()).andStubReturn(now - 3600001);
+    expect(file.delete()).andStubReturn(true);
+    File[] list = { file };
+    expect(dir.listFiles()).andStubReturn(list);
+    
+    AndroidMock.replay(dir, file);
+    assertEquals(1, cleaner.cleanTmpDirectory(dir));
+    AndroidMock.verify(dir, file);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/TrackFormatWriterTest.java

@@ -0,0 +1,208 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+package com.google.android.apps.mytracks.io;
+
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.Sensor;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+
+import android.test.AndroidTestCase;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.Text;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.FactoryConfigurationError;
+import javax.xml.parsers.ParserConfigurationException;
+
+/**
+ * Base class for track format writer tests, which sets up a fake track and
+ * gives auxiliary methods for verifying XML output.
+ *
+ * @author Rodrigo Damazio
+ */
+public abstract class TrackFormatWriterTest extends AndroidTestCase {
+
+  // All the user-provided strings have "]]>" to ensure that proper escaping is
+  // being done.
+  protected static final String TRACK_NAME = "Home]]>";
+  protected static final String TRACK_DESCRIPTION = "The long ]]> journey home";
+  protected static final String WAYPOINT1_NAME = "point]]>1";
+  protected static final String WAYPOINT1_DESCRIPTION = "point 1]]>description";
+  protected static final String WAYPOINT2_NAME = "point]]>2";
+  protected static final String WAYPOINT2_DESCRIPTION = "point 2]]>description";
+  private static final int BUFFER_SIZE = 10240;
+  protected static final long TRACK_ID = 12345L;
+  protected Track track;
+  protected MyTracksLocation location1, location2, location3, location4;
+  protected Waypoint wp1, wp2;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    track = new Track();
+    track.setId(TRACK_ID);
+    track.setName(TRACK_NAME);
+    track.setDescription(TRACK_DESCRIPTION);
+
+    location1 = new MyTracksLocation("mock");
+    location2 = new MyTracksLocation("mock");
+    location3 = new MyTracksLocation("mock");
+    location4 = new MyTracksLocation("mock");
+    populateLocations(location1, location2, location3, location4);
+
+    wp1 = new Waypoint();
+    wp2 = new Waypoint();
+    wp1.setLocation(location2);
+    wp1.setName(WAYPOINT1_NAME);
+    wp1.setDescription(WAYPOINT1_DESCRIPTION);
+    wp2.setLocation(location3);
+    wp2.setName(WAYPOINT2_NAME);
+    wp2.setDescription(WAYPOINT2_DESCRIPTION);
+  }
+
+  /**
+   * Populates the given locations with coordinates and time.
+   */
+  protected void populateLocations(MyTracksLocation... locs) {
+    for (int i = 0; i < locs.length; i++) {
+      MyTracksLocation loc = locs[i];
+      loc.setAltitude(i * 5000000);
+      loc.setLatitude(i);
+      loc.setLongitude(-i);
+      loc.setTime(10000000 + i * 1000);
+      Sensor.SensorData.Builder hr = Sensor.SensorData.newBuilder()
+        .setValue(100 + i)
+        .setState(Sensor.SensorState.SENDING);
+      Sensor.SensorData.Builder power = Sensor.SensorData.newBuilder()
+        .setValue(400 + i)
+        .setState(Sensor.SensorState.SENDING);
+      Sensor.SensorDataSet sds =
+        Sensor.SensorDataSet.newBuilder().setHeartRate(hr.build())
+        .setPower(power)
+        .build();
+      loc.setSensorData(sds);
+    }
+  }
+
+  /**
+   * Makes the right sequence of calls to the writer in order to write the fake
+   * track in {@link #track}.
+   *
+   * @param writer the writer to write to
+   * @return the written contents 
+   */
+  protected String writeTrack(TrackFormatWriter writer) {
+    OutputStream output = new ByteArrayOutputStream(BUFFER_SIZE);
+    writer.prepare(track, output);
+    writer.writeHeader();
+    writer.writeBeginTrack(location1);
+    writer.writeOpenSegment();
+    writer.writeLocation(location1);
+    writer.writeLocation(location2);
+    writer.writeCloseSegment();
+    writer.writeOpenSegment();
+    writer.writeLocation(location3);
+    writer.writeLocation(location4);
+    writer.writeCloseSegment();
+    writer.writeEndTrack(location4);
+    writer.writeWaypoint(wp1);
+    writer.writeWaypoint(wp2);
+    writer.writeFooter();
+    writer.close();
+    return output.toString();
+  }
+
+  /**
+   * Gets the text data contained inside a tag.
+   *
+   * @param parent the parent of the tag containing the text
+   * @param elementName the name of the tag containing the text
+   * @return the text contents
+   */
+  protected String getChildTextValue(Element parent, String elementName) {
+    Element child = getChildElement(parent, elementName);
+    assertTrue(child.hasChildNodes());
+    NodeList children = child.getChildNodes();
+    int length = children.getLength();
+    assertTrue(length > 0);
+
+    // The children may be a sucession of text elements, just concatenate them
+    String result = "";
+    for (int i = 0; i < length; i++) {
+      Text textNode = (Text) children.item(i);
+      result += textNode.getNodeValue();
+    }
+    return result;
+  }
+
+  /**
+   * Returns all child elements of a given parent which have the given name.
+   *
+   * @param parent the parent to get children from
+   * @param elementName the element name to look for
+   * @param expectedChildren the number of children we're expected to find
+   * @return a list of the found elements
+   */
+  protected List<Element> getChildElements(Node parent, String elementName,
+      int expectedChildren) {
+    assertTrue(parent.hasChildNodes());
+    NodeList children = parent.getChildNodes();
+    int length = children.getLength();
+    List<Element> result = new ArrayList<Element>();
+    for (int i = 0; i < length; i++) {
+      Node childNode = children.item(i);
+      if (childNode.getNodeType() == Node.ELEMENT_NODE
+          && childNode.getNodeName().equalsIgnoreCase(elementName)) {
+        result.add((Element) childNode);
+      }
+    }
+    assertTrue(children.toString(), result.size() == expectedChildren);
+    return result;
+  }
+
+  /**
+   * Returns the single child element of the given parent with the given type.
+   *
+   * @param parent the parent to get a child from
+   * @param elementName the name of the child to look for
+   * @return the child element
+   */
+  protected Element getChildElement(Node parent, String elementName) {
+    return getChildElements(parent, elementName, 1).get(0);
+  }
+
+  /**
+   * Parses the given XML contents and returns a DOM {@link Document} for it.
+   */
+  protected Document parseXmlDocument(String contents)
+      throws FactoryConfigurationError, ParserConfigurationException,
+          SAXException, IOException {
+    DocumentBuilderFactory builderFactory =
+        DocumentBuilderFactory.newInstance();
+    builderFactory.setCoalescing(true);
+    // TODO: Somehow do XML validation on Android
+    // builderFactory.setValidating(true);
+    builderFactory.setNamespaceAware(true);
+    builderFactory.setIgnoringComments(true);
+    builderFactory.setIgnoringElementContentWhitespace(true);
+    DocumentBuilder documentBuilder = builderFactory.newDocumentBuilder();
+    Document doc = documentBuilder.parse(
+        new InputSource(new StringReader(contents)));
+    return doc;
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/TrackWriterTest.java

@@ -0,0 +1,366 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+
+package com.google.android.apps.mytracks.io;
+
+import static org.easymock.EasyMock.expect;
+
+import com.google.android.apps.mytracks.content.MyTracksProvider;
+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.content.MyTracksProviderUtils.Factory;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceTest.MockContext;
+import com.google.android.apps.mytracks.testing.TestingProviderUtilsFactory;
+
+import android.content.Context;
+import android.location.Location;
+import android.test.AndroidTestCase;
+import android.test.RenamingDelegatingContext;
+import android.test.mock.MockContentResolver;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.OutputStream;
+
+import org.easymock.EasyMock;
+import org.easymock.IArgumentMatcher;
+import org.easymock.IMocksControl;
+
+/**
+ * Tests for the track writer.
+ *
+ * @author Rodrigo Damazio
+ */
+public class TrackWriterTest extends AndroidTestCase {
+  /**
+   * {@link TrackWriter} subclass which mocks out methods called from
+   * {@link TrackWriter#openFile}.
+   */
+  private static final class OpenFileTrackWriter extends TrackWriter {
+    private final ByteArrayOutputStream stream;
+    private final boolean canWrite;
+
+    /**
+     * Constructor.
+     *
+     * @param stream the stream to return from
+     *        {@link TrackWriter#newOutputStream}, or null to throw a
+     *        {@link FileNotFoundException}
+     * @param canWrite the value that {@link TrackWriter#canWriteFile} will
+     *        return
+     */
+    private OpenFileTrackWriter(Context context,
+        MyTracksProviderUtils providerUtils, Track track,
+        TrackFormatWriter writer, ByteArrayOutputStream stream,
+        boolean canWrite) {
+      super(context, providerUtils, track, writer);
+
+      this.stream = stream;
+      this.canWrite = canWrite;
+    }
+
+    @Override
+    protected boolean canWriteFile() {
+      return canWrite;
+    }
+
+    @Override
+    protected OutputStream newOutputStream(String fileName)
+        throws FileNotFoundException {
+      assertEquals(FULL_TRACK_NAME, fileName);
+
+      if (stream == null) {
+        throw new FileNotFoundException();
+      }
+
+      return stream;
+    }
+  }
+
+  /**
+   * {@link TrackWriter} subclass which mocks out methods called from
+   * {@link TrackWriter#writeTrack}.
+   */
+  private final class WriteTracksTrackWriter extends TrackWriter {
+    private final boolean openResult;
+
+    /**
+     * Constructor.
+     *
+     * @param openResult the return value for {@link TrackWriter#openFile}
+     */
+    private WriteTracksTrackWriter(Context context,
+        MyTracksProviderUtils providerUtils, Track track,
+        TrackFormatWriter writer, boolean openResult) {
+      super(context, providerUtils, track, writer);
+      this.openResult = openResult;
+    }
+
+    @Override
+    protected boolean openFile() {
+      openFileCalls++;
+      return openResult;
+    }
+
+    @Override
+    void writeDocument() {
+      writeDocumentCalls++;
+    }
+
+    @Override
+    protected void runOnUiThread(Runnable runnable) {
+      runnable.run();
+    }
+  }
+
+  private static final long TRACK_ID = 1234567L;
+  private static final String EXTENSION = "ext";
+  private static final String TRACK_NAME = "Swimming across the pacific";
+  private static final String FULL_TRACK_NAME =
+      "Swimming across the pacific.ext";
+
+  private Track track;
+  private TrackFormatWriter formatWriter;
+  private TrackWriter writer;
+  private IMocksControl mocksControl;
+  private MyTracksProviderUtils providerUtils;
+  private Factory oldProviderUtilsFactory;
+
+  // State used in specific tests
+  private int writeDocumentCalls;
+  private int openFileCalls;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    MockContentResolver mockContentResolver = new MockContentResolver();
+    RenamingDelegatingContext targetContext = new RenamingDelegatingContext(
+        getContext(), getContext(), "test.");
+    Context context = new MockContext(mockContentResolver, targetContext);
+    MyTracksProvider provider = new MyTracksProvider();
+    provider.attachInfo(context, null);
+    mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, provider);
+    setContext(context);
+    providerUtils = MyTracksProviderUtils.Factory.get(context);
+    oldProviderUtilsFactory = TestingProviderUtilsFactory.installWithInstance(providerUtils);
+    
+    mocksControl = EasyMock.createStrictControl();
+    formatWriter = mocksControl.createMock(TrackFormatWriter.class);
+    expect(formatWriter.getExtension()).andStubReturn(EXTENSION);
+
+    track = new Track();
+    track.setName(TRACK_NAME);
+    track.setId(TRACK_ID);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    TestingProviderUtilsFactory.restoreOldFactory(oldProviderUtilsFactory);
+    super.tearDown();
+  }
+
+  public void testWriteTrack() {
+    writer = new WriteTracksTrackWriter(getContext(), providerUtils, track,
+        formatWriter, true);
+
+    // Expect the completion callback to be run
+    Runnable completionCallback = mocksControl.createMock(Runnable.class);
+    completionCallback.run();
+
+    mocksControl.replay();
+    writer.setOnCompletion(completionCallback);
+    writer.writeTrack();
+
+    assertEquals(1, writeDocumentCalls);
+    assertEquals(1, openFileCalls);
+    mocksControl.verify();
+  }
+
+  public void testWriteTrack_openFails() {
+    writer = new WriteTracksTrackWriter(getContext(), providerUtils, track,
+        formatWriter, false);
+
+    // Expect the completion callback to be run
+    Runnable completionCallback = mocksControl.createMock(Runnable.class);
+    completionCallback.run();
+
+    mocksControl.replay();
+    writer.setOnCompletion(completionCallback);
+    writer.writeTrack();
+
+    assertEquals(0, writeDocumentCalls);
+    assertEquals(1, openFileCalls);
+    mocksControl.verify();
+  }
+  
+  public void testOpenFile() {
+    final ByteArrayOutputStream stream = new ByteArrayOutputStream();
+    writer = new OpenFileTrackWriter(
+        getContext(), providerUtils, track, formatWriter, stream, true);
+
+    formatWriter.prepare(track, stream);
+
+    mocksControl.replay();
+    assertTrue(writer.openFile());
+    mocksControl.verify();
+  }
+
+  public void testOpenFile_cantWrite() {
+    final ByteArrayOutputStream stream = new ByteArrayOutputStream();
+    writer = new OpenFileTrackWriter(
+        getContext(), providerUtils, track, formatWriter, stream, false);
+
+    mocksControl.replay();
+    assertFalse(writer.openFile());
+    mocksControl.verify();
+  }
+
+  public void testOpenFile_streamError() {
+    writer = new OpenFileTrackWriter(
+        getContext(), providerUtils, track, formatWriter, null, true);
+
+    mocksControl.replay();
+    assertFalse(writer.openFile());
+    mocksControl.verify();
+  }
+
+  public void testWriteDocument_emptyTrack() {
+    writer = new TrackWriter(getContext(), providerUtils, track, formatWriter);
+
+    // Set expected mock behavior
+    formatWriter.writeHeader();
+    formatWriter.writeFooter();
+    formatWriter.close();
+
+    mocksControl.replay();
+    writer.writeDocument();
+
+    assertTrue(writer.wasSuccess());
+    mocksControl.verify();
+  }
+
+  public void testWriteDocument() {
+    writer = new TrackWriter(getContext(), providerUtils, track, formatWriter);
+
+    final Location[] locs = {
+        new Location("fake0"),
+        new Location("fake1"),
+        new Location("fake2"),
+        new Location("fake3"),
+        new Location("fake4"),
+        new Location("fake5")
+    };
+    Waypoint[] wps = { new Waypoint(), new Waypoint(), new Waypoint() };
+
+    // Fill locations with valid values
+    fillLocations(locs);
+
+    // Make location 3 invalid
+    locs[2].setLatitude(100);
+    
+    assertEquals(locs.length, providerUtils.bulkInsertTrackPoints(locs, locs.length, TRACK_ID));
+    for (int i = 0;  i < wps.length; ++i) {
+      Waypoint wpt = wps[i];
+      wpt.setTrackId(TRACK_ID);
+      assertNotNull(providerUtils.insertWaypoint(wpt));
+      wpt.setId(i + 1);
+    }
+
+    formatWriter.writeHeader();
+
+    // Expect reading/writing of the waypoints (except the first)
+    formatWriter.writeWaypoint(wptEq(wps[1]));
+    formatWriter.writeWaypoint(wptEq(wps[2]));
+
+    // Begin the track
+    formatWriter.writeBeginTrack(locEq(locs[0]));
+
+    // Write locations 1-2
+    formatWriter.writeOpenSegment();
+    formatWriter.writeLocation(locEq(locs[0]));
+    formatWriter.writeLocation(locEq(locs[1]));
+    formatWriter.writeCloseSegment();
+
+    // Location 3 is not written - it's invalid
+
+    // Write locations 4-6
+    formatWriter.writeOpenSegment();
+    formatWriter.writeLocation(locEq(locs[3]));
+    formatWriter.writeLocation(locEq(locs[4]));
+    formatWriter.writeLocation(locEq(locs[5]));
+    formatWriter.writeCloseSegment();
+
+    // End the track
+    formatWriter.writeEndTrack(locEq(locs[5]));
+
+    formatWriter.writeFooter();
+    formatWriter.close();
+
+    mocksControl.replay();
+    writer.writeDocument();
+
+    assertTrue(writer.wasSuccess());
+    mocksControl.verify();
+  }
+
+  private static Waypoint wptEq(final Waypoint wpt) {
+    EasyMock.reportMatcher(new IArgumentMatcher() {
+      @Override
+      public boolean matches(Object wptObj2) {
+        if (wptObj2 == null || wpt == null) return wpt == wptObj2;
+        Waypoint wpt2 = (Waypoint) wptObj2;
+
+        return wpt.getId() == wpt2.getId();
+      }
+      
+      @Override
+      public void appendTo(StringBuffer buffer) {
+        buffer.append("wptEq(");
+        buffer.append(wpt);
+        buffer.append(")");
+      }
+    });
+    return null;
+  }
+  
+  private static Location locEq(final Location loc) {
+    EasyMock.reportMatcher(new IArgumentMatcher() {
+      @Override
+      public boolean matches(Object locObj2) {
+        if (locObj2 == null || loc == null) return loc == locObj2;
+        Location loc2 = (Location) locObj2;
+
+        return loc.hasAccuracy() == loc2.hasAccuracy()
+            && (!loc.hasAccuracy() || loc.getAccuracy() == loc2.getAccuracy())
+            && loc.hasAltitude() == loc2.hasAltitude()
+            && (!loc.hasAltitude() || loc.getAltitude() == loc2.getAltitude())
+            && loc.hasBearing() == loc2.hasBearing()
+            && (!loc.hasBearing() || loc.getBearing() == loc2.getBearing())
+            && loc.hasSpeed() == loc2.hasSpeed()
+            && (!loc.hasSpeed() || loc.getSpeed() == loc2.getSpeed())
+            && loc.getLatitude() == loc2.getLatitude()
+            && loc.getLongitude() == loc2.getLongitude()
+            && loc.getTime() == loc2.getTime();
+      }
+      
+      @Override
+      public void appendTo(StringBuffer buffer) {
+        buffer.append("locEq(");
+        buffer.append(loc);
+        buffer.append(")");
+      }
+    });
+    return null;
+  }
+   
+  private void fillLocations(Location... locs) {
+    assertTrue(locs.length < 90);
+    for (int i = 0; i < locs.length; i++) {
+      Location location = locs[i];
+      location.setLatitude(i + 1);
+      location.setLongitude(i + 1);
+      location.setTime(i + 1000);
+    }
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/backup/DatabaseDumperTest.java

@@ -0,0 +1,270 @@
+/*
+ * Copyright 2010 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.backup;
+
+import com.google.android.apps.mytracks.content.ContentTypeIds;
+
+import android.database.MatrixCursor;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for {@link DatabaseDumper}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class DatabaseDumperTest extends TestCase {
+  /**
+   * This class is the same as {@link MatrixCursor}, except this class 
+   * implements {@link #getBlob} ({@link MatrixCursor} leaves it 
+   * unimplemented).
+   */
+  private class BlobAwareMatrixCursor extends MatrixCursor {
+    public BlobAwareMatrixCursor(String[] columnNames) {
+      super(columnNames);
+    }
+    
+    @Override public byte[] getBlob(int columnIndex) {
+      return getString(columnIndex).getBytes();
+    }
+  }
+  
+  private static final String[] COLUMN_NAMES = {
+    "intCol", "longCol", "floatCol", "doubleCol", "stringCol", "boolCol", "blobCol"
+  };
+  private static final byte[] COLUMN_TYPES = {
+    ContentTypeIds.INT_TYPE_ID, ContentTypeIds.LONG_TYPE_ID,
+    ContentTypeIds.FLOAT_TYPE_ID, ContentTypeIds.DOUBLE_TYPE_ID,
+    ContentTypeIds.STRING_TYPE_ID, ContentTypeIds.BOOLEAN_TYPE_ID,
+    ContentTypeIds.BLOB_TYPE_ID
+  };
+  private static final String[][] FAKE_DATA = {
+      { "42", "123456789", "3.1415", "2.72", "lolcat",  "1", "blob" },
+      { null, "123456789", "3.1415", "2.72", "lolcat",  "1", "blob" },
+      { "42",        null, "3.1415", "2.72", "lolcat",  "1", "blob" },
+      { "42", "123456789",     null, "2.72", "lolcat",  "1", "blob" },
+      { "42", "123456789", "3.1415",   null, "lolcat",  "1", "blob" },
+      { "42", "123456789", "3.1415", "2.72",     null,  "1", "blob" },
+      { "42", "123456789", "3.1415", "2.72", "lolcat", null, "blob" },
+      { "42", "123456789", "3.1415", "2.72", "lolcat",  "1", null   },
+  };
+  private static final long[] EXPECTED_FIELD_SETS = {
+      0x7F, 0x7E, 0x7D, 0x7B, 0x77, 0x6F, 0x5F, 0x3F
+  };
+
+  private BlobAwareMatrixCursor cursor;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    // Add fake data to the cursor
+    cursor = new BlobAwareMatrixCursor(COLUMN_NAMES);
+    for (String[] row : FAKE_DATA) {
+      cursor.addRow(row);
+    }
+  }
+
+  public void testWriteAllRows_noNulls() throws Exception {
+    testWriteAllRows(false);
+  }
+
+  public void testWriteAllRows_withNulls() throws Exception {
+    testWriteAllRows(true);
+  }
+
+  private void testWriteAllRows(boolean hasNullFields) throws Exception {
+    // Dump it
+    DatabaseDumper dumper = new DatabaseDumper(COLUMN_NAMES, COLUMN_TYPES, hasNullFields);
+    ByteArrayOutputStream outStream = new ByteArrayOutputStream(1024);
+    DataOutputStream writer = new DataOutputStream(outStream );
+    dumper.writeAllRows(cursor, writer);
+
+    // Read the results
+    byte[] result = outStream.toByteArray();
+    ByteArrayInputStream inputStream = new ByteArrayInputStream(result);
+    DataInputStream reader = new DataInputStream(inputStream);
+
+    // Verify the header
+    assertHeader(reader);
+
+    // Verify the number of rows
+    assertEquals(FAKE_DATA.length, reader.readInt());
+
+    // Verify the row contents
+    byte[] blob = new byte[4];
+
+    // Row 0 -- everything populated
+    assertEquals(EXPECTED_FIELD_SETS[0], reader.readLong());
+    assertEquals(42, reader.readInt());
+    assertEquals(123456789L, reader.readLong());
+    assertEquals(3.1415f, reader.readFloat());
+    assertEquals(2.72, reader.readDouble());
+    assertEquals("lolcat", reader.readUTF());
+    assertTrue(reader.readBoolean());
+    assertEquals(4, reader.readInt());
+    assertEquals("blob", readBlob(reader, 4));
+
+    // Row 1 -- no int
+    assertEquals(EXPECTED_FIELD_SETS[1], reader.readLong());
+    if (hasNullFields) reader.readInt();
+    assertEquals(123456789L, reader.readLong());
+    assertEquals(3.1415f, reader.readFloat());
+    assertEquals(2.72, reader.readDouble());
+    assertEquals("lolcat", reader.readUTF());
+    assertTrue(reader.readBoolean());
+    assertEquals(4, reader.readInt());
+    assertEquals("blob", readBlob(reader, 4));
+
+    // Row 2 -- no long
+    assertEquals(EXPECTED_FIELD_SETS[2], reader.readLong());
+    assertEquals(42, reader.readInt());
+    if (hasNullFields) reader.readLong();
+    assertEquals(3.1415f, reader.readFloat());
+    assertEquals(2.72, reader.readDouble());
+    assertEquals("lolcat", reader.readUTF());
+    assertTrue(reader.readBoolean());
+    assertEquals(4, reader.readInt());
+    assertEquals("blob", readBlob(reader, 4));
+
+    // Row 3 -- no float
+    assertEquals(EXPECTED_FIELD_SETS[3], reader.readLong());
+    assertEquals(42, reader.readInt());
+    assertEquals(123456789L, reader.readLong());
+    if (hasNullFields) reader.readFloat();
+    assertEquals(2.72, reader.readDouble());
+    assertEquals("lolcat", reader.readUTF());
+    assertTrue(reader.readBoolean());
+    assertEquals(4, reader.readInt());
+    assertEquals("blob", readBlob(reader, 4));
+
+    // Row 4 -- no double
+    assertEquals(EXPECTED_FIELD_SETS[4], reader.readLong());
+    assertEquals(42, reader.readInt());
+    assertEquals(123456789L, reader.readLong());
+    assertEquals(3.1415f, reader.readFloat());
+    if (hasNullFields) reader.readDouble();
+    assertEquals("lolcat", reader.readUTF());
+    assertTrue(reader.readBoolean());
+    assertEquals(4, reader.readInt());
+    assertEquals("blob", readBlob(reader, 4));
+
+    // Row 5 -- no string
+    assertEquals(EXPECTED_FIELD_SETS[5], reader.readLong());
+    assertEquals(42, reader.readInt());
+    assertEquals(123456789L, reader.readLong());
+    assertEquals(3.1415f, reader.readFloat());
+    assertEquals(2.72, reader.readDouble());
+    if (hasNullFields) reader.readUTF();
+    assertTrue(reader.readBoolean());
+    assertEquals(4, reader.readInt());
+    assertEquals("blob", readBlob(reader, 4));
+
+    // Row 6 -- no boolean
+    assertEquals(EXPECTED_FIELD_SETS[6], reader.readLong());
+    assertEquals(42, reader.readInt());
+    assertEquals(123456789L, reader.readLong());
+    assertEquals(3.1415f, reader.readFloat());
+    assertEquals(2.72, reader.readDouble());
+    assertEquals("lolcat", reader.readUTF());
+    if (hasNullFields) reader.readBoolean();
+    assertEquals(4, reader.readInt());
+    assertEquals("blob", readBlob(reader, 4));
+
+    // Row 7 -- no blob
+    assertEquals(EXPECTED_FIELD_SETS[7], reader.readLong());
+    assertEquals(42, reader.readInt());
+    assertEquals(123456789L, reader.readLong());
+    assertEquals(3.1415f, reader.readFloat());
+    assertEquals(2.72, reader.readDouble());
+    assertEquals("lolcat", reader.readUTF());
+    assertTrue(reader.readBoolean());
+    if (hasNullFields) {
+      int length = reader.readInt();
+      readBlob(reader, length);
+    }
+  }
+  
+  public void testFewerRows() throws Exception {
+    // Dump only the first two rows
+    DatabaseDumper dumper = new DatabaseDumper(COLUMN_NAMES, COLUMN_TYPES, false);
+    ByteArrayOutputStream outStream = new ByteArrayOutputStream(1024);
+    DataOutputStream writer = new DataOutputStream(outStream);
+
+    dumper.writeHeaders(cursor, 2, writer);
+    cursor.moveToFirst();
+    dumper.writeOneRow(cursor, writer);
+    cursor.moveToNext();
+    dumper.writeOneRow(cursor, writer);
+
+    // Read the results
+    byte[] result = outStream.toByteArray();
+    ByteArrayInputStream inputStream = new ByteArrayInputStream(result);
+    DataInputStream reader = new DataInputStream(inputStream);
+
+    // Verify the header
+    assertHeader(reader);
+
+    // Verify the number of rows
+    assertEquals(2, reader.readInt());
+
+    // Row 0
+    assertEquals(EXPECTED_FIELD_SETS[0], reader.readLong());
+    assertEquals(42, reader.readInt());
+    assertEquals(123456789L, reader.readLong());
+    assertEquals(3.1415f, reader.readFloat());
+    assertEquals(2.72, reader.readDouble());
+    assertEquals("lolcat", reader.readUTF());
+    assertTrue(reader.readBoolean());
+    assertEquals(4, reader.readInt());
+    assertEquals("blob", readBlob(reader, 4));
+
+    // Row 1
+    assertEquals(EXPECTED_FIELD_SETS[1], reader.readLong());
+    // Null field not read
+    assertEquals(123456789L, reader.readLong());
+    assertEquals(3.1415f, reader.readFloat());
+    assertEquals(2.72, reader.readDouble());
+    assertEquals("lolcat", reader.readUTF());
+    assertTrue(reader.readBoolean());
+    assertEquals(4, reader.readInt());
+    assertEquals("blob", readBlob(reader, 4));
+  }
+
+  private void assertHeader(DataInputStream reader) throws IOException {
+    assertEquals(COLUMN_NAMES.length, reader.readInt());
+    for (int i = 0; i < COLUMN_NAMES.length; i++) {
+      assertEquals(COLUMN_NAMES[i], reader.readUTF());
+      assertEquals(COLUMN_TYPES[i], reader.readByte());
+    }
+  }
+
+  private String readBlob(InputStream reader, int length) throws Exception {
+    if (length == 0) {
+      return "";
+    }
+
+    byte[] blob = new byte[length];
+    assertEquals(length, reader.read(blob));
+    return new String(blob);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/backup/DatabaseImporterTest.java

@@ -0,0 +1,293 @@
+/*
+ * Copyright 2010 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.backup;
+
+import com.google.android.apps.mytracks.content.ContentTypeIds;
+
+import android.content.ContentValues;
+import android.net.Uri;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for {@link DatabaseImporter}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class DatabaseImporterTest extends TestCase {
+
+  private static final Uri DESTINATION_URI = Uri.parse("http://www.google.com/");
+  private static final int TEST_BULK_SIZE = 10;
+  private ArrayList<ContentValues> insertedValues;
+
+  private class TestableDatabaseImporter extends DatabaseImporter {
+    public TestableDatabaseImporter(boolean readNullFields) {
+      super(DESTINATION_URI, null, readNullFields, TEST_BULK_SIZE);
+    }
+
+    @Override
+    protected void doBulkInsert(ContentValues[] values) {
+      insertedValues.ensureCapacity(insertedValues.size() + values.length);
+
+      // We need to make a copy of the values since the objects are re-used
+      for (ContentValues contentValues : values) {
+        insertedValues.add(new ContentValues(contentValues));
+      }
+    }
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    insertedValues = new ArrayList<ContentValues>();
+  }
+
+  public void testImportAllRows() throws Exception {
+    testImportAllRows(false);
+  }
+
+  public void testImportAllRows_readNullFields() throws Exception {
+    testImportAllRows(true);
+  }
+  
+  private void testImportAllRows(boolean readNullFields) throws Exception {
+    // Create a fake data stream to be read
+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream(1024);
+    DataOutputStream writer = new DataOutputStream(outputStream);
+
+    writeFullHeader(writer);
+
+    // Add the number of rows
+    writer.writeInt(2);
+
+    // Add a row with all fields present 
+    writer.writeLong(0x7F);
+    writer.writeInt(42);
+    writer.writeBoolean(true);
+    writer.writeUTF("lolcat");
+    writer.writeFloat(3.1415f);
+    writer.writeDouble(2.72);
+    writer.writeLong(123456789L);
+    writer.writeInt(4);
+    writer.writeBytes("blob");
+
+    // Add a row with some missing fields
+    writer.writeLong(0x15);
+    writer.writeInt(42);
+    if (readNullFields) writer.writeBoolean(false);
+    writer.writeUTF("lolcat");
+    if (readNullFields) writer.writeFloat(0.0f);
+    writer.writeDouble(2.72);
+    if (readNullFields) writer.writeLong(0L);
+    if (readNullFields) writer.writeInt(0);  // empty blob
+
+    writer.flush();
+
+    // Do the importing
+    DatabaseImporter importer = new TestableDatabaseImporter(readNullFields);
+    byte[] dataBytes = outputStream.toByteArray();
+    importer.importAllRows(new DataInputStream(new ByteArrayInputStream(dataBytes)));
+
+    assertEquals(2, insertedValues.size());
+
+    // Verify the first row
+    ContentValues value = insertedValues.get(0);
+    assertEquals(value.toString(), 7, value.size());
+
+    assertValue(42, "col1", value);
+    assertValue(true, "col2", value);
+    assertValue("lolcat", "col3", value);
+    assertValue(3.1415f, "col4", value);
+    assertValue(2.72, "col5", value);
+    assertValue(123456789L, "col6", value);
+    assertBlobValue("blob", "col7", value);
+
+    // Verify the second row
+    value = insertedValues.get(1);
+    assertEquals(value.toString(), 3, value.size());
+
+    assertValue(42, "col1", value);
+    assertValue("lolcat", "col3", value);
+    assertValue(2.72, "col5", value);
+  }
+  
+  public void testImportAllRows_noRows() throws Exception {
+    // Create a fake data stream to be read
+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream(1024);
+    DataOutputStream writer = new DataOutputStream(outputStream);
+
+    writeFullHeader(writer);
+
+    // Add the number of rows
+    writer.writeInt(0);
+
+    writer.flush();
+
+    // Do the importing
+    DatabaseImporter importer = new TestableDatabaseImporter(false);
+    byte[] dataBytes = outputStream.toByteArray();
+    importer.importAllRows(new DataInputStream(new ByteArrayInputStream(dataBytes)));
+
+    assertTrue(insertedValues.isEmpty());
+  }
+
+  public void testImportAllRows_emptyRows() throws Exception {
+    testImportAllRowsWithEmptyRows(false);
+  }
+
+  public void testImportAllRows_emptyRowsWithNulls() throws Exception {
+    testImportAllRowsWithEmptyRows(true);
+  }
+
+  private void testImportAllRowsWithEmptyRows(boolean readNullFields) throws Exception {
+    // Create a fake data stream to be read
+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream(1024);
+    DataOutputStream writer = new DataOutputStream(outputStream);
+
+    writeFullHeader(writer);
+
+    // Add the number of rows
+    writer.writeInt(3);
+
+    // Add 2 rows with no fields
+    for (int i = 0; i < 2; i++) {
+      writer.writeLong(0);
+      if (readNullFields) {
+        writer.writeInt(0);
+        writer.writeBoolean(false);
+        writer.writeUTF("");
+        writer.writeFloat(0.0f);
+        writer.writeDouble(0.0);
+        writer.writeLong(0L);
+        writer.writeInt(0);  // empty blob
+      }
+    }
+
+    // Add a row with some missing fields
+    writer.writeLong(0x15);
+    writer.writeInt(42);
+    if (readNullFields) writer.writeBoolean(false);
+    writer.writeUTF("lolcat");
+    if (readNullFields) writer.writeFloat(0.0f);
+    writer.writeDouble(2.72);
+    if (readNullFields) writer.writeLong(0L);
+    if (readNullFields) writer.writeInt(0);  // empty blob
+
+    writer.flush();
+
+    // Do the importing
+    DatabaseImporter importer = new TestableDatabaseImporter(readNullFields);
+    byte[] dataBytes = outputStream.toByteArray();
+    importer.importAllRows(new DataInputStream(new ByteArrayInputStream(dataBytes)));
+
+    assertEquals(insertedValues.toString(), 3, insertedValues.size());
+
+    ContentValues value = insertedValues.get(0);
+    assertEquals(value.toString(), 0, value.size());
+
+    value = insertedValues.get(1);
+    assertEquals(value.toString(), 0, value.size());
+
+    // Verify the third row (only one with values)
+    value = insertedValues.get(2);
+    assertEquals(value.toString(), 3, value.size());
+
+    assertFalse(value.containsKey("col2"));
+    assertFalse(value.containsKey("col4"));
+    assertFalse(value.containsKey("col6"));
+
+    assertValue(42, "col1", value);
+    assertValue("lolcat", "col3", value);
+    assertValue(2.72, "col5", value);
+  }
+
+  public void testImportAllRows_bulks() throws Exception {
+    // Create a fake data stream to be read
+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream(1024);
+    DataOutputStream writer = new DataOutputStream(outputStream);
+
+    // Add the header
+    writer.writeInt(2);
+    writer.writeUTF("col1");
+    writer.writeByte(ContentTypeIds.INT_TYPE_ID);
+    writer.writeUTF("col2");
+    writer.writeByte(ContentTypeIds.STRING_TYPE_ID);
+
+    // Add lots of rows (so the insertions are split in multiple bulks)
+    int numRows = TEST_BULK_SIZE * 5 / 2;
+    writer.writeInt(numRows);
+    for (int i = 0; i < numRows; i++) {
+      writer.writeLong(3);
+      writer.writeInt(i);
+      writer.writeUTF(Integer.toString(i * 2));
+    }
+
+    writer.flush();
+
+    // Do the importing
+    DatabaseImporter importer = new TestableDatabaseImporter(false);
+    byte[] dataBytes = outputStream.toByteArray();
+    importer.importAllRows(new DataInputStream(new ByteArrayInputStream(dataBytes)));
+
+    // Verify the rows
+    assertEquals(numRows, insertedValues.size());
+    for (int i = 0; i < numRows; i++) {
+      ContentValues value = insertedValues.get(i);
+      assertEquals(value.toString(), 2, value.size());
+      assertValue(i, "col1", value);
+      assertValue(Integer.toString(i * 2), "col2", value);
+    }
+  }
+
+  private void writeFullHeader(DataOutputStream writer) throws IOException {
+    // Add the header
+    writer.writeInt(7);
+    writer.writeUTF("col1");
+    writer.writeByte(ContentTypeIds.INT_TYPE_ID);
+    writer.writeUTF("col2");
+    writer.writeByte(ContentTypeIds.BOOLEAN_TYPE_ID);
+    writer.writeUTF("col3");
+    writer.writeByte(ContentTypeIds.STRING_TYPE_ID);
+    writer.writeUTF("col4");
+    writer.writeByte(ContentTypeIds.FLOAT_TYPE_ID);
+    writer.writeUTF("col5");
+    writer.writeByte(ContentTypeIds.DOUBLE_TYPE_ID);
+    writer.writeUTF("col6");
+    writer.writeByte(ContentTypeIds.LONG_TYPE_ID);
+    writer.writeUTF("col7");
+    writer.writeByte(ContentTypeIds.BLOB_TYPE_ID);
+  }
+
+  private <T> void assertValue(T expectedValue, String name, ContentValues values) {
+    @SuppressWarnings("unchecked")
+    T value = (T) values.get(name);
+    assertNotNull(value);
+    assertEquals(expectedValue, value);
+  }
+  
+  private void assertBlobValue(String expectedValue, String name, ContentValues values ){
+    byte[] blob = values.getAsByteArray(name);
+    assertEquals(expectedValue, new String(blob));
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/backup/PreferenceBackupHelperTest.java

@@ -0,0 +1,202 @@
+/*
+ * Copyright 2010 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.backup;
+
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for {@link PreferenceBackupHelper}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class PreferenceBackupHelperTest extends TestCase {
+  private Map<String, ?> preferenceValues;
+  private SharedPreferences preferences;
+  private PreferenceBackupHelper preferenceBackupHelper;
+
+  /**
+   * Mock shared preferences editor which does not persist state.
+   */
+  private class MockPreferenceEditor implements SharedPreferences.Editor {
+    private Map<String, Object> newPreferences = new HashMap<String, Object>(preferenceValues);
+
+    @Override
+    public Editor clear() {
+      newPreferences.clear();
+      return this;
+    }
+
+    @Override
+    public boolean commit() {
+      preferenceValues = newPreferences;
+      return true;
+    }
+
+    @Override
+    public void apply() {
+      commit();
+    }
+
+    @Override
+    public Editor putBoolean(String key, boolean value) {
+      return put(key, value);
+    }
+
+    @Override
+    public Editor putFloat(String key, float value) {
+      return put(key, value);
+    }
+
+    @Override
+    public Editor putInt(String key, int value) {
+      return put(key, value);
+    }
+
+    @Override
+    public Editor putLong(String key, long value) {
+      return put(key, value);
+    }
+
+    @Override
+    public Editor putString(String key, String value) {
+      return put(key, value);
+    }
+
+    private <T> Editor put(String key, T value) {
+      newPreferences.put(key, value);
+      return this;
+    }
+
+    @Override
+    public Editor remove(String key) {
+      newPreferences.remove(key);
+      return this;
+    }
+  }
+
+  /**
+   * Mock shared preferences which does not persist state.
+   */
+  private class MockPreferences implements SharedPreferences {
+    @Override
+    public boolean contains(String key) {
+      return preferenceValues.containsKey(key);
+    }
+
+    @Override
+    public Editor edit() {
+      return new MockPreferenceEditor();
+    }
+
+    @Override
+    public Map<String, ?> getAll() {
+      return preferenceValues;
+    }
+
+    @Override
+    public boolean getBoolean(String key, boolean defValue) {
+      return get(key, defValue);
+    }
+
+    @Override
+    public float getFloat(String key, float defValue) {
+      return get(key, defValue);
+    }
+
+    @Override
+    public int getInt(String key, int defValue) {
+      return get(key, defValue);
+    }
+
+    @Override
+    public long getLong(String key, long defValue) {
+      return get(key, defValue);
+    }
+
+    @Override
+    public String getString(String key, String defValue) {
+      return get(key, defValue);
+    }
+
+    @Override
+    public void registerOnSharedPreferenceChangeListener(
+        OnSharedPreferenceChangeListener listener) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void unregisterOnSharedPreferenceChangeListener(
+        OnSharedPreferenceChangeListener listener) {
+      throw new UnsupportedOperationException();
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> T get(String key, T defValue) {
+      Object value = preferenceValues.get(key);
+      if (value == null) return defValue;
+      return (T) value;
+    }
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    preferenceValues = new HashMap<String, Object>();
+    preferences = new MockPreferences();
+    preferenceBackupHelper = new PreferenceBackupHelper();
+  }
+
+  public void testExportImportPreferences() throws Exception {
+    // Populate with some initial values
+    Editor editor = preferences.edit();
+    editor.clear();
+    editor.putBoolean("bool1", true);
+    editor.putBoolean("bool2", false);
+    editor.putFloat("flt1", 3.14f);
+    editor.putInt("int1", 42);
+    editor.putLong("long1", 123456789L);
+    editor.putString("str1", "lolcat");
+    editor.commit();
+
+    // Export it
+    byte[] exported = preferenceBackupHelper.exportPreferences(preferences);
+
+    // Mess with the previous values
+    editor = preferences.edit();
+    editor.clear();
+    editor.putString("str2", "Shouldn't be there after restore");
+    editor.putBoolean("bool2", true);
+    editor.commit();
+
+    // Import it back
+    preferenceBackupHelper.importPreferences(exported, preferences);
+
+    assertFalse(preferences.contains("str2"));
+    assertTrue(preferences.getBoolean("bool1", false));
+    assertFalse(preferences.getBoolean("bool2", true));
+    assertEquals(3.14f, preferences.getFloat("flt1", 0.0f));
+    assertEquals(42, preferences.getInt("int1", 0));
+    assertEquals(123456789L, preferences.getLong("long1", 0));
+    assertEquals("lolcat", preferences.getString("str1", ""));
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/docs/DocsHelperTest.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2010 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.docs;
+
+import com.google.android.apps.mytracks.io.gdata.GDataWrapper;
+
+import android.content.Context;
+import android.test.mock.MockContext;
+
+import junit.framework.TestCase;
+
+import java.io.IOException;
+
+/**
+ * Tests for {@link DocsHelper}, with the exception of 
+ * {@link DocsHelper#addTrackRow}, which is in 
+ * {@link DocsHelper_AddTrackRowTest}.
+ * 
+ * @author Matthew Simmons
+ */
+public class DocsHelperTest extends TestCase {
+  private Context mockContext = new MockContext();
+  
+  // TODO(simmonmt): Use AndroidMock to mock this class.  We do it the hard
+  // way because use of AndroidMock to mock GDataWrapper triggers a compile
+  // error in an unrelated file.  Specifically, it causes a NoClassDefFound
+  // exception for com.google.wireless.gdata2.client.AuthenticationException, 
+  // (wrongly) attributed to the first source file in the project.  Using the 
+  // @UsesMocks(GDataWrapper.class) annotation is enough -- you don't have to 
+  // touch AndroidMock at all to get this failure.
+  // The bug is filed with Android Mock as
+  //   http://code.google.com/p/android-mock/issues/detail?id=3
+  private class MockGDataWrapper extends GDataWrapper {
+    private final boolean returnValue;
+    
+    MockGDataWrapper(boolean returnValue) {
+      this.returnValue = returnValue;
+    }
+    
+    @Override
+    public boolean runQuery(QueryFunction queryFunction) {
+      return returnValue;
+    }
+  }
+  
+  public void testCreateSpreadsheet_noException() throws Exception {
+    // Our mock GDataWrapper isn't able to affect the return value from
+    // DocsHelper#createSpreadsheet.  As such, we're only able to simulate the
+    // case where there weren't any GData errors, but not spreadsheet ID was
+    // actually returned.  createSpreadsheet is defined to return null in that
+    // situation.
+    assertNull(new DocsHelper().createSpreadsheet(
+        mockContext, new MockGDataWrapper(true), "sheetName"));
+  }
+  
+  public void testCreateSpreadsheet_exception() throws Exception {
+    try {
+      new DocsHelper().createSpreadsheet(
+          mockContext, new MockGDataWrapper(false), "sheetName");
+      fail();
+    } catch (IOException expected) {}
+  }
+  
+  public void testRequestSpreadsheetId_noException() throws Exception {
+    assertNull(new DocsHelper().requestSpreadsheetId(
+        new MockGDataWrapper(true), "sheetName"));
+  }
+  
+  public void testRequestSpreadsheetId_exception() throws Exception {
+    try {
+      new DocsHelper().requestSpreadsheetId(new MockGDataWrapper(false), 
+          "sheetName");
+      fail();
+    } catch (IOException expected) {}
+  }
+  
+  public void testGetWorksheetId_noException() throws Exception {
+    assertNull(new DocsHelper().getWorksheetId(new MockGDataWrapper(true), 
+        "sheetId"));
+  }
+  
+  public void testGetWorksheetId_exception() throws Exception {
+    try {
+      new DocsHelper().getWorksheetId(new MockGDataWrapper(false), "sheetId");
+      fail();
+    } catch (IOException expected) {}
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/docs/DocsHelper_AddTrackRowTest.java

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2010 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.docs;
+
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.io.AuthManager;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.test.mock.MockContext;
+import android.test.mock.MockResources;
+
+import junit.framework.TestCase;
+
+import java.io.IOException;
+
+/**
+ * Tests for {@link DocsHelper#addTrackRow}
+ * 
+ * @author Matthew Simmons
+ */
+public class DocsHelper_AddTrackRowTest extends TestCase {
+  private static final long TIME = 1288721514000L;
+  
+  private static class StringWritingDocsHelper extends DocsHelper {
+    String writtenSheetUri = null;
+    String writtenData = null;
+    
+    @Override
+    protected void writeRowData(AuthManager trixAuth, String worksheetUri,
+        String postText) {
+      writtenSheetUri = worksheetUri;
+      writtenData = postText;
+    }
+  }
+
+  public void testAddTrackRow_imperial() throws Exception {
+    StringWritingDocsHelper docsHelper = new StringWritingDocsHelper();
+    addTrackRow(docsHelper, false);
+    
+    String expectedData =
+      "<entry xmlns='http://www.w3.org/2005/Atom' "
+      + "xmlns:gsx='http://schemas.google.com/spreadsheets/2006/extended'>"
+      + "<gsx:name><![CDATA[trackName]]></gsx:name>"
+      + "<gsx:description><![CDATA[trackDescription]]></gsx:description>"
+      // We format the date here because we can't guarantee/force the timezone
+      + "<gsx:date><![CDATA[" + String.format("%tc", TIME) + "]]></gsx:date>"
+      + "<gsx:totaltime><![CDATA[0:00:05]]></gsx:totaltime>"
+      + "<gsx:movingtime><![CDATA[0:00:04]]></gsx:movingtime>"
+      + "<gsx:distance><![CDATA[12.43]]></gsx:distance>"
+      + "<gsx:distanceunit><![CDATA[mile]]></gsx:distanceunit>"
+      + "<gsx:averagespeed><![CDATA[8,947.75]]></gsx:averagespeed>"
+      + "<gsx:averagemovingspeed><![CDATA[11,184.68]]>"
+      + "</gsx:averagemovingspeed>"
+      + "<gsx:maxspeed><![CDATA[3,355.40]]></gsx:maxspeed>"
+      + "<gsx:speedunit><![CDATA[mph]]></gsx:speedunit>"
+      + "<gsx:elevationgain><![CDATA[19,685]]></gsx:elevationgain>"
+      + "<gsx:minelevation><![CDATA[-1,640]]></gsx:minelevation>"
+      + "<gsx:maxelevation><![CDATA[1,804]]></gsx:maxelevation>"
+      + "<gsx:elevationunit><![CDATA[feet]]></gsx:elevationunit>"
+      + "<gsx:map>"
+      + "<![CDATA[http://maps.google.com/maps/ms?msa=0&msid=trackMapId]]>"
+      + "</gsx:map>"
+      + "</entry>";
+
+    assertEquals(
+        "http://spreadsheets.google.com/feeds/list/ssid/wsid/private/full", 
+        docsHelper.writtenSheetUri);
+    assertEquals(expectedData, docsHelper.writtenData);
+  }
+  
+  public void testAddTrackRow_metric() throws Exception {
+    StringWritingDocsHelper docsHelper = new StringWritingDocsHelper();
+    addTrackRow(docsHelper, true);
+
+    // The imperial test verifies that the tags come out in the proper order,
+    // and with the proper names.  We need only verify that the labels are
+    // correct, and that at least one of the unit-dependent value tags is
+    // correct.
+    assertTrue(docsHelper.writtenData.contains(
+        "<gsx:distanceunit><![CDATA[km]]></gsx:distanceunit>"));
+    assertTrue(docsHelper.writtenData.contains(
+        "<gsx:speedunit><![CDATA[kph]]></gsx:speedunit>"));
+    assertTrue(docsHelper.writtenData.contains(
+        "<gsx:elevationunit><![CDATA[meter]]></gsx:elevationunit>"));
+    
+    assertTrue(docsHelper.writtenData.contains(
+        "<gsx:distance><![CDATA[20.00]]></gsx:distance>"));
+  }
+
+  @UsesMocks({AuthManager.class, MockContext.class, MockResources.class, 
+    Track.class})
+  /** Adds a row to the spreadsheet, using the provided helper. */
+  private void addTrackRow(DocsHelper docsHelper, boolean useMetric) 
+      throws IOException {
+    Resources mockResources = AndroidMock.createMock(MockResources.class);
+    
+    if (useMetric) {
+      AndroidMock.expect(mockResources.getString(R.string.kilometer))
+          .andReturn("km");
+      AndroidMock.expect(mockResources.getString(R.string.kilometer_per_hour))
+          .andReturn("kph");
+      AndroidMock.expect(mockResources.getString(R.string.meter))
+          .andReturn("meter");
+    } else {
+      AndroidMock.expect(mockResources.getString(R.string.mile))
+          .andReturn("mile");
+      AndroidMock.expect(mockResources.getString(R.string.mile_per_hour))
+          .andReturn("mph");
+      AndroidMock.expect(mockResources.getString(R.string.feet))
+          .andReturn("feet");
+    }
+    AndroidMock.replay(mockResources);
+    
+    Context mockContext = AndroidMock.createMock(MockContext.class);
+    AndroidMock.expect(mockContext.getResources())
+        .andReturn(mockResources).anyTimes();
+    AndroidMock.replay(mockContext);
+
+    AuthManager mockAuthManager = AndroidMock.createMock(AuthManager.class);
+    AndroidMock.replay(mockAuthManager);
+    
+    TripStatistics stats = new TripStatistics();
+    stats.setStartTime(TIME);
+    stats.setTotalTime(5000);
+    stats.setMovingTime(4000);
+    stats.setTotalDistance(20000);
+    stats.setMaxSpeed(1500);
+    stats.setTotalElevationGain(6000);
+    stats.setMinElevation(-500);
+    stats.setMaxElevation(550);
+    
+    Track track = new Track();
+    track.setName("trackName");
+    track.setDescription("trackDescription");
+    track.setMapId("trackMapId");
+    track.setStatistics(stats);
+    
+    docsHelper.addTrackRow(mockContext, mockAuthManager, "ssid", "wsid", 
+        track, useMetric);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/io/docs/DocsTagBuilderTest.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2010 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.docs;
+
+import junit.framework.TestCase;
+
+/**
+ * This class tests {@link DocsTagBuilder}
+ * 
+ * @author Matthew Simmons
+ */
+public class DocsTagBuilderTest extends TestCase {
+  public void testAppend() {
+    assertEquals("<gsx:tag><![CDATA[value]]></gsx:tag>", 
+        new DocsTagBuilder(false).append("tag", "value").build());
+  }
+  
+  public void testMultiAppend() {
+    String actual = new DocsTagBuilder(false)
+        .append("tag1", "value1")
+        .append("tag2", "value2")
+        .build();
+    
+    assertEquals("<gsx:tag1><![CDATA[value1]]></gsx:tag1>"
+        + "<gsx:tag2><![CDATA[value2]]></gsx:tag2>", actual); 
+  }
+  
+  public void testAppendLargeUnits_imperial() {
+    assertEquals("<gsx:tag><![CDATA[62.14]]></gsx:tag>",
+        new DocsTagBuilder(false).appendLargeUnits("tag", 100.0).build());
+  }
+  
+  public void testAppendLargeUnits_metric() {
+    assertEquals("<gsx:tag><![CDATA[100.00]]></gsx:tag>",
+        new DocsTagBuilder(true).appendLargeUnits("tag", 100.0).build());
+  }
+  
+  public void testAppendSmallUnits_imperial() {
+    assertEquals("<gsx:tag><![CDATA[328]]></gsx:tag>",
+        new DocsTagBuilder(false).appendSmallUnits("tag", 100.0).build());
+  }
+  
+  public void testAppendSmallUnits_metric() {
+    assertEquals("<gsx:tag><![CDATA[100]]></gsx:tag>",
+        new DocsTagBuilder(true).appendSmallUnits("tag", 100.0).build());
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/services/DefaultTrackNameFactoryTest.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2010 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.services;
+
+import android.content.Context;
+import android.test.AndroidTestCase;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * Tests {@link DefaultTrackNameFactory}
+ * 
+ * @author Matthew Simmons
+ */
+public class DefaultTrackNameFactoryTest extends AndroidTestCase {
+  /**
+   * A version of the factory which allows us to supply our own answer as to
+   * whether a timestamp-based track name should be used.
+   */
+  private static class MockDefaultTrackNameFactory
+      extends DefaultTrackNameFactory {
+    private final boolean useTimestamp;
+
+    MockDefaultTrackNameFactory(Context context, boolean useTimestamp) {
+      super(context);
+      this.useTimestamp = useTimestamp;
+    }
+    
+    @Override
+    protected boolean useTimestampTrackName() {
+      return useTimestamp;
+    }
+  }
+  
+  private static final long TIMESTAMP = 1288213406000L;
+
+  public void testTimestampTrackName() {
+    DefaultTrackNameFactory factory =
+        new MockDefaultTrackNameFactory(getContext(), true);
+    
+    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm");
+    assertEquals(formatter.format(new Date(TIMESTAMP)),
+        factory.newTrackName(1, TIMESTAMP));
+  }
+
+  public void testIncrementingTrackName() {
+    DefaultTrackNameFactory factory =
+        new MockDefaultTrackNameFactory(getContext(), false);
+
+    assertEquals("Track 1", factory.newTrackName(1, TIMESTAMP));
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/services/StatusAnnouncerFactoryTest.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2010 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.services;
+
+import com.google.android.apps.mytracks.util.ApiFeatures;
+
+import android.media.AudioManager;
+import android.speech.tts.TextToSpeech;
+import android.test.AndroidTestCase;
+
+/**
+ * Tests for {@link StatusAnnouncerFactory}.
+ * These tests require Donut+ to run.
+ *
+ * @author Rodrigo Damazio
+ */
+public class StatusAnnouncerFactoryTest extends AndroidTestCase {
+  /**
+   * Mock version of the {@link ApiFeatures} class.
+   */
+  private class MockApiFeatures extends ApiFeatures {
+    private boolean hasTts;
+
+    public void setHasTextToSpeech(boolean hasTts) {
+      this.hasTts = hasTts;
+    }
+
+    @Override
+    public boolean hasTextToSpeech() {
+      return hasTts;
+    }
+  }
+
+  private MockApiFeatures apiFeatures;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    apiFeatures = new MockApiFeatures();
+  }
+
+  public void testCreate() {
+    apiFeatures.setHasTextToSpeech(true);
+    StatusAnnouncerFactory factory =
+        new StatusAnnouncerFactory(apiFeatures);
+    PeriodicTask task = factory.create(getContext());
+    assertTrue(task instanceof StatusAnnouncerTask);
+  }
+
+  public void testCreate_notAvailable() {
+    apiFeatures.setHasTextToSpeech(false);
+    StatusAnnouncerFactory factory =
+        new StatusAnnouncerFactory(apiFeatures);
+    PeriodicTask task = factory.create(getContext());
+    assertNull(task);
+  }
+
+  public void testGetVolumeStream() {
+    apiFeatures.setHasTextToSpeech(true);
+    StatusAnnouncerFactory factory =
+        new StatusAnnouncerFactory(apiFeatures);
+    assertEquals(
+        TextToSpeech.Engine.DEFAULT_STREAM,
+        factory.getVolumeStream());
+  }
+
+  public void testGetVolumeStream_notAvailable() {
+    apiFeatures.setHasTextToSpeech(false);
+    StatusAnnouncerFactory factory =
+        new StatusAnnouncerFactory(apiFeatures);
+    assertEquals(
+        AudioManager.USE_DEFAULT_STREAM_TYPE,
+        factory.getVolumeStream());
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/services/StatusAnnouncerTaskTest.java

@@ -0,0 +1,522 @@
+/*
+ * Copyright 2010 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.services;
+
+import static com.google.android.testing.mocking.AndroidMock.capture;
+import static com.google.android.testing.mocking.AndroidMock.eq;
+import static com.google.android.testing.mocking.AndroidMock.expect;
+import static com.google.android.testing.mocking.AndroidMock.same;
+
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.content.Context;
+import android.speech.tts.TextToSpeech;
+import android.speech.tts.TextToSpeech.OnInitListener;
+import android.speech.tts.TextToSpeech.OnUtteranceCompletedListener;
+import android.telephony.PhoneStateListener;
+import android.telephony.TelephonyManager;
+import android.test.AndroidTestCase;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.easymock.Capture;
+
+/**
+ * Tests for {@link StatusAnnouncerTask}.
+ * WARNING: I'm not responsible if your eyes start bleeding while reading this
+ *          code. You have been warned. It's still better than no test, though.
+ *
+ * @author Rodrigo Damazio
+ */
+public class StatusAnnouncerTaskTest extends AndroidTestCase {
+
+  // Use something other than our hardcoded value
+  private static final Locale DEFAULT_LOCALE = Locale.KOREAN;
+  private static final String ANNOUNCEMENT = "I can haz cheeseburger?";
+  private Locale oldDefaultLocale;
+
+  private StatusAnnouncerTask task;
+  private StringUtils stringUtils;
+  private StatusAnnouncerTask mockTask;
+  private Capture<OnInitListener> initListenerCapture;
+  private Capture<PhoneStateListener> phoneListenerCapture;
+  private TextToSpeechDelegate ttsDelegate;
+  private TextToSpeechInterface tts;
+
+  /**
+   * Mockable interface that we delegate TTS calls to.
+   */
+  interface TextToSpeechInterface {
+    int addEarcon(String earcon, String packagename, int resourceId);
+    int addEarcon(String earcon, String filename);
+    int addSpeech(String text, String packagename, int resourceId);
+    int addSpeech(String text, String filename);
+    boolean areDefaultsEnforced();
+    String getDefaultEngine();
+    Locale getLanguage();
+    int isLanguageAvailable(Locale loc);
+    boolean isSpeaking();
+    int playEarcon(String earcon, int queueMode,
+        HashMap<String, String> params);
+    int playSilence(long durationInMs, int queueMode,
+        HashMap<String, String> params);
+    int setEngineByPackageName(String enginePackageName);
+    int setLanguage(Locale loc);
+    int setOnUtteranceCompletedListener(OnUtteranceCompletedListener listener);
+    int setPitch(float pitch);
+    int setSpeechRate(float speechRate);
+    void shutdown();
+    int speak(String text, int queueMode, HashMap<String, String> params);
+    int stop();
+    int synthesizeToFile(String text, HashMap<String, String> params,
+        String filename);
+  }
+
+  /**
+   * Subclass of {@link TextToSpeech} which delegates calls to the interface
+   * above.
+   * The logic here is stupid and the author is ashamed of having to write it
+   * like this, but basically the issue is that TextToSpeech cannot be mocked
+   * without running its constructor, its constructor runs async operations
+   * which call other methods (and then if the methods are part of a mock we'd
+   * have to set a behavior, but we can't 'cause the object hasn't been fully
+   * built yet).
+   * The logic is that calls made during the constructor (when tts is not yet
+   * set) will go up to the original class, but after tts is set we'll forward
+   * them all to the mock.
+   */
+  private class TextToSpeechDelegate
+      extends TextToSpeech implements TextToSpeechInterface {
+    public TextToSpeechDelegate(Context context, OnInitListener listener) {
+      super(context, listener);
+    }
+
+    @Override
+    public int addEarcon(String earcon, String packagename, int resourceId) {
+      if (tts == null) {
+        return super.addEarcon(earcon, packagename, resourceId);
+      }
+      return tts.addEarcon(earcon, packagename, resourceId);
+    }
+
+    @Override
+    public int addEarcon(String earcon, String filename) {
+      if (tts == null) {
+        return super.addEarcon(earcon, filename);
+      }
+      return tts.addEarcon(earcon, filename);
+    }
+
+    @Override
+    public int addSpeech(String text, String packagename, int resourceId) {
+      if (tts == null) {
+        return super.addSpeech(text, packagename, resourceId);
+      }
+      return tts.addSpeech(text, packagename, resourceId);
+    }
+
+    @Override
+    public int addSpeech(String text, String filename) {
+      if (tts == null) {
+        return super.addSpeech(text, filename);
+      }
+      return tts.addSpeech(text, filename);
+    }
+
+    @Override
+    public Locale getLanguage() {
+      if (tts == null) {
+        return super.getLanguage();
+      }
+      return tts.getLanguage();
+    }
+
+    @Override
+    public int isLanguageAvailable(Locale loc) {
+      if (tts == null) {
+        return super.isLanguageAvailable(loc);
+      }
+      return tts.isLanguageAvailable(loc);
+    }
+
+    @Override
+    public boolean isSpeaking() {
+      if (tts == null) {
+        return super.isSpeaking();
+      }
+      return tts.isSpeaking();
+    }
+
+    @Override
+    public int playEarcon(String earcon, int queueMode,
+        HashMap<String, String> params) {
+      if (tts == null) {
+        return super.playEarcon(earcon, queueMode, params);
+      }
+      return tts.playEarcon(earcon, queueMode, params);
+    }
+
+    @Override
+    public int playSilence(long durationInMs, int queueMode,
+        HashMap<String, String> params) {
+      if (tts == null) {
+        return super.playSilence(durationInMs, queueMode, params);
+      }
+      return tts.playSilence(durationInMs, queueMode, params);
+    }
+
+    @Override
+    public int setLanguage(Locale loc) {
+      if (tts == null) {
+        return super.setLanguage(loc);
+      }
+      return tts.setLanguage(loc);
+    }
+
+    @Override
+    public int setOnUtteranceCompletedListener(
+        OnUtteranceCompletedListener listener) {
+      if (tts == null) {
+        return super.setOnUtteranceCompletedListener(listener);
+      }
+      return tts.setOnUtteranceCompletedListener(listener);
+    }
+
+    @Override
+    public int setPitch(float pitch) {
+      if (tts == null) {
+        return super.setPitch(pitch);
+      }
+      return tts.setPitch(pitch);
+    }
+
+    @Override
+    public int setSpeechRate(float speechRate) {
+      if (tts == null) {
+        return super.setSpeechRate(speechRate);
+      }
+      return tts.setSpeechRate(speechRate);
+    }
+
+    @Override
+    public void shutdown() {
+      if (tts == null) {
+        super.shutdown();
+        return;
+      }
+      tts.shutdown();
+    }
+
+    @Override
+    public int speak(
+        String text, int queueMode, HashMap<String, String> params) {
+      if (tts == null) {
+        return super.speak(text, queueMode, params);
+      }
+      return tts.speak(text, queueMode, params);
+    }
+
+    @Override
+    public int stop() {
+      if (tts == null) {
+        return super.stop();
+      }
+      return tts.stop();
+    }
+
+    @Override
+    public int synthesizeToFile(String text, HashMap<String, String> params,
+        String filename) {
+      if (tts == null) {
+        return super.synthesizeToFile(text, params, filename);
+      }
+      return tts.synthesizeToFile(text, params, filename);
+    }
+  }
+
+  @UsesMocks({
+    StatusAnnouncerTask.class,
+    StringUtils.class,
+    TrackRecordingService.class,
+  })
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    oldDefaultLocale = Locale.getDefault();
+    Locale.setDefault(DEFAULT_LOCALE);
+    stringUtils = AndroidMock.createMock(StringUtils.class, getContext());
+
+    // Eww, the effort required just to mock TextToSpeech is insane
+    final AtomicBoolean listenerCalled = new AtomicBoolean();
+    OnInitListener blockingListener = new OnInitListener() {
+      @Override
+      public void onInit(int status) {
+        synchronized (this) {
+          listenerCalled.set(true);
+          notify();
+        }
+      }
+    };
+
+    ttsDelegate = new TextToSpeechDelegate(getContext(), blockingListener);
+
+    // Wait for all async operations done in the constructor to finish.
+    synchronized (blockingListener) {
+      while (!listenerCalled.get()) {
+        // Releases the synchronized lock until we're woken up.
+        blockingListener.wait();
+      }
+    }
+
+    // Phew, done, now we can start forwarding calls
+    tts = AndroidMock.createMock(TextToSpeechInterface.class);
+
+    initListenerCapture = new Capture<OnInitListener>();
+    phoneListenerCapture = new Capture<PhoneStateListener>();
+
+    // Create a partial forwarding mock
+    mockTask = AndroidMock.createMock(StatusAnnouncerTask.class,
+        getContext(), stringUtils);
+    task = new StatusAnnouncerTask(getContext(), stringUtils) {
+      @Override
+      protected TextToSpeech newTextToSpeech(Context ctx,
+          OnInitListener onInitListener) {
+        return mockTask.newTextToSpeech(ctx, onInitListener);
+      }
+
+      @Override
+      protected String getAnnouncement(TripStatistics stats) {
+        return mockTask.getAnnouncement(stats);
+      }
+
+      @Override
+      protected void listenToPhoneState(
+          PhoneStateListener listener, int events) {
+        mockTask.listenToPhoneState(listener, events);
+      }
+    };
+  }
+
+  @Override
+  protected void tearDown() {
+    Locale.setDefault(oldDefaultLocale);
+  }
+
+  public void testStart() {
+    doStart();
+    OnInitListener ttsInitListener = initListenerCapture.getValue();
+    assertNotNull(ttsInitListener);
+
+    expect(tts.isLanguageAvailable(DEFAULT_LOCALE))
+        .andStubReturn(TextToSpeech.LANG_AVAILABLE);
+    expect(tts.setLanguage(DEFAULT_LOCALE))
+        .andReturn(TextToSpeech.LANG_AVAILABLE);
+    expect(tts.setSpeechRate(StatusAnnouncerTask.TTS_SPEECH_RATE))
+        .andReturn(TextToSpeech.SUCCESS);
+
+    AndroidMock.replay(tts, stringUtils);
+
+    ttsInitListener.onInit(TextToSpeech.SUCCESS);
+
+    AndroidMock.verify(mockTask, tts, stringUtils);
+  }
+
+  public void testStart_languageNotSupported() {
+    doStart();
+    OnInitListener ttsInitListener = initListenerCapture.getValue();
+    assertNotNull(ttsInitListener);
+
+    expect(tts.isLanguageAvailable(DEFAULT_LOCALE))
+        .andStubReturn(TextToSpeech.LANG_NOT_SUPPORTED);
+    expect(tts.setLanguage(Locale.ENGLISH))
+        .andReturn(TextToSpeech.LANG_AVAILABLE);
+    expect(tts.setSpeechRate(StatusAnnouncerTask.TTS_SPEECH_RATE))
+        .andReturn(TextToSpeech.SUCCESS);
+
+    AndroidMock.replay(tts, stringUtils);
+
+    ttsInitListener.onInit(TextToSpeech.SUCCESS);
+
+    AndroidMock.verify(mockTask, tts, stringUtils);
+  }
+
+  public void testStart_notReady() {
+    doStart();
+    OnInitListener ttsInitListener = initListenerCapture.getValue();
+    assertNotNull(ttsInitListener);
+
+    AndroidMock.replay(tts, stringUtils);
+
+    ttsInitListener.onInit(TextToSpeech.ERROR);
+
+    AndroidMock.verify(mockTask, tts, stringUtils);
+  }
+
+  public void testShutdown() {
+    // First, start
+    doStart();
+    AndroidMock.verify(mockTask);
+    AndroidMock.reset(mockTask);
+
+    // Then, shut down
+    PhoneStateListener phoneListener = phoneListenerCapture.getValue();
+    mockTask.listenToPhoneState(
+        same(phoneListener), eq(PhoneStateListener.LISTEN_NONE));
+    tts.shutdown();
+    AndroidMock.replay(mockTask, tts, stringUtils);
+    task.shutdown();
+    AndroidMock.verify(mockTask, tts, stringUtils);
+  }
+
+  public void testRun() throws Exception {
+    // Expect service data calls
+    TripStatistics stats = new TripStatistics();
+    TrackRecordingService service =
+        AndroidMock.createMock(TrackRecordingService.class);
+    expect(service.getTripStatistics()).andStubReturn(stats);
+
+    // Expect announcement building call
+    expect(mockTask.getAnnouncement(same(stats))).andStubReturn(ANNOUNCEMENT);
+
+    // Put task in "ready" state
+    startTask(TextToSpeech.SUCCESS);
+
+    // Expect actual announcement call
+    expect(tts.speak(
+        eq(ANNOUNCEMENT), eq(TextToSpeech.QUEUE_FLUSH),
+        AndroidMock.<HashMap<String, String>>isNull()))
+            .andReturn(TextToSpeech.SUCCESS);
+
+    // Run the announcement
+    AndroidMock.replay(tts, stringUtils, service);
+    task.run(service);
+    AndroidMock.verify(mockTask, tts, stringUtils, service);
+  }
+
+  public void testRun_notReady() throws Exception {
+    TrackRecordingService service =
+        AndroidMock.createMock(TrackRecordingService.class);
+
+    // Put task in "not ready" state
+    startTask(TextToSpeech.ERROR);
+
+    // Run the announcement
+    AndroidMock.replay(tts, stringUtils, service);
+    task.run(service);
+    AndroidMock.verify(mockTask, tts, stringUtils, service);
+  }
+
+  public void testRun_duringCall() throws Exception {
+    TrackRecordingService service =
+        AndroidMock.createMock(TrackRecordingService.class);
+  
+    startTask(TextToSpeech.SUCCESS);
+
+    expect(tts.isSpeaking()).andStubReturn(false);
+
+    // Run the announcement
+    AndroidMock.replay(tts, stringUtils, service);
+    PhoneStateListener phoneListener = phoneListenerCapture.getValue();
+    phoneListener.onCallStateChanged(TelephonyManager.CALL_STATE_OFFHOOK, null);
+    task.run(service);
+    AndroidMock.verify(mockTask, tts, stringUtils, service);
+  }
+
+  public void testRun_ringWhileSpeaking() throws Exception {
+    TrackRecordingService service =
+        AndroidMock.createMock(TrackRecordingService.class);
+
+    startTask(TextToSpeech.SUCCESS);
+
+    expect(tts.isSpeaking()).andStubReturn(true);
+    expect(tts.stop()).andReturn(TextToSpeech.SUCCESS);
+
+    AndroidMock.replay(tts, stringUtils, service);
+
+    // Update the state to ringing - this should stop the current announcement.
+    PhoneStateListener phoneListener = phoneListenerCapture.getValue();
+    phoneListener.onCallStateChanged(TelephonyManager.CALL_STATE_RINGING, null);
+
+    // Run the announcement - this should do nothing.
+    task.run(service);
+
+    AndroidMock.verify(mockTask, tts, stringUtils, service);
+  }
+
+  public void testRun_whileRinging() throws Exception {
+    TrackRecordingService service =
+      AndroidMock.createMock(TrackRecordingService.class);
+
+    startTask(TextToSpeech.SUCCESS);
+
+    expect(tts.isSpeaking()).andStubReturn(false);
+
+    // Run the announcement
+    AndroidMock.replay(tts, stringUtils, service);
+    PhoneStateListener phoneListener = phoneListenerCapture.getValue();
+    phoneListener.onCallStateChanged(TelephonyManager.CALL_STATE_RINGING, null);
+    task.run(service);
+    AndroidMock.verify(mockTask, tts, stringUtils, service);
+  }
+
+  public void testRun_noService() throws Exception {
+    startTask(TextToSpeech.SUCCESS);
+
+    // Run the announcement
+    AndroidMock.replay(tts, stringUtils);
+    task.run(null);
+    AndroidMock.verify(mockTask, tts, stringUtils);
+  }
+
+  public void testRun_noStats() throws Exception {
+    // Expect service data calls
+    TrackRecordingService service =
+        AndroidMock.createMock(TrackRecordingService.class);
+    expect(service.getTripStatistics()).andStubReturn(null);
+
+    startTask(TextToSpeech.SUCCESS);
+
+    // Run the announcement
+    AndroidMock.replay(tts, stringUtils, service);
+    task.run(service);
+    AndroidMock.verify(mockTask, tts, stringUtils, service);
+  }
+
+  private void startTask(int state) {
+    AndroidMock.resetToNice(tts, stringUtils);
+    AndroidMock.replay(tts, stringUtils);
+    doStart();
+    OnInitListener ttsInitListener = initListenerCapture.getValue();
+    ttsInitListener.onInit(state);
+    AndroidMock.resetToDefault(tts, stringUtils);
+  }
+
+  private void doStart() {
+    mockTask.listenToPhoneState(capture(phoneListenerCapture),
+        eq(PhoneStateListener.LISTEN_CALL_STATE));
+    expect(mockTask.newTextToSpeech(
+        same(getContext()), capture(initListenerCapture)))
+        .andStubReturn(ttsDelegate);
+    AndroidMock.replay(mockTask);
+    task.start();
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/services/TrackRecordingServiceTest.java

@@ -0,0 +1,829 @@
+/*
+ * Copyright 2010 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.services;
+
+import static com.google.android.apps.mytracks.MyTracksConstants.RESUME_TRACK_EXTRA_NAME;
+
+import com.google.android.apps.mytracks.MyTracksSettings;
+import com.google.android.apps.mytracks.content.MyTracksProvider;
+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.content.WaypointCreationRequest;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.ApiFeatures;
+import com.google.android.maps.mytracks.R;
+
+import android.content.BroadcastReceiver;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.location.Location;
+import android.os.IBinder;
+import android.test.RenamingDelegatingContext;
+import android.test.ServiceTestCase;
+import android.test.mock.MockContentResolver;
+import android.test.suitebuilder.annotation.MediumTest;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Tests for the MyTracks track recording service.
+ * 
+ * @author Bartlomiej Niechwiej
+ * 
+ * TODO: The original class, ServiceTestCase, has a few limitations, e.g.
+ * it's not possible to properly shutdown the service, unless tearDown()
+ * is called, which prevents from testing multiple scenarios in a single
+ * test (see runFunctionTest for more details).
+ */
+public class TrackRecordingServiceTest
+    extends ServiceTestCase<TrackRecordingService> {
+
+  private Context context;
+  private MyTracksProviderUtils providerUtils;
+  private SharedPreferences sharedPreferences;
+  
+  /*
+   * In order to support starting and binding to the service in the same
+   * unit test, we provide a workaround, as the original class doesn't allow
+   * to bind after the service has been previously started.
+   */
+
+  private boolean bound;
+  private Intent serviceIntent;
+  
+  public TrackRecordingServiceTest() {
+    super(TrackRecordingService.class);
+  }
+
+  /**
+   * A context wrapper with the user provided {@link ContentResolver}.
+   * 
+   * TODO: Move to test utils package.
+   */
+  public static class MockContext extends ContextWrapper {
+    private final ContentResolver contentResolver;
+    
+    public MockContext(ContentResolver contentResolver, Context base) {
+      super(base);
+      this.contentResolver = contentResolver;
+    }
+
+    @Override
+    public ContentResolver getContentResolver() {
+      return contentResolver;
+    }
+  }
+
+  /**
+   * A mock class that forces API level < 5 to make sure we can workaround a bug
+   * in ServiceTestCase (throwing a NPE).
+   * See http://code.google.com/p/android/issues/detail?id=12122 for more
+   * details.
+   */
+  private static class MockApiFeatures extends ApiFeatures {
+    @Override
+    protected int getApiLevel() {
+      return 4;
+    }
+  }
+  
+  @Override
+  protected IBinder bindService(Intent intent) {
+    if (getService() != null) {
+      if (bound) {
+        throw new IllegalStateException(
+            "Service: " + getService() + " is already bound");
+      }
+      bound = true;
+      serviceIntent = intent.cloneFilter();
+      return getService().onBind(intent);
+    } else {
+      return super.bindService(intent);
+    }
+  }
+
+  @Override
+  protected void shutdownService() {
+    if (bound) {
+      assertNotNull(getService());
+      getService().onUnbind(serviceIntent);
+      bound = false;
+    }
+    super.shutdownService();
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    ApiFeatures.injectInstance(new MockApiFeatures());
+
+    MockContentResolver mockContentResolver = new MockContentResolver();
+    RenamingDelegatingContext targetContext = new RenamingDelegatingContext(
+        getContext(), getContext(), "test.");
+    context = new MockContext(mockContentResolver, targetContext);
+    MyTracksProvider provider = new MyTracksProvider();
+    provider.attachInfo(context, null);
+    mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, provider);
+    setContext(context);
+
+    providerUtils = MyTracksProviderUtils.Factory.get(context);
+
+    sharedPreferences = context.getSharedPreferences(
+        MyTracksSettings.SETTINGS_NAME, 0);
+    // Let's use default values.
+    sharedPreferences.edit().clear().commit();
+
+    // Disable auto resume by default.
+    updateAutoResumePrefs(0, -1);
+    // No recording track.
+    Editor editor = sharedPreferences.edit();
+    editor.putLong(context.getString(R.string.recording_track_key), -1);
+    editor.commit();
+  }
+
+  @SmallTest
+  public void testStartable() {
+    startService(createStartIntent());
+    assertNotNull(getService());
+  }
+
+  @MediumTest
+  public void testBindable() {
+    IBinder service = bindService(createStartIntent());
+    assertNotNull(service);
+  }
+
+  @MediumTest
+  public void testResumeAfterReboot_shouldResume() throws Exception {
+    // Insert a dummy track and mark it as recording track.
+    createDummyTrack(123, System.currentTimeMillis(), true);
+
+    // Clear the number of attempts and set the timeout to 10 min.
+    updateAutoResumePrefs(0, 10);
+
+    // Start the service in "resume" mode (simulates the on-reboot action).
+    Intent startIntent = createStartIntent();
+    startIntent.putExtra(RESUME_TRACK_EXTRA_NAME, true);
+    startService(startIntent);
+    assertNotNull(getService());
+
+    // We expect to resume the previous track. 
+    assertTrue(getService().isRecording());
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertEquals(123, service.getRecordingTrackId());
+  }
+
+  // TODO: shutdownService() has a bug and doesn't set mServiceCreated
+  // to false, thus preventing from a second call to onCreate().
+  // Report the bug to Android team.  Until then, the following tests
+  // and checks must be commented out.
+  //
+  // TODO: If fixed, remove "disabled" prefix from the test name.
+  @MediumTest
+  public void disabledTestResumeAfterReboot_simulateReboot() throws Exception {
+    updateAutoResumePrefs(0, 10);
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    // Simulate recording a track.
+    long id = service.startNewTrack();
+    assertTrue(service.isRecording());
+    assertEquals(id, service.getRecordingTrackId());
+    shutdownService();
+    assertEquals(id, sharedPreferences.getLong(
+        context.getString(R.string.recording_track_key), -1));
+
+    // Start the service in "resume" mode (simulates the on-reboot action).
+    Intent startIntent = createStartIntent();
+    startIntent.putExtra(RESUME_TRACK_EXTRA_NAME, true);
+    startService(startIntent);
+    assertNotNull(getService());
+
+    assertTrue(getService().isRecording());
+  }
+
+  @MediumTest
+  public void testResumeAfterReboot_noRecordingTrack() throws Exception {
+    // Insert a dummy track and mark it as recording track.
+    createDummyTrack(123, System.currentTimeMillis(), false);
+
+    // Clear the number of attempts and set the timeout to 10 min.
+    updateAutoResumePrefs(0, 10);
+
+    // Start the service in "resume" mode (simulates the on-reboot action).
+    Intent startIntent = createStartIntent();
+    startIntent.putExtra(RESUME_TRACK_EXTRA_NAME, true);
+    startService(startIntent);
+    assertNotNull(getService());
+
+    // We don't expect to resume the previous track, because it was stopped.
+    assertFalse(getService().isRecording());
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertEquals(-1, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testResumeAfterReboot_expiredTrack() throws Exception {
+    // Insert a dummy track last updated 20 min ago.
+    createDummyTrack(123, System.currentTimeMillis() - 20 * 60 * 1000, true);
+
+    // Clear the number of attempts and set the timeout to 10 min.
+    updateAutoResumePrefs(0, 10);
+
+    // Start the service in "resume" mode (simulates the on-reboot action).
+    Intent startIntent = createStartIntent();
+    startIntent.putExtra(RESUME_TRACK_EXTRA_NAME, true);
+    startService(startIntent);
+    assertNotNull(getService());
+
+    // We don't expect to resume the previous track, because it has expired.
+    assertFalse(getService().isRecording());
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertEquals(-1, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testResumeAfterReboot_tooManyAttempts() throws Exception {
+    // Insert a dummy track.
+    createDummyTrack(123, System.currentTimeMillis(), true);
+
+    // Set the number of attempts to max.
+    updateAutoResumePrefs(
+        TrackRecordingService.MAX_AUTO_RESUME_TRACK_RETRY_ATTEMPTS, 10);
+
+    // Start the service in "resume" mode (simulates the on-reboot action).
+    Intent startIntent = createStartIntent();
+    startIntent.putExtra(RESUME_TRACK_EXTRA_NAME, true);
+    startService(startIntent);
+    assertNotNull(getService());
+
+    // We don't expect to resume the previous track, because there were already
+    // too many attempts.
+    assertFalse(getService().isRecording());
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertEquals(-1, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testRecording_noTracks() throws Exception {
+    List<Track> tracks = providerUtils.getAllTracks();
+    assertTrue(tracks.isEmpty());
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    // Test if we start in no-recording mode by default. 
+    assertFalse(service.isRecording());
+    assertEquals(-1, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testRecording_oldTracks() throws Exception {
+    createDummyTrack(123, -1, false);
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+    assertEquals(-1, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testRecording_orphanedRecordingTrack() throws Exception {
+    // Just set recording track to a bogus value.
+    setRecordingTrack(256);
+
+    // Make sure that the service will not start recording and will clear
+    // the bogus track.
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+    assertEquals(-1, service.getRecordingTrackId());
+  }
+
+  /**
+   * Synchronous/waitable broadcast receiver to be used in testing.
+   */
+  private class BlockingBroadcastReceiver extends BroadcastReceiver {
+    private static final long MAX_WAIT_TIME_MS = 10000;
+    private List<Intent> receivedIntents = new ArrayList<Intent>();
+
+    public List<Intent> getReceivedIntents() {
+      return receivedIntents;
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      Log.d("MyTracksTest", "Got broadcast: " + intent);
+      synchronized (receivedIntents) {
+        receivedIntents.add(intent);
+        receivedIntents.notifyAll();
+      }
+    }
+
+    public boolean waitUntilReceived(int receiveCount) {
+      long deadline = System.currentTimeMillis() + MAX_WAIT_TIME_MS;
+      synchronized (receivedIntents) {
+        while (receivedIntents.size() < receiveCount) {
+          try {
+            // Wait releases synchronized lock until it returns
+            receivedIntents.wait(500);
+          } catch (InterruptedException e) {
+            // Do nothing
+          }
+
+          if (System.currentTimeMillis() > deadline) {
+            return false;
+          }
+        }
+      }
+
+      return true;
+    }
+  }
+
+  @MediumTest
+  public void testStartNewTrack_noRecording() throws Exception {
+    // NOTICE: due to the way Android permissions work, if this fails,
+    // uninstall the test apk then retry - the test must be installed *after*
+    // My Tracks (go figure).
+    // Reference: http://code.google.com/p/android/issues/detail?id=5521
+    BlockingBroadcastReceiver startReceiver = new BlockingBroadcastReceiver();
+    String startAction = context.getString(R.string.track_started_broadcast_action);
+    context.registerReceiver(startReceiver, new IntentFilter(startAction));
+
+    List<Track> tracks = providerUtils.getAllTracks();
+    assertTrue(tracks.isEmpty());
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    long id = service.startNewTrack();
+    assertTrue(id >= 0);
+    assertTrue(service.isRecording());
+    Track track = providerUtils.getTrack(id);
+    assertNotNull(track);
+    assertEquals(id, track.getId());
+    assertEquals(id, sharedPreferences.getLong(
+        context.getString(R.string.recording_track_key), -1));
+    assertEquals(id, service.getRecordingTrackId());
+
+    // Verify that the start broadcast was received.
+    assertTrue(startReceiver.waitUntilReceived(1));
+    List<Intent> receivedIntents = startReceiver.getReceivedIntents();
+    assertEquals(1, receivedIntents.size());
+    Intent broadcastIntent = receivedIntents.get(0);
+    assertEquals(startAction, broadcastIntent.getAction());
+    assertEquals(id, broadcastIntent.getLongExtra(
+        context.getString(R.string.track_id_broadcast_extra), -1));
+
+    context.unregisterReceiver(startReceiver);
+  }
+
+  @MediumTest
+  public void testStartNewTrack_alreadyRecording() throws Exception {
+    createDummyTrack(123, -1, true);
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertTrue(service.isRecording());
+
+    try {
+      service.startNewTrack();
+      fail("Expecting IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+    assertEquals(123, sharedPreferences.getLong(
+        context.getString(R.string.recording_track_key), 0));
+    assertEquals(123, service.getRecordingTrackId());
+  }
+
+  @MediumTest
+  public void testEndCurrentTrack_alreadyRecording() throws Exception {
+    // See comment above if this fails randomly.
+    BlockingBroadcastReceiver stopReceiver = new BlockingBroadcastReceiver();
+    String stopAction = context.getString(R.string.track_stopped_broadcast_action);
+    context.registerReceiver(stopReceiver, new IntentFilter(stopAction));
+
+    createDummyTrack(123, -1, true);
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertTrue(service.isRecording());
+
+    // End the current track.
+    service.endCurrentTrack();
+    assertFalse(service.isRecording());
+    assertEquals(-1, sharedPreferences.getLong(
+        context.getString(R.string.recording_track_key), 0));
+    assertEquals(-1, service.getRecordingTrackId());
+
+    // Verify that the stop broadcast was received.
+    assertTrue(stopReceiver.waitUntilReceived(1));
+    List<Intent> receivedIntents = stopReceiver.getReceivedIntents();
+    assertEquals(1, receivedIntents.size());
+    Intent broadcastIntent = receivedIntents.get(0);
+    assertEquals(stopAction, broadcastIntent.getAction());
+    assertEquals(123, broadcastIntent.getLongExtra(
+        context.getString(R.string.track_id_broadcast_extra), -1));
+
+    context.unregisterReceiver(stopReceiver);
+  }
+
+  @MediumTest
+  public void testEndCurrentTrack_noRecording() throws Exception {
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    // End the current track.
+    try {
+      service.endCurrentTrack();
+      fail("Expecting IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+    assertEquals(-1, sharedPreferences.getLong(
+        context.getString(R.string.recording_track_key), 0));
+    assertEquals(-1, service.getRecordingTrackId());
+  }
+  
+  @MediumTest
+  public void testIntegration_completeRecordingSession() throws Exception {
+    List<Track> tracks = providerUtils.getAllTracks();
+    assertTrue(tracks.isEmpty());
+    fullRecordingSession();
+  }
+  
+  @MediumTest
+  public void testDeleteAllTracks_noRecording() throws Exception {
+    createDummyTrack(123, -1, false);
+    assertEquals(1, providerUtils.getAllTracks().size());
+    
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    // Deleting all tracks should succeed.
+    service.deleteAllTracks();
+    assertFalse(service.isRecording());
+    assertTrue(providerUtils.getAllTracks().isEmpty());
+  }
+
+  @MediumTest
+  public void testDeleteAllTracks_noTracks() throws Exception {
+    assertTrue(providerUtils.getAllTracks().isEmpty());
+    
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+
+    // Deleting all tracks should succeed.
+    service.deleteAllTracks();
+    assertFalse(service.isRecording());
+    assertTrue(providerUtils.getAllTracks().isEmpty());
+  }
+  
+  @MediumTest
+  public void testDeleteAllTracks_trackInProgress() throws Exception {
+    createDummyTrack(123, -1, true);
+    assertEquals(1, providerUtils.getAllTracks().size());
+
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertTrue(service.isRecording());
+
+    // Since we have a track in progress, we expect to fail.
+    try {
+      service.deleteAllTracks();
+      fail("Expecting IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+    assertTrue(service.isRecording());
+    assertEquals(1, providerUtils.getAllTracks().size());
+  }
+  
+  @MediumTest
+  public void testHasRecorded_noTracks() throws Exception {
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+    assertFalse(service.hasRecorded());
+  }
+  
+  @MediumTest
+  public void testHasRecorded_trackInProgress() throws Exception {
+    createDummyTrack(123, -1, true);
+    assertEquals(1, providerUtils.getAllTracks().size());
+    
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertTrue(service.isRecording());
+    assertTrue(service.hasRecorded());
+  }
+  
+  @MediumTest
+  public void testHasRecorded_oldTracks() throws Exception {
+    createDummyTrack(123, -1, false);
+    assertEquals(1, providerUtils.getAllTracks().size());
+    
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+    assertTrue(service.hasRecorded());
+  }
+  
+  @MediumTest
+  public void testInsertStatisticsMarker_noRecordingTrack() throws Exception {
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+    
+    try {
+      service.insertWaypoint(WaypointCreationRequest.DEFAULT_STATISTICS);
+      fail("Expecting IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+  
+  @MediumTest
+  public void testInsertStatisticsMarker_validLocation() throws Exception {
+    createDummyTrack(123, -1, true);
+    
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertTrue(service.isRecording());
+    
+    assertEquals(1, service.insertWaypoint(WaypointCreationRequest.DEFAULT_STATISTICS));
+    assertEquals(2, service.insertWaypoint(WaypointCreationRequest.DEFAULT_STATISTICS));
+    
+    Waypoint wpt = providerUtils.getWaypoint(1);
+    assertEquals(getContext().getString(R.string.stats_icon_url),
+        wpt.getIcon());
+    assertEquals(getContext().getString(R.string.statistics),
+        wpt.getName());
+    assertEquals(Waypoint.TYPE_STATISTICS, wpt.getType());
+    assertEquals(123, wpt.getTrackId());
+    assertEquals(0.0, wpt.getLength());
+    assertNotNull(wpt.getLocation());
+    assertNotNull(wpt.getStatistics());
+    // TODO check the rest of the params.
+
+    // TODO: Check waypoint 2.
+  }
+
+  @MediumTest
+  public void testInsertWaypointMarker_noRecordingTrack() throws Exception {
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+    
+    try {
+      service.insertWaypoint(WaypointCreationRequest.DEFAULT_MARKER);
+      fail("Expecting IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected.
+    }
+  }
+  
+  @MediumTest
+  public void testInsertWaypointMarker_validWaypoint() throws Exception {
+    createDummyTrack(123, -1, true);
+    
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertTrue(service.isRecording());
+    
+    assertEquals(1, service.insertWaypoint(WaypointCreationRequest.DEFAULT_MARKER));
+    Waypoint wpt = providerUtils.getWaypoint(1);
+    assertEquals(getContext().getString(R.string.waypoint_icon_url),
+        wpt.getIcon());
+    assertEquals(getContext().getString(R.string.waypoint),
+        wpt.getName());
+    assertEquals(Waypoint.TYPE_WAYPOINT, wpt.getType());
+    assertEquals(123, wpt.getTrackId());
+    assertEquals(0.0, wpt.getLength());
+    assertNotNull(wpt.getLocation());
+    assertNull(wpt.getStatistics());
+  }
+  
+  @MediumTest
+  public void testWithProperties_noAnnouncementFreq() throws Exception {
+    functionalTest(R.string.announcement_frequency_key, (Object) null);
+  }
+
+  @MediumTest
+  public void testWithProperties_defaultAnnouncementFreq() throws Exception {
+    functionalTest(R.string.announcement_frequency_key, 1);
+  }
+  
+  @MediumTest
+  public void testWithProperties_noMaxRecordingDist() throws Exception {
+    functionalTest(R.string.max_recording_distance_key, (Object) null);
+  }
+
+  @MediumTest
+  public void testWithProperties_defaultMaxRecordingDist() throws Exception {
+    functionalTest(R.string.max_recording_distance_key, 5);
+  }
+
+  @MediumTest
+  public void testWithProperties_noMinRecordingDist() throws Exception {
+    functionalTest(R.string.min_recording_distance_key, (Object) null);
+  }
+
+  @MediumTest
+  public void testWithProperties_defaultMinRecordingDist() throws Exception {
+    functionalTest(R.string.min_recording_distance_key, 2);
+  }
+
+  @MediumTest
+  public void testWithProperties_noSplitFreq() throws Exception {
+    functionalTest(R.string.split_frequency_key, (Object) null);
+  }
+
+  @MediumTest
+  public void testWithProperties_defaultSplitFreqByDist() throws Exception {
+    functionalTest(R.string.split_frequency_key, 5);
+  }
+ 
+  @MediumTest
+  public void testWithProperties_defaultSplitFreqByTime() throws Exception {
+    functionalTest(R.string.split_frequency_key, -2);
+  }
+
+  @MediumTest
+  public void testWithProperties_noMetricUnits() throws Exception {
+    functionalTest(R.string.metric_units_key, (Object) null);
+  }
+
+  @MediumTest
+  public void testWithProperties_metricUnitsEnabled() throws Exception {
+    functionalTest(R.string.metric_units_key, true);
+  }
+
+  @MediumTest
+  public void testWithProperties_metricUnitsDisabled() throws Exception {
+    functionalTest(R.string.metric_units_key, false);
+  }
+  
+  @MediumTest
+  public void testWithProperties_noMinRecordingInterval() throws Exception {
+    functionalTest(R.string.min_recording_interval_key, (Object) null);
+  }
+
+  @MediumTest
+  public void testWithProperties_defaultMinRecordingInterval()
+      throws Exception {
+    functionalTest(R.string.min_recording_interval_key, 3);
+  }
+
+  @MediumTest
+  public void testWithProperties_noMinRequiredAccuracy() throws Exception {
+    functionalTest(R.string.min_required_accuracy_key, (Object) null);
+  }
+  
+  @MediumTest
+  public void testWithProperties_defaultMinRequiredAccuracy() throws Exception {
+    functionalTest(R.string.min_required_accuracy_key, 500);
+  }
+  
+  @MediumTest
+  public void testWithProperties_noSensorType() throws Exception {
+    functionalTest(R.string.sensor_type_key, (Object) null);
+  }
+  
+  @MediumTest
+  public void testWithProperties_zephyrSensorType() throws Exception {
+    functionalTest(R.string.sensor_type_key,
+    		context.getString(R.string.zephyr_sensor_type));
+  }
+  
+  private ITrackRecordingService bindAndGetService(Intent intent) {
+    ITrackRecordingService service = ITrackRecordingService.Stub.asInterface(
+        bindService(intent));
+    assertNotNull(service);
+    return service;
+  }
+
+  private Track createDummyTrack(long id, long stopTime, boolean isRecording) {
+    Track dummyTrack = new Track();
+    dummyTrack.setId(id);
+    dummyTrack.setName("Dummy Track");
+    TripStatistics tripStatistics = new TripStatistics();
+    tripStatistics.setStopTime(stopTime);
+    dummyTrack.setStatistics(tripStatistics);
+    addTrack(dummyTrack, isRecording);
+    return dummyTrack;
+  }
+  
+  private void updateAutoResumePrefs(int attempts, int timeoutMins) {
+    Editor editor = sharedPreferences.edit();
+    editor.putInt(context.getString(
+    R.string.auto_resume_track_current_retry_key), attempts);
+    editor.putInt(context.getString(
+        R.string.auto_resume_track_timeout_key), timeoutMins);
+    editor.commit();
+  }
+  
+  private Intent createStartIntent() {
+    Intent startIntent = new Intent();
+    startIntent.setClass(context, TrackRecordingService.class);
+    return startIntent;
+  }
+  
+  private void addTrack(Track track, boolean isRecording) {
+    assertTrue(track.getId() >= 0);
+    providerUtils.insertTrack(track);
+    assertEquals(track.getId(), providerUtils.getTrack(track.getId()).getId());
+    setRecordingTrack(isRecording ? track.getId() : -1);
+  }
+  
+  private void setRecordingTrack(long id) {
+    Editor editor = sharedPreferences.edit();
+    editor.putLong(context.getString(R.string.recording_track_key), id);
+    editor.commit();
+  }
+
+  // TODO: We support multiple values for readability, however this test's
+  // base class doesn't properly shutdown the service, so it's not possible
+  // to pass more than 1 value at a time.
+  private void functionalTest(int resourceId, Object ...values)
+      throws Exception {
+    final String key = context.getString(resourceId);
+    for (Object value : values) {
+      // Remove all properties and set the property for the given key. 
+      Editor editor = sharedPreferences.edit();
+      editor.clear();
+      if (value instanceof String) {
+        editor.putString(key, (String) value); 
+      } else if (value instanceof Long) {
+        editor.putLong(key, (Long) value);
+      } else if (value instanceof Integer) {
+        editor.putInt(key, (Integer) value);
+      } else if (value instanceof Boolean) {
+        editor.putBoolean(key, (Boolean) value);
+      } else if (value == null) {
+        // Do nothing, as clear above has already removed this property.
+      }
+      editor.commit();
+      
+      fullRecordingSession();
+    }
+  }
+  
+  private void fullRecordingSession() throws Exception {
+    ITrackRecordingService service = bindAndGetService(createStartIntent());
+    assertFalse(service.isRecording());
+    
+    // Start a track.
+    long id = service.startNewTrack();
+    assertTrue(id >= 0);
+    assertTrue(service.isRecording());
+    Track track = providerUtils.getTrack(id);
+    assertNotNull(track);
+    assertEquals(id, track.getId());
+    assertEquals(id, sharedPreferences.getLong(
+        context.getString(R.string.recording_track_key), -1));
+    assertEquals(id, service.getRecordingTrackId());
+
+    // Insert a few points, markers and statistics.
+    long startTime = System.currentTimeMillis();
+    for (int i = 0; i < 30; i++) {
+      Location loc = new Location("gps");
+      loc.setLongitude(35.0f + i / 10.0f);
+      loc.setLatitude(45.0f - i / 5.0f);
+      loc.setAccuracy(5);
+      loc.setSpeed(10);
+      loc.setTime(startTime + i * 10000);
+      loc.setBearing(3.0f);
+      service.recordLocation(loc);
+      
+      if (i % 10 == 0) {
+        service.insertWaypoint(WaypointCreationRequest.DEFAULT_STATISTICS);
+      } else if (i % 7 == 0) {
+        service.insertWaypoint(WaypointCreationRequest.DEFAULT_MARKER);
+      }
+    }
+    
+    // Stop the track.  Validate if it has correct data.
+    service.endCurrentTrack();
+    assertFalse(service.isRecording());
+    assertEquals(-1, service.getRecordingTrackId());
+    track = providerUtils.getTrack(id);
+    assertNotNull(track);
+    assertEquals(id, track.getId());
+    TripStatistics tripStatistics = track.getStatistics();
+    assertNotNull(tripStatistics);
+    assertTrue(tripStatistics.getStartTime() > 0);
+    assertTrue(tripStatistics.getStopTime() >= tripStatistics.getStartTime());
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/services/sensors/AntDirectSensorManagerTest.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2009 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.services.sensors;
+
+import com.dsi.ant.AntMesg;
+import com.google.android.apps.mytracks.MyTracksSettings;
+import com.google.android.apps.mytracks.content.Sensor;
+import com.google.android.maps.mytracks.R;
+
+import android.content.SharedPreferences;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+public class AntDirectSensorManagerTest extends AndroidTestCase {
+
+  private SharedPreferences sharedPreferences;
+  private AntDirectSensorManager manager;
+  
+  public void setUp() {
+    sharedPreferences = getContext().getSharedPreferences(
+        MyTracksSettings.SETTINGS_NAME, 0);
+    // Let's use default values.
+    sharedPreferences.edit().clear().commit();
+    manager = new AntDirectSensorManager(getContext());
+  }
+  
+  @SmallTest
+  public void testBroadcastData() {
+    manager.setDeviceNumberHRM((short) 42);
+    byte[] buff = new byte[11];
+    buff[1] = AntMesg.MESG_BROADCAST_DATA_ID;
+    buff[2] = 0;  // HRM CHANNEL
+    buff[10] = (byte) 220; 
+    manager.handleMessage(buff);
+
+    Sensor.SensorDataSet sds = manager.getSensorDataSet();
+    assertNotNull(sds);
+    assertTrue(sds.hasHeartRate());
+    assertEquals(Sensor.SensorState.SENDING,
+        sds.getHeartRate().getState());
+    assertEquals(220, sds.getHeartRate().getValue());
+    
+    assertFalse(sds.hasCadence());
+    assertFalse(sds.hasPower());
+  }
+
+  @SmallTest
+  public void testHandleChannelId() {
+    assertEquals(0, manager.getDeviceNumberHRM());
+    short id = 42;
+    byte[] buff = new byte[5];
+    buff[3] = 42;
+    manager.handleChannelId(buff);
+    assertEquals(id, manager.getDeviceNumberHRM());
+  }
+
+  @SmallTest
+  public void testChannelId() {
+    byte[] buff = new byte[11];
+    buff[1] = AntMesg.MESG_CHANNEL_ID_ID;
+    buff[3] = 42;
+    manager.handleMessage(buff);
+
+    assertEquals(42, manager.getDeviceNumberHRM());
+    assertEquals(42,
+        sharedPreferences.getInt(
+            getContext().getString(R.string.ant_heart_rate_sensor_id_key), -1));
+    assertNull(manager.getSensorDataSet());
+  }
+
+  @SmallTest
+  public void testResponseEvent() {
+    assertEquals(Sensor.SensorState.NONE, manager.getSensorState());
+    byte[] buff = new byte[11];
+    buff[1] = AntMesg.MESG_RESPONSE_EVENT_ID;
+    buff[3] = AntMesg.MESG_UNASSIGN_CHANNEL_ID;
+    manager.handleMessage(buff);
+
+    assertEquals(Sensor.SensorState.DISCONNECTED, manager.getSensorState());
+    assertNull(manager.getSensorDataSet());
+  }
+  
+  // TODO: Test timeout too.
+}

MyTracksTest/src/com/google/android/apps/mytracks/services/sensors/SensorManagerFactoryTest.java

@@ -0,0 +1,53 @@
+package com.google.android.apps.mytracks.services.sensors;
+
+import com.google.android.apps.mytracks.MyTracksSettings;
+import com.google.android.maps.mytracks.R;
+
+import android.content.SharedPreferences;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+public class SensorManagerFactoryTest extends AndroidTestCase {
+
+  private SharedPreferences sharedPreferences;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    
+    sharedPreferences = getContext().getSharedPreferences(
+        MyTracksSettings.SETTINGS_NAME, 0);
+    // Let's use default values.
+    sharedPreferences.edit().clear().commit();
+  }
+  
+  @SmallTest
+  public void testDefaultSettings() throws Exception {
+    assertNull(SensorManagerFactory.getSensorManager(getContext()));
+  }
+  
+  @SmallTest
+  public void testCreateZephyr() throws Exception {
+    assertClassForName(ZephyrSensorManager.class, R.string.zephyr_sensor_type);
+  }
+  
+  @SmallTest
+  public void testCreateAnt() throws Exception {
+    assertClassForName(AntDirectSensorManager.class, R.string.ant_sensor_type);
+  }
+
+  @SmallTest
+  public void testCreateAntSRM() throws Exception {
+    assertClassForName(AntSRMSensorManager.class, R.string.srm_ant_bridge_sensor_type);
+  }
+
+  private void assertClassForName(Class<?> c, int i) {
+    sharedPreferences.edit()
+        .putString(getContext().getString(R.string.sensor_type_key),
+            getContext().getString(i))
+        .commit();
+    SensorManager sm = SensorManagerFactory.getSensorManager(getContext());
+    assertNotNull(sm);
+    assertTrue(c.isInstance(sm));
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/services/sensors/ZephyrMessageParserTest.java

@@ -0,0 +1,36 @@
+package com.google.android.apps.mytracks.services.sensors;
+
+import com.google.android.apps.mytracks.content.Sensor;
+
+import junit.framework.TestCase;
+
+public class ZephyrMessageParserTest extends TestCase {
+
+  ZephyrMessageParser parser = new ZephyrMessageParser();
+
+  public void testIsValid() {
+    byte[] buf = new byte[60];
+    assertFalse(parser.isValid(buf));
+    buf[0] = 0x02;
+    assertFalse(parser.isValid(buf));
+    buf[59] = 0x03;
+    assertTrue(parser.isValid(buf));
+  }
+
+  public void testParseBuffer() {
+    byte[] buf = new byte[60];
+    buf[12] = 50;
+    Sensor.SensorDataSet sds = parser.parseBuffer(buf);
+    assertTrue(sds.hasHeartRate());
+    assertTrue(sds.getHeartRate().getState() == Sensor.SensorState.SENDING);
+    assertEquals(50, sds.getHeartRate().getValue());
+  }
+
+  public void testFindNextAlignment() {
+    byte[] buf = new byte[60];
+    assertEquals(-1, parser.findNextAlignment(buf));
+    buf[10] = 0x03;
+    buf[11] = 0x02;
+    assertEquals(10, parser.findNextAlignment(buf));
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/stats/DoubleBufferTest.java

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009 Google Inc. All Rights Reserved.
+ */
+
+package com.google.android.apps.mytracks.stats;
+
+import junit.framework.TestCase;
+
+/**
+ * Test for the DoubleBuffer class.
+ *
+ * @author Sandor Dornbush
+ */
+public class DoubleBufferTest extends TestCase {
+
+  /**
+   * Tests that the constructor leaves the buffer in a valid state.
+   */
+  public void testConstructor() {
+    DoubleBuffer buffer = new DoubleBuffer(10);
+    assertFalse(buffer.isFull());
+    assertEquals(0.0, buffer.getAverage());
+    double[] averageAndVariance = buffer.getAverageAndVariance();
+    assertEquals(0.0, averageAndVariance[0]);
+    assertEquals(0.0, averageAndVariance[1]);
+  }
+
+  /**
+   * Simple test with 10 of the same values.
+   */
+  public void testBasic() {
+    DoubleBuffer buffer = new DoubleBuffer(10);
+
+    for (int i = 0; i < 9; i++) {
+      buffer.setNext(1.0);
+      assertFalse(buffer.isFull());
+      assertEquals(1.0, buffer.getAverage());
+      double[] averageAndVariance = buffer.getAverageAndVariance();
+      assertEquals(1.0, averageAndVariance[0]);
+      assertEquals(0.0, averageAndVariance[1]);
+    }
+    buffer.setNext(1);
+    assertTrue(buffer.isFull());
+    assertEquals(1.0, buffer.getAverage());
+    double[] averageAndVariance = buffer.getAverageAndVariance();
+    assertEquals(1.0, averageAndVariance[0]);
+    assertEquals(0.0, averageAndVariance[1]);
+  }
+
+  /**
+   * Tests with 5 entries of -10 and 5 entries of 10.
+   */
+  public void testSplit() {
+    DoubleBuffer buffer = new DoubleBuffer(10);
+
+    for (int i = 0; i < 5; i++) {
+      buffer.setNext(-10);
+      assertFalse(buffer.isFull());
+      assertEquals(-10.0, buffer.getAverage());
+      double[] averageAndVariance = buffer.getAverageAndVariance();
+      assertEquals(-10.0, averageAndVariance[0]);
+      assertEquals(0.0, averageAndVariance[1]);
+    }
+
+    for (int i = 1; i < 5; i++) {
+      buffer.setNext(10);
+      assertFalse(buffer.isFull());
+      double expectedAverage = ((i * 10.0) - 50.0) / (i + 5);
+      assertEquals(buffer.toString(),
+                   expectedAverage, buffer.getAverage(), 0.01);
+      double[] averageAndVariance = buffer.getAverageAndVariance();
+      assertEquals(expectedAverage, averageAndVariance[0]);
+    }
+    buffer.setNext(10);
+    assertTrue(buffer.isFull());
+    assertEquals(0.0, buffer.getAverage());
+    double[] averageAndVariance = buffer.getAverageAndVariance();
+    assertEquals(0.0, averageAndVariance[0]);
+    assertEquals(100.0, averageAndVariance[1]);
+  }
+
+  /**
+   * Tests that reset leaves the buffer in a valid state.
+   */
+  public void testReset() {
+    DoubleBuffer buffer = new DoubleBuffer(10);
+
+    for (int i = 0; i < 100; i++) {
+      buffer.setNext(i);
+    }
+    assertTrue(buffer.isFull());
+
+    buffer.reset();
+    assertFalse(buffer.isFull());
+    assertEquals(0.0, buffer.getAverage());
+    double[] averageAndVariance = buffer.getAverageAndVariance();
+    assertEquals(0.0, averageAndVariance[0]);
+    assertEquals(0.0, averageAndVariance[1]);
+  }
+
+
+  /**
+   * Tests that if a lot of items are inserted the smoothing and looping works.
+   */
+  public void testLoop() {
+    DoubleBuffer buffer = new DoubleBuffer(10);
+
+    for (int i = 0; i < 1000; i++) {
+      buffer.setNext(i);
+      assertEquals(i >= 9, buffer.isFull());
+      if (i > 10) {
+        assertEquals(i - 4.5, buffer.getAverage());
+      }
+    }
+  }
+
+}

MyTracksTest/src/com/google/android/apps/mytracks/stats/ExtremityMonitorTest.java

@@ -0,0 +1,63 @@
+/**
+ * Copyright 2009 Google Inc. All Rights Reserved.
+ */
+package com.google.android.apps.mytracks.stats;
+
+import junit.framework.TestCase;
+import java.util.Random;
+
+/**
+ * This class test the ExtremityMonitor class.
+ *
+ * @author Sandor Dornbush
+ */
+public class ExtremityMonitorTest extends TestCase {
+
+  public ExtremityMonitorTest(String name) {
+    super(name);
+  }
+
+  public void testInitialize() {
+    ExtremityMonitor monitor = new ExtremityMonitor();
+    assertEquals(Double.POSITIVE_INFINITY, monitor.getMin());
+    assertEquals(Double.NEGATIVE_INFINITY, monitor.getMax());
+  }
+
+  public void testSimple() {
+    ExtremityMonitor monitor = new ExtremityMonitor();
+    assertTrue(monitor.update(0));
+    assertTrue(monitor.update(1));
+    assertEquals(0.0, monitor.getMin());
+    assertEquals(1.0, monitor.getMax());
+    assertFalse(monitor.update(1));
+    assertFalse(monitor.update(0.5));
+  }
+
+  /**
+   * Throws a bunch of random numbers between [0,1] at the monitor.
+   */
+  public void testRandom() {
+    ExtremityMonitor monitor = new ExtremityMonitor();
+    Random random = new Random(42);
+    for (int i = 0; i < 1000; i++) {
+      monitor.update(random.nextDouble());
+    }
+    assertTrue(monitor.getMin() < 0.1);
+    assertTrue(monitor.getMax() < 1.0);
+    assertTrue(monitor.getMin() >= 0.0);
+    assertTrue(monitor.getMax() > 0.9);
+  }
+
+  public void testReset() {
+    ExtremityMonitor monitor = new ExtremityMonitor();
+    assertTrue(monitor.update(0));
+    assertTrue(monitor.update(1));
+    monitor.reset();
+    assertEquals(Double.POSITIVE_INFINITY, monitor.getMin());
+    assertEquals(Double.NEGATIVE_INFINITY, monitor.getMax());
+    assertTrue(monitor.update(0));
+    assertTrue(monitor.update(1));
+    assertEquals(0.0, monitor.getMin());
+    assertEquals(1.0, monitor.getMax());
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/stats/TripStatisticsBuilderTest.java

@@ -0,0 +1,184 @@
+// Copyright 2009 Google Inc. All Rights Reserved.
+
+package com.google.android.apps.mytracks.stats;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+
+import android.location.Location;
+
+import junit.framework.TestCase;
+
+/**
+ * Test the the function of the TripStatisticsBuilder class.
+ *
+ * @author Sandor Dornbush
+ */
+public class TripStatisticsBuilderTest extends TestCase {
+
+  private TripStatisticsBuilder builder = null;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    builder = new TripStatisticsBuilder(System.currentTimeMillis());
+  }
+
+  public void testAddLocationSimple() throws Exception {
+    builder = new TripStatisticsBuilder(1000);
+    TripStatistics stats = builder.getStatistics();
+
+    assertEquals(0.0, builder.getSmoothedElevation());
+    assertEquals(Double.POSITIVE_INFINITY, stats.getMinElevation());
+    assertEquals(Double.NEGATIVE_INFINITY, stats.getMaxElevation());
+    assertEquals(0.0, stats.getMaxSpeed());
+    assertEquals(Double.POSITIVE_INFINITY, stats.getMinGrade());
+    assertEquals(Double.NEGATIVE_INFINITY, stats.getMaxGrade());
+    assertEquals(0.0, stats.getTotalElevationGain());
+    assertEquals(0, stats.getMovingTime());
+    assertEquals(0.0, stats.getTotalDistance());
+    for (int i = 0; i < 100; i++) {
+      Location l = new Location("test");
+      l.setAccuracy(1.0f);
+      l.setLongitude(45.0);
+
+      // Going up by 5 meters each time.
+      l.setAltitude(i);
+      // Moving by .1% of a degree latitude.
+      l.setLatitude(i * .001);
+      l.setSpeed(11.1f);
+      // Each time slice is 10 seconds.
+      long time = 1000 + 10000 * i;
+      l.setTime(time);
+      boolean moving = builder.addLocation(l, time);
+      assertEquals((i != 0), moving);
+
+      stats = builder.getStatistics();
+      assertEquals(10000 * i, stats.getTotalTime());
+      assertEquals(10000 * i, stats.getMovingTime());
+      assertEquals(i, builder.getSmoothedElevation(),
+                   MyTracksConstants.ELEVATION_SMOOTHING_FACTOR / 2);
+      assertEquals(0.0, stats.getMinElevation());
+      assertEquals(i, stats.getMaxElevation(),
+                   MyTracksConstants.ELEVATION_SMOOTHING_FACTOR / 2);
+      assertEquals(i, stats.getTotalElevationGain(),
+                   MyTracksConstants.ELEVATION_SMOOTHING_FACTOR);
+
+      if (i > MyTracksConstants.SPEED_SMOOTHING_FACTOR) {
+        assertEquals(11.1f, stats.getMaxSpeed(), 0.1);
+      }
+      if ((i > MyTracksConstants.GRADE_SMOOTHING_FACTOR)
+          && (i > MyTracksConstants.ELEVATION_SMOOTHING_FACTOR)) {
+        assertEquals(0.009, stats.getMinGrade(), 0.0001);
+        assertEquals(0.009, stats.getMaxGrade(), 0.0001);
+      }
+      // 1 degree = 111 km
+      // 1 timeslice = 0.001 degree = 111 m
+      assertEquals(111.0 * i, stats.getTotalDistance(), 100);
+    }
+  }
+
+  /**
+   * Test that elevation works if the user is stable.
+   */
+  public void testElevationSimple() throws Exception {
+    for (double elevation = 0; elevation < 1000; elevation += 10) {
+      builder = new TripStatisticsBuilder(System.currentTimeMillis());
+      for (int j = 0; j < 100; j++) {
+        assertEquals(0.0, builder.updateElevation(elevation));
+        assertEquals(elevation, builder.getSmoothedElevation());
+        TripStatistics data = builder.getStatistics();
+        assertEquals(elevation, data.getMinElevation());
+        assertEquals(elevation, data.getMaxElevation());
+        assertEquals(0.0, data.getTotalElevationGain());
+      }
+    }
+  }
+
+  public void testElevationGain() throws Exception {
+    for (double i = 0; i < 1000; i++) {
+      double expectedGain;
+      if (i < (MyTracksConstants.ELEVATION_SMOOTHING_FACTOR - 1)) {
+        expectedGain = 0;
+      } else if (i < MyTracksConstants.ELEVATION_SMOOTHING_FACTOR) {
+        expectedGain = 0.5;
+      } else {
+        expectedGain = 1.0;
+      }
+      assertEquals(expectedGain,
+                   builder.updateElevation(i));
+      assertEquals(i, builder.getSmoothedElevation(), 20);
+      TripStatistics data = builder.getStatistics();
+      assertEquals(0.0, data.getMinElevation(), 0.0);
+      assertEquals(i, data.getMaxElevation(),
+                   MyTracksConstants.ELEVATION_SMOOTHING_FACTOR);
+      assertEquals(i, data.getTotalElevationGain(),
+                   MyTracksConstants.ELEVATION_SMOOTHING_FACTOR);
+    }
+  }
+
+  public void testGradeSimple() throws Exception {
+    for (double i = 0; i < 1000; i++) {
+      // The value of the elevation does not matter.  This is just to fill the
+      // buffer.
+      builder.updateElevation(i);
+      builder.updateGrade(100, 100);
+      if ((i > MyTracksConstants.GRADE_SMOOTHING_FACTOR)
+          && (i > MyTracksConstants.ELEVATION_SMOOTHING_FACTOR)) {
+        assertEquals(1.0, builder.getStatistics().getMaxGrade());
+        assertEquals(1.0, builder.getStatistics().getMinGrade());
+      }
+    }
+    for (double i = 0; i < 1000; i++) {
+      // The value of the elevation does not matter.  This is just to fill the
+      // buffer.
+      builder.updateElevation(i);
+      builder.updateGrade(100, -100);
+      if ((i > MyTracksConstants.GRADE_SMOOTHING_FACTOR)
+          && (i > MyTracksConstants.ELEVATION_SMOOTHING_FACTOR)) {
+        assertEquals(1.0, builder.getStatistics().getMaxGrade());
+        assertEquals(-1.0, builder.getStatistics().getMinGrade());
+      }
+    }
+  }
+
+  public void testGradeIgnoreShort() throws Exception {
+    for (double i = 0; i < 100; i++) {
+      // The value of the elevation does not matter.  This is just to fill the
+      // buffer.
+      builder.updateElevation(i);
+      builder.updateGrade(1, 100);
+      assertEquals(Double.NEGATIVE_INFINITY, builder.getStatistics().getMaxGrade());
+      assertEquals(Double.POSITIVE_INFINITY, builder.getStatistics().getMinGrade());
+    }
+  }
+
+  public void testUpdateSpeedIncludeZero() {
+    for (int i = 0; i < 1000; i++) {
+      builder.updateSpeed(i + 1000, 0.0, i, 4.0);
+      assertEquals(0.0, builder.getStatistics().getMaxSpeed());
+      assertEquals((i + 1) * 1000, builder.getStatistics().getMovingTime());
+    }
+  }
+
+  public void testUpdateSpeedIngoreErrorCode() {
+    builder.updateSpeed(12345000, 128.0, 12344000, 0.0);
+    assertEquals(0.0, builder.getStatistics().getMaxSpeed());
+    assertEquals(1000, builder.getStatistics().getMovingTime());
+  }
+
+  public void testUpdateSpeedIngoreLargeAcceleration() {
+    builder.updateSpeed(12345000, 100.0, 12344000, 1.0);
+    assertEquals(0.0, builder.getStatistics().getMaxSpeed());
+    assertEquals(1000, builder.getStatistics().getMovingTime());
+  }
+
+  public void testUpdateSpeed() {
+    for (int i = 0; i < 1000; i++) {
+      builder.updateSpeed(i + 1000, 4.0, i, 4.0);
+      assertEquals((i + 1) * 1000, builder.getStatistics().getMovingTime());
+      if (i > MyTracksConstants.SPEED_SMOOTHING_FACTOR) {
+        assertEquals(4.0, builder.getStatistics().getMaxSpeed());
+      }
+    }
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/stats/TripStatisticsTest.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2010 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.stats;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for {@link TripStatistics}.
+ * This only tests non-trivial pieces of that class.
+ *
+ * @author Rodrigo Damazio
+ */
+public class TripStatisticsTest extends TestCase {
+
+  private TripStatistics statistics;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    statistics = new TripStatistics();
+  }
+
+  public void testSetBounds() {
+    // This is not a trivial setter, conversion happens in it
+    statistics.setBounds(12345, -34567, 56789, -98765);
+    assertEquals(12345, statistics.getLeft());
+    assertEquals(-34567, statistics.getTop());
+    assertEquals(56789, statistics.getRight());
+    assertEquals(-98765, statistics.getBottom());
+  }
+
+  public void testMerge() {
+    TripStatistics statistics2 = new TripStatistics();
+    statistics.setStartTime(1000L);  // Resulting start time
+    statistics.setStopTime(2500L);
+    statistics2.setStartTime(3000L);
+    statistics2.setStopTime(4000L);  // Resulting stop time
+    statistics.setTotalTime(1500L);
+    statistics2.setTotalTime(1000L);  // Result: 1500+1000
+    statistics.setMovingTime(700L);
+    statistics2.setMovingTime(600L);  // Result: 700+600
+    statistics.setTotalDistance(750.0);
+    statistics2.setTotalDistance(350.0);  // Result: 750+350
+    statistics.setTotalElevationGain(50.0);
+    statistics2.setTotalElevationGain(850.0);  // Result: 850+50
+    statistics.setMaxSpeed(60.0);  // Resulting max speed
+    statistics2.setMaxSpeed(30.0);
+    statistics.setMaxElevation(1250.0);
+    statistics.setMinElevation(1200.0);  // Resulting min elevation
+    statistics2.setMaxElevation(3575.0);  // Resulting max elevation
+    statistics2.setMinElevation(2800.0);
+    statistics.setMaxGrade(15.0);
+    statistics.setMinGrade(-25.0);  // Resulting min grade
+    statistics2.setMaxGrade(35.0);  // Resulting max grade
+    statistics2.setMinGrade(0.0);
+
+    // Resulting bounds: -10000, 35000, 30000, -40000
+    statistics.setBounds(-10000, 20000, 30000, -40000);
+    statistics2.setBounds(-5000, 35000, 0, 20000);
+
+    statistics.merge(statistics2);
+
+    assertEquals(1000L, statistics.getStartTime());
+    assertEquals(4000L, statistics.getStopTime());
+    assertEquals(2500L, statistics.getTotalTime());
+    assertEquals(1300L, statistics.getMovingTime());
+    assertEquals(1100.0, statistics.getTotalDistance());
+    assertEquals(900.0, statistics.getTotalElevationGain());
+    assertEquals(60.0, statistics.getMaxSpeed());
+    assertEquals(-10000, statistics.getLeft());
+    assertEquals(30000, statistics.getRight());
+    assertEquals(35000, statistics.getTop());
+    assertEquals(-40000, statistics.getBottom());
+    assertEquals(1200.0, statistics.getMinElevation());
+    assertEquals(3575.0, statistics.getMaxElevation());
+    assertEquals(-25.0, statistics.getMinGrade());
+    assertEquals(35.0, statistics.getMaxGrade());
+  }
+
+  public void testGetAverageSpeed() {
+    statistics.setTotalDistance(1000.0);
+    statistics.setTotalTime(50000);  // in milliseconds
+    assertEquals(20.0, statistics.getAverageSpeed());
+  }
+
+  public void testGetAverageMovingSpeed() {
+    statistics.setTotalDistance(1000.0);
+    statistics.setMovingTime(20000);  // in milliseconds
+    assertEquals(50.0, statistics.getAverageMovingSpeed());
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/testing/TestingProviderUtilsFactory.java

@@ -0,0 +1,38 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+
+package com.google.android.apps.mytracks.testing;
+
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.Factory;
+
+import android.content.Context;
+
+/**
+ * A fake factory for {@link MyTracksProviderUtils} which always returns a
+ * predefined instance.
+ *
+ * @author Rodrigo Damazio
+ */
+public class TestingProviderUtilsFactory extends Factory {
+  private MyTracksProviderUtils instance;
+
+  public TestingProviderUtilsFactory(MyTracksProviderUtils instance) {
+    this.instance = instance;
+  }
+
+  @Override
+  protected MyTracksProviderUtils newForContext(Context context) {
+    return instance;
+  }
+
+  public static Factory installWithInstance(MyTracksProviderUtils instance) {
+    Factory oldFactory = Factory.getInstance();
+    Factory factory = new TestingProviderUtilsFactory(instance);
+    MyTracksProviderUtils.Factory.overrideInstance(factory);
+    return oldFactory;
+  }
+
+  public static void restoreOldFactory(Factory factory) {
+    MyTracksProviderUtils.Factory.overrideInstance(factory);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/util/ApiFeaturesTest.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2010 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.util;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests the API feature detection code in {@link ApiFeatures}.
+ * This test requires Froyo+ to run.
+ *
+ * @author Rodrigo Damazio
+ */
+public class ApiFeaturesTest extends TestCase {
+
+  private TestableApiFeatures features;
+
+  private class TestableApiFeatures extends ApiFeatures {
+    private int apiLevel;
+
+    public void setApiLevel(int apiLevel) {
+      this.apiLevel = apiLevel;
+    }
+
+    @Override
+    protected int getApiLevel() {
+      return apiLevel;
+    }
+  }
+  
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    features = new TestableApiFeatures();
+  }
+
+  public void testHasBackup() {
+    for (int i = 3; i <= 7; i++) {
+      features.setApiLevel(i);
+      assertFalse(features.hasBackup());
+    }
+    features.setApiLevel(8);
+    assertTrue(features.hasBackup());
+  }
+
+  public void testHasTextToSpeech() {
+    features.setApiLevel(3);
+    assertFalse(features.hasTextToSpeech());
+    for (int i = 4; i <= 8; i++) {
+      features.setApiLevel(i);
+      assertTrue(features.hasTextToSpeech());
+    }
+  }
+
+  public void testGetApiPlatformAdapter() {
+    assertNotNull(features.getApiPlatformAdapter());
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/util/ChartURLGeneratorTest.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2009 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.util;
+
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+
+import java.util.Vector;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for the Chart URL generator.
+ *
+ * @author Sandor Dornbush
+ */
+public class ChartURLGeneratorTest extends TestCase {
+
+  public void testgetChartUrl() {
+    Vector<Double> distances = new Vector<Double>();
+    Vector<Double> elevations = new Vector<Double>();
+    Track t = new Track();
+    TripStatistics stats = t.getStatistics();
+    stats.setMinElevation(0);
+    stats.setMaxElevation(2000);
+    stats.setTotalDistance(100);
+
+    distances.add(0.0);
+    elevations.add(10.0);
+
+    distances.add(10.0);
+    elevations.add(300.0);
+
+    distances.add(20.0);
+    elevations.add(800.0);
+
+    distances.add(50.0);
+    elevations.add(1900.0);
+
+    distances.add(75.0);
+    elevations.add(1200.0);
+
+    distances.add(90.0);
+    elevations.add(700.0);
+
+    distances.add(100.0);
+    elevations.add(70.0);
+
+    String chart = ChartURLGenerator.getChartUrl(distances,
+                                                 elevations,
+                                                 t,
+                                                 "Title",
+                                                 true,
+                                                 false);
+
+    assertEquals(
+        "http://chart.apis.google.com/chart?&chs=600x350&cht=lxy&"
+        + "chtt=Title&chxt=x,y&chxr=0,0,0,0|1,0.0,2100.0,300&chco=009A00&"
+        + "chm=B,00AA00,0,0,0&chg=100000,14.285714285714286,1,0&"
+        + "chd=e:AAGZMzf.v.5l..,ATJJYY55kkVVCI",
+        chart);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/util/ChartsExtendedEncoderTest.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010 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.util;
+
+import junit.framework.TestCase;
+
+/**
+ * A unit test for {@link ChartsExtendedEncoder}.
+ * 
+ * @author Bartlomiej Niechwiej
+ */
+public class ChartsExtendedEncoderTest extends TestCase {
+
+  public void testGetEncodedValue_validArguments() {
+    // Valid arguments.
+    assertEquals("AK", ChartsExtendedEncoder.getEncodedValue(10));
+    assertEquals("JO", ChartsExtendedEncoder.getEncodedValue(590));
+    assertEquals("AA", ChartsExtendedEncoder.getEncodedValue(0));
+    // 64^2 = 4096.
+    assertEquals("..", ChartsExtendedEncoder.getEncodedValue(4095));
+  }
+
+  public void testGetEncodedValue_invalidArguments() {
+    // Invalid arguments.
+    assertEquals("__", ChartsExtendedEncoder.getEncodedValue(4096));
+    assertEquals("__", ChartsExtendedEncoder.getEncodedValue(1234564096));
+    assertEquals("__", ChartsExtendedEncoder.getEncodedValue(-10));
+    assertEquals("__", ChartsExtendedEncoder.getEncodedValue(-12324435));
+  }
+
+  public void testGetSeparator() {
+    assertEquals(",", ChartsExtendedEncoder.getSeparator());
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/util/FileUtilsTest.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2010 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.util;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+
+import android.os.Environment;
+
+import java.io.File;
+import java.util.HashSet;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for {@link FileUtils}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class FileUtilsTest extends TestCase {
+  private static final String ORIGINAL_NAME = "Swim\10ming-^across: the/ pacific (ocean).";
+  private static final String SANITIZED_NAME = "Swimming-across the pacific (ocean).";
+
+  private FileUtils fileUtils;
+  private Set<String> existingFiles;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    existingFiles = new HashSet<String>();
+    fileUtils = new FileUtils() {
+      @Override
+      protected boolean fileExists(File directory, String fullName) {
+        return existingFiles.contains(fullName);
+      }
+    };
+  }
+
+  public void testBuildExternalDirectoryPath() {
+    String expectedName = Environment.getExternalStorageDirectory()
+        + File.separator
+        + MyTracksConstants.SDCARD_TOP_DIR
+        + File.separator
+        + "a"
+        + File.separator
+        + "b"
+        + File.separator
+        + "c";
+
+    String dirName = fileUtils.buildExternalDirectoryPath("a", "b", "c");
+    assertEquals(expectedName, dirName);
+  }
+
+  public void testSanitizeName() {
+    assertEquals(SANITIZED_NAME, fileUtils.sanitizeName(ORIGINAL_NAME));
+  }
+
+  public void testBuildUniqueFileName_someExist() {
+    existingFiles = new HashSet<String>();
+    existingFiles.add("Filename.ext");
+    existingFiles.add("Filename (1).ext");
+    existingFiles.add("Filename (2).ext");
+    existingFiles.add("Filename (3).ext");
+    existingFiles.add("Filename (4).ext");
+
+    String filename = fileUtils.buildUniqueFileName(null, "Filename", "ext");
+    assertEquals("Filename (5).ext", filename);
+  }
+
+  public void testBuildUniqueFileName_oneExists() {
+    existingFiles.add("Filename.ext");
+
+    String filename = fileUtils.buildUniqueFileName(null, "Filename", "ext");
+    assertEquals("Filename (1).ext", filename);
+  }
+
+  public void testBuildUniqueFileName_noneExists() {
+    String filename = fileUtils.buildUniqueFileName(null, "Filename", "ext");
+    assertEquals("Filename.ext", filename);
+  }
+}

MyTracksTest/src/com/google/android/apps/mytracks/util/StringUtilsTest.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2010 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.util;
+
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for {@link StringUtils}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class StringUtilsTest extends TestCase {
+  public void testParseXmlDateTime() {
+    assertParseXmlDateTime("2010-05-04T03:02:01",
+        2010, 5, 4, 3, 2, 1, 0);
+  }
+
+  public void testParseXmlDateTime_fractional() {
+    assertParseXmlDateTime("2010-05-04T03:02:01.3",
+        2010, 5, 4, 3, 2, 1, 300);
+    assertParseXmlDateTime("2010-05-04T03:02:01.35",
+        2010, 5, 4, 3, 2, 1, 350);
+    assertParseXmlDateTime("2010-05-04T03:02:01.352",
+        2010, 5, 4, 3, 2, 1, 352);
+    assertParseXmlDateTime("2010-05-04T03:02:01.3525",
+        2010, 5, 4, 3, 2, 1, 352);
+  }
+
+  public void testParseXmlDateTime_timezone() {
+    assertParseXmlDateTime("2010-05-04T03:02:01Z",
+        2010, 5, 4, 3, 2, 1, 0);
+    assertParseXmlDateTime("2010-05-04T03:02:01+00:00",
+        2010, 5, 4, 3, 2, 1, 0);
+    assertParseXmlDateTime("2010-05-04T03:02:01-00:00",
+        2010, 5, 4, 3, 2, 1, 0);
+    assertParseXmlDateTime("2010-05-04T03:02:01+01:00",
+        2010, 5, 4, 2, 2, 1, 0);
+    assertParseXmlDateTime("2010-05-04T03:02:01+10:30",
+        2010, 5, 3, 16, 32, 1, 0);
+    assertParseXmlDateTime("2010-05-04T03:02:01-09:30",
+        2010, 5, 4, 12, 32, 1, 0);
+    assertParseXmlDateTime("2010-05-04T03:02:01-05:00",
+        2010, 5, 4, 8, 2, 1, 0);
+  }
+
+  public void testParseXmlDateTime_fractionalAndTimezone() {
+    assertParseXmlDateTime("2010-05-04T03:02:01.352Z",
+        2010, 5, 4, 3, 2, 1, 352);
+    assertParseXmlDateTime("2010-05-04T03:02:01.47+00:00",
+        2010, 5, 4, 3, 2, 1, 470);
+    assertParseXmlDateTime("2010-05-04T03:02:01.5791+03:00",
+        2010, 5, 4, 0, 2, 1, 579);
+    assertParseXmlDateTime("2010-05-04T03:02:01.8-05:30",
+        2010, 5, 4, 8, 32, 1, 800);
+  }
+
+  private void assertParseXmlDateTime(String dateTime,
+      int year, int month, int day, int hour, int min, int second, int millis) {
+    long timestamp = StringUtils.parseXmlDateTime(dateTime);
+    GregorianCalendar calendar =
+        new GregorianCalendar(TimeZone.getTimeZone("UTC"));
+    calendar.set(year, month - 1, day, hour, min, second);
+    calendar.set(GregorianCalendar.MILLISECOND, millis);
+    assertEquals(calendar.getTimeInMillis(), timestamp);
+  }
+}