Home | History | Annotate | Download | only in cronet_sample_apk 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 package org.chromium.cronet_sample_apk;
      6 
      7 import android.content.ComponentName;
      8 import android.content.Intent;
      9 import android.net.Uri;
     10 import android.test.ActivityInstrumentationTestCase2;
     11 import android.text.TextUtils;
     12 
     13 import static org.chromium.base.test.util.ScalableTimeout.scaleTimeout;
     14 
     15 import org.chromium.base.test.util.UrlUtils;
     16 
     17 import java.util.concurrent.atomic.AtomicBoolean;
     18 
     19 /**
     20  * Base test class for all CronetSample based tests.
     21  */
     22 public class CronetSampleTestBase extends
     23         ActivityInstrumentationTestCase2<CronetSampleActivity> {
     24 
     25     /**
     26      * The maximum time the waitForActiveShellToBeDoneLoading method will wait.
     27      */
     28     private static final long
     29             WAIT_FOR_ACTIVE_SHELL_LOADING_TIMEOUT = scaleTimeout(10000);
     30 
     31     protected static final long
     32             WAIT_PAGE_LOADING_TIMEOUT_SECONDS = scaleTimeout(15);
     33 
     34     public CronetSampleTestBase() {
     35         super(CronetSampleActivity.class);
     36     }
     37 
     38     /**
     39      * Starts the CronetSample activity and loads the given URL. The URL can be
     40      * null, in which case will default to
     41      * CronetSampleActivity.DEFAULT_SHELL_URL.
     42      */
     43     protected CronetSampleActivity launchCronetSampleWithUrl(String url) {
     44         return launchCronetSampleWithUrlAndCommandLineArgs(url, null);
     45     }
     46 
     47     /**
     48      * Starts the CronetSample activity appending the provided command line
     49      * arguments and loads the given URL. The URL can be null, in which case
     50      * will default to CronetSampleActivity.DEFAULT_SHELL_URL.
     51      */
     52     protected CronetSampleActivity launchCronetSampleWithUrlAndCommandLineArgs(
     53             String url, String[] commandLineArgs) {
     54         Intent intent = new Intent(Intent.ACTION_MAIN);
     55         intent.addCategory(Intent.CATEGORY_LAUNCHER);
     56         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
     57         if (url != null)
     58             intent.setData(Uri.parse(url));
     59         intent.setComponent(new ComponentName(
     60                 getInstrumentation().getTargetContext(),
     61                 CronetSampleActivity.class));
     62         if (commandLineArgs != null) {
     63             intent.putExtra(CronetSampleActivity.COMMAND_LINE_ARGS_KEY,
     64                     commandLineArgs);
     65         }
     66         setActivityIntent(intent);
     67         return getActivity();
     68     }
     69 
     70     // TODO(cjhopman): These functions are inconsistent with
     71     // launchCronetSample***. Should be startCronetSample*** and should use the
     72     // url exactly without the getTestFileUrl call. Possibly these two ways of
     73     // starting the activity (launch* and start*) should be merged into one.
     74     /**
     75      * Starts the content shell activity with the provided test url. The url is
     76      * synchronously loaded.
     77      *
     78      * @param url Test url to load.
     79      */
     80     protected void startActivityWithTestUrl(String url) throws Throwable {
     81         launchCronetSampleWithUrl(UrlUtils.getTestFileUrl(url));
     82         assertNotNull(getActivity());
     83         assertTrue(waitForActiveShellToBeDoneLoading());
     84         assertEquals(UrlUtils.getTestFileUrl(url), getActivity().getUrl());
     85     }
     86 
     87     /**
     88      * Starts the content shell activity with the provided test url and optional
     89      * command line arguments to append. The url is synchronously loaded.
     90      *
     91      * @param url Test url to load.
     92      * @param commandLineArgs Optional command line args to append when
     93      *            launching the activity.
     94      */
     95     protected void startActivityWithTestUrlAndCommandLineArgs(String url,
     96             String[] commandLineArgs) throws Throwable {
     97         launchCronetSampleWithUrlAndCommandLineArgs(
     98                 UrlUtils.getTestFileUrl(url), commandLineArgs);
     99         assertNotNull(getActivity());
    100         assertTrue(waitForActiveShellToBeDoneLoading());
    101     }
    102 
    103     /**
    104      * Waits for the Active shell to finish loading. This times out after
    105      * WAIT_FOR_ACTIVE_SHELL_LOADING_TIMEOUT milliseconds and it shouldn't be
    106      * used for long loading pages. Instead it should be used more for test
    107      * initialization. The proper way to wait is to use a
    108      * TestCallbackHelperContainer after the initial load is completed.
    109      *
    110      * @return Whether or not the Shell was actually finished loading.
    111      * @throws InterruptedException
    112      */
    113     protected boolean waitForActiveShellToBeDoneLoading()
    114             throws InterruptedException {
    115         final CronetSampleActivity activity = getActivity();
    116 
    117         // Wait for the Content Shell to be initialized.
    118         return CriteriaHelper.pollForCriteria(new Criteria() {
    119                 @Override
    120             public boolean isSatisfied() {
    121                 try {
    122                     final AtomicBoolean isLoaded = new AtomicBoolean(false);
    123                     runTestOnUiThread(new Runnable() {
    124                             @Override
    125                         public void run() {
    126                             if (activity != null) {
    127                                 // There are two cases here that need to be
    128                                 // accounted for.
    129                                 // The first is that we've just created a Shell
    130                                 // and it isn't
    131                                 // loading because it has no URL set yet. The
    132                                 // second is that
    133                                 // we've set a URL and it actually is loading.
    134                                 isLoaded.set(!activity.isLoading() && !TextUtils
    135                                         .isEmpty(activity.getUrl()));
    136                             } else {
    137                                 isLoaded.set(false);
    138                             }
    139                         }
    140                     });
    141 
    142                     return isLoaded.get();
    143                 } catch (Throwable e) {
    144                     return false;
    145                 }
    146             }
    147         }, WAIT_FOR_ACTIVE_SHELL_LOADING_TIMEOUT,
    148                 CriteriaHelper.DEFAULT_POLLING_INTERVAL);
    149     }
    150 }
    151