Fix the run time error in UploadResultActivityTest and add some assertions. Remove a sysout statement in CreateAndSendTrackTest.

2012-06-08 11:55:28 +08:00
commit 20641c694f
639 changed files with 65306 additions and 0 deletions
@@ -0,0 +1,267 @@
+/*
+ * 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());
+
+    // 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);
+  }
+}
@@ -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));
+  }
+}
@@ -0,0 +1,211 @@
+/*
+ * 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 java.util.Set;
+
+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() {
+      apply();
+      return true;
+    }
+
+    @Override
+    public void apply() {
+      preferenceValues = newPreferences;
+    }
+
+    @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);
+    }
+
+    public Editor putStringSet(String key, Set<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);
+    }
+
+    public Set<String> getStringSet(String key, Set<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.apply();
+
+    // 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.apply();
+
+    // 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", ""));
+  }
+}
@@ -0,0 +1,246 @@
+/*
+ * 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.docs;
+
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.io.gdata.docs.SpreadsheetsClient.WorksheetEntry;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+import com.google.android.apps.mytracks.util.StringUtils;
+import com.google.wireless.gdata.data.Entry;
+
+import android.test.AndroidTestCase;
+
+/**
+ * Tests {@link SendDocsUtils}.
+ * 
+ * @author Jimmy Shih
+ */
+public class SendDocsUtilsTest extends AndroidTestCase {
+
+  private static final long TIME = 1288721514000L;
+
+  /**
+   * Tests {@link SendDocsUtils#getEntryId(Entry)} with a valid id.
+   */
+  public void testGetEntryId_valid() {
+    Entry entry = new Entry();
+    entry.setId("https://docs.google.com/feeds/documents/private/full/spreadsheet%3A123");
+    assertEquals("123", SendDocsUtils.getEntryId(entry));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getEntryId(Entry)} with an invalid id.
+   */
+  public void testGetEntryId_invalid() {
+    Entry entry = new Entry();
+    entry.setId("123");
+    assertEquals(null, SendDocsUtils.getEntryId(entry));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getNewSpreadsheetId(String)} with a valid id.
+   */
+  public void testGetNewSpreadsheetId_valid_id() {
+    assertEquals("123", SendDocsUtils.getNewSpreadsheetId(
+        "<id>https://docs.google.com/feeds/documents/private/full/spreadsheet%3A123</id>"));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getNewSpreadsheetId(String)} without an open
+   * tag, <id>.
+   */
+  public void testGetNewSpreadsheetId_no_open_tag() {
+    assertEquals(null, SendDocsUtils.getNewSpreadsheetId(
+        "https://docs.google.com/feeds/documents/private/full/spreadsheet%3A123</id>"));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getNewSpreadsheetId(String)} without an end tag,
+   * </id>.
+   */
+  public void testGetNewSpreadsheetId_no_end_tag() {
+    assertEquals(null, SendDocsUtils.getNewSpreadsheetId(
+        "<id>https://docs.google.com/feeds/documents/private/full/spreadsheet%3A123"));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getNewSpreadsheetId(String)} without the url
+   * prefix,
+   * https://docs.google.com/feeds/documents/private/full/spreadsheet%3A.
+   */
+  public void testGetNewSpreadsheetId_no_prefix() {
+    assertEquals(null, SendDocsUtils.getNewSpreadsheetId("<id>123</id>"));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getWorksheetEntryId(WorksheetEntry)} with a
+   * valid entry.
+   */
+  public void testGetWorksheetEntryId_valid() {
+    WorksheetEntry entry = new WorksheetEntry();
+    entry.setId("/123");
+    assertEquals("123", SendDocsUtils.getWorksheetEntryId(entry));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getWorksheetEntryId(WorksheetEntry)} with a
+   * invalid entry.
+   */
+  public void testGetWorksheetEntryId_invalid() {
+    WorksheetEntry entry = new WorksheetEntry();
+    entry.setId("123");
+    assertEquals(null, SendDocsUtils.getWorksheetEntryId(entry));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getRowContent(Track, boolean,
+   * android.content.Context)} with metric units.
+   */
+  public void testGetRowContent_metric() throws Exception {
+    Track track = getTrack();
+    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>" + "<gsx:date><![CDATA["
+        + StringUtils.formatDateTime(getContext(), TIME) + "]]></gsx:date>"
+        + "<gsx:totaltime><![CDATA[0:00:05]]></gsx:totaltime>"
+        + "<gsx:movingtime><![CDATA[0:00:04]]></gsx:movingtime>"
+        + "<gsx:distance><![CDATA[20.00]]></gsx:distance>"
+        + "<gsx:distanceunit><![CDATA[km]]></gsx:distanceunit>"
+        + "<gsx:averagespeed><![CDATA[14,400.00]]></gsx:averagespeed>"
+        + "<gsx:averagemovingspeed><![CDATA[18,000.00]]>" + "</gsx:averagemovingspeed>"
+        + "<gsx:maxspeed><![CDATA[5,400.00]]></gsx:maxspeed>"
+        + "<gsx:speedunit><![CDATA[km/h]]></gsx:speedunit>"
+        + "<gsx:elevationgain><![CDATA[6,000]]></gsx:elevationgain>"
+        + "<gsx:minelevation><![CDATA[-500]]></gsx:minelevation>"
+        + "<gsx:maxelevation><![CDATA[550]]></gsx:maxelevation>"
+        + "<gsx:elevationunit><![CDATA[m]]></gsx:elevationunit>" + "<gsx:map>"
+        + "<![CDATA[https://maps.google.com/maps/ms?msa=0&msid=trackMapId]]>" + "</gsx:map>"
+        + "</entry>";
+    assertEquals(expectedData, SendDocsUtils.getRowContent(track, true, getContext()));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getRowContent(Track, boolean,
+   * android.content.Context)} with imperial units.
+   */
+  public void testGetRowContent_imperial() throws Exception {
+    Track track = getTrack();
+    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>" + "<gsx:date><![CDATA["
+        + StringUtils.formatDateTime(getContext(), 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[mi]]></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[mi/h]]></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[ft]]></gsx:elevationunit>" + "<gsx:map>"
+        + "<![CDATA[https://maps.google.com/maps/ms?msa=0&msid=trackMapId]]>" + "</gsx:map>"
+        + "</entry>";
+    assertEquals(expectedData, SendDocsUtils.getRowContent(track, false, getContext()));
+  }
+
+  /**
+   * Gets a track for testing {@link SendDocsUtils#getRowContent(Track, boolean,
+   * android.content.Context)}.
+   */
+  private Track getTrack() {
+    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);
+    return track;
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#appendTag(StringBuilder, String, String)} with
+   * repeated calls.
+   */
+  public void testAppendTag() {
+    StringBuilder stringBuilder = new StringBuilder();
+    SendDocsUtils.appendTag(stringBuilder, "name1", "value1");
+    assertEquals("<gsx:name1><![CDATA[value1]]></gsx:name1>", stringBuilder.toString());
+
+    SendDocsUtils.appendTag(stringBuilder, "name2", "value2");
+    assertEquals(
+        "<gsx:name1><![CDATA[value1]]></gsx:name1><gsx:name2><![CDATA[value2]]></gsx:name2>",
+        stringBuilder.toString());
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getDistance(double, boolean)} with metric units.
+   */
+  public void testGetDistance_metric() {
+    assertEquals("1.22", SendDocsUtils.getDistance(1222.3, true));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getDistance(double, boolean)} with imperial
+   * units.
+   */
+  public void testGetDistance_imperial() {
+    assertEquals("0.76", SendDocsUtils.getDistance(1222.3, false));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getSpeed(double, boolean)} with metric units.
+   */
+  public void testGetSpeed_metric() {
+    assertEquals("15.55", SendDocsUtils.getSpeed(4.32, true));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getSpeed(double, boolean)} with imperial units.
+   */
+  public void testGetSpeed_imperial() {
+    assertEquals("9.66", SendDocsUtils.getSpeed(4.32, false));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getElevation(double, boolean)} with metric
+   * units.
+   */
+  public void testGetElevation_metric() {
+    assertEquals("3", SendDocsUtils.getElevation(3.456, true));
+  }
+
+  /**
+   * Tests {@link SendDocsUtils#getElevation(double, boolean)} with imperial
+   * units.
+   */
+  public void testGetElevation_imperial() {
+    assertEquals("11", SendDocsUtils.getElevation(3.456, false));
+  }
+}
@@ -0,0 +1,88 @@
+/*
+ * 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;
+
+
+/**
+ * Tests for {@link CsvTrackWriter}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class CsvTrackWriterTest extends TrackFormatWriterTest {
+
+  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)", "Battery level (%)");
+    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", "400.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", "401.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", "402.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", "403.0");
+    String expected = expectedTrackHeader + expectedTrack + "\n" 
+        + expectedMarkerHeader + expectedMarker1 + expectedMarker2 + "\n"
+        + expectedPointHeader + expectedPoint1 + expectedPoint2 + expectedPoint3 + expectedPoint4;
+
+    CsvTrackWriter writer = new CsvTrackWriter(getContext());
+    assertEquals(expected, writeTrack(writer));
+  }
+
+  /**
+   * 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,295 @@
+/*
+ * 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.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.io.file.GpxImporter;
+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, IOException {
+    testInvalidXML(INVALID_LOCATION_TEST_GPX);
+  }
+
+  /**
+   * Test with invalid time - track should be deleted.
+   */
+  public void testImportTimeFailure() throws ParserConfigurationException, IOException {
+    testInvalidXML(INVALID_TIME_TEST_GPX);
+  }
+
+  /**
+   * Test with invalid xml - track should be deleted.
+   */
+  public void testImportXMLFailure() throws ParserConfigurationException, IOException {
+    testInvalidXML(INVALID_XML_TEST_GPX);
+  }
+
+  /**
+   * Test with invalid altitude - track should be deleted.
+   */
+  public void testImportInvalidAltitude() throws ParserConfigurationException, IOException {
+    testInvalidXML(INVALID_ALTITUDE_TEST_GPX);
+  }
+
+  /**
+   * Test with invalid latitude - track should be deleted.
+   */
+  public void testImportInvalidLatitude() throws ParserConfigurationException, IOException {
+    testInvalidXML(INVALID_LATITUDE_TEST_GPX);
+  }
+
+  /**
+   * Test with invalid longitude - track should be deleted.
+   */
+  public void testImportInvalidLongitude() throws ParserConfigurationException, 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());
+    }
+  }
+}
@@ -0,0 +1,76 @@
+/*
+ * 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 java.util.List;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ * Tests for {@link GpxTrackWriter}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class GpxTrackWriterTest extends TrackFormatWriterTest {
+
+  public void testXmlOutput() throws Exception {
+    TrackFormatWriter writer = new GpxTrackWriter(getContext());
+    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"));
+    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,125 @@
+/*
+ * 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 com.google.android.apps.mytracks.content.DescriptionGenerator;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+
+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 TrackFormatWriterTest {
+
+  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(Waypoint waypoint) {
+      return null;
+    }
+  }
+
+  public void testXmlOutput() throws Exception {
+    KmlTrackWriter writer = new KmlTrackWriter(getContext(), new FakeDescriptionGenerator());
+    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 3 placemarks - start, track, and end
+    List<Element> placemarkTags = getChildElements(docTag, "Placemark", 3);
+    assertTagIsPlacemark(
+        placemarkTags.get(0), TRACK_NAME + " (Start)", TRACK_DESCRIPTION, 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"));
+    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,64 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.android.apps.mytracks.io.file;
+
+import java.io.File;
+
+/**
+ * A simple, fake {@link TrackWriter} subclass with all methods mocked out.
+ * Tests are expected to override {@link #writeTrack}.
+ *
+ * @author Matthew Simmons
+ *
+ */
+public class MockTrackWriter implements TrackWriter {
+  public OnWriteListener onWriteListener;
+
+  @Override
+  public void setOnWriteListener(OnWriteListener onWriteListener) {
+    this.onWriteListener = onWriteListener;
+  }
+
+  @Override
+  public void setDirectory(File directory) {
+    throw new UnsupportedOperationException("not implemented");
+  }
+
+  @Override
+  public String getAbsolutePath() {
+    throw new UnsupportedOperationException("not implemented");
+  }
+
+  @Override
+  public void writeTrack() {
+    throw new UnsupportedOperationException("not implemented");
+  }
+
+  @Override
+  public void stopWriteTrack() {
+    throw new UnsupportedOperationException("not implemented");
+  }
+
+  @Override
+  public boolean wasSuccess() {
+    return false;
+  }
+
+  @Override
+  public int getErrorMessage() {
+    return 0;
+  }
+}
@@ -0,0 +1,96 @@
+/*
+ * 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 com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.Sensor;
+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 TrackFormatWriterTest {
+
+  public void testXmlOutput() throws Exception {
+    TrackFormatWriter writer = new TcxTrackWriter(getContext());
+    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 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,219 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+package com.google.android.apps.mytracks.io.file;
+
+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 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 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_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.SensorData.Builder batteryLevel = Sensor.SensorData.newBuilder().setValue(400 + i)
+          .setState(Sensor.SensorState.SENDING);
+      Sensor.SensorDataSet sensorDataSet = Sensor.SensorDataSet.newBuilder().setPower(power)
+          .setCadence(cadence).setHeartRate(heartRate).setBatteryLevel(batteryLevel).build();
+      location.setSensorData(sensorDataSet);
+    }
+  }
+
+  /**
+   * 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) throws Exception {
+    OutputStream output = new ByteArrayOutputStream(BUFFER_SIZE);
+    writer.prepare(track, output);
+    writer.writeHeader();
+    writer.writeBeginWaypoints();
+    writer.writeWaypoint(wp1);
+    writer.writeWaypoint(wp2);
+    writer.writeEndWaypoints();
+    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.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;
+  }
+}
@@ -0,0 +1,363 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+
+package com.google.android.apps.mytracks.io.file;
+
+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.MyTracksProviderUtils.Factory;
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.content.Waypoint;
+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.File;
+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 TrackWriterImpl} subclass which mocks out methods called from
+   * {@link TrackWriterImpl#openFile}.
+   */
+  private static final class OpenFileTrackWriter extends TrackWriterImpl {
+    private final ByteArrayOutputStream stream;
+    private final boolean canWrite;
+
+    /**
+     * Constructor.
+     *
+     * @param stream the stream to return from
+     *        {@link TrackWriterImpl#newOutputStream}, or null to throw a
+     *        {@link FileNotFoundException}
+     * @param canWrite the value that {@link TrackWriterImpl#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;
+      
+      // The directory is set in the canWriteFile. However, this class
+      // overwrites canWriteFile, thus needs to set it.
+      setDirectory(new File("/"));
+    }
+
+    @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 TrackWriterImpl} subclass which mocks out methods called from
+   * {@link TrackWriterImpl#writeTrack}.
+   */
+  private final class WriteTracksTrackWriter extends TrackWriterImpl {
+    private final boolean openResult;
+
+    /**
+     * Constructor.
+     *
+     * @param openResult the return value for {@link TrackWriterImpl#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 TrackWriterImpl 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);
+
+    mocksControl.replay();
+    writer.writeTrack();
+
+    assertEquals(1, writeDocumentCalls);
+    assertEquals(1, openFileCalls);
+    mocksControl.verify();
+  }
+
+  public void testWriteTrack_openFails() {
+    writer = new WriteTracksTrackWriter(getContext(), providerUtils, track,
+        formatWriter, false);
+
+    mocksControl.replay();
+    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() throws Exception {
+    writer = new TrackWriterImpl(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() throws Exception {
+    writer = new TrackWriterImpl(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.writeBeginWaypoints();
+    formatWriter.writeWaypoint(wptEq(wps[1]));
+    formatWriter.writeWaypoint(wptEq(wps[2]));
+    formatWriter.writeEndWaypoints();
+
+    // 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);
+    }
+  }
+}
@@ -0,0 +1,85 @@
+/*
+ * 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.fusiontables;
+
+import com.google.android.apps.mytracks.io.docs.SendDocsActivity;
+import com.google.android.apps.mytracks.io.sendtogoogle.SendRequest;
+import com.google.android.apps.mytracks.io.sendtogoogle.UploadResultActivity;
+
+import android.test.AndroidTestCase;
+
+/**
+ * Tests the {@link SendFusionTablesActivity}.
+ * 
+ * @author Youtao Liu
+ */
+public class SendFusionTablesActivityTest extends AndroidTestCase {
+
+  private SendFusionTablesActivity sendFusionTablesActivity;
+  private SendRequest sendRequest;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    sendRequest = new SendRequest(1L);
+    sendFusionTablesActivity = new SendFusionTablesActivity();
+  }
+
+  /**
+   * Tests the method
+   * {@link SendFusionTablesActivity#getNextClass(SendRequest, boolean)}. Sets
+   * the flags of "sendDocs" and "cancel" to false and false.
+   */
+  public void testGetNextClass_notCancelNotSendDocs() {
+    sendRequest.setSendDocs(false);
+    Class<?> next = sendFusionTablesActivity.getNextClass(sendRequest, false);
+    assertEquals(UploadResultActivity.class, next);
+  }
+
+  /**
+   * Tests the method
+   * {@link SendFusionTablesActivity#getNextClass(SendRequest, boolean)}. Sets
+   * the flags of "sendDocs" and "cancel" to true and false.
+   */
+  public void testGetNextClass_notCancelSendDocs() {
+    sendRequest.setSendDocs(true);
+    Class<?> next = sendFusionTablesActivity.getNextClass(sendRequest, false);
+    assertEquals(SendDocsActivity.class, next);
+  }
+
+  /**
+   * Tests the method
+   * {@link SendFusionTablesActivity#getNextClass(SendRequest,boolean)}. Sets
+   * the flags of "sendDocs" and "cancel" to true and true.
+   */
+  public void testGetNextClass_cancelSendDocs() {
+    sendRequest.setSendDocs(true);
+    Class<?> next = sendFusionTablesActivity.getNextClass(sendRequest, true);
+    assertEquals(UploadResultActivity.class, next);
+  }
+
+  /**
+   * Tests the method
+   * {@link SendFusionTablesActivity#getNextClass(SendRequest,boolean)}. Sets
+   * the flags of "sendDocs" and "cancel" to false and true.
+   */
+  public void testGetNextClass_cancelNotSendDocs() {
+    sendRequest.setSendDocs(false);
+    Class<?> next = sendFusionTablesActivity.getNextClass(sendRequest, true);
+    assertEquals(UploadResultActivity.class, next);
+  }
+
+}
@@ -0,0 +1,285 @@
+/*
+ * 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.fusiontables;
+
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+
+import android.location.Location;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.util.ArrayList;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests {@link SendFusionTablesUtils}.
+ *
+ * @author Jimmy Shih
+ */
+public class SendFusionTablesUtilsTest extends TestCase {
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getMapUrl(Track)} with null track.
+   */
+  public void testGetMapUrl_null_track() {
+    assertEquals(null, SendFusionTablesUtils.getMapUrl(null));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getMapUrl(Track)} with null table id.
+   */
+  public void testGetMapUrl_null_table_id() {
+    Track track = new Track();
+    TripStatistics stats = new TripStatistics();
+    stats.setBounds((int) 100.E6, (int) 10.E6, (int) 50.E6, (int) 5.E6);
+    track.setStatistics(stats);
+    track.setTableId(null);
+    assertEquals(null, SendFusionTablesUtils.getMapUrl(track));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getMapUrl(Track)} with null stats.
+   */
+  public void testGetMapUrl_null_stats() {
+    Track track = new Track();
+    track.setStatistics(null);
+    track.setTableId("123");
+    assertEquals(null, SendFusionTablesUtils.getMapUrl(track));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getMapUrl(Track)} with a valid track.
+   */
+  public void testGetMapUrl_valid_track() {
+    Track track = new Track();
+    TripStatistics stats = new TripStatistics();
+    stats.setBounds((int) 100.E6, (int) 10.E6, (int) 50.E6, (int) 5.E6);
+    track.setStatistics(stats);
+    track.setTableId("123");
+    assertEquals(
+        "https://www.google.com/fusiontables/embedviz?"
+            + "viz=MAP&q=select+col0,+col1,+col2,+col3+from+123+&h=false&lat=7.500000&lng=75.000000"
+            + "&z=15&t=1&l=col2", SendFusionTablesUtils.getMapUrl(track));
+  }
+
+  /**
+   * Tests (@link {@link SendFusionTablesUtils#formatSqlValues(String...)} with
+   * no value.
+   */
+  public void testFormatSqlValues_no_value() {
+    assertEquals("()", SendFusionTablesUtils.formatSqlValues());
+  }
+
+  /**
+   * Tests (@link {@link SendFusionTablesUtils#formatSqlValues(String...)} with
+   * an empty string.
+   */
+  public void testFormatSqlValues_empty_string() {
+    assertEquals("(\'\')", SendFusionTablesUtils.formatSqlValues(""));
+  }
+
+  /**
+   * Tests (@link {@link SendFusionTablesUtils#formatSqlValues(String...)} with
+   * one value.
+   */
+  public void testFormatSqlValues_one_value() {
+    assertEquals("(\'first\')", SendFusionTablesUtils.formatSqlValues("first"));
+  }
+
+  /**
+   * Tests (@link {@link SendFusionTablesUtils#formatSqlValues(String...)} with
+   * two values.
+   */
+  public void testFormatSqlValues_two_values() {
+    assertEquals(
+        "(\'first\',\'second\')", SendFusionTablesUtils.formatSqlValues("first", "second"));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#escapeSqlString(String)} with a value
+   * containing several single quotes.
+   */
+  public void testEscapeSqValuel() {
+    String value = "let's'";
+    assertEquals("let''s''", SendFusionTablesUtils.escapeSqlString(value));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getKmlPoint(Location)} with a null
+   * point.
+   */
+  public void testGetKmlPoint_null_point() {
+    assertEquals(
+        "<Point><coordinates></coordinates></Point>", SendFusionTablesUtils.getKmlPoint(null));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getKmlPoint(Location)} with a valid
+   * point.
+   */
+  public void testGetKmlPoint_valid_point() {
+    Location location = new Location("test");
+    location.setLongitude(10.1);
+    location.setLatitude(20.2);
+    location.setAltitude(30.3);
+    assertEquals("<Point><coordinates>10.1,20.2,30.3</coordinates></Point>",
+        SendFusionTablesUtils.getKmlPoint(location));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getKmlLineString(ArrayList)} with a null
+   * locations.
+   */
+  public void testKmlLineString_null_locations() {
+    assertEquals("<LineString><coordinates></coordinates></LineString>",
+        SendFusionTablesUtils.getKmlLineString(null));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getKmlLineString(ArrayList)} with no
+   * location.
+   */
+  public void testKmlLineString_no_location() {
+    ArrayList<Location> locations = new ArrayList<Location>();
+    assertEquals("<LineString><coordinates></coordinates></LineString>",
+        SendFusionTablesUtils.getKmlLineString(locations));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getKmlLineString(ArrayList)} with one
+   * location.
+   */
+  public void testKmlLineString_one_location() {
+    ArrayList<Location> locations = new ArrayList<Location>();
+    Location location = new Location("test");
+    location.setLongitude(10.1);
+    location.setLatitude(20.2);
+    location.setAltitude(30.3);
+    locations.add(location);
+    assertEquals("<LineString><coordinates>10.1,20.2,30.3</coordinates></LineString>",
+        SendFusionTablesUtils.getKmlLineString(locations));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getKmlLineString(ArrayList)} with two
+   * locations.
+   */
+  public void testKmlLineString_two_locations() {
+    ArrayList<Location> locations = new ArrayList<Location>();
+    Location location1 = new Location("test");
+    location1.setLongitude(10.1);
+    location1.setLatitude(20.2);
+    location1.setAltitude(30.3);
+    locations.add(location1);
+
+    Location location2 = new Location("test");
+    location2.setLongitude(1.1);
+    location2.setLatitude(2.2);
+    location2.removeAltitude();
+    locations.add(location2);
+
+    assertEquals("<LineString><coordinates>10.1,20.2,30.3 1.1,2.2</coordinates></LineString>",
+        SendFusionTablesUtils.getKmlLineString(locations));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#appendLocation(Location, StringBuilder)}
+   * with no altitude.
+   */
+  public void testAppendLocation_no_altitude() {
+    StringBuilder builder = new StringBuilder();
+    Location location = new Location("test");
+    location.setLongitude(10.1);
+    location.setLatitude(20.2);
+    location.removeAltitude();
+    SendFusionTablesUtils.appendLocation(location, builder);
+    assertEquals("10.1,20.2", builder.toString());
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#appendLocation(Location, StringBuilder)}
+   * with altitude.
+   */
+  public void testAppendLocation_has_altitude() {
+    StringBuilder builder = new StringBuilder();
+    Location location = new Location("test");
+    location.setLongitude(10.1);
+    location.setLatitude(20.2);
+    location.setAltitude(30.3);
+    SendFusionTablesUtils.appendLocation(location, builder);
+    assertEquals("10.1,20.2,30.3", builder.toString());
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getTableId(InputStream)} with a null
+   * inputstream.
+   */
+  public void testGetTableId_null() {
+    assertEquals(null, SendFusionTablesUtils.getTableId(null));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getTableId(InputStream)} with an
+   * inputstream containing no data.
+   */
+  public void testGetTableId_no_data() {
+    InputStream inputStream = new ByteArrayInputStream(new byte[0]);
+    assertEquals(null, SendFusionTablesUtils.getTableId(inputStream));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getTableId(InputStream)} with an empty
+   * inputstream.
+   */
+  public void testGetTableId_empty() {
+    String string = "";
+    InputStream inputStream = new ByteArrayInputStream(string.getBytes());
+    assertEquals(null, SendFusionTablesUtils.getTableId(inputStream));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getTableId(InputStream)} with an one
+   * line inputstream.
+   */
+  public void testGetTableId_one_line() {
+    String string = "tableid";
+    InputStream inputStream = new ByteArrayInputStream(string.getBytes());
+    assertEquals(null, SendFusionTablesUtils.getTableId(inputStream));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getTableId(InputStream)} with an
+   * inputstream not containing "tableid".
+   */
+  public void testGetTableId_no_table_id() {
+    String string = "error\n123";
+    InputStream inputStream = new ByteArrayInputStream(string.getBytes());
+    assertEquals(null, SendFusionTablesUtils.getTableId(inputStream));
+  }
+
+  /**
+   * Tests {@link SendFusionTablesUtils#getTableId(InputStream)} with a valid
+   * inputstream.
+   */
+  public void testGetTableId() {
+    String string = "tableid\n123";
+    InputStream inputStream = null;
+    inputStream = new ByteArrayInputStream(string.getBytes());
+    assertEquals("123", SendFusionTablesUtils.getTableId(inputStream));
+  }
+}
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.android.apps.mytracks.io.maps;
+
+import com.google.android.apps.mytracks.io.gdata.maps.MapsMapMetadata;
+import com.google.android.maps.mytracks.R;
+
+import android.content.Intent;
+import android.test.AndroidTestCase;
+import android.widget.ArrayAdapter;
+
+import java.util.ArrayList;
+
+/**
+ * Tests the {@link ChooseMapActivity}.
+ * 
+ * @author Youtao Liu
+ */
+public class ChooseMapActivityTest extends AndroidTestCase {
+
+  private static final String MAP_ID = "mapid";
+  private static final String MAP_TITLE = "title";
+  private static final String MAP_DESC = "desc";
+
+  private ArrayList<String> mapIds = new ArrayList<String>();
+  private ArrayList<MapsMapMetadata> mapDatas = new ArrayList<MapsMapMetadata>();
+  private boolean errorDialogShown = false;
+  private boolean progressDialogRemoved = false;
+
+  /**
+   * Creates a class to override some methods of {@link ChooseMapActivity} to
+   * makes it testable.
+   * 
+   * @author youtaol
+   */
+  public class ChooseMapActivityMock extends ChooseMapActivity {
+    /**
+     * By overriding this method, avoids to start next activity.
+     */
+    @Override
+    public void startActivity(Intent intent) {}
+
+    /**
+     * By overriding this method, avoids to show an error dialog and set the
+     * show flag to true.
+     */
+    @Override
+    public void showErrorDialog() {
+      errorDialogShown = true;
+    }
+    
+    /**
+     * By overriding this method, avoids to show an error dialog and set the
+     * show flag to true.
+     */
+    @Override
+    public void removeProgressDialog() {
+      progressDialogRemoved = true;
+    }
+  }
+
+  /**
+   * Tests the method
+   * {@link ChooseMapActivity#onAsyncTaskCompleted(boolean, ArrayList, ArrayList)}
+   * . An alert dialog should be shown when there is no map.
+   */
+  public void testOnAsyncTaskCompleted_fail() {
+    ChooseMapActivityMock chooseMapActivityMock = new ChooseMapActivityMock();
+    errorDialogShown = false;
+    progressDialogRemoved = false;
+    chooseMapActivityMock.onAsyncTaskCompleted(false, null, null);
+    assertTrue(progressDialogRemoved);
+    assertTrue(errorDialogShown);
+  }
+
+  /**
+   * Tests the method
+   * {@link ChooseMapActivity#onAsyncTaskCompleted(boolean, ArrayList, ArrayList)}
+   * . Check the logic when there is only map.
+   */
+  public void testOnAsyncTaskCompleted_success_oneMap() {
+    ChooseMapActivityMock chooseMapActivityMock = new ChooseMapActivityMock();
+    chooseMapActivityMock.arrayAdapter = new ArrayAdapter<ChooseMapActivity.ListItem>(getContext(),
+        R.layout.choose_map_item);
+    simulateMaps(1);
+    chooseMapActivityMock.onAsyncTaskCompleted(true, mapIds, mapDatas);
+    assertEquals(1, chooseMapActivityMock.arrayAdapter.getCount());
+    assertEquals(MAP_ID + "0", chooseMapActivityMock.arrayAdapter.getItem(0).getMapId());
+    assertEquals(MAP_TITLE + "0", chooseMapActivityMock.arrayAdapter.getItem(0).getMapData()
+        .getTitle());
+    assertEquals(MAP_DESC + "0", chooseMapActivityMock.arrayAdapter.getItem(0).getMapData()
+        .getDescription());
+  }
+
+  /**
+   * Tests the method
+   * {@link ChooseMapActivity#onAsyncTaskCompleted(boolean, ArrayList, ArrayList)}
+   * . Check the logic when there are 10 maps.
+   */
+  public void testOnAsyncTaskCompleted_success_twoMaps() {
+    ChooseMapActivityMock chooseMapActivityMock = new ChooseMapActivityMock();
+    chooseMapActivityMock.arrayAdapter = new ArrayAdapter<ChooseMapActivity.ListItem>(getContext(),
+        R.layout.choose_map_item);
+    simulateMaps(10);
+    chooseMapActivityMock.onAsyncTaskCompleted(true, mapIds, mapDatas);
+    assertEquals(10, chooseMapActivityMock.arrayAdapter.getCount());
+    assertEquals(MAP_ID + "9", chooseMapActivityMock.arrayAdapter.getItem(9).getMapId());
+    assertEquals(MAP_TITLE + "9", chooseMapActivityMock.arrayAdapter.getItem(9).getMapData()
+        .getTitle());
+    assertEquals(MAP_DESC + "9", chooseMapActivityMock.arrayAdapter.getItem(9).getMapData()
+        .getDescription());
+  }
+
+  /**
+   * Simulates map data for the test.
+   * 
+   * @param number of data should be simulated.
+   */
+  private void simulateMaps(int number) {
+    mapIds = new ArrayList<String>();
+    mapDatas = new ArrayList<MapsMapMetadata>();
+    for (int i = 0; i < number; i++) {
+      mapIds.add(MAP_ID + i);
+      MapsMapMetadata metaData = new MapsMapMetadata();
+      metaData.setTitle(MAP_TITLE + i);
+      metaData.setDescription(MAP_DESC + i);
+      metaData.setSearchable(true);
+      mapDatas.add(metaData);
+    }
+  }
+}
@@ -0,0 +1,199 @@
+/*
+ * 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.maps;
+
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.accounts.Account;
+import android.test.AndroidTestCase;
+
+import java.util.ArrayList;
+
+/**
+ * Tests {@link ChooseMapAsyncTask}.
+ * 
+ * @author Youtao Liu
+ */
+public class ChooseMapAsyncTaskTest extends AndroidTestCase {
+
+  private ChooseMapActivity chooseMapActivityMock;
+  private Account account;
+  private static final String ACCOUNT_NAME = "AccountName";
+  private static final String ACCOUNT_TYPE = "AccountType";
+  private boolean getMapsStatus = false;
+
+  public class ChooseMapAsyncTaskMock extends ChooseMapAsyncTask {
+
+    public ChooseMapAsyncTaskMock(ChooseMapActivity activity, Account account) {
+      super(activity, account);
+    }
+
+    /**
+     * Creates this method to override {@link ChooseMapAsyncTask#getMaps()}.
+     * 
+     * @return mock the return value of getMaps().
+     */
+    @Override
+    boolean getMaps() {
+      return getMapsStatus;
+    }
+  }
+
+  /**
+   * Tests {@link ChooseMapAsyncTask#setActivity(ChooseMapActivity)} when the
+   * task is completed. Makes sure it calls
+   * {@link ChooseMapActivity#onAsyncTaskCompleted(boolean, ArrayList, ArrayList)}
+   * .
+   */
+  public void testSetActivity_completed() {
+    setup();
+    chooseMapActivityMock.onAsyncTaskCompleted(false, null, null);
+    AndroidMock.replay(chooseMapActivityMock);
+    ChooseMapAsyncTask chooseMapAsyncTask = new ChooseMapAsyncTask(chooseMapActivityMock, account);
+    chooseMapAsyncTask.setCompleted(true);
+    chooseMapAsyncTask.setActivity(chooseMapActivityMock);
+    AndroidMock.verify(chooseMapActivityMock);
+  }
+
+  /**
+   * Test {@link ChooseMapAsyncTask#setActivity(ChooseMapActivity)} when the
+   * task is not completed. Makes sure
+   * {@link ChooseMapActivity#onAsyncTaskCompleted(boolean, ArrayList, ArrayList)}
+   * is not invoked.
+   */
+  public void testSetActivity_notCompleted() {
+    setup();
+    AndroidMock.replay(chooseMapActivityMock);
+    ChooseMapAsyncTask chooseMapAsyncTask = new ChooseMapAsyncTask(chooseMapActivityMock, account);
+    chooseMapAsyncTask.setCompleted(false);
+    chooseMapAsyncTask.setActivity(chooseMapActivityMock);
+    AndroidMock.verify(chooseMapActivityMock);
+  }
+
+  /**
+   * Tests {@link ChooseMapAsyncTask#setActivity(ChooseMapActivity)} when the
+   * activity is null. Makes sure
+   * {@link ChooseMapActivity#onAsyncTaskCompleted(boolean, ArrayList, ArrayList)}
+   * is not invoked.
+   */
+  public void testSetActivity_nullActivity() {
+    setup();
+    AndroidMock.replay(chooseMapActivityMock);
+    ChooseMapAsyncTask chooseMapAsyncTask = new ChooseMapAsyncTask(chooseMapActivityMock, account);
+    chooseMapAsyncTask.setCompleted(true);
+    chooseMapAsyncTask.setActivity(null);
+    AndroidMock.verify(chooseMapActivityMock);
+  }
+
+  /**
+   * Tests the method {@link ChooseMapAsyncTask#onPostExecute(Boolean)} when the
+   * result is true. Makes sure
+   * {@link ChooseMapActivity#onAsyncTaskCompleted(boolean, ArrayList, ArrayList)}
+   * is invoked.
+   */
+  public void testOnPostExecute_trueResult() {
+    setup();
+    chooseMapActivityMock.onAsyncTaskCompleted(true, null, null);
+    AndroidMock.replay(chooseMapActivityMock);
+    ChooseMapAsyncTask chooseMapAsyncTask = new ChooseMapAsyncTask(chooseMapActivityMock, account);
+    chooseMapAsyncTask.onPostExecute(true);
+    AndroidMock.verify(chooseMapActivityMock);
+  }
+
+  /**
+   * Tests the method {@link ChooseMapAsyncTask#onPostExecute(Boolean)} when the
+   * result is false. Makes sure
+   * {@link ChooseMapActivity#onAsyncTaskCompleted(boolean, ArrayList, ArrayList)}
+   * is invoked.
+   */
+  public void testOnPostExecute_falseResult() {
+    setup();
+    chooseMapActivityMock.onAsyncTaskCompleted(false, null, null);
+    AndroidMock.replay(chooseMapActivityMock);
+    ChooseMapAsyncTask chooseMapAsyncTask = new ChooseMapAsyncTask(chooseMapActivityMock, account);
+    chooseMapAsyncTask.onPostExecute(false);
+    AndroidMock.verify(chooseMapActivityMock);
+  }
+
+  /**
+   * Tests the method {@link ChooseMapAsyncTask#retryUpload()}. Make sure can
+   * not retry again after have retried once and failed.
+   */
+  public void testRetryUpload() throws Exception {
+    setup();
+    AndroidMock.replay(chooseMapActivityMock);
+    ChooseMapAsyncTaskMock chooseMapAsyncTaskTMock = new ChooseMapAsyncTaskMock(
+        chooseMapActivityMock, account);
+    chooseMapAsyncTaskTMock.setCanRetry(false);
+    getMapsStatus = true;
+    assertFalse(chooseMapAsyncTaskTMock.retryUpload());
+    AndroidMock.verify(chooseMapActivityMock);
+  }
+
+  /**
+   * Tests the method {@link ChooseMapAsyncTask#retryUpload()}. Make sure can
+   * retry after get maps failed and never retry before.
+   */
+  public void testRetryUpload_retryOnce() throws Exception {
+    setup();
+    AndroidMock.replay(chooseMapActivityMock);
+    ChooseMapAsyncTaskMock chooseMapAsyncTaskTMock = new ChooseMapAsyncTaskMock(
+        chooseMapActivityMock, account);
+    chooseMapAsyncTaskTMock.setCanRetry(true);
+    getMapsStatus = false;
+    assertFalse(chooseMapAsyncTaskTMock.retryUpload());
+    // Can only retry once.
+    assertFalse(chooseMapAsyncTaskTMock.getCanRetry());
+    AndroidMock.verify(chooseMapActivityMock);
+  }
+
+  /**
+   * Tests the method {@link ChooseMapAsyncTask#retryUpload()}. Make sure will
+   * not retry after get maps successfully.
+   */
+  public void testRetryUpload_successGetMaps() throws Exception {
+    setup();
+    AndroidMock.replay(chooseMapActivityMock);
+    ChooseMapAsyncTaskMock chooseMapAsyncTaskTMock = new ChooseMapAsyncTaskMock(
+        chooseMapActivityMock, account);
+    chooseMapAsyncTaskTMock.setCanRetry(true);
+    getMapsStatus = true;
+    assertTrue(chooseMapAsyncTaskTMock.retryUpload());
+    // Can only retry once.
+    assertFalse(chooseMapAsyncTaskTMock.getCanRetry());
+    AndroidMock.verify(chooseMapActivityMock);
+  }
+
+  /**
+   * Initials setup for test.
+   */
+  void setup() {
+    setupChooseMapActivityMock();
+    account = new Account(ACCOUNT_NAME, ACCOUNT_TYPE);
+  }
+
+  /**
+   * Create a mock object of ChooseMapActivity.
+   */
+  @UsesMocks(ChooseMapActivity.class)
+  private void setupChooseMapActivityMock() {
+    chooseMapActivityMock = AndroidMock.createMock(ChooseMapActivity.class);
+    // This is used in the constructor of ChooseMapAsyncTask.
+    AndroidMock.expect(chooseMapActivityMock.getApplicationContext()).andReturn(getContext()).anyTimes();
+  }
+
+}
@@ -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.maps;
+
+import com.google.android.apps.mytracks.io.docs.SendDocsActivity;
+import com.google.android.apps.mytracks.io.fusiontables.SendFusionTablesActivity;
+import com.google.android.apps.mytracks.io.sendtogoogle.SendRequest;
+import com.google.android.apps.mytracks.io.sendtogoogle.UploadResultActivity;
+
+import android.test.AndroidTestCase;
+
+/**
+ * Tests the {@link SendMapsActivity}.
+ * 
+ * @author Youtao Liu
+ */
+public class SendMapsActivityTest extends AndroidTestCase {
+
+  private SendMapsActivity sendMapsActivity;
+  private SendRequest sendRequest;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    sendRequest = new SendRequest(1L);
+    sendMapsActivity = new SendMapsActivity();
+  }
+
+  /**
+   * Tests the method
+   * {@link SendMapsActivity#getNextClass(SendRequest, boolean)}. Sets the flags
+   * of "sendFusionTables","sendDocs" and "cancel" to true, true and false.
+   */
+  public void testGetNextClass_notCancelSendFusionTables() {
+    sendRequest.setSendFusionTables(true);
+    sendRequest.setSendDocs(true);
+    Class<?> next = sendMapsActivity.getNextClass(sendRequest, false);
+    assertEquals(SendFusionTablesActivity.class, next);
+  }
+
+  /**
+   * Tests the method
+   * {@link SendMapsActivity#getNextClass(SendRequest, boolean)}. Sets the flags
+   * of "sendFusionTables","sendDocs" and "cancel" to false, true and false.
+  */
+  public void testGetNextClass_notCancelSendDocs() {
+    sendRequest.setSendFusionTables(false);
+    sendRequest.setSendDocs(true);
+    Class<?> next = sendMapsActivity.getNextClass(sendRequest, false);
+    assertEquals(SendDocsActivity.class, next);
+  }
+  
+  /**
+   * Tests the method
+   * {@link SendMapsActivity#getNextClass(SendRequest, boolean)}. Sets the flags
+   * of "sendFusionTables","sendDocs" and "cancel" to false, false and false.
+   */
+  public void testGetNextClass_notCancelNotSend() {
+    sendRequest.setSendFusionTables(false);
+    sendRequest.setSendDocs(false);
+    Class<?> next = sendMapsActivity.getNextClass(sendRequest, false);
+    assertEquals(UploadResultActivity.class, next);
+  }
+
+  /**
+   * Tests the method
+   * {@link SendMapsActivity#getNextClass(SendRequest, boolean)}. Sets the flags
+   * of "sendFusionTables","sendDocs" and "cancel" to true, true and true.
+   */
+  public void testGetNextClass_cancelSendDocs() {
+    sendRequest.setSendFusionTables(true);
+    sendRequest.setSendDocs(true);
+    Class<?> next = sendMapsActivity.getNextClass(sendRequest, true);
+    assertEquals(UploadResultActivity.class, next);
+  }
+
+}
@@ -0,0 +1,356 @@
+/*
+ * 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.maps;
+
+import com.google.android.apps.mytracks.Constants;
+import com.google.android.apps.mytracks.TrackStubUtils;
+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.io.gdata.maps.MapsGDataConverter;
+import com.google.android.apps.mytracks.io.sendtogoogle.SendRequest;
+import com.google.android.testing.mocking.AndroidMock;
+import com.google.android.testing.mocking.UsesMocks;
+
+import android.accounts.Account;
+import android.database.Cursor;
+import android.location.Location;
+import android.test.AndroidTestCase;
+
+import java.util.List;
+
+import org.xmlpull.v1.XmlPullParserException;
+
+/**
+ * Tests {@link SendMapsAsyncTask}.
+ * 
+ * @author Youtao Liu
+ */
+public class SendMapsAsyncTaskTest extends AndroidTestCase {
+
+  private static final long TRACK_ID = 1;
+  private static final String MAP_ID = "MapID_1";
+  // Records the run times of {@link SendMapsAsyncTaskMock#uploadMarker(String,
+  // String, String, Location)}
+  private int uploadMarkerCounter = 0;
+  // Records the run times of {@link
+  // SendMapsAsyncTaskMock#prepareAndUploadPoints(Track, List<Location>,
+  // boolean)}
+  private int prepareAndUploadPointsCounter = 0;
+
+  private SendMapsActivity sendMapsActivityMock;
+  private MyTracksProviderUtils myTracksProviderUtilsMock;
+  private SendRequest sendRequest;
+
+  private class SendMapsAsyncTaskMock extends SendMapsAsyncTask {
+
+    private boolean[] uploadMarkerResult = { false, false };
+    private boolean prepareAndUploadPointsResult = false;
+
+    private SendMapsAsyncTaskMock(SendMapsActivity activity, long trackId, Account account,
+        String chooseMapId, MyTracksProviderUtils myTracksProviderUtils) {
+      super(activity, trackId, account, chooseMapId, myTracksProviderUtils);
+    }
+
+    @Override
+    boolean uploadMarker(String title, String description, String iconUrl, Location location) {
+      int runTimes = uploadMarkerCounter++;
+      return uploadMarkerResult[runTimes];
+    }
+
+    @Override
+    boolean prepareAndUploadPoints(Track track, List<Location> locations, boolean lastBatch) {
+      prepareAndUploadPointsCounter++;
+      return prepareAndUploadPointsResult;
+    }
+  }
+
+  @Override
+  @UsesMocks({ SendMapsActivity.class, MyTracksProviderUtils.class })
+  protected void setUp() throws Exception {
+    super.setUp();
+    uploadMarkerCounter = 0;
+    prepareAndUploadPointsCounter = 0;
+    sendMapsActivityMock = AndroidMock.createMock(SendMapsActivity.class);
+    myTracksProviderUtilsMock = AndroidMock.createMock(MyTracksProviderUtils.class);
+    sendRequest = new SendRequest(TRACK_ID);
+    AndroidMock.expect(sendMapsActivityMock.getApplicationContext()).andReturn(getContext());
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#saveResult()}and makes sure the
+   * track is updated.
+   */
+  public void testSaveResult() {
+    Track track = TrackStubUtils.createTrack(1);
+    track.setMapId(null);
+    AndroidMock.expect(myTracksProviderUtilsMock.getTrack(TRACK_ID)).andReturn(track);
+    myTracksProviderUtilsMock.updateTrack(track);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), sendRequest.getMapId(),
+        myTracksProviderUtilsMock);
+    sendMapsAsyncTask.saveResult();
+    assertEquals(sendRequest.getMapId(), track.getMapId());
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock);
+  }
+
+  /**
+   * Tests {@link SendMapsAsyncTask#fetchSendMapId(Track)} when chooseMapId is
+   * null and makes sure it returns false.
+   */
+  public void testFetchSendMapId_nullMapID() {
+    Track track = TrackStubUtils.createTrack(1);
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock);
+    // Makes chooseMapId to null.
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), null, myTracksProviderUtilsMock);
+    // Returns false for an exception would be thrown.
+    assertFalse(sendMapsAsyncTask.fetchSendMapId(track));
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#fetchSendMapId(Track)} when
+   * chooseMapId is not null. And makes sure it returns false.
+   */
+  public void testFetchSendMapId_notNullMapID() {
+    Track track = TrackStubUtils.createTrack(1);
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    assertTrue(sendMapsAsyncTask.fetchSendMapId(track));
+    assertEquals(MAP_ID, sendMapsAsyncTask.getMapId());
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadAllTrackPoints(Track)} when
+   * cursor is null. And makes sure it returns false.
+   */
+  public void testUploadAllTrackPoints_nullCursor() {
+    Track track = TrackStubUtils.createTrack(1);
+    AndroidMock.expect(myTracksProviderUtilsMock.getLocationsCursor(TRACK_ID, 0, -1, false))
+        .andReturn(null);
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    assertFalse(sendMapsAsyncTask.uploadAllTrackPoints(track));
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadAllTrackPoints(Track)} when
+   * uploads the first marker is failed.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadAllTrackPoints_uploadFirstMarkerFailed() {
+    Track track = TrackStubUtils.createTrack(1);
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    AndroidMock.expect(cursorMock.getCount()).andReturn(2);
+    AndroidMock.expect(cursorMock.moveToPosition(0)).andReturn(true);
+    cursorMock.close();
+    AndroidMock.expect(myTracksProviderUtilsMock.createLocation(cursorMock)).andReturn(
+        new Location("1"));
+    AndroidMock.expect(myTracksProviderUtilsMock.getLocationsCursor(TRACK_ID, 0, -1, false))
+        .andReturn(cursorMock);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTaskMock sendMapsAsyncTask = new SendMapsAsyncTaskMock(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    sendMapsAsyncTask.uploadMarkerResult[0] = false;
+    assertFalse(sendMapsAsyncTask.uploadAllTrackPoints(track));
+    assertEquals(1, uploadMarkerCounter);
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadAllTrackPoints(Track)} when
+   * uploads the two markers is successful but failed when
+   * prepareAndUploadPoints.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadAllTrackPoints_prepareAndUploadPointsFailed() {
+    Track track = TrackStubUtils.createTrack(1);
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    AndroidMock.expect(cursorMock.getCount()).andReturn(2);
+    AndroidMock.expect(cursorMock.moveToPosition(0)).andReturn(true);
+    AndroidMock.expect(cursorMock.moveToPosition(1)).andReturn(true);
+    cursorMock.close();
+    AndroidMock.expect(myTracksProviderUtilsMock.createLocation(cursorMock))
+        .andReturn(new Location("1")).times(2);
+    AndroidMock.expect(myTracksProviderUtilsMock.getLocationsCursor(TRACK_ID, 0, -1, false))
+        .andReturn(cursorMock);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTaskMock sendMapsAsyncTask = new SendMapsAsyncTaskMock(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    // For will be failed when run prepareAndUploadPoints, it no require to
+    // set uploadMarkerResult[1].
+    sendMapsAsyncTask.uploadMarkerResult[0] = true;
+    sendMapsAsyncTask.prepareAndUploadPointsResult = false;
+    assertFalse(sendMapsAsyncTask.uploadAllTrackPoints(track));
+    assertEquals(1, uploadMarkerCounter);
+    assertEquals(1, prepareAndUploadPointsCounter);
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadAllTrackPoints(Track)} when
+   * uploads the last marker is failed.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadAllTrackPoints_uploadLastMarkerFailed() {
+    Track track = TrackStubUtils.createTrack(1);
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    AndroidMock.expect(cursorMock.getCount()).andReturn(2);
+    AndroidMock.expect(cursorMock.moveToPosition(0)).andReturn(true);
+    AndroidMock.expect(cursorMock.moveToPosition(1)).andReturn(true);
+    cursorMock.close();
+    AndroidMock.expect(myTracksProviderUtilsMock.createLocation(cursorMock))
+        .andReturn(new Location("1")).times(2);
+    AndroidMock.expect(myTracksProviderUtilsMock.getLocationsCursor(TRACK_ID, 0, -1, false))
+        .andReturn(cursorMock);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTaskMock sendMapsAsyncTask = new SendMapsAsyncTaskMock(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    sendMapsAsyncTask.uploadMarkerResult[0] = true;
+    sendMapsAsyncTask.uploadMarkerResult[1] = false;
+    sendMapsAsyncTask.prepareAndUploadPointsResult = true;
+    assertFalse(sendMapsAsyncTask.uploadAllTrackPoints(track));
+    assertEquals(2, uploadMarkerCounter);
+    assertEquals(1, prepareAndUploadPointsCounter);
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadAllTrackPoints(Track)} when
+   * return true.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadAllTrackPoints_success() {
+    Track track = TrackStubUtils.createTrack(1);
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    AndroidMock.expect(cursorMock.getCount()).andReturn(2);
+    AndroidMock.expect(cursorMock.moveToPosition(0)).andReturn(true);
+    AndroidMock.expect(cursorMock.moveToPosition(1)).andReturn(true);
+    cursorMock.close();
+    AndroidMock.expect(myTracksProviderUtilsMock.createLocation(cursorMock))
+        .andReturn(new Location("1")).times(2);
+    AndroidMock.expect(myTracksProviderUtilsMock.getLocationsCursor(TRACK_ID, 0, -1, false))
+        .andReturn(cursorMock);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTaskMock sendMapsAsyncTask = new SendMapsAsyncTaskMock(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    sendMapsAsyncTask.uploadMarkerResult[0] = true;
+    sendMapsAsyncTask.uploadMarkerResult[1] = true;
+    sendMapsAsyncTask.prepareAndUploadPointsResult = true;
+    assertTrue(sendMapsAsyncTask.uploadAllTrackPoints(track));
+    assertEquals(2, uploadMarkerCounter);
+    assertEquals(1, prepareAndUploadPointsCounter);
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadWaypoints()} when cursor is
+   * null.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadWaypoints_nullCursor() {
+    AndroidMock.expect(
+        myTracksProviderUtilsMock.getWaypointsCursor(TRACK_ID, 0,
+            Constants.MAX_LOADED_WAYPOINTS_POINTS)).andReturn(null);
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    assertTrue(sendMapsAsyncTask.uploadWaypoints());
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadWaypoints()} when there is
+   * only one point.
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadWaypoints_onePoint() {
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    AndroidMock.expect(cursorMock.moveToFirst()).andReturn(true);
+    // Only one point, so next is null.
+    AndroidMock.expect(cursorMock.moveToNext()).andReturn(false);
+    cursorMock.close();
+
+    AndroidMock.expect(
+        myTracksProviderUtilsMock.getWaypointsCursor(TRACK_ID, 0,
+            Constants.MAX_LOADED_WAYPOINTS_POINTS)).andReturn(cursorMock);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+
+    assertTrue(sendMapsAsyncTask.uploadWaypoints());
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#uploadWaypoints()}. Makes sure a cursor is created and
+   * a way point is created with such cursor.
+   * 
+   * @throws XmlPullParserException
+   */
+  @UsesMocks(Cursor.class)
+  public void testUploadWaypoints() throws XmlPullParserException {
+    Cursor cursorMock = AndroidMock.createMock(Cursor.class);
+    MapsGDataConverter mapsGDataConverterMock = new MapsGDataConverter();
+
+    AndroidMock.expect(cursorMock.moveToFirst()).andReturn(true);
+    AndroidMock.expect(cursorMock.moveToNext()).andReturn(true);
+    cursorMock.close();
+
+    AndroidMock.expect(
+        myTracksProviderUtilsMock.getWaypointsCursor(TRACK_ID, 0,
+            Constants.MAX_LOADED_WAYPOINTS_POINTS)).andReturn(cursorMock);
+    Waypoint waypoint = new Waypoint();
+    waypoint.setLocation(TrackStubUtils.createMyTracksLocation());
+    AndroidMock.expect(myTracksProviderUtilsMock.createWaypoint(cursorMock)).andReturn(waypoint)
+        .times(1);
+
+    AndroidMock.replay(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+    SendMapsAsyncTask sendMapsAsyncTask = new SendMapsAsyncTask(sendMapsActivityMock,
+        sendRequest.getTrackId(), sendRequest.getAccount(), MAP_ID, myTracksProviderUtilsMock);
+    sendMapsAsyncTask.setMapsGDataConverter(mapsGDataConverterMock);
+    // Would be failed for there is no source for uploading.
+    assertFalse(sendMapsAsyncTask.uploadWaypoints());
+    AndroidMock.verify(sendMapsActivityMock, myTracksProviderUtilsMock, cursorMock);
+  }
+
+  /**
+   * Tests the method {@link SendMapsAsyncTask#getPercentage(int, int)}.
+   */
+  public void testCountPercentage() {
+    assertEquals(SendMapsAsyncTask.PROGRESS_UPLOAD_DATA_MIN, SendMapsAsyncTask.getPercentage(0, 5));
+    assertEquals(SendMapsAsyncTask.PROGRESS_UPLOAD_DATA_MAX,
+        SendMapsAsyncTask.getPercentage(50, 50));
+    assertEquals(
+        (int) ((double) 5
+            / 11
+            * (SendMapsAsyncTask.PROGRESS_UPLOAD_DATA_MAX - SendMapsAsyncTask.PROGRESS_UPLOAD_DATA_MIN) + SendMapsAsyncTask.PROGRESS_UPLOAD_DATA_MIN),
+            SendMapsAsyncTask.getPercentage(5, 11));
+  }
+
+}
@@ -0,0 +1,179 @@
+/*
+ * 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.maps;
+
+import com.google.android.apps.mytracks.content.Track;
+import com.google.android.apps.mytracks.io.gdata.maps.MapsFeature;
+import com.google.android.maps.GeoPoint;
+
+import android.location.Location;
+
+import java.util.ArrayList;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests {@link SendMapsUtils}.
+ *
+ * @author Jimmy Shih
+ */
+public class SendMapsUtilsTest extends TestCase {
+
+  /**
+   * Tests {@link SendMapsUtils#getMapUrl(Track)} with null track.
+   */
+  public void testGetMapUrl_null_track() {
+    assertEquals(null, SendMapsUtils.getMapUrl(null));
+  }
+
+  /**
+   * Tests {@link SendMapsUtils#getMapUrl(Track)} with null map id.
+   */
+  public void testGetMapUrl_null_map_id() {
+    Track track = new Track();
+    track.setMapId(null);
+    assertEquals(null, SendMapsUtils.getMapUrl(track));
+  }
+
+  /**
+   * Tests {@link SendMapsUtils#getMapUrl(Track)} with a valid track.
+   */
+  public void testGetMapUrl_valid_track() {
+    Track track = new Track();
+    track.setMapId("123");
+    assertEquals("https://maps.google.com/maps/ms?msa=0&msid=123", SendMapsUtils.getMapUrl(track));
+  }
+
+  /**
+   * Test {@link SendMapsUtils#buildMapsMarkerFeature(String, String, String,
+   * GeoPoint)} with a title.
+   */
+  public void testBuildMapsMarkerFeature_with_title() {
+    MapsFeature mapFeature = SendMapsUtils.buildMapsMarkerFeature(
+        "name", "this\nmap\ndescription", "url", new GeoPoint(123, 456));
+    assertEquals(MapsFeature.MARKER, mapFeature.getType());
+    assertNotNull(mapFeature.getAndroidId());
+    assertEquals("name", mapFeature.getTitle());
+    assertEquals("this<br>map<br>description", mapFeature.getDescription());
+    assertEquals("url", mapFeature.getIconUrl());
+    assertEquals(123, mapFeature.getPoint(0).getLatitudeE6());
+    assertEquals(456, mapFeature.getPoint(0).getLongitudeE6());
+  }
+
+  /**
+   * Test {@link SendMapsUtils#buildMapsMarkerFeature(String, String, String,
+   * GeoPoint)} with an empty title.
+   */
+  public void testBuildMapsMarkerFeature_empty_title() {
+    MapsFeature mapFeature = SendMapsUtils.buildMapsMarkerFeature(
+        "", "description", "url", new GeoPoint(123, 456));
+    assertEquals(MapsFeature.MARKER, mapFeature.getType());
+    assertNotNull(mapFeature.getAndroidId());
+    assertEquals("-", mapFeature.getTitle());
+    assertEquals("description", mapFeature.getDescription());
+    assertEquals("url", mapFeature.getIconUrl());
+    assertEquals(123, mapFeature.getPoint(0).getLatitudeE6());
+    assertEquals(456, mapFeature.getPoint(0).getLongitudeE6());
+  }
+
+  /**
+   * Test {@link SendMapsUtils#buildMapsMarkerFeature(String, String, String,
+   * GeoPoint)} with a null title.
+   */
+  public void testBuildMapsMarkerFeature_null_title() {
+    MapsFeature mapFeature = SendMapsUtils.buildMapsMarkerFeature(
+        null, "description", "url", new GeoPoint(123, 456));
+    assertEquals(MapsFeature.MARKER, mapFeature.getType());
+    assertNotNull(mapFeature.getAndroidId());
+    assertEquals("-", mapFeature.getTitle());
+    assertEquals("description", mapFeature.getDescription());
+    assertEquals("url", mapFeature.getIconUrl());
+    assertEquals(123, mapFeature.getPoint(0).getLatitudeE6());
+    assertEquals(456, mapFeature.getPoint(0).getLongitudeE6());
+  }
+
+  /**
+   * Test {@link SendMapsUtils#buildMapsLineFeature(String, ArrayList)} with a
+   * title.
+   */
+  public void testBuildMapsLineFeature_with_title() {
+    ArrayList<Location> locations = new ArrayList<Location>();
+    Location location = new Location("test");
+    location.setLatitude(50);
+    location.setLongitude(100);
+    locations.add(location);
+    MapsFeature mapFeature = SendMapsUtils.buildMapsLineFeature("name", locations);
+
+    assertEquals(MapsFeature.LINE, mapFeature.getType());
+    assertNotNull(mapFeature.getAndroidId());
+    assertEquals("name", mapFeature.getTitle());
+    assertEquals(0x80FF0000, mapFeature.getColor());
+    assertEquals(50000000, mapFeature.getPoint(0).getLatitudeE6());
+    assertEquals(100000000, mapFeature.getPoint(0).getLongitudeE6());
+  }
+
+  /**
+   * Test {@link SendMapsUtils#buildMapsLineFeature(String, ArrayList)} with an
+   * empty title.
+   */
+  public void testBuildMapsLineFeature_empty_title() {
+    ArrayList<Location> locations = new ArrayList<Location>();
+    Location location = new Location("test");
+    location.setLatitude(50);
+    location.setLongitude(100);
+    locations.add(location);
+    MapsFeature mapFeature = SendMapsUtils.buildMapsLineFeature("", locations);
+
+    assertEquals(MapsFeature.LINE, mapFeature.getType());
+    assertNotNull(mapFeature.getAndroidId());
+    assertEquals("-", mapFeature.getTitle());
+    assertEquals(0x80FF0000, mapFeature.getColor());
+    assertEquals(50000000, mapFeature.getPoint(0).getLatitudeE6());
+    assertEquals(100000000, mapFeature.getPoint(0).getLongitudeE6());
+  }
+
+  /**
+   * Test {@link SendMapsUtils#buildMapsLineFeature(String, ArrayList)} with a
+   * null title.
+   */
+  public void testBuildMapsLineFeature_null_title() {
+    ArrayList<Location> locations = new ArrayList<Location>();
+    Location location = new Location("test");
+    location.setLatitude(50);
+    location.setLongitude(100);
+    locations.add(location);
+    MapsFeature mapFeature = SendMapsUtils.buildMapsLineFeature(null, locations);
+
+    assertEquals(MapsFeature.LINE, mapFeature.getType());
+    assertNotNull(mapFeature.getAndroidId());
+    assertEquals("-", mapFeature.getTitle());
+    assertEquals(0x80FF0000, mapFeature.getColor());
+    assertEquals(50000000, mapFeature.getPoint(0).getLatitudeE6());
+    assertEquals(100000000, mapFeature.getPoint(0).getLongitudeE6());
+  }
+
+  /**
+   * Test {@link SendMapsUtils#getGeoPoint(Location)}.
+   */
+  public void testGeoPoint() {
+    Location location = new Location("test");
+    location.setLatitude(50);
+    location.setLongitude(100);
+    GeoPoint geoPoint = SendMapsUtils.getGeoPoint(location);
+    assertEquals(50000000, geoPoint.getLatitudeE6());
+    assertEquals(100000000, geoPoint.getLongitudeE6());
+  }
+}
@@ -0,0 +1,286 @@
+/*
+ * 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.sendtogoogle;
+
+import android.accounts.Account;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.test.AndroidTestCase;
+
+/**
+ * Tests the {@link SendRequest}.
+ * 
+ * @author Youtao Liu
+ */
+public class SendRequestTest extends AndroidTestCase {
+  private SendRequest sendRequest;
+
+  final static private String ACCOUNTNAME = "testAccount1";
+  final static private String ACCOUNTYPE = "testType1";
+  final static private String MAPID = "mapId1";
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    sendRequest = new SendRequest(1);
+  }
+
+  /**
+   * Tests the method {@link SendRequest#getTrackId()}. The value should be set
+   * to 1 when it is initialed in setup method.
+   */
+  public void testGetTrackId() {
+    assertEquals(1, sendRequest.getTrackId());
+  }
+
+  public void testIsSendMaps() {
+    assertEquals(false, sendRequest.isSendMaps());
+    sendRequest.setSendMaps(true);
+    assertEquals(true, sendRequest.isSendMaps());
+  }
+
+  public void testIsSendFusionTables() {
+    assertEquals(false, sendRequest.isSendFusionTables());
+    sendRequest.setSendFusionTables(true);
+    assertEquals(true, sendRequest.isSendFusionTables());
+  }
+
+  /**
+   * Tests the method {@link SendRequest#isSendDocs()}. The value should be set
+   * to false which is its default value when it is initialed in setup method.
+   */
+  public void testIsSendDocs() {
+    assertEquals(false, sendRequest.isSendDocs());
+    sendRequest.setSendDocs(true);
+    assertEquals(true, sendRequest.isSendDocs());
+  }
+
+  /**
+   * Tests the method {@link SendRequest#isNewMap()}. The value should be set to
+   * false which is its default value when it is initialed in setup method.
+   */
+  public void testIsNewMap() {
+    assertEquals(false, sendRequest.isNewMap());
+    sendRequest.setNewMap(true);
+    assertEquals(true, sendRequest.isNewMap());
+  }
+
+  /**
+   * Tests the method {@link SendRequest#getAccount()}. The value should be set
+   * to null which is its default value when it is initialed in setup method.
+   */
+  public void testGetAccount() {
+    assertEquals(null, sendRequest.getAccount());
+    Account account = new Account(ACCOUNTNAME, ACCOUNTYPE);
+    sendRequest.setAccount(account);
+    assertEquals(account, sendRequest.getAccount());
+  }
+
+  /**
+   * Tests the method {@link SendRequest#getMapId()}. The value should be set to
+   * null which is its default value when it is initialed in setup method.
+   */
+  public void testGetMapId() {
+    assertEquals(null, sendRequest.getMapId());
+    sendRequest.setMapId("1");
+    assertEquals("1", "1");
+  }
+
+  /**
+   * Tests the method {@link SendRequest#isMapsSuccess()}. The value should be
+   * set to false which is its default value when it is initialed in setup
+   * method.
+   */
+  public void testIsMapsSuccess() {
+    assertEquals(false, sendRequest.isMapsSuccess());
+    sendRequest.setMapsSuccess(true);
+    assertEquals(true, sendRequest.isMapsSuccess());
+  }
+
+  /**
+   * Tests the method {@link SendRequest#isFusionTablesSuccess()}. The value
+   * should be set to false which is its default value when it is initialed in
+   * setup method.
+   */
+  public void testIsFusionTablesSuccess() {
+    assertEquals(false, sendRequest.isFusionTablesSuccess());
+    sendRequest.setFusionTablesSuccess(true);
+    assertEquals(true, sendRequest.isFusionTablesSuccess());
+  }
+
+  /**
+   * Tests the method {@link SendRequest#isDocsSuccess()}. The value should be
+   * set to false which is its default value when it is initialed in setup
+   * method.
+   */
+  public void testIsDocsSuccess() {
+    assertEquals(false, sendRequest.isDocsSuccess());
+    sendRequest.setDocsSuccess(true);
+    assertEquals(true, sendRequest.isDocsSuccess());
+  }
+
+  /**
+   * Tests SendRequest.CREATOR.createFromParcel when all values are true.
+   */
+  public void testCreateFromParcel_true() {
+    Parcel parcel = Parcel.obtain();
+    parcel.setDataPosition(0);
+    parcel.writeLong(2);
+    parcel.writeString("");
+    parcel.writeString("");
+    parcel.writeByte((byte) 1);
+    parcel.writeByte((byte) 1);
+    parcel.writeByte((byte) 1);
+    parcel.writeByte((byte) 1);
+    Account account = new Account(ACCOUNTNAME, ACCOUNTYPE);
+    parcel.writeParcelable(account, 0);
+    parcel.writeString(MAPID);
+    parcel.writeByte((byte) 1);
+    parcel.writeByte((byte) 1);
+    parcel.writeByte((byte) 1);
+    parcel.setDataPosition(0);
+    sendRequest = SendRequest.CREATOR.createFromParcel(parcel);
+    assertEquals(2, sendRequest.getTrackId());
+    assertEquals("", sendRequest.getSharingAppPackageName());
+    assertEquals("", sendRequest.getSharingAppClassName());
+    assertTrue(sendRequest.isSendMaps());
+    assertTrue(sendRequest.isSendFusionTables());
+    assertTrue(sendRequest.isSendDocs());
+    assertTrue(sendRequest.isNewMap());
+    assertEquals(account, sendRequest.getAccount());
+    assertEquals(MAPID, sendRequest.getMapId());
+    assertTrue(sendRequest.isMapsSuccess());
+    assertTrue(sendRequest.isFusionTablesSuccess());
+    assertTrue(sendRequest.isDocsSuccess());
+  }
+
+  /**
+   * Tests SendRequest.CREATOR.createFromParcel when all values are false.
+   */
+  public void testCreateFromParcel_false() {
+    Parcel parcel = Parcel.obtain();
+    parcel.setDataPosition(0);
+    parcel.writeLong(4);
+    parcel.writeString(null);
+    parcel.writeString(null);
+    parcel.writeByte((byte) 0);
+    parcel.writeByte((byte) 0);
+    parcel.writeByte((byte) 0);
+    parcel.writeByte((byte) 0);
+    Account account = new Account(ACCOUNTNAME, ACCOUNTYPE);
+    parcel.writeParcelable(account, 0);
+    parcel.writeString(MAPID);
+    parcel.writeByte((byte) 0);
+    parcel.writeByte((byte) 0);
+    parcel.writeByte((byte) 0);
+    parcel.setDataPosition(0);
+    sendRequest = SendRequest.CREATOR.createFromParcel(parcel);
+    assertEquals(4, sendRequest.getTrackId());
+    assertNull(sendRequest.getSharingAppPackageName());
+    assertNull(sendRequest.getSharingAppClassName());
+    assertFalse(sendRequest.isSendMaps());
+    assertFalse(sendRequest.isSendFusionTables());
+    assertFalse(sendRequest.isSendDocs());
+    assertFalse(sendRequest.isNewMap());
+    assertEquals(account, sendRequest.getAccount());
+    assertEquals(MAPID, sendRequest.getMapId());
+    assertFalse(sendRequest.isMapsSuccess());
+    assertFalse(sendRequest.isFusionTablesSuccess());
+    assertFalse(sendRequest.isDocsSuccess());
+  }
+
+  /**
+   * Tests {@link SendRequest#writeToParcel(Parcel, int)} with default values.
+   */
+  public void testWriteToParcel_default() {
+    sendRequest = new SendRequest(1);
+    Parcel parcel = Parcel.obtain();
+    parcel.setDataPosition(0);
+    sendRequest.writeToParcel(parcel, 1);
+    parcel.setDataPosition(0);
+    long trackId = parcel.readLong();
+    String sharingAppPackageName = parcel.readString();
+    String sharingAppClassName = parcel.readString();
+    boolean sendMaps = parcel.readByte() == 1;
+    boolean sendFusionTables = parcel.readByte() == 1;
+    boolean sendDocs = parcel.readByte() == 1;
+    boolean newMap = parcel.readByte() == 1;
+    Parcelable account = parcel.readParcelable(null);
+    String mapId = parcel.readString();
+    boolean mapsSuccess = parcel.readByte() == 1;
+    boolean fusionTablesSuccess = parcel.readByte() == 1;
+    boolean docsSuccess = parcel.readByte() == 1;
+    assertEquals(1, trackId);
+    assertNull(sharingAppPackageName);
+    assertNull(sharingAppClassName);
+    assertFalse(sendMaps);
+    assertFalse(sendFusionTables);
+    assertFalse(sendDocs);
+    assertFalse(newMap);
+    assertNull(account);
+    assertNull(mapId);
+    assertFalse(mapsSuccess);
+    assertFalse(fusionTablesSuccess);
+    assertFalse(docsSuccess);
+  }
+
+  /**
+   * Tests {@link SendRequest#writeToParcel(Parcel, int)}.
+   */
+  public void testWriteToParcel() {
+    sendRequest = new SendRequest(4);
+    sendRequest.setSharingAppPackageName("package");
+    sendRequest.setSharingAppClassName("class"); 
+    sendRequest.setSendMaps(true);
+    sendRequest.setSendFusionTables(true);
+    sendRequest.setSendDocs(true);
+    sendRequest.setNewMap(true);
+    Account accountNew = new Account(ACCOUNTNAME + "2", ACCOUNTYPE + "2");
+    sendRequest.setAccount(accountNew);
+    sendRequest.setMapId(MAPID);
+    sendRequest.setMapsSuccess(true);
+    sendRequest.setFusionTablesSuccess(true);
+    sendRequest.setDocsSuccess(true);
+    Parcel parcel = Parcel.obtain();
+    parcel.setDataPosition(0);
+    sendRequest.writeToParcel(parcel, 1);
+    parcel.setDataPosition(0);
+    long trackId = parcel.readLong();
+    String sharingAppPackageName = parcel.readString();
+    String sharingAppClassName = parcel.readString();
+    boolean sendMaps = parcel.readByte() == 1;
+    boolean sendFusionTables = parcel.readByte() == 1;
+    boolean sendDocs = parcel.readByte() == 1;
+    boolean newMap = parcel.readByte() == 1;
+    Parcelable account = parcel.readParcelable(null);
+    String mapId = parcel.readString();
+    boolean mapsSuccess = parcel.readByte() == 1;
+    boolean fusionTablesSuccess = parcel.readByte() == 1;
+    boolean docsSuccess = parcel.readByte() == 1;
+    assertEquals(4, trackId);
+    assertEquals("package", sharingAppPackageName);
+    assertEquals("class", sharingAppClassName);
+    assertTrue(sendMaps);
+    assertTrue(sendFusionTables);
+    assertTrue(sendDocs);
+    assertTrue(newMap);
+    assertEquals(accountNew, account);
+    assertEquals(MAPID, mapId);
+    assertTrue(mapsSuccess);
+    assertTrue(fusionTablesSuccess);
+    assertTrue(docsSuccess);
+  }
+}
@@ -0,0 +1,140 @@
+/*
+ * 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.sendtogoogle;
+
+/**
+ * Tests the {@link SendToGoogleUtils}.
+ * 
+ * @author Youtao Liu
+ */
+import com.google.android.apps.mytracks.TrackStubUtils;
+import com.google.android.apps.mytracks.content.MyTracksLocation;
+import com.google.android.apps.mytracks.content.Track;
+
+import android.location.Location;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import junit.framework.TestCase;
+
+public class SendToGoogleUtilsTest extends TestCase {
+
+  private final static long TRACK_ID = 1L;
+  private final static String TRACK_CATEGORY = "trackCategory";
+  private final static String TRACK_NAME = "trackName";
+  private final static double DIFFERENCE = 0.02;
+  private final static double INVALID_LATITUDE = 91;
+
+  /**
+   * Tests the method
+   * {@link SendToGoogleUtils#prepareTrackSegment(Track, java.util.ArrayList)}
+   * when there is only one location in a segment.
+   */
+  public void testPrepareTrackSegment_onlyOneLocation() {
+    Track trackStub = TrackStubUtils.createTrack(1);
+    assertFalse(SendToGoogleUtils.prepareTrackSegment(trackStub, null));
+  }
+
+  /**
+   * Tests the method
+   * {@link SendToGoogleUtils#prepareTrackSegment(Track, ArrayList)} when there
+   * is no stop time.
+   */
+  public void testPrepareTrackSegment_noStopTime() {
+    Track trackStub = TrackStubUtils.createTrack(2);
+    assertEquals(-1L, trackStub.getStatistics().getStopTime());
+
+    ArrayList<Track> tracksArray = new ArrayList<Track>();
+    assertTrue(SendToGoogleUtils.prepareTrackSegment(trackStub, tracksArray));
+    assertEquals(trackStub, tracksArray.get(0));
+    // The stop time should be the time of last location
+    assertEquals(trackStub.getLocations().get(1).getTime(), trackStub.getStatistics().getStopTime());
+  }
+
+  /**
+   * Tests the method
+   * {@link SendToGoogleUtils#prepareTrackSegment(Track, java.util.ArrayList)}
+   * when there is stop time.
+   */
+  public void testPrepareTrackSegment_hasStopTime() {
+    Track trackStub = TrackStubUtils.createTrack(2);
+    // Gives a margin to make sure the this time will be not same with the last
+    // location in the track.
+    long stopTime = System.currentTimeMillis() + 1000;
+    trackStub.getStatistics().setStopTime(stopTime);
+
+    ArrayList<Track> tracksArray = new ArrayList<Track>();
+    SendToGoogleUtils.prepareTrackSegment(trackStub, tracksArray);
+    assertEquals(trackStub, tracksArray.get(0));
+    assertEquals(stopTime, trackStub.getStatistics().getStopTime());
+  }
+
+  /**
+   * Tests the method
+   * {@link SendToGoogleUtils#prepareLocations(Track, java.util.List)} .
+   */
+  public void testPrepareLocations() {
+    Track trackStub = TrackStubUtils.createTrack(2);
+    trackStub.setId(TRACK_ID);
+    trackStub.setName(TRACK_NAME);
+    trackStub.setCategory(TRACK_CATEGORY);
+
+    List<Location> locationsArray = new ArrayList<Location>();
+    // Adds 100 location to List.
+    for (int i = 0; i < 100; i++) {
+      // Use this variable as a flag to make all points in the track can be kept
+      // after run the LocationUtils#decimate(Track, double) with
+      // Ramer–Douglas–Peucker algorithm.
+      double latitude = TrackStubUtils.INITIAL_LATITUDE;
+      if (i % 2 == 0) {
+        latitude -= DIFFERENCE * (i % 10);
+      }
+      // Inserts 9 points which have wrong latitude, so would have 10 segments.
+      if (i % 10 == 0 && i > 0) {
+        MyTracksLocation location = TrackStubUtils.createMyTracksLocation();
+        location.setLatitude(INVALID_LATITUDE);
+        locationsArray.add(location);
+      } else {
+        locationsArray.add(TrackStubUtils.createMyTracksLocation(latitude,
+            TrackStubUtils.INITIAL_LONGITUDE + DIFFERENCE * (i % 10),
+            TrackStubUtils.INITIAL_ALTITUDE + DIFFERENCE * (i % 10)));
+      }
+    }
+    ArrayList<Track> result = SendToGoogleUtils.prepareLocations(trackStub, locationsArray);
+    assertEquals(10, result.size());
+    // Checks all segments.
+    for (int i = 0; i < 10; i++) {
+      Track segmentOne = result.get(i);
+      assertEquals(TRACK_ID, segmentOne.getId());
+      assertEquals(TRACK_NAME, segmentOne.getName());
+      assertEquals(TRACK_CATEGORY, segmentOne.getCategory());
+    }
+    // Checks all locations in the first segment.
+    for (int j = 0; j < 9; j++) {
+      double latitude = TrackStubUtils.INITIAL_LATITUDE;
+      if (j % 2 == 0) {
+        latitude -= DIFFERENCE * (j % 10);
+      }
+      Location oneLocation = result.get(0).getLocations().get(j);
+      assertEquals(TrackStubUtils.createMyTracksLocation().getAltitude() + DIFFERENCE * (j % 10),
+          oneLocation.getAltitude());
+      assertEquals(latitude, oneLocation.getLatitude());
+      assertEquals(TrackStubUtils.createMyTracksLocation().getLongitude() + DIFFERENCE * (j % 10),
+          oneLocation.getLongitude());
+    }
+  }
+}
@@ -0,0 +1,156 @@
+/*
+ * 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.sendtogoogle;
+
+import com.google.android.maps.mytracks.R;
+
+import android.content.Intent;
+import android.test.ActivityInstrumentationTestCase2;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+/**
+ * Tests the {@link UploadResultActivity}.
+ * 
+ * @author Youtao Liu
+ */
+public class UploadResultActivityTest
+    extends ActivityInstrumentationTestCase2<UploadResultActivity> {
+  
+
+  private UploadResultActivity uploadResultActivity;
+  private TextView errorFooter;
+  private TextView successFooter;
+  private LinearLayout mapsResult;
+  private LinearLayout fusionTablesResult;
+  private LinearLayout docsResult;
+  private ImageView mapsResultIcon;
+  private ImageView fusionTablesResultIcon;
+  private ImageView docsResultIcon;
+
+  /**
+   * This method is necessary for ActivityInstrumentationTestCase2.
+   */
+  public UploadResultActivityTest() {
+    super(UploadResultActivity.class);
+  }
+
+  /**
+   * Checks the display of dialog when send to all and all sends are successful.
+   */
+  public void testAllSuccess() {
+    initialActivity(true, true, true, true, true, true);
+    createDialogAndGetViews();
+    assertEquals(View.VISIBLE, successFooter.getVisibility()); 
+    assertEquals(View.GONE, errorFooter.getVisibility()); 
+    
+    assertEquals(View.VISIBLE, mapsResult.getVisibility()); 
+    assertEquals(View.VISIBLE, fusionTablesResult.getVisibility()); 
+    assertEquals(View.VISIBLE, docsResult.getVisibility()); 
+    
+    assertEquals(uploadResultActivity.getString(R.string.generic_success_title), mapsResultIcon.getContentDescription());
+    assertEquals(uploadResultActivity.getString(R.string.generic_success_title), fusionTablesResultIcon.getContentDescription());
+    assertEquals(uploadResultActivity.getString(R.string.generic_success_title), docsResultIcon.getContentDescription()); 
+  }
+
+  /**
+   * Checks the display of dialog when send to all and all sends are failed.
+   */
+  public void testAllFailed() {
+    // Send all kinds but all failed.
+    initialActivity(true, true, true, false, false, false);
+    createDialogAndGetViews();
+    assertEquals(View.GONE, successFooter.getVisibility()); 
+    assertEquals(View.VISIBLE, errorFooter.getVisibility()); 
+    
+    assertEquals(View.VISIBLE, mapsResult.getVisibility()); 
+    assertEquals(View.VISIBLE, fusionTablesResult.getVisibility()); 
+    assertEquals(View.VISIBLE, docsResult.getVisibility()); 
+    
+    assertEquals(uploadResultActivity.getString(R.string.generic_error_title), mapsResultIcon.getContentDescription());
+    assertEquals(uploadResultActivity.getString(R.string.generic_error_title), fusionTablesResultIcon.getContentDescription());
+    assertEquals(uploadResultActivity.getString(R.string.generic_error_title), docsResultIcon.getContentDescription());
+  }
+
+  /**
+   * Checks the display of dialog when match following items:
+   * <ul>
+   * <li>Only send to Maps and Docs.</li>
+   * <li>Send to Maps successful.</li>
+   * <li>Send to Docs failed.</li>
+   * </ul>
+   */
+  public void testPartialSuccess() {
+    initialActivity(true, false, true, true, false, false);
+    createDialogAndGetViews();
+    assertEquals(View.VISIBLE, errorFooter.getVisibility()); 
+    
+    assertEquals(View.VISIBLE, mapsResult.getVisibility()); 
+    assertEquals(View.GONE, fusionTablesResult.getVisibility()); 
+    assertEquals(View.VISIBLE, docsResult.getVisibility()); 
+    
+    assertEquals(uploadResultActivity.getString(R.string.generic_success_title), mapsResultIcon.getContentDescription());
+    assertEquals(uploadResultActivity.getString(R.string.generic_error_title), docsResultIcon.getContentDescription());
+  }
+
+  /**
+   * Initials a {@link SendRequest} and then initials a activity to be tested.
+   * 
+   * @param isSendMaps
+   * @param isSendFusionTables
+   * @param isSendDocs
+   * @param isMapsSuccess
+   * @param isFusionTablesSuccess
+   * @param isDocsSuccess
+   */
+  private void initialActivity(boolean isSendMaps, boolean isSendFusionTables, boolean isSendDocs,
+      boolean isMapsSuccess, boolean isFusionTablesSuccess, boolean isDocsSuccess) {
+    Intent intent = new Intent();
+    SendRequest sendRequest = new SendRequest(1L);
+    sendRequest.setSendMaps(isSendMaps);
+    sendRequest.setSendFusionTables(isSendFusionTables);
+    sendRequest.setSendDocs(isSendDocs);
+    sendRequest.setMapsSuccess(isMapsSuccess);
+    sendRequest.setFusionTablesSuccess(isFusionTablesSuccess);
+    sendRequest.setDocsSuccess(isDocsSuccess);
+    intent.putExtra(SendRequest.SEND_REQUEST_KEY, sendRequest);
+    setActivityIntent(intent);
+    uploadResultActivity = this.getActivity();
+  }
+  
+  /**
+   * Creates result dialog and gets views in the dialog.
+   */
+  private void createDialogAndGetViews() {
+    uploadResultActivity.onCreateDialog(UploadResultActivity.DIALOG_RESULT_ID);
+    View view = uploadResultActivity.view;
+    errorFooter = (TextView) view.findViewById(R.id.upload_result_error_footer);
+    successFooter = (TextView) view.findViewById(R.id.upload_result_success_footer);
+    
+    mapsResult = (LinearLayout) view.findViewById(R.id.upload_result_maps_result);
+    fusionTablesResult = (LinearLayout) view.findViewById(
+        R.id.upload_result_fusion_tables_result);
+    docsResult = (LinearLayout) view.findViewById(R.id.upload_result_docs_result);
+    
+    mapsResultIcon = (ImageView) view.findViewById(R.id.upload_result_maps_result_icon);
+    fusionTablesResultIcon = (ImageView) view.findViewById(
+        R.id.upload_result_fusion_tables_result_icon);
+    docsResultIcon = (ImageView) view.findViewById(R.id.upload_result_docs_result_icon);
+  }
+}