Import kmz or kml tracks

2013-09-04 13:44:39 -07:00
commit e4f6be4938
1119 changed files with 74983 additions and 0 deletions
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.android.apps.mytracks.io.file;
+
+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.MyTracksProviderUtils.Factory;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.TracksColumns;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.content.WaypointsColumns;
+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.text.SimpleDateFormat;
+import java.util.Locale;
+import java.util.SimpleTimeZone;
+
+import org.easymock.Capture;
+
+/**
+ * Abstract class for testing file track importers.
+ * 
+ * @author Jimmy Shih.
+ */
+public class AbstractTestFileTrackImporter extends AndroidTestCase {
+
+  protected static final String TRACK_NAME_0 = "blablub";
+  protected static final String TRACK_DESCRIPTION_0 = "s'Laebe isch koi Schlotzer";
+
+  protected static final String TRACK_NAME_1 = "another track";
+  protected static final String TRACK_DESCRIPTION_1 = "another description";
+
+  protected static final double TRACK_LATITUDE = 48.768364;
+  protected static final double TRACK_LONGITUDE = 9.177886;
+  protected static final double TRACK_ELEVATION = 324.0;
+
+  protected static final String TRACK_TIME_0 = "2010-04-22T18:21:00Z";
+  protected static final String TRACK_TIME_1 = "2010-04-22T18:21:50.123";
+  protected static final String TRACK_TIME_2 = "2010-04-22T18:23:00.123";
+  protected static final String TRACK_TIME_3 = "2010-04-22T18:24:50.123";
+
+  protected static final SimpleDateFormat DATE_FORMAT_0 = new SimpleDateFormat(
+      "yyyy-MM-dd'T'hh:mm:ss'Z'", Locale.US);
+  protected static final SimpleDateFormat DATE_FORMAT_1 = new SimpleDateFormat(
+      "yyyy-MM-dd'T'HH:mm:ss.SSS", Locale.US);
+
+  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_FORMAT_0.setTimeZone(utc);
+    DATE_FORMAT_1.setTimeZone(utc);
+  }
+
+  protected static final long TRACK_ID_0 = 1;
+  protected static final long TRACK_ID_1 = 2;
+  protected static final long TRACK_POINT_ID_0 = 1;
+  protected static final long TRACK_POINT_ID_1 = 2;
+  protected static final long TRACK_POINT_ID_3 = 4;
+  protected static final long WAYPOINT_ID_0 = 1;
+
+  protected static final Uri TRACK_ID_0_URI = ContentUris.appendId(
+      TracksColumns.CONTENT_URI.buildUpon(), TRACK_ID_0).build();
+  protected static final Uri TRACK_ID_1_URI = ContentUris.appendId(
+      TracksColumns.CONTENT_URI.buildUpon(), TRACK_ID_1).build();
+  protected static final Uri WAYPOINT_ID_O_URI = ContentUris.appendId(
+      WaypointsColumns.CONTENT_URI.buildUpon(), WAYPOINT_ID_0).build();
+
+  protected MyTracksProviderUtils myTracksProviderUtils;
+
+  private Factory oldMyTracksProviderUtilsFactory;
+
+  @UsesMocks(MyTracksProviderUtils.class)
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    myTracksProviderUtils = AndroidMock.createMock(MyTracksProviderUtils.class);
+    oldMyTracksProviderUtilsFactory = TestingProviderUtilsFactory.installWithInstance(
+        myTracksProviderUtils);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    TestingProviderUtilsFactory.restoreOldFactory(oldMyTracksProviderUtilsFactory);
+    super.tearDown();
+  }
+  
+  protected Location createLocation(int index, long time) {
+    Location location = new Location(LocationManager.GPS_PROVIDER);
+    location.setLatitude(TRACK_LATITUDE + index);
+    location.setLongitude(TRACK_LONGITUDE + index);
+    location.setAltitude(TRACK_ELEVATION + index);
+    location.setTime(time);
+    return location;
+  }
+
+  /**
+   * Expects the first track point to be added.
+   * 
+   * @param location the location
+   * @param trackId the track id
+   * @param trackPointId the track point id
+   */
+  protected void expectFirstTrackPoint(Location location, long trackId, long trackPointId) {
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        location != null ? LocationsMatcher.eqLoc(location) : (Location[]) AndroidMock.anyObject(),
+        eq(1), eq(trackId))).andReturn(1);
+    expect(myTracksProviderUtils.getFirstTrackPointId(trackId)).andReturn(trackPointId);
+    expect(myTracksProviderUtils.getLastTrackPointId(trackId)).andReturn(trackPointId);
+  }
+
+  /**
+   * Expects the track to be updated.
+   * 
+   * @param track the track
+   * @param lastTrack true if it is the last track in the gpx
+   * @param trackId the track id
+   */
+  protected void expectUpdateTrack(Capture<Track> track, boolean lastTrack, long trackId) {
+    myTracksProviderUtils.updateTrack(AndroidMock.capture(track));
+    expect(myTracksProviderUtils.insertWaypoint((Waypoint) AndroidMock.anyObject()))
+        .andReturn(WAYPOINT_ID_O_URI);
+    if (lastTrack) {
+      // Return null to not add waypoints
+      expect(myTracksProviderUtils.getTrack(trackId)).andReturn(null);
+    }
+  }
+
+  protected void verifyTrack(Track track, String name, String description, long time) {
+    assertEquals(name, track.getName());
+    assertEquals(description, track.getDescription());
+    if (time != -1L) {
+      assertEquals(time, track.getTripStatistics().getStartTime());
+    }
+    assertNotSame(-1, track.getStartId());
+    assertNotSame(-1, track.getStopId());
+  }  
+}
@@ -0,0 +1,294 @@
+/*
+ * 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.file;
+
+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.Track;
+import com.google.android.testing.mocking.AndroidMock;
+
+import android.location.Location;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+
+import org.easymock.Capture;
+import org.xml.sax.SAXException;
+
+/**
+ * Tests for {@link GpxFileTrackImporter}.
+ * 
+ * @author Steffen Horlacher
+ */
+public class GpxFileTrackImporterTest extends AbstractTestFileTrackImporter {
+
+  private static String getNameAndDescription(String name, String description) {
+    return "<name><![CDATA[" + name + "]]></name>" + "<desc><![CDATA[" + description + "]]></desc>";
+  }
+
+  private static String getTrackPoint(int index, String time) {
+    String latitude = Double.toString(TRACK_LATITUDE + index);
+    String longitude = Double.toString(TRACK_LONGITUDE + index);
+    String elevation = Double.toString(TRACK_ELEVATION + index);
+    StringBuffer buffer = new StringBuffer();
+    buffer.append(
+        "<trkpt lat=\"" + latitude + "\" lon=\"" + longitude + "\"><ele>" + elevation + "</ele>");
+    if (time != null) {
+      buffer.append("<time>" + time + "</time>");
+    }
+    buffer.append("</trkpt>");
+    return buffer.toString();
+  }
+
+  private static final String VALID_ONE_TRACK_ONE_SEGMENT_GPX = "<gpx><trk>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<trkseg>"
+      + getTrackPoint(0, TRACK_TIME_0) + getTrackPoint(1, TRACK_TIME_1) + "</trkseg></trk></gpx>";
+  private static final String VALID_ONE_TRACK_TWO_SEGMENTS_GPX = "<gpx><trk>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<trkseg>"
+      + getTrackPoint(0, TRACK_TIME_0) + getTrackPoint(1, TRACK_TIME_1) + "</trkseg><trkseg>"
+      + getTrackPoint(2, TRACK_TIME_2) + getTrackPoint(3, TRACK_TIME_3) + "</trkseg></trk></gpx>";
+  private static final String VALID_ONE_TRACK_TWO_SEGMENTS_NO_TIME_GPX = "<gpx><trk>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<trkseg>"
+      + getTrackPoint(0, null) + getTrackPoint(1, null) + "</trkseg><trkseg>"
+      + getTrackPoint(2, null) + getTrackPoint(3, null) + "</trkseg></trk></gpx>";
+  private static final String VALID_TWO_TRACKS_GPX = "<gpx><trk>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<trkseg>"
+      + getTrackPoint(0, TRACK_TIME_0) + "</trkseg></trk><trk>"
+      + getNameAndDescription(TRACK_NAME_1, TRACK_DESCRIPTION_1) + "<trkseg>"
+      + getTrackPoint(1, TRACK_TIME_1) + "</trkseg></trk></gpx>";
+
+  private static final String INVALID_XML_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.substring(
+      0, VALID_ONE_TRACK_ONE_SEGMENT_GPX.length() - 50);
+  private static final String INVALID_LOCATION_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.replaceAll(
+      Double.toString(TRACK_LATITUDE), "1000.0");
+  private static final String INVALID_TIME_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.replaceAll(
+      TRACK_TIME_0, "invalid");
+  private static final String INVALID_ALTITUDE_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.replaceAll(
+      Double.toString(TRACK_ELEVATION), "invalid");
+  private static final String INVALID_LATITUDE_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.replaceAll(
+      Double.toString(TRACK_LATITUDE), "invalid");
+  private static final String INVALID_LONGITUDE_GPX = VALID_ONE_TRACK_ONE_SEGMENT_GPX.replaceAll(
+      Double.toString(TRACK_LONGITUDE), "invalid");
+
+  /**
+   * Tests one track with one segment.
+   */
+  public void testOneTrackOneSegment() throws Exception {
+    Capture<Track> track = new Capture<Track>();
+
+    Location location0 = createLocation(0, DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+    Location location1 = createLocation(1, DATE_FORMAT_1.parse(TRACK_TIME_1).getTime());
+
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+    expectFirstTrackPoint(location0, TRACK_ID_0, TRACK_POINT_ID_0);
+
+    // A flush happens at the end
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        LocationsMatcher.eqLoc(location1), eq(1), eq(TRACK_ID_0))).andReturn(1);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andReturn(TRACK_POINT_ID_1);
+
+    expectUpdateTrack(track, true, TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(VALID_ONE_TRACK_ONE_SEGMENT_GPX.getBytes());
+    GpxFileTrackImporter gpxFileTrackImporter = new GpxFileTrackImporter(
+        getContext(), myTracksProviderUtils);
+    long[] trackIds = gpxFileTrackImporter.importFile(inputStream);
+    assertEquals(1, trackIds.length);
+    assertEquals(TRACK_ID_0, trackIds[0]);
+
+    long time0 = DATE_FORMAT_0.parse(TRACK_TIME_0).getTime();
+    long time1 = DATE_FORMAT_1.parse(TRACK_TIME_1).getTime();
+    assertEquals(time1 - time0, track.getValue().getTripStatistics().getTotalTime());
+    AndroidMock.verify(myTracksProviderUtils);
+    verifyTrack(track.getValue(), TRACK_NAME_0, TRACK_DESCRIPTION_0, time0);
+  }
+
+  /**
+   * Tests one track with two segments.
+   */
+  public void testOneTrackTwoSegments() throws Exception {
+    Capture<Track> track = new Capture<Track>();
+
+    Location location0 = createLocation(0, DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+    expectFirstTrackPoint(location0, TRACK_ID_0, TRACK_POINT_ID_0);
+
+    // A flush happens at the end
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        (Location[]) AndroidMock.anyObject(), eq(5), eq(TRACK_ID_0))).andStubReturn(5);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andReturn(TRACK_POINT_ID_3);
+
+    expectUpdateTrack(track, true, TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(VALID_ONE_TRACK_TWO_SEGMENTS_GPX.getBytes());
+    GpxFileTrackImporter gpxFileTrackImporter = new GpxFileTrackImporter(
+        getContext(), myTracksProviderUtils);
+    long[] trackIds = gpxFileTrackImporter.importFile(inputStream);
+    assertEquals(1, trackIds.length);
+    assertEquals(TRACK_ID_0, trackIds[0]);
+
+    long time0 = DATE_FORMAT_0.parse(TRACK_TIME_0).getTime();
+    long time1 = DATE_FORMAT_1.parse(TRACK_TIME_1).getTime();
+    long time2 = DATE_FORMAT_1.parse(TRACK_TIME_2).getTime();
+    long time3 = DATE_FORMAT_1.parse(TRACK_TIME_3).getTime();
+    assertEquals(
+        time1 - time0 + time3 - time2, track.getValue().getTripStatistics().getTotalTime());
+
+    AndroidMock.verify(myTracksProviderUtils);
+    verifyTrack(track.getValue(), TRACK_NAME_0, TRACK_DESCRIPTION_0,
+        DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+  }
+
+  /**
+   * Tests one track with two segments, but no time in the track points.
+   */
+  public void testOneTrackTwoSegmentsNoTime() throws Exception {
+    Capture<Track> track = new Capture<Track>();
+
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+    expectFirstTrackPoint(null, TRACK_ID_0, TRACK_POINT_ID_0);
+
+    // A flush happens at the end
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        (Location[]) AndroidMock.anyObject(), eq(5), eq(TRACK_ID_0))).andStubReturn(5);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andReturn(TRACK_POINT_ID_3);
+
+    expectUpdateTrack(track, true, TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(
+        VALID_ONE_TRACK_TWO_SEGMENTS_NO_TIME_GPX.getBytes());
+    GpxFileTrackImporter gpxFileTrackImporter = new GpxFileTrackImporter(
+        getContext(), myTracksProviderUtils);
+    long[] trackIds = gpxFileTrackImporter.importFile(inputStream);
+    
+    assertEquals(1, trackIds.length);
+    assertEquals(TRACK_ID_0, trackIds[0]);
+
+    assertEquals(0, track.getValue().getTripStatistics().getTotalTime());
+
+    AndroidMock.verify(myTracksProviderUtils);
+    verifyTrack(track.getValue(), TRACK_NAME_0, TRACK_DESCRIPTION_0, -1L);
+  }
+
+  /**
+   * Tests two tracks.
+   */
+  public void testTwoTracks() throws Exception {
+    Capture<Track> track0 = new Capture<Track>();
+    Capture<Track> track1 = new Capture<Track>();
+
+    Location location0 = createLocation(0, DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+    Location location1 = createLocation(1, DATE_FORMAT_1.parse(TRACK_TIME_1).getTime());
+
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+    expectFirstTrackPoint(location0, TRACK_ID_0, TRACK_POINT_ID_0);
+    expectUpdateTrack(track0, false, TRACK_ID_0);
+
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_1_URI);
+    expectFirstTrackPoint(location1, TRACK_ID_1, TRACK_POINT_ID_1);
+    expectUpdateTrack(track1, true, TRACK_ID_1);
+
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(VALID_TWO_TRACKS_GPX.getBytes());
+    GpxFileTrackImporter gpxFileTrackImporter = new GpxFileTrackImporter(
+        getContext(), myTracksProviderUtils);
+    long[] trackIds = gpxFileTrackImporter.importFile(inputStream);
+    assertEquals(2, trackIds.length);
+    assertEquals(TRACK_ID_0, trackIds[0]);
+    assertEquals(TRACK_ID_1, trackIds[1]);
+
+    AndroidMock.verify(myTracksProviderUtils);
+  }
+
+  /**
+   * Test an invalid xml input.
+   */
+  public void testInvalidXml() throws Exception {
+    testInvalidGpx(INVALID_XML_GPX);
+  }
+
+  /**
+   * Test an invalid location.
+   */
+  public void testInvalidLocation() throws Exception {
+    testInvalidGpx(INVALID_LOCATION_GPX);
+  }
+
+  /**
+   * Test an invalid time.
+   */
+  public void testInvalidTime() throws Exception {
+    testInvalidGpx(INVALID_TIME_GPX);
+  }
+
+  /**
+   * Test an invalid altitude.
+   */
+  public void testInvalidAltitude() throws Exception {
+    testInvalidGpx(INVALID_ALTITUDE_GPX);
+  }
+
+  /**
+   * Test an invalid latitude.
+   */
+  public void testInvalidLatitude() throws Exception {
+    testInvalidGpx(INVALID_LATITUDE_GPX);
+  }
+
+  /**
+   * Test an invalid longitude.
+   */
+  public void testInvalidLongitude() throws Exception {
+    testInvalidGpx(INVALID_LONGITUDE_GPX);
+  }
+
+  private void testInvalidGpx(String xml) throws Exception {
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+
+    // For the following, use StubReturn since we don't care whether they are
+    // invoked or not.
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        (Location[]) AndroidMock.anyObject(), AndroidMock.anyInt(), AndroidMock.anyLong()))
+        .andStubReturn(1);
+    expect(myTracksProviderUtils.getFirstTrackPointId(TRACK_ID_0)).andStubReturn(TRACK_POINT_ID_0);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andStubReturn(TRACK_POINT_ID_0);
+    myTracksProviderUtils.deleteTrack(TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(xml.getBytes());
+    try {
+      GpxFileTrackImporter gpxFileTrackImporter = new GpxFileTrackImporter(
+          getContext(), myTracksProviderUtils);
+      gpxFileTrackImporter.importFile(inputStream);
+    } catch (SAXException e) {
+      // expected
+    }
+    AndroidMock.verify(myTracksProviderUtils);
+  }
+}
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.android.apps.mytracks.io.file;
+
+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.Track;
+import com.google.android.testing.mocking.AndroidMock;
+
+import android.location.Location;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+
+import org.easymock.Capture;
+
+/**
+ * Tests for {@link KmlFileTrackImporter}.
+ * 
+ * @author Jimmy Shih
+ */
+public class KmlFileTrackImporterTest extends AbstractTestFileTrackImporter {
+
+  private static String getNameAndDescription(String name, String description) {
+    return "<name><![CDATA[" + name + "]]></name><description><![CDATA[" + description
+        + "]]></description>";
+  }
+
+  private static String getTrackPoint(int index, String time) {
+    String latitude = Double.toString(TRACK_LATITUDE + index);
+    String longitude = Double.toString(TRACK_LONGITUDE + index);
+    String altitude = Double.toString(TRACK_ELEVATION + index);
+    StringBuffer buffer = new StringBuffer();
+    buffer.append("<when>" + time + "</when>" + "<gx:coord>" + longitude + " " + latitude + " "
+        + altitude + "</gx:coord>");
+    return buffer.toString();
+  }
+
+  private static final String VALID_ONE_TRACK_ONE_SEGMENT_GPX =
+      "<kml xmlns:gx=\"http://www.google.com/kml/ext/2.2\"><Placemark>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<gx:MultiTrack><gx:Track>"
+      + getTrackPoint(0, TRACK_TIME_0) + getTrackPoint(1, TRACK_TIME_1)
+      + "</gx:Track></gx:MultiTrack></Placemark></kml>";
+  private static final String VALID_ONE_TRACK_TWO_SEGMENTS_GPX =
+      "<kml xmlns:gx=\"http://www.google.com/kml/ext/2.2\"><Placemark>"
+      + getNameAndDescription(TRACK_NAME_0, TRACK_DESCRIPTION_0) + "<gx:MultiTrack><gx:Track>"
+      + getTrackPoint(0, TRACK_TIME_0) + getTrackPoint(1, TRACK_TIME_1) + "</gx:Track><gx:Track>"
+      + getTrackPoint(2, TRACK_TIME_2) + getTrackPoint(3, TRACK_TIME_3)
+      + "</gx:Track></gx:MultiTrack></Placemark></kml>";
+
+  /**
+   * Tests one track with one segment.
+   */
+  public void testOneTrackOneSegment() throws Exception {
+    Capture<Track> track = new Capture<Track>();
+
+    Location location0 = createLocation(0, DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+    Location location1 = createLocation(1, DATE_FORMAT_1.parse(TRACK_TIME_1).getTime());
+
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+    expectFirstTrackPoint(location0, TRACK_ID_0, TRACK_POINT_ID_0);
+
+    // A flush happens at the end
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        LocationsMatcher.eqLoc(location1), eq(1), eq(TRACK_ID_0))).andReturn(1);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andReturn(TRACK_POINT_ID_1);
+
+    expectUpdateTrack(track, true, TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(VALID_ONE_TRACK_ONE_SEGMENT_GPX.getBytes());
+    KmlFileTrackImporter kmlFileTrackImporter = new KmlFileTrackImporter(
+        getContext(), -1L, null, myTracksProviderUtils);
+    long[] trackIds = kmlFileTrackImporter.importFile(inputStream);
+    assertEquals(1, trackIds.length);
+    assertEquals(TRACK_ID_0, trackIds[0]);
+
+    long time0 = DATE_FORMAT_0.parse(TRACK_TIME_0).getTime();
+    long time1 = DATE_FORMAT_1.parse(TRACK_TIME_1).getTime();
+    assertEquals(time1 - time0, track.getValue().getTripStatistics().getTotalTime());
+    AndroidMock.verify(myTracksProviderUtils);
+    verifyTrack(track.getValue(), TRACK_NAME_0, TRACK_DESCRIPTION_0, time0);
+  }
+
+  /**
+   * Tests one track with two segments.
+   */
+  public void testOneTrackTwoSegments() throws Exception {
+    Capture<Track> track = new Capture<Track>();
+
+    Location location0 = createLocation(0, DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+
+    expect(myTracksProviderUtils.insertTrack((Track) AndroidMock.anyObject()))
+        .andReturn(TRACK_ID_0_URI);
+    expectFirstTrackPoint(location0, TRACK_ID_0, TRACK_POINT_ID_0);
+
+    // A flush happens at the end
+    expect(myTracksProviderUtils.bulkInsertTrackPoint(
+        (Location[]) AndroidMock.anyObject(), eq(5), eq(TRACK_ID_0))).andStubReturn(5);
+    expect(myTracksProviderUtils.getLastTrackPointId(TRACK_ID_0)).andReturn(TRACK_POINT_ID_3);
+
+    expectUpdateTrack(track, true, TRACK_ID_0);
+    AndroidMock.replay(myTracksProviderUtils);
+
+    InputStream inputStream = new ByteArrayInputStream(VALID_ONE_TRACK_TWO_SEGMENTS_GPX.getBytes());
+    KmlFileTrackImporter kmlFileTrackImporter = new KmlFileTrackImporter(
+        getContext(), -1L, null, myTracksProviderUtils);
+    long[] trackIds = kmlFileTrackImporter.importFile(inputStream);
+    assertEquals(1, trackIds.length);
+    assertEquals(TRACK_ID_0, trackIds[0]);
+
+    long time0 = DATE_FORMAT_0.parse(TRACK_TIME_0).getTime();
+    long time1 = DATE_FORMAT_1.parse(TRACK_TIME_1).getTime();
+    long time2 = DATE_FORMAT_1.parse(TRACK_TIME_2).getTime();
+    long time3 = DATE_FORMAT_1.parse(TRACK_TIME_3).getTime();
+    assertEquals(
+        time1 - time0 + time3 - time2, track.getValue().getTripStatistics().getTotalTime());
+
+    AndroidMock.verify(myTracksProviderUtils);
+    verifyTrack(track.getValue(), TRACK_NAME_0, TRACK_DESCRIPTION_0,
+        DATE_FORMAT_0.parse(TRACK_TIME_0).getTime());
+  }
+}
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.android.apps.mytracks.io.file;
+
+import com.google.android.testing.mocking.AndroidMock;
+
+import android.location.Location;
+
+import java.util.Arrays;
+
+import org.easymock.IArgumentMatcher;
+
+/**
+ * Locations matcher. Workaround because of capture bug 2617107 in easymock:
+ * http://sourceforge.net/tracker/?func=detail&aid=2617107&group_id=82958&atid=567837
+ * 
+ * @author Jimmy Shih
+ */
+public class LocationsMatcher implements IArgumentMatcher {
+
+  public static Location[] eqLoc(Location expected) {
+    return eqLoc(new Location[] { expected });
+  }
+
+  public static Location[] eqLoc(Location[] expected) {
+    IArgumentMatcher matcher = new LocationsMatcher(expected);
+    AndroidMock.reportMatcher(matcher);
+    return null;
+  }
+
+  private final Location[] expectedLocations;
+
+  private LocationsMatcher(Location[] expected) {
+    this.expectedLocations = expected;
+  }
+
+  @Override
+  public void appendTo(StringBuffer buf) {
+    buf.append("eqLoc(").append(Arrays.toString(expectedLocations)).append(")");
+  }
+
+  @Override
+  public boolean matches(Object obj) {
+    if (!(obj instanceof Location[])) {
+      return false;
+    }
+    Location[] locations = (Location[]) obj;
+    if (locations.length < expectedLocations.length) {
+      return false;
+    }
+
+    // Only check the first elements (those that will be taken into account)
+    for (int i = 0; i < expectedLocations.length; i++) {
+      if (!matchLocation(locations[i], expectedLocations[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private boolean matchLocation(Location location1, Location location2) {
+    return (location1.getTime() == location2.getTime())
+        && (location1.getLatitude() == location2.getLatitude())
+        && (location1.getLongitude() == location2.getLongitude())
+        && (location1.getAltitude() == location2.getAltitude());
+  }
+}
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.android.apps.mytracks.io.file.export;
+
+import com.google.android.apps.mytracks.io.file.export.CsvTrackWriter;
+
+
+/**
+ * Tests for {@link CsvTrackWriter}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class CsvTrackWriterTest extends TrackWriterTest {
+
+  private static final String BEGIN_TAG = "\"";
+  private static final String END_TAG = "\"\n";
+  private static final String SEPARATOR = "\",\"";
+
+  public void testCsvOutput() throws Exception {
+    String expectedTrackHeader = getExpectedLine(
+        "Name", "Activity type", "Description");
+    String expectedTrack = getExpectedLine(TRACK_NAME, TRACK_CATEGORY, TRACK_DESCRIPTION);
+    String expectedMarkerHeader = getExpectedLine("Name",
+        "Marker type",
+        "Description",
+        "Latitude (deg)",
+        "Longitude (deg)",
+        "Altitude (m)",
+        "Bearing (deg)",
+        "Accuracy (m)",
+        "Speed (m/s)",
+        "Time");
+    String expectedMarker1 = getExpectedLine(WAYPOINT1_NAME, WAYPOINT1_CATEGORY,
+        WAYPOINT1_DESCRIPTION, "1.0", "-1.0", "10.0", "100.0", "1,000", "10,000",
+        "1970-01-01T00:01:40.000Z");
+    String expectedMarker2 = getExpectedLine(WAYPOINT2_NAME, WAYPOINT2_CATEGORY,
+        WAYPOINT2_DESCRIPTION, "2.0", "-2.0", "20.0", "200.0", "2,000", "20,000",
+        "1970-01-01T00:03:20.000Z");
+    String expectedPointHeader = getExpectedLine("Segment", "Point", "Latitude (deg)",
+        "Longitude (deg)", "Altitude (m)", "Bearing (deg)", "Accuracy (m)", "Speed (m/s)", "Time",
+        "Power (W)", "Cadence (rpm)", "Heart rate (bpm)");
+    String expectedPoint1 = getExpectedLine("1", "1", "0.0", "0.0", "0.0", "0.0", "0", "0",
+        "1970-01-01T00:00:00.000Z", "100.0", "200.0", "300.0");
+    String expectedPoint2 = getExpectedLine("1", "2", "1.0", "-1.0", "10.0", "100.0", "1,000",
+        "10,000", "1970-01-01T00:01:40.000Z", "101.0", "201.0", "301.0");
+    String expectedPoint3 = getExpectedLine("2", "1", "2.0", "-2.0", "20.0", "200.0", "2,000",
+        "20,000", "1970-01-01T00:03:20.000Z", "102.0", "202.0", "302.0");
+    String expectedPoint4 = getExpectedLine("2", "2", "3.0", "-3.0", "30.0", "300.0", "3,000",
+        "30,000", "1970-01-01T00:05:00.000Z", "103.0", "203.0", "303.0");
+    String expected = expectedTrackHeader + expectedTrack + "\n" 
+        + expectedMarkerHeader + expectedMarker1 + expectedMarker2 + "\n"
+        + expectedPointHeader + expectedPoint1 + expectedPoint2 + expectedPoint3 + expectedPoint4;
+
+    CsvTrackWriter csvTrackWriter = new CsvTrackWriter(getContext());
+    assertEquals(expected, writeTrack(csvTrackWriter));
+  }
+
+  /**
+   * Gets the expected CSV line from a list of expected values.
+   * 
+   * @param values expected values
+   */
+  private String getExpectedLine(String... values) {
+    StringBuilder builder = new StringBuilder();
+    builder.append(BEGIN_TAG);
+    boolean first = true;
+    for (String value : values) {
+      if (!first) {
+        builder.append(SEPARATOR);
+      }
+      first = false;
+      builder.append(value);
+    }
+    builder.append(END_TAG);
+    return builder.toString();
+  }
+}
@@ -0,0 +1,310 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+
+package com.google.android.apps.mytracks.io.file.export;
+
+import com.google.android.apps.mytracks.content.MyTracksProvider;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils;
+import com.google.android.apps.mytracks.content.MyTracksProviderUtils.Factory;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+import com.google.android.apps.mytracks.io.file.export.FileTrackExporter;
+import com.google.android.apps.mytracks.io.file.export.TrackExporterListener;
+import com.google.android.apps.mytracks.io.file.export.TrackWriter;
+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.OutputStream;
+
+import org.easymock.EasyMock;
+import org.easymock.IArgumentMatcher;
+import org.easymock.IMocksControl;
+
+/**
+ * Tests for {@link FileTrackExporter}.
+ * 
+ * @author Rodrigo Damazio
+ */
+public class FileTrackExporterTest extends AndroidTestCase {
+
+  private static final long TRACK_ID = 1234567L;
+  private static final String TRACK_NAME = "Swimming across the pacific";
+
+  private MyTracksProviderUtils myTracksProviderUtils;
+  private Factory oldProviderUtilsFactory;
+
+  private IMocksControl mocksControl;
+
+  private TrackWriter trackWriter;
+  private Track track;
+  private OutputStream outputStream;
+  private FileTrackExporter fileTrackExporter;
+
+  @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 myTracksProvider = new MyTracksProvider();
+    myTracksProvider.attachInfo(context, null);
+    mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, myTracksProvider);
+    setContext(context);
+    myTracksProviderUtils = MyTracksProviderUtils.Factory.get(context);
+    oldProviderUtilsFactory = TestingProviderUtilsFactory.installWithInstance(
+        myTracksProviderUtils);
+
+    mocksControl = EasyMock.createStrictControl();
+    trackWriter = mocksControl.createMock(TrackWriter.class);
+
+    track = new Track();
+    track.setName(TRACK_NAME);
+    track.setId(TRACK_ID);
+
+    outputStream = new ByteArrayOutputStream();
+    TrackExporterListener trackExporterListener = new TrackExporterListener() {
+      
+        @Override
+      public void onProgressUpdate(int number, int max) {
+        // Safe to ignore
+
+      }
+    };
+    fileTrackExporter = new FileTrackExporter(
+        myTracksProviderUtils, new Track[] { track }, trackWriter, trackExporterListener);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    TestingProviderUtilsFactory.restoreOldFactory(oldProviderUtilsFactory);
+    super.tearDown();
+  }
+
+  /**
+   * Tests write track with an empty track.
+   */
+  public void testWriteTrack_emptyTrack() throws Exception {
+
+    // Set expected mock behavior
+    trackWriter.prepare(outputStream);
+    trackWriter.writeHeader(track);
+    trackWriter.writeBeginTrack(track, null);
+    trackWriter.writeEndTrack(track, null);
+    trackWriter.writeFooter();
+ 
+    mocksControl.replay();
+    fileTrackExporter.writeTrack(outputStream);
+
+    assertTrue(fileTrackExporter.isSuccess());
+    mocksControl.verify();
+  }
+
+  /**
+   * Tests write track with invalid locations. Make sure an empty track is
+   * written.
+   */
+  public void testWriteTrack_oneInvalidLocation() throws Exception {
+
+    // Add two locations
+    Location[] locations = { new Location("fake0"), new Location("fake1") };
+    fillLocations(locations);
+
+    // Make locations invalid
+    locations[0].setLatitude(100.0);
+    locations[1].setLatitude(100.0);
+
+    assertEquals(locations.length,
+        myTracksProviderUtils.bulkInsertTrackPoint(locations, locations.length, TRACK_ID));
+
+    // Set expected mock behavior
+    trackWriter.prepare(outputStream);
+    trackWriter.writeHeader(track);
+    trackWriter.writeBeginTrack(track, null);
+    trackWriter.writeEndTrack(track, null);
+    trackWriter.writeFooter();
+
+    mocksControl.replay();
+    fileTrackExporter.writeTrack(outputStream);
+
+    assertTrue(fileTrackExporter.isSuccess());
+    mocksControl.verify();
+  }
+
+  /**
+   * Tests write track.
+   */
+  public void testWriteTrack() throws Exception {
+
+    // Add six locations
+    Location[] locations = { new Location("fake0"), new Location("fake1"), new Location("fake2"),
+        new Location("fake3"), new Location("fake4"), new Location("fake5") };
+    fillLocations(locations);
+
+    // Make location 3 invalid
+    locations[2].setLatitude(100.0);
+
+    assertEquals(locations.length,
+        myTracksProviderUtils.bulkInsertTrackPoint(locations, locations.length, TRACK_ID));
+
+    Waypoint[] waypoints = { new Waypoint(), new Waypoint(), new Waypoint() };
+
+    for (int i = 0; i < waypoints.length; i++) {
+      Waypoint waypoint = waypoints[i];
+      waypoint.setTrackId(TRACK_ID);
+      assertNotNull(myTracksProviderUtils.insertWaypoint(waypoint));
+      waypoint.setId(i + 1);
+    }
+
+    trackWriter.prepare(outputStream);
+    trackWriter.writeHeader(track);
+
+    // Expect reading/writing of the waypoints (except the first)
+    trackWriter.writeBeginWaypoints();
+    trackWriter.writeWaypoint(waypointEq(waypoints[1]));
+    trackWriter.writeWaypoint(waypointEq(waypoints[2]));
+    trackWriter.writeEndWaypoints();
+
+    // Begin the track
+    trackWriter.writeBeginTrack(trackEq(track), locationEq(locations[0]));
+
+    // Write locations 1-2
+    trackWriter.writeOpenSegment();
+    trackWriter.writeLocation(locationEq(locations[0]));
+    trackWriter.writeLocation(locationEq(locations[1]));
+    trackWriter.writeCloseSegment();
+
+    // Location 3 is not written - it's invalid
+
+    // Write locations 4-6
+    trackWriter.writeOpenSegment();
+    trackWriter.writeLocation(locationEq(locations[3]));
+    trackWriter.writeLocation(locationEq(locations[4]));
+    trackWriter.writeLocation(locationEq(locations[5]));
+    trackWriter.writeCloseSegment();
+
+    // End the track
+    trackWriter.writeEndTrack(trackEq(track), locationEq(locations[5]));
+
+    trackWriter.writeFooter();
+
+    mocksControl.replay();
+    fileTrackExporter.writeTrack(outputStream);
+
+    assertTrue(fileTrackExporter.isSuccess());
+    mocksControl.verify();
+  }
+
+  /**
+   * Waypoint equals.
+   * 
+   * @param waypoint the waypoint
+   */
+  private Waypoint waypointEq(final Waypoint waypoint) {
+    EasyMock.reportMatcher(new IArgumentMatcher() {
+        @Override
+      public boolean matches(Object object) {
+        if (object == null || waypoint == null) {
+          return waypoint == object;
+        }
+        Waypoint waypoint2 = (Waypoint) object;
+
+        return waypoint.getId() == waypoint2.getId();
+      }
+
+        @Override
+      public void appendTo(StringBuffer buffer) {
+        buffer.append("waypointEq(");
+        buffer.append(waypoint);
+        buffer.append(")");
+      }
+    });
+    return null;
+  }
+
+  /**
+   * Location equals.
+   *  
+   * @param location the location
+   */
+  private Location locationEq(final Location location) {
+    EasyMock.reportMatcher(new IArgumentMatcher() {
+        @Override
+      public boolean matches(Object object) {
+        if (object == null || location == null) {
+          return location == object;
+        }
+        Location location2 = (Location) object;
+
+        return location.hasAccuracy() == location2.hasAccuracy()
+            && (!location.hasAccuracy() || location.getAccuracy() == location2.getAccuracy())
+            && location.hasAltitude() == location2.hasAltitude()
+            && (!location.hasAltitude() || location.getAltitude() == location2.getAltitude())
+            && location.hasBearing() == location2.hasBearing()
+            && (!location.hasBearing() || location.getBearing() == location2.getBearing())
+            && location.hasSpeed() == location2.hasSpeed()
+            && (!location.hasSpeed() || location.getSpeed() == location2.getSpeed())
+            && location.getLatitude() == location2.getLatitude()
+            && location.getLongitude() == location2.getLongitude()
+            && location.getTime() == location2.getTime();
+      }
+
+        @Override
+      public void appendTo(StringBuffer buffer) {
+        buffer.append("locationEq(");
+        buffer.append(location);
+        buffer.append(")");
+      }
+    });
+    return null;
+  }
+
+  /**
+   * Track equals.
+   * 
+   * @param track1 the track
+   */
+  private Track trackEq(final Track track1) {
+    EasyMock.reportMatcher(new IArgumentMatcher() {
+        @Override
+      public boolean matches(Object object) {
+        if (object == null || track1 == null) {
+          return track1 == object;
+        }
+        Track track2 = (Track) object;
+
+        return track1.getName().equals(track2.getName());
+      }
+
+        @Override
+      public void appendTo(StringBuffer buffer) {
+        buffer.append("trackEq(");
+        buffer.append(track1);
+        buffer.append(")");
+      }
+    });
+    return null;
+  }
+
+  /**
+   * Fills the locations.
+   * 
+   * @param locations the locations
+   */
+  private void fillLocations(Location... locations) {
+    assertTrue(locations.length < 90);
+    for (int i = 0; i < locations.length; i++) {
+      Location location = locations[i];
+      location.setLatitude(i + 1);
+      location.setLongitude(i + 1);
+      location.setTime(i + 1000);
+    }
+  }
+}
@@ -0,0 +1,78 @@
+/*
+ * 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.file.export;
+
+import com.google.android.apps.mytracks.io.file.export.GpxTrackWriter;
+
+import java.util.List;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * Tests for {@link GpxTrackWriter}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class GpxTrackWriterTest extends TrackWriterTest {
+
+  public void testXmlOutput() throws Exception {
+    GpxTrackWriter gpxTrackWriter = new GpxTrackWriter(getContext());
+    String result = writeTrack(gpxTrackWriter);
+    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"));
+    List<Element> segmentTags = getChildElements(trackTag, "trkseg", 2);
+    List<Element> segPointTags = getChildElements(segmentTags.get(0), "trkpt", 2);
+    assertTagMatchesLocation(segPointTags.get(0), "0", "0", "1970-01-01T00:00:00.000Z", "0");
+    assertTagMatchesLocation(segPointTags.get(1), "1", "-1", "1970-01-01T00:01:40.000Z", "10");
+
+    segPointTags = getChildElements(segmentTags.get(1), "trkpt", 2);
+    assertTagMatchesLocation(segPointTags.get(0), "2", "-2", "1970-01-01T00:03:20.000Z", "20");
+    assertTagMatchesLocation(segPointTags.get(1), "3", "-3", "1970-01-01T00:05:00.000Z", "30");
+
+    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-01T00:01:40.000Z", "10");
+
+    wptTag = waypointTags.get(1);
+    assertEquals(WAYPOINT2_NAME, getChildTextValue(wptTag, "name"));
+    assertEquals(WAYPOINT2_DESCRIPTION, getChildTextValue(wptTag, "desc"));
+    assertTagMatchesLocation(wptTag, "2", "-2", "1970-01-01T00:03:20.000Z", "20");
+  }
+
+  /**
+   * Asserts that the given tag describes a location.
+   *
+   * @param tag the tag
+   * @param latitude the location's latitude
+   * @param longitude the location's longitude
+   * @param time the location's time
+   * @param elevation the location's elevation
+   */
+  private void assertTagMatchesLocation(
+      Element tag, String latitude, String longitude, String time, String elevation) {
+    assertEquals(latitude, tag.getAttribute("lat"));
+    assertEquals(longitude, tag.getAttribute("lon"));
+    assertEquals(time, getChildTextValue(tag, "time"));
+    assertEquals(elevation, getChildTextValue(tag, "ele"));
+  }
+}
@@ -0,0 +1,128 @@
+/*
+ * 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.file.export;
+
+import com.google.android.apps.mytracks.content.DescriptionGenerator;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.io.file.export.KmlTrackWriter;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+
+import android.location.Location;
+
+import java.util.List;
+import java.util.Vector;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * Tests for {@link KmlTrackWriter}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class KmlTrackWriterTest extends TrackWriterTest {
+
+  private static final String FULL_TRACK_DESCRIPTION = "full track description";
+
+  /**
+   * A fake version of {@link DescriptionGenerator} which returns a fixed track
+   * description, thus not depending on the context.
+   */
+  private class FakeDescriptionGenerator implements DescriptionGenerator {
+    @Override
+    public String generateTrackDescription(
+        Track aTrack, Vector<Double> distances, Vector<Double> elevations, boolean html) {
+      return FULL_TRACK_DESCRIPTION;
+    }
+
+    @Override
+    public String generateWaypointDescription(TripStatistics tripStatistics) {
+      return null;
+    }
+  }
+
+  public void testXmlOutput() throws Exception {
+    KmlTrackWriter kmlTrackWriter = new KmlTrackWriter(
+        getContext(), false, new FakeDescriptionGenerator());
+    String result = writeTrack(kmlTrackWriter);
+    Document doc = parseXmlDocument(result);
+
+    Element kmlTag = getChildElement(doc, "kml");
+    Element docTag = getChildElement(kmlTag, "Document");
+    assertEquals(TRACK_NAME, getChildTextValue(docTag, "name"));
+
+    // There are 3 placemarks - start, track, and end
+    List<Element> placemarkTags = getChildElements(docTag, "Placemark", 3);
+    assertTagIsPlacemark(
+        placemarkTags.get(0), TRACK_NAME + " (Start)", "", location1);
+    assertTagIsPlacemark(
+        placemarkTags.get(2), TRACK_NAME + " (End)", FULL_TRACK_DESCRIPTION, location4);
+
+    List<Element> folderTag = getChildElements(docTag, "Folder", 1);
+    List<Element> folderPlacemarkTags = getChildElements(folderTag.get(0), "Placemark", 2);
+    assertTagIsPlacemark(
+        folderPlacemarkTags.get(0), WAYPOINT1_NAME, WAYPOINT1_DESCRIPTION, location2);
+    assertTagIsPlacemark(
+        folderPlacemarkTags.get(1), WAYPOINT2_NAME, WAYPOINT2_DESCRIPTION, location3);
+
+    Element trackPlacemarkTag = placemarkTags.get(1);
+    assertEquals(TRACK_NAME, getChildTextValue(trackPlacemarkTag, "name"));
+    assertEquals(TRACK_DESCRIPTION, getChildTextValue(trackPlacemarkTag, "description"));
+    Element multiTrackTag = getChildElement(trackPlacemarkTag, "gx:MultiTrack");
+    List<Element> trackTags = getChildElements(multiTrackTag, "gx:Track", 2);
+    assertTagHasPoints(trackTags.get(0), location1, location2);
+    assertTagHasPoints(trackTags.get(1), location3, location4);
+  }
+
+  /**
+   * Asserts that the given tag is a placemark with the given properties.
+   *
+   * @param tag the tag
+   * @param name the expected placemark name
+   * @param description the expected placemark description
+   * @param location the expected placemark location
+   */
+  private void assertTagIsPlacemark(
+      Element tag, String name, String description, Location location) {
+    assertEquals(name, getChildTextValue(tag, "name"));
+    if (description != null && !description.equals("")) {
+      assertEquals(description, getChildTextValue(tag, "description"));
+    }
+    Element pointTag = getChildElement(tag, "Point");
+    String expected = location.getLongitude() + "," + location.getLatitude() + ","
+        + location.getAltitude();
+    String actual = getChildTextValue(pointTag, "coordinates");
+    assertEquals(expected, actual);
+  }
+
+  /**
+   * Asserts that the given tag has a list of "gx:coord" subtags matching the
+   * expected locations.
+   *
+   * @param tag the parent tag
+   * @param locations list of expected locations
+   */
+  private void assertTagHasPoints(Element tag, Location... locations) {
+    List<Element> coordTags = getChildElements(tag, "gx:coord", locations.length);
+    for (int i = 0; i < locations.length; i++) {
+      Location location = locations[i];
+      String expected = location.getLongitude() + " " + location.getLatitude() + " "
+          + location.getAltitude();
+      String actual = coordTags.get(i).getFirstChild().getTextContent();
+      assertEquals(expected, actual);
+    }
+  }
+}
@@ -0,0 +1,97 @@
+/*
+ * 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.file.export;
+
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.Sensor;
+import com.google.android.apps.mytracks.io.file.export.TcxTrackWriter;
+import com.google.android.apps.mytracks.util.StringUtils;
+
+import java.util.List;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * Tests for {@link TcxTrackWriter}.
+ *
+ * @author Sandor Dornbush
+ */
+public class TcxTrackWriterTest extends TrackWriterTest {
+
+  public void testXmlOutput() throws Exception {
+    TcxTrackWriter tcxTrackWriter = new TcxTrackWriter(getContext());
+    String result = writeTrack(tcxTrackWriter);
+    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 locations in the same order.
+   *
+   * @param tags list of tags
+   * @param locations list of locations
+   */
+  private void assertTagsMatchPoints(List<Element> tags, MyTracksLocation... locations) {
+    assertEquals(locations.length, tags.size());
+    for (int i = 0; i < locations.length; i++) {
+      assertTagMatchesLocation(tags.get(i), locations[i]);
+    }
+  }
+
+  /**
+   * Asserts that the given tag describes the given location.
+   *
+   * @param tag the tag
+   * @param location the location
+   */
+  private void assertTagMatchesLocation(Element tag, MyTracksLocation location) {
+    assertEquals(StringUtils.formatDateTimeIso8601(location.getTime()), getChildTextValue(tag, "Time"));
+
+    Element positionTag = getChildElement(tag, "Position");
+    assertEquals(
+        Double.toString(location.getLatitude()), getChildTextValue(positionTag, "LatitudeDegrees"));
+    assertEquals(Double.toString(location.getLongitude()),
+        getChildTextValue(positionTag, "LongitudeDegrees"));
+
+    assertEquals(Double.toString(location.getAltitude()), getChildTextValue(tag, "AltitudeMeters"));
+    assertTrue(location.getSensorDataSet() != null);
+    Sensor.SensorDataSet sds = location.getSensorDataSet();
+
+    List<Element> heartRate = getChildElements(tag, "HeartRateBpm", 1);
+    assertEquals(Integer.toString(sds.getHeartRate().getValue()),
+        getChildTextValue(heartRate.get(0), "Value"));
+
+    List<Element> extensions = getChildElements(tag, "Extensions", 1);
+    List<Element> tpx = getChildElements(extensions.get(0), "TPX", 1);
+    assertEquals(
+        Integer.toString(sds.getCadence().getValue()), getChildTextValue(tpx.get(0), "RunCadence"));
+    assertEquals(
+        Integer.toString(sds.getPower().getValue()), getChildTextValue(tpx.get(0), "Watts"));
+  }
+}
@@ -0,0 +1,217 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+package com.google.android.apps.mytracks.io.file.export;
+
+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 com.google.android.apps.mytracks.io.file.export.TrackWriter;
+
+import android.test.AndroidTestCase;
+
+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;
+
+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;
+
+/**
+ * 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 TrackWriterTest 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_CATEGORY = "Hiking";
+  protected static final String TRACK_DESCRIPTION = "The long ]]> journey home";
+  protected static final String WAYPOINT1_NAME = "point]]>1";
+  protected static final String WAYPOINT1_CATEGORY = "Statistics";
+  protected static final String WAYPOINT1_DESCRIPTION = "point 1]]>description";
+  protected static final String WAYPOINT2_NAME = "point]]>2";
+  protected static final String WAYPOINT2_CATEGORY = "Waypoint";
+  protected static final String WAYPOINT2_DESCRIPTION = "point 2]]>description";
+  private static final int BUFFER_SIZE = 10240;
+  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.setName(TRACK_NAME);
+    track.setCategory(TRACK_CATEGORY);
+    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.setCategory(WAYPOINT1_CATEGORY);
+    wp1.setDescription(WAYPOINT1_DESCRIPTION);
+    wp2.setLocation(location3);
+    wp2.setName(WAYPOINT2_NAME);
+    wp2.setCategory(WAYPOINT2_CATEGORY);
+    wp2.setDescription(WAYPOINT2_DESCRIPTION);
+  }
+
+  /**
+   * Populates a list of locations with values.
+   *
+   * @param locations a list of locations
+   */
+  private void populateLocations(MyTracksLocation... locations) {
+    for (int i = 0; i < locations.length; i++) {
+      MyTracksLocation location = locations[i];
+      location.setLatitude(i);
+      location.setLongitude(-i);
+      location.setAltitude(i * 10);
+      location.setBearing(i * 100);
+      location.setAccuracy(i * 1000);
+      location.setSpeed(i * 10000);
+      location.setTime(i * 100000);
+      Sensor.SensorData.Builder power = Sensor.SensorData.newBuilder().setValue(100 + i)
+          .setState(Sensor.SensorState.SENDING);
+      Sensor.SensorData.Builder cadence = Sensor.SensorData.newBuilder().setValue(200 + i)
+          .setState(Sensor.SensorState.SENDING);
+      Sensor.SensorData.Builder heartRate = Sensor.SensorData.newBuilder().setValue(300 + i)
+          .setState(Sensor.SensorState.SENDING);     
+      Sensor.SensorDataSet sensorDataSet = Sensor.SensorDataSet.newBuilder().setPower(power)
+          .setCadence(cadence).setHeartRate(heartRate).build();
+      location.setSensorDataSet(sensorDataSet);
+    }
+  }
+
+  /**
+   * Makes the right sequence of calls to the writer in order to write the fake
+   * track in {@link #track}.
+   *
+   * @param trackWriter the track writer
+   * @return the written contents
+   */
+  protected String writeTrack(TrackWriter trackWriter) throws Exception {
+    OutputStream output = new ByteArrayOutputStream(BUFFER_SIZE);
+    trackWriter.prepare(output);
+    trackWriter.writeHeader(track);
+    trackWriter.writeBeginWaypoints();
+    trackWriter.writeWaypoint(wp1);
+    trackWriter.writeWaypoint(wp2);
+    trackWriter.writeEndWaypoints();
+    trackWriter.writeBeginTrack(track, location1);
+    trackWriter.writeOpenSegment();
+    trackWriter.writeLocation(location1);
+    trackWriter.writeLocation(location2);
+    trackWriter.writeCloseSegment();
+    trackWriter.writeOpenSegment();
+    trackWriter.writeLocation(location3);
+    trackWriter.writeLocation(location4);
+    trackWriter.writeCloseSegment();
+    trackWriter.writeEndTrack(track, location4);
+    trackWriter.writeFooter();
+    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;
+  }
+}