package android.content;
import android.app.SearchManager;
import android.database.Cursor;
import android.net.Uri;
import android.provider.SearchRecentSuggestions;
import android.test.ProviderTestCase2;
import android.test.suitebuilder.annotation.Suppress;
/**
* Very simple provider that I can instantiate right here.
*/
class TestProvider extends SearchRecentSuggestionsProvider {
final static String AUTHORITY = "android.content.TestProvider";
final static int MODE = DATABASE_MODE_QUERIES + DATABASE_MODE_2LINES;
public TestProvider() {
super();
setupSuggestions(AUTHORITY, MODE);
}
}
/**
* 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.content.SearchRecentSuggestionsProviderTest
* com.android.frameworktest.tests/android.test.InstrumentationTestRunner
*/
// Suppress these until bug http://b/issue?id=1416586 is fixed.
@Suppress
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);
// 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 testPrun
