Add m-esr52 at 52.6.0

80 files changed, 9507 insertions, 0 deletions

diff --git a/mobile/android/tests/background/junit3/AndroidManifest.xml.in b/mobile/android/tests/background/junit3/AndroidManifest.xml.in
new file mode 100644
index 000000000..09f1a25a1
--- /dev/null
+++ b/mobile/android/tests/background/junit3/AndroidManifest.xml.in
@@ -0,0 +1,23 @@
+#filter substitution
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.mozilla.gecko.background.tests"
+    sharedUserId="@MOZ_ANDROID_SHARED_ID@"
+    android:versionCode="1"
+    android:versionName="1.0" >
+
+    <uses-sdk android:minSdkVersion="8"
+              android:targetSdkVersion="@ANDROID_TARGET_SDK@" />
+
+    <application
+        android:debuggable="true"
+        android:icon="@drawable/icon"
+        android:label="@ANDROID_BACKGROUND_APP_DISPLAYNAME@">
+        <uses-library android:name="android.test.runner" />
+    </application>
+
+    <instrumentation
+        android:label="@string/app_name"
+        android:name="android.test.InstrumentationTestRunner"
+        android:targetPackage="@ANDROID_BACKGROUND_TARGET_PACKAGE_NAME@" />
+</manifest>
diff --git a/mobile/android/tests/background/junit3/Makefile.in b/mobile/android/tests/background/junit3/Makefile.in
new file mode 100644
index 000000000..f7f40ca78
--- /dev/null
+++ b/mobile/android/tests/background/junit3/Makefile.in
@@ -0,0 +1,13 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+ANDROID_EXTRA_JARS := \
+  background-junit3.jar \
+  $(NULL)
+
+ANDROID_MANIFEST_FILE := $(CURDIR)/AndroidManifest.xml
+
+include $(topsrcdir)/config/rules.mk
+
+tools:: $(ANDROID_APK_NAME).apk
diff --git a/mobile/android/tests/background/junit3/background_junit3_sources.mozbuild b/mobile/android/tests/background/junit3/background_junit3_sources.mozbuild
new file mode 100644
index 000000000..021af2eb8
--- /dev/null
+++ b/mobile/android/tests/background/junit3/background_junit3_sources.mozbuild
@@ -0,0 +1,78 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+background_junit3_sources = [
+    'src/org/mozilla/gecko/background/common/TestAndroidLogWriters.java',
+    'src/org/mozilla/gecko/background/common/TestUtils.java',
+    'src/org/mozilla/gecko/background/common/TestWaitHelper.java',
+    'src/org/mozilla/gecko/background/db/AndroidBrowserRepositoryTestCase.java',
+    'src/org/mozilla/gecko/background/db/TestAndroidBrowserBookmarksRepository.java',
+    'src/org/mozilla/gecko/background/db/TestAndroidBrowserHistoryRepository.java',
+    'src/org/mozilla/gecko/background/db/TestBookmarks.java',
+    'src/org/mozilla/gecko/background/db/TestClientsDatabase.java',
+    'src/org/mozilla/gecko/background/db/TestClientsDatabaseAccessor.java',
+    'src/org/mozilla/gecko/background/db/TestFennecTabsRepositorySession.java',
+    'src/org/mozilla/gecko/background/db/TestFormHistoryRepositorySession.java',
+    'src/org/mozilla/gecko/background/db/TestPasswordsRepository.java',
+    'src/org/mozilla/gecko/background/db/TestTopSites.java',
+    'src/org/mozilla/gecko/background/fxa/authenticator/TestAccountPickler.java',
+    'src/org/mozilla/gecko/background/fxa/TestAccountLoader.java',
+    'src/org/mozilla/gecko/background/fxa/TestBrowserIDKeyPairGeneration.java',
+    'src/org/mozilla/gecko/background/helpers/AndroidSyncTestCase.java',
+    'src/org/mozilla/gecko/background/helpers/DBHelpers.java',
+    'src/org/mozilla/gecko/background/helpers/DBProviderTestCase.java',
+    'src/org/mozilla/gecko/background/nativecode/test/TestNativeCrypto.java',
+    'src/org/mozilla/gecko/background/sync/AndroidSyncTestCaseWithAccounts.java',
+    'src/org/mozilla/gecko/background/sync/helpers/BookmarkHelpers.java',
+    'src/org/mozilla/gecko/background/sync/helpers/DefaultBeginDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/DefaultCleanDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/DefaultDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/DefaultFetchDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/DefaultFinishDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/DefaultGuidsSinceDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/DefaultSessionCreationDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/DefaultStoreDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectBeginDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectBeginFailDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectFetchDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectFetchSinceDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectFinishDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectFinishFailDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectGuidsSinceDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectInvalidRequestFetchDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectInvalidTypeStoreDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectManyStoredDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectNoGUIDsSinceDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectNoStoreDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectStoreCompletedDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/ExpectStoredDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/HistoryHelpers.java',
+    'src/org/mozilla/gecko/background/sync/helpers/PasswordHelpers.java',
+    'src/org/mozilla/gecko/background/sync/helpers/SessionTestHelper.java',
+    'src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessBeginDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessCreationDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessFetchDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessFinishDelegate.java',
+    'src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessStoreDelegate.java',
+    'src/org/mozilla/gecko/background/sync/TestClientsStage.java',
+    'src/org/mozilla/gecko/background/sync/TestResetting.java',
+    'src/org/mozilla/gecko/background/sync/TestStoreTracking.java',
+    'src/org/mozilla/gecko/background/sync/TestSyncConfiguration.java',
+    'src/org/mozilla/gecko/background/sync/TestWebURLFinder.java',
+    'src/org/mozilla/gecko/background/testhelpers/BaseMockServerSyncStage.java',
+    'src/org/mozilla/gecko/background/testhelpers/CommandHelpers.java',
+    'src/org/mozilla/gecko/background/testhelpers/DefaultGlobalSessionCallback.java',
+    'src/org/mozilla/gecko/background/testhelpers/MockAbstractNonRepositorySyncStage.java',
+    'src/org/mozilla/gecko/background/testhelpers/MockClientsDatabaseAccessor.java',
+    'src/org/mozilla/gecko/background/testhelpers/MockClientsDataDelegate.java',
+    'src/org/mozilla/gecko/background/testhelpers/MockGlobalSession.java',
+    'src/org/mozilla/gecko/background/testhelpers/MockPrefsGlobalSession.java',
+    'src/org/mozilla/gecko/background/testhelpers/MockRecord.java',
+    'src/org/mozilla/gecko/background/testhelpers/MockServerSyncStage.java',
+    'src/org/mozilla/gecko/background/testhelpers/MockSharedPreferences.java',
+    'src/org/mozilla/gecko/background/testhelpers/WaitHelper.java',
+    'src/org/mozilla/gecko/background/testhelpers/WBORepository.java',
+]
diff --git a/mobile/android/tests/background/junit3/instrumentation.ini b/mobile/android/tests/background/junit3/instrumentation.ini
new file mode 100644
index 000000000..e2c7b2ea1
--- /dev/null
+++ b/mobile/android/tests/background/junit3/instrumentation.ini
@@ -0,0 +1,22 @@
+[DEFAULT]
+subsuite = background
+
+[src/org/mozilla/gecko/background/common/TestAndroidLogWriters.java]
+[src/org/mozilla/gecko/background/common/TestUtils.java]
+[src/org/mozilla/gecko/background/common/TestWaitHelper.java]
+[src/org/mozilla/gecko/background/db/TestAndroidBrowserBookmarksRepository.java]
+[src/org/mozilla/gecko/background/db/TestAndroidBrowserHistoryRepository.java]
+[src/org/mozilla/gecko/background/db/TestBookmarks.java]
+[src/org/mozilla/gecko/background/db/TestClientsDatabase.java]
+[src/org/mozilla/gecko/background/db/TestClientsDatabaseAccessor.java]
+[src/org/mozilla/gecko/background/db/TestFennecTabsRepositorySession.java]
+[src/org/mozilla/gecko/background/db/TestFormHistoryRepositorySession.java]
+[src/org/mozilla/gecko/background/db/TestPasswordsRepository.java]
+[src/org/mozilla/gecko/background/fxa/TestBrowserIDKeyPairGeneration.java]
+[src/org/mozilla/gecko/background/fxa/authenticator/TestAccountPickler.java]
+[src/org/mozilla/gecko/background/nativecode/test/TestNativeCrypto.java]
+[src/org/mozilla/gecko/background/sync/TestClientsStage.java]
+[src/org/mozilla/gecko/background/sync/TestResetting.java]
+[src/org/mozilla/gecko/background/sync/TestStoreTracking.java]
+[src/org/mozilla/gecko/background/sync/TestSyncConfiguration.java]
+[src/org/mozilla/gecko/background/sync/TestWebURLFinder.java]
diff --git a/mobile/android/tests/background/junit3/moz.build b/mobile/android/tests/background/junit3/moz.build
new file mode 100644
index 000000000..3e81e1e32
--- /dev/null
+++ b/mobile/android/tests/background/junit3/moz.build
@@ -0,0 +1,42 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+DEFINES['ANDROID_PACKAGE_NAME'] = CONFIG['ANDROID_PACKAGE_NAME']
+
+ANDROID_APK_NAME = 'background-junit3-debug'
+ANDROID_APK_PACKAGE = 'org.mozilla.gecko.background.tests'
+
+include('background_junit3_sources.mozbuild')
+
+jar = add_java_jar('background-junit3')
+jar.sources += background_junit3_sources
+jar.extra_jars += [
+    CONFIG['ANDROID_SUPPORT_V4_AAR_LIB'],
+    CONFIG['ANDROID_RECYCLERVIEW_V7_AAR_LIB'],
+    TOPOBJDIR + '/mobile/android/base/constants.jar',
+    TOPOBJDIR + '/mobile/android/base/gecko-R.jar',
+    TOPOBJDIR + '/mobile/android/base/gecko-browser.jar',
+    TOPOBJDIR + '/mobile/android/base/gecko-mozglue.jar',
+    TOPOBJDIR + '/mobile/android/base/gecko-thirdparty.jar',
+    TOPOBJDIR + '/mobile/android/base/gecko-util.jar',
+    TOPOBJDIR + '/mobile/android/base/gecko-view.jar',
+    TOPOBJDIR + '/mobile/android/base/services.jar',
+    TOPOBJDIR + '/mobile/android/base/sync-thirdparty.jar',
+]
+
+if CONFIG['MOZ_ANDROID_MLS_STUMBLER']:
+    jar.extra_jars += [
+        TOPOBJDIR + '/mobile/android/stumbler/stumbler.jar',
+    ]
+
+ANDROID_INSTRUMENTATION_MANIFESTS += ['instrumentation.ini']
+
+DEFINES['ANDROID_BACKGROUND_TARGET_PACKAGE_NAME'] = CONFIG['ANDROID_PACKAGE_NAME']
+DEFINES['ANDROID_BACKGROUND_APP_DISPLAYNAME'] = '%s Background Tests' % CONFIG['MOZ_APP_DISPLAYNAME']
+DEFINES['MOZ_ANDROID_SHARED_ID'] = CONFIG['MOZ_ANDROID_SHARED_ID']
+OBJDIR_PP_FILES.mobile.android.tests.background.junit3 += [
+    'AndroidManifest.xml.in',
+]
diff --git a/mobile/android/tests/background/junit3/res/drawable-hdpi/icon.png b/mobile/android/tests/background/junit3/res/drawable-hdpi/icon.png
new file mode 100644
index 000000000..e83438eee
--- /dev/null
+++ b/mobile/android/tests/background/junit3/res/drawable-hdpi/icon.png
diff --git a/mobile/android/tests/background/junit3/res/drawable-ldpi/icon.png b/mobile/android/tests/background/junit3/res/drawable-ldpi/icon.png
new file mode 100644
index 000000000..0483c95e9
--- /dev/null
+++ b/mobile/android/tests/background/junit3/res/drawable-ldpi/icon.png
diff --git a/mobile/android/tests/background/junit3/res/drawable-mdpi/icon.png b/mobile/android/tests/background/junit3/res/drawable-mdpi/icon.png
new file mode 100644
index 000000000..86b4dee54
--- /dev/null
+++ b/mobile/android/tests/background/junit3/res/drawable-mdpi/icon.png
diff --git a/mobile/android/tests/background/junit3/res/layout/main.xml b/mobile/android/tests/background/junit3/res/layout/main.xml
new file mode 100644
index 000000000..14dbff7e0
--- /dev/null
+++ b/mobile/android/tests/background/junit3/res/layout/main.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:orientation="vertical" >
+
+    <TextView
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/app_name" />
+
+</LinearLayout>
diff --git a/mobile/android/tests/background/junit3/res/values/strings.xml b/mobile/android/tests/background/junit3/res/values/strings.xml
new file mode 100644
index 000000000..d6534d7fa
--- /dev/null
+++ b/mobile/android/tests/background/junit3/res/values/strings.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <string name="app_name">Gecko Background Tests</string>
+
+</resources>
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/common/TestAndroidLogWriters.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/common/TestAndroidLogWriters.java
new file mode 100644
index 000000000..7f4b9bb9c
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/common/TestAndroidLogWriters.java
@@ -0,0 +1,68 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.common;
+
+import org.mozilla.gecko.background.common.log.Logger;
+import org.mozilla.gecko.background.common.log.writers.AndroidLevelCachingLogWriter;
+import org.mozilla.gecko.background.common.log.writers.AndroidLogWriter;
+import org.mozilla.gecko.background.common.log.writers.LogWriter;
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+
+public class TestAndroidLogWriters extends AndroidSyncTestCase {
+  public static final String TEST_LOG_TAG = "TestAndroidLogWriters";
+
+  public static final String TEST_MESSAGE_1 = "LOG TEST MESSAGE one";
+  public static final String TEST_MESSAGE_2 = "LOG TEST MESSAGE two";
+  public static final String TEST_MESSAGE_3 = "LOG TEST MESSAGE three";
+
+  public void setUp() {
+    Logger.stopLoggingToAll();
+  }
+
+  public void tearDown() {
+    Logger.resetLogging();
+  }
+
+  /**
+   * Verify these *all* appear in the Android log by using
+   * <code>adb logcat | grep TestAndroidLogWriters</code> after executing
+   * <code>adb shell setprop log.tag.TestAndroidLogWriters ERROR</code>.
+   * <p>
+   * This writer does not use the Android log levels!
+   */
+  public void testAndroidLogWriter() {
+    LogWriter lw = new AndroidLogWriter();
+
+    Logger.error(TEST_LOG_TAG, TEST_MESSAGE_1, new RuntimeException());
+    Logger.startLoggingTo(lw);
+    Logger.error(TEST_LOG_TAG, TEST_MESSAGE_2);
+    Logger.warn(TEST_LOG_TAG, TEST_MESSAGE_2);
+    Logger.info(TEST_LOG_TAG, TEST_MESSAGE_2);
+    Logger.debug(TEST_LOG_TAG, TEST_MESSAGE_2);
+    Logger.trace(TEST_LOG_TAG, TEST_MESSAGE_2);
+    Logger.stopLoggingTo(lw);
+    Logger.error(TEST_LOG_TAG, TEST_MESSAGE_3, new RuntimeException());
+  }
+
+  /**
+   * Verify only *some* of these appear in the Android log by using
+   * <code>adb logcat | grep TestAndroidLogWriters</code> after executing
+   * <code>adb shell setprop log.tag.TestAndroidLogWriters INFO</code>.
+   * <p>
+   * This writer should use the Android log levels!
+   */
+  public void testAndroidLevelCachingLogWriter() throws Exception {
+    LogWriter lw = new AndroidLevelCachingLogWriter(new AndroidLogWriter());
+
+    Logger.error(TEST_LOG_TAG, TEST_MESSAGE_1, new RuntimeException());
+    Logger.startLoggingTo(lw);
+    Logger.error(TEST_LOG_TAG, TEST_MESSAGE_2);
+    Logger.warn(TEST_LOG_TAG, TEST_MESSAGE_2);
+    Logger.info(TEST_LOG_TAG, TEST_MESSAGE_2);
+    Logger.debug(TEST_LOG_TAG, TEST_MESSAGE_2);
+    Logger.trace(TEST_LOG_TAG, TEST_MESSAGE_2);
+    Logger.stopLoggingTo(lw);
+    Logger.error(TEST_LOG_TAG, TEST_MESSAGE_3, new RuntimeException());
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/common/TestUtils.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/common/TestUtils.java
new file mode 100644
index 000000000..270eae6f6
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/common/TestUtils.java
@@ -0,0 +1,159 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.common;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.sync.Utils;
+
+import android.os.Bundle;
+
+public class TestUtils extends AndroidSyncTestCase {
+  protected static void assertStages(String[] all, String[] sync, String[] skip, String[] expected) {
+    final Set<String> sAll = new HashSet<String>();
+    for (String s : all) {
+      sAll.add(s);
+    }
+    List<String> sSync = null;
+    if (sync != null) {
+      sSync = new ArrayList<String>();
+      for (String s : sync) {
+        sSync.add(s);
+      }
+    }
+    List<String> sSkip = null;
+    if (skip != null) {
+      sSkip = new ArrayList<String>();
+      for (String s : skip) {
+        sSkip.add(s);
+      }
+    }
+    List<String> stages = new ArrayList<String>(Utils.getStagesToSync(sAll, sSync, sSkip));
+    Collections.sort(stages);
+    List<String> exp = new ArrayList<String>();
+    for (String e : expected) {
+      exp.add(e);
+    }
+    assertEquals(exp, stages);
+  }
+
+  public void testGetStagesToSync() {
+    final String[] all = new String[] { "other1", "other2", "skip1", "skip2", "sync1", "sync2" };
+    assertStages(all, null, null, all);
+    assertStages(all, new String[] { "sync1" }, null, new String[] { "sync1" });
+    assertStages(all, null, new String[] { "skip1", "skip2" }, new String[] { "other1", "other2", "sync1", "sync2" });
+    assertStages(all, new String[] { "sync1", "sync2" }, new String[] { "skip1", "skip2" }, new String[] { "sync1", "sync2" });
+  }
+
+  protected static void assertStagesFromBundle(String[] all, String[] sync, String[] skip, String[] expected) {
+    final Set<String> sAll = new HashSet<String>();
+    for (String s : all) {
+      sAll.add(s);
+    }
+    final Bundle bundle = new Bundle();
+    Utils.putStageNamesToSync(bundle, sync, skip);
+
+    Collection<String> ss = Utils.getStagesToSyncFromBundle(sAll, bundle);
+    List<String> stages = new ArrayList<String>(ss);
+    Collections.sort(stages);
+    List<String> exp = new ArrayList<String>();
+    for (String e : expected) {
+      exp.add(e);
+    }
+    assertEquals(exp, stages);
+  }
+
+  public void testGetStagesToSyncFromBundle() {
+    final String[] all = new String[] { "other1", "other2", "skip1", "skip2", "sync1", "sync2" };
+    assertStagesFromBundle(all, null, null, all);
+    assertStagesFromBundle(all, new String[] { "sync1" }, null, new String[] { "sync1" });
+    assertStagesFromBundle(all, null, new String[] { "skip1", "skip2" }, new String[] { "other1", "other2", "sync1", "sync2" });
+    assertStagesFromBundle(all, new String[] { "sync1", "sync2" }, new String[] { "skip1", "skip2" }, new String[] { "sync1", "sync2" });
+  }
+
+  public static void deleteDirectoryRecursively(final File dir) throws IOException {
+    if (!dir.isDirectory()) {
+      throw new IllegalStateException("Given directory, " + dir + ", is not a directory!");
+    }
+
+    for (File f : dir.listFiles()) {
+      if (f.isDirectory()) {
+        deleteDirectoryRecursively(f);
+      } else if (!f.delete()) {
+        // Since this method is for testing, we assume we should be able to do this.
+        throw new IOException("Could not delete file, " + f.getAbsolutePath() + ". Permissions?");
+      }
+    }
+
+    if (!dir.delete()) {
+      throw new IOException("Could not delete dir, " + dir.getAbsolutePath() + ".");
+    }
+  }
+
+  public void testDeleteDirectoryRecursively() throws Exception {
+    final String TEST_DIR = getApplicationContext().getCacheDir().getAbsolutePath() +
+        "-testDeleteDirectory-" + System.currentTimeMillis();
+
+    // Non-existent directory.
+    final File nonexistent = new File("nonexistentDirectory"); // Hopefully. ;)
+    assertFalse(nonexistent.exists());
+    try {
+      deleteDirectoryRecursively(nonexistent);
+      fail("deleteDirectoryRecursively on a nonexistent directory should throw Exception");
+    } catch (IllegalStateException e) { }
+
+    // Empty dir.
+    File dir = mkdir(TEST_DIR);
+    deleteDirectoryRecursively(dir);
+    assertFalse(dir.exists());
+
+    // Filled dir.
+    dir = mkdir(TEST_DIR);
+    populateDir(dir);
+    deleteDirectoryRecursively(dir);
+    assertFalse(dir.exists());
+
+    // Filled dir with empty dir.
+    dir = mkdir(TEST_DIR);
+    populateDir(dir);
+    File subDir = new File(TEST_DIR + File.separator + "subDir");
+    assertTrue(subDir.mkdir());
+    deleteDirectoryRecursively(dir);
+    assertFalse(subDir.exists()); // For short-circuiting errors.
+    assertFalse(dir.exists());
+
+    // Filled dir with filled dir.
+    dir = mkdir(TEST_DIR);
+    populateDir(dir);
+    subDir = new File(TEST_DIR + File.separator + "subDir");
+    assertTrue(subDir.mkdir());
+    populateDir(subDir);
+    deleteDirectoryRecursively(dir);
+    assertFalse(subDir.exists()); // For short-circuiting errors.
+    assertFalse(dir.exists());
+  }
+
+  private File mkdir(final String name) {
+    final File dir = new File(name);
+    assertTrue(dir.mkdir());
+    return dir;
+  }
+
+  private void populateDir(final File dir) throws IOException {
+    assertTrue(dir.isDirectory());
+    final String dirPath = dir.getAbsolutePath();
+    for (int i = 0; i < 3; i++) {
+      final File f = new File(dirPath + File.separator + i);
+      assertTrue(f.createNewFile()); // Throws IOException if file could not be created.
+    }
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/common/TestWaitHelper.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/common/TestWaitHelper.java
new file mode 100644
index 000000000..1f818e0cf
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/common/TestWaitHelper.java
@@ -0,0 +1,356 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.common;
+
+import junit.framework.AssertionFailedError;
+
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.background.testhelpers.WaitHelper;
+import org.mozilla.gecko.background.testhelpers.WaitHelper.InnerError;
+import org.mozilla.gecko.background.testhelpers.WaitHelper.TimeoutError;
+import org.mozilla.gecko.sync.ThreadPool;
+
+public class TestWaitHelper extends AndroidSyncTestCase {
+  private static final String ERROR_UNIQUE_IDENTIFIER = "error unique identifier";
+
+  public static int NO_WAIT    = 1;               // Milliseconds.
+  public static int SHORT_WAIT = 100;             // Milliseconds.
+  public static int LONG_WAIT  = 3 * SHORT_WAIT;
+
+  private Object notifyMonitor = new Object();
+  // Guarded by notifyMonitor.
+  private boolean performNotifyCalled      = false;
+  private boolean performNotifyErrorCalled = false;
+  private void setPerformNotifyCalled() {
+    synchronized (notifyMonitor) {
+      performNotifyCalled = true;
+    }
+  }
+  private void setPerformNotifyErrorCalled() {
+    synchronized (notifyMonitor) {
+      performNotifyErrorCalled = true;
+    }
+  }
+  private void resetNotifyCalled() {
+    synchronized (notifyMonitor) {
+      performNotifyCalled      = false;
+      performNotifyErrorCalled = false;
+    }
+  }
+  private void assertBothCalled() {
+    synchronized (notifyMonitor) {
+      assertTrue(performNotifyCalled);
+      assertTrue(performNotifyErrorCalled);
+    }
+  }
+  private void assertErrorCalled() {
+    synchronized (notifyMonitor) {
+      assertFalse(performNotifyCalled);
+      assertTrue(performNotifyErrorCalled);
+    }
+  }
+  private void assertCalled() {
+    synchronized (notifyMonitor) {
+      assertTrue(performNotifyCalled);
+      assertFalse(performNotifyErrorCalled);
+    }
+  }
+
+  public WaitHelper waitHelper;
+
+  public TestWaitHelper() {
+    super();
+  }
+
+  public void setUp() {
+    WaitHelper.resetTestWaiter();
+    waitHelper = WaitHelper.getTestWaiter();
+    resetNotifyCalled();
+  }
+
+  public void tearDown() {
+    assertTrue(waitHelper.isIdle());
+  }
+
+  public Runnable performNothingRunnable() {
+    return new Runnable() {
+      public void run() {
+      }
+    };
+  }
+
+  public Runnable performNotifyRunnable() {
+    return new Runnable() {
+      public void run() {
+        setPerformNotifyCalled();
+        waitHelper.performNotify();
+      }
+    };
+  }
+
+  public Runnable performNotifyAfterDelayRunnable(final int delayInMillis) {
+    return new Runnable() {
+      public void run() {
+        try {
+          Thread.sleep(delayInMillis);
+        } catch (InterruptedException e) {
+          fail("Interrupted.");
+        }
+
+        setPerformNotifyCalled();
+        waitHelper.performNotify();
+      }
+    };
+  }
+
+  public Runnable performNotifyErrorRunnable() {
+    return new Runnable() {
+      public void run() {
+        setPerformNotifyCalled();
+        waitHelper.performNotify(new AssertionFailedError(ERROR_UNIQUE_IDENTIFIER));
+      }
+    };
+  }
+
+  public Runnable inThreadPool(final Runnable runnable) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        ThreadPool.run(runnable);
+      }
+    };
+  }
+
+  public Runnable inThread(final Runnable runnable) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        new Thread(runnable).start();
+      }
+    };
+  }
+
+  protected void expectAssertionFailedError(Runnable runnable) {
+    try {
+      waitHelper.performWait(runnable);
+    } catch (InnerError e) {
+      AssertionFailedError inner = (AssertionFailedError)e.innerError;
+      setPerformNotifyErrorCalled();
+      String message = inner.getMessage();
+      assertTrue("Expected '" + message + "' to contain '" + ERROR_UNIQUE_IDENTIFIER + "'",
+                 message.contains(ERROR_UNIQUE_IDENTIFIER));
+    }
+  }
+
+  protected void expectAssertionFailedErrorAfterDelay(int wait, Runnable runnable) {
+    try {
+      waitHelper.performWait(wait, runnable);
+    } catch (InnerError e) {
+      AssertionFailedError inner = (AssertionFailedError)e.innerError;
+      setPerformNotifyErrorCalled();
+      String message = inner.getMessage();
+      assertTrue("Expected '" + message + "' to contain '" + ERROR_UNIQUE_IDENTIFIER + "'",
+                 message.contains(ERROR_UNIQUE_IDENTIFIER));
+    }
+  }
+
+  public void testPerformWait() {
+    waitHelper.performWait(performNotifyRunnable());
+    assertCalled();
+  }
+
+  public void testPerformWaitInThread() {
+    waitHelper.performWait(inThread(performNotifyRunnable()));
+    assertCalled();
+  }
+
+  public void testPerformWaitInThreadPool() {
+    waitHelper.performWait(inThreadPool(performNotifyRunnable()));
+    assertCalled();
+  }
+
+  public void testPerformTimeoutWait() {
+    waitHelper.performWait(SHORT_WAIT, performNotifyRunnable());
+    assertCalled();
+  }
+
+  public void testPerformTimeoutWaitInThread() {
+    waitHelper.performWait(SHORT_WAIT, inThread(performNotifyRunnable()));
+    assertCalled();
+  }
+
+  public void testPerformTimeoutWaitInThreadPool() {
+    waitHelper.performWait(SHORT_WAIT, inThreadPool(performNotifyRunnable()));
+    assertCalled();
+  }
+
+  public void testPerformErrorWaitInThread() {
+    expectAssertionFailedError(inThread(performNotifyErrorRunnable()));
+    assertBothCalled();
+  }
+
+  public void testPerformErrorWaitInThreadPool() {
+    expectAssertionFailedError(inThreadPool(performNotifyErrorRunnable()));
+    assertBothCalled();
+  }
+
+  public void testPerformErrorTimeoutWaitInThread() {
+    expectAssertionFailedErrorAfterDelay(SHORT_WAIT, inThread(performNotifyErrorRunnable()));
+    assertBothCalled();
+  }
+
+  public void testPerformErrorTimeoutWaitInThreadPool() {
+    expectAssertionFailedErrorAfterDelay(SHORT_WAIT, inThreadPool(performNotifyErrorRunnable()));
+    assertBothCalled();
+  }
+
+  public void testTimeout() {
+    try {
+      waitHelper.performWait(SHORT_WAIT, performNothingRunnable());
+    } catch (TimeoutError e) {
+      setPerformNotifyErrorCalled();
+      assertEquals(SHORT_WAIT, e.waitTimeInMillis);
+    }
+    assertErrorCalled();
+  }
+
+  /**
+   * This will pass.  The sequence in the main thread is:
+   * - A short delay.
+   * - performNotify is called.
+   * - performWait is called and immediately finds that performNotify was called before.
+   */
+  public void testDelay() {
+    try {
+      waitHelper.performWait(1, performNotifyAfterDelayRunnable(SHORT_WAIT));
+    } catch (AssertionFailedError e) {
+      setPerformNotifyErrorCalled();
+      assertTrue(e.getMessage(), e.getMessage().contains("TIMEOUT"));
+    }
+    assertCalled();
+  }
+
+  public Runnable performNotifyMultipleTimesRunnable() {
+    return new Runnable() {
+      public void run() {
+        waitHelper.performNotify();
+        setPerformNotifyCalled();
+        waitHelper.performNotify();
+      }
+    };
+  }
+
+  public void testPerformNotifyMultipleTimesFails() {
+    try {
+      waitHelper.performWait(NO_WAIT, performNotifyMultipleTimesRunnable()); // Not run on thread, so runnable executes before performWait looks for notifications.
+    } catch (WaitHelper.MultipleNotificationsError e) {
+      setPerformNotifyErrorCalled();
+    }
+    assertBothCalled();
+    assertFalse(waitHelper.isIdle()); // First perform notify should be hanging around.
+    waitHelper.performWait(NO_WAIT, performNothingRunnable());
+  }
+
+  public void testNestedWaitsAndNotifies() {
+      waitHelper.performWait(new Runnable() {
+        @Override
+        public void run() {
+          waitHelper.performWait(new Runnable() {
+            public void run() {
+              setPerformNotifyCalled();
+              waitHelper.performNotify();
+            }
+          });
+          setPerformNotifyErrorCalled();
+          waitHelper.performNotify();
+        }
+      });
+    assertBothCalled();
+  }
+
+  public void testAssertIsReported() {
+    try {
+      waitHelper.performWait(1, new Runnable() {
+        @Override
+        public void run() {
+          assertTrue("unique identifier", false);
+        }
+      });
+    } catch (AssertionFailedError e) {
+      setPerformNotifyErrorCalled();
+      assertTrue(e.getMessage(), e.getMessage().contains("unique identifier"));
+    }
+    assertErrorCalled();
+  }
+
+  /**
+   * The inner wait will timeout, but the outer wait will succeed.  The sequence in the helper thread is:
+   * - A short delay.
+   * - performNotify is called.
+   *
+   * The sequence in the main thread is:
+   * - performWait is called and times out because the helper thread does not call
+   *   performNotify quickly enough.
+   */
+  public void testDelayInThread() throws InterruptedException {
+    waitHelper.performWait(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          waitHelper.performWait(NO_WAIT, inThread(new Runnable() {
+            public void run() {
+              try {
+                Thread.sleep(SHORT_WAIT);
+              } catch (InterruptedException e) {
+                fail("Interrupted.");
+              }
+
+              setPerformNotifyCalled();
+              waitHelper.performNotify();
+            }
+          }));
+        } catch (WaitHelper.TimeoutError e) {
+          setPerformNotifyErrorCalled();
+          assertEquals(NO_WAIT, e.waitTimeInMillis);
+        }
+      }
+    });
+    assertBothCalled();
+  }
+
+  /**
+   * The inner wait will timeout, but the outer wait will succeed.  The sequence in the helper thread is:
+   * - A short delay.
+   * - performNotify is called.
+   *
+   * The sequence in the main thread is:
+   * - performWait is called and times out because the helper thread does not call
+   *   performNotify quickly enough.
+   */
+  public void testDelayInThreadPool() throws InterruptedException {
+    waitHelper.performWait(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          waitHelper.performWait(NO_WAIT, inThreadPool(new Runnable() {
+            public void run() {
+              try {
+                Thread.sleep(SHORT_WAIT);
+              } catch (InterruptedException e) {
+                fail("Interrupted.");
+              }
+
+              setPerformNotifyCalled();
+              waitHelper.performNotify();
+            }
+          }));
+        } catch (WaitHelper.TimeoutError e) {
+          setPerformNotifyErrorCalled();
+          assertEquals(NO_WAIT, e.waitTimeInMillis);
+        }
+      }
+    });
+    assertBothCalled();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/AndroidBrowserRepositoryTestCase.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/AndroidBrowserRepositoryTestCase.java
new file mode 100644
index 000000000..da980735b
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/AndroidBrowserRepositoryTestCase.java
@@ -0,0 +1,818 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.db;
+
+import java.util.concurrent.ExecutorService;
+
+import org.mozilla.gecko.background.common.log.Logger;
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.background.sync.helpers.DefaultBeginDelegate;
+import org.mozilla.gecko.background.sync.helpers.DefaultCleanDelegate;
+import org.mozilla.gecko.background.sync.helpers.DefaultFetchDelegate;
+import org.mozilla.gecko.background.sync.helpers.DefaultFinishDelegate;
+import org.mozilla.gecko.background.sync.helpers.DefaultSessionCreationDelegate;
+import org.mozilla.gecko.background.sync.helpers.DefaultStoreDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectBeginDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectBeginFailDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectFetchDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectFetchSinceDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectFinishDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectFinishFailDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectGuidsSinceDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectInvalidRequestFetchDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectManyStoredDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectStoreCompletedDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectStoredDelegate;
+import org.mozilla.gecko.background.sync.helpers.SessionTestHelper;
+import org.mozilla.gecko.background.testhelpers.WaitHelper;
+import org.mozilla.gecko.db.BrowserContract;
+import org.mozilla.gecko.sync.Utils;
+import org.mozilla.gecko.sync.repositories.InactiveSessionException;
+import org.mozilla.gecko.sync.repositories.InvalidSessionTransitionException;
+import org.mozilla.gecko.sync.repositories.NoStoreDelegateException;
+import org.mozilla.gecko.sync.repositories.Repository;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserRepositoryDataAccessor;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionGuidsSinceDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionWipeDelegate;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+import android.content.ContentValues;
+import android.content.Context;
+
+public abstract class AndroidBrowserRepositoryTestCase extends AndroidSyncTestCase {
+  protected static String LOG_TAG = "BrowserRepositoryTest";
+
+  protected static void wipe(AndroidBrowserRepositoryDataAccessor helper) {
+    Logger.debug(LOG_TAG, "Wiping.");
+    try {
+      helper.wipe();
+    } catch (NullPointerException e) {
+      // This will be handled in begin, here we can just ignore
+      // the error if it actually occurs since this is just test
+      // code. We will throw a ProfileDatabaseException. This
+      // error shouldn't occur in the future, but results from
+      // trying to access content providers before Fennec has
+      // been run at least once.
+      Logger.error(LOG_TAG, "ProfileDatabaseException seen in wipe. Begin should fail");
+      fail("NullPointerException in wipe.");
+    }
+  }
+
+  @Override
+  public void setUp() {
+    AndroidBrowserRepositoryDataAccessor helper = getDataAccessor();
+    wipe(helper);
+    assertTrue(WaitHelper.getTestWaiter().isIdle());
+    closeDataAccessor(helper);
+  }
+
+  public void tearDown() {
+    assertTrue(WaitHelper.getTestWaiter().isIdle());
+  }
+
+  protected RepositorySession createSession() {
+    return SessionTestHelper.createSession(
+        getApplicationContext(),
+        getRepository());
+  }
+
+  protected RepositorySession createAndBeginSession() {
+    return SessionTestHelper.createAndBeginSession(
+        getApplicationContext(),
+        getRepository());
+  }
+
+  protected static void dispose(RepositorySession session) {
+    if (session != null) {
+      session.abort();
+    }
+  }
+
+  /**
+   * Hook to return an ExpectFetchDelegate, possibly with special GUIDs ignored.
+   */
+  public ExpectFetchDelegate preparedExpectFetchDelegate(Record[] expected) {
+    return new ExpectFetchDelegate(expected);
+  }
+
+  /**
+   * Hook to return an ExpectGuidsSinceDelegate, possibly with special GUIDs ignored.
+   */
+  public ExpectGuidsSinceDelegate preparedExpectGuidsSinceDelegate(String[] expected) {
+    return new ExpectGuidsSinceDelegate(expected);
+  }
+
+  /**
+   * Hook to return an ExpectGuidsSinceDelegate expecting only special GUIDs (if there are any).
+   */
+  public ExpectGuidsSinceDelegate preparedExpectOnlySpecialGuidsSinceDelegate() {
+    return new ExpectGuidsSinceDelegate(new String[] {});
+  }
+
+  /**
+   * Hook to return an ExpectFetchSinceDelegate, possibly with special GUIDs ignored.
+   */
+  public ExpectFetchSinceDelegate preparedExpectFetchSinceDelegate(long timestamp, String[] expected) {
+    return new ExpectFetchSinceDelegate(timestamp, expected);
+  }
+
+  public static Runnable storeRunnable(final RepositorySession session, final Record record, final DefaultStoreDelegate delegate) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.setStoreDelegate(delegate);
+        try {
+          session.store(record);
+          session.storeDone();
+        } catch (NoStoreDelegateException e) {
+          fail("NoStoreDelegateException should not occur.");
+        }
+      }
+    };
+  }
+
+  public static Runnable storeRunnable(final RepositorySession session, final Record record) {
+    return storeRunnable(session, record, new ExpectStoredDelegate(record.guid));
+  }
+
+  public static Runnable storeManyRunnable(final RepositorySession session, final Record[] records, final DefaultStoreDelegate delegate) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.setStoreDelegate(delegate);
+        try {
+          for (Record record : records) {
+            session.store(record);
+          }
+          session.storeDone();
+        } catch (NoStoreDelegateException e) {
+          fail("NoStoreDelegateException should not occur.");
+        }
+      }
+    };
+  }
+
+  public static Runnable storeManyRunnable(final RepositorySession session, final Record[] records) {
+    return storeManyRunnable(session, records, new ExpectManyStoredDelegate(records));
+  }
+
+  /**
+   * Store a record and don't expect a store callback until we're done.
+   *
+   * @param session
+   * @param record
+   * @return Runnable.
+   */
+  public static Runnable quietStoreRunnable(final RepositorySession session, final Record record) {
+    return storeRunnable(session, record, new ExpectStoreCompletedDelegate());
+  }
+
+  public static Runnable beginRunnable(final RepositorySession session, final DefaultBeginDelegate delegate) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        try {
+          session.begin(delegate);
+        } catch (InvalidSessionTransitionException e) {
+          performNotify(e);
+        }
+      }
+    };
+  }
+
+  public static Runnable finishRunnable(final RepositorySession session, final DefaultFinishDelegate delegate) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        try {
+          session.finish(delegate);
+        } catch (InactiveSessionException e) {
+          performNotify(e);
+        }
+      }
+    };
+  }
+
+  public static Runnable fetchAllRunnable(final RepositorySession session, final ExpectFetchDelegate delegate) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.fetchAll(delegate);
+      }
+    };
+  }
+
+  public Runnable fetchAllRunnable(final RepositorySession session, final Record[] expectedRecords) {
+    return fetchAllRunnable(session, preparedExpectFetchDelegate(expectedRecords));
+  }
+
+  public Runnable guidsSinceRunnable(final RepositorySession session, final long timestamp, final String[] expected) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.guidsSince(timestamp, preparedExpectGuidsSinceDelegate(expected));
+      }
+    };
+  }
+
+  public Runnable fetchSinceRunnable(final RepositorySession session, final long timestamp, final String[] expected) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.fetchSince(timestamp, preparedExpectFetchSinceDelegate(timestamp, expected));
+      }
+    };
+  }
+
+  public static Runnable fetchRunnable(final RepositorySession session, final String[] guids, final DefaultFetchDelegate delegate) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        try {
+          session.fetch(guids, delegate);
+        } catch (InactiveSessionException e) {
+          performNotify(e);
+        }
+      }
+    };
+  }
+  public Runnable fetchRunnable(final RepositorySession session, final String[] guids, final Record[] expected) {
+    return fetchRunnable(session, guids, preparedExpectFetchDelegate(expected));
+  }
+
+  public static Runnable cleanRunnable(final Repository repository, final boolean success, final Context context, final DefaultCleanDelegate delegate) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        repository.clean(success, delegate, context);
+      }
+    };
+  }
+
+  protected abstract Repository getRepository();
+  protected abstract AndroidBrowserRepositoryDataAccessor getDataAccessor();
+
+  protected static void doStore(RepositorySession session, Record[] records) {
+    performWait(storeManyRunnable(session, records));
+  }
+
+  // Tests to implement
+  public abstract void testFetchAll();
+  public abstract void testGuidsSinceReturnMultipleRecords();
+  public abstract void testGuidsSinceReturnNoRecords();
+  public abstract void testFetchSinceOneRecord();
+  public abstract void testFetchSinceReturnNoRecords();
+  public abstract void testFetchOneRecordByGuid();
+  public abstract void testFetchMultipleRecordsByGuids();
+  public abstract void testFetchNoRecordByGuid();
+  public abstract void testWipe();
+  public abstract void testStore();
+  public abstract void testRemoteNewerTimeStamp();
+  public abstract void testLocalNewerTimeStamp();
+  public abstract void testDeleteRemoteNewer();
+  public abstract void testDeleteLocalNewer();
+  public abstract void testDeleteRemoteLocalNonexistent();
+  public abstract void testStoreIdenticalExceptGuid();
+  public abstract void testCleanMultipleRecords();
+
+
+  /*
+   * Test abstractions
+   */
+  protected void basicStoreTest(Record record) {
+    final RepositorySession session = createAndBeginSession();
+    performWait(storeRunnable(session, record));
+  }
+
+  protected void basicFetchAllTest(Record[] expected) {
+    Logger.debug("rnewman", "Starting testFetchAll.");
+    RepositorySession session = createAndBeginSession();
+    Logger.debug("rnewman", "Prepared.");
+
+    AndroidBrowserRepositoryDataAccessor helper = getDataAccessor();
+    helper.dumpDB();
+    performWait(storeManyRunnable(session, expected));
+
+    helper.dumpDB();
+    performWait(fetchAllRunnable(session, expected));
+
+    closeDataAccessor(helper);
+    dispose(session);
+  }
+
+  /*
+   * Tests for clean
+   */
+  // Input: 4 records; 2 which are to be cleaned, 2 which should remain after the clean
+  protected void cleanMultipleRecords(Record delete0, Record delete1, Record keep0, Record keep1, Record keep2) {
+    RepositorySession session = createAndBeginSession();
+    doStore(session, new Record[] {
+        delete0, delete1, keep0, keep1, keep2
+    });
+
+    // Force two records to appear deleted.
+    AndroidBrowserRepositoryDataAccessor db = getDataAccessor();
+    ContentValues cv = new ContentValues();
+    cv.put(BrowserContract.SyncColumns.IS_DELETED, 1);
+    db.updateByGuid(delete0.guid, cv);
+    db.updateByGuid(delete1.guid, cv);
+
+    final DefaultCleanDelegate delegate = new DefaultCleanDelegate() {
+      public void onCleaned(Repository repo) {
+        performNotify();
+      }
+    };
+
+    final Runnable cleanRunnable = cleanRunnable(
+        getRepository(),
+        true,
+        getApplicationContext(),
+        delegate);
+
+    performWait(cleanRunnable);
+    performWait(fetchAllRunnable(session, preparedExpectFetchDelegate(new Record[] { keep0, keep1, keep2})));
+    closeDataAccessor(db);
+    dispose(session);
+  }
+
+  /*
+   * Tests for guidsSince
+   */
+  protected void guidsSinceReturnMultipleRecords(Record record0, Record record1) {
+    RepositorySession session = createAndBeginSession();
+    long timestamp = System.currentTimeMillis();
+
+    String[] expected = new String[2];
+    expected[0] = record0.guid;
+    expected[1] = record1.guid;
+
+    Logger.debug(getName(), "Storing two records...");
+    performWait(storeManyRunnable(session, new Record[] { record0, record1 }));
+    Logger.debug(getName(), "Getting guids since " + timestamp + "; expecting " + expected.length);
+    performWait(guidsSinceRunnable(session, timestamp, expected));
+    dispose(session);
+  }
+
+  protected void guidsSinceReturnNoRecords(Record record0) {
+    RepositorySession session = createAndBeginSession();
+
+    //  Store 1 record in the past.
+    performWait(storeRunnable(session, record0));
+
+    String[] expected = {};
+    performWait(guidsSinceRunnable(session, System.currentTimeMillis() + 1000, expected));
+    dispose(session);
+  }
+
+  /*
+   * Tests for fetchSince
+   */
+  protected void fetchSinceOneRecord(Record record0, Record record1) {
+    RepositorySession session = createAndBeginSession();
+
+    performWait(storeRunnable(session, record0));
+    long timestamp = System.currentTimeMillis();
+    Logger.debug("fetchSinceOneRecord", "Entering synchronized section. Timestamp " + timestamp);
+    synchronized(this) {
+      try {
+        wait(1000);
+      } catch (InterruptedException e) {
+        Logger.warn("fetchSinceOneRecord", "Interrupted.", e);
+      }
+    }
+    Logger.debug("fetchSinceOneRecord", "Storing.");
+    performWait(storeRunnable(session, record1));
+
+    Logger.debug("fetchSinceOneRecord", "Fetching record 1.");
+    String[] expectedOne = new String[] { record1.guid };
+    performWait(fetchSinceRunnable(session, timestamp + 10, expectedOne));
+
+    Logger.debug("fetchSinceOneRecord", "Fetching both, relying on inclusiveness.");
+    String[] expectedBoth = new String[] { record0.guid, record1.guid };
+    performWait(fetchSinceRunnable(session, timestamp - 3000, expectedBoth));
+
+    Logger.debug("fetchSinceOneRecord", "Done.");
+    dispose(session);
+  }
+
+  protected void fetchSinceReturnNoRecords(Record record) {
+    RepositorySession session = createAndBeginSession();
+
+    performWait(storeRunnable(session, record));
+
+    long timestamp = System.currentTimeMillis();
+
+    performWait(fetchSinceRunnable(session, timestamp + 2000, new String[] {}));
+    dispose(session);
+  }
+
+  protected void fetchOneRecordByGuid(Record record0, Record record1) {
+    RepositorySession session = createAndBeginSession();
+
+    Record[] store = new Record[] { record0, record1 };
+    performWait(storeManyRunnable(session, store));
+
+    String[] guids = new String[] { record0.guid };
+    Record[] expected = new Record[] { record0 };
+    performWait(fetchRunnable(session, guids, expected));
+    dispose(session);
+  }
+
+  protected void fetchMultipleRecordsByGuids(Record record0,
+      Record record1, Record record2) {
+    RepositorySession session = createAndBeginSession();
+
+    Record[] store = new Record[] { record0, record1, record2 };
+    performWait(storeManyRunnable(session, store));
+
+    String[] guids = new String[] { record0.guid, record2.guid };
+    Record[] expected = new Record[] { record0, record2 };
+    performWait(fetchRunnable(session, guids, expected));
+    dispose(session);
+  }
+
+  protected void fetchNoRecordByGuid(Record record) {
+    RepositorySession session = createAndBeginSession();
+
+    performWait(storeRunnable(session, record));
+    performWait(fetchRunnable(session,
+        new String[] { Utils.generateGuid() },
+        new Record[] {}));
+    dispose(session);
+  }
+
+  /*
+   * Test wipe
+   */
+   protected void doWipe(final Record record0, final Record record1) {
+     final RepositorySession session = createAndBeginSession();
+     final Runnable run = new Runnable() {
+       @Override
+       public void run() {
+         session.wipe(new RepositorySessionWipeDelegate() {
+           public void onWipeSucceeded() {
+             performNotify();
+           }
+           public void onWipeFailed(Exception ex) {
+             fail("wipe should have succeeded");
+             performNotify();
+           }
+           @Override
+           public RepositorySessionWipeDelegate deferredWipeDelegate(final ExecutorService executor) {
+             final RepositorySessionWipeDelegate self = this;
+             return new RepositorySessionWipeDelegate() {
+
+               @Override
+               public void onWipeSucceeded() {
+                 new Thread(new Runnable() {
+                   @Override
+                   public void run() {
+                     self.onWipeSucceeded();
+                   }}).start();
+               }
+
+               @Override
+               public void onWipeFailed(final Exception ex) {
+                 new Thread(new Runnable() {
+                   @Override
+                   public void run() {
+                     self.onWipeFailed(ex);
+                   }}).start();
+               }
+
+               @Override
+               public RepositorySessionWipeDelegate deferredWipeDelegate(ExecutorService newExecutor) {
+                 if (newExecutor == executor) {
+                   return this;
+                 }
+                 throw new IllegalArgumentException("Can't re-defer this delegate.");
+               }
+             };
+           }
+         });
+       }
+     };
+
+     // Store 2 records.
+     Record[] records = new Record[] { record0, record1 };
+     performWait(storeManyRunnable(session, records));
+     performWait(fetchAllRunnable(session, records));
+
+     // Wipe.
+     performWait(run);
+     dispose(session);
+   }
+
+   /*
+    * TODO adding or subtracting from lastModified timestamps does NOTHING
+    * since it gets overwritten when we store stuff. See other tests
+    * for ways to do this properly.
+    */
+
+   /*
+    * Record being stored has newer timestamp than existing local record, local
+    * record has not been modified since last sync.
+    */
+   protected void remoteNewerTimeStamp(Record local, Record remote) {
+     final RepositorySession session = createAndBeginSession();
+
+     // Record existing and hasn't changed since before lastSync.
+     // Automatically will be assigned lastModified = current time.
+     performWait(storeRunnable(session, local));
+
+     remote.guid = local.guid;
+
+     // Get the timestamp and make remote newer than it
+     ExpectFetchDelegate timestampDelegate = preparedExpectFetchDelegate(new Record[] { local });
+     performWait(fetchRunnable(session, new String[] { remote.guid }, timestampDelegate));
+     remote.lastModified = timestampDelegate.records.get(0).lastModified + 1000;
+     performWait(storeRunnable(session, remote));
+
+     Record[] expected = new Record[] { remote };
+     ExpectFetchDelegate delegate = preparedExpectFetchDelegate(expected);
+     performWait(fetchAllRunnable(session, delegate));
+     dispose(session);
+   }
+
+   /*
+    * Local record has a newer timestamp than the record being stored. For now,
+    * we just take newer (local) record)
+    */
+   protected void localNewerTimeStamp(Record local, Record remote) {
+     final RepositorySession session = createAndBeginSession();
+
+     performWait(storeRunnable(session, local));
+
+     remote.guid = local.guid;
+
+     // Get the timestamp and make remote older than it
+     ExpectFetchDelegate timestampDelegate = preparedExpectFetchDelegate(new Record[] { local });
+     performWait(fetchRunnable(session, new String[] { remote.guid }, timestampDelegate));
+     remote.lastModified = timestampDelegate.records.get(0).lastModified - 1000;
+     performWait(storeRunnable(session, remote));
+
+     // Do a fetch and make sure that we get back the local record.
+     Record[] expected = new Record[] { local };
+     performWait(fetchAllRunnable(session, preparedExpectFetchDelegate(expected)));
+     dispose(session);
+   }
+
+   /*
+    * Insert a record that is marked as deleted, remote has newer timestamp
+    */
+   protected void deleteRemoteNewer(Record local, Record remote) {
+     final RepositorySession session = createAndBeginSession();
+
+     // Record existing and hasn't changed since before lastSync.
+     // Automatically will be assigned lastModified = current time.
+     performWait(storeRunnable(session, local));
+
+     // Pass the same record to store, but mark it deleted and modified
+     // more recently
+     ExpectFetchDelegate timestampDelegate = preparedExpectFetchDelegate(new Record[] { local });
+     performWait(fetchRunnable(session, new String[] { local.guid }, timestampDelegate));
+     remote.lastModified = timestampDelegate.records.get(0).lastModified + 1000;
+     remote.deleted = true;
+     remote.guid = local.guid;
+     performWait(storeRunnable(session, remote));
+
+     performWait(fetchAllRunnable(session, preparedExpectFetchDelegate(new Record[]{})));
+     dispose(session);
+   }
+
+   // Store two records that are identical (this has different meanings based on the
+   // type of record) other than their guids. The record existing locally already
+   // should have its guid replaced (the assumption is that the record existed locally
+   // and then sync was enabled and this record existed on another sync'd device).
+   public void storeIdenticalExceptGuid(Record record0) {
+     Logger.debug("storeIdenticalExceptGuid", "Started.");
+     final RepositorySession session = createAndBeginSession();
+     Logger.debug("storeIdenticalExceptGuid", "Session is " + session);
+     performWait(storeRunnable(session, record0));
+     Logger.debug("storeIdenticalExceptGuid", "Stored record0.");
+     DefaultFetchDelegate timestampDelegate = getTimestampDelegate(record0.guid);
+
+     performWait(fetchRunnable(session, new String[] { record0.guid }, timestampDelegate));
+     Logger.debug("storeIdenticalExceptGuid", "fetchRunnable done.");
+     record0.lastModified = timestampDelegate.records.get(0).lastModified + 3000;
+     record0.guid = Utils.generateGuid();
+     Logger.debug("storeIdenticalExceptGuid", "Storing modified...");
+     performWait(storeRunnable(session, record0));
+     Logger.debug("storeIdenticalExceptGuid", "Stored modified.");
+
+     Record[] expected = new Record[] { record0 };
+     performWait(fetchAllRunnable(session, preparedExpectFetchDelegate(expected)));
+     Logger.debug("storeIdenticalExceptGuid", "Fetched all. Returning.");
+     dispose(session);
+   }
+
+   // Special delegate so that we don't verify parenting is correct since
+   // at some points it won't be since parent folder hasn't been stored.
+   private DefaultFetchDelegate getTimestampDelegate(final String guid) {
+     return new DefaultFetchDelegate() {
+       @Override
+       public void onFetchCompleted(final long fetchEnd) {
+         assertEquals(guid, this.records.get(0).guid);
+         performNotify();
+       }
+     };
+   }
+
+   /*
+    * Insert a record that is marked as deleted, local has newer timestamp
+    * and was not marked deleted (so keep it)
+    */
+   protected void deleteLocalNewer(Record local, Record remote) {
+     Logger.debug("deleteLocalNewer", "Begin.");
+     final RepositorySession session = createAndBeginSession();
+
+     Logger.debug("deleteLocalNewer", "Storing local...");
+     performWait(storeRunnable(session, local));
+
+     // Create an older version of a record with the same GUID.
+     remote.guid = local.guid;
+
+     Logger.debug("deleteLocalNewer", "Fetching...");
+
+     // Get the timestamp and make remote older than it
+     Record[] expected = new Record[] { local };
+     ExpectFetchDelegate timestampDelegate = preparedExpectFetchDelegate(expected);
+     performWait(fetchRunnable(session, new String[] { remote.guid }, timestampDelegate));
+
+     Logger.debug("deleteLocalNewer", "Fetched.");
+     remote.lastModified = timestampDelegate.records.get(0).lastModified - 1000;
+
+     Logger.debug("deleteLocalNewer", "Last modified is " + remote.lastModified);
+     remote.deleted = true;
+     Logger.debug("deleteLocalNewer", "Storing deleted...");
+     performWait(quietStoreRunnable(session, remote));      // This appears to do a lot of work...?!
+
+     // Do a fetch and make sure that we get back the first (local) record.
+     performWait(fetchAllRunnable(session, preparedExpectFetchDelegate(expected)));
+     Logger.debug("deleteLocalNewer", "Fetched and done!");
+     dispose(session);
+   }
+
+   /*
+    * Insert a record that is marked as deleted, record never existed locally
+    */
+   protected void deleteRemoteLocalNonexistent(Record remote) {
+     final RepositorySession session = createAndBeginSession();
+
+     long timestamp = 1000000000;
+
+     // Pass a record marked deleted to store, doesn't exist locally
+     remote.lastModified = timestamp;
+     remote.deleted = true;
+     performWait(quietStoreRunnable(session, remote));
+
+     ExpectFetchDelegate delegate = preparedExpectFetchDelegate(new Record[]{});
+     performWait(fetchAllRunnable(session, delegate));
+     dispose(session);
+   }
+
+   /*
+    * Tests that don't require specific records based on type of repository.
+    * These tests don't need to be overriden in subclasses, they will just work.
+    */
+   public void testCreateSessionNullContext() {
+     Logger.debug(LOG_TAG, "In testCreateSessionNullContext.");
+     Repository repo = getRepository();
+     try {
+       repo.createSession(new DefaultSessionCreationDelegate(), null);
+       fail("Should throw.");
+     } catch (Exception ex) {
+       assertNotNull(ex);
+     }
+   }
+
+   public void testStoreNullRecord() {
+     final RepositorySession session = createAndBeginSession();
+     try {
+       session.setStoreDelegate(new DefaultStoreDelegate());
+       session.store(null);
+       fail("Should throw.");
+     } catch (Exception ex) {
+       assertNotNull(ex);
+     }
+     dispose(session);
+   }
+
+   public void testFetchNoGuids() {
+     final RepositorySession session = createAndBeginSession();
+     performWait(fetchRunnable(session, new String[] {}, new ExpectInvalidRequestFetchDelegate()));
+     dispose(session);
+   }
+
+   public void testFetchNullGuids() {
+     final RepositorySession session = createAndBeginSession();
+     performWait(fetchRunnable(session, null, new ExpectInvalidRequestFetchDelegate()));
+     dispose(session);
+   }
+
+   public void testBeginOnNewSession() {
+     final RepositorySession session = createSession();
+     performWait(beginRunnable(session, new ExpectBeginDelegate()));
+     dispose(session);
+   }
+
+   public void testBeginOnRunningSession() {
+     final RepositorySession session = createAndBeginSession();
+     try {
+       session.begin(new ExpectBeginFailDelegate());
+     } catch (InvalidSessionTransitionException e) {
+       dispose(session);
+       return;
+     }
+     fail("Should have caught InvalidSessionTransitionException.");
+   }
+
+   public void testBeginOnFinishedSession() throws InactiveSessionException {
+     final RepositorySession session = createAndBeginSession();
+     performWait(finishRunnable(session, new ExpectFinishDelegate()));
+     try {
+       session.begin(new ExpectBeginFailDelegate());
+     } catch (InvalidSessionTransitionException e) {
+       Logger.debug(getName(), "Yay! Got an exception.", e);
+       dispose(session);
+       return;
+     } catch (Exception e) {
+       Logger.debug(getName(), "Yay! Got an exception.", e);
+       dispose(session);
+       return;
+     }
+     fail("Should have caught InvalidSessionTransitionException.");
+   }
+
+   public void testFinishOnFinishedSession() throws InactiveSessionException {
+     final RepositorySession session = createAndBeginSession();
+     performWait(finishRunnable(session, new ExpectFinishDelegate()));
+     try {
+       session.finish(new ExpectFinishFailDelegate());
+     } catch (InactiveSessionException e) {
+       dispose(session);
+       return;
+     }
+     fail("Should have caught InactiveSessionException.");
+   }
+
+   public void testFetchOnInactiveSession() throws InactiveSessionException {
+     final RepositorySession session = createSession();
+     try {
+       session.fetch(new String[] { Utils.generateGuid() }, new DefaultFetchDelegate());
+     } catch (InactiveSessionException e) {
+       // Yay.
+       dispose(session);
+       return;
+     };
+     fail("Should have caught InactiveSessionException.");
+   }
+
+   public void testFetchOnFinishedSession() {
+     final RepositorySession session = createAndBeginSession();
+     Logger.debug(getName(), "Finishing...");
+     performWait(finishRunnable(session, new ExpectFinishDelegate()));
+     try {
+       session.fetch(new String[] { Utils.generateGuid() }, new DefaultFetchDelegate());
+     } catch (InactiveSessionException e) {
+       // Yay.
+       dispose(session);
+       return;
+     };
+     fail("Should have caught InactiveSessionException.");
+   }
+
+   public void testGuidsSinceOnUnstartedSession() {
+     final RepositorySession session = createSession();
+     Runnable run = new Runnable() {
+       @Override
+       public void run() {
+         session.guidsSince(System.currentTimeMillis(),
+             new RepositorySessionGuidsSinceDelegate() {
+           public void onGuidsSinceSucceeded(String[] guids) {
+             fail("Session inactive, should fail");
+             performNotify();
+           }
+
+           public void onGuidsSinceFailed(Exception ex) {
+             verifyInactiveException(ex);
+             performNotify();
+           }
+         });
+       }
+     };
+     performWait(run);
+     dispose(session);
+   }
+
+   private static void verifyInactiveException(Exception ex) {
+     if (!(ex instanceof InactiveSessionException)) {
+       fail("Wrong exception type");
+     }
+   }
+
+   protected void closeDataAccessor(AndroidBrowserRepositoryDataAccessor dataAccessor) {
+   }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestAndroidBrowserBookmarksRepository.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestAndroidBrowserBookmarksRepository.java
new file mode 100644
index 000000000..71563a46c
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestAndroidBrowserBookmarksRepository.java
@@ -0,0 +1,636 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.db;
+
+import java.util.ArrayList;
+
+import org.json.simple.JSONArray;
+import org.mozilla.gecko.background.sync.helpers.BookmarkHelpers;
+import org.mozilla.gecko.background.sync.helpers.ExpectFetchDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectFetchSinceDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectFinishDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectGuidsSinceDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectInvalidTypeStoreDelegate;
+import org.mozilla.gecko.db.BrowserContract;
+import org.mozilla.gecko.sync.Utils;
+import org.mozilla.gecko.sync.repositories.InactiveSessionException;
+import org.mozilla.gecko.sync.repositories.NullCursorException;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserBookmarksDataAccessor;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserBookmarksRepository;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserBookmarksRepositorySession;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserRepository;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserRepositoryDataAccessor;
+import org.mozilla.gecko.sync.repositories.android.BrowserContractHelpers;
+import org.mozilla.gecko.sync.repositories.android.RepoUtils;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
+import org.mozilla.gecko.sync.repositories.domain.BookmarkRecord;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+
+public class TestAndroidBrowserBookmarksRepository extends AndroidBrowserRepositoryTestCase {
+
+  @Override
+  protected AndroidBrowserRepository getRepository() {
+
+    /**
+     * Override this chain in order to avoid our test code having to create two
+     * sessions all the time.
+     */
+    return new AndroidBrowserBookmarksRepository() {
+      @Override
+      protected void sessionCreator(RepositorySessionCreationDelegate delegate, Context context) {
+        AndroidBrowserBookmarksRepositorySession session;
+        session = new AndroidBrowserBookmarksRepositorySession(this, context) {
+          @Override
+          protected synchronized void trackGUID(String guid) {
+            System.out.println("Ignoring trackGUID call: this is a test!");
+          }
+        };
+        delegate.deferredCreationDelegate().onSessionCreated(session);
+      }
+    };
+  }
+
+  @Override
+  protected AndroidBrowserRepositoryDataAccessor getDataAccessor() {
+    return new AndroidBrowserBookmarksDataAccessor(getApplicationContext());
+  }
+
+  /**
+   * Hook to return an ExpectFetchDelegate, possibly with special GUIDs ignored.
+   */
+  @Override
+  public ExpectFetchDelegate preparedExpectFetchDelegate(Record[] expected) {
+    ExpectFetchDelegate delegate = new ExpectFetchDelegate(expected);
+    delegate.ignore.addAll(AndroidBrowserBookmarksRepositorySession.SPECIAL_GUIDS_MAP.keySet());
+    return delegate;
+  }
+
+  /**
+   * Hook to return an ExpectGuidsSinceDelegate expecting only special GUIDs (if there are any).
+   */
+  public ExpectGuidsSinceDelegate preparedExpectOnlySpecialGuidsSinceDelegate() {
+    ExpectGuidsSinceDelegate delegate = new ExpectGuidsSinceDelegate(AndroidBrowserBookmarksRepositorySession.SPECIAL_GUIDS_MAP.keySet().toArray(new String[] {}));
+    return delegate;
+  }
+
+  /**
+   * Hook to return an ExpectGuidsSinceDelegate, possibly with special GUIDs ignored.
+   */
+  @Override
+  public ExpectGuidsSinceDelegate preparedExpectGuidsSinceDelegate(String[] expected) {
+    ExpectGuidsSinceDelegate delegate = new ExpectGuidsSinceDelegate(expected);
+    delegate.ignore.addAll(AndroidBrowserBookmarksRepositorySession.SPECIAL_GUIDS_MAP.keySet());
+    return delegate;
+  }
+
+  /**
+   * Hook to return an ExpectFetchSinceDelegate, possibly with special GUIDs ignored.
+   */
+  public ExpectFetchSinceDelegate preparedExpectFetchSinceDelegate(long timestamp, String[] expected) {
+    ExpectFetchSinceDelegate delegate = new ExpectFetchSinceDelegate(timestamp, expected);
+    delegate.ignore.addAll(AndroidBrowserBookmarksRepositorySession.SPECIAL_GUIDS_MAP.keySet());
+    return delegate;
+  }
+
+  // NOTE NOTE NOTE
+  // Must store folder before records if we we are checking that the
+  // records returned are the same as those sent in. If the folder isn't stored
+  // first, the returned records won't be identical to those stored because we
+  // aren't able to find the parent name/guid when we do a fetch. If you don't want
+  // to store a folder first, store your record in "mobile" or one of the folders
+  // that always exists.
+
+  public void testFetchOneWithChildren() {
+    BookmarkRecord folder = BookmarkHelpers.createFolder1();
+    BookmarkRecord bookmark1 = BookmarkHelpers.createBookmark1();
+    BookmarkRecord bookmark2 = BookmarkHelpers.createBookmark2();
+
+    RepositorySession session = createAndBeginSession();
+
+    Record[] records = new Record[] { folder, bookmark1, bookmark2 };
+    performWait(storeManyRunnable(session, records));
+
+    AndroidBrowserRepositoryDataAccessor helper = getDataAccessor();
+    helper.dumpDB();
+    closeDataAccessor(helper);
+
+    String[] guids = new String[] { folder.guid };
+    Record[] expected = new Record[] { folder };
+    performWait(fetchRunnable(session, guids, expected));
+    dispose(session);
+  }
+
+  @Override
+  public void testFetchAll() {
+    Record[] expected = new Record[3];
+    expected[0] = BookmarkHelpers.createFolder1();
+    expected[1] = BookmarkHelpers.createBookmark1();
+    expected[2] = BookmarkHelpers.createBookmark2();
+    basicFetchAllTest(expected);
+  }
+
+  @Override
+  public void testGuidsSinceReturnMultipleRecords() {
+    BookmarkRecord record0 = BookmarkHelpers.createBookmark1();
+    BookmarkRecord record1 = BookmarkHelpers.createBookmark2();
+    guidsSinceReturnMultipleRecords(record0, record1);
+  }
+
+  @Override
+  public void testGuidsSinceReturnNoRecords() {
+    guidsSinceReturnNoRecords(BookmarkHelpers.createBookmarkInMobileFolder1());
+  }
+
+  @Override
+  public void testFetchSinceOneRecord() {
+    fetchSinceOneRecord(BookmarkHelpers.createBookmarkInMobileFolder1(),
+        BookmarkHelpers.createBookmarkInMobileFolder2());
+  }
+
+  @Override
+  public void testFetchSinceReturnNoRecords() {
+    fetchSinceReturnNoRecords(BookmarkHelpers.createBookmark1());
+  }
+
+  @Override
+  public void testFetchOneRecordByGuid() {
+    fetchOneRecordByGuid(BookmarkHelpers.createBookmarkInMobileFolder1(),
+        BookmarkHelpers.createBookmarkInMobileFolder2());
+  }
+
+  @Override
+  public void testFetchMultipleRecordsByGuids() {
+    BookmarkRecord record0 = BookmarkHelpers.createFolder1();
+    BookmarkRecord record1 = BookmarkHelpers.createBookmark1();
+    BookmarkRecord record2 = BookmarkHelpers.createBookmark2();
+    fetchMultipleRecordsByGuids(record0, record1, record2);
+  }
+
+  @Override
+  public void testFetchNoRecordByGuid() {
+    fetchNoRecordByGuid(BookmarkHelpers.createBookmark1());
+  }
+
+
+  @Override
+  public void testWipe() {
+    doWipe(BookmarkHelpers.createBookmarkInMobileFolder1(),
+        BookmarkHelpers.createBookmarkInMobileFolder2());
+  }
+
+  @Override
+  public void testStore() {
+    basicStoreTest(BookmarkHelpers.createBookmark1());
+  }
+
+
+  public void testStoreFolder() {
+    basicStoreTest(BookmarkHelpers.createFolder1());
+  }
+
+  /**
+   * TODO: 2011-12-24, tests disabled because we no longer fail
+   * a store call if we get an unknown record type.
+   */
+  /*
+   * Test storing each different type of Bookmark record.
+   * We expect any records with type other than "bookmark"
+   * or "folder" to fail. For now we throw these away.
+   */
+  /*
+  public void testStoreMicrosummary() {
+    basicStoreFailTest(BookmarkHelpers.createMicrosummary());
+  }
+
+  public void testStoreQuery() {
+    basicStoreFailTest(BookmarkHelpers.createQuery());
+  }
+
+  public void testStoreLivemark() {
+    basicStoreFailTest(BookmarkHelpers.createLivemark());
+  }
+
+  public void testStoreSeparator() {
+    basicStoreFailTest(BookmarkHelpers.createSeparator());
+  }
+   */
+
+  protected void basicStoreFailTest(Record record) {
+    final RepositorySession session = createAndBeginSession();
+    performWait(storeRunnable(session, record, new ExpectInvalidTypeStoreDelegate()));
+    dispose(session);
+  }
+
+  /*
+   * Re-parenting tests
+   */
+  // Insert two records missing parent, then insert their parent.
+  // Make sure they end up with the correct parent on fetch.
+  public void testBasicReparenting() throws InactiveSessionException {
+    Record[] expected = new Record[] {
+        BookmarkHelpers.createBookmark1(),
+        BookmarkHelpers.createBookmark2(),
+        BookmarkHelpers.createFolder1()
+    };
+    doMultipleFolderReparentingTest(expected);
+  }
+
+  // Insert 3 folders and 4 bookmarks in different orders
+  // and make sure they come out parented correctly
+  public void testMultipleFolderReparenting1() throws InactiveSessionException {
+    Record[] expected = new Record[] {
+        BookmarkHelpers.createBookmark1(),
+        BookmarkHelpers.createBookmark2(),
+        BookmarkHelpers.createBookmark3(),
+        BookmarkHelpers.createFolder1(),
+        BookmarkHelpers.createBookmark4(),
+        BookmarkHelpers.createFolder3(),
+        BookmarkHelpers.createFolder2(),
+    };
+    doMultipleFolderReparentingTest(expected);
+  }
+
+  public void testMultipleFolderReparenting2() throws InactiveSessionException {
+    Record[] expected = new Record[] {
+        BookmarkHelpers.createBookmark1(),
+        BookmarkHelpers.createBookmark2(),
+        BookmarkHelpers.createBookmark3(),
+        BookmarkHelpers.createFolder1(),
+        BookmarkHelpers.createBookmark4(),
+        BookmarkHelpers.createFolder3(),
+        BookmarkHelpers.createFolder2(),
+    };
+    doMultipleFolderReparentingTest(expected);
+  }
+
+  public void testMultipleFolderReparenting3() throws InactiveSessionException {
+    Record[] expected = new Record[] {
+        BookmarkHelpers.createBookmark1(),
+        BookmarkHelpers.createBookmark2(),
+        BookmarkHelpers.createBookmark3(),
+        BookmarkHelpers.createFolder1(),
+        BookmarkHelpers.createBookmark4(),
+        BookmarkHelpers.createFolder3(),
+        BookmarkHelpers.createFolder2(),
+    };
+    doMultipleFolderReparentingTest(expected);
+  }
+
+  private void doMultipleFolderReparentingTest(Record[] expected) throws InactiveSessionException {
+    final RepositorySession session = createAndBeginSession();
+    doStore(session, expected);
+    ExpectFetchDelegate delegate = preparedExpectFetchDelegate(expected);
+    performWait(fetchAllRunnable(session, delegate));
+    performWait(finishRunnable(session, new ExpectFinishDelegate()));
+  }
+
+  /*
+   * Test storing identical records with different guids.
+   * For bookmarks identical is defined by the following fields
+   * being the same: title, uri, type, parentName
+   */
+  @Override
+  public void testStoreIdenticalExceptGuid() {
+    storeIdenticalExceptGuid(BookmarkHelpers.createBookmarkInMobileFolder1());
+  }
+
+  /*
+   * More complicated situation in which we insert a folder
+   * followed by a couple of its children. We then insert
+   * the folder again but with a different guid. Children
+   * must still get correct parent when they are fetched.
+   * Store a record after with the new guid as the parent
+   * and make sure it works as well.
+   */
+  public void testStoreIdenticalFoldersWithChildren() {
+    final RepositorySession session = createAndBeginSession();
+    Record record0 = BookmarkHelpers.createFolder1();
+
+    // Get timestamp so that the conflicting folder that we store below is newer.
+    // Children won't come back on this fetch since they haven't been stored, so remove them
+    // before our delegate throws a failure.
+    BookmarkRecord rec0 = (BookmarkRecord) record0;
+    rec0.children = new JSONArray();
+    performWait(storeRunnable(session, record0));
+
+    ExpectFetchDelegate timestampDelegate = preparedExpectFetchDelegate(new Record[] { rec0 });
+    performWait(fetchRunnable(session, new String[] { record0.guid }, timestampDelegate));
+
+    AndroidBrowserRepositoryDataAccessor helper = getDataAccessor();
+    helper.dumpDB();
+    closeDataAccessor(helper);
+
+    Record record1 = BookmarkHelpers.createBookmark1();
+    Record record2 = BookmarkHelpers.createBookmark2();
+    Record record3 = BookmarkHelpers.createFolder1();
+    BookmarkRecord bmk3 = (BookmarkRecord) record3;
+    record3.guid = Utils.generateGuid();
+    record3.lastModified = timestampDelegate.records.get(0).lastModified + 3000;
+    assertFalse(record0.guid.equals(record3.guid));
+
+    // Store an additional record after inserting the duplicate folder
+    // with new GUID. Make sure it comes back as well.
+    Record record4 = BookmarkHelpers.createBookmark3();
+    BookmarkRecord bmk4 = (BookmarkRecord) record4;
+    bmk4.parentID = bmk3.guid;
+    bmk4.parentName = bmk3.parentName;
+
+    doStore(session, new Record[] {
+        record1, record2, record3, bmk4
+    });
+    BookmarkRecord bmk1 = (BookmarkRecord) record1;
+    bmk1.parentID = record3.guid;
+    BookmarkRecord bmk2 = (BookmarkRecord) record2;
+    bmk2.parentID = record3.guid;
+    Record[] expect = new Record[] {
+        bmk1, bmk2, record3
+    };
+    fetchAllRunnable(session, preparedExpectFetchDelegate(expect));
+    dispose(session);
+  }
+
+  @Override
+  public void testRemoteNewerTimeStamp() {
+    BookmarkRecord local = BookmarkHelpers.createBookmarkInMobileFolder1();
+    BookmarkRecord remote = BookmarkHelpers.createBookmarkInMobileFolder2();
+    remoteNewerTimeStamp(local, remote);
+  }
+
+  @Override
+  public void testLocalNewerTimeStamp() {
+    BookmarkRecord local = BookmarkHelpers.createBookmarkInMobileFolder1();
+    BookmarkRecord remote = BookmarkHelpers.createBookmarkInMobileFolder2();
+    localNewerTimeStamp(local, remote);
+  }
+
+  @Override
+  public void testDeleteRemoteNewer() {
+    BookmarkRecord local = BookmarkHelpers.createBookmarkInMobileFolder1();
+    BookmarkRecord remote = BookmarkHelpers.createBookmarkInMobileFolder2();
+    deleteRemoteNewer(local, remote);
+  }
+
+  @Override
+  public void testDeleteLocalNewer() {
+    BookmarkRecord local = BookmarkHelpers.createBookmarkInMobileFolder1();
+    BookmarkRecord remote = BookmarkHelpers.createBookmarkInMobileFolder2();
+    deleteLocalNewer(local, remote);
+  }
+
+  @Override
+  public void testDeleteRemoteLocalNonexistent() {
+    BookmarkRecord remote = BookmarkHelpers.createBookmark2();
+    deleteRemoteLocalNonexistent(remote);
+  }
+
+  @Override
+  public void testCleanMultipleRecords() {
+    cleanMultipleRecords(
+        BookmarkHelpers.createBookmarkInMobileFolder1(),
+        BookmarkHelpers.createBookmarkInMobileFolder2(),
+        BookmarkHelpers.createBookmark1(),
+        BookmarkHelpers.createBookmark2(),
+        BookmarkHelpers.createFolder1());
+  }
+
+  public void testBasicPositioning() {
+    final RepositorySession session = createAndBeginSession();
+    Record[] expected = new Record[] {
+        BookmarkHelpers.createBookmark1(),
+        BookmarkHelpers.createFolder1(),
+        BookmarkHelpers.createBookmark2()
+    };
+    System.out.println("TEST: Inserting " + expected[0].guid + ", "
+        + expected[1].guid + ", "
+        + expected[2].guid);
+    doStore(session, expected);
+
+    ExpectFetchDelegate delegate = preparedExpectFetchDelegate(expected);
+    performWait(fetchAllRunnable(session, delegate));
+
+    int found = 0;
+    boolean foundFolder = false;
+    for (int i = 0; i < delegate.records.size(); i++) {
+      BookmarkRecord rec = (BookmarkRecord) delegate.records.get(i);
+      if (rec.guid.equals(expected[0].guid)) {
+        assertEquals(0, ((BookmarkRecord) delegate.records.get(i)).androidPosition);
+        found++;
+      } else if (rec.guid.equals(expected[2].guid)) {
+        assertEquals(1, ((BookmarkRecord) delegate.records.get(i)).androidPosition);
+        found++;
+      } else if (rec.guid.equals(expected[1].guid)) {
+        foundFolder = true;
+      } else {
+        System.out.println("TEST: found " + rec.guid);
+      }
+    }
+    assertTrue(foundFolder);
+    assertEquals(2, found);
+    dispose(session);
+  }
+
+  public void testSqlInjectPurgeDeleteAndUpdateByGuid() {
+    // Some setup.
+    RepositorySession session = createAndBeginSession();
+    AndroidBrowserRepositoryDataAccessor db = getDataAccessor();
+
+    ContentValues cv = new ContentValues();
+    cv.put(BrowserContract.SyncColumns.IS_DELETED, 1);
+
+    // Create and insert 2 bookmarks, 2nd one is evil (attempts injection).
+    BookmarkRecord bmk1 = BookmarkHelpers.createBookmark1();
+    BookmarkRecord bmk2 = BookmarkHelpers.createBookmark2();
+    bmk2.guid = "' or '1'='1";
+
+    db.insert(bmk1);
+    db.insert(bmk2);
+
+    // Test 1 - updateByGuid() handles evil bookmarks correctly.
+    db.updateByGuid(bmk2.guid, cv);
+
+    // Query bookmarks table.
+    Cursor cur = getAllBookmarks();
+    int numBookmarks = cur.getCount();
+
+    // Ensure only the evil bookmark is marked for deletion.
+    try {
+      cur.moveToFirst();
+      while (!cur.isAfterLast()) {
+        String guid = RepoUtils.getStringFromCursor(cur, BrowserContract.SyncColumns.GUID);
+        boolean deleted = RepoUtils.getLongFromCursor(cur, BrowserContract.SyncColumns.IS_DELETED) == 1;
+
+        if (guid.equals(bmk2.guid)) {
+          assertTrue(deleted);
+        } else {
+          assertFalse(deleted);
+        }
+        cur.moveToNext();
+      }
+    } finally {
+      cur.close();
+    }
+
+    // Test 2 - Ensure purgeDelete()'s call to delete() deletes only 1 record.
+    try {
+      db.purgeDeleted();
+    } catch (NullCursorException e) {
+      e.printStackTrace();
+    }
+
+    cur = getAllBookmarks();
+    int numBookmarksAfterDeletion = cur.getCount();
+
+    // Ensure we have only 1 deleted row.
+    assertEquals(numBookmarksAfterDeletion, numBookmarks - 1);
+
+    // Ensure only the evil bookmark is deleted.
+    try {
+      cur.moveToFirst();
+      while (!cur.isAfterLast()) {
+        String guid = RepoUtils.getStringFromCursor(cur, BrowserContract.SyncColumns.GUID);
+        boolean deleted = RepoUtils.getLongFromCursor(cur, BrowserContract.SyncColumns.IS_DELETED) == 1;
+
+        if (guid.equals(bmk2.guid)) {
+          fail("Evil guid was not deleted!");
+        } else {
+          assertFalse(deleted);
+        }
+        cur.moveToNext();
+      }
+    } finally {
+      cur.close();
+    }
+    dispose(session);
+  }
+
+  protected Cursor getAllBookmarks() {
+    Context context = getApplicationContext();
+    Cursor cur = context.getContentResolver().query(BrowserContractHelpers.BOOKMARKS_CONTENT_URI,
+        BrowserContractHelpers.BookmarkColumns, null, null, null);
+    return cur;
+  }
+
+  public void testSqlInjectFetch() {
+    // Some setup.
+    RepositorySession session = createAndBeginSession();
+    AndroidBrowserRepositoryDataAccessor db = getDataAccessor();
+
+    // Create and insert 4 bookmarks, last one is evil (attempts injection).
+    BookmarkRecord bmk1 = BookmarkHelpers.createBookmark1();
+    BookmarkRecord bmk2 = BookmarkHelpers.createBookmark2();
+    BookmarkRecord bmk3 = BookmarkHelpers.createBookmark3();
+    BookmarkRecord bmk4 = BookmarkHelpers.createBookmark4();
+    bmk4.guid = "' or '1'='1";
+
+    db.insert(bmk1);
+    db.insert(bmk2);
+    db.insert(bmk3);
+    db.insert(bmk4);
+
+    // Perform a fetch.
+    Cursor cur = null;
+    try {
+      cur = db.fetch(new String[] { bmk3.guid, bmk4.guid });
+    } catch (NullCursorException e1) {
+      e1.printStackTrace();
+    }
+
+    // Ensure the correct number (2) of records were fetched and with the correct guids.
+    if (cur == null) {
+      fail("No records were fetched.");
+    }
+
+    try {
+      if (cur.getCount() != 2) {
+        fail("Wrong number of guids fetched!");
+      }
+      cur.moveToFirst();
+      while (!cur.isAfterLast()) {
+        String guid = RepoUtils.getStringFromCursor(cur, BrowserContract.SyncColumns.GUID);
+        if (!guid.equals(bmk3.guid) && !guid.equals(bmk4.guid)) {
+          fail("Wrong guids were fetched!");
+        }
+        cur.moveToNext();
+      }
+    } finally {
+      cur.close();
+    }
+    dispose(session);
+  }
+
+  public void testSqlInjectDelete() {
+    // Some setup.
+    RepositorySession session = createAndBeginSession();
+    AndroidBrowserRepositoryDataAccessor db = getDataAccessor();
+
+    // Create and insert 2 bookmarks, 2nd one is evil (attempts injection).
+    BookmarkRecord bmk1 = BookmarkHelpers.createBookmark1();
+    BookmarkRecord bmk2 = BookmarkHelpers.createBookmark2();
+    bmk2.guid = "' or '1'='1";
+
+    db.insert(bmk1);
+    db.insert(bmk2);
+
+    // Note size of table before delete.
+    Cursor cur = getAllBookmarks();
+    int numBookmarks = cur.getCount();
+
+    db.purgeGuid(bmk2.guid);
+
+    // Note size of table after delete.
+    cur = getAllBookmarks();
+    int numBookmarksAfterDelete = cur.getCount();
+
+    // Ensure size of table after delete is *only* 1 less.
+    assertEquals(numBookmarksAfterDelete, numBookmarks - 1);
+
+    try {
+      cur.moveToFirst();
+      while (!cur.isAfterLast()) {
+        String guid = RepoUtils.getStringFromCursor(cur, BrowserContract.SyncColumns.GUID);
+        if (guid.equals(bmk2.guid)) {
+          fail("Guid was not deleted!");
+        }
+        cur.moveToNext();
+      }
+    } finally {
+      cur.close();
+    }
+    dispose(session);
+  }
+
+  /**
+   * Verify that data accessor's bulkInsert actually inserts.
+   * @throws NullCursorException
+   */
+  public void testBulkInsert() throws NullCursorException {
+    RepositorySession session = createAndBeginSession();
+    AndroidBrowserRepositoryDataAccessor db = getDataAccessor();
+
+    // Have to set androidID of parent manually.
+    Cursor cur = db.fetch(new String[] { "mobile" } );
+    assertEquals(1, cur.getCount());
+    cur.moveToFirst();
+    int mobileAndroidID = RepoUtils.getIntFromCursor(cur, BrowserContract.Bookmarks._ID);
+
+    BookmarkRecord bookmark1 = BookmarkHelpers.createBookmarkInMobileFolder1();
+    BookmarkRecord bookmark2 = BookmarkHelpers.createBookmarkInMobileFolder2();
+    bookmark1.androidParentID = mobileAndroidID;
+    bookmark2.androidParentID = mobileAndroidID;
+    ArrayList<Record> recordList = new ArrayList<Record>();
+    recordList.add(bookmark1);
+    recordList.add(bookmark2);
+    db.bulkInsert(recordList);
+
+    String[] guids = new String[] { bookmark1.guid, bookmark2.guid };
+    Record[] expected = new Record[] { bookmark1, bookmark2 };
+    performWait(fetchRunnable(session, guids, expected));
+    dispose(session);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestAndroidBrowserHistoryRepository.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestAndroidBrowserHistoryRepository.java
new file mode 100644
index 000000000..ffde59575
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestAndroidBrowserHistoryRepository.java
@@ -0,0 +1,450 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.db;
+
+import java.util.ArrayList;
+
+import org.json.simple.JSONObject;
+import org.mozilla.gecko.background.sync.helpers.ExpectFetchDelegate;
+import org.mozilla.gecko.background.sync.helpers.HistoryHelpers;
+import org.mozilla.gecko.db.BrowserContract;
+import org.mozilla.gecko.sync.Utils;
+import org.mozilla.gecko.sync.repositories.NullCursorException;
+import org.mozilla.gecko.sync.repositories.Repository;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserHistoryDataAccessor;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserHistoryRepository;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserHistoryRepositorySession;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserRepository;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserRepositoryDataAccessor;
+import org.mozilla.gecko.sync.repositories.android.BrowserContractHelpers;
+import org.mozilla.gecko.sync.repositories.android.RepoUtils;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
+import org.mozilla.gecko.sync.repositories.domain.HistoryRecord;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+
+public class TestAndroidBrowserHistoryRepository extends AndroidBrowserRepositoryTestCase {
+
+  @Override
+  protected AndroidBrowserRepository getRepository() {
+
+    /**
+     * Override this chain in order to avoid our test code having to create two
+     * sessions all the time.
+     */
+    return new AndroidBrowserHistoryRepository() {
+      @Override
+      protected void sessionCreator(RepositorySessionCreationDelegate delegate, Context context) {
+        AndroidBrowserHistoryRepositorySession session;
+        session = new AndroidBrowserHistoryRepositorySession(this, context) {
+          @Override
+          protected synchronized void trackGUID(String guid) {
+            System.out.println("Ignoring trackGUID call: this is a test!");
+          }
+        };
+        delegate.onSessionCreated(session);
+      }
+    };
+  }
+
+  @Override
+  protected AndroidBrowserRepositoryDataAccessor getDataAccessor() {
+    return new AndroidBrowserHistoryDataAccessor(getApplicationContext());
+  }
+
+  @Override
+  public void testFetchAll() {
+    Record[] expected = new Record[2];
+    expected[0] = HistoryHelpers.createHistory3();
+    expected[1] = HistoryHelpers.createHistory2();
+    basicFetchAllTest(expected);
+  }
+
+  /*
+   * Test storing identical records with different guids.
+   * For bookmarks identical is defined by the following fields
+   * being the same: title, uri, type, parentName
+   */
+  @Override
+  public void testStoreIdenticalExceptGuid() {
+    storeIdenticalExceptGuid(HistoryHelpers.createHistory1());
+  }
+
+  @Override
+  public void testCleanMultipleRecords() {
+    cleanMultipleRecords(
+        HistoryHelpers.createHistory1(),
+        HistoryHelpers.createHistory2(),
+        HistoryHelpers.createHistory3(),
+        HistoryHelpers.createHistory4(),
+        HistoryHelpers.createHistory5()
+        );
+  }
+
+  @Override
+  public void testGuidsSinceReturnMultipleRecords() {
+    HistoryRecord record0 = HistoryHelpers.createHistory1();
+    HistoryRecord record1 = HistoryHelpers.createHistory2();
+    guidsSinceReturnMultipleRecords(record0, record1);
+  }
+
+  @Override
+  public void testGuidsSinceReturnNoRecords() {
+    guidsSinceReturnNoRecords(HistoryHelpers.createHistory3());
+  }
+
+  @Override
+  public void testFetchSinceOneRecord() {
+    fetchSinceOneRecord(HistoryHelpers.createHistory1(),
+        HistoryHelpers.createHistory2());
+  }
+
+  @Override
+  public void testFetchSinceReturnNoRecords() {
+    fetchSinceReturnNoRecords(HistoryHelpers.createHistory3());
+  }
+
+  @Override
+  public void testFetchOneRecordByGuid() {
+    fetchOneRecordByGuid(HistoryHelpers.createHistory1(),
+        HistoryHelpers.createHistory2());
+  }
+
+  @Override
+  public void testFetchMultipleRecordsByGuids() {
+    HistoryRecord record0 = HistoryHelpers.createHistory1();
+    HistoryRecord record1 = HistoryHelpers.createHistory2();
+    HistoryRecord record2 = HistoryHelpers.createHistory3();
+    fetchMultipleRecordsByGuids(record0, record1, record2);
+  }
+
+  @Override
+  public void testFetchNoRecordByGuid() {
+    fetchNoRecordByGuid(HistoryHelpers.createHistory1());
+  }
+
+  @Override
+  public void testWipe() {
+    doWipe(HistoryHelpers.createHistory2(), HistoryHelpers.createHistory3());
+  }
+
+  @Override
+  public void testStore() {
+    basicStoreTest(HistoryHelpers.createHistory1());
+  }
+
+  @Override
+  public void testRemoteNewerTimeStamp() {
+    HistoryRecord local = HistoryHelpers.createHistory1();
+    HistoryRecord remote = HistoryHelpers.createHistory2();
+    remoteNewerTimeStamp(local, remote);
+  }
+
+  @Override
+  public void testLocalNewerTimeStamp() {
+    HistoryRecord local = HistoryHelpers.createHistory1();
+    HistoryRecord remote = HistoryHelpers.createHistory2();
+    localNewerTimeStamp(local, remote);
+  }
+
+  @Override
+  public void testDeleteRemoteNewer() {
+    HistoryRecord local = HistoryHelpers.createHistory1();
+    HistoryRecord remote = HistoryHelpers.createHistory2();
+    deleteRemoteNewer(local, remote);
+  }
+
+  @Override
+  public void testDeleteLocalNewer() {
+    HistoryRecord local = HistoryHelpers.createHistory1();
+    HistoryRecord remote = HistoryHelpers.createHistory2();
+    deleteLocalNewer(local, remote);
+  }
+
+  @Override
+  public void testDeleteRemoteLocalNonexistent() {
+    deleteRemoteLocalNonexistent(HistoryHelpers.createHistory2());
+  }
+
+  /**
+   * Exists to provide access to record string logic.
+   */
+  protected class HelperHistorySession extends AndroidBrowserHistoryRepositorySession {
+    public HelperHistorySession(Repository repository, Context context) {
+      super(repository, context);
+    }
+
+    public boolean sameRecordString(HistoryRecord r1, HistoryRecord r2) {
+      return buildRecordString(r1).equals(buildRecordString(r2));
+    }
+  }
+
+  /**
+   * Verifies that two history records with the same URI but different
+   * titles will be reconciled locally.
+   */
+  public void testRecordStringCollisionAndEquality() {
+    final AndroidBrowserHistoryRepository repo = new AndroidBrowserHistoryRepository();
+    final HelperHistorySession testSession = new HelperHistorySession(repo, getApplicationContext());
+
+    final long now = RepositorySession.now();
+
+    final HistoryRecord record0 = new HistoryRecord(null, "history", now + 1, false);
+    final HistoryRecord record1 = new HistoryRecord(null, "history", now + 2, false);
+    final HistoryRecord record2 = new HistoryRecord(null, "history", now + 3, false);
+
+    record0.histURI = "http://example.com/foo";
+    record1.histURI = "http://example.com/foo";
+    record2.histURI = "http://example.com/bar";
+    record0.title = "Foo 0";
+    record1.title = "Foo 1";
+    record2.title = "Foo 2";
+
+    // Ensure that two records with the same URI produce the same record string,
+    // and two records with different URIs do not.
+    assertTrue(testSession.sameRecordString(record0, record1));
+    assertFalse(testSession.sameRecordString(record0, record2));
+
+    // Two records are congruent if they have the same URI and their
+    // identifiers match (which is why these all have null GUIDs).
+    assertTrue(record0.congruentWith(record0));
+    assertTrue(record0.congruentWith(record1));
+    assertTrue(record1.congruentWith(record0));
+    assertFalse(record0.congruentWith(record2));
+    assertFalse(record1.congruentWith(record2));
+    assertFalse(record2.congruentWith(record1));
+    assertFalse(record2.congruentWith(record0));
+
+    // None of these records are equal, because they have different titles.
+    // (Except for being equal to themselves, of course.)
+    assertTrue(record0.equalPayloads(record0));
+    assertTrue(record1.equalPayloads(record1));
+    assertTrue(record2.equalPayloads(record2));
+    assertFalse(record0.equalPayloads(record1));
+    assertFalse(record1.equalPayloads(record0));
+    assertFalse(record1.equalPayloads(record2));
+  }
+
+  /*
+   * Tests for adding some visits to a history record
+   * and doing a fetch.
+   */
+  @SuppressWarnings("unchecked")
+  public void testAddOneVisit() {
+    final RepositorySession session = createAndBeginSession();
+
+    HistoryRecord record0 = HistoryHelpers.createHistory3();
+    performWait(storeRunnable(session, record0));
+
+    // Add one visit to the count and put in a new
+    // last visited date.
+    ContentValues cv = new ContentValues();
+    int visits = record0.visits.size() + 1;
+    long newVisitTime = System.currentTimeMillis();
+    cv.put(BrowserContract.History.VISITS, visits);
+    cv.put(BrowserContract.History.DATE_LAST_VISITED, newVisitTime);
+    final AndroidBrowserRepositoryDataAccessor dataAccessor = getDataAccessor();
+    dataAccessor.updateByGuid(record0.guid, cv);
+
+    // Add expected visit to record for verification.
+    JSONObject expectedVisit = new JSONObject();
+    expectedVisit.put("date", newVisitTime * 1000);    // Microseconds.
+    expectedVisit.put("type", 1L);
+    record0.visits.add(expectedVisit);
+
+    performWait(fetchRunnable(session, new String[] { record0.guid }, new ExpectFetchDelegate(new Record[] { record0 })));
+    closeDataAccessor(dataAccessor);
+  }
+
+  @SuppressWarnings("unchecked")
+  public void testAddMultipleVisits() {
+    final RepositorySession session = createAndBeginSession();
+
+    HistoryRecord record0 = HistoryHelpers.createHistory4();
+    performWait(storeRunnable(session, record0));
+
+    // Add three visits to the count and put in a new
+    // last visited date.
+    ContentValues cv = new ContentValues();
+    int visits = record0.visits.size() + 3;
+    long newVisitTime = System.currentTimeMillis();
+    cv.put(BrowserContract.History.VISITS, visits);
+    cv.put(BrowserContract.History.DATE_LAST_VISITED, newVisitTime);
+    final AndroidBrowserRepositoryDataAccessor dataAccessor = getDataAccessor();
+    dataAccessor.updateByGuid(record0.guid, cv);
+
+    // Now shift to microsecond timing for visits.
+    long newMicroVisitTime = newVisitTime * 1000;
+
+    // Add expected visits to record for verification
+    JSONObject expectedVisit = new JSONObject();
+    expectedVisit.put("date", newMicroVisitTime);
+    expectedVisit.put("type", 1L);
+    record0.visits.add(expectedVisit);
+    expectedVisit = new JSONObject();
+    expectedVisit.put("date", newMicroVisitTime - 1000);
+    expectedVisit.put("type", 1L);
+    record0.visits.add(expectedVisit);
+    expectedVisit = new JSONObject();
+    expectedVisit.put("date", newMicroVisitTime - 2000);
+    expectedVisit.put("type", 1L);
+    record0.visits.add(expectedVisit);
+
+    ExpectFetchDelegate delegate = new ExpectFetchDelegate(new Record[] { record0 });
+    performWait(fetchRunnable(session, new String[] { record0.guid }, delegate));
+
+    Record fetched = delegate.records.get(0);
+    assertTrue(record0.equalPayloads(fetched));
+    closeDataAccessor(dataAccessor);
+  }
+
+  public void testInvalidHistoryItemIsSkipped() throws NullCursorException {
+    final AndroidBrowserHistoryRepositorySession session = (AndroidBrowserHistoryRepositorySession) createAndBeginSession();
+    final AndroidBrowserRepositoryDataAccessor dbHelper = session.getDBHelper();
+
+    final long now = System.currentTimeMillis();
+    final HistoryRecord emptyURL = new HistoryRecord(Utils.generateGuid(), "history", now, false);
+    final HistoryRecord noVisits = new HistoryRecord(Utils.generateGuid(), "history", now, false);
+    final HistoryRecord aboutURL = new HistoryRecord(Utils.generateGuid(), "history", now, false);
+
+    emptyURL.fennecDateVisited = now;
+    emptyURL.fennecVisitCount  = 1;
+    emptyURL.histURI           = "";
+    emptyURL.title             = "Something";
+
+    noVisits.fennecDateVisited = now;
+    noVisits.fennecVisitCount  = 0;
+    noVisits.histURI           = "http://example.org/novisits";
+    noVisits.title             = "Something Else";
+
+    aboutURL.fennecDateVisited = now;
+    aboutURL.fennecVisitCount  = 1;
+    aboutURL.histURI           = "about:home";
+    aboutURL.title             = "Fennec Home";
+
+    Uri one = dbHelper.insert(emptyURL);
+    Uri two = dbHelper.insert(noVisits);
+    Uri tre = dbHelper.insert(aboutURL);
+    assertNotNull(one);
+    assertNotNull(two);
+    assertNotNull(tre);
+
+    // The records are in the DB.
+    final Cursor all = dbHelper.fetchAll();
+    assertEquals(3, all.getCount());
+    all.close();
+
+    // But aren't returned by fetching.
+    performWait(fetchAllRunnable(session, new Record[] {}));
+
+    // And we'd ignore about:home if we downloaded it.
+    assertTrue(session.shouldIgnore(aboutURL));
+
+    session.abort();
+  }
+
+  public void testSqlInjectPurgeDelete() {
+    // Some setup.
+    RepositorySession session = createAndBeginSession();
+    final AndroidBrowserRepositoryDataAccessor db = getDataAccessor();
+
+    try {
+      ContentValues cv = new ContentValues();
+      cv.put(BrowserContract.SyncColumns.IS_DELETED, 1);
+
+      // Create and insert 2 history entries, 2nd one is evil (attempts injection).
+      HistoryRecord h1 = HistoryHelpers.createHistory1();
+      HistoryRecord h2 = HistoryHelpers.createHistory2();
+      h2.guid = "' or '1'='1";
+
+      db.insert(h1);
+      db.insert(h2);
+
+      // Test 1 - updateByGuid() handles evil history entries correctly.
+      db.updateByGuid(h2.guid, cv);
+
+      // Query history table.
+      Cursor cur = getAllHistory();
+      int numHistory = cur.getCount();
+
+      // Ensure only the evil history entry is marked for deletion.
+      try {
+        cur.moveToFirst();
+        while (!cur.isAfterLast()) {
+          String guid = RepoUtils.getStringFromCursor(cur, BrowserContract.SyncColumns.GUID);
+          boolean deleted = RepoUtils.getLongFromCursor(cur, BrowserContract.SyncColumns.IS_DELETED) == 1;
+
+          if (guid.equals(h2.guid)) {
+            assertTrue(deleted);
+          } else {
+            assertFalse(deleted);
+          }
+          cur.moveToNext();
+        }
+      } finally {
+        cur.close();
+      }
+
+      // Test 2 - Ensure purgeDelete()'s call to delete() deletes only 1 record.
+      try {
+        db.purgeDeleted();
+      } catch (NullCursorException e) {
+        e.printStackTrace();
+      }
+
+      cur = getAllHistory();
+      int numHistoryAfterDeletion = cur.getCount();
+
+      // Ensure we have only 1 deleted row.
+      assertEquals(numHistoryAfterDeletion, numHistory - 1);
+
+      // Ensure only the evil history is deleted.
+      try {
+        cur.moveToFirst();
+        while (!cur.isAfterLast()) {
+          String guid = RepoUtils.getStringFromCursor(cur, BrowserContract.SyncColumns.GUID);
+          boolean deleted = RepoUtils.getLongFromCursor(cur, BrowserContract.SyncColumns.IS_DELETED) == 1;
+
+          if (guid.equals(h2.guid)) {
+            fail("Evil guid was not deleted!");
+          } else {
+            assertFalse(deleted);
+          }
+          cur.moveToNext();
+        }
+      } finally {
+        cur.close();
+      }
+    } finally {
+      closeDataAccessor(db);
+      session.abort();
+    }
+  }
+
+  protected Cursor getAllHistory() {
+    Context context = getApplicationContext();
+    Cursor cur = context.getContentResolver().query(BrowserContractHelpers.HISTORY_CONTENT_URI,
+        BrowserContractHelpers.HistoryColumns, null, null, null);
+    return cur;
+  }
+
+  public void testDataAccessorBulkInsert() throws NullCursorException {
+    final AndroidBrowserHistoryRepositorySession session = (AndroidBrowserHistoryRepositorySession) createAndBeginSession();
+    AndroidBrowserHistoryDataAccessor db = (AndroidBrowserHistoryDataAccessor) session.getDBHelper();
+
+    ArrayList<HistoryRecord> records = new ArrayList<HistoryRecord>();
+    records.add(HistoryHelpers.createHistory1());
+    records.add(HistoryHelpers.createHistory2());
+    records.add(HistoryHelpers.createHistory3());
+    db.bulkInsert(records);
+
+    performWait(fetchAllRunnable(session, preparedExpectFetchDelegate(records.toArray(new Record[records.size()]))));
+    session.abort();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestBookmarks.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestBookmarks.java
new file mode 100644
index 000000000..783aea1ff
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestBookmarks.java
@@ -0,0 +1,1063 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.db;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+
+import org.json.simple.JSONArray;
+import org.mozilla.gecko.R;
+import org.mozilla.gecko.background.common.log.Logger;
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.background.sync.helpers.BookmarkHelpers;
+import org.mozilla.gecko.background.sync.helpers.SimpleSuccessBeginDelegate;
+import org.mozilla.gecko.background.sync.helpers.SimpleSuccessCreationDelegate;
+import org.mozilla.gecko.background.sync.helpers.SimpleSuccessFetchDelegate;
+import org.mozilla.gecko.background.sync.helpers.SimpleSuccessFinishDelegate;
+import org.mozilla.gecko.background.sync.helpers.SimpleSuccessStoreDelegate;
+import org.mozilla.gecko.db.BrowserContract;
+import org.mozilla.gecko.db.BrowserContract.Bookmarks;
+import org.mozilla.gecko.sync.Utils;
+import org.mozilla.gecko.sync.repositories.InactiveSessionException;
+import org.mozilla.gecko.sync.repositories.InvalidSessionTransitionException;
+import org.mozilla.gecko.sync.repositories.NoStoreDelegateException;
+import org.mozilla.gecko.sync.repositories.NullCursorException;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.RepositorySessionBundle;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserBookmarksDataAccessor;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserBookmarksRepository;
+import org.mozilla.gecko.sync.repositories.android.AndroidBrowserBookmarksRepositorySession;
+import org.mozilla.gecko.sync.repositories.android.BrowserContractHelpers;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionBeginDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionFetchRecordsDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionStoreDelegate;
+import org.mozilla.gecko.sync.repositories.domain.BookmarkRecord;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.net.Uri;
+
+public class TestBookmarks extends AndroidSyncTestCase {
+
+  protected static final String LOG_TAG = "BookmarksTest";
+
+  /**
+   * Trivial test that forbidden records such as pinned items
+   * will be ignored if processed.
+   */
+  public void testForbiddenItemsAreIgnored() {
+    final AndroidBrowserBookmarksRepository repo = new AndroidBrowserBookmarksRepository();
+    final long now = System.currentTimeMillis();
+    final String bookmarksCollection = "bookmarks";
+
+    final BookmarkRecord pinned = new BookmarkRecord("pinpinpinpin", "bookmarks", now - 1, false);
+    final BookmarkRecord normal = new BookmarkRecord("baaaaaaaaaaa", "bookmarks", now - 2, false);
+
+    final BookmarkRecord pinnedItems  = new BookmarkRecord(Bookmarks.PINNED_FOLDER_GUID,
+                                                           bookmarksCollection, now - 4, false);
+
+    normal.type = "bookmark";
+    pinned.type = "bookmark";
+    pinnedItems.type = "folder";
+
+    pinned.parentID = Bookmarks.PINNED_FOLDER_GUID;
+    normal.parentID = Bookmarks.TOOLBAR_FOLDER_GUID;
+
+    pinnedItems.parentID = Bookmarks.PLACES_FOLDER_GUID;
+
+    inBegunSession(repo, new SimpleSuccessBeginDelegate() {
+      @Override
+      public void onBeginSucceeded(RepositorySession session) {
+        assertTrue(((AndroidBrowserBookmarksRepositorySession) session).shouldIgnore(pinned));
+        assertTrue(((AndroidBrowserBookmarksRepositorySession) session).shouldIgnore(pinnedItems));
+        assertFalse(((AndroidBrowserBookmarksRepositorySession) session).shouldIgnore(normal));
+        finishAndNotify(session);
+      }
+    });
+  }
+
+  /**
+   * Trivial test that pinned items will be skipped if present in the DB.
+   */
+  public void testPinnedItemsAreNotRetrieved() {
+    final AndroidBrowserBookmarksRepository repo = new AndroidBrowserBookmarksRepository();
+
+    // Ensure that they exist.
+    setUpFennecPinnedItemsRecord();
+
+    // They're there in the DB…
+    final ArrayList<String> roots = fetchChildrenDirect(Bookmarks.FIXED_ROOT_ID);
+    Logger.info(LOG_TAG, "Roots: " + roots);
+    assertTrue(roots.contains(Bookmarks.PINNED_FOLDER_GUID));
+
+    final ArrayList<String> pinned = fetchChildrenDirect(Bookmarks.FIXED_PINNED_LIST_ID);
+    Logger.info(LOG_TAG, "Pinned: " + pinned);
+    assertTrue(pinned.contains("dapinneditem"));
+
+    // … but not when we fetch.
+    final ArrayList<String> guids = fetchGUIDs(repo);
+    assertFalse(guids.contains(Bookmarks.PINNED_FOLDER_GUID));
+    assertFalse(guids.contains("dapinneditem"));
+  }
+
+  public void testRetrieveFolderHasAccurateChildren() {
+    AndroidBrowserBookmarksRepository repo = new AndroidBrowserBookmarksRepository();
+
+    final long now = System.currentTimeMillis();
+
+    final String folderGUID = "eaaaaaaaafff";
+    BookmarkRecord folder    = new BookmarkRecord(folderGUID,     "bookmarks", now - 5, false);
+    BookmarkRecord bookmarkA = new BookmarkRecord("daaaaaaaaaaa", "bookmarks", now - 1, false);
+    BookmarkRecord bookmarkB = new BookmarkRecord("baaaaaaaabbb", "bookmarks", now - 3, false);
+    BookmarkRecord bookmarkC = new BookmarkRecord("aaaaaaaaaccc", "bookmarks", now - 2, false);
+
+    folder.children   = childrenFromRecords(bookmarkA, bookmarkB, bookmarkC);
+    folder.sortIndex  = 150;
+    folder.title      = "Test items";
+    folder.parentID   = "toolbar";
+    folder.parentName = "Bookmarks Toolbar";
+    folder.type       = "folder";
+
+    bookmarkA.parentID    = folderGUID;
+    bookmarkA.bookmarkURI = "http://example.com/A";
+    bookmarkA.title       = "Title A";
+    bookmarkA.type        = "bookmark";
+
+    bookmarkB.parentID    = folderGUID;
+    bookmarkB.bookmarkURI = "http://example.com/B";
+    bookmarkB.title       = "Title B";
+    bookmarkB.type        = "bookmark";
+
+    bookmarkC.parentID    = folderGUID;
+    bookmarkC.bookmarkURI = "http://example.com/C";
+    bookmarkC.title       = "Title C";
+    bookmarkC.type        = "bookmark";
+
+    BookmarkRecord[] folderOnly = new BookmarkRecord[1];
+    BookmarkRecord[] children   = new BookmarkRecord[3];
+
+    folderOnly[0] = folder;
+
+    children[0] = bookmarkA;
+    children[1] = bookmarkB;
+    children[2] = bookmarkC;
+
+    wipe();
+    Logger.debug(getName(), "Storing just folder...");
+    storeRecordsInSession(repo, folderOnly, null);
+
+    // We don't have any children, despite our insistence upon storing.
+    assertChildrenAreOrdered(repo, folderGUID, new Record[] {});
+
+    // Now store the children.
+    Logger.debug(getName(), "Storing children...");
+    storeRecordsInSession(repo, children, null);
+
+    // Now we have children, but their order is not determined, because
+    // they were stored out-of-session with the original folder.
+    assertChildrenAreUnordered(repo, folderGUID, children);
+
+    // Now if we store the folder record again, they'll be put in the
+    // right place.
+    folder.lastModified++;
+    Logger.debug(getName(), "Storing just folder again...");
+    storeRecordsInSession(repo, folderOnly, null);
+    Logger.debug(getName(), "Fetching children yet again...");
+    assertChildrenAreOrdered(repo, folderGUID, children);
+
+    // Now let's see what happens when we see records in the same session.
+    BookmarkRecord[] parentMixed = new BookmarkRecord[4];
+    BookmarkRecord[] parentFirst = new BookmarkRecord[4];
+    BookmarkRecord[] parentLast  = new BookmarkRecord[4];
+
+    // None of our records have a position set.
+    assertTrue(bookmarkA.androidPosition <= 0);
+    assertTrue(bookmarkB.androidPosition <= 0);
+    assertTrue(bookmarkC.androidPosition <= 0);
+
+    parentMixed[1] = folder;
+    parentMixed[0] = bookmarkA;
+    parentMixed[2] = bookmarkC;
+    parentMixed[3] = bookmarkB;
+
+    parentFirst[0] = folder;
+    parentFirst[1] = bookmarkC;
+    parentFirst[2] = bookmarkA;
+    parentFirst[3] = bookmarkB;
+
+    parentLast[3]  = folder;
+    parentLast[0]  = bookmarkB;
+    parentLast[1]  = bookmarkA;
+    parentLast[2]  = bookmarkC;
+
+    wipe();
+    storeRecordsInSession(repo, parentMixed, null);
+    assertChildrenAreOrdered(repo, folderGUID, children);
+
+    wipe();
+    storeRecordsInSession(repo, parentFirst, null);
+    assertChildrenAreOrdered(repo, folderGUID, children);
+
+    wipe();
+    storeRecordsInSession(repo, parentLast, null);
+    assertChildrenAreOrdered(repo, folderGUID, children);
+
+    // Ensure that records are ordered even if we re-process the folder.
+    wipe();
+    storeRecordsInSession(repo, parentLast, null);
+    folder.lastModified++;
+    storeRecordsInSession(repo, folderOnly, null);
+    assertChildrenAreOrdered(repo, folderGUID, children);
+  }
+
+  public void testMergeFoldersPreservesSaneOrder() {
+    AndroidBrowserBookmarksRepository repo = new AndroidBrowserBookmarksRepository();
+
+    final long now = System.currentTimeMillis();
+    final String folderGUID = "mobile";
+
+    wipe();
+    final long mobile = setUpFennecMobileRecord();
+
+    // No children.
+    assertChildrenAreUnordered(repo, folderGUID, new Record[] {});
+
+    // Add some, as Fennec would.
+    fennecAddBookmark("Bookmark One", "http://example.com/fennec/One");
+    fennecAddBookmark("Bookmark Two", "http://example.com/fennec/Two");
+
+    Logger.debug(getName(), "Fetching children...");
+    JSONArray folderChildren = fetchChildrenForGUID(repo, folderGUID);
+
+    assertTrue(folderChildren != null);
+    Logger.debug(getName(), "Children are " + folderChildren.toJSONString());
+    assertEquals(2, folderChildren.size());
+    String guidOne = (String) folderChildren.get(0);
+    String guidTwo = (String) folderChildren.get(1);
+
+    // Make sure positions were saved.
+    assertChildrenAreDirect(mobile, new String[] {
+        guidOne,
+        guidTwo
+    });
+
+    // Add some through Sync.
+    BookmarkRecord folder    = new BookmarkRecord(folderGUID,     "bookmarks", now, false);
+    BookmarkRecord bookmarkA = new BookmarkRecord("daaaaaaaaaaa", "bookmarks", now, false);
+    BookmarkRecord bookmarkB = new BookmarkRecord("baaaaaaaabbb", "bookmarks", now, false);
+
+    folder.children   = childrenFromRecords(bookmarkA, bookmarkB);
+    folder.sortIndex  = 150;
+    folder.title      = "Mobile Bookmarks";
+    folder.parentID   = "places";
+    folder.parentName = "";
+    folder.type       = "folder";
+
+    bookmarkA.parentID    = folderGUID;
+    bookmarkA.parentName  = "Mobile Bookmarks";       // Using this title exercises Bug 748898.
+    bookmarkA.bookmarkURI = "http://example.com/A";
+    bookmarkA.title       = "Title A";
+    bookmarkA.type        = "bookmark";
+
+    bookmarkB.parentID    = folderGUID;
+    bookmarkB.parentName  = "mobile";
+    bookmarkB.bookmarkURI = "http://example.com/B";
+    bookmarkB.title       = "Title B";
+    bookmarkB.type        = "bookmark";
+
+    BookmarkRecord[] parentMixed = new BookmarkRecord[3];
+    parentMixed[0] = bookmarkA;
+    parentMixed[1] = folder;
+    parentMixed[2] = bookmarkB;
+
+    storeRecordsInSession(repo, parentMixed, null);
+
+    BookmarkRecord expectedOne = new BookmarkRecord(guidOne, "bookmarks", now - 10, false);
+    BookmarkRecord expectedTwo = new BookmarkRecord(guidTwo, "bookmarks", now - 10, false);
+
+    // We want the server to win in this case, and otherwise to preserve order.
+    // TODO
+    assertChildrenAreOrdered(repo, folderGUID, new Record[] {
+        bookmarkA,
+        bookmarkB,
+        expectedOne,
+        expectedTwo
+    });
+
+    // Furthermore, the children of that folder should be correct in the DB.
+    ContentResolver cr = getApplicationContext().getContentResolver();
+    final long folderId = fennecGetFolderId(cr, folderGUID);
+    Logger.debug(getName(), "Folder " + folderGUID + " => " + folderId);
+
+    assertChildrenAreDirect(folderId, new String[] {
+        bookmarkA.guid,
+        bookmarkB.guid,
+        expectedOne.guid,
+        expectedTwo.guid
+    });
+  }
+
+  /**
+   * Apply a folder record whose children array is already accurately
+   * stored in the database. Verify that the parent folder is not flagged
+   * for reupload (i.e., that its modified time is *ahem* unmodified).
+   */
+  public void testNoReorderingMeansNoReupload() {
+    AndroidBrowserBookmarksRepository repo = new AndroidBrowserBookmarksRepository();
+
+    final long now = System.currentTimeMillis();
+
+    final String folderGUID = "eaaaaaaaafff";
+    BookmarkRecord folder    = new BookmarkRecord(folderGUID,     "bookmarks", now -5, false);
+    BookmarkRecord bookmarkA = new BookmarkRecord("daaaaaaaaaaa", "bookmarks", now -1, false);
+    BookmarkRecord bookmarkB = new BookmarkRecord("baaaaaaaabbb", "bookmarks", now -3, false);
+
+    folder.children   = childrenFromRecords(bookmarkA, bookmarkB);
+    folder.sortIndex  = 150;
+    folder.title      = "Test items";
+    folder.parentID   = "toolbar";
+    folder.parentName = "Bookmarks Toolbar";
+    folder.type       = "folder";
+
+    bookmarkA.parentID    = folderGUID;
+    bookmarkA.bookmarkURI = "http://example.com/A";
+    bookmarkA.title       = "Title A";
+    bookmarkA.type        = "bookmark";
+
+    bookmarkB.parentID    = folderGUID;
+    bookmarkB.bookmarkURI = "http://example.com/B";
+    bookmarkB.title       = "Title B";
+    bookmarkB.type        = "bookmark";
+
+    BookmarkRecord[] abf = new BookmarkRecord[3];
+    BookmarkRecord[] justFolder = new BookmarkRecord[1];
+
+    abf[0] = bookmarkA;
+    abf[1] = bookmarkB;
+    abf[2] = folder;
+
+    justFolder[0] = folder;
+
+    final String[] abGUIDs   = new String[] { bookmarkA.guid, bookmarkB.guid };
+    final Record[] abRecords = new Record[] { bookmarkA, bookmarkB };
+    final String[] baGUIDs   = new String[] { bookmarkB.guid, bookmarkA.guid };
+    final Record[] baRecords = new Record[] { bookmarkB, bookmarkA };
+
+    wipe();
+    Logger.debug(getName(), "Storing A, B, folder...");
+    storeRecordsInSession(repo, abf, null);
+
+    ContentResolver cr = getApplicationContext().getContentResolver();
+    final long folderID = fennecGetFolderId(cr, folderGUID);
+    assertChildrenAreOrdered(repo, folderGUID, abRecords);
+    assertChildrenAreDirect(folderID, abGUIDs);
+
+    // To ensure an interval.
+    try {
+      Thread.sleep(100);
+    } catch (InterruptedException e) {
+    }
+
+    // Store the same folder record again, and check the tracking.
+    // Because the folder array didn't change,
+    // the item is still tracked to not be uploaded.
+    folder.lastModified = System.currentTimeMillis() + 1;
+    HashSet<String> tracked = new HashSet<String>();
+    storeRecordsInSession(repo, justFolder, tracked);
+    assertChildrenAreOrdered(repo, folderGUID, abRecords);
+    assertChildrenAreDirect(folderID, abGUIDs);
+
+    assertTrue(tracked.contains(folderGUID));
+
+    // Store again, but with a different order.
+    tracked = new HashSet<String>();
+    folder.children = childrenFromRecords(bookmarkB, bookmarkA);
+    folder.lastModified = System.currentTimeMillis() + 1;
+    storeRecordsInSession(repo, justFolder, tracked);
+    assertChildrenAreOrdered(repo, folderGUID, baRecords);
+    assertChildrenAreDirect(folderID, baGUIDs);
+
+    // Now it's going to be reuploaded.
+    assertFalse(tracked.contains(folderGUID));
+  }
+
+  /**
+   * Exercise the deletion of folders when their children have not been
+   * marked as deleted. In a database with constraints, this would fail
+   * if we simply deleted the records, so we move them first.
+   */
+  public void testFolderDeletionOrphansChildren() {
+    AndroidBrowserBookmarksRepository repo = new AndroidBrowserBookmarksRepository();
+
+    long now = System.currentTimeMillis();
+
+    // Add a folder and four children.
+    final String folderGUID = "eaaaaaaaafff";
+    BookmarkRecord folder    = new BookmarkRecord(folderGUID,     "bookmarks", now -5, false);
+    BookmarkRecord bookmarkA = new BookmarkRecord("daaaaaaaaaaa", "bookmarks", now -1, false);
+    BookmarkRecord bookmarkB = new BookmarkRecord("baaaaaaaabbb", "bookmarks", now -3, false);
+    BookmarkRecord bookmarkC = new BookmarkRecord("daaaaaaaaccc", "bookmarks", now -7, false);
+    BookmarkRecord bookmarkD = new BookmarkRecord("baaaaaaaaddd", "bookmarks", now -4, false);
+
+    folder.children   = childrenFromRecords(bookmarkA, bookmarkB, bookmarkC, bookmarkD);
+    folder.sortIndex  = 150;
+    folder.title      = "Test items";
+    folder.parentID   = "toolbar";
+    folder.parentName = "Bookmarks Toolbar";
+    folder.type       = "folder";
+
+    bookmarkA.parentID    = folderGUID;
+    bookmarkA.bookmarkURI = "http://example.com/A";
+    bookmarkA.title       = "Title A";
+    bookmarkA.type        = "bookmark";
+
+    bookmarkB.parentID    = folderGUID;
+    bookmarkB.bookmarkURI = "http://example.com/B";
+    bookmarkB.title       = "Title B";
+    bookmarkB.type        = "bookmark";
+
+    bookmarkC.parentID    = folderGUID;
+    bookmarkC.bookmarkURI = "http://example.com/C";
+    bookmarkC.title       = "Title C";
+    bookmarkC.type        = "bookmark";
+
+    bookmarkD.parentID    = folderGUID;
+    bookmarkD.bookmarkURI = "http://example.com/D";
+    bookmarkD.title       = "Title D";
+    bookmarkD.type        = "bookmark";
+
+    BookmarkRecord[] abfcd = new BookmarkRecord[5];
+    BookmarkRecord[] justFolder = new BookmarkRecord[1];
+    abfcd[0] = bookmarkA;
+    abfcd[1] = bookmarkB;
+    abfcd[2] = folder;
+    abfcd[3] = bookmarkC;
+    abfcd[4] = bookmarkD;
+
+    justFolder[0] = folder;
+
+    final String[] abcdGUIDs   = new String[] { bookmarkA.guid, bookmarkB.guid, bookmarkC.guid, bookmarkD.guid };
+    final Record[] abcdRecords = new Record[] { bookmarkA, bookmarkB, bookmarkC, bookmarkD };
+
+    wipe();
+    Logger.debug(getName(), "Storing A, B, folder, C, D...");
+    storeRecordsInSession(repo, abfcd, null);
+
+    // Verify that it worked.
+    ContentResolver cr = getApplicationContext().getContentResolver();
+    final long folderID = fennecGetFolderId(cr, folderGUID);
+    assertChildrenAreOrdered(repo, folderGUID, abcdRecords);
+    assertChildrenAreDirect(folderID, abcdGUIDs);
+
+    now = System.currentTimeMillis();
+
+    // Add one child to unsorted bookmarks.
+    BookmarkRecord unsortedA = new BookmarkRecord("yiamunsorted", "bookmarks", now, false);
+    unsortedA.parentID = "unfiled";
+    unsortedA.title    = "Unsorted A";
+    unsortedA.type     = "bookmark";
+    unsortedA.androidPosition = 0;
+
+    BookmarkRecord[] ua = new BookmarkRecord[1];
+    ua[0] = unsortedA;
+
+    storeRecordsInSession(repo, ua, null);
+
+    // Ensure that the database is in this state.
+    assertChildrenAreOrdered(repo, "unfiled", ua);
+
+    // Delete the second child, the folder, and then the third child.
+    bookmarkB.bookmarkURI  = bookmarkC.bookmarkURI  = folder.bookmarkURI  = null;
+    bookmarkB.deleted      = bookmarkC.deleted      = folder.deleted      = true;
+    bookmarkB.title        = bookmarkC.title        = folder.title        = null;
+
+    // Nulling the type of folder is very important: it verifies
+    // that the session can behave correctly according to local type.
+    bookmarkB.type = bookmarkC.type = folder.type = null;
+
+    bookmarkB.lastModified = bookmarkC.lastModified = folder.lastModified = now = System.currentTimeMillis();
+
+    BookmarkRecord[] deletions = new BookmarkRecord[] { bookmarkB, folder, bookmarkC };
+    storeRecordsInSession(repo, deletions, null);
+
+    // Verify that the unsorted bookmarks folder contains its child and the
+    // first and fourth children of the now-deleted folder.
+    // Also verify that the folder is gone.
+    long unsortedID = fennecGetFolderId(cr, "unfiled");
+    long toolbarID  = fennecGetFolderId(cr, "toolbar");
+    String[] expected = new String[] { unsortedA.guid, bookmarkA.guid, bookmarkD.guid };
+
+    // This will trigger positioning.
+    assertChildrenAreUnordered(repo, "unfiled", new Record[] { unsortedA, bookmarkA, bookmarkD });
+    assertChildrenAreDirect(unsortedID, expected);
+    assertChildrenAreDirect(toolbarID, new String[] {});
+  }
+
+  /**
+   * A test where we expect to replace a local folder with a new folder (with a
+   * new GUID), whilst adding children to it. Verifies that replace and insert
+   * co-operate.
+   */
+  public void testInsertAndReplaceGuid() {
+    AndroidBrowserBookmarksRepository repo = new AndroidBrowserBookmarksRepository();
+    wipe();
+
+    BookmarkRecord folder1 = BookmarkHelpers.createFolder1();
+    BookmarkRecord folder2 = BookmarkHelpers.createFolder2(); // child of folder1
+    BookmarkRecord folder3 = BookmarkHelpers.createFolder3(); // child of folder2
+    BookmarkRecord bmk1 = BookmarkHelpers.createBookmark1();  // child of folder1
+    BookmarkRecord bmk2 = BookmarkHelpers.createBookmark2();  // child of folder1
+    BookmarkRecord bmk3 = BookmarkHelpers.createBookmark3();  // child of folder2
+    BookmarkRecord bmk4 = BookmarkHelpers.createBookmark4();  // child of folder3
+
+    BookmarkRecord[] records = new BookmarkRecord[] {
+        folder1, folder2, folder3,
+        bmk1, bmk4
+    };
+    storeRecordsInSession(repo, records, null);
+
+    assertChildrenAreUnordered(repo, folder1.guid, new Record[] { bmk1, folder2 });
+    assertChildrenAreUnordered(repo, folder2.guid, new Record[] { folder3 });
+    assertChildrenAreUnordered(repo, folder3.guid, new Record[] { bmk4 });
+
+    // Replace folder3 with a record with a new GUID, and add bmk4 as folder3's child.
+    final long now = System.currentTimeMillis();
+    folder3.guid = Utils.generateGuid();
+    folder3.lastModified = now;
+    bmk4.title = bmk4.title + "/NEW";
+    bmk4.parentID = folder3.guid; // Incoming child knows its parent.
+    bmk4.parentName = folder3.title;
+    bmk4.lastModified = now;
+
+    // Order of store should not matter.
+    ArrayList<BookmarkRecord> changedRecords = new ArrayList<BookmarkRecord>();
+    changedRecords.add(bmk2); changedRecords.add(bmk3); changedRecords.add(bmk4); changedRecords.add(folder3);
+    Collections.shuffle(changedRecords);
+    storeRecordsInSession(repo, changedRecords.toArray(new BookmarkRecord[changedRecords.size()]), null);
+
+    assertChildrenAreUnordered(repo, folder1.guid, new Record[] { bmk1, bmk2, folder2 });
+    assertChildrenAreUnordered(repo, folder2.guid, new Record[] { bmk3, folder3 });
+    assertChildrenAreUnordered(repo, folder3.guid, new Record[] { bmk4 });
+
+    assertNotNull(fetchGUID(repo, folder3.guid));
+    assertEquals(bmk4.title, fetchGUID(repo, bmk4.guid).title);
+  }
+
+  /**
+   * A test where we expect to replace a local folder with a new folder (with a
+   * new title but the same GUID), whilst adding children to it. Verifies that
+   * replace and insert co-operate.
+   */
+  public void testInsertAndReplaceTitle() {
+    AndroidBrowserBookmarksRepository repo = new AndroidBrowserBookmarksRepository();
+    wipe();
+
+    BookmarkRecord folder1 = BookmarkHelpers.createFolder1();
+    BookmarkRecord folder2 = BookmarkHelpers.createFolder2(); // child of folder1
+    BookmarkRecord folder3 = BookmarkHelpers.createFolder3(); // child of folder2
+    BookmarkRecord bmk1 = BookmarkHelpers.createBookmark1();  // child of folder1
+    BookmarkRecord bmk2 = BookmarkHelpers.createBookmark2();  // child of folder1
+    BookmarkRecord bmk3 = BookmarkHelpers.createBookmark3();  // child of folder2
+    BookmarkRecord bmk4 = BookmarkHelpers.createBookmark4();  // child of folder3
+
+    BookmarkRecord[] records = new BookmarkRecord[] {
+        folder1, folder2, folder3,
+        bmk1, bmk4
+    };
+    storeRecordsInSession(repo, records, null);
+
+    assertChildrenAreUnordered(repo, folder1.guid, new Record[] { bmk1, folder2 });
+    assertChildrenAreUnordered(repo, folder2.guid, new Record[] { folder3 });
+    assertChildrenAreUnordered(repo, folder3.guid, new Record[] { bmk4 });
+
+    // Rename folder1, and add bmk2 as folder1's child.
+    final long now = System.currentTimeMillis();
+    folder1.title = folder1.title + "/NEW";
+    folder1.lastModified = now;
+    bmk2.title = bmk2.title + "/NEW";
+    bmk2.parentID = folder1.guid; // Incoming child knows its parent.
+    bmk2.parentName = folder1.title;
+    bmk2.lastModified = now;
+
+    // Order of store should not matter.
+    ArrayList<BookmarkRecord> changedRecords = new ArrayList<BookmarkRecord>();
+    changedRecords.add(bmk2); changedRecords.add(bmk3); changedRecords.add(folder1);
+    Collections.shuffle(changedRecords);
+    storeRecordsInSession(repo, changedRecords.toArray(new BookmarkRecord[changedRecords.size()]), null);
+
+    assertChildrenAreUnordered(repo, folder1.guid, new Record[] { bmk1, bmk2, folder2 });
+    assertChildrenAreUnordered(repo, folder2.guid, new Record[] { bmk3, folder3 });
+    assertChildrenAreUnordered(repo, folder3.guid, new Record[] { bmk4 });
+
+    assertEquals(folder1.title, fetchGUID(repo, folder1.guid).title);
+    assertEquals(bmk2.title, fetchGUID(repo, bmk2.guid).title);
+  }
+
+  /**
+   * Create and begin a new session, handing control to the delegate when started.
+   * Returns when the delegate has notified.
+   */
+  public void inBegunSession(final AndroidBrowserBookmarksRepository repo,
+                             final RepositorySessionBeginDelegate beginDelegate) {
+    Runnable go = new Runnable() {
+      @Override
+      public void run() {
+        RepositorySessionCreationDelegate delegate = new SimpleSuccessCreationDelegate() {
+          @Override
+          public void onSessionCreated(final RepositorySession session) {
+            try {
+              session.begin(beginDelegate);
+            } catch (InvalidSessionTransitionException e) {
+              performNotify(e);
+            }
+          }
+        };
+        repo.createSession(delegate, getApplicationContext());
+      }
+    };
+    performWait(go);
+  }
+
+  /**
+   * Finish the provided session, notifying on success.
+   *
+   * @param session
+   */
+  public void finishAndNotify(final RepositorySession session) {
+    try {
+      session.finish(new SimpleSuccessFinishDelegate() {
+        @Override
+        public void onFinishSucceeded(RepositorySession session,
+                                      RepositorySessionBundle bundle) {
+          performNotify();
+        }
+      });
+    } catch (InactiveSessionException e) {
+      performNotify(e);
+    }
+  }
+
+  /**
+   * Simple helper class for fetching all records.
+   * The fetched records' GUIDs are stored in `fetchedGUIDs`.
+   */
+  public class SimpleFetchAllBeginDelegate extends SimpleSuccessBeginDelegate {
+    public final ArrayList<String> fetchedGUIDs = new ArrayList<String>();
+
+    @Override
+    public void onBeginSucceeded(final RepositorySession session) {
+      RepositorySessionFetchRecordsDelegate fetchDelegate = new SimpleSuccessFetchDelegate() {
+
+        @Override
+        public void onFetchedRecord(Record record) {
+          fetchedGUIDs.add(record.guid);
+        }
+
+        @Override
+        public void onFetchCompleted(long end) {
+          finishAndNotify(session);
+        }
+      };
+      session.fetchSince(0, fetchDelegate);
+    }
+  }
+
+  /**
+   * Simple helper class for fetching a single record by GUID.
+   * The fetched record is stored in `fetchedRecord`.
+   */
+  public class SimpleFetchOneBeginDelegate extends SimpleSuccessBeginDelegate {
+    public final String guid;
+    public Record fetchedRecord = null;
+
+    public SimpleFetchOneBeginDelegate(String guid) {
+      this.guid = guid;
+    }
+
+    @Override
+    public void onBeginSucceeded(final RepositorySession session) {
+      RepositorySessionFetchRecordsDelegate fetchDelegate = new SimpleSuccessFetchDelegate() {
+
+        @Override
+        public void onFetchedRecord(Record record) {
+          fetchedRecord = record;
+        }
+
+        @Override
+        public void onFetchCompleted(long end) {
+          finishAndNotify(session);
+        }
+      };
+      try {
+        session.fetch(new String[] { guid }, fetchDelegate);
+      } catch (InactiveSessionException e) {
+        performNotify("Session is inactive.", e);
+      }
+    }
+  }
+
+  /**
+   * Create a new session for the given repository, storing each record
+   * from the provided array. Notifies on failure or success.
+   *
+   * Optionally populates a provided Collection with tracked items.
+   * @param repo
+   * @param records
+   * @param tracked
+   */
+  public void storeRecordsInSession(AndroidBrowserBookmarksRepository repo,
+                                    final BookmarkRecord[] records,
+                                    final Collection<String> tracked) {
+    SimpleSuccessBeginDelegate beginDelegate = new SimpleSuccessBeginDelegate() {
+      @Override
+      public void onBeginSucceeded(final RepositorySession session) {
+        RepositorySessionStoreDelegate storeDelegate = new SimpleSuccessStoreDelegate() {
+
+          @Override
+          public void onStoreCompleted(final long storeEnd) {
+            // Pass back whatever we tracked.
+            if (tracked != null) {
+              Iterator<String> iter = session.getTrackedRecordIDs();
+              while (iter.hasNext()) {
+                tracked.add(iter.next());
+              }
+            }
+            finishAndNotify(session);
+          }
+
+          @Override
+          public void onRecordStoreSucceeded(String guid) {
+          }
+        };
+        session.setStoreDelegate(storeDelegate);
+        for (BookmarkRecord record : records) {
+          try {
+            session.store(record);
+          } catch (NoStoreDelegateException e) {
+            // Never happens.
+          }
+        }
+        session.storeDone();
+      }
+    };
+    inBegunSession(repo, beginDelegate);
+  }
+
+  public ArrayList<String> fetchGUIDs(AndroidBrowserBookmarksRepository repo) {
+    SimpleFetchAllBeginDelegate beginDelegate = new SimpleFetchAllBeginDelegate();
+    inBegunSession(repo, beginDelegate);
+    return beginDelegate.fetchedGUIDs;
+  }
+
+  public BookmarkRecord fetchGUID(AndroidBrowserBookmarksRepository repo,
+                                  final String guid) {
+    Logger.info(LOG_TAG, "Fetching for " + guid);
+    SimpleFetchOneBeginDelegate beginDelegate = new SimpleFetchOneBeginDelegate(guid);
+    inBegunSession(repo, beginDelegate);
+    Logger.info(LOG_TAG, "Fetched " + beginDelegate.fetchedRecord);
+    assertTrue(beginDelegate.fetchedRecord != null);
+    return (BookmarkRecord) beginDelegate.fetchedRecord;
+  }
+
+  public JSONArray fetchChildrenForGUID(AndroidBrowserBookmarksRepository repo,
+      final String guid) {
+    return fetchGUID(repo, guid).children;
+  }
+
+  @SuppressWarnings("unchecked")
+  protected static JSONArray childrenFromRecords(BookmarkRecord... records) {
+    JSONArray children = new JSONArray();
+    for (BookmarkRecord record : records) {
+      children.add(record.guid);
+    }
+    return children;
+  }
+
+
+  protected void updateRow(ContentValues values) {
+    Uri uri = BrowserContractHelpers.BOOKMARKS_CONTENT_URI;
+    final String where = BrowserContract.Bookmarks.GUID + " = ?";
+    final String[] args = new String[] { values.getAsString(BrowserContract.Bookmarks.GUID) };
+    getApplicationContext().getContentResolver().update(uri, values, where, args);
+  }
+
+  protected Uri insertRow(ContentValues values) {
+    Uri uri = BrowserContractHelpers.BOOKMARKS_CONTENT_URI;
+    return getApplicationContext().getContentResolver().insert(uri, values);
+  }
+
+  protected static ContentValues specialFolder() {
+    ContentValues values = new ContentValues();
+
+    final long now = System.currentTimeMillis();
+    values.put(Bookmarks.DATE_CREATED, now);
+    values.put(Bookmarks.DATE_MODIFIED, now);
+    values.put(Bookmarks.TYPE, BrowserContract.Bookmarks.TYPE_FOLDER);
+
+    return values;
+  }
+
+  protected static ContentValues fennecMobileRecordWithoutTitle() {
+    ContentValues values = specialFolder();
+    values.put(BrowserContract.SyncColumns.GUID, "mobile");
+    values.putNull(BrowserContract.Bookmarks.TITLE);
+
+    return values;
+  }
+
+  protected ContentValues fennecPinnedItemsRecord() {
+    final ContentValues values = specialFolder();
+    final String title = getApplicationContext().getResources().getString(R.string.bookmarks_folder_pinned);
+
+    values.put(BrowserContract.SyncColumns.GUID, Bookmarks.PINNED_FOLDER_GUID);
+    values.put(Bookmarks._ID, Bookmarks.FIXED_PINNED_LIST_ID);
+    values.put(Bookmarks.PARENT, Bookmarks.FIXED_ROOT_ID);
+    values.put(Bookmarks.TITLE, title);
+    return values;
+  }
+
+  protected static ContentValues fennecPinnedChildItemRecord() {
+    ContentValues values = new ContentValues();
+
+    final long now = System.currentTimeMillis();
+
+    values.put(BrowserContract.SyncColumns.GUID, "dapinneditem");
+    values.put(Bookmarks.DATE_CREATED, now);
+    values.put(Bookmarks.DATE_MODIFIED, now);
+    values.put(Bookmarks.TYPE, BrowserContract.Bookmarks.TYPE_BOOKMARK);
+    values.put(Bookmarks.URL, "user-entered:foobar");
+    values.put(Bookmarks.PARENT, Bookmarks.FIXED_PINNED_LIST_ID);
+    values.put(Bookmarks.TITLE, "Foobar");
+    return values;
+  }
+
+  protected long setUpFennecMobileRecordWithoutTitle() {
+    ContentResolver cr = getApplicationContext().getContentResolver();
+    ContentValues values = fennecMobileRecordWithoutTitle();
+    updateRow(values);
+    return fennecGetMobileBookmarksFolderId(cr);
+  }
+
+  protected long setUpFennecMobileRecord() {
+    ContentResolver cr = getApplicationContext().getContentResolver();
+    ContentValues values = fennecMobileRecordWithoutTitle();
+    values.put(BrowserContract.Bookmarks.PARENT, BrowserContract.Bookmarks.FIXED_ROOT_ID);
+    String title = getApplicationContext().getResources().getString(R.string.bookmarks_folder_mobile);
+    values.put(BrowserContract.Bookmarks.TITLE, title);
+    updateRow(values);
+    return fennecGetMobileBookmarksFolderId(cr);
+  }
+
+  protected void setUpFennecPinnedItemsRecord() {
+    insertRow(fennecPinnedItemsRecord());
+    insertRow(fennecPinnedChildItemRecord());
+  }
+
+  //
+  // Fennec fake layer.
+  //
+  private Uri appendProfile(Uri uri) {
+    final String defaultProfile = "default";     // Fennec constant removed in Bug 715307.
+    return uri.buildUpon().appendQueryParameter(BrowserContract.PARAM_PROFILE, defaultProfile).build();
+  }
+
+  private long fennecGetFolderId(ContentResolver cr, String guid) {
+    Cursor c = null;
+    try {
+      c = cr.query(appendProfile(BrowserContractHelpers.BOOKMARKS_CONTENT_URI),
+          new String[] { BrowserContract.Bookmarks._ID },
+          BrowserContract.Bookmarks.GUID + " = ?",
+          new String[] { guid },
+          null);
+
+      if (c.moveToFirst()) {
+        return c.getLong(c.getColumnIndexOrThrow(BrowserContract.Bookmarks._ID));
+      }
+      return -1;
+    } finally {
+      if (c != null) {
+        c.close();
+      }
+    }
+  }
+
+  private long fennecGetMobileBookmarksFolderId(ContentResolver cr) {
+    return fennecGetFolderId(cr, BrowserContract.Bookmarks.MOBILE_FOLDER_GUID);
+  }
+
+  public void fennecAddBookmark(String title, String uri) {
+    ContentResolver cr = getApplicationContext().getContentResolver();
+
+    long folderId = fennecGetMobileBookmarksFolderId(cr);
+    if (folderId < 0) {
+      return;
+    }
+
+    ContentValues values = new ContentValues();
+    values.put(BrowserContract.Bookmarks.TITLE, title);
+    values.put(BrowserContract.Bookmarks.URL, uri);
+    values.put(BrowserContract.Bookmarks.PARENT, folderId);
+
+    // Restore deleted record if possible
+    values.put(BrowserContract.Bookmarks.IS_DELETED, 0);
+
+    Logger.debug(getName(), "Adding bookmark " + title + ", " + uri + " in " + folderId);
+    int updated = cr.update(appendProfile(BrowserContractHelpers.BOOKMARKS_CONTENT_URI),
+        values,
+        BrowserContract.Bookmarks.URL + " = ?",
+            new String[] { uri });
+
+    if (updated == 0) {
+      Uri insert = cr.insert(appendProfile(BrowserContractHelpers.BOOKMARKS_CONTENT_URI), values);
+      long idFromUri = ContentUris.parseId(insert);
+      Logger.debug(getName(), "Inserted " + uri + " as " + idFromUri);
+      Logger.debug(getName(), "Position is " + getPosition(idFromUri));
+    }
+  }
+
+  private long getPosition(long idFromUri) {
+    ContentResolver cr = getApplicationContext().getContentResolver();
+    Cursor c = cr.query(appendProfile(BrowserContractHelpers.BOOKMARKS_CONTENT_URI),
+                        new String[] { BrowserContract.Bookmarks.POSITION },
+                        BrowserContract.Bookmarks._ID + " = ?",
+                        new String[] { String.valueOf(idFromUri) },
+                        null);
+    if (!c.moveToFirst()) {
+      return -2;
+    }
+    return c.getLong(0);
+  }
+
+  protected AndroidBrowserBookmarksDataAccessor dataAccessor = null;
+  protected AndroidBrowserBookmarksDataAccessor getDataAccessor() {
+    if (dataAccessor == null) {
+      dataAccessor = new AndroidBrowserBookmarksDataAccessor(getApplicationContext());
+    }
+    return dataAccessor;
+  }
+
+  protected void wipe() {
+    Logger.debug(getName(), "Wiping.");
+    getDataAccessor().wipe();
+  }
+
+  protected void assertChildrenAreOrdered(AndroidBrowserBookmarksRepository repo, String guid, Record[] expected) {
+    Logger.debug(getName(), "Fetching children...");
+    JSONArray folderChildren = fetchChildrenForGUID(repo, guid);
+
+    assertTrue(folderChildren != null);
+    Logger.debug(getName(), "Children are " + folderChildren.toJSONString());
+    assertEquals(expected.length, folderChildren.size());
+    for (int i = 0; i < expected.length; ++i) {
+      assertEquals(expected[i].guid, ((String) folderChildren.get(i)));
+    }
+  }
+
+  protected void assertChildrenAreUnordered(AndroidBrowserBookmarksRepository repo, String guid, Record[] expected) {
+    Logger.debug(getName(), "Fetching children...");
+    JSONArray folderChildren = fetchChildrenForGUID(repo, guid);
+
+    assertTrue(folderChildren != null);
+    Logger.debug(getName(), "Children are " + folderChildren.toJSONString());
+    assertEquals(expected.length, folderChildren.size());
+    for (Record record : expected) {
+      folderChildren.contains(record.guid);
+    }
+  }
+
+  /**
+   * Return a sequence of children GUIDs for the provided folder ID.
+   */
+  protected ArrayList<String> fetchChildrenDirect(long id) {
+    Logger.debug(getName(), "Fetching children directly from DB...");
+    final ArrayList<String> out = new ArrayList<String>();
+    final AndroidBrowserBookmarksDataAccessor accessor = new AndroidBrowserBookmarksDataAccessor(getApplicationContext());
+    Cursor cur = null;
+    try {
+      cur = accessor.getChildren(id);
+    } catch (NullCursorException e) {
+      fail("Got null cursor.");
+    }
+    try {
+      if (!cur.moveToFirst()) {
+        return out;
+      }
+      final int guidCol = cur.getColumnIndex(BrowserContract.SyncColumns.GUID);
+      while (!cur.isAfterLast()) {
+        out.add(cur.getString(guidCol));
+        cur.moveToNext();
+      }
+    } finally {
+      cur.close();
+    }
+    return out;
+  }
+
+  /**
+   * Assert that the children of the provided ID are correct and positioned in the database.
+   * @param id
+   * @param guids
+   */
+  protected void assertChildrenAreDirect(long id, String[] guids) {
+    Logger.debug(getName(), "Fetching children directly from DB...");
+    AndroidBrowserBookmarksDataAccessor accessor = new AndroidBrowserBookmarksDataAccessor(getApplicationContext());
+    Cursor cur = null;
+    try {
+      cur = accessor.getChildren(id);
+    } catch (NullCursorException e) {
+      fail("Got null cursor.");
+    }
+    try {
+      if (guids == null || guids.length == 0) {
+        assertFalse(cur.moveToFirst());
+        return;
+      }
+
+      assertTrue(cur.moveToFirst());
+      int i = 0;
+      final int guidCol = cur.getColumnIndex(BrowserContract.SyncColumns.GUID);
+      final int posCol = cur.getColumnIndex(BrowserContract.Bookmarks.POSITION);
+      while (!cur.isAfterLast()) {
+        assertTrue(i < guids.length);
+        final String guid = cur.getString(guidCol);
+        final int pos = cur.getInt(posCol);
+        Logger.debug(getName(), "Fetched child: " + guid + " has position " + pos);
+        assertEquals(guids[i], guid);
+        assertEquals(i,        pos);
+
+        ++i;
+        cur.moveToNext();
+      }
+      assertEquals(guids.length, i);
+    } finally {
+      cur.close();
+    }
+  }
+}
+
+/**
+TODO
+
+Test for storing a record that will reconcile to mobile; postcondition is
+that there's still a directory called mobile that includes all the items that
+it used to.
+
+mobile folder created without title.
+Unsorted put in mobile???
+Tests for children retrieval
+Tests for children merge
+Tests for modify retrieve parent when child added, removed, reordered (oh, reorder is hard! Any change, then.)
+Safety mode?
+Test storing folder first, contents first.
+Store folder in next session. Verify order recovery.
+
+
+*/
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestClientsDatabase.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestClientsDatabase.java
new file mode 100644
index 000000000..198073fcf
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestClientsDatabase.java
@@ -0,0 +1,200 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.db;
+
+import java.util.ArrayList;
+
+import org.json.simple.JSONArray;
+import org.mozilla.gecko.sync.Utils;
+import org.mozilla.gecko.sync.repositories.NullCursorException;
+import org.mozilla.gecko.sync.repositories.android.ClientsDatabase;
+import org.mozilla.gecko.sync.repositories.android.RepoUtils;
+import org.mozilla.gecko.sync.repositories.domain.ClientRecord;
+import org.mozilla.gecko.sync.setup.Constants;
+
+import android.database.Cursor;
+import android.test.AndroidTestCase;
+
+public class TestClientsDatabase extends AndroidTestCase {
+
+  protected ClientsDatabase db;
+
+  public void setUp() {
+    db = new ClientsDatabase(mContext);
+    db.wipeDB();
+  }
+
+  public void testStoreAndFetch() {
+    ClientRecord record = new ClientRecord();
+    String profileConst = Constants.DEFAULT_PROFILE;
+    db.store(profileConst, record);
+
+    Cursor cur = null;
+    try {
+      // Test stored item gets fetched correctly.
+      cur = db.fetchClientsCursor(record.guid, profileConst);
+      assertTrue(cur.moveToFirst());
+      assertEquals(1, cur.getCount());
+
+      String guid = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_ACCOUNT_GUID);
+      String profileId = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_PROFILE);
+      String clientName = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_NAME);
+      String clientType = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_TYPE);
+
+      assertEquals(record.guid, guid);
+      assertEquals(profileConst, profileId);
+      assertEquals(record.name, clientName);
+      assertEquals(record.type, clientType);
+    } catch (NullCursorException e) {
+      fail("Should not have NullCursorException");
+    } finally {
+      if (cur != null) {
+        cur.close();
+      }
+    }
+  }
+
+  public void testStoreAndFetchSpecificCommands() {
+    String accountGUID = Utils.generateGuid();
+    ArrayList<String> args = new ArrayList<String>();
+    args.add("URI of Page");
+    args.add("Sender GUID");
+    args.add("Title of Page");
+    String jsonArgs = JSONArray.toJSONString(args);
+
+    Cursor cur = null;
+    try {
+      db.store(accountGUID, "displayURI", jsonArgs);
+
+      // This row should not show up in the fetch.
+      args.add("Another arg.");
+      db.store(accountGUID, "displayURI", JSONArray.toJSONString(args));
+
+      // Test stored item gets fetched correctly.
+      cur = db.fetchSpecificCommand(accountGUID, "displayURI", jsonArgs);
+      assertTrue(cur.moveToFirst());
+      assertEquals(1, cur.getCount());
+
+      String guid = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_ACCOUNT_GUID);
+      String commandType = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_COMMAND);
+      String fetchedArgs = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_ARGS);
+
+      assertEquals(accountGUID, guid);
+      assertEquals("displayURI", commandType);
+      assertEquals(jsonArgs, fetchedArgs);
+    } catch (NullCursorException e) {
+      fail("Should not have NullCursorException");
+    } finally {
+      if (cur != null) {
+        cur.close();
+      }
+    }
+  }
+
+  public void testFetchCommandsForClient() {
+    String accountGUID = Utils.generateGuid();
+    ArrayList<String> args = new ArrayList<String>();
+    args.add("URI of Page");
+    args.add("Sender GUID");
+    args.add("Title of Page");
+    String jsonArgs = JSONArray.toJSONString(args);
+
+    Cursor cur = null;
+    try {
+      db.store(accountGUID, "displayURI", jsonArgs);
+
+      // This row should ALSO show up in the fetch.
+      args.add("Another arg.");
+      db.store(accountGUID, "displayURI", JSONArray.toJSONString(args));
+
+      // Test both stored items with the same GUID but different command are fetched.
+      cur = db.fetchCommandsForClient(accountGUID);
+      assertTrue(cur.moveToFirst());
+      assertEquals(2, cur.getCount());
+    } catch (NullCursorException e) {
+      fail("Should not have NullCursorException");
+    } finally {
+      if (cur != null) {
+        cur.close();
+      }
+    }
+  }
+
+  @SuppressWarnings("resource")
+  public void testDelete() {
+    ClientRecord record1 = new ClientRecord();
+    ClientRecord record2 = new ClientRecord();
+    String profileConst = Constants.DEFAULT_PROFILE;
+
+    db.store(profileConst, record1);
+    db.store(profileConst, record2);
+
+    Cursor cur = null;
+    try {
+      // Test record doesn't exist after delete.
+      db.deleteClient(record1.guid, profileConst);
+      cur = db.fetchClientsCursor(record1.guid, profileConst);
+      assertFalse(cur.moveToFirst());
+      assertEquals(0, cur.getCount());
+
+      // Test record2 still there after deleting record1.
+      cur = db.fetchClientsCursor(record2.guid, profileConst);
+      assertTrue(cur.moveToFirst());
+      assertEquals(1, cur.getCount());
+
+      String guid = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_ACCOUNT_GUID);
+      String profileId = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_PROFILE);
+      String clientName = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_NAME);
+      String clientType = RepoUtils.getStringFromCursor(cur, ClientsDatabase.COL_TYPE);
+
+      assertEquals(record2.guid, guid);
+      assertEquals(profileConst, profileId);
+      assertEquals(record2.name, clientName);
+      assertEquals(record2.type, clientType);
+    } catch (NullCursorException e) {
+      fail("Should not have NullCursorException");
+    } finally {
+      if (cur != null) {
+        cur.close();
+      }
+    }
+  }
+
+  @SuppressWarnings("resource")
+  public void testWipe() {
+    ClientRecord record1 = new ClientRecord();
+    ClientRecord record2 = new ClientRecord();
+    String profileConst = Constants.DEFAULT_PROFILE;
+
+    db.store(profileConst, record1);
+    db.store(profileConst, record2);
+
+
+    Cursor cur = null;
+    try {
+      // Test before wipe the records are there.
+      cur = db.fetchClientsCursor(record2.guid, profileConst);
+      assertTrue(cur.moveToFirst());
+      assertEquals(1, cur.getCount());
+      cur = db.fetchClientsCursor(record2.guid, profileConst);
+      assertTrue(cur.moveToFirst());
+      assertEquals(1, cur.getCount());
+
+      // Test after wipe neither record exists.
+      db.wipeClientsTable();
+      cur = db.fetchClientsCursor(record2.guid, profileConst);
+      assertFalse(cur.moveToFirst());
+      assertEquals(0, cur.getCount());
+      cur = db.fetchClientsCursor(record1.guid, profileConst);
+      assertFalse(cur.moveToFirst());
+      assertEquals(0, cur.getCount());
+    } catch (NullCursorException e) {
+      fail("Should not have NullCursorException");
+    } finally {
+      if (cur != null) {
+        cur.close();
+      }
+    }
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestClientsDatabaseAccessor.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestClientsDatabaseAccessor.java
new file mode 100644
index 000000000..65b14e860
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestClientsDatabaseAccessor.java
@@ -0,0 +1,128 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.db;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.mozilla.gecko.background.testhelpers.CommandHelpers;
+import org.mozilla.gecko.sync.CommandProcessor.Command;
+import org.mozilla.gecko.sync.Utils;
+import org.mozilla.gecko.sync.repositories.NullCursorException;
+import org.mozilla.gecko.sync.repositories.android.ClientsDatabaseAccessor;
+import org.mozilla.gecko.sync.repositories.domain.ClientRecord;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.test.AndroidTestCase;
+
+public class TestClientsDatabaseAccessor extends AndroidTestCase {
+
+  public class StubbedClientsDatabaseAccessor extends ClientsDatabaseAccessor {
+    public StubbedClientsDatabaseAccessor(Context mContext) {
+      super(mContext);
+    }
+  }
+
+  StubbedClientsDatabaseAccessor db;
+
+  public void setUp() {
+    db = new StubbedClientsDatabaseAccessor(mContext);
+    db.wipeDB();
+  }
+
+  public void tearDown() {
+    db.close();
+  }
+
+  public void testStoreArrayListAndFetch() throws NullCursorException {
+    ArrayList<ClientRecord> list = new ArrayList<ClientRecord>();
+    ClientRecord record1 = new ClientRecord(Utils.generateGuid());
+    ClientRecord record2 = new ClientRecord(Utils.generateGuid());
+    ClientRecord record3 = new ClientRecord(Utils.generateGuid());
+
+    list.add(record1);
+    list.add(record2);
+    db.store(list);
+
+    ClientRecord r1 = db.fetchClient(record1.guid);
+    ClientRecord r2 = db.fetchClient(record2.guid);
+    ClientRecord r3 = db.fetchClient(record3.guid);
+
+    assertNotNull(r1);
+    assertNotNull(r2);
+    assertNull(r3);
+    assertTrue(record1.equals(r1));
+    assertTrue(record2.equals(r2));
+    assertFalse(record3.equals(r3));
+  }
+
+  public void testStoreAndFetchCommandsForClient() {
+    String accountGUID1 = Utils.generateGuid();
+    String accountGUID2 = Utils.generateGuid();
+
+    Command command1 = CommandHelpers.getCommand1();
+    Command command2 = CommandHelpers.getCommand2();
+    Command command3 = CommandHelpers.getCommand3();
+
+    Cursor cur = null;
+    try {
+      db.store(accountGUID1, command1);
+      db.store(accountGUID1, command2);
+      db.store(accountGUID2, command3);
+
+      List<Command> commands = db.fetchCommandsForClient(accountGUID1);
+      assertEquals(2, commands.size());
+      assertEquals(1, commands.get(0).args.size());
+      assertEquals(1, commands.get(1).args.size());
+    } catch (NullCursorException e) {
+      fail("Should not have NullCursorException");
+    } finally {
+      if (cur != null) {
+        cur.close();
+      }
+    }
+  }
+
+  public void testNumClients() {
+    final int COUNT = 5;
+    ArrayList<ClientRecord> list = new ArrayList<ClientRecord>();
+    for (int i = 0; i < 5; i++) {
+      list.add(new ClientRecord());
+    }
+    db.store(list);
+    assertEquals(COUNT, db.clientsCount());
+  }
+
+  public void testFetchAll() throws NullCursorException {
+    ArrayList<ClientRecord> list = new ArrayList<ClientRecord>();
+    ClientRecord record1 = new ClientRecord(Utils.generateGuid());
+    ClientRecord record2 = new ClientRecord(Utils.generateGuid());
+
+    list.add(record1);
+    list.add(record2);
+
+    boolean thrown = false;
+    try {
+      Map<String, ClientRecord> records =  db.fetchAllClients();
+
+      assertNotNull(records);
+      assertEquals(0, records.size());
+
+      db.store(list);
+      records = db.fetchAllClients();
+      assertNotNull(records);
+      assertEquals(2, records.size());
+      assertTrue(record1.equals(records.get(record1.guid)));
+      assertTrue(record2.equals(records.get(record2.guid)));
+
+      // put() should throw an exception since records is immutable.
+      records.put(null, null);
+    } catch (UnsupportedOperationException e) {
+      thrown = true;
+    }
+    assertTrue(thrown);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestFennecTabsRepositorySession.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestFennecTabsRepositorySession.java
new file mode 100644
index 000000000..02d393ce8
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestFennecTabsRepositorySession.java
@@ -0,0 +1,297 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.db;
+
+import org.json.simple.JSONArray;
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.background.sync.helpers.ExpectFetchDelegate;
+import org.mozilla.gecko.background.sync.helpers.SessionTestHelper;
+import org.mozilla.gecko.background.testhelpers.MockClientsDataDelegate;
+import org.mozilla.gecko.db.BrowserContract;
+import org.mozilla.gecko.db.BrowserContract.Clients;
+import org.mozilla.gecko.sync.repositories.NoContentProviderException;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.android.BrowserContractHelpers;
+import org.mozilla.gecko.sync.repositories.android.ClientsDatabaseAccessor;
+import org.mozilla.gecko.sync.repositories.android.FennecTabsRepository;
+import org.mozilla.gecko.sync.repositories.android.FennecTabsRepository.FennecTabsRepositorySession;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
+import org.mozilla.gecko.sync.repositories.domain.ClientRecord;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+import org.mozilla.gecko.sync.repositories.domain.TabsRecord;
+
+import android.content.ContentProviderClient;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.Cursor;
+import android.os.RemoteException;
+
+public class TestFennecTabsRepositorySession extends AndroidSyncTestCase {
+  public static final MockClientsDataDelegate clientsDataDelegate = new MockClientsDataDelegate();
+  public static final String TEST_CLIENT_GUID = clientsDataDelegate.getAccountGUID();
+  public static final String TEST_CLIENT_NAME = clientsDataDelegate.getClientName();
+  public static final String TEST_CLIENT_DEVICE_TYPE = "phablet";
+
+  // Override these to test against data that is not live.
+  public static final String TEST_TABS_CLIENT_GUID_IS_LOCAL_SELECTION = BrowserContract.Tabs.CLIENT_GUID + " IS ?";
+  public static final String[] TEST_TABS_CLIENT_GUID_IS_LOCAL_SELECTION_ARGS = new String[] { TEST_CLIENT_GUID };
+
+  public static final String TEST_CLIENTS_GUID_IS_LOCAL_SELECTION = BrowserContract.Clients.GUID + " IS ?";
+  public static final String[] TEST_CLIENTS_GUID_IS_LOCAL_SELECTION_ARGS = new String[] { TEST_CLIENT_GUID };
+
+  protected ContentProviderClient tabsClient = null;
+  protected ContentProviderClient clientsClient = null;
+
+  protected ContentProviderClient getTabsClient() {
+    final ContentResolver cr = getApplicationContext().getContentResolver();
+    return cr.acquireContentProviderClient(BrowserContractHelpers.TABS_CONTENT_URI);
+  }
+
+  protected ContentProviderClient getClientsClient() {
+    final ContentResolver cr = getApplicationContext().getContentResolver();
+    return cr.acquireContentProviderClient(BrowserContractHelpers.CLIENTS_CONTENT_URI);
+  }
+
+  public TestFennecTabsRepositorySession() throws NoContentProviderException {
+    super();
+  }
+
+  @Override
+  public void setUp() {
+    if (tabsClient == null) {
+      tabsClient = getTabsClient();
+    }
+    if (clientsClient == null) {
+      clientsClient = getClientsClient();
+    }
+  }
+
+  protected int deleteTestClient(final ContentProviderClient clientsClient) throws RemoteException {
+    if (clientsClient == null) {
+      return -1;
+    }
+    return clientsClient.delete(BrowserContractHelpers.CLIENTS_CONTENT_URI, TEST_CLIENTS_GUID_IS_LOCAL_SELECTION, TEST_CLIENTS_GUID_IS_LOCAL_SELECTION_ARGS);
+  }
+
+  protected int deleteAllTestTabs(final ContentProviderClient tabsClient) throws RemoteException {
+    if (tabsClient == null) {
+      return -1;
+    }
+    return tabsClient.delete(BrowserContractHelpers.TABS_CONTENT_URI,
+        TEST_TABS_CLIENT_GUID_IS_LOCAL_SELECTION, TEST_TABS_CLIENT_GUID_IS_LOCAL_SELECTION_ARGS);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    if (tabsClient != null) {
+      deleteAllTestTabs(tabsClient);
+
+      tabsClient.release();
+      tabsClient = null;
+    }
+
+    if (clientsClient != null) {
+      deleteTestClient(clientsClient);
+
+      clientsClient.release();
+      clientsClient = null;
+    }
+  }
+
+  protected FennecTabsRepository getRepository() {
+    /**
+     * Override this chain in order to avoid our test code having to create two
+     * sessions all the time.
+     */
+    return new FennecTabsRepository(clientsDataDelegate) {
+      @Override
+      public void createSession(RepositorySessionCreationDelegate delegate,
+                                Context context) {
+        try {
+          final FennecTabsRepositorySession session = new FennecTabsRepositorySession(this, context) {
+            @Override
+            protected synchronized void trackGUID(String guid) {
+            }
+
+            @Override
+            protected String localClientSelection() {
+              return TEST_TABS_CLIENT_GUID_IS_LOCAL_SELECTION;
+            }
+
+            @Override
+            protected String[] localClientSelectionArgs() {
+              return TEST_TABS_CLIENT_GUID_IS_LOCAL_SELECTION_ARGS;
+            }
+          };
+          delegate.onSessionCreated(session);
+        } catch (Exception e) {
+          delegate.onSessionCreateFailed(e);
+        }
+      }
+    };
+  }
+
+  protected FennecTabsRepositorySession createSession() {
+    return (FennecTabsRepositorySession) SessionTestHelper.createSession(
+        getApplicationContext(),
+        getRepository());
+  }
+
+  protected FennecTabsRepositorySession createAndBeginSession() {
+    return (FennecTabsRepositorySession) SessionTestHelper.createAndBeginSession(
+        getApplicationContext(),
+        getRepository());
+  }
+
+  protected Runnable fetchSinceRunnable(final RepositorySession session, final long timestamp, final Record[] expectedRecords) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.fetchSince(timestamp, new ExpectFetchDelegate(expectedRecords));
+      }
+    };
+  }
+
+  protected Runnable fetchAllRunnable(final RepositorySession session, final Record[] expectedRecords) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.fetchAll(new ExpectFetchDelegate(expectedRecords));
+      }
+    };
+  }
+
+  protected Tab testTab1;
+  protected Tab testTab2;
+  protected Tab testTab3;
+
+  @SuppressWarnings("unchecked")
+  private void insertSomeTestTabs(ContentProviderClient tabsClient) throws RemoteException {
+    final JSONArray history1 = new JSONArray();
+    history1.add("http://test.com/test1.html");
+    testTab1 = new Tab("test title 1", "http://test.com/test1.png", history1, 1000);
+
+    final JSONArray history2 = new JSONArray();
+    history2.add("http://test.com/test2.html#1");
+    history2.add("http://test.com/test2.html#2");
+    history2.add("http://test.com/test2.html#3");
+    testTab2 = new Tab("test title 2", "http://test.com/test2.png", history2, 2000);
+
+    final JSONArray history3 = new JSONArray();
+    history3.add("http://test.com/test3.html#1");
+    history3.add("http://test.com/test3.html#2");
+    testTab3 = new Tab("test title 3", "http://test.com/test3.png", history3, 3000);
+
+    tabsClient.insert(BrowserContractHelpers.TABS_CONTENT_URI, testTab1.toContentValues(TEST_CLIENT_GUID, 0));
+    tabsClient.insert(BrowserContractHelpers.TABS_CONTENT_URI, testTab2.toContentValues(TEST_CLIENT_GUID, 1));
+    tabsClient.insert(BrowserContractHelpers.TABS_CONTENT_URI, testTab3.toContentValues(TEST_CLIENT_GUID, 2));
+  }
+
+  protected TabsRecord insertTestTabsAndExtractTabsRecord() throws RemoteException {
+    insertSomeTestTabs(tabsClient);
+
+    final String positionAscending = BrowserContract.Tabs.POSITION + " ASC";
+    Cursor cursor = null;
+    try {
+      cursor = tabsClient.query(BrowserContractHelpers.TABS_CONTENT_URI, null,
+          TEST_TABS_CLIENT_GUID_IS_LOCAL_SELECTION, TEST_TABS_CLIENT_GUID_IS_LOCAL_SELECTION_ARGS, positionAscending);
+      CursorDumper.dumpCursor(cursor);
+
+      final TabsRecord tabsRecord = FennecTabsRepository.tabsRecordFromCursor(cursor, TEST_CLIENT_GUID, TEST_CLIENT_NAME);
+
+      assertEquals(TEST_CLIENT_GUID, tabsRecord.guid);
+      assertEquals(TEST_CLIENT_NAME, tabsRecord.clientName);
+
+      assertNotNull(tabsRecord.tabs);
+      assertEquals(cursor.getCount(), tabsRecord.tabs.size());
+
+      return tabsRecord;
+    } finally {
+      cursor.close();
+    }
+  }
+
+  public void testFetchAll() throws NoContentProviderException, RemoteException {
+    final TabsRecord tabsRecord = insertTestTabsAndExtractTabsRecord();
+
+    final FennecTabsRepositorySession session = createAndBeginSession();
+    performWait(fetchAllRunnable(session, new Record[] { tabsRecord }));
+
+    session.abort();
+  }
+
+  public void testFetchSince() throws NoContentProviderException, RemoteException {
+    final TabsRecord tabsRecord = insertTestTabsAndExtractTabsRecord();
+
+    final FennecTabsRepositorySession session = createAndBeginSession();
+
+    // Not all tabs are modified after this, but the record should contain them all.
+    performWait(fetchSinceRunnable(session, 1000, new Record[] { tabsRecord }));
+
+    // No tabs are modified after this, but our client name has changed in the interim.
+    performWait(fetchSinceRunnable(session, 4000, new Record[] { tabsRecord }));
+
+    // No tabs are modified after this, and our client name hasn't changed, so
+    // we shouldn't get a record at all. Note: this runs after our static
+    // initializer that sets the client data timestamp.
+    final long now = System.currentTimeMillis();
+    performWait(fetchSinceRunnable(session, now, new Record[] { }));
+
+    // No tabs are modified after this, but our client name has changed, so
+    // again we get a record.
+    clientsDataDelegate.setClientName("new client name", System.currentTimeMillis());
+    performWait(fetchSinceRunnable(session, now, new Record[] { tabsRecord }));
+
+    session.abort();
+  }
+
+  // Verify that storing a tabs record writes a clients record with the correct
+  // device type to the Fennec clients provider.
+  public void testStore() throws NoContentProviderException, RemoteException {
+    // Get a valid tabsRecord to write.
+    final TabsRecord tabsRecord = insertTestTabsAndExtractTabsRecord();
+    deleteAllTestTabs(tabsClient);
+    deleteTestClient(clientsClient);
+
+    final ContentResolver cr = getApplicationContext().getContentResolver();
+    final ContentProviderClient clientsClient = cr.acquireContentProviderClient(BrowserContractHelpers.CLIENTS_CONTENT_URI);
+
+    try {
+      // This clients DB is not the Fennec DB; it's Sync's own clients DB.
+      final ClientsDatabaseAccessor db = new ClientsDatabaseAccessor(getApplicationContext());
+      try {
+        ClientRecord clientRecord = new ClientRecord(TEST_CLIENT_GUID);
+        clientRecord.name = TEST_CLIENT_NAME;
+        clientRecord.type = TEST_CLIENT_DEVICE_TYPE;
+        db.store(clientRecord);
+      } finally {
+        db.close();
+      }
+
+      final FennecTabsRepositorySession session = createAndBeginSession();
+      performWait(AndroidBrowserRepositoryTestCase.storeRunnable(session, tabsRecord));
+
+      session.abort();
+
+      // This store should write Sync's idea of the client's device_type to Fennec's clients CP.
+      final Cursor cursor = clientsClient.query(BrowserContractHelpers.CLIENTS_CONTENT_URI, null,
+          TEST_CLIENTS_GUID_IS_LOCAL_SELECTION, TEST_CLIENTS_GUID_IS_LOCAL_SELECTION_ARGS, null);
+      assertNotNull(cursor);
+
+      try {
+        assertTrue(cursor.moveToFirst());
+        assertEquals(TEST_CLIENT_GUID, cursor.getString(cursor.getColumnIndex(Clients.GUID)));
+        assertEquals(TEST_CLIENT_NAME, cursor.getString(cursor.getColumnIndex(Clients.NAME)));
+        assertEquals(TEST_CLIENT_DEVICE_TYPE, cursor.getString(cursor.getColumnIndex(Clients.DEVICE_TYPE)));
+        assertTrue(cursor.isLast());
+      } finally {
+        cursor.close();
+      }
+    } finally {
+      // We can't delete only our test client due to a Fennec CP issue with guid vs. client_guid.
+      clientsClient.delete(BrowserContractHelpers.CLIENTS_CONTENT_URI, null, null);
+      clientsClient.release();
+    }
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestFormHistoryRepositorySession.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestFormHistoryRepositorySession.java
new file mode 100644
index 000000000..5d5014b75
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestFormHistoryRepositorySession.java
@@ -0,0 +1,441 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.db;
+
+import java.util.concurrent.ExecutorService;
+
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.background.sync.helpers.ExpectFetchDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectFetchSinceDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectGuidsSinceDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectNoStoreDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectStoredDelegate;
+import org.mozilla.gecko.background.sync.helpers.SessionTestHelper;
+import org.mozilla.gecko.background.testhelpers.WaitHelper;
+import org.mozilla.gecko.db.BrowserContract;
+import org.mozilla.gecko.sync.repositories.InactiveSessionException;
+import org.mozilla.gecko.sync.repositories.NoContentProviderException;
+import org.mozilla.gecko.sync.repositories.NoStoreDelegateException;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.android.BrowserContractHelpers;
+import org.mozilla.gecko.sync.repositories.android.FormHistoryRepositorySession;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionStoreDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionWipeDelegate;
+import org.mozilla.gecko.sync.repositories.domain.FormHistoryRecord;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+import android.content.ContentProviderClient;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.RemoteException;
+
+public class TestFormHistoryRepositorySession extends AndroidSyncTestCase {
+  protected ContentProviderClient formsProvider = null;
+
+  public TestFormHistoryRepositorySession() throws NoContentProviderException {
+    super();
+  }
+
+  public void setUp() {
+    if (formsProvider == null) {
+      try {
+        formsProvider = FormHistoryRepositorySession.acquireContentProvider(getApplicationContext());
+      } catch (NoContentProviderException e) {
+        fail("Failed to acquireContentProvider: " + e);
+      }
+    }
+
+    try {
+      FormHistoryRepositorySession.purgeDatabases(formsProvider);
+    } catch (RemoteException e) {
+      fail("Failed to purgeDatabases: " + e);
+    }
+  }
+
+  public void tearDown() {
+    if (formsProvider != null) {
+      formsProvider.release();
+      formsProvider = null;
+    }
+  }
+
+  protected FormHistoryRepositorySession.FormHistoryRepository getRepository() {
+    /**
+     * Override this chain in order to avoid our test code having to create two
+     * sessions all the time.
+     */
+    return new FormHistoryRepositorySession.FormHistoryRepository() {
+      @Override
+      public void createSession(RepositorySessionCreationDelegate delegate,
+                                Context context) {
+        try {
+          final FormHistoryRepositorySession session = new FormHistoryRepositorySession(this, context) {
+            @Override
+            protected synchronized void trackGUID(String guid) {
+            }
+          };
+          delegate.onSessionCreated(session);
+        } catch (Exception e) {
+          delegate.onSessionCreateFailed(e);
+        }
+      }
+    };
+  }
+
+
+  protected FormHistoryRepositorySession createSession() {
+    return (FormHistoryRepositorySession) SessionTestHelper.createSession(
+        getApplicationContext(),
+        getRepository());
+  }
+
+  protected FormHistoryRepositorySession createAndBeginSession() {
+    return (FormHistoryRepositorySession) SessionTestHelper.createAndBeginSession(
+        getApplicationContext(),
+        getRepository());
+  }
+
+  public void testAcquire() throws NoContentProviderException {
+    final FormHistoryRepositorySession session = createAndBeginSession();
+    assertNotNull(session.getFormsProvider());
+    session.abort();
+  }
+
+  protected int numRecords(FormHistoryRepositorySession session, Uri uri) throws RemoteException {
+    Cursor cur = null;
+    try {
+      cur = session.getFormsProvider().query(uri, null, null, null, null);
+      return cur.getCount();
+    } finally {
+      if (cur != null) {
+        cur.close();
+      }
+    }
+  }
+
+  protected long after0;
+  protected long after1;
+  protected long after2;
+  protected long after3;
+  protected long after4;
+  protected FormHistoryRecord regular1;
+  protected FormHistoryRecord regular2;
+  protected FormHistoryRecord deleted1;
+  protected FormHistoryRecord deleted2;
+
+  public void insertTwoRecords(FormHistoryRepositorySession session) throws RemoteException {
+    Uri regularUri = BrowserContractHelpers.FORM_HISTORY_CONTENT_URI;
+    Uri deletedUri = BrowserContractHelpers.DELETED_FORM_HISTORY_CONTENT_URI;
+    after0 = System.currentTimeMillis();
+
+    regular1 = new FormHistoryRecord("guid1", "forms", System.currentTimeMillis(), false);
+    regular1.fieldName = "fieldName1";
+    regular1.fieldValue = "value1";
+    final ContentValues cv1 = new ContentValues();
+    cv1.put(BrowserContract.FormHistory.GUID, regular1.guid);
+    cv1.put(BrowserContract.FormHistory.FIELD_NAME, regular1.fieldName);
+    cv1.put(BrowserContract.FormHistory.VALUE, regular1.fieldValue);
+    cv1.put(BrowserContract.FormHistory.FIRST_USED, 1000 * regular1.lastModified); // Microseconds.
+
+    int regularInserted = session.getFormsProvider().bulkInsert(regularUri, new ContentValues[] { cv1 });
+    assertEquals(1, regularInserted);
+    after1 = System.currentTimeMillis();
+
+    deleted1 = new FormHistoryRecord("guid3", "forms", -1, true);
+    final ContentValues cv3 = new ContentValues();
+    cv3.put(BrowserContract.FormHistory.GUID, deleted1.guid);
+    // cv3.put(BrowserContract.DeletedFormHistory.TIME_DELETED, record3.lastModified); // Set by CP.
+
+    int deletedInserted = session.getFormsProvider().bulkInsert(deletedUri, new ContentValues[] { cv3 });
+    assertEquals(1, deletedInserted);
+    after2 = System.currentTimeMillis();
+
+    regular2 = null;
+    deleted2 = null;
+  }
+
+  public void insertFourRecords(FormHistoryRepositorySession session) throws RemoteException {
+    Uri regularUri = BrowserContractHelpers.FORM_HISTORY_CONTENT_URI;
+    Uri deletedUri = BrowserContractHelpers.DELETED_FORM_HISTORY_CONTENT_URI;
+
+    insertTwoRecords(session);
+
+    regular2 = new FormHistoryRecord("guid2", "forms", System.currentTimeMillis(), false);
+    regular2.fieldName = "fieldName2";
+    regular2.fieldValue = "value2";
+    final ContentValues cv2 = new ContentValues();
+    cv2.put(BrowserContract.FormHistory.GUID, regular2.guid);
+    cv2.put(BrowserContract.FormHistory.FIELD_NAME, regular2.fieldName);
+    cv2.put(BrowserContract.FormHistory.VALUE, regular2.fieldValue);
+    cv2.put(BrowserContract.FormHistory.FIRST_USED, 1000 * regular2.lastModified); // Microseconds.
+
+    int regularInserted = session.getFormsProvider().bulkInsert(regularUri, new ContentValues[] { cv2 });
+    assertEquals(1, regularInserted);
+    after3 = System.currentTimeMillis();
+
+    deleted2 = new FormHistoryRecord("guid4", "forms", -1, true);
+    final ContentValues cv4 = new ContentValues();
+    cv4.put(BrowserContract.FormHistory.GUID, deleted2.guid);
+    // cv4.put(BrowserContract.DeletedFormHistory.TIME_DELETED, record4.lastModified); // Set by CP.
+
+    int deletedInserted = session.getFormsProvider().bulkInsert(deletedUri, new ContentValues[] { cv4 });
+    assertEquals(1, deletedInserted);
+    after4 = System.currentTimeMillis();
+  }
+
+  public void testWipe() throws NoContentProviderException, RemoteException {
+    final FormHistoryRepositorySession session = createAndBeginSession();
+
+    insertTwoRecords(session);
+    assertTrue(numRecords(session, BrowserContractHelpers.FORM_HISTORY_CONTENT_URI) > 0);
+    assertTrue(numRecords(session, BrowserContractHelpers.DELETED_FORM_HISTORY_CONTENT_URI) > 0);
+
+    performWait(WaitHelper.onThreadRunnable(new Runnable() {
+      @Override
+      public void run() {
+        session.wipe(new RepositorySessionWipeDelegate() {
+          public void onWipeSucceeded() {
+            performNotify();
+          }
+          public void onWipeFailed(Exception ex) {
+            performNotify("Wipe should have succeeded", ex);
+          }
+          @Override
+          public RepositorySessionWipeDelegate deferredWipeDelegate(final ExecutorService executor) {
+            return this;
+          }
+        });
+      }
+    }));
+
+    assertEquals(0, numRecords(session, BrowserContractHelpers.FORM_HISTORY_CONTENT_URI));
+    assertEquals(0, numRecords(session, BrowserContractHelpers.DELETED_FORM_HISTORY_CONTENT_URI));
+
+    session.abort();
+  }
+
+  protected Runnable fetchSinceRunnable(final RepositorySession session, final long timestamp, final String[] expectedGuids) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.fetchSince(timestamp, new ExpectFetchSinceDelegate(timestamp, expectedGuids));
+      }
+    };
+  }
+
+  protected Runnable fetchAllRunnable(final RepositorySession session, final Record[] expectedRecords) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.fetchAll(new ExpectFetchDelegate(expectedRecords));
+      }
+    };
+  }
+
+  protected Runnable fetchRunnable(final RepositorySession session, final String[] guids, final Record[] expectedRecords) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        try {
+          session.fetch(guids, new ExpectFetchDelegate(expectedRecords));
+        } catch (InactiveSessionException e) {
+          performNotify(e);
+        }
+      }
+    };
+  }
+
+  public void testFetchAll() throws NoContentProviderException, RemoteException {
+    final FormHistoryRepositorySession session = createAndBeginSession();
+
+    insertTwoRecords(session);
+
+    performWait(fetchAllRunnable(session, new Record[] { regular1, deleted1 }));
+
+    session.abort();
+  }
+
+  public void testFetchByGuid() throws NoContentProviderException, RemoteException {
+    final FormHistoryRepositorySession session = createAndBeginSession();
+
+    insertTwoRecords(session);
+
+    performWait(fetchRunnable(session,
+        new String[] { regular1.guid, deleted1.guid },
+        new Record[] { regular1, deleted1 }));
+    performWait(fetchRunnable(session,
+        new String[] { regular1.guid },
+        new Record[] { regular1 }));
+    performWait(fetchRunnable(session,
+        new String[] { deleted1.guid, "NON_EXISTENT_GUID?" },
+        new Record[] { deleted1 }));
+    performWait(fetchRunnable(session,
+        new String[] { "FIRST_NON_EXISTENT_GUID", "SECOND_NON_EXISTENT_GUID?" },
+        new Record[] { }));
+
+    session.abort();
+  }
+
+  public void testFetchSince() throws NoContentProviderException, RemoteException {
+    final FormHistoryRepositorySession session = createAndBeginSession();
+
+    insertFourRecords(session);
+
+    performWait(fetchSinceRunnable(session,
+        after0, new String[] { regular1.guid, deleted1.guid, regular2.guid, deleted2.guid }));
+    performWait(fetchSinceRunnable(session,
+        after1, new String[] { deleted1.guid, regular2.guid, deleted2.guid }));
+    performWait(fetchSinceRunnable(session,
+        after2, new String[] { regular2.guid, deleted2.guid }));
+    performWait(fetchSinceRunnable(session,
+        after3, new String[] { deleted2.guid }));
+    performWait(fetchSinceRunnable(session,
+        after4, new String[] { }));
+
+    session.abort();
+  }
+
+  protected Runnable guidsSinceRunnable(final RepositorySession session, final long timestamp, final String[] expectedGuids) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.guidsSince(timestamp, new ExpectGuidsSinceDelegate(expectedGuids));
+      }
+    };
+  }
+
+  public void testGuidsSince() throws NoContentProviderException, RemoteException {
+    final FormHistoryRepositorySession session = createAndBeginSession();
+
+    insertTwoRecords(session);
+
+    performWait(guidsSinceRunnable(session,
+        after0, new String[] { regular1.guid, deleted1.guid }));
+    performWait(guidsSinceRunnable(session,
+        after1, new String[] { deleted1.guid}));
+    performWait(guidsSinceRunnable(session,
+        after2, new String[] { }));
+
+    session.abort();
+  }
+
+  protected Runnable storeRunnable(final RepositorySession session, final Record record, final RepositorySessionStoreDelegate delegate) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.setStoreDelegate(delegate);
+        try {
+          session.store(record);
+          session.storeDone();
+        } catch (NoStoreDelegateException e) {
+          performNotify("NoStoreDelegateException should not occur.", e);
+        }
+      }
+    };
+  }
+
+  public void testStoreRemoteNew() throws NoContentProviderException, RemoteException {
+    final FormHistoryRepositorySession session = createAndBeginSession();
+
+    insertTwoRecords(session);
+
+    FormHistoryRecord rec;
+
+    // remote regular, local missing => should store.
+    rec = new FormHistoryRecord("new1", "forms", System.currentTimeMillis(), false);
+    rec.fieldName  = "fieldName1";
+    rec.fieldValue = "fieldValue1";
+    performWait(storeRunnable(session, rec, new ExpectStoredDelegate(rec.guid)));
+    performWait(fetchRunnable(session, new String[] { rec.guid }, new Record[] { rec }));
+
+    // remote deleted, local missing => should delete, but at the moment we ignore.
+    rec = new FormHistoryRecord("new2", "forms", System.currentTimeMillis(), true);
+    performWait(storeRunnable(session, rec, new ExpectNoStoreDelegate()));
+    performWait(fetchRunnable(session, new String[] { rec.guid }, new Record[] { }));
+
+    session.abort();
+  }
+
+  public void testStoreRemoteNewer() throws NoContentProviderException, RemoteException {
+    final FormHistoryRepositorySession session = createAndBeginSession();
+
+    insertFourRecords(session);
+    long newTimestamp = System.currentTimeMillis();
+
+    FormHistoryRecord rec;
+
+    // remote regular, local regular, remote newer => should update.
+    rec = new FormHistoryRecord(regular1.guid, regular1.collection, newTimestamp, false);
+    rec.fieldName  = regular1.fieldName;
+    rec.fieldValue = regular1.fieldValue + "NEW";
+    performWait(storeRunnable(session, rec, new ExpectStoredDelegate(rec.guid)));
+    performWait(fetchRunnable(session, new String[] { regular1.guid }, new Record[] { rec }));
+
+    // remote deleted, local regular, remote newer => should delete everything.
+    rec = new FormHistoryRecord(regular2.guid, regular2.collection, newTimestamp, true);
+    performWait(storeRunnable(session, rec, new ExpectStoredDelegate(rec.guid)));
+    performWait(fetchRunnable(session, new String[] { regular2.guid }, new Record[] { }));
+
+    // remote regular, local deleted, remote newer => should update.
+    rec = new FormHistoryRecord(deleted1.guid, deleted1.collection, newTimestamp, false);
+    rec.fieldName  = regular1.fieldName;
+    rec.fieldValue = regular1.fieldValue + "NEW";
+    performWait(storeRunnable(session, rec, new ExpectStoredDelegate(rec.guid)));
+    performWait(fetchRunnable(session, new String[] { deleted1.guid }, new Record[] { rec }));
+
+    // remote deleted, local deleted, remote newer => should delete everything.
+    rec = new FormHistoryRecord(deleted2.guid, deleted2.collection, newTimestamp, true);
+    performWait(storeRunnable(session, rec, new ExpectNoStoreDelegate()));
+    performWait(fetchRunnable(session, new String[] { deleted2.guid }, new Record[] { }));
+
+    session.abort();
+  }
+
+  public void testStoreRemoteOlder() throws NoContentProviderException, RemoteException {
+    final FormHistoryRepositorySession session = createAndBeginSession();
+
+    long oldTimestamp = System.currentTimeMillis() - 100;
+    insertFourRecords(session);
+
+    FormHistoryRecord rec;
+
+    // remote regular, local regular, remote older => should ignore.
+    rec = new FormHistoryRecord(regular1.guid, regular1.collection, oldTimestamp, false);
+    rec.fieldName  = regular1.fieldName;
+    rec.fieldValue = regular1.fieldValue + "NEW";
+    performWait(storeRunnable(session, rec, new ExpectNoStoreDelegate()));
+
+    // remote deleted, local regular, remote older => should ignore.
+    rec = new FormHistoryRecord(regular2.guid, regular2.collection, oldTimestamp, true);
+    performWait(storeRunnable(session, rec, new ExpectNoStoreDelegate()));
+
+    // remote regular, local deleted, remote older => should ignore.
+    rec = new FormHistoryRecord(deleted1.guid, deleted1.collection, oldTimestamp, false);
+    rec.fieldName  = regular1.fieldName;
+    rec.fieldValue = regular1.fieldValue + "NEW";
+    performWait(storeRunnable(session, rec, new ExpectNoStoreDelegate()));
+
+    // remote deleted, local deleted, remote older => should ignore.
+    rec = new FormHistoryRecord(deleted2.guid, deleted2.collection, oldTimestamp, true);
+    performWait(storeRunnable(session, rec, new ExpectNoStoreDelegate()));
+
+    session.abort();
+  }
+
+  public void testStoreDifferentGuid() throws NoContentProviderException, RemoteException {
+    final FormHistoryRepositorySession session = createAndBeginSession();
+
+    insertTwoRecords(session);
+
+    FormHistoryRecord rec = (FormHistoryRecord) regular1.copyWithIDs("distinct", 999);
+    performWait(storeRunnable(session, rec, new ExpectStoredDelegate(rec.guid)));
+    // Existing record should take remote record's GUID.
+    performWait(fetchAllRunnable(session, new Record[] { rec, deleted1 }));
+
+    session.abort();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestPasswordsRepository.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestPasswordsRepository.java
new file mode 100644
index 000000000..210c8ca8c
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestPasswordsRepository.java
@@ -0,0 +1,482 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.db;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.background.sync.helpers.ExpectFetchDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectFetchSinceDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectGuidsSinceDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectNoStoreDelegate;
+import org.mozilla.gecko.background.sync.helpers.ExpectStoredDelegate;
+import org.mozilla.gecko.background.sync.helpers.PasswordHelpers;
+import org.mozilla.gecko.background.sync.helpers.SessionTestHelper;
+import org.mozilla.gecko.background.testhelpers.WaitHelper;
+import org.mozilla.gecko.db.BrowserContract;
+import org.mozilla.gecko.sync.Utils;
+import org.mozilla.gecko.sync.repositories.InactiveSessionException;
+import org.mozilla.gecko.sync.repositories.NoStoreDelegateException;
+import org.mozilla.gecko.sync.repositories.Repository;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.android.BrowserContractHelpers;
+import org.mozilla.gecko.sync.repositories.android.PasswordsRepositorySession;
+import org.mozilla.gecko.sync.repositories.android.RepoUtils;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionStoreDelegate;
+import org.mozilla.gecko.sync.repositories.domain.PasswordRecord;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+import android.content.ContentProviderClient;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.os.RemoteException;
+
+public class TestPasswordsRepository extends AndroidSyncTestCase {
+  private final String NEW_PASSWORD1 = "password";
+  private final String NEW_PASSWORD2 = "drowssap";
+
+  @Override
+  public void setUp() {
+    wipe();
+    assertTrue(WaitHelper.getTestWaiter().isIdle());
+  }
+
+  public void testFetchAll() {
+    RepositorySession session = createAndBeginSession();
+    Record[] expected = new Record[] { PasswordHelpers.createPassword1(),
+                                       PasswordHelpers.createPassword2() };
+
+    performWait(storeRunnable(session, expected[0]));
+    performWait(storeRunnable(session, expected[1]));
+
+    performWait(fetchAllRunnable(session, expected));
+    dispose(session);
+  }
+
+  public void testGuidsSinceReturnMultipleRecords() {
+    RepositorySession session = createAndBeginSession();
+
+    PasswordRecord record1 = PasswordHelpers.createPassword1();
+    PasswordRecord record2 = PasswordHelpers.createPassword2();
+
+    updatePassword(NEW_PASSWORD1, record1);
+    long timestamp = updatePassword(NEW_PASSWORD2, record2);
+
+    String[] expected = new String[] { record1.guid, record2.guid };
+
+    performWait(storeRunnable(session, record1));
+    performWait(storeRunnable(session, record2));
+
+    performWait(guidsSinceRunnable(session, timestamp, expected));
+    dispose(session);
+  }
+
+  public void testGuidsSinceReturnNoRecords() {
+    RepositorySession session = createAndBeginSession();
+
+    //  Store 1 record in the past.
+    performWait(storeRunnable(session, PasswordHelpers.createPassword1()));
+
+    String[] expected = {};
+    performWait(guidsSinceRunnable(session, System.currentTimeMillis() + 1000, expected));
+    dispose(session);
+  }
+
+  public void testFetchSinceOneRecord() {
+    RepositorySession session = createAndBeginSession();
+
+    // Passwords fetchSince checks timePasswordChanged, not insertion time.
+    PasswordRecord record1 = PasswordHelpers.createPassword1();
+    long timeModified1 = updatePassword(NEW_PASSWORD1, record1);
+    performWait(storeRunnable(session, record1));
+
+    PasswordRecord record2 = PasswordHelpers.createPassword2();
+    long timeModified2 = updatePassword(NEW_PASSWORD2, record2);
+    performWait(storeRunnable(session, record2));
+
+    String[] expectedOne = new String[] { record2.guid };
+    performWait(fetchSinceRunnable(session, timeModified2 - 10, expectedOne));
+
+    String[] expectedBoth = new String[] { record1.guid, record2.guid };
+    performWait(fetchSinceRunnable(session, timeModified1 - 10, expectedBoth));
+
+    dispose(session);
+  }
+
+  public void testFetchSinceReturnNoRecords() {
+   RepositorySession session = createAndBeginSession();
+
+    performWait(storeRunnable(session, PasswordHelpers.createPassword2()));
+
+    long timestamp = System.currentTimeMillis();
+
+    performWait(fetchSinceRunnable(session, timestamp + 2000, new String[] {}));
+    dispose(session);
+  }
+
+  public void testFetchOneRecordByGuid() {
+    RepositorySession session = createAndBeginSession();
+    Record record = PasswordHelpers.createPassword1();
+    performWait(storeRunnable(session, record));
+    performWait(storeRunnable(session, PasswordHelpers.createPassword2()));
+
+    String[] guids = new String[] { record.guid };
+    Record[] expected = new Record[] { record };
+    performWait(fetchRunnable(session, guids, expected));
+    dispose(session);
+  }
+
+  public void testFetchMultipleRecordsByGuids() {
+    RepositorySession session = createAndBeginSession();
+    PasswordRecord record1 = PasswordHelpers.createPassword1();
+    PasswordRecord record2 = PasswordHelpers.createPassword2();
+    PasswordRecord record3 = PasswordHelpers.createPassword3();
+
+    performWait(storeRunnable(session, record1));
+    performWait(storeRunnable(session, record2));
+    performWait(storeRunnable(session, record3));
+
+    String[] guids = new String[] { record1.guid, record2.guid };
+    Record[] expected = new Record[] { record1, record2 };
+    performWait(fetchRunnable(session, guids, expected));
+    dispose(session);
+  }
+
+  public void testFetchNoRecordByGuid() {
+    RepositorySession session = createAndBeginSession();
+    Record record = PasswordHelpers.createPassword1();
+
+    performWait(storeRunnable(session, record));
+    performWait(fetchRunnable(session,
+                              new String[] { Utils.generateGuid() },
+                              new Record[] {}));
+    dispose(session);
+  }
+
+  public void testStore() {
+    final RepositorySession session = createAndBeginSession();
+    performWait(storeRunnable(session, PasswordHelpers.createPassword1()));
+    dispose(session);
+  }
+
+  public void testRemoteNewerTimeStamp() {
+    final RepositorySession session = createAndBeginSession();
+
+    // Store updated local record.
+    PasswordRecord local = PasswordHelpers.createPassword1();
+    updatePassword(NEW_PASSWORD1, local, System.currentTimeMillis() - 1000);
+    performWait(storeRunnable(session, local));
+
+    // Sync a remote record version that is newer.
+    PasswordRecord remote = PasswordHelpers.createPassword2();
+    remote.guid = local.guid;
+    updatePassword(NEW_PASSWORD2, remote);
+    performWait(storeRunnable(session, remote));
+
+    // Make a fetch, expecting only the newer (remote) record.
+    performWait(fetchAllRunnable(session, new Record[] { remote }));
+
+    // Store an older local record.
+    PasswordRecord local2 = PasswordHelpers.createPassword3();
+    updatePassword(NEW_PASSWORD2, local2, System.currentTimeMillis() - 1000);
+    performWait(storeRunnable(session, local2));
+
+    // Sync a remote record version that is newer and is deleted.
+    PasswordRecord remote2 = PasswordHelpers.createPassword3();
+    remote2.guid = local2.guid;
+    remote2.deleted = true;
+    updatePassword(NEW_PASSWORD2, remote2);
+    performWait(storeRunnable(session, remote2));
+
+    // Make a fetch, expecting the local record to be deleted.
+    performWait(fetchRunnable(session, new String[] { remote2.guid }, new Record[] {}));
+
+    // Store an older deleted local record.
+    PasswordRecord local3 = PasswordHelpers.createPassword4();
+    updatePassword(NEW_PASSWORD2, local3, System.currentTimeMillis() - 1000);
+    local3.deleted = true;
+    storeLocalDeletedRecord(local3, System.currentTimeMillis() - 1000);
+
+    // Sync a remote record version that is newer and is deleted.
+    PasswordRecord remote3 = PasswordHelpers.createPassword5();
+    remote3.guid = local3.guid;
+    remote3.deleted = true;
+    updatePassword(NEW_PASSWORD2, remote3);
+    performWait(storeRunnable(session, remote3));
+
+    // Make a fetch, expecting the local record to be deleted.
+    performWait(fetchRunnable(session, new String[] { remote3.guid }, new Record[] {}));
+    dispose(session);
+  }
+
+  public void testLocalNewerTimeStamp() {
+    final RepositorySession session = createAndBeginSession();
+    // Remote record updated before local record.
+    PasswordRecord remote = PasswordHelpers.createPassword1();
+    updatePassword(NEW_PASSWORD1, remote, System.currentTimeMillis() - 1000);
+
+    // Store updated local record.
+    PasswordRecord local = PasswordHelpers.createPassword2();
+    updatePassword(NEW_PASSWORD2, local);
+    performWait(storeRunnable(session, local));
+
+    // Sync a remote record version that is older.
+    remote.guid = local.guid;
+    performWait(storeRunnable(session, remote));
+
+    // Make a fetch, expecting only the newer (local) record.
+    performWait(fetchAllRunnable(session, new Record[] { local }));
+
+    // Remote record updated before local record.
+    PasswordRecord remote2 = PasswordHelpers.createPassword3();
+    updatePassword(NEW_PASSWORD1, remote2, System.currentTimeMillis() - 1000);
+
+    // Store updated local record that is deleted.
+    PasswordRecord local2 = PasswordHelpers.createPassword3();
+    updatePassword(NEW_PASSWORD2, local2);
+    local2.deleted = true;
+    storeLocalDeletedRecord(local2, System.currentTimeMillis());
+
+    // Sync a remote record version that is older.
+    remote2.guid = local2.guid;
+    performWait(storeRunnable(session, remote2, new ExpectNoStoreDelegate()));
+
+    // Make a fetch, expecting only the deleted newer (local) record.
+    performWait(fetchRunnable(session, new String[] { local2.guid }, new Record[] { local2 }));
+
+    // Remote record updated before local record.
+    PasswordRecord remote3 = PasswordHelpers.createPassword4();
+    updatePassword(NEW_PASSWORD1, remote3, System.currentTimeMillis() - 1000);
+
+    // Store updated local record that is deleted.
+    PasswordRecord local3 = PasswordHelpers.createPassword4();
+    updatePassword(NEW_PASSWORD2, local3);
+    local3.deleted = true;
+    storeLocalDeletedRecord(local3, System.currentTimeMillis());
+
+    // Sync a remote record version that is older and is deleted.
+    remote3.guid = local3.guid;
+    remote3.deleted = true;
+    performWait(storeRunnable(session, remote3));
+
+    // Make a fetch, expecting the local record to be deleted.
+    performWait(fetchRunnable(session, new String[] { local3.guid }, new Record[] {}));
+    dispose(session);
+  }
+
+  /*
+   * Store two records that are identical except for guid. Expect to find the
+   * remote one after reconciling.
+   */
+  public void testStoreIdenticalExceptGuid() {
+    RepositorySession session = createAndBeginSession();
+    PasswordRecord record = PasswordHelpers.createPassword1();
+    record.guid = "before1";
+    // Store record.
+    performWait(storeRunnable(session, record));
+
+    // Store same record, but with different guid.
+    record.guid = Utils.generateGuid();
+    performWait(storeRunnable(session, record));
+
+    performWait(fetchAllRunnable(session, new Record[] { record }));
+    dispose(session);
+
+    session = createAndBeginSession();
+
+    PasswordRecord record2 = PasswordHelpers.createPassword2();
+    record2.guid = "before2";
+    // Store record.
+    performWait(storeRunnable(session, record2));
+
+    // Store same record, but with different guid.
+    record2.guid = Utils.generateGuid();
+    performWait(storeRunnable(session, record2));
+
+    performWait(fetchAllRunnable(session, new Record[] { record, record2 }));
+    dispose(session);
+  }
+
+  /*
+   * Store two records that are identical except for guid when they both point
+   * to the same site and there are multiple records for that site. Expect to
+   * find the remote one after reconciling.
+   */
+  public void testStoreIdenticalExceptGuidOnSameSite() {
+    RepositorySession session = createAndBeginSession();
+    PasswordRecord record1 = PasswordHelpers.createPassword1();
+    record1.encryptedUsername = "original";
+    record1.guid = "before1";
+    PasswordRecord record2 = PasswordHelpers.createPassword1();
+    record2.encryptedUsername = "different";
+    record1.guid = "before2";
+    // Store records.
+    performWait(storeRunnable(session, record1));
+    performWait(storeRunnable(session, record2));
+    performWait(fetchAllRunnable(session, new Record[] { record1, record2 }));
+
+    dispose(session);
+    session = createAndBeginSession();
+
+    // Store same records, but with different guids.
+    record1.guid = Utils.generateGuid();
+    performWait(storeRunnable(session, record1));
+    performWait(fetchAllRunnable(session, new Record[] { record1, record2 }));
+
+    record2.guid = Utils.generateGuid();
+    performWait(storeRunnable(session, record2));
+    performWait(fetchAllRunnable(session, new Record[] { record1, record2 }));
+
+    dispose(session);
+  }
+
+  public void testRawFetch() throws RemoteException {
+    RepositorySession session = createAndBeginSession();
+    Record[] expected = new Record[] { PasswordHelpers.createPassword1(),
+                                       PasswordHelpers.createPassword2() };
+
+    performWait(storeRunnable(session, expected[0]));
+    performWait(storeRunnable(session, expected[1]));
+
+    ContentProviderClient client = getApplicationContext().getContentResolver().acquireContentProviderClient(BrowserContract.PASSWORDS_AUTHORITY_URI);
+    Cursor cursor = client.query(BrowserContractHelpers.PASSWORDS_CONTENT_URI, null, null, null, null);
+    assertEquals(2, cursor.getCount());
+    cursor.moveToFirst();
+    Set<String> guids = new HashSet<String>();
+    while (!cursor.isAfterLast()) {
+      String guid = RepoUtils.getStringFromCursor(cursor, BrowserContract.Passwords.GUID);
+      guids.add(guid);
+      cursor.moveToNext();
+    }
+    cursor.close();
+    assertEquals(2, guids.size());
+    assertTrue(guids.contains(expected[0].guid));
+    assertTrue(guids.contains(expected[1].guid));
+    dispose(session);
+  }
+
+  // Helper methods.
+  private RepositorySession createAndBeginSession() {
+    return SessionTestHelper.createAndBeginSession(
+        getApplicationContext(),
+        getRepository());
+  }
+
+  private Repository getRepository() {
+    /**
+     * Override this chain in order to avoid our test code having to create two
+     * sessions all the time. Don't track records, so they filtering doesn't happen.
+     */
+    return new PasswordsRepositorySession.PasswordsRepository() {
+      @Override
+      public void createSession(RepositorySessionCreationDelegate delegate,
+          Context context) {
+        PasswordsRepositorySession session;
+        session = new PasswordsRepositorySession(this, context) {
+          @Override
+          protected synchronized void trackGUID(String guid) {
+          }
+        };
+        delegate.onSessionCreated(session);
+      }
+    };
+  }
+
+  private void wipe() {
+    Context context = getApplicationContext();
+    context.getContentResolver().delete(BrowserContractHelpers.PASSWORDS_CONTENT_URI, null, null);
+    context.getContentResolver().delete(BrowserContractHelpers.DELETED_PASSWORDS_CONTENT_URI, null, null);
+  }
+
+  private void storeLocalDeletedRecord(Record record, long time) {
+    // Wipe data-store
+    wipe();
+    // Store record in deleted table.
+    ContentValues contentValues = new ContentValues();
+    contentValues.put(BrowserContract.DeletedColumns.GUID, record.guid);
+    contentValues.put(BrowserContract.DeletedColumns.TIME_DELETED, time);
+    contentValues.put(BrowserContract.DeletedColumns.ID, record.androidID);
+    getApplicationContext().getContentResolver().insert(BrowserContractHelpers.DELETED_PASSWORDS_CONTENT_URI, contentValues);
+  }
+
+  private static void dispose(RepositorySession session) {
+    if (session != null) {
+      session.abort();
+    }
+  }
+
+  private static long updatePassword(String password, PasswordRecord record, long timestamp) {
+    record.encryptedPassword = password;
+    long modifiedTime = System.currentTimeMillis();
+    record.timePasswordChanged = record.lastModified = modifiedTime;
+    return modifiedTime;
+  }
+
+  private static long updatePassword(String password, PasswordRecord record) {
+    return updatePassword(password, record, System.currentTimeMillis());
+  }
+
+  // Runnable Helpers.
+  private static Runnable storeRunnable(final RepositorySession session, final Record record) {
+    return storeRunnable(session, record, new ExpectStoredDelegate(record.guid));
+  }
+
+  private static Runnable storeRunnable(final RepositorySession session, final Record record, final RepositorySessionStoreDelegate delegate) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.setStoreDelegate(delegate);
+        try {
+          session.store(record);
+          session.storeDone();
+        } catch (NoStoreDelegateException e) {
+          fail("NoStoreDelegateException should not occur.");
+        }
+      }
+    };
+  }
+
+  private static Runnable fetchAllRunnable(final RepositorySession session, final Record[] records) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.fetchAll(new ExpectFetchDelegate(records));
+      }
+    };
+  }
+
+  private static Runnable guidsSinceRunnable(final RepositorySession session, final long timestamp, final String[] expected) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.guidsSince(timestamp, new ExpectGuidsSinceDelegate(expected));
+      }
+    };
+  }
+
+  private static Runnable fetchSinceRunnable(final RepositorySession session, final long timestamp, final String[] expected) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        session.fetchSince(timestamp, new ExpectFetchSinceDelegate(timestamp, expected));
+      }
+    };
+  }
+
+  private static Runnable fetchRunnable(final RepositorySession session, final String[] guids, final Record[] expected) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        try {
+          session.fetch(guids, new ExpectFetchDelegate(expected));
+        } catch (InactiveSessionException e) {
+          performNotify(e);
+        }
+      }
+    };
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestTopSites.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestTopSites.java
new file mode 100644
index 000000000..003fc7172
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/db/TestTopSites.java
@@ -0,0 +1,92 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.db;
+
+
+import org.mozilla.gecko.GeckoProfile;
+import org.mozilla.gecko.db.BrowserContract;
+import org.mozilla.gecko.db.BrowserDB;
+import org.mozilla.gecko.db.BrowserContract.Combined;
+import org.mozilla.gecko.db.SuggestedSites;
+import org.mozilla.gecko.sync.setup.Constants;
+
+import android.app.Activity;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.test.ActivityInstrumentationTestCase2;
+
+/**
+ * Exercise BrowserDB's getTopSites
+ *
+ * @author ahunt
+ *
+ */
+public class TestTopSites extends ActivityInstrumentationTestCase2<Activity> {
+    Context mContext;
+    SuggestedSites mSuggestedSites;
+
+    public TestTopSites() {
+        super(Activity.class);
+    }
+
+    @Override
+    public void setUp() {
+        mContext = getInstrumentation().getTargetContext();
+        mSuggestedSites = new SuggestedSites(mContext);
+
+        // By default we're using StubBrowserDB which has no suggested sites available.
+        BrowserDB.from(GeckoProfile.get(mContext, Constants.DEFAULT_PROFILE)).setSuggestedSites(mSuggestedSites);
+    }
+
+    @Override
+    public void tearDown() {
+        BrowserDB.from(GeckoProfile.get(mContext, Constants.DEFAULT_PROFILE)).setSuggestedSites(null);
+    }
+
+    public void testGetTopSites() {
+        final int SUGGESTED_LIMIT = 6;
+        final int TOTAL_LIMIT = 50;
+
+        ContentResolver cr = mContext.getContentResolver();
+
+        final Uri uri = BrowserContract.TopSites.CONTENT_URI
+                                .buildUpon()
+                                .appendQueryParameter(BrowserContract.PARAM_PROFILE,
+                                                      Constants.DEFAULT_PROFILE)
+                                .appendQueryParameter(BrowserContract.PARAM_LIMIT,
+                                                      String.valueOf(SUGGESTED_LIMIT))
+                                .appendQueryParameter(BrowserContract.PARAM_SUGGESTEDSITES_LIMIT,
+                                                      String.valueOf(TOTAL_LIMIT))
+                                .build();
+
+        final Cursor c = cr.query(uri,
+                                  new String[] { Combined._ID,
+                                          Combined.URL,
+                                          Combined.TITLE,
+                                          Combined.BOOKMARK_ID,
+                                          Combined.HISTORY_ID },
+                                  null,
+                                  null,
+                                  null);
+
+        int suggestedCount = 0;
+        try {
+            while (c.moveToNext()) {
+                int type = c.getInt(c.getColumnIndexOrThrow(BrowserContract.Bookmarks.TYPE));
+                assertEquals(BrowserContract.TopSites.TYPE_SUGGESTED, type);
+                suggestedCount++;
+            }
+        } finally {
+            c.close();
+        }
+
+        Cursor suggestedSitesCursor = mSuggestedSites.get(SUGGESTED_LIMIT);
+
+        assertEquals(suggestedSitesCursor.getCount(), suggestedCount);
+
+        suggestedSitesCursor.close();
+    }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/fxa/TestAccountLoader.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/fxa/TestAccountLoader.java
new file mode 100644
index 000000000..3009cac3e
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/fxa/TestAccountLoader.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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 org.mozilla.gecko.background.fxa;
+
+import android.accounts.Account;
+import android.content.Context;
+import android.content.Loader;
+import android.os.AsyncTask;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+
+import org.mozilla.gecko.background.sync.AndroidSyncTestCaseWithAccounts;
+import org.mozilla.gecko.fxa.AccountLoader;
+import org.mozilla.gecko.fxa.FirefoxAccounts;
+import org.mozilla.gecko.fxa.FxAccountConstants;
+import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount;
+import org.mozilla.gecko.fxa.login.Separated;
+import org.mozilla.gecko.fxa.login.State;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URISyntaxException;
+import java.security.GeneralSecurityException;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * A version of https://android.googlesource.com/platform/frameworks/base/+/c91893511dc1b9e634648406c9ae61b15476e65d/test-runner/src/android/test/LoaderTestCase.java,
+ * hacked to work with the v4 support library, and patched to work around
+ * https://code.google.com/p/android/issues/detail?id=40987.
+ */
+public class TestAccountLoader extends AndroidSyncTestCaseWithAccounts {
+  // Test account names must start with TEST_USERNAME in order to be recognized
+  // as test accounts and deleted in tearDown.
+  private static final String TEST_USERNAME = "testAccount@mozilla.com";
+  private static final String TEST_ACCOUNTTYPE = FxAccountConstants.ACCOUNT_TYPE;
+
+  private static final String TEST_SYNCKEY = "testSyncKey";
+  private static final String TEST_SYNCPASSWORD = "testSyncPassword";
+
+  private static final String TEST_TOKEN_SERVER_URI = "testTokenServerURI";
+  private static final String TEST_PROFILE_SERVER_URI = "testProfileServerURI";
+  private static final String TEST_AUTH_SERVER_URI = "testAuthServerURI";
+  private static final String TEST_PROFILE = "testProfile";
+
+  public TestAccountLoader() {
+    super(TEST_ACCOUNTTYPE, TEST_USERNAME);
+  }
+
+  static {
+    // Force class loading of AsyncTask on the main thread so that it's handlers are tied to
+    // the main thread and responses from the worker thread get delivered on the main thread.
+    // The tests are run on another thread, allowing them to block waiting on a response from
+    // the code running on the main thread. The main thread can't block since the AsyncTask
+    // results come in via the event loop.
+    new AsyncTask<Void, Void, Void>() {
+      @Override
+      protected Void doInBackground(Void... args) {
+        return null;
+      }
+
+      @Override
+      protected void onPostExecute(Void result) {
+      }
+    };
+  }
+
+  /**
+   * Runs a Loader synchronously and returns the result of the load. The loader will
+   * be started, stopped, and destroyed by this method so it cannot be reused.
+   *
+   * @param loader The loader to run synchronously
+   * @return The result from the loader
+   */
+  public <T> T getLoaderResultSynchronously(final Loader<T> loader) {
+    // The test thread blocks on this queue until the loader puts it's result in
+    final ArrayBlockingQueue<AtomicReference<T>> queue = new ArrayBlockingQueue<AtomicReference<T>>(1);
+
+    // This callback runs on the "main" thread and unblocks the test thread
+    // when it puts the result into the blocking queue
+    final Loader.OnLoadCompleteListener<T> listener = new Loader.OnLoadCompleteListener<T>() {
+      @Override
+      public void onLoadComplete(Loader<T> completedLoader, T data) {
+        // Shut the loader down
+        completedLoader.unregisterListener(this);
+        completedLoader.stopLoading();
+        completedLoader.reset();
+        // Store the result, unblocking the test thread
+        queue.add(new AtomicReference<T>(data));
+      }
+    };
+
+    // This handler runs on the "main" thread of the process since AsyncTask
+    // is documented as needing to run on the main thread and many Loaders use
+    // AsyncTask
+    final Handler mainThreadHandler = new Handler(Looper.getMainLooper()) {
+      @Override
+      public void handleMessage(Message msg) {
+        loader.registerListener(0, listener);
+        loader.startLoading();
+      }
+    };
+
+    // Ask the main thread to start the loading process
+    mainThreadHandler.sendEmptyMessage(0);
+
+    // Block on the queue waiting for the result of the load to be inserted
+    T result;
+    while (true) {
+      try {
+        result = queue.take().get();
+        break;
+      } catch (InterruptedException e) {
+        throw new RuntimeException("waiting thread interrupted", e);
+      }
+    }
+    return result;
+  }
+
+  public void testInitialLoad() throws UnsupportedEncodingException, GeneralSecurityException, URISyntaxException {
+    // This is tricky. We can't mock the AccountManager easily -- see
+    // https://groups.google.com/d/msg/android-mock/VXyzvKTMUGs/Y26wVPrl50sJ --
+    // and we don't want to delete any existing accounts on device. So our test
+    // needs to be adaptive (and therefore a little race-prone).
+
+    final Context context = getApplicationContext();
+    final AccountLoader loader = new AccountLoader(context);
+
+    final boolean firefoxAccountsExist = FirefoxAccounts.firefoxAccountsExist(context);
+
+    if (firefoxAccountsExist) {
+      assertFirefoxAccount(getLoaderResultSynchronously((Loader<Account>) loader));
+      return;
+    }
+
+    // This account will get cleaned up in tearDown.
+    final State state = new Separated(TEST_USERNAME, "uid", false); // State choice is arbitrary.
+    final AndroidFxAccount account = AndroidFxAccount.addAndroidAccount(context,
+        TEST_USERNAME, TEST_PROFILE, TEST_AUTH_SERVER_URI, TEST_TOKEN_SERVER_URI, TEST_PROFILE_SERVER_URI,
+        state, AndroidSyncTestCaseWithAccounts.TEST_SYNC_AUTOMATICALLY_MAP_WITH_ALL_AUTHORITIES_DISABLED);
+    assertNotNull(account);
+    assertFirefoxAccount(getLoaderResultSynchronously((Loader<Account>) loader));
+  }
+
+  protected void assertFirefoxAccount(Account account) {
+    assertNotNull(account);
+    assertEquals(FxAccountConstants.ACCOUNT_TYPE, account.type);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/fxa/TestBrowserIDKeyPairGeneration.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/fxa/TestBrowserIDKeyPairGeneration.java
new file mode 100644
index 000000000..18fb58a97
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/fxa/TestBrowserIDKeyPairGeneration.java
@@ -0,0 +1,49 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.fxa;
+
+import java.security.GeneralSecurityException;
+
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.browserid.BrowserIDKeyPair;
+import org.mozilla.gecko.browserid.DSACryptoImplementation;
+import org.mozilla.gecko.browserid.JSONWebTokenUtils;
+import org.mozilla.gecko.browserid.RSACryptoImplementation;
+import org.mozilla.gecko.browserid.SigningPrivateKey;
+import org.mozilla.gecko.browserid.VerifyingPublicKey;
+import org.mozilla.gecko.sync.ExtendedJSONObject;
+import org.mozilla.gecko.sync.Utils;
+
+public class TestBrowserIDKeyPairGeneration extends AndroidSyncTestCase {
+  public void doTestEncodeDecode(BrowserIDKeyPair keyPair) throws Exception {
+    SigningPrivateKey privateKey = keyPair.getPrivate();
+    VerifyingPublicKey publicKey = keyPair.getPublic();
+
+    ExtendedJSONObject o = new ExtendedJSONObject();
+    o.put("key", Utils.generateGuid());
+
+    String token = JSONWebTokenUtils.encode(o.toJSONString(), privateKey);
+    assertNotNull(token);
+
+    String payload = JSONWebTokenUtils.decode(token, publicKey);
+    assertEquals(o.toJSONString(), payload);
+
+    try {
+      JSONWebTokenUtils.decode(token + "x", publicKey);
+      fail("Expected exception.");
+    } catch (GeneralSecurityException e) {
+      // Do nothing.
+    }
+  }
+
+  public void testEncodeDecodeSuccessRSA() throws Exception {
+    doTestEncodeDecode(RSACryptoImplementation.generateKeyPair(1024));
+    doTestEncodeDecode(RSACryptoImplementation.generateKeyPair(2048));
+  }
+
+  public void testEncodeDecodeSuccessDSA() throws Exception {
+    doTestEncodeDecode(DSACryptoImplementation.generateKeyPair(512));
+    doTestEncodeDecode(DSACryptoImplementation.generateKeyPair(1024));
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/fxa/authenticator/TestAccountPickler.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/fxa/authenticator/TestAccountPickler.java
new file mode 100644
index 000000000..d50bd47e0
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/fxa/authenticator/TestAccountPickler.java
@@ -0,0 +1,134 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.fxa.authenticator;
+
+import org.mozilla.gecko.background.sync.AndroidSyncTestCaseWithAccounts;
+import org.mozilla.gecko.fxa.FxAccountConstants;
+import org.mozilla.gecko.fxa.authenticator.AccountPickler;
+import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount;
+import org.mozilla.gecko.fxa.login.Separated;
+import org.mozilla.gecko.fxa.login.State;
+import org.mozilla.gecko.sync.ExtendedJSONObject;
+import org.mozilla.gecko.sync.Utils;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.test.RenamingDelegatingContext;
+
+public class TestAccountPickler extends AndroidSyncTestCaseWithAccounts {
+  private static final String TEST_TOKEN_SERVER_URI = "tokenServerURI";
+  private static final String TEST_PROFILE_SERVER_URI = "profileServerURI";
+  private static final String TEST_AUTH_SERVER_URI = "serverURI";
+  private static final String TEST_PROFILE = "profile";
+  private final static String FILENAME_PREFIX = "TestAccountPickler-";
+  private final static String PICKLE_FILENAME = "pickle";
+
+  private final static String TEST_ACCOUNTTYPE = FxAccountConstants.ACCOUNT_TYPE;
+
+  // Test account names must start with TEST_USERNAME in order to be recognized
+  // as test accounts and deleted in tearDown.
+  public static final String TEST_USERNAME   = "testFirefoxAccount@mozilla.com";
+
+  public Account account;
+  public RenamingDelegatingContext context;
+
+  public TestAccountPickler() {
+    super(TEST_ACCOUNTTYPE, TEST_USERNAME);
+  }
+
+  @Override
+  public void setUp() {
+    super.setUp();
+    this.account = null;
+    // Randomize the filename prefix in case we don't clean up correctly.
+    this.context = new RenamingDelegatingContext(getApplicationContext(), FILENAME_PREFIX +
+        Math.random() * 1000001 + "-");
+    this.accountManager = AccountManager.get(context);
+  }
+
+  @Override
+  public void tearDown() {
+    super.tearDown();
+    this.context.deleteFile(PICKLE_FILENAME);
+  }
+
+  public AndroidFxAccount addTestAccount() throws Exception {
+    final State state = new Separated(TEST_USERNAME, "uid", false); // State choice is arbitrary.
+    final AndroidFxAccount account = AndroidFxAccount.addAndroidAccount(context, TEST_USERNAME,
+        TEST_PROFILE, TEST_AUTH_SERVER_URI, TEST_TOKEN_SERVER_URI, TEST_PROFILE_SERVER_URI, state,
+        AndroidSyncTestCaseWithAccounts.TEST_SYNC_AUTOMATICALLY_MAP_WITH_ALL_AUTHORITIES_DISABLED);
+    assertNotNull(account);
+    assertNotNull(account.getProfile());
+    assertTrue(testAccountsExist()); // Sanity check.
+    this.account = account.getAndroidAccount(); // To remove in tearDown() if we throw.
+    return account;
+  }
+
+  public void testPickle() throws Exception {
+    final AndroidFxAccount account = addTestAccount();
+
+    final long now = System.currentTimeMillis();
+    final ExtendedJSONObject o = AccountPickler.toJSON(account, now);
+    assertNotNull(o.toJSONString());
+
+    assertEquals(3, o.getLong(AccountPickler.KEY_PICKLE_VERSION).longValue());
+    assertTrue(o.getLong(AccountPickler.KEY_PICKLE_TIMESTAMP).longValue() < System.currentTimeMillis());
+
+    assertEquals(AndroidFxAccount.CURRENT_ACCOUNT_VERSION, o.getIntegerSafely(AccountPickler.KEY_ACCOUNT_VERSION).intValue());
+    assertEquals(FxAccountConstants.ACCOUNT_TYPE, o.getString(AccountPickler.KEY_ACCOUNT_TYPE));
+
+    assertEquals(TEST_USERNAME, o.getString(AccountPickler.KEY_EMAIL));
+    assertEquals(TEST_PROFILE, o.getString(AccountPickler.KEY_PROFILE));
+    assertEquals(TEST_AUTH_SERVER_URI, o.getString(AccountPickler.KEY_IDP_SERVER_URI));
+    assertEquals(TEST_TOKEN_SERVER_URI, o.getString(AccountPickler.KEY_TOKEN_SERVER_URI));
+    assertEquals(TEST_PROFILE_SERVER_URI, o.getString(AccountPickler.KEY_PROFILE_SERVER_URI));
+
+    assertNotNull(o.getObject(AccountPickler.KEY_AUTHORITIES_TO_SYNC_AUTOMATICALLY_MAP));
+    assertNotNull(o.get(AccountPickler.KEY_BUNDLE));
+  }
+
+  public void testPickleAndUnpickle() throws Exception {
+    final AndroidFxAccount inputAccount = addTestAccount();
+
+    AccountPickler.pickle(inputAccount, PICKLE_FILENAME);
+    final ExtendedJSONObject inputJSON = AccountPickler.toJSON(inputAccount, 0);
+    final State inputState = inputAccount.getState();
+    assertNotNull(inputJSON);
+    assertNotNull(inputState);
+
+    // unpickle adds an account to the AccountManager so delete it first.
+    deleteTestAccounts();
+    assertFalse(testAccountsExist());
+
+    final AndroidFxAccount unpickledAccount = AccountPickler.unpickle(context, PICKLE_FILENAME);
+    assertNotNull(unpickledAccount);
+    final ExtendedJSONObject unpickledJSON = AccountPickler.toJSON(unpickledAccount, 0);
+    final State unpickledState = unpickledAccount.getState();
+    assertNotNull(unpickledJSON);
+    assertNotNull(unpickledState);
+
+    assertEquals(inputJSON, unpickledJSON);
+    assertStateEquals(inputState, unpickledState);
+  }
+
+  public void testDeletePickle() throws Exception {
+    final AndroidFxAccount account = addTestAccount();
+    AccountPickler.pickle(account, PICKLE_FILENAME);
+
+    final String s = Utils.readFile(context, PICKLE_FILENAME);
+    assertNotNull(s);
+    assertTrue(s.length() > 0);
+
+    AccountPickler.deletePickle(context, PICKLE_FILENAME);
+    assertFileNotPresent(context, PICKLE_FILENAME);
+  }
+
+  private void assertStateEquals(final State expected, final State actual) throws Exception {
+    // TODO: Write and use State.equals. Thus, this is only thorough for the State base class.
+    assertEquals(expected.getStateLabel(), actual.getStateLabel());
+    assertEquals(expected.email, actual.email);
+    assertEquals(expected.uid, actual.uid);
+    assertEquals(expected.verified, actual.verified);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/helpers/AndroidSyncTestCase.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/helpers/AndroidSyncTestCase.java
new file mode 100644
index 000000000..5cdbe44f4
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/helpers/AndroidSyncTestCase.java
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.helpers;
+
+import junit.framework.AssertionFailedError;
+
+import org.mozilla.gecko.background.testhelpers.WaitHelper;
+
+import android.app.Activity;
+import android.content.Context;
+import android.test.ActivityInstrumentationTestCase2;
+
+/**
+ * AndroidSyncTestCase provides helper methods for testing.
+ */
+public class AndroidSyncTestCase extends ActivityInstrumentationTestCase2<Activity> {
+  protected static String LOG_TAG = "AndroidSyncTestCase";
+
+  public AndroidSyncTestCase() {
+    super(Activity.class);
+    WaitHelper.resetTestWaiter();
+  }
+
+  public Context getApplicationContext() {
+    return this.getInstrumentation().getTargetContext();
+  }
+
+  public static void performWait(Runnable runnable) {
+    try {
+      WaitHelper.getTestWaiter().performWait(runnable);
+    } catch (WaitHelper.InnerError e) {
+      AssertionFailedError inner = new AssertionFailedError("Caught error in performWait");
+      inner.initCause(e.innerError);
+      throw inner;
+    }
+  }
+
+  public static void performNotify() {
+    WaitHelper.getTestWaiter().performNotify();
+  }
+
+  public static void performNotify(Throwable e) {
+    WaitHelper.getTestWaiter().performNotify(e);
+  }
+
+  public static void performNotify(String reason, Throwable e) {
+    AssertionFailedError er = new AssertionFailedError(reason + ": " + e.getMessage());
+    er.initCause(e);
+    WaitHelper.getTestWaiter().performNotify(er);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/helpers/DBHelpers.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/helpers/DBHelpers.java
new file mode 100644
index 000000000..c37f1e8bd
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/helpers/DBHelpers.java
@@ -0,0 +1,84 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.helpers;
+
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import junit.framework.Assert;
+
+public class DBHelpers {
+
+  /*
+   * Works for strings and int-ish values.
+   */
+  public static void assertCursorContains(Object[][] expected, Cursor actual) {
+    Assert.assertEquals(expected.length, actual.getCount());
+    int i = 0, j = 0;
+    Object[] row;
+
+    do {
+      row = expected[i];
+      for (j = 0; j < row.length; ++j) {
+        Object atIndex = row[j];
+        if (atIndex == null) {
+          continue;
+        }
+        if (atIndex instanceof String) {
+          Assert.assertEquals(atIndex, actual.getString(j));
+        } else {
+          Assert.assertEquals(atIndex, actual.getInt(j));
+        }
+      }
+      ++i;
+    } while (actual.moveToPosition(i));
+  }
+
+  public static int getRowCount(SQLiteDatabase db, String table) {
+    return getRowCount(db, table, null, null);
+  }
+
+  public static int getRowCount(SQLiteDatabase db, String table, String selection, String[] selectionArgs) {
+    final Cursor c = db.query(table, null, selection, selectionArgs, null, null, null);
+    try {
+      return c.getCount();
+    } finally {
+      c.close();
+    }
+  }
+
+  /**
+   * Returns an ID that is non-existent in the given sqlite table. Assumes that a column named
+   * "id" exists.
+   */
+  public static int getNonExistentID(SQLiteDatabase db, String table) {
+    // XXX: We should use selectionArgs to concatenate table, but sqlite throws a syntax error on
+    // "?" because it wants to ensure id is a valid column in table.
+    final Cursor c = db.rawQuery("SELECT MAX(id) + 1 FROM " + table, null);
+    try {
+      if (!c.moveToNext()) {
+        return 0;
+      }
+      return c.getInt(0);
+    } finally {
+      c.close();
+    }
+  }
+
+  /**
+   * Returns an ID that exists in the given sqlite table. Assumes that a column named * "id"
+   * exists.
+   */
+  public static long getExistentID(SQLiteDatabase db, String table) {
+    final Cursor c = db.query(table, new String[] {"id"}, null, null, null, null, null, "1");
+    try {
+      if (!c.moveToNext()) {
+        throw new IllegalStateException("Given table does not contain any entries.");
+      }
+      return c.getInt(0);
+    } finally {
+      c.close();
+    }
+  }
+
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/helpers/DBProviderTestCase.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/helpers/DBProviderTestCase.java
new file mode 100644
index 000000000..ccfeb8d63
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/helpers/DBProviderTestCase.java
@@ -0,0 +1,73 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.helpers;
+
+import java.io.File;
+
+import android.content.ContentProvider;
+import android.content.Context;
+import android.test.AndroidTestCase;
+import android.test.mock.MockContentResolver;
+
+/**
+ * Because ProviderTestCase2 is unable to handle custom DB paths.
+ */
+public abstract class DBProviderTestCase<T extends ContentProvider> extends
+    AndroidTestCase {
+
+  Class<T> providerClass;
+  String providerAuthority;
+
+  protected File fakeProfileDirectory;
+  private MockContentResolver resolver;
+  private T provider;
+
+  public DBProviderTestCase(Class<T> providerClass, String providerAuthority) {
+    this.providerClass = providerClass;
+    this.providerAuthority = providerAuthority;
+  }
+
+  public T getProvider() {
+    return provider;
+  }
+
+  public MockContentResolver getMockContentResolver() {
+    return resolver;
+  }
+
+  protected String getCacheSuffix() {
+    return this.getClass().getName() + "-" + System.currentTimeMillis();
+  }
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    File cache = getContext().getCacheDir();
+    fakeProfileDirectory = new File(cache.getAbsolutePath() + getCacheSuffix());
+    System.out.println("Test: Creating profile directory " + fakeProfileDirectory.getAbsolutePath());
+    if (!fakeProfileDirectory.mkdir()) {
+      throw new IllegalStateException("Could not create temporary directory.");
+    }
+
+    final Context context = getContext();
+    assertNotNull(context);
+    resolver = new MockContentResolver();
+    provider = providerClass.newInstance();
+    provider.attachInfo(context, null);
+    assertNotNull(provider);
+    resolver.addProvider(providerAuthority, getProvider());
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    // We don't check return values.
+    System.out.println("Test: Cleaning up " + fakeProfileDirectory.getAbsolutePath());
+    for (File child : fakeProfileDirectory.listFiles()) {
+      child.delete();
+    }
+    fakeProfileDirectory.delete();
+    super.tearDown();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/nativecode/test/TestNativeCrypto.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/nativecode/test/TestNativeCrypto.java
new file mode 100644
index 000000000..d24f28491
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/nativecode/test/TestNativeCrypto.java
@@ -0,0 +1,175 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.nativecode.test;
+
+import java.io.UnsupportedEncodingException;
+import java.security.GeneralSecurityException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+
+import junit.framework.TestCase;
+
+import org.mozilla.gecko.background.nativecode.NativeCrypto;
+import org.mozilla.gecko.sync.Utils;
+
+/*
+ * Tests the Java wrapper over native implementations of crypto code. Test vectors from:
+ *   * PBKDF2SHA256:
+ *     - <https://github.com/ircmaxell/PHP-PasswordLib/blob/master/test/Data/Vectors/pbkdf2-draft-josefsson-sha256.test-vectors>
+ *     - <https://gitorious.org/scrypt/nettle-scrypt/blobs/37c0d5288e991604fe33dba2f1724986a8dddf56/testsuite/pbkdf2-test.c>
+ *   * SHA-1:
+ *     - <http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c>
+ */
+public class TestNativeCrypto extends TestCase {
+
+  public final void testPBKDF2SHA256A() throws UnsupportedEncodingException, GeneralSecurityException {
+    String  p = "password";
+    String  s = "salt";
+    int dkLen = 32;
+
+    checkPBKDF2SHA256(p, s, 1, dkLen, "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b");
+    checkPBKDF2SHA256(p, s, 4096, dkLen, "c5e478d59288c841aa530db6845c4c8d962893a001ce4e11a4963873aa98134a");
+  }
+
+  public final void testPBKDF2SHA256B() throws UnsupportedEncodingException, GeneralSecurityException {
+    String  p = "passwordPASSWORDpassword";
+    String  s = "saltSALTsaltSALTsaltSALTsaltSALTsalt";
+    int dkLen = 40;
+
+    checkPBKDF2SHA256(p, s, 4096, dkLen, "348c89dbcbd32b2f32d814b8116e84cf2b17347ebc1800181c4e2a1fb8dd53e1c635518c7dac47e9");
+  }
+
+  public final void testPBKDF2SHA256scryptA() throws UnsupportedEncodingException, GeneralSecurityException {
+    String  p = "passwd";
+    String  s = "salt";
+    int dkLen = 64;
+
+    checkPBKDF2SHA256(p, s, 1, dkLen, "55ac046e56e3089fec1691c22544b605f94185216dde0465e68b9d57c20dacbc49ca9cccf179b645991664b39d77ef317c71b845b1e30bd509112041d3a19783");
+  }
+
+  public final void testPBKDF2SHA256scryptB() throws UnsupportedEncodingException, GeneralSecurityException {
+    String  p = "Password";
+    String  s = "NaCl";
+    int dkLen = 64;
+
+    checkPBKDF2SHA256(p, s, 80000, dkLen, "4ddcd8f60b98be21830cee5ef22701f9641a4418d04c0414aeff08876b34ab56a1d425a1225833549adb841b51c9b3176a272bdebba1d078478f62b397f33c8d");
+  }
+
+  public final void testPBKDF2SHA256C() throws UnsupportedEncodingException, GeneralSecurityException {
+    String  p = "pass\0word";
+    String  s = "sa\0lt";
+    int dkLen = 16;
+
+    checkPBKDF2SHA256(p, s, 4096, dkLen, "89b69d0516f829893c696226650a8687");
+  }
+
+  /*
+  // This test takes two or three minutes to run, so we don't.
+  public final void testPBKDF2SHA256D() throws UnsupportedEncodingException, GeneralSecurityException {
+    String  p = "password";
+    String  s = "salt";
+    int dkLen = 32;
+
+    checkPBKDF2SHA256(p, s, 16777216, dkLen, "cf81c66fe8cfc04d1f31ecb65dab4089f7f179e89b3b0bcb17ad10e3ac6eba46");
+  }
+  */
+
+  public final void testTimePBKDF2SHA256() throws UnsupportedEncodingException, GeneralSecurityException {
+    checkPBKDF2SHA256("password", "salt", 80000, 32, null);
+  }
+
+  public final void testPBKDF2SHA256InvalidLenArg() throws UnsupportedEncodingException, GeneralSecurityException {
+    final String p = "password";
+    final String s = "salt";
+    final int c = 1;
+    final int dkLen = -1; // Should always be positive.
+
+    try {
+      NativeCrypto.pbkdf2SHA256(p.getBytes("US-ASCII"), s.getBytes("US-ASCII"), c, dkLen);
+      fail("Expected sha256 to throw with negative dkLen argument.");
+    } catch (IllegalArgumentException e) { } // Expected.
+  }
+
+  public final void testSHA1() throws UnsupportedEncodingException {
+    final String[] inputs = new String[] {
+      "abc",
+      "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+      "" // To be filled in below.
+    };
+    final String baseStr = "01234567";
+    final int repetitions = 80;
+    final StringBuilder builder = new StringBuilder(baseStr.length() * repetitions);
+    for (int i = 0; i < 80; ++i) {
+      builder.append(baseStr);
+    }
+    inputs[2] = builder.toString();
+
+    final String[] expecteds = new String[] {
+      "a9993e364706816aba3e25717850c26c9cd0d89d",
+      "84983e441c3bd26ebaae4aa1f95129e5e54670f1",
+      "dea356a2cddd90c7a7ecedc5ebb563934f460452"
+    };
+
+    for (int i = 0; i < inputs.length; ++i) {
+      final byte[] input = inputs[i].getBytes("US-ASCII");
+      final String expected = expecteds[i];
+
+      final byte[] actual = NativeCrypto.sha1(input);
+      assertNotNull("Hashed value is non-null", actual);
+      assertExpectedBytes(expected, actual);
+    }
+  }
+
+  /**
+   * Test to ensure the output of our SHA1 algo is the same as MessageDigest's. This is important
+   * because we intend to replace MessageDigest in FHR with this SHA-1 algo (bug 959652).
+   */
+  public final void testSHA1AgainstMessageDigest() throws UnsupportedEncodingException,
+      NoSuchAlgorithmException {
+    final String[] inputs = {
+      "password",
+      "saranghae",
+      "aoeusnthaoeusnthaoeusnth \0 12345098765432109876_!"
+    };
+
+    final MessageDigest digest = MessageDigest.getInstance("SHA-1");
+    for (final String input : inputs) {
+      final byte[] inputBytes = input.getBytes("US-ASCII");
+
+      final byte[] mdBytes = digest.digest(inputBytes);
+      final byte[] ourBytes = NativeCrypto.sha1(inputBytes);
+      assertTrue("MessageDigest hash is the same as NativeCrypto SHA-1 hash",
+          Arrays.equals(ourBytes, mdBytes));
+    }
+  }
+
+  private void checkPBKDF2SHA256(String p, String s, int c, int dkLen,
+                                final String expectedStr)
+                                                    throws GeneralSecurityException, UnsupportedEncodingException {
+    long start = System.currentTimeMillis();
+    byte[] key = NativeCrypto.pbkdf2SHA256(p.getBytes("US-ASCII"), s.getBytes("US-ASCII"), c, dkLen);
+    assertNotNull(key);
+
+    long end = System.currentTimeMillis();
+
+    System.err.println("SHA-256 " + c + " took " + (end - start) + "ms");
+    if (expectedStr == null) {
+      return;
+    }
+
+    assertEquals(dkLen, Utils.hex2Byte(expectedStr).length);
+    assertExpectedBytes(expectedStr, key);
+  }
+
+  private void assertExpectedBytes(final String expectedStr, byte[] key) {
+    assertEquals(expectedStr, Utils.byte2Hex(key));
+    byte[] expected = Utils.hex2Byte(expectedStr);
+
+    assertEquals(expected.length, key.length);
+    for (int i = 0; i < key.length; i++) {
+      assertEquals(expected[i], key[i]);
+    }
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/AndroidSyncTestCaseWithAccounts.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/AndroidSyncTestCaseWithAccounts.java
new file mode 100644
index 000000000..e0e4e8bb1
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/AndroidSyncTestCaseWithAccounts.java
@@ -0,0 +1,128 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.accounts.AccountManagerCallback;
+import android.accounts.AccountManagerFuture;
+import android.content.Context;
+import android.test.InstrumentationTestCase;
+
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.fxa.authenticator.AndroidFxAccount;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+public class AndroidSyncTestCaseWithAccounts extends AndroidSyncTestCase {
+  public final String testAccountType;
+  public final String testAccountPrefix;
+
+  protected Context context;
+  protected AccountManager accountManager;
+  protected int numAccounts;
+
+  public static final Map<String, Boolean> TEST_SYNC_AUTOMATICALLY_MAP_WITH_ALL_AUTHORITIES_DISABLED;
+  static {
+    final Map<String, Boolean> m = new HashMap<String, Boolean>();
+    for (String authority : AndroidFxAccount.DEFAULT_AUTHORITIES_TO_SYNC_AUTOMATICALLY_MAP.keySet()) {
+      m.put(authority, false);
+    }
+    TEST_SYNC_AUTOMATICALLY_MAP_WITH_ALL_AUTHORITIES_DISABLED = m;
+  }
+
+  public AndroidSyncTestCaseWithAccounts(String accountType, String accountPrefix) {
+    super();
+    this.testAccountType = accountType;
+    this.testAccountPrefix = accountPrefix;
+  }
+
+  @Override
+  public void setUp() {
+    context = getApplicationContext();
+    accountManager = AccountManager.get(context);
+    deleteTestAccounts(); // Always start with no test accounts.
+    numAccounts = accountManager.getAccountsByType(testAccountType).length;
+  }
+
+  public List<Account> getTestAccounts() {
+    final List<Account> testAccounts = new ArrayList<Account>();
+
+    final Account[] accounts = accountManager.getAccountsByType(testAccountType);
+    for (Account account : accounts) {
+      if (account.name.startsWith(testAccountPrefix)) {
+        testAccounts.add(account);
+      }
+    }
+
+    return testAccounts;
+  }
+
+  public static void deleteAccount(final InstrumentationTestCase test, final AccountManager accountManager, final Account account) {
+    performWait(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          test.runTestOnUiThread(new Runnable() {
+            final AccountManagerCallback<Boolean> callback = new AccountManagerCallback<Boolean>() {
+              @Override
+              public void run(AccountManagerFuture<Boolean> future) {
+                try {
+                  future.getResult(5L, TimeUnit.SECONDS);
+                } catch (Exception e) {
+                }
+                performNotify();
+              }
+            };
+
+            @Override
+            public void run() {
+              accountManager.removeAccount(account, callback, null);
+            }
+          });
+        } catch (Throwable e) {
+          performNotify(e);
+        }
+      }
+    });
+  }
+
+  public void deleteTestAccounts() {
+    for (Account account : getTestAccounts()) {
+      deleteAccount(this, accountManager, account);
+    }
+  }
+
+  public boolean testAccountsExist() {
+    // Note that we don't use FirefoxAccounts.firefoxAccountsExist because it unpickles.
+    return !getTestAccounts().isEmpty();
+  }
+
+  @Override
+  public void tearDown() {
+    deleteTestAccounts();
+    assertEquals(numAccounts, accountManager.getAccountsByType(testAccountType).length);
+  }
+
+  public static void assertFileNotPresent(final Context context, final String filename) throws Exception {
+    // Verify file is not present.
+    FileInputStream fis = null;
+    try {
+      fis = context.openFileInput(filename);
+      fail("Should get FileNotFoundException.");
+    } catch (FileNotFoundException e) {
+      // Do nothing; file should not exist.
+    } finally {
+      if (fis != null) {
+        fis.close();
+      }
+    }
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestClientsStage.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestClientsStage.java
new file mode 100644
index 000000000..39e24b4d4
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestClientsStage.java
@@ -0,0 +1,95 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync;
+
+import org.json.simple.JSONArray;
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.background.testhelpers.DefaultGlobalSessionCallback;
+import org.mozilla.gecko.background.testhelpers.MockClientsDataDelegate;
+import org.mozilla.gecko.background.testhelpers.MockSharedPreferences;
+import org.mozilla.gecko.sync.GlobalSession;
+import org.mozilla.gecko.sync.SyncConfiguration;
+import org.mozilla.gecko.sync.crypto.KeyBundle;
+import org.mozilla.gecko.sync.delegates.ClientsDataDelegate;
+import org.mozilla.gecko.sync.delegates.GlobalSessionCallback;
+import org.mozilla.gecko.sync.net.AuthHeaderProvider;
+import org.mozilla.gecko.sync.net.BasicAuthHeaderProvider;
+import org.mozilla.gecko.sync.repositories.android.ClientsDatabaseAccessor;
+import org.mozilla.gecko.sync.repositories.domain.ClientRecord;
+import org.mozilla.gecko.sync.stage.SyncClientsEngineStage;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+public class TestClientsStage extends AndroidSyncTestCase {
+  private static final String TEST_USERNAME    = "johndoe";
+  private static final String TEST_PASSWORD    = "password";
+  private static final String TEST_SYNC_KEY    = "abcdeabcdeabcdeabcdeabcdea";
+
+  @Override
+  public void setUp() {
+    ClientsDatabaseAccessor db = new ClientsDatabaseAccessor(getApplicationContext());
+    db.wipeDB();
+    db.close();
+  }
+
+  public void testWipeClearsClients() throws Exception {
+
+    // Wiping clients is equivalent to a reset and dropping all local stored client records.
+    // Resetting is defined as being the same as for other engines -- discard local
+    // and remote timestamps, tracked failed records, and tracked records to fetch.
+
+    final Context context = getApplicationContext();
+    final ClientsDatabaseAccessor dataAccessor = new ClientsDatabaseAccessor(context);
+    final GlobalSessionCallback callback = new DefaultGlobalSessionCallback();
+    final ClientsDataDelegate delegate = new MockClientsDataDelegate();
+
+    final KeyBundle keyBundle = new KeyBundle(TEST_USERNAME, TEST_SYNC_KEY);
+    final AuthHeaderProvider authHeaderProvider = new BasicAuthHeaderProvider(TEST_USERNAME, TEST_PASSWORD);
+    final SharedPreferences prefs = new MockSharedPreferences();
+    final SyncConfiguration config = new SyncConfiguration(TEST_USERNAME, authHeaderProvider, prefs);
+    config.syncKeyBundle = keyBundle;
+    GlobalSession session = new GlobalSession(config, callback, context, delegate);
+
+    SyncClientsEngineStage stage = new SyncClientsEngineStage() {
+
+      @Override
+      public synchronized ClientsDatabaseAccessor getClientsDatabaseAccessor() {
+        if (db == null) {
+          db = dataAccessor;
+        }
+        return db;
+      }
+    };
+
+    final String guid = "clientabcdef";
+    long lastModified = System.currentTimeMillis();
+    ClientRecord record = new ClientRecord(guid, "clients", lastModified , false);
+    record.name = "John's Phone";
+    record.type = "mobile";
+    record.device = "Some Device";
+    record.os = "iOS";
+    record.commands = new JSONArray();
+
+    dataAccessor.store(record);
+    assertEquals(1, dataAccessor.clientsCount());
+
+    final ClientRecord stored = dataAccessor.fetchAllClients().get(guid);
+    assertNotNull(stored);
+    assertEquals("John's Phone", stored.name);
+    assertEquals("mobile", stored.type);
+    assertEquals("Some Device", stored.device);
+    assertEquals("iOS", stored.os);
+
+    stage.wipeLocal(session);
+
+    try {
+      assertEquals(0, dataAccessor.clientsCount());
+      assertEquals(0L, session.config.getPersistedServerClientRecordTimestamp());
+      assertEquals(0, session.getClientsDelegate().getClientsCount());
+    } finally {
+      dataAccessor.close();
+    }
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestResetting.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestResetting.java
new file mode 100644
index 000000000..52af2ad01
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestResetting.java
@@ -0,0 +1,198 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync;
+
+import android.content.SharedPreferences;
+
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.background.testhelpers.BaseMockServerSyncStage;
+import org.mozilla.gecko.background.testhelpers.DefaultGlobalSessionCallback;
+import org.mozilla.gecko.background.testhelpers.MockRecord;
+import org.mozilla.gecko.background.testhelpers.MockSharedPreferences;
+import org.mozilla.gecko.background.testhelpers.WBORepository;
+import org.mozilla.gecko.background.testhelpers.WaitHelper;
+import org.mozilla.gecko.sync.EngineSettings;
+import org.mozilla.gecko.sync.GlobalSession;
+import org.mozilla.gecko.sync.MetaGlobalException;
+import org.mozilla.gecko.sync.SyncConfiguration;
+import org.mozilla.gecko.sync.SynchronizerConfiguration;
+import org.mozilla.gecko.sync.crypto.KeyBundle;
+import org.mozilla.gecko.sync.delegates.GlobalSessionCallback;
+import org.mozilla.gecko.sync.net.AuthHeaderProvider;
+import org.mozilla.gecko.sync.net.BasicAuthHeaderProvider;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+import org.mozilla.gecko.sync.stage.NoSuchStageException;
+import org.mozilla.gecko.sync.synchronizer.Synchronizer;
+
+/**
+ * Test the on-device side effects of reset operations on a stage.
+ *
+ * See also "TestResetCommands" in the unit test suite.
+ */
+public class TestResetting extends AndroidSyncTestCase {
+  private static final String TEST_USERNAME    = "johndoe";
+  private static final String TEST_PASSWORD    = "password";
+  private static final String TEST_SYNC_KEY    = "abcdeabcdeabcdeabcdeabcdea";
+
+  @Override
+  public void setUp() {
+    assertTrue(WaitHelper.getTestWaiter().isIdle());
+  }
+
+  /**
+   * Set up a mock stage that synchronizes two mock repositories. Apply various
+   * reset/sync/wipe permutations and check state.
+   */
+  public void testResetAndWipeStage() throws Exception {
+
+    final long startTime = System.currentTimeMillis();
+    final GlobalSessionCallback callback = createGlobalSessionCallback();
+    final GlobalSession session = createDefaultGlobalSession(callback);
+
+    final ExecutableMockServerSyncStage stage = new ExecutableMockServerSyncStage() {
+      @Override
+      public void onSynchronized(Synchronizer synchronizer) {
+        try {
+          assertTrue(startTime <= synchronizer.bundleA.getTimestamp());
+          assertTrue(startTime <= synchronizer.bundleB.getTimestamp());
+
+          // Call up to allow the usual persistence etc. to happen.
+          super.onSynchronized(synchronizer);
+        } catch (Throwable e) {
+          performNotify(e);
+          return;
+        }
+        performNotify();
+      }
+    };
+
+    final boolean bumpTimestamps = true;
+    WBORepository local = new WBORepository(bumpTimestamps);
+    WBORepository remote = new WBORepository(bumpTimestamps);
+
+    stage.name       = "mock";
+    stage.collection = "mock";
+    stage.local      = local;
+    stage.remote     = remote;
+
+    stage.executeSynchronously(session);
+
+    // Verify the persisted values.
+    assertConfigTimestampsGreaterThan(stage.leakConfig(), startTime, startTime);
+
+    // Reset.
+    stage.resetLocal(session);
+
+    // Verify that they're gone.
+    assertConfigTimestampsEqual(stage.leakConfig(), 0, 0);
+
+    // Now sync data, ensure that timestamps come back.
+    final long afterReset = System.currentTimeMillis();
+    final String recordGUID = "abcdefghijkl";
+    local.wbos.put(recordGUID, new MockRecord(recordGUID, "mock", startTime, false));
+
+    // Sync again with data and verify timestamps and data.
+    stage.executeSynchronously(session);
+
+    assertConfigTimestampsGreaterThan(stage.leakConfig(), afterReset, afterReset);
+    assertEquals(1, remote.wbos.size());
+    assertEquals(1, local.wbos.size());
+
+    Record remoteRecord = remote.wbos.get(recordGUID);
+    assertNotNull(remoteRecord);
+    assertNotNull(local.wbos.get(recordGUID));
+    assertEquals(recordGUID, remoteRecord.guid);
+    assertTrue(afterReset <= remoteRecord.lastModified);
+
+    // Reset doesn't clear data.
+    stage.resetLocal(session);
+    assertConfigTimestampsEqual(stage.leakConfig(), 0, 0);
+    assertEquals(1, remote.wbos.size());
+    assertEquals(1, local.wbos.size());
+    remoteRecord = remote.wbos.get(recordGUID);
+    assertNotNull(remoteRecord);
+    assertNotNull(local.wbos.get(recordGUID));
+
+    // Wipe does. Recover from reset...
+    final long beforeWipe = System.currentTimeMillis();
+    stage.executeSynchronously(session);
+    assertEquals(1, remote.wbos.size());
+    assertEquals(1, local.wbos.size());
+    assertConfigTimestampsGreaterThan(stage.leakConfig(), beforeWipe, beforeWipe);
+
+    // ... then wipe.
+    stage.wipeLocal(session);
+    assertConfigTimestampsEqual(stage.leakConfig(), 0, 0);
+    assertEquals(1, remote.wbos.size());     // We don't wipe the server.
+    assertEquals(0, local.wbos.size());      // We do wipe local.
+  }
+
+  /**
+   * A stage that joins two Repositories with no wrapping.
+   */
+  public class ExecutableMockServerSyncStage extends BaseMockServerSyncStage {
+    /**
+     * Run this stage synchronously.
+     */
+    public void executeSynchronously(final GlobalSession session) {
+      final BaseMockServerSyncStage self = this;
+      performWait(new Runnable() {
+        @Override
+        public void run() {
+          try {
+            self.execute(session);
+          } catch (NoSuchStageException e) {
+            performNotify(e);
+          }
+        }
+      });
+    }
+  }
+
+  private GlobalSession createDefaultGlobalSession(final GlobalSessionCallback callback) throws Exception {
+    final KeyBundle keyBundle = new KeyBundle(TEST_USERNAME, TEST_SYNC_KEY);
+    final AuthHeaderProvider authHeaderProvider = new BasicAuthHeaderProvider(TEST_USERNAME, TEST_PASSWORD);
+    final SharedPreferences prefs = new MockSharedPreferences();
+    final SyncConfiguration config = new SyncConfiguration(TEST_USERNAME, authHeaderProvider, prefs);
+    config.syncKeyBundle = keyBundle;
+    return new GlobalSession(config, callback, getApplicationContext(), null) {
+      @Override
+      public boolean isEngineRemotelyEnabled(String engineName,
+                                     EngineSettings engineSettings)
+        throws MetaGlobalException {
+        return true;
+      }
+
+      @Override
+      public void advance() {
+        // So we don't proceed and run other stages.
+      }
+    };
+  }
+
+  private static GlobalSessionCallback createGlobalSessionCallback() {
+    return new DefaultGlobalSessionCallback() {
+
+      @Override
+      public void handleAborted(GlobalSession globalSession, String reason) {
+        performNotify(new Exception("Aborted"));
+      }
+
+      @Override
+      public void handleError(GlobalSession globalSession, Exception ex) {
+        performNotify(ex);
+      }
+    };
+  }
+
+  private static void assertConfigTimestampsGreaterThan(SynchronizerConfiguration config, long local, long remote) {
+    assertTrue(local <= config.localBundle.getTimestamp());
+    assertTrue(remote <= config.remoteBundle.getTimestamp());
+  }
+
+  private static void assertConfigTimestampsEqual(SynchronizerConfiguration config, long local, long remote) {
+    assertEquals(local, config.localBundle.getTimestamp());
+    assertEquals(remote, config.remoteBundle.getTimestamp());
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestStoreTracking.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestStoreTracking.java
new file mode 100644
index 000000000..bac6c7f49
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestStoreTracking.java
@@ -0,0 +1,377 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+
+import junit.framework.AssertionFailedError;
+
+import org.mozilla.gecko.background.common.log.Logger;
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.background.sync.helpers.SimpleSuccessBeginDelegate;
+import org.mozilla.gecko.background.sync.helpers.SimpleSuccessCreationDelegate;
+import org.mozilla.gecko.background.sync.helpers.SimpleSuccessFetchDelegate;
+import org.mozilla.gecko.background.sync.helpers.SimpleSuccessFinishDelegate;
+import org.mozilla.gecko.background.sync.helpers.SimpleSuccessStoreDelegate;
+import org.mozilla.gecko.background.testhelpers.WBORepository;
+import org.mozilla.gecko.sync.CryptoRecord;
+import org.mozilla.gecko.sync.ExtendedJSONObject;
+import org.mozilla.gecko.sync.repositories.InactiveSessionException;
+import org.mozilla.gecko.sync.repositories.InvalidSessionTransitionException;
+import org.mozilla.gecko.sync.repositories.NoStoreDelegateException;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.RepositorySessionBundle;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
+import org.mozilla.gecko.sync.repositories.domain.BookmarkRecord;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+import org.mozilla.gecko.sync.synchronizer.Synchronizer;
+import org.mozilla.gecko.sync.synchronizer.SynchronizerDelegate;
+
+import android.content.Context;
+
+public class TestStoreTracking extends AndroidSyncTestCase {
+  public void assertEq(Object expected, Object actual) {
+    try {
+      assertEquals(expected, actual);
+    } catch (AssertionFailedError e) {
+      performNotify(e);
+    }
+  }
+
+  public class TrackingWBORepository extends WBORepository {
+    @Override
+    public synchronized boolean shouldTrack() {
+      return true;
+    }
+  }
+
+  public void doTestStoreRetrieveByGUID(final WBORepository repository,
+                                        final RepositorySession session,
+                                        final String expectedGUID,
+                                        final Record record) {
+
+    final SimpleSuccessStoreDelegate storeDelegate = new SimpleSuccessStoreDelegate() {
+
+      @Override
+      public void onRecordStoreSucceeded(String guid) {
+        Logger.debug(getName(), "Stored " + guid);
+        assertEq(expectedGUID, guid);
+      }
+
+      @Override
+      public void onStoreCompleted(long storeEnd) {
+        Logger.debug(getName(), "Store completed at " + storeEnd + ".");
+        try {
+          session.fetch(new String[] { expectedGUID }, new SimpleSuccessFetchDelegate() {
+            @Override
+            public void onFetchedRecord(Record record) {
+              Logger.debug(getName(), "Hurrah! Fetched record " + record.guid);
+              assertEq(expectedGUID, record.guid);
+            }
+
+            @Override
+            public void onFetchCompleted(final long fetchEnd) {
+              Logger.debug(getName(), "Fetch completed at " + fetchEnd + ".");
+
+              // But fetching by time returns nothing.
+              session.fetchSince(0, new SimpleSuccessFetchDelegate() {
+                private AtomicBoolean fetched = new AtomicBoolean(false);
+
+                @Override
+                public void onFetchedRecord(Record record) {
+                  Logger.debug(getName(), "Fetched record " + record.guid);
+                  fetched.set(true);
+                  performNotify(new AssertionFailedError("Should have fetched no record!"));
+                }
+
+                @Override
+                public void onFetchCompleted(final long fetchEnd) {
+                  if (fetched.get()) {
+                    Logger.debug(getName(), "Not finishing session: record retrieved.");
+                    return;
+                  }
+                  try {
+                    session.finish(new SimpleSuccessFinishDelegate() {
+                      @Override
+                      public void onFinishSucceeded(RepositorySession session,
+                                                    RepositorySessionBundle bundle) {
+                        performNotify();
+                      }
+                    });
+                  } catch (InactiveSessionException e) {
+                    performNotify(e);
+                  }
+                }
+              });
+            }
+          });
+        } catch (InactiveSessionException e) {
+          performNotify(e);
+        }
+      }
+    };
+
+    session.setStoreDelegate(storeDelegate);
+    try {
+      Logger.debug(getName(), "Storing...");
+      session.store(record);
+      session.storeDone();
+    } catch (NoStoreDelegateException e) {
+      // Should not happen.
+    }
+  }
+
+  private void doTestNewSessionRetrieveByTime(final WBORepository repository,
+                                              final String expectedGUID) {
+    final SimpleSuccessCreationDelegate createDelegate = new SimpleSuccessCreationDelegate() {
+      @Override
+      public void onSessionCreated(final RepositorySession session) {
+        Logger.debug(getName(), "Session created.");
+        try {
+          session.begin(new SimpleSuccessBeginDelegate() {
+            @Override
+            public void onBeginSucceeded(final RepositorySession session) {
+              // Now we get a result.
+              session.fetchSince(0, new SimpleSuccessFetchDelegate() {
+
+                @Override
+                public void onFetchedRecord(Record record) {
+                  assertEq(expectedGUID, record.guid);
+                }
+
+                @Override
+                public void onFetchCompleted(long end) {
+                  try {
+                    session.finish(new SimpleSuccessFinishDelegate() {
+                      @Override
+                      public void onFinishSucceeded(RepositorySession session,
+                                                    RepositorySessionBundle bundle) {
+                        // Hooray!
+                        performNotify();
+                      }
+                    });
+                  } catch (InactiveSessionException e) {
+                    performNotify(e);
+                  }
+                }
+              });
+            }
+          });
+        } catch (InvalidSessionTransitionException e) {
+          performNotify(e);
+        }
+      }
+    };
+    Runnable create = new Runnable() {
+      @Override
+      public void run() {
+        repository.createSession(createDelegate, getApplicationContext());
+      }
+    };
+
+    performWait(create);
+  }
+
+  /**
+   * Store a record in one session. Verify that fetching by GUID returns
+   * the record. Verify that fetching by timestamp fails to return records.
+   * Start a new session. Verify that fetching by timestamp returns the
+   * stored record.
+   *
+   * Invokes doTestStoreRetrieveByGUID, doTestNewSessionRetrieveByTime.
+   */
+  public void testStoreRetrieveByGUID() {
+    Logger.debug(getName(), "Started.");
+    final WBORepository r = new TrackingWBORepository();
+    final long now = System.currentTimeMillis();
+    final String expectedGUID = "abcdefghijkl";
+    final Record record = new BookmarkRecord(expectedGUID, "bookmarks", now , false);
+
+    final RepositorySessionCreationDelegate createDelegate = new SimpleSuccessCreationDelegate() {
+      @Override
+      public void onSessionCreated(RepositorySession session) {
+        Logger.debug(getName(), "Session created: " + session);
+        try {
+          session.begin(new SimpleSuccessBeginDelegate() {
+            @Override
+            public void onBeginSucceeded(final RepositorySession session) {
+              doTestStoreRetrieveByGUID(r, session, expectedGUID, record);
+            }
+          });
+        } catch (InvalidSessionTransitionException e) {
+          performNotify(e);
+        }
+      }
+    };
+
+    final Context applicationContext = getApplicationContext();
+
+    // This has to happen on a new thread so that we
+    // can wait for it!
+    Runnable create = onThreadRunnable(new Runnable() {
+      @Override
+      public void run() {
+        r.createSession(createDelegate, applicationContext);
+      }
+    });
+
+    Runnable retrieve = onThreadRunnable(new Runnable() {
+      @Override
+      public void run() {
+        doTestNewSessionRetrieveByTime(r, expectedGUID);
+        performNotify();
+      }
+    });
+
+    performWait(create);
+    performWait(retrieve);
+  }
+
+  private Runnable onThreadRunnable(final Runnable r) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        new Thread(r).start();
+      }
+    };
+  }
+
+
+  public class CountingWBORepository extends TrackingWBORepository {
+    public AtomicLong counter = new AtomicLong(0L);
+    public class CountingWBORepositorySession extends WBORepositorySession {
+      private static final String LOG_TAG = "CountingRepoSession";
+
+      public CountingWBORepositorySession(WBORepository repository) {
+        super(repository);
+      }
+
+      @Override
+      public void store(final Record record) throws NoStoreDelegateException {
+        Logger.debug(LOG_TAG, "Counter now " + counter.incrementAndGet());
+        super.store(record);
+      }
+    }
+
+    @Override
+    public void createSession(RepositorySessionCreationDelegate delegate,
+                              Context context) {
+      delegate.deferredCreationDelegate().onSessionCreated(new CountingWBORepositorySession(this));
+    }
+  }
+
+  public class TestRecord extends Record {
+    public TestRecord(String guid, String collection, long lastModified,
+                      boolean deleted) {
+      super(guid, collection, lastModified, deleted);
+    }
+
+    @Override
+    public void initFromEnvelope(CryptoRecord payload) {
+      return;
+    }
+
+    @Override
+    public CryptoRecord getEnvelope() {
+      return null;
+    }
+
+    @Override
+    protected void populatePayload(ExtendedJSONObject payload) {
+    }
+
+    @Override
+    protected void initFromPayload(ExtendedJSONObject payload) {
+    }
+
+    @Override
+    public Record copyWithIDs(String guid, long androidID) {
+      return new TestRecord(guid, this.collection, this.lastModified, this.deleted);
+    }
+  }
+
+  /**
+   * Create two repositories, syncing from one to the other. Ensure
+   * that records stored from one aren't re-uploaded.
+   */
+  public void testStoreBetweenRepositories() {
+    final CountingWBORepository repoA = new CountingWBORepository();    // "Remote". First source.
+    final CountingWBORepository repoB = new CountingWBORepository();    // "Local". First sink.
+    long now = System.currentTimeMillis();
+
+    TestRecord recordA1 = new TestRecord("aacdefghiaaa", "coll", now - 30, false);
+    TestRecord recordA2 = new TestRecord("aacdefghibbb", "coll", now - 20, false);
+    TestRecord recordB1 = new TestRecord("aacdefghiaaa", "coll", now - 10, false);
+    TestRecord recordB2 = new TestRecord("aacdefghibbb", "coll", now - 40, false);
+
+    TestRecord recordA3 = new TestRecord("nncdefghibbb", "coll", now, false);
+    TestRecord recordB3 = new TestRecord("nncdefghiaaa", "coll", now, false);
+
+    // A1 and B1 are the same, but B's version is newer. We expect A1 to be downloaded
+    // and B1 to be uploaded.
+    // A2 and B2 are the same, but A's version is newer. We expect A2 to be downloaded
+    // and B2 to not be uploaded.
+    // Both A3 and B3 are new. We expect them to go in each direction.
+    // Expected counts, then:
+    // Repo A: B1 + B3
+    // Repo B: A1 + A2 + A3
+    repoB.wbos.put(recordB1.guid, recordB1);
+    repoB.wbos.put(recordB2.guid, recordB2);
+    repoB.wbos.put(recordB3.guid, recordB3);
+    repoA.wbos.put(recordA1.guid, recordA1);
+    repoA.wbos.put(recordA2.guid, recordA2);
+    repoA.wbos.put(recordA3.guid, recordA3);
+
+    final Synchronizer s = new Synchronizer();
+    s.repositoryA = repoA;
+    s.repositoryB = repoB;
+
+    Runnable r = new Runnable() {
+      @Override
+      public void run() {
+        s.synchronize(getApplicationContext(), new SynchronizerDelegate() {
+
+          @Override
+          public void onSynchronized(Synchronizer synchronizer) {
+            long countA = repoA.counter.get();
+            long countB = repoB.counter.get();
+            Logger.debug(getName(), "Counts: " + countA + ", " + countB);
+            assertEq(2L, countA);
+            assertEq(3L, countB);
+
+            // Testing for store timestamp 'hack'.
+            // We fetched from A first, and so its bundle timestamp will be the last
+            // stored time. We fetched from B second, so its bundle timestamp will be
+            // the last fetched time.
+            final long timestampA = synchronizer.bundleA.getTimestamp();
+            final long timestampB = synchronizer.bundleB.getTimestamp();
+            Logger.debug(getName(), "Repo A timestamp: " + timestampA);
+            Logger.debug(getName(), "Repo B timestamp: " + timestampB);
+            Logger.debug(getName(), "Repo A fetch done: " + repoA.stats.fetchCompleted);
+            Logger.debug(getName(), "Repo A store done: " + repoA.stats.storeCompleted);
+            Logger.debug(getName(), "Repo B fetch done: " + repoB.stats.fetchCompleted);
+            Logger.debug(getName(), "Repo B store done: " + repoB.stats.storeCompleted);
+
+            assertTrue(timestampB <= timestampA);
+            assertTrue(repoA.stats.fetchCompleted <= timestampA);
+            assertTrue(repoA.stats.storeCompleted >= repoA.stats.fetchCompleted);
+            assertEquals(repoA.stats.storeCompleted, timestampA);
+            assertEquals(repoB.stats.fetchCompleted, timestampB);
+            performNotify();
+          }
+
+          @Override
+          public void onSynchronizeFailed(Synchronizer synchronizer,
+                                          Exception lastException, String reason) {
+            Logger.debug(getName(), "Failed.");
+            performNotify(new AssertionFailedError("Should not fail."));
+          }
+        });
+      }
+    };
+
+    performWait(onThreadRunnable(r));
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestSyncConfiguration.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestSyncConfiguration.java
new file mode 100644
index 000000000..389aaf891
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestSyncConfiguration.java
@@ -0,0 +1,146 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.sync.SyncConfiguration;
+
+import android.content.SharedPreferences;
+
+public class TestSyncConfiguration extends AndroidSyncTestCase {
+  public static final String TEST_PREFS_NAME = "test";
+
+  public SharedPreferences getPrefs(String name, int mode) {
+    return this.getApplicationContext().getSharedPreferences(name, mode);
+  }
+
+  /**
+   * Ensure that declined engines persist through prefs.
+   */
+  public void testDeclinedEngineNames() {
+    SyncConfiguration config = null;
+    SharedPreferences prefs = getPrefs(TEST_PREFS_NAME, 0);
+
+    config = newSyncConfiguration();
+    config.declinedEngineNames = new HashSet<String>();
+    config.declinedEngineNames.add("test1");
+    config.declinedEngineNames.add("test2");
+    config.persistToPrefs();
+    assertTrue(prefs.contains(SyncConfiguration.PREF_DECLINED_ENGINE_NAMES));
+    config = newSyncConfiguration();
+    Set<String> expected = new HashSet<String>();
+    for (String name : new String[] { "test1", "test2" }) {
+      expected.add(name);
+    }
+    assertEquals(expected, config.declinedEngineNames);
+
+    config.declinedEngineNames = null;
+    config.persistToPrefs();
+    assertFalse(prefs.contains(SyncConfiguration.PREF_DECLINED_ENGINE_NAMES));
+    config = newSyncConfiguration();
+    assertNotNull(config.declinedEngineNames);
+    assertTrue(config.declinedEngineNames.isEmpty());
+  }
+
+  public void testEnabledEngineNames() {
+    SyncConfiguration config = null;
+    SharedPreferences prefs = getPrefs(TEST_PREFS_NAME, 0);
+
+    config = newSyncConfiguration();
+    config.enabledEngineNames = new HashSet<String>();
+    config.enabledEngineNames.add("test1");
+    config.enabledEngineNames.add("test2");
+    config.persistToPrefs();
+    assertTrue(prefs.contains(SyncConfiguration.PREF_ENABLED_ENGINE_NAMES));
+    config = newSyncConfiguration();
+    Set<String> expected = new HashSet<String>();
+    for (String name : new String[] { "test1", "test2" }) {
+      expected.add(name);
+    }
+    assertEquals(expected, config.enabledEngineNames);
+
+    config.enabledEngineNames = null;
+    config.persistToPrefs();
+    assertFalse(prefs.contains(SyncConfiguration.PREF_ENABLED_ENGINE_NAMES));
+    config = newSyncConfiguration();
+    assertNull(config.enabledEngineNames);
+  }
+
+  public void testSyncID() {
+    SyncConfiguration config = null;
+    SharedPreferences prefs = getPrefs(TEST_PREFS_NAME, 0);
+
+    config = newSyncConfiguration();
+    config.syncID = "test1";
+    config.persistToPrefs();
+    assertTrue(prefs.contains(SyncConfiguration.PREF_SYNC_ID));
+    config = newSyncConfiguration();
+    assertEquals("test1", config.syncID);
+  }
+
+  public void testStoreSelectedEnginesToPrefs() {
+    SharedPreferences prefs = getPrefs(TEST_PREFS_NAME, 0);
+    // Store engines, excluding history/forms special case.
+    Map<String, Boolean> expectedEngines = new HashMap<String, Boolean>();
+    expectedEngines.put("test1", true);
+    expectedEngines.put("test2", false);
+    expectedEngines.put("test3", true);
+
+    SyncConfiguration.storeSelectedEnginesToPrefs(prefs, expectedEngines);
+
+    // Read values from selectedEngines.
+    assertTrue(prefs.contains(SyncConfiguration.PREF_USER_SELECTED_ENGINES_TO_SYNC));
+    SyncConfiguration config = null;
+    config = newSyncConfiguration();
+    config.loadFromPrefs(prefs);
+    assertEquals(expectedEngines, config.userSelectedEngines);
+  }
+
+  /**
+   * Tests dependency of forms engine on history engine.
+   */
+  public void testSelectedEnginesHistoryAndForms() {
+    SharedPreferences prefs = getPrefs(TEST_PREFS_NAME, 0);
+    // Store engines, excluding history/forms special case.
+    Map<String, Boolean> storedEngines = new HashMap<String, Boolean>();
+    storedEngines.put("history", true);
+
+    SyncConfiguration.storeSelectedEnginesToPrefs(prefs, storedEngines);
+
+    // Expected engines.
+    storedEngines.put("forms", true);
+    // Read values from selectedEngines.
+    assertTrue(prefs.contains(SyncConfiguration.PREF_USER_SELECTED_ENGINES_TO_SYNC));
+    SyncConfiguration config = null;
+    config = newSyncConfiguration();
+    config.loadFromPrefs(prefs);
+    assertEquals(storedEngines, config.userSelectedEngines);
+  }
+
+  public void testsSelectedEnginesNoHistoryNorForms() {
+    SharedPreferences prefs = getPrefs(TEST_PREFS_NAME, 0);
+    // Store engines, excluding history/forms special case.
+    Map<String, Boolean> storedEngines = new HashMap<String, Boolean>();
+    storedEngines.put("forms", true);
+
+    SyncConfiguration.storeSelectedEnginesToPrefs(prefs, storedEngines);
+
+    // Read values from selectedEngines.
+    assertTrue(prefs.contains(SyncConfiguration.PREF_USER_SELECTED_ENGINES_TO_SYNC));
+    SyncConfiguration config = null;
+    config = newSyncConfiguration();
+    config.loadFromPrefs(prefs);
+    // Forms should not be selected if history is not present.
+    assertTrue(config.userSelectedEngines.isEmpty());
+  }
+
+  protected SyncConfiguration newSyncConfiguration() {
+    return new SyncConfiguration(null, null, getPrefs(TEST_PREFS_NAME, 0));
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestWebURLFinder.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestWebURLFinder.java
new file mode 100644
index 000000000..a7ebb71d5
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/TestWebURLFinder.java
@@ -0,0 +1,49 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync;
+
+import java.util.Arrays;
+
+import org.mozilla.gecko.background.helpers.AndroidSyncTestCase;
+import org.mozilla.gecko.sync.setup.activities.WebURLFinder;
+
+/**
+ * These tests are on device because the WebKit APIs are stubs on desktop.
+ */
+public class TestWebURLFinder extends AndroidSyncTestCase {
+  public String find(String string) {
+    return new WebURLFinder(string).bestWebURL();
+  }
+
+  public String find(String[] strings) {
+    return new WebURLFinder(Arrays.asList(strings)).bestWebURL();
+  }
+
+  public void testNoEmail() {
+    assertNull(find("test@test.com"));
+  }
+
+  public void testSchemeFirst() {
+    assertEquals("http://scheme.com", find("test.com http://scheme.com"));
+  }
+
+  public void testFullURL() {
+    assertEquals("http://scheme.com:8080/inner#anchor&arg=1", find("test.com http://scheme.com:8080/inner#anchor&arg=1"));
+  }
+
+  public void testNoScheme() {
+    assertEquals("noscheme.com", find("noscheme.com"));
+  }
+
+  public void testNoBadScheme() {
+    assertNull(find("file:///test javascript:///test.js"));
+  }
+
+  public void testStrings() {
+    assertEquals("http://test.com", find(new String[] { "http://test.com", "noscheme.com" }));
+    assertEquals("http://test.com", find(new String[] { "noschemefirst.com", "http://test.com" }));
+    assertEquals("http://test.com/inner#test", find(new String[] { "noschemefirst.com", "http://test.com/inner#test", "http://second.org/fark" }));
+    assertEquals("http://test.com", find(new String[] { "javascript:///test.js", "http://test.com" }));
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/BookmarkHelpers.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/BookmarkHelpers.java
new file mode 100644
index 000000000..0fcd762f4
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/BookmarkHelpers.java
@@ -0,0 +1,216 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.json.simple.JSONArray;
+import org.mozilla.gecko.sync.Utils;
+import org.mozilla.gecko.sync.repositories.domain.BookmarkRecord;
+
+public class BookmarkHelpers {
+
+  private static String mobileFolderGuid = "mobile";
+  private static String mobileFolderName = "mobile";
+  private static String topFolderGuid = Utils.generateGuid();
+  private static String topFolderName = "My Top Folder";
+  private static String middleFolderGuid = Utils.generateGuid();
+  private static String middleFolderName = "My Middle Folder";
+  private static String bottomFolderGuid = Utils.generateGuid();
+  private static String bottomFolderName = "My Bottom Folder";
+  private static String bmk1Guid = Utils.generateGuid();
+  private static String bmk2Guid = Utils.generateGuid();
+  private static String bmk3Guid = Utils.generateGuid();
+  private static String bmk4Guid = Utils.generateGuid();
+
+  /*
+   * Helpers for creating bookmark records of different types
+   */
+  public static BookmarkRecord createBookmarkInMobileFolder1() {
+    BookmarkRecord rec = createBookmark1();
+    rec.guid = Utils.generateGuid();
+    rec.parentID = mobileFolderGuid;
+    rec.parentName = mobileFolderName;
+    return rec;
+  }
+
+  public static BookmarkRecord createBookmarkInMobileFolder2() {
+    BookmarkRecord rec = createBookmark2();
+    rec.guid = Utils.generateGuid();
+    rec.parentID = mobileFolderGuid;
+    rec.parentName = mobileFolderName;
+    return rec;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static BookmarkRecord createBookmark1() {
+    BookmarkRecord record = new BookmarkRecord();
+    JSONArray tags = new JSONArray();
+    tags.add("tag1");
+    tags.add("tag2");
+    tags.add("tag3");
+    record.guid = bmk1Guid;
+    record.title = "Foo!!!";
+    record.bookmarkURI = "http://foo.bar.com";
+    record.description = "This is a description for foo.bar.com";
+    record.tags = tags;
+    record.keyword = "fooooozzzzz";
+    record.parentID = topFolderGuid;
+    record.parentName = topFolderName;
+    record.type = "bookmark";
+    return record;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static BookmarkRecord createBookmark2() {
+    BookmarkRecord record = new BookmarkRecord();
+    JSONArray tags = new JSONArray();
+    tags.add("tag1");
+    tags.add("tag2");
+    record.guid = bmk2Guid;
+    record.title = "Bar???";
+    record.bookmarkURI = "http://bar.foo.com";
+    record.description = "This is a description for Bar???";
+    record.tags = tags;
+    record.keyword = "keywordzzz";
+    record.parentID = topFolderGuid;
+    record.parentName = topFolderName;
+    record.type = "bookmark";
+    return record;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static BookmarkRecord createBookmark3() {
+    BookmarkRecord record = new BookmarkRecord();
+    JSONArray tags = new JSONArray();
+    tags.add("tag1");
+    tags.add("tag2");
+    record.guid = bmk3Guid;
+    record.title = "Bmk3";
+    record.bookmarkURI = "http://bmk3.com";
+    record.description = "This is a description for bmk3";
+    record.tags = tags;
+    record.keyword = "snooozzz";
+    record.parentID = middleFolderGuid;
+    record.parentName = middleFolderName;
+    record.type = "bookmark";
+    return record;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static BookmarkRecord createBookmark4() {
+    BookmarkRecord record = new BookmarkRecord();
+    JSONArray tags = new JSONArray();
+    tags.add("tag1");
+    tags.add("tag2");
+    record.guid = bmk4Guid;
+    record.title = "Bmk4";
+    record.bookmarkURI = "http://bmk4.com";
+    record.description = "This is a description for bmk4?";
+    record.tags = tags;
+    record.keyword = "booooozzz";
+    record.parentID = bottomFolderGuid;
+    record.parentName = bottomFolderName;
+    record.type = "bookmark";
+    return record;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static BookmarkRecord createMicrosummary() {
+    BookmarkRecord record = new BookmarkRecord();
+    JSONArray tags = new JSONArray();
+    tags.add("tag1");
+    tags.add("tag2");
+    record.guid = Utils.generateGuid();
+    record.title = "Microsummary 1";
+    record.bookmarkURI = "www.bmkuri.com";
+    record.description = "microsummary description";
+    record.tags = tags;
+    record.keyword = "keywordzzz";
+    record.parentID = topFolderGuid;
+    record.parentName = topFolderName;
+    record.type = "microsummary";
+    return record;
+  }
+
+  public static BookmarkRecord createQuery() {
+    BookmarkRecord record = new BookmarkRecord();
+    record.guid = Utils.generateGuid();
+    record.title = "Query 1";
+    record.bookmarkURI = "http://www.query.com";
+    record.description = "Query 1 description";
+    record.tags = new JSONArray();
+    record.keyword = "queryKeyword";
+    record.parentID = topFolderGuid;
+    record.parentName = topFolderName;
+    record.type = "query";
+    return record;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static BookmarkRecord createFolder1() {
+    BookmarkRecord record = new BookmarkRecord();
+    record.guid = topFolderGuid;
+    record.title = topFolderName;
+    record.parentID = "mobile";
+    record.parentName = "mobile";
+    JSONArray children = new JSONArray();
+    children.add(bmk1Guid);
+    children.add(bmk2Guid);
+    record.children = children;
+    record.type = "folder";
+    return record;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static BookmarkRecord createFolder2() {
+    BookmarkRecord record = new BookmarkRecord();
+    record.guid = middleFolderGuid;
+    record.title = middleFolderName;
+    record.parentID = topFolderGuid;
+    record.parentName = topFolderName;
+    JSONArray children = new JSONArray();
+    children.add(bmk3Guid);
+    record.children = children;
+    record.type = "folder";
+    return record;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static BookmarkRecord createFolder3() {
+    BookmarkRecord record = new BookmarkRecord();
+    record.guid = bottomFolderGuid;
+    record.title = bottomFolderName;
+    record.parentID = middleFolderGuid;
+    record.parentName = middleFolderName;
+    JSONArray children = new JSONArray();
+    children.add(bmk4Guid);
+    record.children = children;
+    record.type = "folder";
+    return record;
+  }
+
+  @SuppressWarnings("unchecked")
+  public static BookmarkRecord createLivemark() {
+    BookmarkRecord record = new BookmarkRecord();
+    record.guid = Utils.generateGuid();
+    record.title = "Livemark title";
+    record.parentID = topFolderGuid;
+    record.parentName = topFolderName;
+    JSONArray children = new JSONArray();
+    children.add(Utils.generateGuid());
+    children.add(Utils.generateGuid());
+    record.children = children;
+    record.type = "livemark";
+    return record;
+  }
+
+  public static BookmarkRecord createSeparator() {
+    BookmarkRecord record = new BookmarkRecord();
+    record.guid = Utils.generateGuid();
+    record.androidPosition = 3;
+    record.parentID = topFolderGuid;
+    record.parentName = topFolderName;
+    record.type = "separator";
+    return record;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultBeginDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultBeginDelegate.java
new file mode 100644
index 000000000..67aa81fff
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultBeginDelegate.java
@@ -0,0 +1,33 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import java.util.concurrent.ExecutorService;
+
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionBeginDelegate;
+
+public class DefaultBeginDelegate extends DefaultDelegate implements RepositorySessionBeginDelegate {
+  @Override
+  public void onBeginFailed(Exception ex) {
+    performNotify("Begin failed", ex);
+  }
+
+  @Override
+  public void onBeginSucceeded(RepositorySession session) {
+    performNotify("Default begin delegate hit.", null);
+  }
+
+  @Override
+  public RepositorySessionBeginDelegate deferredBeginDelegate(ExecutorService executor) {
+    DefaultBeginDelegate copy;
+    try {
+      copy = (DefaultBeginDelegate) this.clone();
+      copy.executor = executor;
+      return copy;
+    } catch (CloneNotSupportedException e) {
+      return this;
+    }
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultCleanDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultCleanDelegate.java
new file mode 100644
index 000000000..a1f5b7a97
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultCleanDelegate.java
@@ -0,0 +1,21 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.mozilla.gecko.sync.repositories.Repository;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCleanDelegate;
+
+public class DefaultCleanDelegate extends DefaultDelegate implements RepositorySessionCleanDelegate {
+
+  @Override
+  public void onCleaned(Repository repo) {
+    performNotify("Default begin delegate hit.", null);
+  }
+
+  @Override
+  public void onCleanFailed(Repository repo, Exception ex) {
+    performNotify("Clean failed.", ex);
+  }
+
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultDelegate.java
new file mode 100644
index 000000000..7e9341f02
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultDelegate.java
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import java.util.concurrent.ExecutorService;
+
+import junit.framework.AssertionFailedError;
+
+import org.mozilla.gecko.background.testhelpers.WaitHelper;
+
+public abstract class DefaultDelegate {
+  protected ExecutorService executor;
+
+  protected final WaitHelper waitHelper;
+
+  public DefaultDelegate() {
+    waitHelper = WaitHelper.getTestWaiter();
+  }
+
+  public DefaultDelegate(WaitHelper waitHelper) {
+    this.waitHelper = waitHelper;
+  }
+
+  protected WaitHelper getTestWaiter() {
+    return waitHelper;
+  }
+
+  public void performWait(Runnable runnable) throws AssertionFailedError {
+    getTestWaiter().performWait(runnable);
+  }
+
+  public void performNotify() {
+    getTestWaiter().performNotify();
+  }
+
+  public void performNotify(Throwable e) {
+    getTestWaiter().performNotify(e);
+  }
+
+  public void performNotify(String reason, Throwable e) {
+    String message = reason;
+    if (e != null) {
+      message += ": " + e.getMessage();
+    }
+    AssertionFailedError ex = new AssertionFailedError(message);
+    if (e != null) {
+      ex.initCause(e);
+    }
+    getTestWaiter().performNotify(ex);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultFetchDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultFetchDelegate.java
new file mode 100644
index 000000000..3d7d23bab
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultFetchDelegate.java
@@ -0,0 +1,106 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertTrue;
+import static junit.framework.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+
+import junit.framework.AssertionFailedError;
+
+import org.mozilla.gecko.background.common.log.Logger;
+import org.mozilla.gecko.sync.repositories.delegates.DeferredRepositorySessionFetchRecordsDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionFetchRecordsDelegate;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+public class DefaultFetchDelegate extends DefaultDelegate implements RepositorySessionFetchRecordsDelegate {
+
+  private static final String LOG_TAG = "DefaultFetchDelegate";
+  public ArrayList<Record> records = new ArrayList<Record>();
+  public Set<String> ignore = new HashSet<String>();
+
+  @Override
+  public void onFetchFailed(Exception ex, Record record) {
+    performNotify("Fetch failed.", ex);
+  }
+
+  protected void onDone(ArrayList<Record> records, HashMap<String, Record> expected, long end) {
+    Logger.debug(LOG_TAG, "onDone.");
+    Logger.debug(LOG_TAG, "End timestamp is " + end);
+    Logger.debug(LOG_TAG, "Expected is " + expected);
+    Logger.debug(LOG_TAG, "Records is " + records);
+    Set<String> foundGuids = new HashSet<String>();
+    try {
+      int expectedCount = 0;
+      int expectedFound = 0;
+      Logger.debug(LOG_TAG, "Counting expected keys.");
+      for (String key : expected.keySet()) {
+        if (!ignore.contains(key)) {
+          expectedCount++;
+        }
+      }
+      Logger.debug(LOG_TAG, "Expected keys: " + expectedCount);
+      for (Record record : records) {
+        Logger.debug(LOG_TAG, "Record.");
+        Logger.debug(LOG_TAG, record.guid);
+
+        // Ignore special GUIDs (e.g., for bookmarks).
+        if (!ignore.contains(record.guid)) {
+          if (foundGuids.contains(record.guid)) {
+            fail("Found duplicate guid " + record.guid);
+          }
+          Record expect = expected.get(record.guid);
+          if (expect == null) {
+            fail("Do not expect to get back a record with guid: " + record.guid); // Caught below
+          }
+          Logger.debug(LOG_TAG, "Checking equality.");
+          try {
+            assertTrue(expect.equalPayloads(record)); // Caught below
+          } catch (Exception e) {
+            Logger.error(LOG_TAG, "ONOZ!", e);
+          }
+          Logger.debug(LOG_TAG, "Checked equality.");
+          expectedFound += 1;
+          // Track record once we've found it.
+          foundGuids.add(record.guid);
+        }
+      }
+      assertEquals(expectedCount, expectedFound); // Caught below
+      Logger.debug(LOG_TAG, "Notifying success.");
+      performNotify();
+    } catch (AssertionFailedError e) {
+      Logger.error(LOG_TAG, "Notifying assertion failure.");
+      performNotify(e);
+    } catch (Exception e) {
+      Logger.error(LOG_TAG, "No!");
+      performNotify();
+    }
+  }
+
+  public int recordCount() {
+    return (this.records == null) ? 0 : this.records.size();
+  }
+
+  @Override
+  public void onFetchedRecord(Record record) {
+    Logger.debug(LOG_TAG, "onFetchedRecord(" + record.guid + ")");
+    records.add(record);
+  }
+
+  @Override
+  public void onFetchCompleted(final long fetchEnd) {
+    Logger.debug(LOG_TAG, "onFetchCompleted. Doing nothing.");
+  }
+
+  @Override
+  public RepositorySessionFetchRecordsDelegate deferredFetchDelegate(final ExecutorService executor) {
+    return new DeferredRepositorySessionFetchRecordsDelegate(this, executor);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultFinishDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultFinishDelegate.java
new file mode 100644
index 000000000..11e451e82
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultFinishDelegate.java
@@ -0,0 +1,60 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import java.util.concurrent.ExecutorService;
+
+import org.mozilla.gecko.background.common.log.Logger;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.RepositorySessionBundle;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionFinishDelegate;
+
+public class DefaultFinishDelegate extends DefaultDelegate implements RepositorySessionFinishDelegate {
+
+  @Override
+  public void onFinishFailed(Exception ex) {
+    performNotify("Finish failed", ex);
+  }
+
+  @Override
+  public void onFinishSucceeded(RepositorySession session, RepositorySessionBundle bundle) {
+    performNotify("Hit default finish delegate", null);
+  }
+
+  @Override
+  public RepositorySessionFinishDelegate deferredFinishDelegate(final ExecutorService executor) {
+    final RepositorySessionFinishDelegate self = this;
+
+    Logger.info("DefaultFinishDelegate", "Deferring…");
+    return new RepositorySessionFinishDelegate() {
+      @Override
+      public void onFinishSucceeded(final RepositorySession session,
+                                    final RepositorySessionBundle bundle) {
+        Logger.info("DefaultFinishDelegate", "Executing onFinishSucceeded Runnable…");
+        executor.execute(new Runnable() {
+          @Override
+          public void run() {
+            self.onFinishSucceeded(session, bundle);
+          }});
+      }
+
+      @Override
+      public void onFinishFailed(final Exception ex) {
+        executor.execute(new Runnable() {
+          @Override
+          public void run() {
+            self.onFinishFailed(ex);
+          }});
+      }
+
+      @Override
+      public RepositorySessionFinishDelegate deferredFinishDelegate(ExecutorService newExecutor) {
+        if (newExecutor == executor) {
+          return this;
+        }
+        throw new IllegalArgumentException("Can't re-defer this delegate.");
+      }
+    };
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultGuidsSinceDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultGuidsSinceDelegate.java
new file mode 100644
index 000000000..78e3cc84f
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultGuidsSinceDelegate.java
@@ -0,0 +1,19 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionGuidsSinceDelegate;
+
+public class DefaultGuidsSinceDelegate extends DefaultDelegate implements RepositorySessionGuidsSinceDelegate {
+
+  @Override
+  public void onGuidsSinceFailed(Exception ex) {
+    performNotify("shouldn't fail", ex);
+  }
+
+  @Override
+  public void onGuidsSinceSucceeded(String[] guids) {
+    performNotify("default guids since delegate called", null);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultSessionCreationDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultSessionCreationDelegate.java
new file mode 100644
index 000000000..5d52df84d
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultSessionCreationDelegate.java
@@ -0,0 +1,53 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
+
+public class DefaultSessionCreationDelegate extends DefaultDelegate implements
+    RepositorySessionCreationDelegate {
+
+  @Override
+  public void onSessionCreateFailed(Exception ex) {
+    performNotify("Session creation failed", ex);
+  }
+
+  @Override
+  public void onSessionCreated(RepositorySession session) {
+    performNotify("Should not have been created.", null);
+  }
+
+  @Override
+  public RepositorySessionCreationDelegate deferredCreationDelegate() {
+    final RepositorySessionCreationDelegate self = this;
+    return new RepositorySessionCreationDelegate() {
+
+      @Override
+      public void onSessionCreated(final RepositorySession session) {
+        new Thread(new Runnable() {
+          @Override
+          public void run() {
+            self.onSessionCreated(session);
+          }
+        }).start();
+      }
+
+      @Override
+      public void onSessionCreateFailed(final Exception ex) {
+        new Thread(new Runnable() {
+          @Override
+          public void run() {
+            self.onSessionCreateFailed(ex);
+          }
+        }).start();
+      }
+
+      @Override
+      public RepositorySessionCreationDelegate deferredCreationDelegate() {
+        return this;
+      }
+    };
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultStoreDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultStoreDelegate.java
new file mode 100644
index 000000000..7ba2e6df6
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/DefaultStoreDelegate.java
@@ -0,0 +1,71 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import java.util.concurrent.ExecutorService;
+
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionStoreDelegate;
+
+public class DefaultStoreDelegate extends DefaultDelegate implements RepositorySessionStoreDelegate {
+
+  @Override
+  public void onRecordStoreFailed(Exception ex, String guid) {
+    performNotify("Store failed", ex);
+  }
+
+  @Override
+  public void onRecordStoreSucceeded(String guid) {
+    performNotify("DefaultStoreDelegate used", null);
+  }
+
+  @Override
+  public void onStoreCompleted(long storeEnd) {
+    performNotify("DefaultStoreDelegate used", null);
+  }
+
+  @Override
+  public RepositorySessionStoreDelegate deferredStoreDelegate(final ExecutorService executor) {
+    final RepositorySessionStoreDelegate self = this;
+    return new RepositorySessionStoreDelegate() {
+
+      @Override
+      public void onRecordStoreSucceeded(final String guid) {
+        executor.execute(new Runnable() {
+          @Override
+          public void run() {
+            self.onRecordStoreSucceeded(guid);
+          }
+        });
+      }
+
+      @Override
+      public void onRecordStoreFailed(final Exception ex, final String guid) {
+        executor.execute(new Runnable() {
+          @Override
+          public void run() {
+            self.onRecordStoreFailed(ex, guid);
+          }
+        });
+      }
+
+      @Override
+      public void onStoreCompleted(final long storeEnd) {
+        executor.execute(new Runnable() {
+          @Override
+          public void run() {
+            self.onStoreCompleted(storeEnd);
+          }
+        });
+      }
+
+      @Override
+      public RepositorySessionStoreDelegate deferredStoreDelegate(ExecutorService newExecutor) {
+        if (newExecutor == executor) {
+          return this;
+        }
+        throw new IllegalArgumentException("Can't re-defer this delegate.");
+      }
+    };
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectBeginDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectBeginDelegate.java
new file mode 100644
index 000000000..d320cfd7a
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectBeginDelegate.java
@@ -0,0 +1,22 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import static junit.framework.Assert.assertNotNull;
+import junit.framework.AssertionFailedError;
+
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+
+public class ExpectBeginDelegate extends DefaultBeginDelegate {
+  @Override
+  public void onBeginSucceeded(RepositorySession session) {
+    try {
+      assertNotNull(session);
+    } catch (AssertionFailedError e) {
+      performNotify("Expected non-null session", e);
+      return;
+    }
+    performNotify();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectBeginFailDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectBeginFailDelegate.java
new file mode 100644
index 000000000..ff1807d51
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectBeginFailDelegate.java
@@ -0,0 +1,16 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.mozilla.gecko.sync.repositories.InvalidSessionTransitionException;
+
+public class ExpectBeginFailDelegate extends DefaultBeginDelegate {
+
+  @Override
+  public void onBeginFailed(Exception ex) {
+    if (!(ex instanceof InvalidSessionTransitionException)) {
+      performNotify("Expected InvalidSessionTransititionException but got ", ex);
+    }
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFetchDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFetchDelegate.java
new file mode 100644
index 000000000..5cfe5327a
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFetchDelegate.java
@@ -0,0 +1,32 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import java.util.HashMap;
+
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+public class ExpectFetchDelegate extends DefaultFetchDelegate {
+  private HashMap<String, Record> expect = new HashMap<String, Record>();
+
+  public ExpectFetchDelegate(Record[] records) {
+    for(int i = 0; i < records.length; i++) {
+      expect.put(records[i].guid, records[i]);
+    }
+  }
+
+  @Override
+  public void onFetchedRecord(Record record) {
+    this.records.add(record);
+  }
+
+  @Override
+  public void onFetchCompleted(final long fetchEnd) {
+    super.onDone(this.records, this.expect, fetchEnd);
+  }
+
+  public Record recordAt(int i) {
+    return this.records.get(i);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFetchSinceDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFetchSinceDelegate.java
new file mode 100644
index 000000000..7dcada0d4
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFetchSinceDelegate.java
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.Arrays;
+
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+import junit.framework.AssertionFailedError;
+
+public class ExpectFetchSinceDelegate extends DefaultFetchDelegate {
+  private String[] expected;
+  private long earliest;
+
+  public ExpectFetchSinceDelegate(long timestamp, String[] guids) {
+    expected = guids;
+    earliest = timestamp;
+    Arrays.sort(expected);
+  }
+
+  @Override
+  public void onFetchCompleted(final long fetchEnd) {
+    AssertionFailedError err = null;
+    try {
+      int countSpecials = 0;
+      for (Record record : records) {
+        // Check if record should be ignored.
+        if (!ignore.contains(record.guid)) {
+          assertFalse(-1 == Arrays.binarySearch(this.expected, record.guid));
+        } else {
+          countSpecials++;
+        }
+        // Check that record is later than timestamp-earliest.
+        assertTrue(record.lastModified >= this.earliest);
+      }
+      assertEquals(this.expected.length, records.size() - countSpecials);
+    } catch (AssertionFailedError e) {
+      err = e;
+    }
+    performNotify(err);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFinishDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFinishDelegate.java
new file mode 100644
index 000000000..0b6f1de88
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFinishDelegate.java
@@ -0,0 +1,17 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.mozilla.gecko.background.common.log.Logger;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+import org.mozilla.gecko.sync.repositories.RepositorySessionBundle;
+
+public class ExpectFinishDelegate extends DefaultFinishDelegate {
+
+  @Override
+  public void onFinishSucceeded(RepositorySession session, RepositorySessionBundle bundle) {
+    Logger.info("ExpectFinishDelegate", "Finish succeeded.");
+    performNotify();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFinishFailDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFinishFailDelegate.java
new file mode 100644
index 000000000..df83432bc
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectFinishFailDelegate.java
@@ -0,0 +1,15 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.mozilla.gecko.sync.repositories.InvalidSessionTransitionException;
+
+public class ExpectFinishFailDelegate extends DefaultFinishDelegate {
+  @Override
+  public void onFinishFailed(Exception ex) {
+    if (!(ex instanceof InvalidSessionTransitionException)) {
+      performNotify("Expected InvalidSessionTransititionException but got ", ex);
+    }
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectGuidsSinceDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectGuidsSinceDelegate.java
new file mode 100644
index 000000000..435ba7502
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectGuidsSinceDelegate.java
@@ -0,0 +1,41 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import junit.framework.AssertionFailedError;
+
+public class ExpectGuidsSinceDelegate extends DefaultGuidsSinceDelegate {
+  private String[] expected;
+  public Set<String> ignore = new HashSet<String>();
+
+  public ExpectGuidsSinceDelegate(String[] guids) {
+    expected = guids;
+    Arrays.sort(expected);
+  }
+
+  @Override
+  public void onGuidsSinceSucceeded(String[] guids) {
+    AssertionFailedError err = null;
+    try {
+      int notIgnored = 0;
+      for (String guid : guids) {
+        if (!ignore.contains(guid)) {
+          notIgnored++;
+          assertFalse(-1 == Arrays.binarySearch(this.expected, guid));
+        }
+      }
+      assertEquals(this.expected.length, notIgnored);
+    } catch (AssertionFailedError e) {
+      err = e;
+    }
+    performNotify(err);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectInvalidRequestFetchDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectInvalidRequestFetchDelegate.java
new file mode 100644
index 000000000..73035869c
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectInvalidRequestFetchDelegate.java
@@ -0,0 +1,24 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.mozilla.gecko.sync.repositories.InvalidRequestException;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+public class ExpectInvalidRequestFetchDelegate extends DefaultFetchDelegate {
+  public static final String LOG_TAG = "ExpInvRequestFetchDel";
+
+  @Override
+  public void onFetchFailed(Exception ex, Record rec) {
+    if (ex instanceof InvalidRequestException) {
+      onDone();
+    } else {
+      performNotify("Expected InvalidRequestException but got ", ex);
+    }
+  }
+
+  private void onDone() {
+    performNotify();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectInvalidTypeStoreDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectInvalidTypeStoreDelegate.java
new file mode 100644
index 000000000..5ce56ee5f
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectInvalidTypeStoreDelegate.java
@@ -0,0 +1,18 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import static junit.framework.Assert.assertEquals;
+
+import org.mozilla.gecko.sync.repositories.InvalidBookmarkTypeException;
+
+public class ExpectInvalidTypeStoreDelegate extends DefaultStoreDelegate {
+
+  @Override
+  public void onRecordStoreFailed(Exception ex, String guid) {
+    assertEquals(InvalidBookmarkTypeException.class, ex.getClass());
+    performNotify();
+  }
+
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectManyStoredDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectManyStoredDelegate.java
new file mode 100644
index 000000000..2a8df0228
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectManyStoredDelegate.java
@@ -0,0 +1,48 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.HashSet;
+import java.util.concurrent.atomic.AtomicLong;
+
+import junit.framework.AssertionFailedError;
+
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+public class ExpectManyStoredDelegate extends DefaultStoreDelegate {
+  HashSet<String> expectedGUIDs;
+  AtomicLong stored;
+
+  public ExpectManyStoredDelegate(Record[] records) {
+    HashSet<String> s = new HashSet<String>();
+    for (Record record : records) {
+      s.add(record.guid);
+    }
+    expectedGUIDs = s;
+    stored = new AtomicLong(0);
+  }
+
+  @Override
+  public void onStoreCompleted(long storeEnd) {
+    try {
+      assertEquals(expectedGUIDs.size(), stored.get());
+      performNotify();
+    } catch (AssertionFailedError e) {
+      performNotify(e);
+    }
+  }
+
+  @Override
+  public void onRecordStoreSucceeded(String guid) {
+    try {
+      assertTrue(expectedGUIDs.contains(guid));
+    } catch (AssertionFailedError e) {
+      performNotify(e);
+    }
+    stored.incrementAndGet();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectNoGUIDsSinceDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectNoGUIDsSinceDelegate.java
new file mode 100644
index 000000000..a9f11d7b0
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectNoGUIDsSinceDelegate.java
@@ -0,0 +1,33 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import static junit.framework.Assert.assertEquals;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import junit.framework.AssertionFailedError;
+
+public class ExpectNoGUIDsSinceDelegate extends DefaultGuidsSinceDelegate {
+
+  public Set<String> ignore = new HashSet<String>();
+
+  @Override
+  public void onGuidsSinceSucceeded(String[] guids) {
+    AssertionFailedError err = null;
+    try {
+      int nonIgnored = 0;
+      for (int i = 0; i < guids.length; i++) {
+        if (!ignore.contains(guids[i])) {
+          nonIgnored++;
+        }
+      }
+      assertEquals(0, nonIgnored);
+    } catch (AssertionFailedError e) {
+      err = e;
+    }
+    performNotify(err);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectNoStoreDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectNoStoreDelegate.java
new file mode 100644
index 000000000..93626898e
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectNoStoreDelegate.java
@@ -0,0 +1,11 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+public class ExpectNoStoreDelegate extends ExpectStoreCompletedDelegate {
+    @Override
+    public void onRecordStoreSucceeded(String guid) {
+        performNotify("Should not have stored record " + guid, null);
+    }
+}
\ No newline at end of file
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectStoreCompletedDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectStoreCompletedDelegate.java
new file mode 100644
index 000000000..b3cc909a1
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectStoreCompletedDelegate.java
@@ -0,0 +1,17 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+public class ExpectStoreCompletedDelegate extends DefaultStoreDelegate {
+
+  @Override
+  public void onRecordStoreSucceeded(String guid) {
+    // That's fine.
+  }
+
+  @Override
+  public void onStoreCompleted(long storeEnd) {
+    performNotify();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectStoredDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectStoredDelegate.java
new file mode 100644
index 000000000..dc2e8a2d1
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/ExpectStoredDelegate.java
@@ -0,0 +1,39 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertNotNull;
+import junit.framework.AssertionFailedError;
+
+public class ExpectStoredDelegate extends DefaultStoreDelegate {
+  String expectedGUID;
+  String storedGuid;
+
+  public ExpectStoredDelegate(String guid) {
+    this.expectedGUID = guid;
+  }
+
+  @Override
+  public synchronized void onStoreCompleted(long storeEnd) {
+    try {
+      assertNotNull(storedGuid);
+      performNotify();
+    } catch (AssertionFailedError e) {
+      performNotify("GUID " + this.expectedGUID + " was not stored", e);
+    }
+  }
+
+  @Override
+  public synchronized void onRecordStoreSucceeded(String guid) {
+    this.storedGuid = guid;
+    try {
+      if (this.expectedGUID != null) {
+        assertEquals(this.expectedGUID, guid);
+      }
+    } catch (AssertionFailedError e) {
+      performNotify(e);
+    }
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/HistoryHelpers.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/HistoryHelpers.java
new file mode 100644
index 000000000..68f80043e
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/HistoryHelpers.java
@@ -0,0 +1,90 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.mozilla.gecko.sync.repositories.domain.HistoryRecord;
+
+public class HistoryHelpers {
+
+  @SuppressWarnings("unchecked")
+  private static JSONArray getVisits1() {
+    JSONArray json = new JSONArray();
+    JSONObject obj = new JSONObject();
+    obj.put("date", 1320087601465600000L);
+    obj.put("type", 2L);
+    json.add(obj);
+    obj = new JSONObject();
+    obj.put("date", 1320084970724990000L);
+    obj.put("type", 1L);
+    json.add(obj);
+    obj = new JSONObject();
+    obj.put("date", 1319764134412287000L);
+    obj.put("type", 1L);
+    json.add(obj);
+    obj = new JSONObject();
+    obj.put("date", 1319681306455594000L);
+    obj.put("type", 2L);
+    json.add(obj);
+    return json;
+  }
+
+  @SuppressWarnings("unchecked")
+  private static JSONArray getVisits2() {
+    JSONArray json = new JSONArray();
+    JSONObject obj = new JSONObject();
+    obj = new JSONObject();
+    obj.put("date", 1319764134412345000L);
+    obj.put("type", 4L);
+    json.add(obj);
+    obj = new JSONObject();
+    obj.put("date", 1319681306454321000L);
+    obj.put("type", 3L);
+    json.add(obj);
+    return json;
+  }
+
+  public static HistoryRecord createHistory1() {
+    HistoryRecord record = new HistoryRecord();
+    record.title          = "History 1";
+    record.histURI        = "http://history.page1.com";
+    record.visits         = getVisits1();
+    return record;
+  }
+
+
+  public static HistoryRecord createHistory2() {
+    HistoryRecord record = new HistoryRecord();
+    record.title          = "History 2";
+    record.histURI        = "http://history.page2.com";
+    record.visits         = getVisits2();
+    return record;
+  }
+
+  public static HistoryRecord createHistory3() {
+    HistoryRecord record = new HistoryRecord();
+    record.title          = "History 3";
+    record.histURI        = "http://history.page3.com";
+    record.visits         = getVisits2();
+    return record;
+  }
+
+  public static HistoryRecord createHistory4() {
+    HistoryRecord record = new HistoryRecord();
+    record.title          = "History 4";
+    record.histURI        = "http://history.page4.com";
+    record.visits         = getVisits1();
+    return record;
+  }
+
+  public static HistoryRecord createHistory5() {
+    HistoryRecord record = new HistoryRecord();
+    record.title          = "History 5";
+    record.histURI        = "http://history.page5.com";
+    record.visits         = getVisits2();
+    return record;
+  }
+
+}
\ No newline at end of file
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/PasswordHelpers.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/PasswordHelpers.java
new file mode 100644
index 000000000..87400a2b0
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/PasswordHelpers.java
@@ -0,0 +1,94 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.mozilla.gecko.sync.repositories.domain.PasswordRecord;
+
+public class PasswordHelpers {
+
+  public static PasswordRecord createPassword1() {
+    PasswordRecord rec = new PasswordRecord();
+    rec.encType = "some type";
+    rec.formSubmitURL = "http://submit.html";
+    rec.hostname = "http://hostname";
+    rec.httpRealm = "httpRealm";
+    rec.encryptedPassword ="12345";
+    rec.passwordField = "box.pass.field";
+    rec.timeCreated = 111111111L;
+    rec.timeLastUsed = 123412352435L;
+    rec.timePasswordChanged = 121111111L;
+    rec.timesUsed = 5L;
+    rec.encryptedUsername = "jvoll";
+    rec.usernameField = "box.user.field";
+    return rec;
+  }
+
+  public static PasswordRecord createPassword2() {
+    PasswordRecord rec = new PasswordRecord();
+    rec.encType = "some type";
+    rec.formSubmitURL = "http://submit2.html";
+    rec.hostname = "http://hostname2";
+    rec.httpRealm = "httpRealm2";
+    rec.encryptedPassword ="54321";
+    rec.passwordField = "box.pass.field2";
+    rec.timeCreated = 12111111111L;
+    rec.timeLastUsed = 123412352213L;
+    rec.timePasswordChanged = 123111111111L;
+    rec.timesUsed = 2L;
+    rec.encryptedUsername = "rnewman";
+    rec.usernameField = "box.user.field2";
+    return rec;
+  }
+
+  public static PasswordRecord createPassword3() {
+    PasswordRecord rec = new PasswordRecord();
+    rec.encType = "some type3";
+    rec.formSubmitURL = "http://submit3.html";
+    rec.hostname = "http://hostname3";
+    rec.httpRealm = "httpRealm3";
+    rec.encryptedPassword ="54321";
+    rec.passwordField = "box.pass.field3";
+    rec.timeCreated = 100000000000L;
+    rec.timeLastUsed = 123412352213L;
+    rec.timePasswordChanged = 110000000000L;
+    rec.timesUsed = 2L;
+    rec.encryptedUsername = "rnewman";
+    rec.usernameField = "box.user.field3";
+    return rec;
+  }
+
+  public static PasswordRecord createPassword4() {
+    PasswordRecord rec = new PasswordRecord();
+    rec.encType = "some type";
+    rec.formSubmitURL = "http://submit4.html";
+    rec.hostname = "http://hostname4";
+    rec.httpRealm = "httpRealm4";
+    rec.encryptedPassword ="54324";
+    rec.passwordField = "box.pass.field4";
+    rec.timeCreated = 101000000000L;
+    rec.timeLastUsed = 123412354444L;
+    rec.timePasswordChanged = 110000000000L;
+    rec.timesUsed = 4L;
+    rec.encryptedUsername = "rnewman4";
+    rec.usernameField = "box.user.field4";
+    return rec;
+  }
+
+  public static PasswordRecord createPassword5() {
+    PasswordRecord rec = new PasswordRecord();
+    rec.encType = "some type5";
+    rec.formSubmitURL = "http://submit5.html";
+    rec.hostname = "http://hostname5";
+    rec.httpRealm = "httpRealm5";
+    rec.encryptedPassword ="54325";
+    rec.passwordField = "box.pass.field5";
+    rec.timeCreated = 101000000000L;
+    rec.timeLastUsed = 123412352555L;
+    rec.timePasswordChanged = 111111111111L;
+    rec.timesUsed = 5L;
+    rec.encryptedUsername = "jvoll5";
+    rec.usernameField = "box.user.field5";
+    return rec;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SessionTestHelper.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SessionTestHelper.java
new file mode 100644
index 000000000..9c9e6719b
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SessionTestHelper.java
@@ -0,0 +1,82 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import static junit.framework.Assert.assertNotNull;
+
+import org.mozilla.gecko.background.common.log.Logger;
+import org.mozilla.gecko.background.testhelpers.WaitHelper;
+import org.mozilla.gecko.sync.repositories.InvalidSessionTransitionException;
+import org.mozilla.gecko.sync.repositories.Repository;
+import org.mozilla.gecko.sync.repositories.RepositorySession;
+
+import android.content.Context;
+
+public class SessionTestHelper {
+
+  protected static RepositorySession prepareRepositorySession(
+      final Context context,
+      final boolean begin,
+      final Repository repository) {
+
+    final WaitHelper testWaiter = WaitHelper.getTestWaiter();
+
+    final String logTag = "prepareRepositorySession";
+    class CreationDelegate extends DefaultSessionCreationDelegate {
+      private RepositorySession session;
+      synchronized void setSession(RepositorySession session) {
+        this.session = session;
+      }
+      synchronized RepositorySession getSession() {
+        return this.session;
+      }
+
+      @Override
+      public void onSessionCreated(final RepositorySession session) {
+        assertNotNull(session);
+        Logger.info(logTag, "Setting session to " + session);
+        setSession(session);
+        if (begin) {
+          Logger.info(logTag, "Calling session.begin on new session.");
+          // The begin callbacks will notify.
+          try {
+            session.begin(new ExpectBeginDelegate());
+          } catch (InvalidSessionTransitionException e) {
+            testWaiter.performNotify(e);
+          }
+        } else {
+          Logger.info(logTag, "Notifying after setting new session.");
+          testWaiter.performNotify();
+        }
+      }
+    }
+
+    final CreationDelegate delegate = new CreationDelegate();
+    try {
+      Runnable runnable = new Runnable() {
+        @Override
+        public void run() {
+          repository.createSession(delegate, context);
+        }
+      };
+      testWaiter.performWait(runnable);
+    } catch (IllegalArgumentException ex) {
+      Logger.warn(logTag, "Caught IllegalArgumentException.");
+    }
+
+    Logger.info(logTag, "Retrieving new session.");
+    final RepositorySession session = delegate.getSession();
+    assertNotNull(session);
+
+    return session;
+  }
+
+  public static RepositorySession createSession(final Context context, final Repository repository) {
+    return prepareRepositorySession(context, false, repository);
+  }
+
+  public static RepositorySession createAndBeginSession(Context context, Repository repository) {
+    return prepareRepositorySession(context, true, repository);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessBeginDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessBeginDelegate.java
new file mode 100644
index 000000000..0eb477be7
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessBeginDelegate.java
@@ -0,0 +1,20 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import java.util.concurrent.ExecutorService;
+
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionBeginDelegate;
+
+public abstract class SimpleSuccessBeginDelegate extends DefaultDelegate implements RepositorySessionBeginDelegate {
+  @Override
+  public void onBeginFailed(Exception ex) {
+    performNotify("Begin failed", ex);
+  }
+
+  @Override
+  public RepositorySessionBeginDelegate deferredBeginDelegate(ExecutorService executor) {
+    return this;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessCreationDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessCreationDelegate.java
new file mode 100644
index 000000000..3b3b3d5fa
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessCreationDelegate.java
@@ -0,0 +1,18 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
+
+public abstract class SimpleSuccessCreationDelegate extends DefaultDelegate implements RepositorySessionCreationDelegate {
+  @Override
+  public void onSessionCreateFailed(Exception ex) {
+    performNotify("Session creation failed", ex);
+  }
+
+  @Override
+  public RepositorySessionCreationDelegate deferredCreationDelegate() {
+    return this;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessFetchDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessFetchDelegate.java
new file mode 100644
index 000000000..f0e9428ba
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessFetchDelegate.java
@@ -0,0 +1,22 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import java.util.concurrent.ExecutorService;
+
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionFetchRecordsDelegate;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+public abstract class SimpleSuccessFetchDelegate extends DefaultDelegate implements
+    RepositorySessionFetchRecordsDelegate {
+  @Override
+  public void onFetchFailed(Exception ex, Record record) {
+    performNotify("Fetch failed", ex);
+  }
+
+  @Override
+  public RepositorySessionFetchRecordsDelegate deferredFetchDelegate(ExecutorService executor) {
+    return this;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessFinishDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessFinishDelegate.java
new file mode 100644
index 000000000..5ac1bcde7
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessFinishDelegate.java
@@ -0,0 +1,20 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import java.util.concurrent.ExecutorService;
+
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionFinishDelegate;
+
+public abstract class SimpleSuccessFinishDelegate extends DefaultDelegate implements RepositorySessionFinishDelegate {
+  @Override
+  public void onFinishFailed(Exception ex) {
+    performNotify("Finish failed", ex);
+  }
+
+  @Override
+  public RepositorySessionFinishDelegate deferredFinishDelegate(ExecutorService executor) {
+    return this;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessStoreDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessStoreDelegate.java
new file mode 100644
index 000000000..c725c4a46
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/sync/helpers/SimpleSuccessStoreDelegate.java
@@ -0,0 +1,20 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.sync.helpers;
+
+import java.util.concurrent.ExecutorService;
+
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionStoreDelegate;
+
+public abstract class SimpleSuccessStoreDelegate extends DefaultDelegate implements RepositorySessionStoreDelegate {
+  @Override
+  public void onRecordStoreFailed(Exception ex, String guid) {
+    performNotify("Store failed", ex);
+  }
+
+  @Override
+  public RepositorySessionStoreDelegate deferredStoreDelegate(ExecutorService executor) {
+    return this;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/BaseMockServerSyncStage.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/BaseMockServerSyncStage.java
new file mode 100644
index 000000000..d2a8b8476
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/BaseMockServerSyncStage.java
@@ -0,0 +1,69 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import org.mozilla.gecko.sync.NoCollectionKeysSetException;
+import org.mozilla.gecko.sync.SynchronizerConfiguration;
+import org.mozilla.gecko.sync.repositories.RecordFactory;
+import org.mozilla.gecko.sync.repositories.Repository;
+import org.mozilla.gecko.sync.stage.ServerSyncStage;
+
+import java.net.URISyntaxException;
+
+/**
+ * A stage that joins two Repositories with no wrapping.
+ */
+public abstract class BaseMockServerSyncStage extends ServerSyncStage {
+
+  public Repository local;
+  public Repository remote;
+  public String name;
+  public String collection;
+  public int version = 1;
+
+  @Override
+  public boolean isEnabled() {
+    return true;
+  }
+
+  @Override
+  protected String getCollection() {
+    return collection;
+  }
+
+  @Override
+  protected Repository getLocalRepository() {
+    return local;
+  }
+
+  @Override
+  protected Repository getRemoteRepository() throws URISyntaxException {
+    return remote;
+  }
+
+  @Override
+  protected String getEngineName() {
+    return name;
+  }
+
+  @Override
+  public Integer getStorageVersion() {
+    return version;
+  }
+
+  @Override
+  protected RecordFactory getRecordFactory() {
+    return null;
+  }
+
+  @Override
+  protected Repository wrappedServerRepo()
+  throws NoCollectionKeysSetException, URISyntaxException {
+    return getRemoteRepository();
+  }
+
+  public SynchronizerConfiguration leakConfig() throws Exception {
+    return this.getConfig();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/CommandHelpers.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/CommandHelpers.java
new file mode 100644
index 000000000..48217f1b0
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/CommandHelpers.java
@@ -0,0 +1,40 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import org.json.simple.JSONArray;
+import org.mozilla.gecko.sync.CommandProcessor.Command;
+
+public class CommandHelpers {
+
+  @SuppressWarnings("unchecked")
+  public static Command getCommand1() {
+    JSONArray args = new JSONArray();
+    args.add("argsA");
+    return new Command("displayURI", args);
+  }
+
+  @SuppressWarnings("unchecked")
+  public static Command getCommand2() {
+    JSONArray args = new JSONArray();
+    args.add("argsB");
+    return new Command("displayURI", args);
+  }
+
+  @SuppressWarnings("unchecked")
+  public static Command getCommand3() {
+    JSONArray args = new JSONArray();
+    args.add("argsC");
+    return new Command("displayURI", args);
+  }
+
+  @SuppressWarnings("unchecked")
+  public static Command getCommand4() {
+    JSONArray args = new JSONArray();
+    args.add("URI of Page");
+    args.add("Sender ID");
+    args.add("Title of Page");
+    return new Command("displayURI", args);
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/DefaultGlobalSessionCallback.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/DefaultGlobalSessionCallback.java
new file mode 100644
index 000000000..c8be7e330
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/DefaultGlobalSessionCallback.java
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import java.net.URI;
+
+import org.mozilla.gecko.sync.GlobalSession;
+import org.mozilla.gecko.sync.delegates.GlobalSessionCallback;
+import org.mozilla.gecko.sync.stage.GlobalSyncStage.Stage;
+
+public class DefaultGlobalSessionCallback implements GlobalSessionCallback {
+
+  @Override
+  public void requestBackoff(long backoff) {
+  }
+
+  @Override
+  public void informUnauthorizedResponse(GlobalSession globalSession,
+                                         URI oldClusterURL) {
+  }
+
+  @Override
+  public void informUpgradeRequiredResponse(GlobalSession session) {
+  }
+
+  @Override
+  public void informMigrated(GlobalSession globalSession) {
+  }
+
+  @Override
+  public void handleAborted(GlobalSession globalSession, String reason) {
+  }
+
+  @Override
+  public void handleError(GlobalSession globalSession, Exception ex) {
+  }
+
+  @Override
+  public void handleSuccess(GlobalSession globalSession) {
+  }
+
+  @Override
+  public void handleStageCompleted(Stage currentState,
+                                   GlobalSession globalSession) {
+  }
+
+  @Override
+  public boolean shouldBackOffStorage() {
+    return false;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockAbstractNonRepositorySyncStage.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockAbstractNonRepositorySyncStage.java
new file mode 100644
index 000000000..d8380df97
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockAbstractNonRepositorySyncStage.java
@@ -0,0 +1,13 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import org.mozilla.gecko.sync.stage.AbstractNonRepositorySyncStage;
+
+public class MockAbstractNonRepositorySyncStage extends AbstractNonRepositorySyncStage {
+  @Override
+  public void execute() {
+    session.advance();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockClientsDataDelegate.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockClientsDataDelegate.java
new file mode 100644
index 000000000..f4af51f64
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockClientsDataDelegate.java
@@ -0,0 +1,66 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import org.mozilla.gecko.sync.Utils;
+import org.mozilla.gecko.sync.delegates.ClientsDataDelegate;
+
+public class MockClientsDataDelegate implements ClientsDataDelegate {
+  private String accountGUID;
+  private String clientName;
+  private int clientsCount;
+  private long clientDataTimestamp = 0;
+
+  @Override
+  public synchronized String getAccountGUID() {
+    if (accountGUID == null) {
+      accountGUID = Utils.generateGuid();
+    }
+    return accountGUID;
+  }
+
+  @Override
+  public synchronized String getDefaultClientName() {
+    return "Default client";
+  }
+
+  @Override
+  public synchronized void setClientName(String clientName, long now) {
+    this.clientName = clientName;
+    this.clientDataTimestamp = now;
+  }
+
+  @Override
+  public synchronized String getClientName() {
+    if (clientName == null) {
+      setClientName(getDefaultClientName(), System.currentTimeMillis());
+    }
+    return clientName;
+  }
+
+  @Override
+  public synchronized void setClientsCount(int clientsCount) {
+    this.clientsCount = clientsCount;
+  }
+
+  @Override
+  public synchronized int getClientsCount() {
+    return clientsCount;
+  }
+
+  @Override
+  public synchronized boolean isLocalGUID(String guid) {
+    return getAccountGUID().equals(guid);
+  }
+
+  @Override
+  public synchronized long getLastModifiedTimestamp() {
+    return clientDataTimestamp;
+  }
+
+  @Override
+  public String getFormFactor() {
+    return "phone";
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockClientsDatabaseAccessor.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockClientsDatabaseAccessor.java
new file mode 100644
index 000000000..5e574e33d
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockClientsDatabaseAccessor.java
@@ -0,0 +1,76 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import org.mozilla.gecko.sync.CommandProcessor.Command;
+import org.mozilla.gecko.sync.repositories.NullCursorException;
+import org.mozilla.gecko.sync.repositories.android.ClientsDatabaseAccessor;
+import org.mozilla.gecko.sync.repositories.domain.ClientRecord;
+
+public class MockClientsDatabaseAccessor extends ClientsDatabaseAccessor {
+  public boolean storedRecord = false;
+  public boolean dbWiped = false;
+  public boolean clientsTableWiped = false;
+  public boolean closed = false;
+  public boolean storedArrayList = false;
+  public boolean storedCommand;
+
+  @Override
+  public void store(ClientRecord record) {
+    storedRecord = true;
+  }
+
+  @Override
+  public void store(Collection<ClientRecord> records) {
+    storedArrayList = false;
+  }
+
+  @Override
+  public void store(String accountGUID, Command command) throws NullCursorException {
+    storedCommand = true;
+  }
+
+  @Override
+  public ClientRecord fetchClient(String profileID) throws NullCursorException {
+    return null;
+  }
+
+  @Override
+  public Map<String, ClientRecord> fetchAllClients() throws NullCursorException {
+    return null;
+  }
+
+  @Override
+  public List<Command> fetchCommandsForClient(String accountGUID) throws NullCursorException {
+    return null;
+  }
+
+  @Override
+  public int clientsCount() {
+    return 0;
+  }
+
+  @Override
+  public void wipeDB() {
+    dbWiped = true;
+  }
+
+  @Override
+  public void wipeClientsTable() {
+    clientsTableWiped = true;
+  }
+
+  @Override
+  public void close() {
+    closed = true;
+  }
+
+  public void resetVars() {
+    storedRecord = dbWiped = clientsTableWiped = closed = storedArrayList = false;
+  }
+}
\ No newline at end of file
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockGlobalSession.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockGlobalSession.java
new file mode 100644
index 000000000..63afdd1ac
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockGlobalSession.java
@@ -0,0 +1,57 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import org.mozilla.gecko.sync.EngineSettings;
+import org.mozilla.gecko.sync.NonObjectJSONException;
+import org.mozilla.gecko.sync.SyncConfiguration;
+import org.mozilla.gecko.sync.SyncConfigurationException;
+import org.mozilla.gecko.sync.crypto.KeyBundle;
+import org.mozilla.gecko.sync.delegates.GlobalSessionCallback;
+import org.mozilla.gecko.sync.net.BasicAuthHeaderProvider;
+import org.mozilla.gecko.sync.stage.CompletedStage;
+import org.mozilla.gecko.sync.stage.GlobalSyncStage;
+import org.mozilla.gecko.sync.stage.GlobalSyncStage.Stage;
+
+import java.io.IOException;
+import java.util.HashMap;
+
+
+public class MockGlobalSession extends MockPrefsGlobalSession {
+
+  public MockGlobalSession(String username, String password, KeyBundle keyBundle, GlobalSessionCallback callback) throws SyncConfigurationException, IllegalArgumentException, NonObjectJSONException, IOException {
+    this(new SyncConfiguration(username, new BasicAuthHeaderProvider(username, password), new MockSharedPreferences(), keyBundle), callback);
+  }
+
+  public MockGlobalSession(SyncConfiguration config, GlobalSessionCallback callback)
+          throws SyncConfigurationException, IllegalArgumentException, IOException, NonObjectJSONException {
+    super(config, callback, null, null);
+  }
+
+  @Override
+  public boolean isEngineRemotelyEnabled(String engine, EngineSettings engineSettings) {
+    return false;
+  }
+
+  @Override
+  protected void prepareStages() {
+    super.prepareStages();
+    HashMap<Stage, GlobalSyncStage> newStages = new HashMap<Stage, GlobalSyncStage>(this.stages);
+
+    for (Stage stage : this.stages.keySet()) {
+      newStages.put(stage, new MockServerSyncStage());
+    }
+
+    // This signals that the global session is complete.
+    newStages.put(Stage.completed, new CompletedStage());
+
+    this.stages = newStages;
+  }
+
+  public MockGlobalSession withStage(Stage stage, GlobalSyncStage syncStage) {
+    stages.put(stage, syncStage);
+
+    return this;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockPrefsGlobalSession.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockPrefsGlobalSession.java
new file mode 100644
index 000000000..2ff29453f
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockPrefsGlobalSession.java
@@ -0,0 +1,63 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import org.mozilla.gecko.sync.GlobalSession;
+import org.mozilla.gecko.sync.NonObjectJSONException;
+import org.mozilla.gecko.sync.SyncConfiguration;
+import org.mozilla.gecko.sync.SyncConfigurationException;
+import org.mozilla.gecko.sync.crypto.KeyBundle;
+import org.mozilla.gecko.sync.delegates.ClientsDataDelegate;
+import org.mozilla.gecko.sync.delegates.GlobalSessionCallback;
+import org.mozilla.gecko.sync.net.AuthHeaderProvider;
+import org.mozilla.gecko.sync.net.BasicAuthHeaderProvider;
+
+import java.io.IOException;
+
+/**
+ * GlobalSession touches the Android prefs system. Stub that out.
+ */
+public class MockPrefsGlobalSession extends GlobalSession {
+
+  public MockSharedPreferences prefs;
+
+  public MockPrefsGlobalSession(
+      SyncConfiguration config, GlobalSessionCallback callback, Context context,
+      ClientsDataDelegate clientsDelegate)
+      throws SyncConfigurationException, IllegalArgumentException, IOException,
+      NonObjectJSONException {
+    super(config, callback, context, clientsDelegate);
+  }
+
+  public static MockPrefsGlobalSession getSession(
+      String username, String password,
+      KeyBundle syncKeyBundle, GlobalSessionCallback callback, Context context,
+      ClientsDataDelegate clientsDelegate)
+      throws SyncConfigurationException, IllegalArgumentException, IOException,
+      NonObjectJSONException {
+    return getSession(username, new BasicAuthHeaderProvider(username, password), null,
+         syncKeyBundle, callback, context, clientsDelegate);
+  }
+
+  public static MockPrefsGlobalSession getSession(
+      String username, AuthHeaderProvider authHeaderProvider, String prefsPath,
+      KeyBundle syncKeyBundle, GlobalSessionCallback callback, Context context,
+      ClientsDataDelegate clientsDelegate)
+      throws SyncConfigurationException, IllegalArgumentException, IOException,
+      NonObjectJSONException {
+
+    final SharedPreferences prefs = new MockSharedPreferences();
+    final SyncConfiguration config = new SyncConfiguration(username, authHeaderProvider, prefs);
+    config.syncKeyBundle = syncKeyBundle;
+    return new MockPrefsGlobalSession(config, callback, context, clientsDelegate);
+  }
+
+  @Override
+  public Context getContext() {
+    return null;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockRecord.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockRecord.java
new file mode 100644
index 000000000..d3a05bcec
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockRecord.java
@@ -0,0 +1,34 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import org.mozilla.gecko.sync.ExtendedJSONObject;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+public class MockRecord extends Record {
+
+  public MockRecord(String guid, String collection, long lastModified, boolean deleted) {
+    super(guid, collection, lastModified, deleted);
+  }
+
+  @Override
+  protected void populatePayload(ExtendedJSONObject payload) {
+  }
+
+  @Override
+  protected void initFromPayload(ExtendedJSONObject payload) {
+  }
+
+  @Override
+  public Record copyWithIDs(String guid, long androidID) {
+    MockRecord r = new MockRecord(guid, this.collection, this.lastModified, this.deleted);
+    r.androidID = androidID;
+    return r;
+  }
+
+  @Override
+  public String toJSONString() {
+    return "{\"id\":\"" + guid + "\", \"payload\": \"foo\"}";
+  }
+}
\ No newline at end of file
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockServerSyncStage.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockServerSyncStage.java
new file mode 100644
index 000000000..02b72b676
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockServerSyncStage.java
@@ -0,0 +1,12 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+
+public class MockServerSyncStage extends BaseMockServerSyncStage {
+  @Override
+  public void execute() {
+    session.advance();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockSharedPreferences.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockSharedPreferences.java
new file mode 100644
index 000000000..bc49fa7fb
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/MockSharedPreferences.java
@@ -0,0 +1,137 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import android.content.SharedPreferences;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A programmable mock content provider.
+ */
+public class MockSharedPreferences implements SharedPreferences, SharedPreferences.Editor {
+  private HashMap<String, Object> mValues;
+  private HashMap<String, Object> mTempValues;
+
+  public MockSharedPreferences() {
+    mValues = new HashMap<String, Object>();
+    mTempValues = new HashMap<String, Object>();
+  }
+
+  public Editor edit() {
+    return this;
+  }
+
+  public boolean contains(String key) {
+    return mValues.containsKey(key);
+  }
+
+  public Map<String, ?> getAll() {
+    return new HashMap<String, Object>(mValues);
+  }
+
+  public boolean getBoolean(String key, boolean defValue) {
+    if (mValues.containsKey(key)) {
+      return ((Boolean)mValues.get(key)).booleanValue();
+    }
+    return defValue;
+  }
+
+  public float getFloat(String key, float defValue) {
+    if (mValues.containsKey(key)) {
+      return ((Float)mValues.get(key)).floatValue();
+    }
+    return defValue;
+  }
+
+  public int getInt(String key, int defValue) {
+    if (mValues.containsKey(key)) {
+      return ((Integer)mValues.get(key)).intValue();
+    }
+    return defValue;
+  }
+
+  public long getLong(String key, long defValue) {
+    if (mValues.containsKey(key)) {
+      return ((Long)mValues.get(key)).longValue();
+    }
+    return defValue;
+  }
+
+  public String getString(String key, String defValue) {
+    if (mValues.containsKey(key))
+      return (String)mValues.get(key);
+    return defValue;
+  }
+
+  @SuppressWarnings("unchecked")
+  public Set<String> getStringSet(String key, Set<String> defValues) {
+    if (mValues.containsKey(key)) {
+      return (Set<String>) mValues.get(key);
+    }
+    return defValues;
+  }
+
+  public void registerOnSharedPreferenceChangeListener(
+    OnSharedPreferenceChangeListener listener) {
+    throw new UnsupportedOperationException();
+  }
+
+  public void unregisterOnSharedPreferenceChangeListener(
+    OnSharedPreferenceChangeListener listener) {
+    throw new UnsupportedOperationException();
+  }
+
+  public Editor putBoolean(String key, boolean value) {
+    mTempValues.put(key, Boolean.valueOf(value));
+    return this;
+  }
+
+  public Editor putFloat(String key, float value) {
+    mTempValues.put(key, value);
+    return this;
+  }
+
+  public Editor putInt(String key, int value) {
+    mTempValues.put(key, value);
+    return this;
+  }
+
+  public Editor putLong(String key, long value) {
+    mTempValues.put(key, value);
+    return this;
+  }
+
+  public Editor putString(String key, String value) {
+    mTempValues.put(key, value);
+    return this;
+  }
+
+  public Editor putStringSet(String key, Set<String> values) {
+    mTempValues.put(key, values);
+    return this;
+  }
+
+  public Editor remove(String key) {
+    mTempValues.remove(key);
+    return this;
+  }
+
+  public Editor clear() {
+    mTempValues.clear();
+    return this;
+  }
+
+  @SuppressWarnings("unchecked")
+  public boolean commit() {
+    mValues = (HashMap<String, Object>)mTempValues.clone();
+    return true;
+  }
+
+  public void apply() {
+    commit();
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/WBORepository.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/WBORepository.java
new file mode 100644
index 000000000..bd2e7f791
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/WBORepository.java
@@ -0,0 +1,231 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import org.mozilla.gecko.background.common.log.Logger;
+import org.mozilla.gecko.sync.repositories.InactiveSessionException;
+import org.mozilla.gecko.sync.repositories.InvalidSessionTransitionException;
+import org.mozilla.gecko.sync.repositories.NoStoreDelegateException;
+import org.mozilla.gecko.sync.repositories.RecordFilter;
+import org.mozilla.gecko.sync.repositories.Repository;
+import org.mozilla.gecko.sync.repositories.StoreTrackingRepositorySession;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionBeginDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionFetchRecordsDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionFinishDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionGuidsSinceDelegate;
+import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionWipeDelegate;
+import org.mozilla.gecko.sync.repositories.domain.Record;
+
+import android.content.Context;
+
+public class WBORepository extends Repository {
+
+  public class WBORepositoryStats {
+    public long created         = -1;
+    public long begun           = -1;
+    public long fetchBegan      = -1;
+    public long fetchCompleted  = -1;
+    public long storeBegan      = -1;
+    public long storeCompleted  = -1;
+    public long finished        = -1;
+  }
+
+  public static final String LOG_TAG = "WBORepository";
+
+  // Access to stats is not guarded.
+  public WBORepositoryStats stats;
+
+  // Whether or not to increment the timestamp of stored records.
+  public final boolean bumpTimestamps;
+
+  public class WBORepositorySession extends StoreTrackingRepositorySession {
+
+    protected WBORepository wboRepository;
+    protected ExecutorService delegateExecutor = Executors.newSingleThreadExecutor();
+    public ConcurrentHashMap<String, Record> wbos;
+
+    public WBORepositorySession(WBORepository repository) {
+      super(repository);
+
+      wboRepository = repository;
+      wbos          = new ConcurrentHashMap<String, Record>();
+      stats         = new WBORepositoryStats();
+      stats.created = now();
+    }
+
+    @Override
+    protected synchronized void trackGUID(String guid) {
+      if (wboRepository.shouldTrack()) {
+        super.trackGUID(guid);
+      }
+    }
+
+    @Override
+    public void guidsSince(long timestamp,
+                           RepositorySessionGuidsSinceDelegate delegate) {
+      throw new RuntimeException("guidsSince not implemented.");
+    }
+
+    @Override
+    public void fetchSince(long timestamp,
+                           RepositorySessionFetchRecordsDelegate delegate) {
+      long fetchBegan  = now();
+      stats.fetchBegan = fetchBegan;
+      RecordFilter filter = storeTracker.getFilter();
+
+      for (Entry<String, Record> entry : wbos.entrySet()) {
+        Record record = entry.getValue();
+        if (record.lastModified >= timestamp) {
+          if (filter != null &&
+              filter.excludeRecord(record)) {
+            Logger.debug(LOG_TAG, "Excluding record " + record.guid);
+            continue;
+          }
+          delegate.deferredFetchDelegate(delegateExecutor).onFetchedRecord(record);
+        }
+      }
+      long fetchCompleted  = now();
+      stats.fetchCompleted = fetchCompleted;
+      delegate.deferredFetchDelegate(delegateExecutor).onFetchCompleted(fetchCompleted);
+    }
+
+    @Override
+    public void fetch(final String[] guids,
+                      final RepositorySessionFetchRecordsDelegate delegate) {
+      long fetchBegan  = now();
+      stats.fetchBegan = fetchBegan;
+      for (String guid : guids) {
+        if (wbos.containsKey(guid)) {
+          delegate.deferredFetchDelegate(delegateExecutor).onFetchedRecord(wbos.get(guid));
+        }
+      }
+      long fetchCompleted  = now();
+      stats.fetchCompleted = fetchCompleted;
+      delegate.deferredFetchDelegate(delegateExecutor).onFetchCompleted(fetchCompleted);
+    }
+
+    @Override
+    public void fetchAll(final RepositorySessionFetchRecordsDelegate delegate) {
+      long fetchBegan  = now();
+      stats.fetchBegan = fetchBegan;
+      for (Entry<String, Record> entry : wbos.entrySet()) {
+        Record record = entry.getValue();
+        delegate.deferredFetchDelegate(delegateExecutor).onFetchedRecord(record);
+      }
+      long fetchCompleted  = now();
+      stats.fetchCompleted = fetchCompleted;
+      delegate.deferredFetchDelegate(delegateExecutor).onFetchCompleted(fetchCompleted);
+    }
+
+    @Override
+    public void store(final Record record) throws NoStoreDelegateException {
+      if (delegate == null) {
+        throw new NoStoreDelegateException();
+      }
+      final long now = now();
+      if (stats.storeBegan < 0) {
+        stats.storeBegan = now;
+      }
+      Record existing = wbos.get(record.guid);
+      Logger.debug(LOG_TAG, "Existing record is " + (existing == null ? "<null>" : (existing.guid + ", " + existing)));
+      if (existing != null &&
+          existing.lastModified > record.lastModified) {
+        Logger.debug(LOG_TAG, "Local record is newer. Not storing.");
+        delegate.deferredStoreDelegate(delegateExecutor).onRecordStoreSucceeded(record.guid);
+        return;
+      }
+      if (existing != null) {
+        Logger.debug(LOG_TAG, "Replacing local record.");
+      }
+
+      // Store a copy of the record with an updated modified time.
+      Record toStore = record.copyWithIDs(record.guid, record.androidID);
+      if (bumpTimestamps) {
+        toStore.lastModified = now;
+      }
+      wbos.put(record.guid, toStore);
+
+      trackRecord(toStore);
+      delegate.deferredStoreDelegate(delegateExecutor).onRecordStoreSucceeded(record.guid);
+    }
+
+    @Override
+    public void wipe(final RepositorySessionWipeDelegate delegate) {
+      if (!isActive()) {
+        delegate.onWipeFailed(new InactiveSessionException(null));
+        return;
+      }
+
+      Logger.info(LOG_TAG, "Wiping WBORepositorySession.");
+      this.wbos = new ConcurrentHashMap<String, Record>();
+
+      // Wipe immediately for the convenience of test code.
+      wboRepository.wbos = new ConcurrentHashMap<String, Record>();
+      delegate.deferredWipeDelegate(delegateExecutor).onWipeSucceeded();
+    }
+
+    @Override
+    public void finish(RepositorySessionFinishDelegate delegate) throws InactiveSessionException {
+      Logger.info(LOG_TAG, "Finishing WBORepositorySession: handing back " + this.wbos.size() + " WBOs.");
+      wboRepository.wbos = this.wbos;
+      stats.finished = now();
+      super.finish(delegate);
+    }
+
+    @Override
+    public void begin(RepositorySessionBeginDelegate delegate) throws InvalidSessionTransitionException {
+      this.wbos = wboRepository.cloneWBOs();
+      stats.begun = now();
+      super.begin(delegate);
+    }
+
+    @Override
+    public void storeDone(long end) {
+      // TODO: this is not guaranteed to be called after all of the record
+      // store callbacks have completed!
+      if (stats.storeBegan < 0) {
+        stats.storeBegan = end;
+      }
+      stats.storeCompleted = end;
+      delegate.deferredStoreDelegate(delegateExecutor).onStoreCompleted(end);
+    }
+  }
+
+  public ConcurrentHashMap<String, Record> wbos;
+
+  public WBORepository(boolean bumpTimestamps) {
+    super();
+    this.bumpTimestamps = bumpTimestamps;
+    this.wbos = new ConcurrentHashMap<String, Record>();
+  }
+
+  public WBORepository() {
+    this(false);
+  }
+
+  public synchronized boolean shouldTrack() {
+    return false;
+  }
+
+  @Override
+  public void createSession(RepositorySessionCreationDelegate delegate,
+                            Context context) {
+    delegate.deferredCreationDelegate().onSessionCreated(new WBORepositorySession(this));
+  }
+
+  public ConcurrentHashMap<String, Record> cloneWBOs() {
+    ConcurrentHashMap<String, Record> out = new ConcurrentHashMap<String, Record>();
+    for (Entry<String, Record> entry : wbos.entrySet()) {
+      out.put(entry.getKey(), entry.getValue()); // Assume that records are
+                                                 // immutable.
+    }
+    return out;
+  }
+}
diff --git a/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/WaitHelper.java b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/WaitHelper.java
new file mode 100644
index 000000000..1a84977cf
--- /dev/null
+++ b/mobile/android/tests/background/junit3/src/org/mozilla/gecko/background/testhelpers/WaitHelper.java
@@ -0,0 +1,171 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.background.testhelpers;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+import org.mozilla.gecko.background.common.log.Logger;
+
+/**
+ * Implements waiting for asynchronous test events.
+ *
+ * Call WaitHelper.getTestWaiter() to get the unique instance.
+ *
+ * Call performWait(runnable) to execute runnable synchronously.
+ * runnable *must* call performNotify() on all exit paths to signal to
+ * the TestWaiter that the runnable has completed.
+ *
+ * @author rnewman
+ * @author nalexander
+ */
+public class WaitHelper {
+
+  public static final String LOG_TAG = "WaitHelper";
+
+  public static class Result {
+    public Throwable error;
+    public Result() {
+      error = null;
+    }
+
+    public Result(Throwable error) {
+      this.error = error;
+    }
+  }
+
+  public static abstract class WaitHelperError extends Error {
+    private static final long serialVersionUID = 7074690961681883619L;
+  }
+
+  /**
+   * Immutable.
+   *
+   * @author rnewman
+   */
+  public static class TimeoutError extends WaitHelperError {
+    private static final long serialVersionUID = 8591672555848651736L;
+    public final int waitTimeInMillis;
+
+    public TimeoutError(int waitTimeInMillis) {
+      this.waitTimeInMillis = waitTimeInMillis;
+    }
+  }
+
+  public static class MultipleNotificationsError extends WaitHelperError {
+    private static final long serialVersionUID = -9072736521571635495L;
+  }
+
+  public static class InterruptedError extends WaitHelperError {
+    private static final long serialVersionUID = 8383948170038639308L;
+  }
+
+  public static class InnerError extends WaitHelperError {
+    private static final long serialVersionUID = 3008502618576773778L;
+    public Throwable innerError;
+
+    public InnerError(Throwable e) {
+      innerError = e;
+      if (e != null) {
+        // Eclipse prints the stack trace of the cause.
+        this.initCause(e);
+      }
+    }
+  }
+
+  public BlockingQueue<Result> queue = new ArrayBlockingQueue<Result>(1);
+
+  /**
+   * How long performWait should wait for, in milliseconds, with the
+   * convention that a negative value means "wait forever".
+   */
+  public static int defaultWaitTimeoutInMillis = -1;
+
+  public void performWait(Runnable action) throws WaitHelperError {
+    this.performWait(defaultWaitTimeoutInMillis, action);
+  }
+
+  public void performWait(int waitTimeoutInMillis, Runnable action) throws WaitHelperError {
+    Logger.debug(LOG_TAG, "performWait called.");
+
+    Result result = null;
+
+    try {
+      if (action != null) {
+        try {
+          action.run();
+          Logger.debug(LOG_TAG, "Action done.");
+        } catch (Exception ex) {
+          Logger.debug(LOG_TAG, "Performing action threw: " + ex.getMessage());
+          throw new InnerError(ex);
+        }
+      }
+
+      if (waitTimeoutInMillis < 0) {
+        result = queue.take();
+      } else {
+        result = queue.poll(waitTimeoutInMillis, TimeUnit.MILLISECONDS);
+      }
+      Logger.debug(LOG_TAG, "Got result from queue: " + result);
+    } catch (InterruptedException e) {
+      // We were interrupted.
+      Logger.debug(LOG_TAG, "performNotify interrupted with InterruptedException " + e);
+      final InterruptedError interruptedError = new InterruptedError();
+      interruptedError.initCause(e);
+      throw interruptedError;
+    }
+
+    if (result == null) {
+      // We timed out.
+      throw new TimeoutError(waitTimeoutInMillis);
+    } else if (result.error != null) {
+      Logger.debug(LOG_TAG, "Notified with error: " + result.error.getMessage());
+
+      // Rethrow any assertion with which we were notified.
+      InnerError innerError = new InnerError(result.error);
+      throw innerError;
+    }
+    // Success!
+  }
+
+  public void performNotify(final Throwable e) {
+    if (e != null) {
+      Logger.debug(LOG_TAG, "performNotify called with Throwable: " + e.getMessage());
+    } else {
+      Logger.debug(LOG_TAG, "performNotify called.");
+    }
+
+    if (!queue.offer(new Result(e))) {
+      // This could happen if performNotify is called multiple times (which is an error).
+      throw new MultipleNotificationsError();
+    }
+  }
+
+  public void performNotify() {
+    this.performNotify(null);
+  }
+
+  public static Runnable onThreadRunnable(final Runnable r) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        new Thread(r).start();
+      }
+    };
+  }
+
+  private static WaitHelper singleWaiter = new WaitHelper();
+  public static WaitHelper getTestWaiter() {
+    return singleWaiter;
+  }
+
+  public static void resetTestWaiter() {
+    singleWaiter = new WaitHelper();
+  }
+
+  public boolean isIdle() {
+    return queue.isEmpty();
+  }
+}