sync from main

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

@@ -0,0 +1,313 @@
+/**
+ *
+ */
+package com.google.android.apps.mytracks.content;
+
+import com.google.android.apps.mytracks.content.SearchEngine.ScoredResult;
+import com.google.android.apps.mytracks.content.SearchEngine.SearchQuery;
+import com.google.android.apps.mytracks.services.TrackRecordingServiceTest.MockContext;
+import com.google.android.apps.mytracks.stats.TripStatistics;
+
+import android.content.ContentUris;
+import android.location.Location;
+import android.net.Uri;
+import android.test.AndroidTestCase;
+import android.test.RenamingDelegatingContext;
+import android.test.mock.MockContentResolver;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Tests for {@link SearchEngine}.
+ * These are not meant to be quality tests, but instead feature-by-feature tests
+ * (in other words, they don't test the mixing of different score boostings, just
+ * each boosting separately)
+ *
+ * @author Rodrigo Damazio
+ */
+public class SearchEngineTest extends AndroidTestCase {
+
+  private static final Location HERE = new Location("gps");
+  private static final long NOW = 1234567890000L;  // After OLDEST_ALLOWED_TIMESTAMP
+  private MyTracksProviderUtils providerUtils;
+  private SearchEngine engine;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+
+    MockContentResolver mockContentResolver = new MockContentResolver();
+    RenamingDelegatingContext targetContext = new RenamingDelegatingContext(
+        getContext(), getContext(), "test.");
+    MockContext context = new MockContext(mockContentResolver, targetContext);
+    MyTracksProvider provider = new MyTracksProvider();
+    provider.attachInfo(context, null);
+    mockContentResolver.addProvider(MyTracksProviderUtils.AUTHORITY, provider);
+    setContext(context);
+
+    providerUtils = MyTracksProviderUtils.Factory.get(context);
+    engine = new SearchEngine(providerUtils);
+  }
+
+  @Override
+  protected void tearDown() throws Exception {
+    providerUtils.deleteAllTracks();
+
+    super.tearDown();
+  }
+
+  private long insertTrack(String title, String description, String category, double distance, long hoursAgo) {
+    Track track = new Track();
+    track.setName(title);
+    track.setDescription(description);
+    track.setCategory(category);
+
+    TripStatistics stats = track.getStatistics();
+    if (hoursAgo > 0) {
+      // Started twice hoursAgo, so the average time is hoursAgo.
+      stats.setStartTime(NOW - hoursAgo * 1000L * 60L * 60L * 2);
+      stats.setStopTime(NOW);
+    }
+
+    int latitude = (int) ((HERE.getLatitude() + distance) * 1E6);
+    int longitude = (int) ((HERE.getLongitude() + distance) * 1E6);
+    stats.setBounds(latitude, longitude, latitude, longitude);
+
+    Uri uri = providerUtils.insertTrack(track);
+    return ContentUris.parseId(uri);
+  }
+
+  private long insertTrack(String title, String description, String category) {
+    return insertTrack(title, description, category, 0, -1);
+  }
+
+  private long insertTrack(String title, double distance) {
+    return insertTrack(title, "", "", distance, -1);
+  }
+
+  private long insertTrack(String title, long hoursAgo) {
+    return insertTrack(title, "", "", 0.0, hoursAgo);
+  }
+
+  private long insertWaypoint(String title, String description, String category, double distance, long hoursAgo, long trackId) {
+    Waypoint waypoint = new Waypoint();
+    waypoint.setName(title);
+    waypoint.setDescription(description);
+    waypoint.setCategory(category);
+    waypoint.setTrackId(trackId);
+
+    Location location = new Location(HERE);
+    location.setLatitude(location.getLatitude() + distance);
+    location.setLongitude(location.getLongitude() + distance);
+    if (hoursAgo >= 0) {
+      location.setTime(NOW - hoursAgo * 1000L * 60L * 60L);
+    }
+    waypoint.setLocation(location);
+
+    Uri uri = providerUtils.insertWaypoint(waypoint);
+    return ContentUris.parseId(uri);
+  }
+
+  private long insertWaypoint(String title, String description, String category) {
+    return insertWaypoint(title, description, category, 0.0, -1, -1);
+  }
+
+  private long insertWaypoint(String title, double distance) {
+    return insertWaypoint(title, "", "", distance, -1, -1);
+  }
+
+  private long insertWaypoint(String title, long hoursAgo) {
+    return insertWaypoint(title, "", "", 0.0, hoursAgo, -1);
+  }
+
+  private long insertWaypoint(String title, long hoursAgo, long trackId) {
+    return insertWaypoint(title, "", "", 0.0, hoursAgo, trackId);
+  }
+
+  public void testSearchText() {
+    // Insert 7 tracks (purposefully out of result order):
+    // - one which won't match
+    // - one which will match the description
+    // - one which will match the category
+    // - one which will match the title
+    // - one which will match in title and category
+    // - one which will match in title and description
+    // - one which will match in all fields
+    insertTrack("bb", "cc", "dd");
+    long descriptionMatchId = insertTrack("bb", "aa", "cc");
+    long categoryMatchId = insertTrack("bb", "cc", "aa");
+    long titleMatchId = insertTrack("aa", "bb", "cc");
+    long titleCategoryMatchId = insertTrack("aa", "bb", "ca");
+    long titleDescriptionMatchId = insertTrack("aa", "ba", "cc");
+    long allMatchId = insertTrack("aa", "ba", "ca");
+
+    SearchQuery query = new SearchQuery("a", null, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Title > Description > Category.
+    assertTrackResults(results,
+        allMatchId, titleDescriptionMatchId, titleCategoryMatchId, titleMatchId, descriptionMatchId,
+        categoryMatchId);
+  }
+
+  public void testSearchWaypointText() {
+    // Insert 7 waypoints (purposefully out of result order):
+    // - one which won't match
+    // - one which will match the description
+    // - one which will match the category
+    // - one which will match the title
+    // - one which will match in title and category
+    // - one which will match in title and description
+    // - one which will match in all fields
+    insertWaypoint("bb", "cc", "dd");
+    long descriptionMatchId = insertWaypoint("bb", "aa", "cc");
+    long categoryMatchId = insertWaypoint("bb", "cc", "aa");
+    long titleMatchId = insertWaypoint("aa", "bb", "cc");
+    long titleCategoryMatchId = insertWaypoint("aa", "bb", "ca");
+    long titleDescriptionMatchId = insertWaypoint("aa", "ba", "cc");
+    long allMatchId = insertWaypoint("aa", "ba", "ca");
+
+    SearchQuery query = new SearchQuery("a", null, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Title > Description > Category.
+    assertWaypointResults(results,
+        allMatchId, titleDescriptionMatchId, titleCategoryMatchId, titleMatchId, descriptionMatchId,
+        categoryMatchId);
+  }
+
+  public void testSearchMixedText() {
+    // Insert 5 entries (purposefully out of result order):
+    // - one waypoint which will match by description
+    // - one waypoint which won't match
+    // - one waypoint which will match by title
+    // - one track which won't match
+    // - one track which will match by title
+    long descriptionWaypointId = insertWaypoint("bb", "aa", "cc");
+    insertWaypoint("bb", "cc", "dd");
+    long titleWaypointId = insertWaypoint("aa", "bb", "cc");
+    insertTrack("bb", "cc", "dd");
+    long trackId = insertTrack("aa", "bb", "cc");
+
+    SearchQuery query = new SearchQuery("a", null, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Title > Description > Category.
+    assertEquals(results.toString(), 3, results.size());
+    assertTrackResult(trackId, results.get(0));
+    assertWaypointResult(titleWaypointId, results.get(1));
+    assertWaypointResult(descriptionWaypointId, results.get(2));
+  }
+
+  public void testSearchTrackDistance() {
+    // All results match text, but they're at difference distances from the user.
+    long farFarAwayId = insertTrack("aa", 0.3);
+    long nearId = insertTrack("ab", 0.1);
+    long farId = insertTrack("ac", 0.2);
+
+    SearchQuery query = new SearchQuery("a", HERE, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Distance order.
+    assertTrackResults(results, nearId, farId, farFarAwayId);
+  }
+
+  public void testSearchWaypointDistance() {
+    // All results match text, but they're at difference distances from the user.
+    long farFarAwayId = insertWaypoint("aa", 0.3);
+    long nearId = insertWaypoint("ab", 0.1);
+    long farId = insertWaypoint("ac", 0.2);
+
+    SearchQuery query = new SearchQuery("a", HERE, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Distance order.
+    assertWaypointResults(results, nearId, farId, farFarAwayId);
+  }
+
+  public void testSearchTrackRecent() {
+    // All results match text, but they're were recorded at different times.
+    long oldestId = insertTrack("aa", 3);
+    long recentId = insertTrack("ab", 1);
+    long oldId = insertTrack("ac", 2);
+
+    SearchQuery query = new SearchQuery("a", null, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Reverse time order.
+    assertTrackResults(results, recentId, oldId, oldestId);
+  }
+
+  public void testSearchWaypointRecent() {
+    // All results match text, but they're were recorded at different times.
+    long oldestId = insertWaypoint("aa", 2);
+    long recentId = insertWaypoint("ab", 0);
+    long oldId = insertWaypoint("ac", 1);
+
+    SearchQuery query = new SearchQuery("a", null, -1, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Reverse time order.
+    assertWaypointResults(results, recentId, oldId, oldestId);
+  }
+
+  public void testSearchCurrentTrack() {
+    // All results match text, but one of them is the current track.
+    long currentId = insertTrack("ab", 1);
+    long otherId = insertTrack("aa", 1);
+
+    SearchQuery query = new SearchQuery("a", null, currentId, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Current track should be demoted.
+    assertTrackResults(results, otherId, currentId);
+  }
+
+  public void testSearchCurrentTrackWaypoint() {
+    // All results match text, but one of them is in the current track.
+    long otherId = insertWaypoint("aa", 1, 456);
+    long currentId = insertWaypoint("ab", 1, 123);
+
+    SearchQuery query = new SearchQuery("a", null, 123, NOW);
+    ArrayList<ScoredResult> results = new ArrayList<ScoredResult>(engine.search(query));
+
+    // Waypoint in current track should be promoted.
+    assertWaypointResults(results, currentId, otherId);
+  }
+
+  private void assertTrackResult(long trackId, ScoredResult result) {
+    assertNotNull("Not a track", result.track);
+    assertNull("Ambiguous result", result.waypoint);
+    assertEquals(trackId, result.track.getId());
+  }
+
+  private void assertTrackResults(List<ScoredResult> results, long... trackIds) {
+    String errMsg = "Expected IDs=" + Arrays.toString(trackIds) + "; results=" + results;
+    assertEquals(results.size(), trackIds.length);
+    for (int i = 0; i < results.size(); i++) {
+      ScoredResult result = results.get(i);
+      assertNotNull(errMsg, result.track);
+      assertNull(errMsg, result.waypoint);
+      assertEquals(errMsg, trackIds[i], result.track.getId());
+    }
+  }
+
+  private void assertWaypointResult(long waypointId, ScoredResult result) {
+    assertNotNull("Not a waypoint", result.waypoint);
+    assertNull("Ambiguous result", result.track);
+    assertEquals(waypointId, result.waypoint.getId());
+  }
+
+  private void assertWaypointResults(List<ScoredResult> results, long... waypointIds) {
+    String errMsg = "Expected IDs=" + Arrays.toString(waypointIds) + "; results=" + results;
+    assertEquals(results.size(), waypointIds.length);
+    for (int i = 0; i < results.size(); i++) {
+      ScoredResult result = results.get(i);
+      assertNotNull(errMsg, result.waypoint);
+      assertNull(errMsg, result.track);
+      assertEquals(errMsg, waypointIds[i], result.waypoint.getId());
+    }
+  }
+}

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

@@ -0,0 +1,64 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+package com.google.android.apps.mytracks.services;
+
+import android.app.Notification;
+import android.app.Service;
+import android.test.ServiceTestCase;
+import android.util.Log;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * A {@link TrackRecordingService} that can be used with {@link ServiceTestCase}. 
+ * {@link ServiceTestCase} throws a null pointer exception when the service
+ * calls {@link Service#startForeground(int, android.app.Notification)} and
+ * {@link Service#stopForeground(boolean)}.
+ * <p>
+ * See http://code.google.com/p/android/issues/detail?id=12122
+ * <p>
+ * Wrap these two methods in wrappers and override them.
+ *
+ * @author Jimmy Shih
+ */
+public class TestRecordingService extends TrackRecordingService {
+
+  private static final String TAG = TestRecordingService.class.getSimpleName();
+
+  @Override
+  protected void startForegroundService(Notification notification) {
+    try {
+      Method setForegroundMethod = Service.class.getMethod("setForeground", boolean.class);
+      setForegroundMethod.invoke(this, true);
+    } catch (SecurityException e) {
+      Log.e(TAG, "Unable to start a service in foreground", e);
+    } catch (NoSuchMethodException e) {
+      Log.e(TAG, "Unable to start a service in foreground", e);
+    } catch (IllegalArgumentException e) {
+      Log.e(TAG, "Unable to start a service in foreground", e);
+    } catch (IllegalAccessException e) {
+      Log.e(TAG, "Unable to start a service in foreground", e);
+    } catch (InvocationTargetException e) {
+      Log.e(TAG, "Unable to start a service in foreground", e);
+    }
+  }
+
+  @Override
+  protected void stopForegroundService() {
+    try {
+      Method setForegroundMethod = Service.class.getMethod("setForeground", boolean.class);
+      setForegroundMethod.invoke(this, false);
+    } catch (SecurityException e) {
+      Log.e(TAG, "Unable to start a service in foreground", e);
+    } catch (NoSuchMethodException e) {
+      Log.e(TAG, "Unable to start a service in foreground", e);
+    } catch (IllegalArgumentException e) {
+      Log.e(TAG, "Unable to start a service in foreground", e);
+    } catch (IllegalAccessException e) {
+      Log.e(TAG, "Unable to start a service in foreground", e);
+    } catch (InvocationTargetException e) {
+      Log.e(TAG, "Unable to start a service in foreground", e);
+    }
+  }
+}

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

@@ -24,7 +24,6 @@ import com.google.android.apps.mytracks.content.Track;
 import com.google.android.apps.mytracks.content.Waypoint;
 import com.google.android.apps.mytracks.content.WaypointCreationRequest;
 import com.google.android.apps.mytracks.stats.TripStatistics;
-import com.google.android.apps.mytracks.util.ApiFeatures;
 import com.google.android.maps.mytracks.R;
 
 import android.content.BroadcastReceiver;
@@ -57,8 +56,7 @@ import java.util.List;
  * is called, which prevents from testing multiple scenarios in a single
  * test (see runFunctionTest for more details).
  */
-public class TrackRecordingServiceTest
-    extends ServiceTestCase<TrackRecordingService> {
+public class TrackRecordingServiceTest extends ServiceTestCase<TestRecordingService> {
 
   private Context context;
   private MyTracksProviderUtils providerUtils;
@@ -74,7 +72,7 @@ public class TrackRecordingServiceTest
   private Intent serviceIntent;
 
   public TrackRecordingServiceTest() {
-    super(TrackRecordingService.class);
+    super(TestRecordingService.class);
   }
 
   /**
@@ -96,19 +94,6 @@ public class TrackRecordingServiceTest
     }
   }
 
-  /**
-   * A mock class that forces API level < 5 to make sure we can workaround a bug
-   * in ServiceTestCase (throwing a NPE).
-   * See http://code.google.com/p/android/issues/detail?id=12122 for more
-   * details.
-   */
-  private static class MockApiFeatures extends ApiFeatures {
-    @Override
-    protected int getApiLevel() {
-      return 4;
-    }
-  }
-
   @Override
   protected IBinder bindService(Intent intent) {
     if (getService() != null) {
@@ -138,8 +123,6 @@ public class TrackRecordingServiceTest
   protected void setUp() throws Exception {
     super.setUp();
 
-    ApiFeatures.injectInstance(new MockApiFeatures());
-
     MockContentResolver mockContentResolver = new MockContentResolver();
     RenamingDelegatingContext targetContext = new RenamingDelegatingContext(
         getContext(), getContext(), "test.");

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

@@ -15,13 +15,6 @@
  */
 package com.google.android.apps.mytracks.services.tasks;
 
-import com.google.android.apps.mytracks.services.tasks.PeriodicTask;
-import com.google.android.apps.mytracks.services.tasks.StatusAnnouncerFactory;
-import com.google.android.apps.mytracks.services.tasks.StatusAnnouncerTask;
-import com.google.android.apps.mytracks.util.ApiFeatures;
-
-import android.media.AudioManager;
-import android.speech.tts.TextToSpeech;
 import android.test.AndroidTestCase;
 
 /**
@@ -31,62 +24,9 @@ import android.test.AndroidTestCase;
  * @author Rodrigo Damazio
  */
 public class StatusAnnouncerFactoryTest extends AndroidTestCase {
-  /**
-   * Mock version of the {@link ApiFeatures} class.
-   */
-  private class MockApiFeatures extends ApiFeatures {
-    private boolean hasTts;
-
-    public void setHasTextToSpeech(boolean hasTts) {
-      this.hasTts = hasTts;
-    }
-
-    @Override
-    public boolean hasTextToSpeech() {
-      return hasTts;
-    }
-  }
-
-  private MockApiFeatures apiFeatures;
-
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
-
-    apiFeatures = new MockApiFeatures();
-  }
-
   public void testCreate() {
-    apiFeatures.setHasTextToSpeech(true);
-    PeriodicTaskFactory factory =
-        new StatusAnnouncerFactory(apiFeatures);
+    PeriodicTaskFactory factory = new StatusAnnouncerFactory();
     PeriodicTask task = factory.create(getContext());
     assertTrue(task instanceof StatusAnnouncerTask);
   }
-
-  public void testCreate_notAvailable() {
-    apiFeatures.setHasTextToSpeech(false);
-    PeriodicTaskFactory factory =
-        new StatusAnnouncerFactory(apiFeatures);
-    PeriodicTask task = factory.create(getContext());
-    assertNull(task);
-  }
-
-  public void testGetVolumeStream() {
-    apiFeatures.setHasTextToSpeech(true);
-    StatusAnnouncerFactory factory =
-        new StatusAnnouncerFactory(apiFeatures);
-    assertEquals(
-        TextToSpeech.Engine.DEFAULT_STREAM,
-        factory.getVolumeStream());
-  }
-
-  public void testGetVolumeStream_notAvailable() {
-    apiFeatures.setHasTextToSpeech(false);
-    StatusAnnouncerFactory factory =
-        new StatusAnnouncerFactory(apiFeatures);
-    assertEquals(
-        AudioManager.USE_DEFAULT_STREAM_TYPE,
-        factory.getVolumeStream());
-  }
 }

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.android.apps.mytracks.util;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests {@link ApiAdapterFactory}.
+ *
+ * @author Rodrigo Damazio
+ */
+public class ApiAdapterFactoryTest extends TestCase {
+  public void testGetApiLevelAdapter() {
+    assertNotNull(ApiAdapterFactory.getApiAdapter());
+  }
+}

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

@@ -1,62 +0,0 @@
-/*
- * Copyright 2010 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.google.android.apps.mytracks.util;
-
-import junit.framework.TestCase;
-
-/**
- * Tests the API feature detection code in {@link ApiFeatures}.
- * This test requires Froyo+ to run.
- *
- * @author Rodrigo Damazio
- */
-public class ApiFeaturesTest extends TestCase {
-
-  private TestableApiFeatures features;
-
-  private class TestableApiFeatures extends ApiFeatures {
-    private int apiLevel;
-
-    public void setApiLevel(int apiLevel) {
-      this.apiLevel = apiLevel;
-    }
-
-    @Override
-    protected int getApiLevel() {
-      return apiLevel;
-    }
-  }
-  
-  @Override
-  protected void setUp() throws Exception {
-    super.setUp();
-
-    features = new TestableApiFeatures();
-  }
-
-  public void testHasTextToSpeech() {
-    features.setApiLevel(3);
-    assertFalse(features.hasTextToSpeech());
-    for (int i = 4; i <= 8; i++) {
-      features.setApiLevel(i);
-      assertTrue(features.hasTextToSpeech());
-    }
-  }
-
-  public void testGetApiAdapter() {
-    assertNotNull(features.getApiAdapter());
-  }
-}