• Home
• it.tidalwave.bluebill
• bluebill-mobile-android-test-functional
• 1.0-ALPHA-4
• source code
• TestHelper.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

it.tidalwave.bluebill.mobile.android.TestHelper Maven / Gradle / Ivy

/***********************************************************************************************************************
 *
 * blueBill Mobile - Android - open source birding
 * Copyright (C) 2009-2011 by Tidalwave s.a.s. (http://www.tidalwave.it)
 *
 ***********************************************************************************************************************
 *
 * 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.
 *
 ***********************************************************************************************************************
 *
 * WWW: http://bluebill.tidalwave.it/mobile
 * SCM: https://java.net/hg/bluebill-mobile~android-src
 *
 **********************************************************************************************************************/
package it.tidalwave.bluebill.mobile.android;

import android.app.Activity;
import android.app.Instrumentation;
import android.os.Build;
import android.os.SystemClock;
import android.test.ActivityInstrumentationTestCase2;
import android.test.TouchUtils;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.widget.Button;
import android.widget.ListView;
import com.jayway.android.robotium.solo.Solo;
import it.tidalwave.bluebill.mobile.android.impl.TestHelperNoTouch;
import it.tidalwave.bluebill.mobile.android.impl.TestHelperTouch;
import it.tidalwave.util.logging.Logger;
import java.util.List;
import javax.annotation.Nonnegative;
import javax.annotation.Nonnull;

/***********************************************************************************************************************
 *
 * @author  Fabrizio Giudici
 * @version $Id$
 *
 **********************************************************************************************************************/
public abstract class TestHelper
  {
    private static final String CLASS = TestHelper.class.getName();
    private static final Logger logger = Logger.getLogger(CLASS);

    protected final int timeout = 30000;

    protected final int generalDelay = 300;

    @Nonnull
    protected final ActivityInstrumentationTestCase2 instrumentationTestCase;

    @Nonnull
    protected final Solo solo;

    protected static boolean touchMode = false;

    protected final boolean emulator;

    protected final float delayFactor;

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    protected TestHelper (final @Nonnull ActivityInstrumentationTestCase2 instrumentationTestCase,
                          final @Nonnull Solo solo)
      {
        this.instrumentationTestCase = instrumentationTestCase;
        this.solo = solo;
        emulator = Build.PRODUCT.contains("sdk");
        delayFactor = emulator ? 3 : 1;
        logger.info("************** delayFactor: %f", delayFactor);
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    @Nonnull
    public static TestHelper createHelper (final @Nonnull ActivityInstrumentationTestCase2 instrumentationTestCase,
                                           final @Nonnull Solo solo)
      {
        return touchMode ? new TestHelperTouch(instrumentationTestCase, solo)
                         : new TestHelperNoTouch(instrumentationTestCase, solo);
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public static boolean isTouchMode()
      {
        return touchMode;
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void waitForListNotEmpty (final int id, final long timeOut)
      throws InterruptedException
      {
        final long time = System.currentTimeMillis();
        final Activity activity = solo.getCurrentActivity();
        final ListView listView = (ListView)activity.findViewById(id);

        if (listView == null)
          {
            throw new AssertionError("No ListView with id " + id);
          }

        while ((listView.getAdapter() == null) || listView.getAdapter().isEmpty())
          {
            if (System.currentTimeMillis() - time >= timeOut * delayFactor)
              {
                throw new AssertionError("Time out while waiting for a ListView to become not empty");
              }

            logger.fine("Waiting for ListView #%d to become not empty...", id);
            sleep(100);
          }
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void waitForVisible (final int id)
      throws InterruptedException
      {
        final long time = System.currentTimeMillis();
        final Activity activity = solo.getCurrentActivity();
        final View view = activity.findViewById(id);

        while (view.getVisibility() != View.VISIBLE)
          {
            if (System.currentTimeMillis() - time >= timeout)
              {
                throw new AssertionError("Time out while waiting for a View to become visible");
              }

            logger.info("Waiting for View #%d to become visible...", id);
            sleep(100);
          }
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void waitForActivity (final @Nonnull Class activityClass)
      throws InterruptedException
      {
        logger.info("Waiting for %s ... (%s)", activityClass.getName(), solo.getCurrentActivity().getClass().getName());
//        solo.waitForActivity(activityClass.getName(), timeout);
        final long time = System.currentTimeMillis();

        while (!activityClass.isAssignableFrom(solo.getCurrentActivity().getClass()))
          {
            if (System.currentTimeMillis() - time >= timeout)
              {
                throw new AssertionError("Time out while waiting for " + activityClass.getName());
              }

            logger.info("Waiting for %s ... (%s)", activityClass.getName(), solo.getCurrentActivity().getClass().getName());
            sleep(100);
          }
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public abstract void clickOnImageButtonById (int id);

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void clickOnButtonById (final int id)
      {
        final List buttons = solo.getCurrentButtons();

        for (int i = 0; i < buttons.size(); i++)
          {
            final Button button = buttons.get(i);

            if (button.getId() == id)
              {
                logger.info(">>>> Clicking on Button #%d ...", i);

                if (touchMode)
                  {
                    clickViewWithTouchUtils(button);
//                    solo.clickOnButton(i);
                  }
                else
                  {
                    sleep(generalDelay);
                    requestFocus(button);
                    press(KeyEvent.KEYCODE_DPAD_CENTER);
                  }
                
                return;
              }
          }

        throw new AssertionError("Cannot find button #" + id + " on " + solo.getCurrentActivity() + ": " + buttons);
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public abstract void clickOnListView (@Nonnull ListView listView, @Nonnull String text);

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public abstract void clickOnListView (@Nonnull ListView listView, @Nonnegative int index);

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void popContextMenuOnListView (final @Nonnull ListView listView,
                                          final @Nonnegative int itemIndex,
                                          final @Nonnegative int menuId)
      {
        if (touchMode)
          {
//            clickViewWithTouchUtils(listView.getChildAt(itemIndex));
//            solo.clickInList(listIndex, index);
          }
        else
          {
//            if (true) // scroll down
//              {
                requestFocus(listView);
                final Instrumentation instrumentation = instrumentationTestCase.getInstrumentation();

                for (int i = 0; i < itemIndex; i++)
                  {
                    instrumentationTestCase.sendKeys(KeyEvent.KEYCODE_DPAD_DOWN);
                    instrumentation.waitForIdleSync();
                    sleep(generalDelay);
                  }

                instrumentation.invokeContextMenuAction(solo.getCurrentActivity(), menuId, 0);
//              }
//
//            else // immediate click - doesn't work, doesn't put the focus in the proper place
//              {
//                requestFocus(listView);
//                requestFocus(listView.getChildAt(itemIndex));
//                ins
//                press(KeyEvent.KEYCODE_DPAD_CENTER);
//              }
          }
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void requestFocus (final @Nonnull View view)
      {
        logger.info("Requesting focus for %s...", view);

        if (!view.isFocused())
          {
            instrumentationTestCase.getActivity().runOnUiThread(new Runnable()
              {
                public void run()
                  {
                    view.requestFocus();
                  }
              });

            instrumentationTestCase.getInstrumentation().waitForIdleSync();
            ActivityInstrumentationTestCase2.assertTrue(view.isFocused());
          }
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void press (final int keyCode)
      {
        long downTime = SystemClock.uptimeMillis();
        long eventTime = SystemClock.uptimeMillis();
        final KeyEvent keyDown = new KeyEvent(downTime, eventTime, KeyEvent.ACTION_DOWN, keyCode, 0);
        final Instrumentation instrumentation = instrumentationTestCase.getInstrumentation();
        instrumentation.sendKeySync(keyDown);
        solo.sleep((int)(ViewConfiguration.getLongPressTimeout() * 0.8f));
        downTime = SystemClock.uptimeMillis();
        eventTime = SystemClock.uptimeMillis();
        final KeyEvent keyUp = new KeyEvent(downTime, eventTime, KeyEvent.ACTION_UP, keyCode, 0);
        instrumentation.sendKeySync(keyUp);
        instrumentation.waitForIdleSync();
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void sendFilterKeyToListView (final @Nonnull ListView listView, final int c)
      {
        logger.info("sending filter key %d to %s...", c, listView);
        requestFocus(listView);
        sleep(50);
        final Instrumentation instrumentation = instrumentationTestCase.getInstrumentation();
        instrumentation.sendCharacterSync(c);
        instrumentation.waitForIdleSync();
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void sendFilterKeyToListView (final @Nonnull ListView listView, final @Nonnull String chars)
      {
        logger.info("sending filter keys %s to %s...", chars, listView);
        requestFocus(listView);
        final Instrumentation instrumentation = instrumentationTestCase.getInstrumentation();

        for (int i = 0; i < chars.length(); i++)
          {
            instrumentation.sendCharacterSync(chars.charAt(i) - 'a' + KeyEvent.KEYCODE_A);
            instrumentation.waitForIdleSync();
            sleep(500);
          }
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public abstract void confirmDialog();


    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public boolean scrollDownList (final @Nonnegative int index)
      {
        final long time = System.currentTimeMillis();
        final boolean result = scrollList(index, Solo.DOWN);
//        return solo.scrollDownList(index);
        logger.info("scrollDownList() done in %d msec", System.currentTimeMillis() - time);
        return result;
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void sleep (final int time)
      {
        solo.sleep((int)(time * delayFactor));
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    public void invokeMenuAction (final int id)
      {
//        if (!touchMode)
          {
            instrumentationTestCase.getInstrumentation().invokeMenuActionSync(solo.getCurrentActivity(), id, 0);
          }
//        else
//          {
//            solo.sendKey(Solo.MENU);
//            solo.sleep(200);
//
//            for (final View view : solo.getViews())
//              {
//                  System.err.println("VIEW " + view + " ID " + view.getId() + " VS " + id);
//
//                if (view.getId() == id)
//                  {
//                    solo.clickOnView(view);
//                    return;
//                  }
//              }
//
//            throw new AssertionFailedError("No menu with id=" + id);
//            solo.clickOnMenuItem(".*Pref.*"); // FIXME: get the text from the id
//          }
      }

    /*******************************************************************************************************************
     *
     *
     ******************************************************************************************************************/
    protected void clickViewWithTouchUtils (final @Nonnull View view)
      {
//        solo.getCurrentActivity().runOnUiThread(new Runnable()
//          {
//            public void run()
//              {
                TouchUtils.tapView(instrumentationTestCase, view);
//              }
//          });
      }


    // Copied from Solo to increase the scroll speed

    private boolean scrollList(int listIndex, int direction) {
        logger.info("scrollList(%d, %d)", listIndex, direction);
        final int stepCount = 4;
        final int delta = 20;
        ListView listView = solo.getCurrentListViews().get(listIndex);
        int[] xy = new int[2];
        listView.getLocationOnScreen(xy);

        while (xy[1] + delta > solo.getCurrentActivity().getWindowManager().getDefaultDisplay().getHeight()) {
            int yStart = (solo.getCurrentActivity().getWindowManager().getDefaultDisplay().getHeight() - delta);
            int yEnd = ((solo.getCurrentActivity().getWindowManager().getDefaultDisplay().getHeight() / 2));
            int x = solo.getCurrentActivity().getWindowManager().getDefaultDisplay().getWidth() / 2;
            drag(x, x, yStart, yEnd, stepCount);
            listView.getLocationOnScreen(xy);
        }
        int yStart;
        int yEnd;
        if (direction == Solo.DOWN) {
            yStart = ((xy[1] + listView.getHeight()) - delta);
            yEnd = (xy[1] + delta);
        } else {

            yStart = ((xy[1]) + delta);
            yEnd = (xy[1] + listView.getHeight());
        }
        int x = solo.getCurrentActivity().getWindowManager().getDefaultDisplay().getWidth() / 2;

        if (listView.getLastVisiblePosition() < listView.getCount() - 1) {
            drag(x, x, yStart, yEnd, stepCount);
            return true;

        } else {
            return false;
        }

    }

    public void drag(float fromX, float toX, float fromY, float toY, int stepCount)
      {
        logger.info("drag(%f, %f, %f, %f, %d)", fromX, toX, fromY, toY, stepCount);
        final long time = System.currentTimeMillis();
        long downTime = SystemClock.uptimeMillis();
        long eventTime = SystemClock.uptimeMillis();
        float y = fromY;
        float x = fromX;
        float yStep = (toY - fromY) / stepCount;
        float xStep = (toX - fromX) / stepCount;
        logger.info("DOWN: %f,%f", fromX, fromY);
        MotionEvent event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_DOWN, fromX, fromY, 0);

        final Instrumentation inst = instrumentationTestCase.getInstrumentation();

        try {
            inst.sendPointerSync(event);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        for (int i = 0; i < stepCount; ++i) {
            y += yStep;
            x += xStep;
            eventTime = SystemClock.uptimeMillis();
            event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_MOVE, x, y, 0);
            logger.info("MOVE: %f,%f", x, y);
            try {
                inst.sendPointerSync(event);
            } catch (Throwable e) {
                e.printStackTrace();
            }
//            inst.waitForIdleSync();
        }
        eventTime = SystemClock.uptimeMillis();
        event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_UP, toX, toY, 0);
        logger.info("UP: %f,%f", toX, toY);
        try {
            inst.sendPointerSync(event);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        logger.info("drag() done in %d msec", System.currentTimeMillis() - time);
    }

    public void waitForProgressDialogToClose (final @Nonnegative long timeOut)
      {
        // TODO: assert it's a progress dialog
        solo.waitForDialogToClose((int)(timeOut * delayFactor));
      }
  }