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