The Tor Browser: comparison mobile/android/base/tests/BaseTest.java

--1:000000000000
+:1065e139f95f
+/* 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/. */
+package org.mozilla.gecko.tests;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.mozilla.gecko.Actions;
+import org.mozilla.gecko.Driver;
+import org.mozilla.gecko.Element;
+import org.mozilla.gecko.FennecNativeActions;
+import org.mozilla.gecko.FennecNativeDriver;
+import org.mozilla.gecko.GeckoAppShell;
+import org.mozilla.gecko.GeckoEvent;
+import org.mozilla.gecko.GeckoThread;
+import org.mozilla.gecko.GeckoThread.LaunchState;
+import org.mozilla.gecko.R;
+import org.mozilla.gecko.RobocopUtils;
+import org.mozilla.gecko.Tab;
+import org.mozilla.gecko.Tabs;
+import android.app.Activity;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.res.AssetManager;
+import android.database.Cursor;
+import android.os.Build;
+import android.os.SystemClock;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentActivity;
+import android.support.v4.app.FragmentManager;
+import android.text.TextUtils;
+import android.util.DisplayMetrics;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AdapterView;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ListAdapter;
+import android.widget.TextView;
+import com.jayway.android.robotium.solo.Condition;
+import com.jayway.android.robotium.solo.Solo;
+/**
+*  A convenient base class suitable for most Robocop tests.
+*/
+@SuppressWarnings("unchecked")
+abstract class BaseTest extends BaseRobocopTest {
+private static final int VERIFY_URL_TIMEOUT = 2000;
+private static final int MAX_WAIT_ENABLED_TEXT_MS = 10000;
+private static final int MAX_WAIT_HOME_PAGER_HIDDEN_MS = 15000;
+public static final int MAX_WAIT_MS = 4500;
+public static final int LONG_PRESS_TIME = 6000;
+private static final int GECKO_READY_WAIT_MS = 180000;
+public static final int MAX_WAIT_BLOCK_FOR_EVENT_DATA_MS = 90000;
+private Activity mActivity;
+private int mPreferenceRequestID = 0;
+protected Solo mSolo;
+protected Driver mDriver;
+protected Actions mActions;
+protected String mBaseUrl;
+protected String mRawBaseUrl;
+protected String mProfile;
+public Device mDevice;
+protected DatabaseHelper mDatabaseHelper;
+protected StringHelper mStringHelper;
+protected int mScreenMidWidth;
+protected int mScreenMidHeight;
+protected void blockForGeckoReady() {
+try {
+Actions.EventExpecter geckoReadyExpector = mActions.expectGeckoEvent("Gecko:Ready");
+if (!GeckoThread.checkLaunchState(LaunchState.GeckoRunning)) {
+geckoReadyExpector.blockForEvent(GECKO_READY_WAIT_MS, true);
+}
+geckoReadyExpector.unregisterListener();
+} catch (Exception e) {
+mAsserter.dumpLog("Exception in blockForGeckoReady", e);
+}
+}
+@Override
+public void setUp() throws Exception {
+super.setUp();
+// Create the intent to be used with all the important arguments.
+mBaseUrl = ((String) mConfig.get("host")).replaceAll("(/$)", "");
+mRawBaseUrl = ((String) mConfig.get("rawhost")).replaceAll("(/$)", "");
+Intent i = new Intent(Intent.ACTION_MAIN);
+mProfile = (String) mConfig.get("profile");
+i.putExtra("args", "-no-remote -profile " + mProfile);
+String envString = (String) mConfig.get("envvars");
+if (envString != "") {
+String[] envStrings = envString.split(",");
+for (int iter = 0; iter < envStrings.length; iter++) {
+i.putExtra("env" + iter, envStrings[iter]);
+}
+}
+// Start the activity
+setActivityIntent(i);
+mActivity = getActivity();
+// Set up Robotium.solo and Driver objects
+mSolo = new Solo(getInstrumentation(), mActivity);
+mDriver = new FennecNativeDriver(mActivity, mSolo, mRootPath);
+mActions = new FennecNativeActions(mActivity, mSolo, getInstrumentation(), mAsserter);
+mDevice = new Device();
+mDatabaseHelper = new DatabaseHelper(mActivity, mAsserter);
+mStringHelper = new StringHelper();
+}
+@Override
+protected void runTest() throws Throwable {
+try {
+super.runTest();
+} catch (Throwable t) {
+// save screenshot -- written to /mnt/sdcard/Robotium-Screenshots
+// as <filename>.jpg
+mSolo.takeScreenshot("robocop-screenshot");
+if (mAsserter != null) {
+mAsserter.dumpLog("Exception caught during test!", t);
+mAsserter.ok(false, "Exception caught", t.toString());
+}
+// re-throw to continue bail-out
+throw t;
+}
+}
+@Override
+public void tearDown() throws Exception {
+try {
+mAsserter.endTest();
+// request a force quit of the browser and wait for it to take effect
+GeckoAppShell.sendEventToGecko(GeckoEvent.createBroadcastEvent("Robocop:Quit", null));
+mSolo.sleep(7000);
+// if still running, finish activities as recommended by Robotium
+mSolo.finishOpenedActivities();
+} catch (Throwable e) {
+e.printStackTrace();
+}
+super.tearDown();
+}
+public void assertMatches(String value, String regex, String name) {
+if (value == null) {
+mAsserter.ok(false, name, "Expected /" + regex + "/, got null");
+return;
+}
+mAsserter.ok(value.matches(regex), name, "Expected /" + regex +"/, got \"" + value + "\"");
+}
+/**
+* Click on the URL bar to focus it and enter editing mode.
+*/
+protected final void focusUrlBar() {
+// Click on the browser toolbar to enter editing mode
+final View toolbarView = mSolo.getView(R.id.browser_toolbar);
+mSolo.clickOnView(toolbarView);
+// Wait for highlighed text to gain focus
+boolean success = waitForCondition(new Condition() {
+@Override
+public boolean isSatisfied() {
+EditText urlEditText = (EditText) mSolo.getView(R.id.url_edit_text);
+if (urlEditText.isInputMethodTarget()) {
+return true;
+}
+return false;
+}
+}, MAX_WAIT_ENABLED_TEXT_MS);
+mAsserter.ok(success, "waiting for urlbar text to gain focus", "urlbar text gained focus");
+}
+protected final void enterUrl(String url) {
+final EditText urlEditView = (EditText) mSolo.getView(R.id.url_edit_text);
+focusUrlBar();
+// Send the keys for the URL we want to enter
+mSolo.clearEditText(urlEditView);
+mSolo.enterText(urlEditView, url);
+// Get the URL text from the URL bar EditText view
+final String urlBarText = urlEditView.getText().toString();
+mAsserter.is(url, urlBarText, "URL typed properly");
+}
+protected final Fragment getBrowserSearch() {
+final FragmentManager fm = ((FragmentActivity) getActivity()).getSupportFragmentManager();
+return fm.findFragmentByTag("browser_search");
+}
+protected final void hitEnterAndWait() {
+Actions.EventExpecter contentEventExpecter = mActions.expectGeckoEvent("DOMContentLoaded");
+mActions.sendSpecialKey(Actions.SpecialKey.ENTER);
+// wait for screen to load
+contentEventExpecter.blockForEvent();
+contentEventExpecter.unregisterListener();
+}
+/**
+* Load <code>url</code> by sending key strokes to the URL bar UI.
+*
+* This method waits synchronously for the <code>DOMContentLoaded</code>
+* message from Gecko before returning.
+*/
+protected final void inputAndLoadUrl(String url) {
+enterUrl(url);
+hitEnterAndWait();
+}
+/**
+* Load <code>url</code> using reflection and the internal
+* <code>org.mozilla.gecko.Tabs</code> API.
+*
+* This method does not wait for any confirmation from Gecko before
+* returning.
+*/
+protected final void loadUrl(final String url) {
+try {
+Tabs.getInstance().loadUrl(url);
+} catch (Exception e) {
+mAsserter.dumpLog("Exception in loadUrl", e);
+throw new RuntimeException(e);
+}
+}
+protected final void closeTab(int tabId) {
+Tabs tabs = Tabs.getInstance();
+Tab tab = tabs.getTab(tabId);
+tabs.closeTab(tab);
+}
+public final void verifyUrl(String url) {
+final EditText urlEditText = (EditText) mSolo.getView(R.id.url_edit_text);
+String urlBarText = null;
+if (urlEditText != null) {
+// wait for a short time for the expected text, in case there is a delay
+// in updating the view
+waitForCondition(new VerifyTextViewText(urlEditText, url), VERIFY_URL_TIMEOUT);
+urlBarText = urlEditText.getText().toString();
+}
+mAsserter.is(urlBarText, url, "Browser toolbar URL stayed the same");
+}
+class VerifyTextViewText implements Condition {
+private TextView mTextView;
+private String mExpected;
+public VerifyTextViewText(TextView textView, String expected) {
+mTextView = textView;
+mExpected = expected;
+}
+@Override
+public boolean isSatisfied() {
+String textValue = mTextView.getText().toString();
+return mExpected.equals(textValue);
+}
+}
+protected final String getAbsoluteUrl(String url) {
+return mBaseUrl + "/" + url.replaceAll("(^/)", "");
+}
+protected final String getAbsoluteRawUrl(String url) {
+return mRawBaseUrl + "/" + url.replaceAll("(^/)", "");
+}
+/*
+* Wrapper method for mSolo.waitForCondition with additional logging.
+*/
+protected final boolean waitForCondition(Condition condition, int timeout) {
+boolean result = mSolo.waitForCondition(condition, timeout);
+if (!result) {
+// Log timeout failure for diagnostic purposes only; a failed wait may
+// be normal and does not necessarily warrant a test asssertion/failure.
+mAsserter.dumpLog("waitForCondition timeout after " + timeout + " ms.");
+}
+return result;
+}
+// TODO: With Robotium 4.2, we should use Condition and waitForCondition instead.
+// Future boolean tests should not use this method.
+protected final boolean waitForTest(BooleanTest t, int timeout) {
+long end = SystemClock.uptimeMillis() + timeout;
+while (SystemClock.uptimeMillis() < end) {
+if (t.test()) {
+return true;
+}
+mSolo.sleep(100);
+}
+// log out wait failure for diagnostic purposes only;
+// a failed wait may be normal and does not necessarily
+// warrant a test assertion/failure
+mAsserter.dumpLog("waitForTest timeout after "+timeout+" ms");
+return false;
+}
+// TODO: With Robotium 4.2, we should use Condition and waitForCondition instead.
+// Future boolean tests should not implement this interface.
+protected interface BooleanTest {
+public boolean test();
+}
+public void SqliteCompare(String dbName, String sqlCommand, ContentValues[] cvs) {
+File profile = new File(mProfile);
+String dbPath = new File(profile, dbName).getPath();
+Cursor c = mActions.querySql(dbPath, sqlCommand);
+SqliteCompare(c, cvs);
+}
+public void SqliteCompare(Cursor c, ContentValues[] cvs) {
+mAsserter.is(c.getCount(), cvs.length, "List is correct length");
+if (c.moveToFirst()) {
+do {
+boolean found = false;
+for (int i = 0; !found && i < cvs.length; i++) {
+if (CursorMatches(c, cvs[i])) {
+found = true;
+}
+}
+mAsserter.is(found, true, "Password was found");
+} while (c.moveToNext());
+}
+}
+public boolean CursorMatches(Cursor c, ContentValues cv) {
+for (int i = 0; i < c.getColumnCount(); i++) {
+String column = c.getColumnName(i);
+if (cv.containsKey(column)) {
+mAsserter.info("Comparing", "Column values for: " + column);
+Object value = cv.get(column);
+if (value == null) {
+if (!c.isNull(i)) {
+return false;
+}
+} else {
+if (c.isNull(i) || !value.toString().equals(c.getString(i))) {
+return false;
+}
+}
+}
+}
+return true;
+}
+public InputStream getAsset(String filename) throws IOException {
+AssetManager assets = getInstrumentation().getContext().getAssets();
+return assets.open(filename);
+}
+public boolean waitForText(String text) {
+boolean rc = mSolo.waitForText(text);
+if (!rc) {
+// log out failed wait for diagnostic purposes only;
+// waitForText failures are sometimes expected/normal
+mAsserter.dumpLog("waitForText timeout on "+text);
+}
+return rc;
+}
+// waitForText usually scrolls down in a view when text is not visible.
+// For PreferenceScreens and dialogs, Solo.waitForText scrolling does not
+// work, so we use this hack to do the same thing.
+protected boolean waitForPreferencesText(String txt) {
+boolean foundText = waitForText(txt);
+if (!foundText) {
+if ((mScreenMidWidth == 0) || (mScreenMidHeight == 0)) {
+mScreenMidWidth = mDriver.getGeckoWidth()/2;
+mScreenMidHeight = mDriver.getGeckoHeight()/2;
+}
+// If we don't see the item, scroll down once in case it's off-screen.
+// Hacky way to scroll down.  solo.scroll* does not work in dialogs.
+MotionEventHelper meh = new MotionEventHelper(getInstrumentation(), mDriver.getGeckoLeft(), mDriver.getGeckoTop());
+meh.dragSync(mScreenMidWidth, mScreenMidHeight+100, mScreenMidWidth, mScreenMidHeight-100);
+foundText = mSolo.waitForText(txt);
+}
+return foundText;
+}
+/**
+* Wait for <text> to be visible and also be enabled/clickable.
+*/
+public boolean waitForEnabledText(String text) {
+final String testText = text;
+boolean rc = waitForCondition(new Condition() {
+@Override
+public boolean isSatisfied() {
+// Solo.getText() could be used here, except that it sometimes
+// hits an assertion when the requested text is not found.
+ArrayList<View> views = mSolo.getCurrentViews();
+for (View view : views) {
+if (view instanceof TextView) {
+TextView tv = (TextView)view;
+String viewText = tv.getText().toString();
+if (tv.isEnabled() && viewText != null && viewText.matches(testText)) {
+return true;
+}
+}
+}
+return false;
+}
+}, MAX_WAIT_ENABLED_TEXT_MS);
+if (!rc) {
+// log out failed wait for diagnostic purposes only;
+// failures are sometimes expected/normal
+mAsserter.dumpLog("waitForEnabledText timeout on "+text);
+}
+return rc;
+}
+/**
+* Select <item> from Menu > "Settings" > <section>.
+*/
+public void selectSettingsItem(String section, String item) {
+String[] itemPath = { "Settings", section, item };
+selectMenuItemByPath(itemPath);
+}
+/**
+* Traverses the items in listItems in order in the menu.
+*/
+public void selectMenuItemByPath(String[] listItems) {
+int listLength = listItems.length;
+if (listLength > 0) {
+selectMenuItem(listItems[0]);
+}
+if (listLength > 1) {
+for (int i = 1; i < listLength; i++) {
+String itemName = "^" + listItems[i] + "$";
+mAsserter.ok(waitForPreferencesText(itemName), "Waiting for and scrolling once to find item " + itemName, itemName + " found");
+mAsserter.ok(waitForEnabledText(itemName), "Waiting for enabled text " + itemName, itemName + " option is present and enabled");
+mSolo.clickOnText(itemName);
+}
+}
+}
+public final void selectMenuItem(String menuItemName) {
+// build the item name ready to be used
+String itemName = "^" + menuItemName + "$";
+mActions.sendSpecialKey(Actions.SpecialKey.MENU);
+if (waitForText(itemName)) {
+mSolo.clickOnText(itemName);
+} else {
+// Older versions of Android have additional settings under "More",
+// including settings that newer versions have under "Tools."
+if (mSolo.searchText("(^More$|^Tools$)")) {
+mSolo.clickOnText("(^More$|^Tools$)");
+}
+waitForText(itemName);
+mSolo.clickOnText(itemName);
+}
+}
+public final void verifyHomePagerHidden() {
+final View homePagerContainer = mSolo.getView(R.id.home_pager_container);
+boolean rc = waitForCondition(new Condition() {
+@Override
+public boolean isSatisfied() {
+return homePagerContainer.getVisibility() != View.VISIBLE;
+}
+}, MAX_WAIT_HOME_PAGER_HIDDEN_MS);
+if (!rc) {
+mAsserter.ok(rc, "Verify HomePager is hidden", "HomePager is hidden");
+}
+}
+public final void verifyPageTitle(String title) {
+final TextView urlBarTitle = (TextView) mSolo.getView(R.id.url_bar_title);
+String pageTitle = null;
+if (urlBarTitle != null) {
+// Wait for the title to make sure it has been displayed in case the view
+// does not update fast enough
+waitForCondition(new VerifyTextViewText(urlBarTitle, title), MAX_WAIT_MS);
+pageTitle = urlBarTitle.getText().toString();
+}
+mAsserter.is(pageTitle, title, "Page title is correct");
+}
+public final void verifyTabCount(int expectedTabCount) {
+Element tabCount = mDriver.findElement(getActivity(), R.id.tabs_counter);
+String tabCountText = tabCount.getText();
+int tabCountInt = Integer.parseInt(tabCountText);
+mAsserter.is(tabCountInt, expectedTabCount, "The correct number of tabs are opened");
+}
+// Used to perform clicks on pop-up buttons without having to close the virtual keyboard
+public void clickOnButton(String label) {
+final Button button = mSolo.getButton(label);
+try {
+runTestOnUiThread(new Runnable() {
+@Override
+public void run() {
+button.performClick();
+}
+});
+} catch (Throwable throwable) {
+mAsserter.ok(false, "Unable to click the button","Was unable to click button ");
+}
+}
+// Used to hide/show the virtual keyboard
+public void toggleVKB() {
+InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Activity.INPUT_METHOD_SERVICE);
+imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
+}
+public void addTab() {
+mSolo.clickOnView(mSolo.getView(R.id.tabs));
+// wait for addTab to appear (this is usually immediate)
+boolean success = waitForCondition(new Condition() {
+@Override
+public boolean isSatisfied() {
+View addTabView = mSolo.getView(R.id.add_tab);
+if (addTabView == null) {
+return false;
+}
+return true;
+}
+}, MAX_WAIT_MS);
+mAsserter.ok(success, "waiting for add tab view", "add tab view available");
+Actions.EventExpecter pageShowExpecter = mActions.expectGeckoEvent("Content:PageShow");
+mSolo.clickOnView(mSolo.getView(R.id.add_tab));
+pageShowExpecter.blockForEvent();
+pageShowExpecter.unregisterListener();
+}
+public void addTab(String url) {
+addTab();
+// Adding a new tab opens about:home, so now we just need to load the url in it.
+inputAndLoadUrl(url);
+}
+/**
+* Gets the AdapterView of the tabs list.
+*
+* @return List view in the tabs tray
+*/
+private final AdapterView<ListAdapter> getTabsList() {
+Element tabs = mDriver.findElement(getActivity(), R.id.tabs);
+tabs.click();
+return (AdapterView<ListAdapter>) getActivity().findViewById(R.id.normal_tabs);
+}
+/**
+* Gets the view in the tabs tray at the specified index.
+*
+* @return View at index
+*/
+private View getTabViewAt(final int index) {
+final View[] childView = { null };
+final AdapterView<ListAdapter> view = getTabsList();
+runOnUiThreadSync(new Runnable() {
+@Override
+public void run() {
+view.setSelection(index);
+// The selection isn't updated synchronously; posting a
+// runnable to the view's queue guarantees we'll run after the
+// layout pass.
+view.post(new Runnable() {
+@Override
+public void run() {
+// getChildAt() is relative to the list of visible
+// views, but our index is relative to all views in the
+// list. Subtract the first visible list position for
+// the correct offset.
+childView[0] = view.getChildAt(index - view.getFirstVisiblePosition());
+}
+});
+}
+});
+boolean result = waitForCondition(new Condition() {
+@Override
+public boolean isSatisfied() {
+return childView[0] != null;
+}
+}, MAX_WAIT_MS);
+mAsserter.ok(result, "list item at index " + index + " exists", null);
+return childView[0];
+}
+/**
+* Selects the tab at the specified index.
+*
+* @param index Index of tab to select
+*/
+public void selectTabAt(final int index) {
+mSolo.clickOnView(getTabViewAt(index));
+}
+/**
+* Closes the tab at the specified index.
+*
+* @param index Index of tab to close
+*/
+public void closeTabAt(final int index) {
+View closeButton = getTabViewAt(index).findViewById(R.id.close);
+mSolo.clickOnView(closeButton);
+}
+public final void runOnUiThreadSync(Runnable runnable) {
+RobocopUtils.runOnUiThreadSync(mActivity, runnable);
+}
+/* Tap the "star" (bookmark) button to bookmark or un-bookmark the current page */
+public void toggleBookmark() {
+mActions.sendSpecialKey(Actions.SpecialKey.MENU);
+waitForText("Settings");
+// On ICS+ phones, there is no button labeled "Bookmarks"
+// instead we have to just dig through every button on the screen
+ArrayList<View> images = mSolo.getCurrentViews();
+for (int i = 0; i < images.size(); i++) {
+final View view = images.get(i);
+boolean found = false;
+found = "Bookmark".equals(view.getContentDescription());
+// on older android versions, try looking at the button's text
+if (!found) {
+if (view instanceof TextView) {
+found = "Bookmark".equals(((TextView)view).getText());
+}
+}
+if (found) {
+int[] xy = new int[2];
+view.getLocationOnScreen(xy);
+final int viewWidth = view.getWidth();
+final int viewHeight = view.getHeight();
+final float x = xy[0] + (viewWidth / 2.0f);
+float y = xy[1] + (viewHeight / 2.0f);
+mSolo.clickOnScreen(x, y);
+}
+}
+}
+public void clearPrivateData() {
+selectSettingsItem(StringHelper.PRIVACY_SECTION_LABEL, StringHelper.CLEAR_PRIVATE_DATA_LABEL);
+Actions.EventExpecter clearData = mActions.expectGeckoEvent("Sanitize:Finished");
+mSolo.clickOnText("Clear data");
+clearData.blockForEvent();
+clearData.unregisterListener();
+}
+class Device {
+public final String version; // 2.x or 3.x or 4.x
+public String type; // "tablet" or "phone"
+public final int width;
+public final int height;
+public final float density;
+public Device() {
+// Determine device version
+int sdk = Build.VERSION.SDK_INT;
+if (sdk < Build.VERSION_CODES.HONEYCOMB) {
+version = "2.x";
+} else {
+if (sdk > Build.VERSION_CODES.HONEYCOMB_MR2) {
+version = "4.x";
+} else {
+version = "3.x";
+}
+}
+// Determine with and height
+DisplayMetrics dm = new DisplayMetrics();
+getActivity().getWindowManager().getDefaultDisplay().getMetrics(dm);
+height = dm.heightPixels;
+width = dm.widthPixels;
+density = dm.density;
+// Determine device type
+type = "phone";
+try {
+if (GeckoAppShell.isTablet()) {
+type = "tablet";
+}
+} catch (Exception e) {
+mAsserter.dumpLog("Exception in detectDevice", e);
+}
+}
+public void rotate() {
+if (getActivity().getRequestedOrientation () == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
+mSolo.setActivityOrientation(Solo.PORTRAIT);
+} else {
+mSolo.setActivityOrientation(Solo.LANDSCAPE);
+}
+}
+}
+class Navigation {
+private String devType;
+private String osVersion;
+public Navigation(Device mDevice) {
+devType = mDevice.type;
+osVersion = mDevice.version;
+}
+public void back() {
+Actions.EventExpecter pageShowExpecter = mActions.expectGeckoEvent("Content:PageShow");
+if (devType.equals("tablet")) {
+Element backBtn = mDriver.findElement(getActivity(), R.id.back);
+backBtn.click();
+} else {
+mActions.sendSpecialKey(Actions.SpecialKey.BACK);
+}
+pageShowExpecter.blockForEvent();
+pageShowExpecter.unregisterListener();
+}
+public void forward() {
+Actions.EventExpecter pageShowExpecter = mActions.expectGeckoEvent("Content:PageShow");
+if (devType.equals("tablet")) {
+Element fwdBtn = mDriver.findElement(getActivity(), R.id.forward);
+fwdBtn.click();
+} else {
+mActions.sendSpecialKey(Actions.SpecialKey.MENU);
+waitForText("^New Tab$");
+if (!osVersion.equals("2.x")) {
+Element fwdBtn = mDriver.findElement(getActivity(), R.id.forward);
+fwdBtn.click();
+} else {
+mSolo.clickOnText("^Forward$");
+}
+ensureMenuClosed();
+}
+pageShowExpecter.blockForEvent();
+pageShowExpecter.unregisterListener();
+}
+public void reload() {
+if (devType.equals("tablet")) {
+Element reloadBtn = mDriver.findElement(getActivity(), R.id.reload);
+reloadBtn.click();
+} else {
+mActions.sendSpecialKey(Actions.SpecialKey.MENU);
+waitForText("^New Tab$");
+if (!osVersion.equals("2.x")) {
+Element reloadBtn = mDriver.findElement(getActivity(), R.id.reload);
+reloadBtn.click();
+} else {
+mSolo.clickOnText("^Reload$");
+}
+ensureMenuClosed();
+}
+}
+// DEPRECATED!
+// Use BaseTest.toggleBookmark() in new code.
+public void bookmark() {
+mActions.sendSpecialKey(Actions.SpecialKey.MENU);
+waitForText("^New Tab$");
+if (mSolo.searchText("^Bookmark$")) {
+// This is the Android 2.x so the button has text
+mSolo.clickOnText("^Bookmark$");
+} else {
+Element bookmarkBtn = mDriver.findElement(getActivity(), R.id.bookmark);
+if (bookmarkBtn != null) {
+// We are on Android 4.x so the button is an image button
+bookmarkBtn.click();
+}
+}
+ensureMenuClosed();
+}
+// On some devices, the menu may not be dismissed after clicking on an
+// item. Close it here.
+private void ensureMenuClosed() {
+if (mSolo.searchText("^New Tab$")) {
+mActions.sendSpecialKey(Actions.SpecialKey.BACK);
+}
+}
+}
+/**
+* Gets the string representation of a stack trace.
+*
+* @param t Throwable to get stack trace for
+* @return Stack trace as a string
+*/
+public static String getStackTraceString(Throwable t) {
+StringWriter sw = new StringWriter();
+t.printStackTrace(new PrintWriter(sw));
+return sw.toString();
+}
+/**
+* Condition class that waits for a view, and allows callers access it when done.
+*/
+private class DescriptionCondition<T extends View> implements Condition {
+public T mView;
+private String mDescr;
+private Class<T> mCls;
+public DescriptionCondition(Class<T> cls, String descr) {
+mDescr = descr;
+mCls = cls;
+}
+@Override
+public boolean isSatisfied() {
+mView = findViewWithContentDescription(mCls, mDescr);
+return (mView != null);
+}
+}
+/**
+* Wait for a view with the specified description .
+*/
+public <T extends View> T waitForViewWithDescription(Class<T> cls, String description) {
+DescriptionCondition<T> c = new DescriptionCondition<T>(cls, description);
+waitForCondition(c, MAX_WAIT_ENABLED_TEXT_MS);
+return c.mView;
+}
+/**
+* Get an active view with the specified description .
+*/
+public <T extends View> T findViewWithContentDescription(Class<T> cls, String description) {
+for (T view : mSolo.getCurrentViews(cls)) {
+final String descr = (String) view.getContentDescription();
+if (TextUtils.isEmpty(descr)) {
+continue;
+}
+if (TextUtils.equals(description, descr)) {
+return view;
+}
+}
+return null;
+}
+/**
+* Abstract class for running small test cases within a BaseTest.
+*/
+abstract class TestCase implements Runnable {
+/**
+* Implement tests here. setUp and tearDown for the test case
+* should be handled by the parent test. This is so we can avoid the
+* overhead of starting Gecko and creating profiles.
+*/
+protected abstract void test() throws Exception;
+@Override
+public void run() {
+try {
+test();
+} catch (Exception e) {
+mAsserter.ok(false,
+"Test " + this.getClass().getName() + " threw exception: " + e,
+"");
+}
+}
+}
+/**
+* Set the preference and wait for it to change before proceeding with the test.
+*/
+public void setPreferenceAndWaitForChange(final JSONObject jsonPref) {
+mActions.sendGeckoEvent("Preferences:Set", jsonPref.toString());
+// Get the preference name from the json and store it in an array. This array
+// will be used later while fetching the preference data.
+String[] prefNames = new String[1];
+try {
+prefNames[0] = jsonPref.getString("name");
+} catch (JSONException e) {
+mAsserter.ok(false, "Exception in setPreferenceAndWaitForChange", getStackTraceString(e));
+}
+// Wait for confirmation of the pref change before proceeding with the test.
+final int ourRequestID = mPreferenceRequestID--;
+final Actions.RepeatedEventExpecter eventExpecter = mActions.expectGeckoEvent("Preferences:Data");
+mActions.sendPreferencesGetEvent(ourRequestID, prefNames);
+// Wait until we get the correct "Preferences:Data" event
+waitForCondition(new Condition() {
+final long endTime = SystemClock.elapsedRealtime() + MAX_WAIT_BLOCK_FOR_EVENT_DATA_MS;
+@Override
+public boolean isSatisfied() {
+try {
+long timeout = endTime - SystemClock.elapsedRealtime();
+if (timeout < 0) {
+timeout = 0;
+}
+JSONObject data = new JSONObject(eventExpecter.blockForEventDataWithTimeout(timeout));
+int requestID = data.getInt("requestId");
+if (requestID != ourRequestID) {
+return false;
+}
+JSONArray preferences = data.getJSONArray("preferences");
+mAsserter.is(preferences.length(), 1, "Expecting preference array to have one element");
+JSONObject prefs = (JSONObject) preferences.get(0);
+mAsserter.is(prefs.getString("name"), jsonPref.getString("name"),
+"Expecting returned preference name to be the same as the set name");
+mAsserter.is(prefs.getString("type"), jsonPref.getString("type"),
+"Expecting returned preference type to be the same as the set type");
+mAsserter.is(prefs.get("value"), jsonPref.get("value"),
+"Expecting returned preference value to be the same as the set value");
+return true;
+} catch(JSONException e) {
+mAsserter.ok(false, "Exception in setPreferenceAndWaitForChange", getStackTraceString(e));
+// Please the java compiler
+return false;
+}
+}
+}, MAX_WAIT_BLOCK_FOR_EVENT_DATA_MS);
+eventExpecter.unregisterListener();
+}
+}

The Tor Browser / file comparison

comparison: mobile/android/base/tests/BaseTest.java

mobile/android/base/tests/BaseTest.java