core/tests/coretests/src/android/provider/SearchRecentSuggestionsProviderTest.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2008 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 android.provider;

 import android.app.SearchManager;
 import android.content.ContentResolver;
 import android.database.Cursor;
 import android.net.Uri;
 import android.test.ProviderTestCase2;
 import android.test.suitebuilder.annotation.MediumTest;

 /**
  * ProviderTestCase that performs unit tests of SearchRecentSuggestionsProvider.
  *
  * You can run this test in isolation via the commands:
  *
  * $ (cd tests/FrameworkTests/ && mm) && adb sync
  * $ adb shell am instrument -w \
  *     -e class android.provider.SearchRecentSuggestionsProviderTest
  *     com.android.frameworktest.tests/android.test.InstrumentationTestRunner
  */
 @MediumTest
 public class SearchRecentSuggestionsProviderTest extends ProviderTestCase2<TestProvider> {

     // Elements prepared by setUp()
     SearchRecentSuggestions mSearchHelper;

     public SearchRecentSuggestionsProviderTest() {
         super(TestProvider.class, TestProvider.AUTHORITY);
     }

     /**
      * During setup, grab a helper for DB access
      */
     @Override
     public void setUp() throws Exception {
         super.setUp();

         // Use the recent suggestions helper.  As long as we pass in our isolated context,
         // it should correctly access the provider under test.
         mSearchHelper = new SearchRecentSuggestions(getMockContext(),
                 TestProvider.AUTHORITY, TestProvider.MODE);

         // test for empty database at setup time
         checkOpenCursorCount(0);
     }

     /**
      * Simple test to see if we can instantiate the whole mess.
      */
     public void testSetup() {
         assertTrue(true);
     }

     /**
      * Simple test to see if we can write and read back a single query
      */
     public void testOneQuery() {
         final String TEST_LINE1 = "test line 1";
         final String TEST_LINE2 = "test line 2";
         mSearchHelper.saveRecentQuery(TEST_LINE1, TEST_LINE2);
         mSearchHelper.waitForSave();

         // make sure that there are is exactly one entry returned by a non-filtering cursor
         checkOpenCursorCount(1);

         // test non-filtering cursor for correct entry
         checkResultCounts(null, 1, 1, TEST_LINE1, TEST_LINE2);

         // test filtering cursor for correct entry
         checkResultCounts(TEST_LINE1, 1, 1, TEST_LINE1, TEST_LINE2);
         checkResultCounts(TEST_LINE2, 1, 1, TEST_LINE1, TEST_LINE2);

         // test that a different filter returns zero results
         checkResultCounts("bad filter", 0, 0, null, null);
     }

     /**
      * Simple test to see if we can write and read back a diverse set of queries
      */
     public void testMixedQueries() {
         // we'll make 10 queries named "query x" and 10 queries named "test x"
         final String TEST_GROUP_1 = "query ";
         final String TEST_GROUP_2 = "test ";
         final String TEST_LINE2 = "line2 ";
         final int GROUP_COUNT = 10;

         writeEntries(GROUP_COUNT, TEST_GROUP_1, TEST_LINE2);
         writeEntries(GROUP_COUNT, TEST_GROUP_2, TEST_LINE2);

         // check counts
         checkOpenCursorCount(2 * GROUP_COUNT);

         // check that each query returns the right result counts
         checkResultCounts(TEST_GROUP_1, GROUP_COUNT, GROUP_COUNT, null, null);
         checkResultCounts(TEST_GROUP_2, GROUP_COUNT, GROUP_COUNT, null, null);
         checkResultCounts(TEST_LINE2, 2 * GROUP_COUNT, 2 * GROUP_COUNT, null, null);
     }

     /**
      * Test that the reordering code works properly.  The most recently injected queries
      * should replace existing queries and be sorted to the top of the list.
      */
     public void testReordering() {
         // first we'll make 10 queries named "group1 x"
         final int GROUP_1_COUNT = 10;
         final String GROUP_1_QUERY = "group1 ";
         final String GROUP_1_LINE2 = "line2 ";
         writeEntries(GROUP_1_COUNT, GROUP_1_QUERY, GROUP_1_LINE2);

         // check totals
         checkOpenCursorCount(GROUP_1_COUNT);

         // guarantee that group 1 has older timestamps
         writeDelay();

         // next we'll add 10 entries named "group2 x"
         final int GROUP_2_COUNT = 10;
         final String GROUP_2_QUERY = "group2 ";
         final String GROUP_2_LINE2 = "line2 ";
         writeEntries(GROUP_2_COUNT, GROUP_2_QUERY, GROUP_2_LINE2);

         // check totals
         checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

         // guarantee that group 2 has older timestamps
         writeDelay();

         // now refresh 5 of the 10 from group 1
         // change line2 so they can be more easily tracked
         final int GROUP_3_COUNT = 5;
         final String GROUP_3_QUERY = GROUP_1_QUERY;
         final String GROUP_3_LINE2 = "refreshed ";
         writeEntries(GROUP_3_COUNT, GROUP_3_QUERY, GROUP_3_LINE2);

         // confirm that the total didn't change (those were replacements, not adds)
         checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

         // confirm that the are now 5 in group 1, 10 in group 2, and 5 in group 3
         int newGroup1Count = GROUP_1_COUNT - GROUP_3_COUNT;
         checkResultCounts(GROUP_1_QUERY, newGroup1Count, newGroup1Count, null, GROUP_1_LINE2);
         checkResultCounts(GROUP_2_QUERY, GROUP_2_COUNT, GROUP_2_COUNT, null, null);
         checkResultCounts(GROUP_3_QUERY, GROUP_3_COUNT, GROUP_3_COUNT, null, GROUP_3_LINE2);

         // finally, spot check that the right groups are in the right places
         // the ordering should be group 3 (newest), group 2, group 1 (oldest)
         Cursor c = getQueryCursor(null);
         int colQuery = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_QUERY);
         int colDisplay1 = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_TEXT_1);
         int colDisplay2 = c.getColumnIndex(SearchManager.SUGGEST_COLUMN_TEXT_2);

         // Spot check the first and last expected entries of group 3
         c.moveToPosition(0);
         assertTrue("group 3 did not properly reorder to head of list",
                 checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_3_QUERY, GROUP_3_LINE2));
         c.move(GROUP_3_COUNT - 1);
         assertTrue("group 3 did not properly reorder to head of list",
                 checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_3_QUERY, GROUP_3_LINE2));

         // Spot check the first and last expected entries of group 2
         c.move(1);
         assertTrue("group 2 not in expected position after reordering",
                 checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_2_QUERY, GROUP_2_LINE2));
         c.move(GROUP_2_COUNT - 1);
         assertTrue("group 2 not in expected position after reordering",
                 checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_2_QUERY, GROUP_2_LINE2));

         // Spot check the first and last expected entries of group 1
         c.move(1);
         assertTrue("group 1 not in expected position after reordering",
                 checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_1_QUERY, GROUP_1_LINE2));
         c.move(newGroup1Count - 1);
         assertTrue("group 1 not in expected position after reordering",
                 checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_1_QUERY, GROUP_1_LINE2));

         c.close();
     }

     /**
      * Test that the pruning code works properly,  The database should not go beyond 250 entries,
      * and the oldest entries should always be discarded first.
      *
      * TODO:  This is a slow test, do we have annotation for that?
      */
     public void testPruning() {
         // first we'll make 50 queries named "group1 x"
         final int GROUP_1_COUNT = 50;
         final String GROUP_1_QUERY = "group1 ";
         final String GROUP_1_LINE2 = "line2 ";
         writeEntries(GROUP_1_COUNT, GROUP_1_QUERY, GROUP_1_LINE2);

         // check totals
         checkOpenCursorCount(GROUP_1_COUNT);

         // guarantee that group 1 has older timestamps (and will be pruned first)
         writeDelay();

         // next we'll add 200 entries named "group2 x"
         final int GROUP_2_COUNT = 200;
         final String GROUP_2_QUERY = "group2 ";
         final String GROUP_2_LINE2 = "line2 ";
         writeEntries(GROUP_2_COUNT, GROUP_2_QUERY, GROUP_2_LINE2);

         // check totals
         checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

         // Finally we'll add 10 more entries named "group3 x"
         // These should push out 10 entries from group 1
         final int GROUP_3_COUNT = 10;
         final String GROUP_3_QUERY = "group3 ";
         final String GROUP_3_LINE2 = "line2 ";
         writeEntries(GROUP_3_COUNT, GROUP_3_QUERY, GROUP_3_LINE2);

         // total should still be 250
         checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

         // there should be 40 group 1, 200 group 2, and 10 group 3
         int group1NewCount = GROUP_1_COUNT-GROUP_3_COUNT;
         checkResultCounts(GROUP_1_QUERY, group1NewCount, group1NewCount, null, null);
         checkResultCounts(GROUP_2_QUERY, GROUP_2_COUNT, GROUP_2_COUNT, null, null);
         checkResultCounts(GROUP_3_QUERY, GROUP_3_COUNT, GROUP_3_COUNT, null, null);
     }

     /**
      * Test that the clear history code works properly.
      */
     public void testClear() {
         // first we'll make 10 queries named "group1 x"
         final int GROUP_1_COUNT = 10;
         final String GROUP_1_QUERY = "group1 ";
         final String GROUP_1_LINE2 = "line2 ";
         writeEntries(GROUP_1_COUNT, GROUP_1_QUERY, GROUP_1_LINE2);

         // next we'll add 10 entries named "group2 x"
         final int GROUP_2_COUNT = 10;
         final String GROUP_2_QUERY = "group2 ";
         final String GROUP_2_LINE2 = "line2 ";
         writeEntries(GROUP_2_COUNT, GROUP_2_QUERY, GROUP_2_LINE2);

         // check totals
         checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

         // delete all
         mSearchHelper.clearHistory();

         // check totals
         checkOpenCursorCount(0);
     }

     /**
      * Write a sequence of queries into the database, with incrementing counters in the strings.
      */
     private void writeEntries(int groupCount, String line1Base, String line2Base) {
         for (int i = 0; i < groupCount; i++) {
             final String line1 = line1Base + i;
             final String line2 = line2Base + i;
             mSearchHelper.saveRecentQuery(line1, line2);
             mSearchHelper.waitForSave();
         }
     }

     /**
      * A very slight delay to ensure that successive groups of queries in the DB cannot
      * have the same timestamp.
      */
     private void writeDelay() {
         try {
             Thread.sleep(10);
         } catch (InterruptedException e) {
             fail("Interrupted sleep.");
         }
     }

     /**
      * Access an "open" (no selection) suggestions cursor and confirm that it has the specified
      * number of entries.
      *
      * @param expectCount The expected number of entries returned by the cursor.
      */
     private void checkOpenCursorCount(int expectCount) {
         Cursor c = getQueryCursor(null);
         assertEquals(expectCount, c.getCount());
         c.close();
     }

     /**
      * Set up a filter cursor and then scan it for specific results.
      *
      * @param queryString The query string to apply.
      * @param minRows The minimum number of matching rows that must be found.
      * @param maxRows The maximum number of matching rows that must be found.
      * @param matchDisplay1 If non-null, must match DISPLAY1 column if row counts as match
      * @param matchDisplay2 If non-null, must match DISPLAY2 column if row counts as match
      */
     private void checkResultCounts(String queryString, int minRows, int maxRows,
             String matchDisplay1, String matchDisplay2) {

         // get the cursor and apply sanity checks to result
         Cursor c = getQueryCursor(queryString);
         assertNotNull(c);
         assertTrue("Insufficient rows in filtered cursor", c.getCount() >= minRows);

         // look for minimum set of columns (note, display2 is optional)
         int colQuery = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_QUERY);
         int colDisplay1 = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_TEXT_1);
         int colDisplay2 = c.getColumnIndex(SearchManager.SUGGEST_COLUMN_TEXT_2);

         // now loop through rows and look for desired rows
         int foundRows = 0;
         c.moveToFirst();
         while (!c.isAfterLast()) {
             if (checkRow(c, colQuery, colDisplay1, colDisplay2, matchDisplay1, matchDisplay2)) {
                 foundRows++;
             }
             c.moveToNext();
         }

         // now check the results
         assertTrue(minRows <= foundRows);
         assertTrue(foundRows <= maxRows);

         c.close();
     }

     /**
      * Check a single row for equality with target strings.
      *
      * @param c The cursor, already moved to the row
      * @param colQuery The column # containing the query.  The query must match display1.
      * @param colDisp1 The column # containing display line 1.
      * @param colDisp2 The column # containing display line 2, or -1 if no column
      * @param matchDisplay1 If non-null, this must be the prefix of display1
      * @param matchDisplay2 If non-null, this must be the prefix of display2
      * @return Returns true if the row is a "match"
      */
     private boolean checkRow(Cursor c, int colQuery, int colDisp1, int colDisp2,
             String matchDisplay1, String matchDisplay2) {
         // Get the data from the row
         String query = c.getString(colQuery);
         String display1 = c.getString(colDisp1);
         String display2 = (colDisp2 >= 0) ? c.getString(colDisp2) : null;

         assertEquals(query, display1);
         boolean result = true;
         if (matchDisplay1 != null) {
             result = result && (display1 != null) && display1.startsWith(matchDisplay1);
         }
         if (matchDisplay2 != null) {
             result = result && (display2 != null) && display2.startsWith(matchDisplay2);
         }

         return result;
     }

     /**
      * Generate a query cursor in a manner like the search dialog would.
      *
      * @param queryString The search string, or, null for "all"
      * @return Returns a cursor, or null if there was some problem.  Be sure to close the cursor
      * when done with it.
      */
     private Cursor getQueryCursor(String queryString) {
         ContentResolver cr = getMockContext().getContentResolver();

         String uriStr = "content://" + TestProvider.AUTHORITY +
         '/' + SearchManager.SUGGEST_URI_PATH_QUERY;
         Uri contentUri = Uri.parse(uriStr);

         String[] selArgs = new String[] {queryString};

         Cursor c = cr.query(contentUri, null, null, selArgs, null);

         assertNotNull(c);
         return c;
     }
 }
	/*
	* Copyright (C) 2008 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 android.provider;

	import android.app.SearchManager;
	import android.content.ContentResolver;
	import android.database.Cursor;
	import android.net.Uri;
	import android.test.ProviderTestCase2;
	import android.test.suitebuilder.annotation.MediumTest;

	/**
	* ProviderTestCase that performs unit tests of SearchRecentSuggestionsProvider.
	*
	* You can run this test in isolation via the commands:
	*
	* $ (cd tests/FrameworkTests/ && mm) && adb sync
	* $ adb shell am instrument -w \
	* -e class android.provider.SearchRecentSuggestionsProviderTest
	* com.android.frameworktest.tests/android.test.InstrumentationTestRunner
	*/
	@MediumTest
	public class SearchRecentSuggestionsProviderTest extends ProviderTestCase2<TestProvider> {

	// Elements prepared by setUp()
	SearchRecentSuggestions mSearchHelper;

	public SearchRecentSuggestionsProviderTest() {
	super(TestProvider.class, TestProvider.AUTHORITY);
	}

	/**
	* During setup, grab a helper for DB access
	*/
	@Override
	public void setUp() throws Exception {
	super.setUp();

	// Use the recent suggestions helper. As long as we pass in our isolated context,
	// it should correctly access the provider under test.
	mSearchHelper = new SearchRecentSuggestions(getMockContext(),
	TestProvider.AUTHORITY, TestProvider.MODE);

	// test for empty database at setup time
	checkOpenCursorCount(0);
	}

	/**
	* Simple test to see if we can instantiate the whole mess.
	*/
	public void testSetup() {
	assertTrue(true);
	}

	/**
	* Simple test to see if we can write and read back a single query
	*/
	public void testOneQuery() {
	final String TEST_LINE1 = "test line 1";
	final String TEST_LINE2 = "test line 2";
	mSearchHelper.saveRecentQuery(TEST_LINE1, TEST_LINE2);
	mSearchHelper.waitForSave();

	// make sure that there are is exactly one entry returned by a non-filtering cursor
	checkOpenCursorCount(1);

	// test non-filtering cursor for correct entry
	checkResultCounts(null, 1, 1, TEST_LINE1, TEST_LINE2);

	// test filtering cursor for correct entry
	checkResultCounts(TEST_LINE1, 1, 1, TEST_LINE1, TEST_LINE2);
	checkResultCounts(TEST_LINE2, 1, 1, TEST_LINE1, TEST_LINE2);

	// test that a different filter returns zero results
	checkResultCounts("bad filter", 0, 0, null, null);
	}

	/**
	* Simple test to see if we can write and read back a diverse set of queries
	*/
	public void testMixedQueries() {
	// we'll make 10 queries named "query x" and 10 queries named "test x"
	final String TEST_GROUP_1 = "query ";
	final String TEST_GROUP_2 = "test ";
	final String TEST_LINE2 = "line2 ";
	final int GROUP_COUNT = 10;

	writeEntries(GROUP_COUNT, TEST_GROUP_1, TEST_LINE2);
	writeEntries(GROUP_COUNT, TEST_GROUP_2, TEST_LINE2);

	// check counts
	checkOpenCursorCount(2 * GROUP_COUNT);

	// check that each query returns the right result counts
	checkResultCounts(TEST_GROUP_1, GROUP_COUNT, GROUP_COUNT, null, null);
	checkResultCounts(TEST_GROUP_2, GROUP_COUNT, GROUP_COUNT, null, null);
	checkResultCounts(TEST_LINE2, 2 * GROUP_COUNT, 2 * GROUP_COUNT, null, null);
	}

	/**
	* Test that the reordering code works properly. The most recently injected queries
	* should replace existing queries and be sorted to the top of the list.
	*/
	public void testReordering() {
	// first we'll make 10 queries named "group1 x"
	final int GROUP_1_COUNT = 10;
	final String GROUP_1_QUERY = "group1 ";
	final String GROUP_1_LINE2 = "line2 ";
	writeEntries(GROUP_1_COUNT, GROUP_1_QUERY, GROUP_1_LINE2);

	// check totals
	checkOpenCursorCount(GROUP_1_COUNT);

	// guarantee that group 1 has older timestamps
	writeDelay();

	// next we'll add 10 entries named "group2 x"
	final int GROUP_2_COUNT = 10;
	final String GROUP_2_QUERY = "group2 ";
	final String GROUP_2_LINE2 = "line2 ";
	writeEntries(GROUP_2_COUNT, GROUP_2_QUERY, GROUP_2_LINE2);

	// check totals
	checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

	// guarantee that group 2 has older timestamps
	writeDelay();

	// now refresh 5 of the 10 from group 1
	// change line2 so they can be more easily tracked
	final int GROUP_3_COUNT = 5;
	final String GROUP_3_QUERY = GROUP_1_QUERY;
	final String GROUP_3_LINE2 = "refreshed ";
	writeEntries(GROUP_3_COUNT, GROUP_3_QUERY, GROUP_3_LINE2);

	// confirm that the total didn't change (those were replacements, not adds)
	checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

	// confirm that the are now 5 in group 1, 10 in group 2, and 5 in group 3
	int newGroup1Count = GROUP_1_COUNT - GROUP_3_COUNT;
	checkResultCounts(GROUP_1_QUERY, newGroup1Count, newGroup1Count, null, GROUP_1_LINE2);
	checkResultCounts(GROUP_2_QUERY, GROUP_2_COUNT, GROUP_2_COUNT, null, null);
	checkResultCounts(GROUP_3_QUERY, GROUP_3_COUNT, GROUP_3_COUNT, null, GROUP_3_LINE2);

	// finally, spot check that the right groups are in the right places
	// the ordering should be group 3 (newest), group 2, group 1 (oldest)
	Cursor c = getQueryCursor(null);
	int colQuery = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_QUERY);
	int colDisplay1 = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_TEXT_1);
	int colDisplay2 = c.getColumnIndex(SearchManager.SUGGEST_COLUMN_TEXT_2);

	// Spot check the first and last expected entries of group 3
	c.moveToPosition(0);
	assertTrue("group 3 did not properly reorder to head of list",
	checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_3_QUERY, GROUP_3_LINE2));
	c.move(GROUP_3_COUNT - 1);
	assertTrue("group 3 did not properly reorder to head of list",
	checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_3_QUERY, GROUP_3_LINE2));

	// Spot check the first and last expected entries of group 2
	c.move(1);
	assertTrue("group 2 not in expected position after reordering",
	checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_2_QUERY, GROUP_2_LINE2));
	c.move(GROUP_2_COUNT - 1);
	assertTrue("group 2 not in expected position after reordering",
	checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_2_QUERY, GROUP_2_LINE2));

	// Spot check the first and last expected entries of group 1
	c.move(1);
	assertTrue("group 1 not in expected position after reordering",
	checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_1_QUERY, GROUP_1_LINE2));
	c.move(newGroup1Count - 1);
	assertTrue("group 1 not in expected position after reordering",
	checkRow(c, colQuery, colDisplay1, colDisplay2, GROUP_1_QUERY, GROUP_1_LINE2));

	c.close();
	}

	/**
	* Test that the pruning code works properly, The database should not go beyond 250 entries,
	* and the oldest entries should always be discarded first.
	*
	* TODO: This is a slow test, do we have annotation for that?
	*/
	public void testPruning() {
	// first we'll make 50 queries named "group1 x"
	final int GROUP_1_COUNT = 50;
	final String GROUP_1_QUERY = "group1 ";
	final String GROUP_1_LINE2 = "line2 ";
	writeEntries(GROUP_1_COUNT, GROUP_1_QUERY, GROUP_1_LINE2);

	// check totals
	checkOpenCursorCount(GROUP_1_COUNT);

	// guarantee that group 1 has older timestamps (and will be pruned first)
	writeDelay();

	// next we'll add 200 entries named "group2 x"
	final int GROUP_2_COUNT = 200;
	final String GROUP_2_QUERY = "group2 ";
	final String GROUP_2_LINE2 = "line2 ";
	writeEntries(GROUP_2_COUNT, GROUP_2_QUERY, GROUP_2_LINE2);

	// check totals
	checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

	// Finally we'll add 10 more entries named "group3 x"
	// These should push out 10 entries from group 1
	final int GROUP_3_COUNT = 10;
	final String GROUP_3_QUERY = "group3 ";
	final String GROUP_3_LINE2 = "line2 ";
	writeEntries(GROUP_3_COUNT, GROUP_3_QUERY, GROUP_3_LINE2);

	// total should still be 250
	checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

	// there should be 40 group 1, 200 group 2, and 10 group 3
	int group1NewCount = GROUP_1_COUNT-GROUP_3_COUNT;
	checkResultCounts(GROUP_1_QUERY, group1NewCount, group1NewCount, null, null);
	checkResultCounts(GROUP_2_QUERY, GROUP_2_COUNT, GROUP_2_COUNT, null, null);
	checkResultCounts(GROUP_3_QUERY, GROUP_3_COUNT, GROUP_3_COUNT, null, null);
	}

	/**
	* Test that the clear history code works properly.
	*/
	public void testClear() {
	// first we'll make 10 queries named "group1 x"
	final int GROUP_1_COUNT = 10;
	final String GROUP_1_QUERY = "group1 ";
	final String GROUP_1_LINE2 = "line2 ";
	writeEntries(GROUP_1_COUNT, GROUP_1_QUERY, GROUP_1_LINE2);

	// next we'll add 10 entries named "group2 x"
	final int GROUP_2_COUNT = 10;
	final String GROUP_2_QUERY = "group2 ";
	final String GROUP_2_LINE2 = "line2 ";
	writeEntries(GROUP_2_COUNT, GROUP_2_QUERY, GROUP_2_LINE2);

	// check totals
	checkOpenCursorCount(GROUP_1_COUNT + GROUP_2_COUNT);

	// delete all
	mSearchHelper.clearHistory();

	// check totals
	checkOpenCursorCount(0);
	}

	/**
	* Write a sequence of queries into the database, with incrementing counters in the strings.
	*/
	private void writeEntries(int groupCount, String line1Base, String line2Base) {
	for (int i = 0; i < groupCount; i++) {
	final String line1 = line1Base + i;
	final String line2 = line2Base + i;
	mSearchHelper.saveRecentQuery(line1, line2);
	mSearchHelper.waitForSave();
	}
	}

	/**
	* A very slight delay to ensure that successive groups of queries in the DB cannot
	* have the same timestamp.
	*/
	private void writeDelay() {
	try {
	Thread.sleep(10);
	} catch (InterruptedException e) {
	fail("Interrupted sleep.");
	}
	}

	/**
	* Access an "open" (no selection) suggestions cursor and confirm that it has the specified
	* number of entries.
	*
	* @param expectCount The expected number of entries returned by the cursor.
	*/
	private void checkOpenCursorCount(int expectCount) {
	Cursor c = getQueryCursor(null);
	assertEquals(expectCount, c.getCount());
	c.close();
	}

	/**
	* Set up a filter cursor and then scan it for specific results.
	*
	* @param queryString The query string to apply.
	* @param minRows The minimum number of matching rows that must be found.
	* @param maxRows The maximum number of matching rows that must be found.
	* @param matchDisplay1 If non-null, must match DISPLAY1 column if row counts as match
	* @param matchDisplay2 If non-null, must match DISPLAY2 column if row counts as match
	*/
	private void checkResultCounts(String queryString, int minRows, int maxRows,
	String matchDisplay1, String matchDisplay2) {

	// get the cursor and apply sanity checks to result
	Cursor c = getQueryCursor(queryString);
	assertNotNull(c);
	assertTrue("Insufficient rows in filtered cursor", c.getCount() >= minRows);

	// look for minimum set of columns (note, display2 is optional)
	int colQuery = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_QUERY);
	int colDisplay1 = c.getColumnIndexOrThrow(SearchManager.SUGGEST_COLUMN_TEXT_1);
	int colDisplay2 = c.getColumnIndex(SearchManager.SUGGEST_COLUMN_TEXT_2);

	// now loop through rows and look for desired rows
	int foundRows = 0;
	c.moveToFirst();
	while (!c.isAfterLast()) {
	if (checkRow(c, colQuery, colDisplay1, colDisplay2, matchDisplay1, matchDisplay2)) {
	foundRows++;
	}
	c.moveToNext();
	}

	// now check the results
	assertTrue(minRows <= foundRows);
	assertTrue(foundRows <= maxRows);

	c.close();
	}

	/**
	* Check a single row for equality with target strings.
	*
	* @param c The cursor, already moved to the row
	* @param colQuery The column # containing the query. The query must match display1.
	* @param colDisp1 The column # containing display line 1.
	* @param colDisp2 The column # containing display line 2, or -1 if no column
	* @param matchDisplay1 If non-null, this must be the prefix of display1
	* @param matchDisplay2 If non-null, this must be the prefix of display2
	* @return Returns true if the row is a "match"
	*/
	private boolean checkRow(Cursor c, int colQuery, int colDisp1, int colDisp2,
	String matchDisplay1, String matchDisplay2) {
	// Get the data from the row
	String query = c.getString(colQuery);
	String display1 = c.getString(colDisp1);
	String display2 = (colDisp2 >= 0) ? c.getString(colDisp2) : null;

	assertEquals(query, display1);
	boolean result = true;
	if (matchDisplay1 != null) {
	result = result && (display1 != null) && display1.startsWith(matchDisplay1);
	}
	if (matchDisplay2 != null) {
	result = result && (display2 != null) && display2.startsWith(matchDisplay2);
	}

	return result;
	}

	/**
	* Generate a query cursor in a manner like the search dialog would.
	*
	* @param queryString The search string, or, null for "all"
	* @return Returns a cursor, or null if there was some problem. Be sure to close the cursor
	* when done with it.
	*/
	private Cursor getQueryCursor(String queryString) {
	ContentResolver cr = getMockContext().getContentResolver();

	String uriStr = "content://" + TestProvider.AUTHORITY +
	'/' + SearchManager.SUGGEST_URI_PATH_QUERY;
	Uri contentUri = Uri.parse(uriStr);

	String[] selArgs = new String[] {queryString};

	Cursor c = cr.query(contentUri, null, null, selArgs, null);

	assertNotNull(c);
	return c;
	}
	}