mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
759 lines
28 KiB
Java
759 lines
28 KiB
Java
#filter substitution
|
|
package @ANDROID_PACKAGE_NAME@.tests;
|
|
|
|
import com.jayway.android.robotium.solo.Solo;
|
|
import @ANDROID_PACKAGE_NAME@.*;
|
|
|
|
import android.app.Activity;
|
|
import android.app.Instrumentation;
|
|
import android.content.ContentResolver;
|
|
import android.content.ContentValues;
|
|
import android.content.ContentUris;
|
|
import android.content.Intent;
|
|
import android.content.pm.ActivityInfo;
|
|
import android.content.res.AssetManager;
|
|
import android.database.Cursor;
|
|
import android.net.Uri;
|
|
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.test.ActivityInstrumentationTestCase2;
|
|
import android.util.DisplayMetrics;
|
|
import android.view.inputmethod.InputMethodManager;
|
|
import android.view.KeyEvent;
|
|
import android.view.View;
|
|
import android.widget.Button;
|
|
import android.widget.EditText;
|
|
import android.widget.ListAdapter;
|
|
import android.widget.ListView;
|
|
import android.widget.TextView;
|
|
import java.io.File;
|
|
import java.io.InputStream;
|
|
import java.io.IOException;
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
|
|
/**
|
|
* A convenient base class suitable for most Robocop tests.
|
|
*/
|
|
abstract class BaseTest extends ActivityInstrumentationTestCase2<Activity> {
|
|
public static final int TEST_MOCHITEST = 0;
|
|
public static final int TEST_TALOS = 1;
|
|
|
|
private static final String TARGET_PACKAGE_ID = "org.mozilla.gecko";
|
|
private static final String LAUNCH_ACTIVITY_FULL_CLASSNAME ="@ANDROID_PACKAGE_NAME@.App";
|
|
private static final int VERIFY_URL_TIMEOUT = 2000;
|
|
private static final int MAX_LIST_ATTEMPTS = 3;
|
|
private static final int MAX_WAIT_ENABLED_TEXT_MS = 10000;
|
|
private static final int MAX_WAIT_HOME_PAGER_HIDDEN_MS = 10000;
|
|
public static final int MAX_WAIT_MS = 3000;
|
|
|
|
// Note: DEFAULT_BOOKMARKS_TITLES.length == DEFAULT_BOOKMARKS_URLS.length
|
|
protected static final String[] DEFAULT_BOOKMARKS_TITLES = new String[] {
|
|
"Firefox: About your browser",
|
|
"Firefox: Support",
|
|
"Firefox: Customize with add-ons"
|
|
};
|
|
protected static final String[] DEFAULT_BOOKMARKS_URLS = new String[] {
|
|
"about:firefox",
|
|
"http://support.mozilla.org/en-US/products/mobile",
|
|
"https://addons.mozilla.org/en-US/android/"
|
|
};
|
|
protected static final int DEFAULT_BOOKMARKS_COUNT = DEFAULT_BOOKMARKS_TITLES.length;
|
|
|
|
// IDs for UI views
|
|
private static final String BROWSER_TOOLBAR_ID = "browser_toolbar";
|
|
protected static final String URL_EDIT_TEXT_ID = "url_edit_text";
|
|
protected static final String URL_BAR_TITLE_ID = "url_bar_title";
|
|
|
|
// Settings menu paths
|
|
protected static final String PRIVACY_LABEL = "Privacy";
|
|
protected static final String CLEAR_PRIVATE_DATA_LABEL = "Clear private data";
|
|
|
|
private static Class<Activity> mLauncherActivityClass;
|
|
private Activity mActivity;
|
|
protected Solo mSolo;
|
|
protected Driver mDriver;
|
|
protected Assert mAsserter;
|
|
protected Actions mActions;
|
|
protected String mBaseUrl;
|
|
protected String mRawBaseUrl;
|
|
private String mLogFile;
|
|
protected String mProfile;
|
|
public Device mDevice;
|
|
|
|
protected void blockForGeckoReady() {
|
|
try {
|
|
Actions.EventExpecter geckoReadyExpector = mActions.expectGeckoEvent("Gecko:Ready");
|
|
ClassLoader classLoader = getActivity().getClassLoader();
|
|
Class appsCls = classLoader.loadClass("org.mozilla.gecko.GeckoThread");
|
|
Class launchStateCls = classLoader.loadClass("org.mozilla.gecko.GeckoThread$LaunchState");
|
|
Method checkLaunchState = appsCls.getMethod("checkLaunchState", launchStateCls);
|
|
Object states[] = launchStateCls.getEnumConstants();
|
|
Boolean ret = (Boolean)checkLaunchState.invoke(null, states[3]);
|
|
if (!ret.booleanValue()) {
|
|
geckoReadyExpector.blockForEvent();
|
|
}
|
|
geckoReadyExpector.unregisterListener();
|
|
} catch (Exception e) {
|
|
mAsserter.dumpLog("Exception in blockForGeckoReady", e);
|
|
}
|
|
}
|
|
|
|
static {
|
|
try {
|
|
mLauncherActivityClass = (Class<Activity>)Class.forName(LAUNCH_ACTIVITY_FULL_CLASSNAME);
|
|
} catch (ClassNotFoundException e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
public BaseTest() {
|
|
super(TARGET_PACKAGE_ID, mLauncherActivityClass);
|
|
}
|
|
|
|
protected abstract int getTestType();
|
|
|
|
@Override
|
|
protected void setUp() throws Exception {
|
|
// Load config file from root path (setup by python script)
|
|
String rootPath = FennecInstrumentationTestRunner.getFennecArguments().getString("deviceroot");
|
|
String configFile = FennecNativeDriver.getFile(rootPath + "/robotium.config");
|
|
HashMap config = FennecNativeDriver.convertTextToTable(configFile);
|
|
// Create the intent to be used with all the important arguments.
|
|
Intent i = new Intent(Intent.ACTION_MAIN);
|
|
mProfile = (String)config.get("profile");
|
|
i.putExtra("args", "-no-remote -profile " + mProfile);
|
|
String envString = (String)config.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();
|
|
mLogFile = (String)config.get("logfile");
|
|
mBaseUrl = ((String)config.get("host")).replaceAll("(/$)", "");
|
|
mRawBaseUrl = ((String)config.get("rawhost")).replaceAll("(/$)", "");
|
|
// Initialize the asserter
|
|
if (getTestType() == TEST_TALOS) {
|
|
mAsserter = new FennecTalosAssert();
|
|
} else {
|
|
mAsserter = new FennecMochitestAssert();
|
|
}
|
|
mAsserter.setLogFile(mLogFile);
|
|
mAsserter.setTestName(this.getClass().getName());
|
|
// Set up Robotium.solo and Driver objects
|
|
mSolo = new Solo(getInstrumentation(), mActivity);
|
|
mDriver = new FennecNativeDriver(mActivity, mSolo, rootPath);
|
|
mActions = new FennecNativeActions(mActivity, mSolo, getInstrumentation(), mAsserter);
|
|
mDevice = new Device();
|
|
}
|
|
|
|
@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();
|
|
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
|
|
mDriver.findElement(mActivity, BROWSER_TOOLBAR_ID).click();
|
|
|
|
// Wait for highlighed text to gain focus
|
|
boolean success = waitForTest(new BooleanTest() {
|
|
@Override
|
|
public boolean test() {
|
|
EditText urlEditText = mSolo.getEditText(0);
|
|
if (urlEditText.isInputMethodTarget()) {
|
|
return true;
|
|
} else {
|
|
mSolo.clickOnEditText(0);
|
|
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) {
|
|
focusUrlBar();
|
|
|
|
// Send the keys for the URL we want to enter
|
|
mActions.sendKeys(url);
|
|
|
|
// Get the URL text from the URL bar EditText view
|
|
String urlBarText = mDriver.findElement(mActivity, URL_EDIT_TEXT_ID).getText();
|
|
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 {
|
|
ClassLoader classLoader = getActivity().getClassLoader();
|
|
Class tabsClass = classLoader.loadClass("org.mozilla.gecko.Tabs");
|
|
Method getInstance = tabsClass.getMethod("getInstance");
|
|
Method loadUrl = tabsClass.getMethod("loadUrl", String.class);
|
|
Object tabs = getInstance.invoke(null);
|
|
loadUrl.invoke(tabs, new Object[] { url });
|
|
} catch (Exception e) {
|
|
mAsserter.dumpLog("Exception in loadUrl", e);
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
public final void verifyUrl(String url) {
|
|
Element urlEditText = mDriver.findElement(mActivity, URL_EDIT_TEXT_ID);
|
|
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
|
|
waitForTest(new VerifyUrlTest(urlEditText, url), VERIFY_URL_TIMEOUT);
|
|
urlBarText = urlEditText.getText();
|
|
}
|
|
mAsserter.is(urlBarText, url, "Browser toolbar URL stayed the same");
|
|
}
|
|
|
|
class VerifyUrlTest implements BooleanTest {
|
|
private Element mUrlEditText;
|
|
private String mUrl;
|
|
public VerifyUrlTest(Element urlEditText, String url) {
|
|
mUrlEditText = urlEditText;
|
|
mUrl = url;
|
|
}
|
|
|
|
@Override
|
|
public boolean test() {
|
|
String urlbarText = mUrlEditText.getText();
|
|
if (urlbarText.equals(mUrl)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected final String getAbsoluteUrl(String url) {
|
|
return mBaseUrl + "/" + url.replaceAll("(^/)", "");
|
|
}
|
|
|
|
protected final String getAbsoluteRawUrl(String url) {
|
|
return mRawBaseUrl + "/" + url.replaceAll("(^/)", "");
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
protected interface BooleanTest {
|
|
public boolean test();
|
|
}
|
|
|
|
@SuppressWarnings({"unchecked", "non-varargs"})
|
|
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);
|
|
}
|
|
|
|
private boolean CursorMatches(Cursor c, String[] columns, ContentValues cv) {
|
|
for (int i = 0; i < columns.length; i++) {
|
|
String column = columns[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;
|
|
}
|
|
|
|
@SuppressWarnings({"unchecked", "non-varargs"})
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Wait for <text> to be visible and also be enabled/clickable.
|
|
*/
|
|
public boolean waitForEnabledText(String text) {
|
|
final String testText = text;
|
|
boolean rc = waitForTest(new BooleanTest() {
|
|
@Override
|
|
public boolean test() {
|
|
// 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] + "$";
|
|
if (!waitForEnabledText(itemName)) {
|
|
mSolo.scrollDown();
|
|
}
|
|
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 Element homePagerElement = mDriver.findElement(mActivity, "home_pager");
|
|
final View homePagerView = mActivity.findViewById(homePagerElement.getId());
|
|
|
|
boolean rc = waitForTest(new BooleanTest() {
|
|
@Override
|
|
public boolean test() {
|
|
return homePagerView.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) {
|
|
Element urlBarTitle = mDriver.findElement(getActivity(), URL_BAR_TITLE_ID);
|
|
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
|
|
waitForTest(new VerifyTitle(urlBarTitle, title), MAX_WAIT_MS);
|
|
pageTitle = urlBarTitle.getText();
|
|
}
|
|
mAsserter.is(pageTitle, title, "Page title is correct");
|
|
}
|
|
|
|
class VerifyTitle implements BooleanTest {
|
|
private Element mUrlBarTitle;
|
|
private String mTitle;
|
|
public VerifyTitle(Element urlBarTitle, String title) {
|
|
mUrlBarTitle = urlBarTitle;
|
|
mTitle = title;
|
|
}
|
|
|
|
@Override
|
|
public boolean test() {
|
|
String pageTitle = mUrlBarTitle.getText();
|
|
if (pageTitle.equals(mTitle)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public final void verifyTabCount(int expectedTabCount) {
|
|
Activity activity = getActivity();
|
|
Element tabCount = mDriver.findElement(activity, "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(String url) {
|
|
Element tabs = null;
|
|
Element addTab = null;
|
|
Activity activity = getActivity();
|
|
tabs = mDriver.findElement(activity, "tabs");
|
|
addTab = mDriver.findElement(activity, "add_tab");
|
|
final int addTabId = addTab.getId();
|
|
mAsserter.ok(tabs.click(), "checking that tabs clicked", "tabs element clicked");
|
|
// wait for addTab to appear (this is usually immediate)
|
|
boolean success = waitForTest(new BooleanTest() {
|
|
@Override
|
|
public boolean test() {
|
|
View addTabView = getActivity().findViewById(addTabId);
|
|
if (addTabView == null) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}, MAX_WAIT_MS);
|
|
mAsserter.ok(success, "waiting for add tab view", "add tab view available");
|
|
mAsserter.ok(addTab.click(), "checking that add_tab clicked", "add_tab element clicked");
|
|
|
|
// Adding a new tab opens about:home, so now we just need to load the url in it.
|
|
inputAndLoadUrl(url);
|
|
}
|
|
|
|
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(PRIVACY_LABEL, 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 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;
|
|
// Determine device type
|
|
type = "phone";
|
|
try {
|
|
ClassLoader classLoader = getActivity().getClassLoader();
|
|
Class appsCls = classLoader.loadClass("org.mozilla.gecko.GeckoAppShell");
|
|
Method isTabletMethod = appsCls.getMethod("isTablet", (Class[]) null);
|
|
boolean isTablet = (Boolean)isTabletMethod.invoke(null);
|
|
if (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() {
|
|
if (devType.equals("tablet")) {
|
|
Element backBtn = mDriver.findElement(getActivity(), "back");
|
|
backBtn.click();
|
|
} else {
|
|
mActions.sendSpecialKey(Actions.SpecialKey.BACK);
|
|
}
|
|
}
|
|
|
|
public void forward() {
|
|
if (devType.equals("tablet")) {
|
|
Element fwdBtn = mDriver.findElement(getActivity(), "forward");
|
|
fwdBtn.click();
|
|
} else {
|
|
mActions.sendSpecialKey(Actions.SpecialKey.MENU);
|
|
waitForText("^New Tab$");
|
|
if (!osVersion.equals("2.x")) {
|
|
Element fwdBtn = mDriver.findElement(getActivity(), "forward");
|
|
fwdBtn.click();
|
|
} else {
|
|
mSolo.clickOnText("^Forward$");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void reload() {
|
|
if (devType.equals("tablet")) {
|
|
Element reloadBtn = mDriver.findElement(getActivity(), "reload");
|
|
reloadBtn.click();
|
|
} else {
|
|
mActions.sendSpecialKey(Actions.SpecialKey.MENU);
|
|
waitForText("^New Tab$");
|
|
if (!osVersion.equals("2.x")) {
|
|
Element reloadBtn = mDriver.findElement(getActivity(), "reload");
|
|
reloadBtn.click();
|
|
} else {
|
|
mSolo.clickOnText("^Reload$");
|
|
}
|
|
}
|
|
}
|
|
|
|
// DEPRECATED!
|
|
// Use BaseTest.toggleBookmark() in new code.
|
|
public void bookmark() {
|
|
if (devType.equals("tablet")) {
|
|
if (!osVersion.equals("4.x")){
|
|
Element bookmarkBtn = mDriver.findElement(getActivity(), "bookmark");
|
|
bookmarkBtn.click();
|
|
}
|
|
else {
|
|
mActions.sendSpecialKey(Actions.SpecialKey.MENU);
|
|
mSolo.waitForText("^New Tab$");
|
|
mSolo.clickOnText("^Bookmark$");
|
|
}
|
|
}
|
|
else {
|
|
mActions.sendSpecialKey(Actions.SpecialKey.MENU);
|
|
mSolo.waitForText("^New Tab$");
|
|
if (!osVersion.equals("2.x")) {
|
|
Element bookmarkBtn = mDriver.findElement(getActivity(), "bookmark");
|
|
bookmarkBtn.click();
|
|
}
|
|
else {
|
|
mSolo.clickOnText("^Bookmark$");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|