src/xwalk/test/android/core/javatests/src/org/xwalk/core/xwview/test/XWalkViewTestBase.java

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Copyright (c) 2013-2014 Intel Corporation. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5
   6 package org.xwalk.core.xwview.test;
   7
   8 import android.app.Activity;
   9 import android.content.Context;
  10 import android.net.Uri;
  11 import android.test.ActivityInstrumentationTestCase2;
  12 import android.util.Log;
  13 import android.view.KeyEvent;
  14 import android.webkit.ValueCallback;
  15 import android.webkit.WebResourceResponse;
  16
  17 import java.io.InputStream;
  18 import java.io.IOException;
  19 import java.util.concurrent.atomic.AtomicReference;
  20 import java.util.concurrent.Callable;
  21 import java.util.concurrent.FutureTask;
  22 import java.util.concurrent.TimeUnit;
  23
  24 import junit.framework.Assert;
  25
  26 import org.chromium.content_public.browser.LoadUrlParams;
  27 import org.chromium.content.browser.test.util.CallbackHelper;
  28 import org.chromium.content.browser.test.util.Criteria;
  29 import org.chromium.content.browser.test.util.CriteriaHelper;
  30
  31 import org.xwalk.core.XWalkJavascriptResult;
  32 import org.xwalk.core.XWalkNavigationHistory;
  33 import org.xwalk.core.XWalkNavigationItem;
  34 import org.xwalk.core.XWalkResourceClient;
  35 import org.xwalk.core.XWalkUIClient;
  36 import org.xwalk.core.XWalkView;
  37
  38 public class XWalkViewTestBase
  39        extends ActivityInstrumentationTestCase2<XWalkViewTestRunnerActivity> {
  40     protected final static int WAIT_TIMEOUT_SECONDS = 15;
  41     protected final static long WAIT_TIMEOUT_MS = 2000;
  42     private final static int CHECK_INTERVAL = 100;
  43     private final static String TAG = "XWalkViewTestBase";
  44     private XWalkView mXWalkView;
  45     final TestHelperBridge mTestHelperBridge = new TestHelperBridge();
  46
  47     class TestXWalkUIClientBase extends XWalkUIClient {
  48         TestHelperBridge mInnerContentsClient;
  49         public TestXWalkUIClientBase(TestHelperBridge client) {
  50             super(getXWalkView());
  51             mInnerContentsClient = client;
  52         }
  53
  54         @Override
  55         public void onPageLoadStarted(XWalkView view, String url) {
  56             mInnerContentsClient.onPageStarted(url);
  57         }
  58
  59         @Override
  60         public void onPageLoadStopped(XWalkView view, String url, LoadStatus status) {
  61             mInnerContentsClient.onPageFinished(url, status);
  62         }
  63
  64         @Override
  65         public void onReceivedTitle(XWalkView view, String title) {
  66             mInnerContentsClient.onTitleChanged(title);
  67         }
  68
  69         @Override
  70         public void onJavascriptCloseWindow(XWalkView view) {
  71             mInnerContentsClient.onJavascriptCloseWindow();
  72         }
  73
  74         @Override
  75         public void onScaleChanged(XWalkView view, float oldScale, float newScale) {
  76             mInnerContentsClient.onScaleChanged(newScale);
  77         }
  78
  79         @Override
  80         public void onRequestFocus(XWalkView view) {
  81             mInnerContentsClient.onRequestFocus();
  82         }
  83
  84         @Override
  85         public boolean onJavascriptModalDialog(XWalkView view,
  86                 XWalkUIClient.JavascriptMessageType type, String url, String message,
  87                         String defaultValue, XWalkJavascriptResult result) {
  88             return mInnerContentsClient.onJavascriptModalDialog(message);
  89         }
  90
  91         @Override
  92         public void openFileChooser(XWalkView view, ValueCallback<Uri> uploadFile,
  93                 String acceptType, String capture) {
  94             mInnerContentsClient.openFileChooser(uploadFile);
  95         }
  96
  97         @Override
  98         public void onFullscreenToggled(XWalkView view, boolean enterFullscreen) {
  99             mInnerContentsClient.onFullscreenToggled(enterFullscreen);
 100         }
 101
 102         @Override
 103         public boolean shouldOverrideKeyEvent(XWalkView view, KeyEvent event) {
 104             return mInnerContentsClient.overrideOrUnhandledKeyEvent(event);
 105         }
 106     }
 107
 108     class TestXWalkUIClient extends TestXWalkUIClientBase {
 109         public TestXWalkUIClient() {
 110             super(mTestHelperBridge);
 111         }
 112     }
 113
 114     class TestXWalkResourceClientBase extends XWalkResourceClient {
 115         TestHelperBridge mInnerContentsClient;
 116         public TestXWalkResourceClientBase(TestHelperBridge client) {
 117             super(mXWalkView);
 118             mInnerContentsClient = client;
 119         }
 120
 121         @Override
 122         public void onLoadStarted(XWalkView view, String url) {
 123             mInnerContentsClient.onLoadStarted(url);
 124         }
 125
 126         @Override
 127         public void onReceivedLoadError(XWalkView view, int errorCode, String description, String failingUrl) {
 128             mInnerContentsClient.onReceivedLoadError(errorCode, description, failingUrl);
 129         }
 130
 131         @Override
 132         public WebResourceResponse shouldInterceptLoadRequest(XWalkView view,
 133                 String url) {
 134             return mInnerContentsClient.shouldInterceptLoadRequest(url);
 135         }
 136
 137         @Override
 138         public void onProgressChanged(XWalkView view, int progressInPercent) {
 139             mTestHelperBridge.onProgressChanged(progressInPercent);
 140         }
 141
 142         @Override
 143         public boolean shouldOverrideUrlLoading(XWalkView view, String url) {
 144             return mTestHelperBridge.shouldOverrideUrlLoading(url);
 145         }
 146     }
 147
 148     class TestXWalkResourceClient extends TestXWalkResourceClientBase {
 149         public TestXWalkResourceClient() {
 150             super(mTestHelperBridge);
 151         }
 152     }
 153
 154     void setUIClient(final XWalkUIClient client) {
 155         getInstrumentation().runOnMainSync(new Runnable() {
 156             @Override
 157             public void run() {
 158                 getXWalkView().setUIClient(client);
 159             }
 160         });
 161     }
 162
 163     void setResourceClient(final XWalkResourceClient client) {
 164         getInstrumentation().runOnMainSync(new Runnable() {
 165             @Override
 166             public void run() {
 167                 getXWalkView().setResourceClient(client);
 168             }
 169         });
 170     }
 171
 172     public XWalkViewTestBase() {
 173         super(XWalkViewTestRunnerActivity.class);
 174     }
 175
 176     @Override
 177     protected void setUp() throws Exception {
 178         super.setUp();
 179
 180         // Must call getActivity() here but not in main thread.
 181         final Activity activity = getActivity();
 182         getInstrumentation().runOnMainSync(new Runnable() {
 183             @Override
 184             public void run() {
 185                 mXWalkView = new XWalkView(activity, activity);
 186                 getActivity().addView(mXWalkView);
 187                 mXWalkView.setUIClient(new TestXWalkUIClient());
 188                 mXWalkView.setResourceClient(new TestXWalkResourceClient());
 189                 // mXWalkView.getXWalkViewContentForTest().installWebContentsObserverForTest(mTestHelperBridge);
 190             }
 191         });
 192     }
 193
 194     protected boolean pollOnUiThread(final Callable<Boolean> callable) throws Exception {
 195         return CriteriaHelper.pollForCriteria(new Criteria() {
 196             @Override
 197             public boolean isSatisfied() {
 198                 try {
 199                     return runTestOnUiThreadAndGetResult(callable);
 200                 } catch (Throwable e) {
 201                     return false;
 202                 }
 203             }
 204         });
 205     }
 206
 207     protected void loadJavaScriptUrl(final String url) throws Exception {
 208         if (!url.startsWith("javascript:")) {
 209             Log.w(TAG, "loadJavascriptUrl only accepts javascript: url");
 210             return;
 211         }
 212         loadUrlAsync(url);
 213     }
 214
 215     protected void loadUrlSync(final String url) throws Exception {
 216         CallbackHelper pageFinishedHelper = mTestHelperBridge.getOnPageFinishedHelper();
 217         int currentCallCount = pageFinishedHelper.getCallCount();
 218         loadUrlAsync(url);
 219
 220         pageFinishedHelper.waitForCallback(currentCallCount, 1, WAIT_TIMEOUT_SECONDS,
 221                 TimeUnit.SECONDS);
 222     }
 223
 224     protected void loadUrlAsync(final String url) throws Exception {
 225         getInstrumentation().runOnMainSync(new Runnable() {
 226             @Override
 227             public void run() {
 228                 mXWalkView.load(url, null);
 229             }
 230         });
 231     }
 232
 233     protected void loadDataSync(final String url, final String data, final String mimeType,
 234             final boolean isBase64Encoded) throws Exception {
 235         CallbackHelper pageFinishedHelper = mTestHelperBridge.getOnPageFinishedHelper();
 236         int currentCallCount = pageFinishedHelper.getCallCount();
 237         loadDataAsync(url, data, mimeType, isBase64Encoded);
 238         pageFinishedHelper.waitForCallback(currentCallCount, 1, WAIT_TIMEOUT_SECONDS,
 239                 TimeUnit.SECONDS);
 240     }
 241
 242     protected void loadDataAsync(final String url, final String data, final String mimeType,
 243              final boolean isBase64Encoded) throws Exception {
 244         getInstrumentation().runOnMainSync(new Runnable() {
 245             @Override
 246             public void run() {
 247                 mXWalkView.load(url, data);
 248             }
 249         });
 250     }
 251
 252     protected void loadUrlSyncByContent(final XWalkView xWalkContent,
 253             final TestHelperBridge contentsClient,
 254             final String url) throws Exception {
 255         CallbackHelper pageFinishedHelper = contentsClient.getOnPageFinishedHelper();
 256         int currentCallCount = pageFinishedHelper.getCallCount();
 257         loadUrlAsyncByContent(xWalkContent, url);
 258
 259         pageFinishedHelper.waitForCallback(currentCallCount, 1, WAIT_TIMEOUT_SECONDS,
 260                 TimeUnit.SECONDS);
 261     }
 262
 263     protected void loadUrlAsyncByContent(final XWalkView xWalkContent,
 264             final String url) throws Exception {
 265         getInstrumentation().runOnMainSync(new Runnable() {
 266             @Override
 267             public void run() {
 268                 xWalkContent.load(url, null);
 269             }
 270         });
 271     }
 272
 273     protected String getTitleOnUiThread() throws Exception {
 274         return runTestOnUiThreadAndGetResult(new Callable<String>() {
 275             @Override
 276             public String call() throws Exception {
 277                 return mXWalkView.getTitle();
 278             }
 279         });
 280     }
 281
 282     protected <R> R runTestOnUiThreadAndGetResult(Callable<R> callable)
 283             throws Exception {
 284         FutureTask<R> task = new FutureTask<R>(callable);
 285         getInstrumentation().waitForIdleSync();
 286         getInstrumentation().runOnMainSync(task);
 287         return task.get();
 288     }
 289
 290     protected String getFileContent(String fileName) {
 291         try {
 292             Context context = getInstrumentation().getContext();
 293             InputStream inputStream = context.getAssets().open(fileName);
 294             int size = inputStream.available();
 295             byte buffer[] = new byte[size];
 296             inputStream.read(buffer);
 297             inputStream.close();
 298
 299             String fileContent = new String(buffer);
 300             return fileContent;
 301         } catch (IOException e) {
 302             throw new RuntimeException(e);
 303         }
 304     }
 305
 306     protected String getTitleOnUiThreadByContent(final XWalkView xWalkContent) throws Exception {
 307         return runTestOnUiThreadAndGetResult(new Callable<String>() {
 308             @Override
 309             public String call() throws Exception {
 310                 String title = xWalkContent.getTitle();
 311                 return title;
 312             }
 313         });
 314     }
 315
 316     protected XWalkView createXWalkViewContainerOnMainSync(
 317             final Context context,
 318             final XWalkUIClient uiClient,
 319             final XWalkResourceClient resourceClient) throws Exception {
 320         final AtomicReference<XWalkView> xWalkViewContainer =
 321                 new AtomicReference<XWalkView>();
 322         getInstrumentation().runOnMainSync(new Runnable() {
 323             @Override
 324             public void run() {
 325                 xWalkViewContainer.set(new XWalkView(context, getActivity()));
 326                 getActivity().addView(xWalkViewContainer.get());
 327                 xWalkViewContainer.get().setUIClient(uiClient);
 328                 xWalkViewContainer.get().setResourceClient(resourceClient);
 329             }
 330         });
 331
 332         return xWalkViewContainer.get();
 333     }
 334
 335     protected void loadAssetFile(String fileName) throws Exception {
 336         String fileContent = getFileContent(fileName);
 337         loadDataSync(fileName, fileContent, "text/html", false);
 338     }
 339
 340     public void loadAssetFileAndWaitForTitle(String fileName) throws Exception {
 341         CallbackHelper getTitleHelper = mTestHelperBridge.getOnTitleUpdatedHelper();
 342         int currentCallCount = getTitleHelper.getCallCount();
 343         String fileContent = getFileContent(fileName);
 344
 345         loadDataSync(fileName, fileContent, "text/html", false);
 346
 347         getTitleHelper.waitForCallback(currentCallCount, 1, WAIT_TIMEOUT_SECONDS,
 348                 TimeUnit.SECONDS);
 349     }
 350
 351     protected XWalkView getXWalkView() {
 352         return mXWalkView;
 353     }
 354
 355     protected void runTestWaitPageFinished(Runnable runnable) throws Exception{
 356         CallbackHelper pageFinishedHelper = mTestHelperBridge.getOnPageFinishedHelper();
 357         int currentCallCount = pageFinishedHelper.getCallCount();
 358         runnable.run();
 359         pageFinishedHelper.waitForCallback(currentCallCount, 1, WAIT_TIMEOUT_SECONDS,
 360                 TimeUnit.SECONDS);
 361     }
 362
 363     protected void reloadSync(final int mode) throws Exception {
 364         runTestWaitPageFinished(new Runnable(){
 365             @Override
 366             public void run() {
 367                 getInstrumentation().runOnMainSync(new Runnable() {
 368                     @Override
 369                     public void run() {
 370                         mXWalkView.reload(mode);
 371                     }
 372                 });
 373             }
 374         });
 375     }
 376
 377     protected void goBackSync() throws Throwable {
 378         runTestWaitPageFinished(new Runnable(){
 379             @Override
 380             public void run() {
 381                 getInstrumentation().runOnMainSync(new Runnable() {
 382                     @Override
 383                     public void run() {
 384                         mXWalkView.getNavigationHistory().navigate(
 385                             XWalkNavigationHistory.Direction.BACKWARD, 1);
 386                     }
 387                 });
 388             }
 389         });
 390     }
 391
 392     protected void goForwardSync() throws Throwable {
 393         runTestWaitPageFinished(new Runnable(){
 394             @Override
 395             public void run() {
 396                 getInstrumentation().runOnMainSync(new Runnable() {
 397                     @Override
 398                     public void run() {
 399                         mXWalkView.getNavigationHistory().navigate(
 400                             XWalkNavigationHistory.Direction.FORWARD, 1);
 401                     }
 402                 });
 403             }
 404         });
 405     }
 406
 407     protected void clearHistoryOnUiThread() throws Exception {
 408         getInstrumentation().runOnMainSync(new Runnable() {
 409             @Override
 410             public void run() {
 411                 mXWalkView.getNavigationHistory().clear();
 412             }
 413         });
 414     }
 415
 416     protected boolean canGoBackOnUiThread() throws Throwable {
 417         return runTestOnUiThreadAndGetResult(new Callable<Boolean>() {
 418             @Override
 419             public Boolean call() {
 420                 return mXWalkView.getNavigationHistory().canGoBack();
 421             }
 422         });
 423     }
 424
 425     protected boolean canGoForwardOnUiThread() throws Throwable {
 426         return runTestOnUiThreadAndGetResult(new Callable<Boolean>() {
 427             @Override
 428             public Boolean call() {
 429                 return mXWalkView.getNavigationHistory().canGoForward();
 430             }
 431         });
 432     }
 433
 434     protected int historySizeOnUiThread() throws Throwable {
 435         return runTestOnUiThreadAndGetResult(new Callable<Integer>() {
 436             @Override
 437             public Integer call() {
 438                 return mXWalkView.getNavigationHistory().size();
 439             }
 440         });
 441     }
 442
 443     protected boolean hasItemAtOnUiThread(final int index) throws Throwable {
 444         return runTestOnUiThreadAndGetResult(new Callable<Boolean>() {
 445             @Override
 446             public Boolean call() {
 447                 return mXWalkView.getNavigationHistory().hasItemAt(index);
 448             }
 449         });
 450     }
 451
 452     protected XWalkNavigationItem getItemAtOnUiThread(final int index) throws Throwable {
 453         return runTestOnUiThreadAndGetResult(new Callable<XWalkNavigationItem>() {
 454             @Override
 455             public XWalkNavigationItem call() {
 456                 return mXWalkView.getNavigationHistory().getItemAt(index);
 457             }
 458         });
 459     }
 460
 461     protected XWalkNavigationItem getCurrentItemOnUiThread() throws Throwable {
 462         return runTestOnUiThreadAndGetResult(new Callable<XWalkNavigationItem>() {
 463             @Override
 464             public XWalkNavigationItem call() {
 465                 return mXWalkView.getNavigationHistory().getCurrentItem();
 466             }
 467         });
 468     }
 469
 470     protected String executeJavaScriptAndWaitForResult(final String code) throws Exception {
 471
 472         final TestHelperBridge.OnEvaluateJavaScriptResultHelper helper =
 473                 mTestHelperBridge.getOnEvaluateJavaScriptResultHelper();
 474         getInstrumentation().runOnMainSync(new Runnable() {
 475             @Override
 476             public void run() {
 477                 helper.evaluateJavascript(mXWalkView, code);
 478             }
 479         });
 480         helper.waitUntilHasValue();
 481         Assert.assertTrue("Failed to retrieve JavaScript evaluation results.", helper.hasValue());
 482         return helper.getJsonResultAndClear();
 483     }
 484
 485     protected String getUrlOnUiThread() throws Exception {
 486         return runTestOnUiThreadAndGetResult(new Callable<String>() {
 487             @Override
 488             public String call() throws Exception {
 489                 return mXWalkView.getUrl();
 490             }
 491         });
 492     }
 493
 494     protected void clearCacheOnUiThread(final boolean includeDiskFiles) throws Exception {
 495         getInstrumentation().runOnMainSync(new Runnable() {
 496             @Override
 497             public void run() {
 498                 mXWalkView.clearCache(includeDiskFiles);
 499             }
 500         });
 501     }
 502
 503     protected String getAPIVersionOnUiThread() throws Exception {
 504         return runTestOnUiThreadAndGetResult(new Callable<String>() {
 505             @Override
 506             public String call() throws Exception {
 507                 return mXWalkView.getAPIVersion();
 508             }
 509         });
 510     }
 511
 512     protected String getXWalkVersionOnUiThread() throws Exception {
 513         return runTestOnUiThreadAndGetResult(new Callable<String>() {
 514             @Override
 515             public String call() throws Exception {
 516                 return mXWalkView.getXWalkVersion();
 517             }
 518         });
 519     }
 520
 521     public void clickOnElementId(final String id, String frameName) throws Exception {
 522         String str;
 523         if (frameName != null) {
 524             str = "top.window." + "LeftFrame" + ".document.getElementById('" + id + "')";
 525         } else {
 526             str = "document.getElementById('" + id + "')";
 527         }
 528         final String script1 = str + " != null";
 529         final String script2 = str + ".dispatchEvent(evObj);";
 530         Assert.assertTrue(CriteriaHelper.pollForCriteria(new Criteria() {
 531             @Override
 532             public boolean isSatisfied() {
 533                 try {
 534                     String idIsNotNull = executeJavaScriptAndWaitForResult(script1);
 535                     return idIsNotNull.equals("true");
 536                 } catch (Throwable t) {
 537                     t.printStackTrace();
 538                     Assert.fail("Failed to check if DOM is loaded: " + t.toString());
 539                     return false;
 540                 }
 541             }
 542         }, WAIT_TIMEOUT_MS, CHECK_INTERVAL));
 543
 544         try {
 545             String result = executeJavaScriptAndWaitForResult(
 546                 "var evObj = document.createEvent('Events'); " +
 547                 "evObj.initEvent('click', true, false); " +
 548                 script2 +
 549                 "console.log('element with id [" + id + "] clicked');");
 550         } catch (Throwable t) {
 551             t.printStackTrace();
 552         }
 553     }
 554
 555     public void simulateKeyAction(final int action) {
 556         new Thread(new Runnable() {
 557             public void run() {
 558                 try {
 559                     getInstrumentation().sendKeySync(new KeyEvent(action,
 560                             KeyEvent.KEYCODE_DPAD_CENTER));
 561                 } catch (Exception e) {
 562                     e.printStackTrace();
 563                 }
 564             }
 565         }).start();
 566     }
 567
 568     protected void stopLoading() throws Exception {
 569         getInstrumentation().runOnMainSync(new Runnable() {
 570             @Override
 571             public void run() {
 572                 mXWalkView.stopLoading();
 573             }
 574         });
 575     }
 576 }