/*
* Copyright (C) 2006 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 com.android.unit_tests;
import com.android.unit_tests.activity.LocalActivity;
import android.app.Activity;
import android.app.ISearchManager;
import android.app.SearchManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ProviderInfo;
import android.content.pm.ResolveInfo;
import android.content.res.Resources;
import android.content.res.XmlResourceParser;
import android.os.ServiceManager;
import android.server.search.SearchableInfo;
import android.server.search.SearchableInfo.ActionKeyInfo;
import android.test.ActivityInstrumentationTestCase;
import android.test.MoreAsserts;
import android.test.mock.MockContext;
import android.test.mock.MockPackageManager;
import android.test.suitebuilder.annotation.LargeTest;
import android.test.suitebuilder.annotation.MediumTest;
import android.util.AndroidRuntimeException;
import android.view.KeyEvent;
import java.util.ArrayList;
import java.util.List;
/**
* To launch this test from the command line:
*
* adb shell am instrument -w \
* -e class com.android.unit_tests.SearchManagerTest \
* com.android.unit_tests/android.test.InstrumentationTestRunner
*/
public class SearchManagerTest extends ActivityInstrumentationTestCase<LocalActivity> {
// If non-zero, enable a set of tests that start and stop the search manager.
// This is currently disabled because it's causing an unwanted jump from the unit test
// activity into the contacts activity. We'll put this back after we disable that jump.
private static final int TEST_SEARCH_START = 0;
/*
* Bug list of test ideas.
*
* testSearchManagerInterfaceAvailable()
* Exercise the interface obtained
*
* testSearchManagerAvailable()
* Exercise the interface obtained
*
* testSearchManagerInvocations()
* FIX - make it work again
* stress test with a very long string
*
* SearchableInfo tests
* Mock the context so I can provide very specific input data
* Confirm OK with "zero" searchables
* Confirm "good" metadata read properly
* Confirm "bad" metadata skipped properly
* Confirm ordering of searchables
* Confirm "good" actionkeys
* confirm "bad" actionkeys are rejected
* confirm XML ordering enforced (will fail today - bug in SearchableInfo)
* findActionKey works
* getIcon works
*
* SearchManager tests
* confirm proper identification of "default" activity based on policy, not hardcoded contacts
*
* SearchBar tests
* Maybe have to do with framework / unittest runner - need instrumented activity?
* How can we unit test the suggestions content providers?
* Should I write unit tests for any of them?
* Test scenarios:
* type-BACK (cancel)
* type-GO (send)
* type-navigate-click (suggestion)
* type-action
* type-navigate-action (suggestion)
*/
/**
* Local copy of activity context
*/
Context mContext;
public SearchManagerTest() {
super("com.android.unit_tests", LocalActivity.class);
}
/**
* Setup any common data for the upcoming tests.
*/
@Override
public void setUp() throws Exception {
super.setUp();
Activity testActivity = getActivity();
mContext = (Context)testActivity;
}
/**
* The goal of this test is to confirm that we can obtain
* a search manager interface.
*/
@MediumTest
public void testSearchManagerInterfaceAvailable() {
ISearchManager searchManager1 = ISearchManager.Stub.asInterface(
ServiceManager.getService(Context.SEARCH_SERVICE));
assertNotNull(searchManager1);
}
/**
* The goal of this test is to confirm that we can *only* obtain a search manager
* interface from an Activity context.
*/
@MediumTest
public void testSearchManagerContextRestrictions() {
SearchManager searchManager1 = (SearchManager)
mContext.getSystemService(Context.SEARCH_SERVICE);
assertNotNull(searchManager1);
Context applicationContext = mContext.getApplicationContext();
// this should fail, because you can't get a SearchManager from a non-Activity context
try {
applicationContext.getSystemService(Context.SEARCH_SERVICE);
assertFalse("Shouldn't retrieve SearchManager from a non-Activity context", true);
} catch (AndroidRuntimeException e) {
// happy here - we should catch this.
}
}
/**
* The goal of this test is to confirm that we can obtain
* a search manager at any time, and that for any given context,
* it is a singleton.
*/
@LargeTest
public void testSearchManagerAvailable() {
SearchManager searchManager1 = (SearchManager)
mContext.getSystemService(Context.SEARCH_SERVICE);
assertNotNull(searchManager1);
SearchManager searchManager2 = (SearchManager)
mContext.getSystemService(Context.SEARCH_SERVICE);
assertNotNull(searchManager2);
assertSame( searchManager1, searchManager2 );
}
/**
* The goal of this test is to confirm that we can start and then
* stop a simple search.
*/
@MediumTest
public void testSearchManagerInvocations() {
SearchManager searchManager = (SearchManager)
mContext.getSystemService(Context.SEARCH_SERVICE);
assertNotNull(searchManager);
// TODO: make a real component name, or remove this need
final ComponentName cn = new ComponentName("", "");
if (TEST_SEARCH_START != 0) {
// These tests should simply run to completion w/o exceptions
searchManager.startSearch(null, false, cn, null, false);
searchManager.stopSearch();
searchManager.startSearch("", false, cn, null, false);
searchManager.stopSearch();
searchManager.startSearch("test search string", false, cn, null, false);
searchManager.stopSearch();
searchManager.startSearch("test search string", true, cn, null, false);
searchManager.stopSearch();
}
}
/**
* The goal of this test is to confirm proper operation of the
* SearchableInfo helper class.
*
* TODO: The metadata source needs to be mocked out because adding
* searchability metadata via this test is causing it to leak into the
* real system. So for now I'm just going to test for existence of the
* GoogleSearch app (which is searchable).
*/
@LargeTest
public void testSearchableGoogleSearch() {
// test basic array & hashmap
SearchableInfo.buildSearchableList(mContext);
// test linkage from another activity
// TODO inject this via mocking into the package manager.
// TODO for now, just check for searchable GoogleSearch app (this isn't really a unit test)
ComponentName thisActivity = new ComponentName(
"com.android.googlesearch",
"com.android.googlesearch.GoogleSearch");
SearchableInfo si = SearchableInfo.getSearchableInfo(mContext, thisActivity);
assertNotNull(si);
assertTrue(si.mSearchable);
assertEquals(thisActivity, si.mSearchActivity);
Context appContext = si.getActivityContext(mContext);
assertNotNull(appContext);
MoreAsserts.assertNotEqual(appContext, mContext);
assertEquals("Google Search", appContext.getString(si.getHintId()));
assertEquals("Google", appContext.getString(si.getLabelId()));
}
/**
* Test that non-searchable activities return no searchable info (this would typically
* trigger the use of the default searchable e.g. contacts)
*/
@LargeTest
public void testNonSearchable() {
// test basic array & hashmap
SearchableInfo.buildSearchableList(mContext);
// confirm that we return null for non-searchy activities
ComponentName nonActivity = new ComponentName(
"com.android.unit_tests",
"com.android.unit_tests.NO_SEARCH_ACTIVITY");
SearchableInfo si = SearchableInfo.getSearchableInfo(mContext, nonActivity);
assertNull(si);
}
/**
* This is an attempt to run the searchable info list with a mocked context. Here are some
* things I'd like to test.
*
* Confirm OK with "zero" searchables
* Confirm "good" metadata read properly
* Confirm "bad" metadata skipped properly
* Confirm ordering of searchables
* Confirm "good" actionkeys
* confirm "bad" actionkeys are rejected
* confirm XML ordering enforced (will fail today - bug in SearchableInfo)
* findActionKey works
* getIcon works
*/
@LargeTest
public void testSearchableMocked() {
MyMockPackageManager mockPM = new MyMockPackageManager(mContext.getPackageManager());
MyMockContext mockContext = new MyMockContext(mContext, mockPM);
ArrayList<SearchableInfo> searchables;
int count;
// build item list with real-world source data
mockPM.setSearchablesMode(MyMockPackageManager.SEARCHABLES_PASSTHROUGH);
SearchableInfo.buildSearchableList(mockContext);
// tests with "real" searchables (deprecate, this should be a unit test)
searchables = SearchableInfo.getSearchablesList();
count = searchables.size();
assertTrue(count >= 1); // this isn't really a unit test
checkSearchables(searchables);
// build item list with mocked search data
// this round of tests confirms good operations with "zero" searchables found
// This should return either a null pointer or an empty list
mockPM.setSearchablesMode(MyMockPackageManager.SEARCHABLES_MOCK_ZERO);
SearchableInfo.buildSearchableList(mockContext);
searchables = SearchableInfo.getSearchablesList();
if (searchables != null) {
count = searchables.size();
assertTrue(count == 0);
}
}
/**
* Generic health checker for an array of searchables.
*
* This is designed to pass for any semi-legal searchable, without knowing much about
* the format of the underlying data. It's fairly easy for a non-compliant application
* to provide meta-data that will pass here (e.g. a non-existent suggestions authority).
*
* @param searchables The list of searchables to examine.
*/
private void checkSearchables(ArrayList<SearchableInfo> searchablesList) {
assertNotNull(searchablesList);
int count = searchablesList.size();
for (int ii = 0; ii < count; ii++) {
SearchableInfo si = searchablesList.get(ii);
assertNotNull(si);
assertTrue(si.mSearchable);
assertTrue(si.getLabelId() != 0); // This must be a useable string
assertNotEmpty(si.mSearchActivity.getClassName());
assertNotEmpty(si.mSearchActivity.getPackageName());
if (si.getSuggestAuthority() != null) {
// The suggestion fields are largely optional, so we'll just confirm basic health
assertNotEmpty(si.getSuggestAuthority());
assertNullOrNotEmpty(si.getSuggestPath());
assertNullOrNotEmpty(si.getSuggestSelection());
assertNullOrNotEmpty(si.getSuggestIntentAction());
assertNullOrNotEmpty(si.getSuggestIntentData());
}
/* Add a way to get the entire action key list, then explicitly test its elements */
/* For now, test the most common action key (CALL) */
ActionKeyInfo ai = si.findActionKey(KeyEvent.KEYCODE_CALL);
if (ai != null) {
assertEquals(ai.mKeyCode, KeyEvent.KEYCODE_CALL);
// one of these three fields must be non-null & non-empty
boolean m1 = (ai.mQueryActionMsg != null) && (ai.mQueryActionMsg.length() > 0);
boolean m2 = (ai.mSuggestActionMsg != null) && (ai.mSuggestActionMsg.length() > 0);
boolean m3 = (ai.mSuggestActionMsgColumn != null) &&
(ai.mSuggestActionMsgColumn.length() > 0);
assertTrue(m1 || m2 || m3);
}
/*
* Find ways to test these:
*
* private int mSearchMode
* private Drawable mIcon
*/
/*
* Explicitly not tested here:
*
* Can be null, so not much to see:
* public String mSearchHint
* private String mZeroQueryBanner
*
* To be deprecated/removed, so don't bother:
* public boolean mFilterMode
* public boolean mQuickStart
* private boolean mIconResized
* private int mIconResizeWidth
* private int mIconResizeHeight
*
* All of these are "internal" working variables, not part of any contract
* private ActivityInfo mActivityInfo
* private Rect mTempRect
* private String mSuggestProviderPackage
* private String mCacheActivityContext
*/
}
}
/**
* Combo assert for "string not null and not empty"
*/
private void assertNotEmpty(final String s) {
assertNotNull(s);
MoreAsserts.assertNotEqual(s, "");
}
/**
* Combo assert for "string null or (not null and not empty)"
*/
private void assertNullOrNotEmpty(final String s) {
if (s != null) {
MoreAsserts.assertNotEqual(s, "");
}
}
/**
* This is a mock for context. Used to perform a true unit test on SearchableInfo.
*
*/
private class MyMockContext extends MockContext {
protected Context mRealContext;
protected PackageManager mPackageManager;
/**
* Constructor.
*
* @param realContext Please pass in a real context for some pass-throughs to function.
*/
MyMockContext(Context realContext, PackageManager packageManager) {
mRealContext = realContext;
mPackageManager = packageManager;
}
/**
* Resources. Pass through for now.
*/
@Override
public Resources getResources() {
return mRealContext.getResources();
}
/**
* Package manager. Pass through for now.
*/
@Override
public PackageManager getPackageManager() {
return mPackageManager;
}
/**
* Package manager. Pass through for now.
*/
@Override
public Context createPackageContext(String packageName, int flags)
throws PackageManager.NameNotFoundException {
return mRealContext.createPackageContext(packageName, flags);
}
}
/**
* This is a mock for package manager. Used to perform a true unit test on SearchableInfo.
*
*/
private class MyMockPackageManager extends MockPackageManager {
public final static int SEARCHABLES_PASSTHROUGH = 0;
public final static int SEARCHABLES_MOCK_ZERO = 1;
public final static int SEARCHABLES_MOCK_ONEGOOD = 2;
public final static int SEARCHABLES_MOCK_ONEGOOD_ONEBAD = 3;
protected PackageManager mRealPackageManager;
protected int mSearchablesMode;
public MyMockPackageManager(PackageManager realPM) {
mRealPackageManager = realPM;
mSearchablesMode = SEARCHABLES_PASSTHROUGH;
}
/**
* Set the mode for various tests.
*/
public void setSearchablesMode(int newMode) {
switch (newMode) {
case SEARCHABLES_PASSTHROUGH:
case SEARCHABLES_MOCK_ZERO:
mSearchablesMode = newMode;
break;
default:
throw new UnsupportedOperationException();
}
}
/**
* Find activities that support a given intent.
*
* Retrieve all activities that can be performed for the given intent.
*
* @param intent The desired intent as per resolveActivity().
* @param flags Additional option flags. The most important is
* MATCH_DEFAULT_ONLY, to limit the resolution to only
* those activities that support the CATEGORY_DEFAULT.
*
* @return A List<ResolveInfo> containing one entry for each matching
* Activity. These are ordered from best to worst match -- that
* is, the first item in the list is what is returned by
* resolveActivity(). If there are no matching activities, an empty
* list is returned.
*/
@Override
public List<ResolveInfo> queryIntentActivities(Intent intent, int flags) {
assertNotNull(intent);
assertEquals(intent.getAction(), Intent.ACTION_SEARCH);
switch (mSearchablesMode) {
case SEARCHABLES_PASSTHROUGH:
return mRealPackageManager.queryIntentActivities(intent, flags);
case SEARCHABLES_MOCK_ZERO:
return null;
default:
throw new UnsupportedOperationException();
}
}
/**
* Retrieve an XML file from a package. This is a low-level API used to
* retrieve XML meta data.
*
* @param packageName The name of the package that this xml is coming from.
* Can not be null.
* @param resid The resource identifier of the desired xml. Can not be 0.
* @param appInfo Overall information about <var>packageName</var>. This
* may be null, in which case the application information will be retrieved
* for you if needed; if you already have this information around, it can
* be much more efficient to supply it here.
*
* @return Returns an XmlPullParser allowing you to parse out the XML
* data. Returns null if the xml resource could not be found for any
* reason.
*/
@Override
public XmlResourceParser getXml(String packageName, int resid, ApplicationInfo appInfo) {
assertNotNull(packageName);
MoreAsserts.assertNotEqual(packageName, "");
MoreAsserts.assertNotEqual(resid, 0);
switch (mSearchablesMode) {
case SEARCHABLES_PASSTHROUGH:
return mRealPackageManager.getXml(packageName, resid, appInfo);
case SEARCHABLES_MOCK_ZERO:
default:
throw new UnsupportedOperationException();
}
}
/**
* Find a single content provider by its base path name.
*
* @param name The name of the provider to find.
* @param flags Additional option flags. Currently should always be 0.
*
* @return ContentProviderInfo Information about the provider, if found,
* else null.
*/
@Override
public ProviderInfo resolveContentProvider(String name, int flags) {
assertNotNull(name);
MoreAsserts.assertNotEqual(name, "");
assertEquals(flags, 0);
switch (mSearchablesMode) {
case SEARCHABLES_PASSTHROUGH:
return mRealPackageManager.resolveContentProvider(name, flags);
case SEARCHABLES_MOCK_ZERO:
default:
throw new UnsupportedOperationException();
}
}
}
}