Convert ChromeActivityTestCaseBase direct children to JUnit4

chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/OfflinePageSavePageLaterEvaluationTest.java

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.offlinepages;
 
 import android.app.NotificationManager;
 import android.content.Context;
 import android.os.Environment;
 import android.text.TextUtils;
 import android.util.LongSparseArray;
 
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
 import org.chromium.base.Callback;
 import org.chromium.base.ContextUtils;
 import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.test.util.CommandLineFlags;
 import org.chromium.base.test.util.Manual;
 import org.chromium.base.test.util.TimeoutScale;
 import org.chromium.chrome.browser.ChromeActivity;
+import org.chromium.chrome.browser.ChromeSwitches;
 import org.chromium.chrome.browser.offlinepages.evaluation.OfflinePageEvaluationBridge;
 import org.chromium.chrome.browser.offlinepages.evaluation.OfflinePageEvaluationBridge.OfflinePageEvaluationObserver;
 import org.chromium.chrome.browser.profiles.Profile;
-import org.chromium.chrome.test.ChromeActivityTestCaseBase;
+import org.chromium.chrome.test.ChromeActivityTestRule;
+import org.chromium.chrome.test.ChromeJUnit4ClassRunner;
 import org.chromium.components.offlinepages.BackgroundSavePageResult;
 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
-
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Properties;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 
 /**
  * Tests OfflinePageBridge.SavePageLater over a batch of urls.
  * Tests against a list of top EM urls, try to call SavePageLater on each of the url. It also
  * record metrics (failure rate, time elapsed etc.) by writing metrics to a file on external
  * storage. This will always use prerenderer.
  */
-@CommandLineFlags.Add({"disable-features=BackgroundLoader"})
-public class OfflinePageSavePageLaterEvaluationTest
-        extends ChromeActivityTestCaseBase<ChromeActivity> {
+@RunWith(ChromeJUnit4ClassRunner.class)
+@CommandLineFlags.Add({"disable-features=BackgroundLoader",
+        ChromeSwitches.DISABLE_FIRST_RUN_EXPERIENCE,
+        ChromeActivityTestRule.DISABLE_NETWORK_PREDICTION_FLAG})
+public class OfflinePageSavePageLaterEvaluationTest {
     /**
      * Class which is used to calculate time difference.
      */
+
+    @Rule
+    public ChromeActivityTestRule<ChromeActivity> mActivityTestRule =
+            new ChromeActivityTestRule<>(ChromeActivity.class);
+
     static class TimeDelta {
         public void setStartTime(Long startTime) {
             mStartTime = startTime;
         }
         public void setEndTime(Long endTime) {
             mEndTime = endTime;
         }
         // Return time delta in milliseconds.
         public Long getTimeDelta() {
             return mEndTime - mStartTime;
@@ skipping 30 matching lines @@
     private CountDownLatch mCompletionLatch;
     private List<String> mUrls;
     private int mCount;
     private boolean mIsUserRequested;
     private boolean mUseTestScheduler;
     private int mScheduleBatchSize;
     private boolean mUseBackgroundLoader;
 
     private LongSparseArray<RequestMetadata> mRequestMetadata;
 
-    public OfflinePageSavePageLaterEvaluationTest() {
-        super(ChromeActivity.class);
-    }
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
+    @Before
+    public void setUp() throws Exception {
+        mActivityTestRule.startMainActivityOnBlankPage();
         mRequestMetadata = new LongSparseArray<RequestMetadata>();
         mCount = 0;
     }
 
-    @Override
-    protected void tearDown() throws Exception {
+    @After
+    public void tearDown() throws Exception {
         NotificationManager notificationManager =
                 (NotificationManager) ContextUtils.getApplicationContext().getSystemService(
                         Context.NOTIFICATION_SERVICE);
         notificationManager.cancelAll();
         final Semaphore mClearingSemaphore = new Semaphore(0);
         ThreadUtils.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 assert mBridge != null;
                 mBridge.getRequestsInQueue(new Callback<SavePageRequest[]>() {
@@ skipping 10 matching lines @@
                             }
                         });
                     }
                 });
             }
         });
         checkTrue(mClearingSemaphore.tryAcquire(REMOVE_REQUESTS_TIMEOUT_MS, TimeUnit.MILLISECONDS),
                 "Timed out when clearing remaining requests!");
         mBridge.closeLog();
         mBridge.destroy();
-        super.tearDown();
-    }
-
-    @Override
-    public void startMainActivity() throws InterruptedException {
-        startMainActivityOnBlankPage();
     }
 
     /**
      * Get a reader for a given input file path.
      */
     private BufferedReader getInputStream(String inputFilePath) throws FileNotFoundException {
         FileReader fileReader =
                 new FileReader(new File(Environment.getExternalStorageDirectory(), inputFilePath));
         BufferedReader bufferedReader = new BufferedReader(fileReader);
         return bufferedReader;
@@ skipping 40 matching lines @@
     private void log(String tag, String format, Object... args) {
         mBridge.log(tag, String.format(format, args));
     }
 
     /**
      * Assert the condition is true, otherwise abort the test and log.
      */
     private void checkTrue(boolean condition, String message) {
         if (!condition) {
             log(TAG, message);
-            fail();
+            Assert.fail();
         }
     }
 
     /**
      * Initializes the evaluation bridge which will be used.
      * @param useCustomScheduler True if customized scheduler (the one with immediate scheduling)
      *                           will be used. False otherwise.
      * @param useBackgroundLoader True if use background loader. False if use prerenderer.
      */
     private void initializeBridgeForProfile(final boolean useTestingScheduler,
             final boolean useBackgroundLoader) throws InterruptedException {
         final Semaphore semaphore = new Semaphore(0);
         ThreadUtils.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 Profile profile = Profile.getLastUsedProfile();
                 mBridge = new OfflinePageEvaluationBridge(
                         profile, useTestingScheduler, useBackgroundLoader);
                 if (mBridge == null) {
-                    fail("OfflinePageEvaluationBridge initialization failed!");
+                    Assert.fail("OfflinePageEvaluationBridge initialization failed!");
                     return;
                 }
                 if (mBridge.isOfflinePageModelLoaded()) {
                     semaphore.release();
                     return;
                 }
                 mBridge.addObserver(new OfflinePageEvaluationObserver() {
                     @Override
                     public void offlinePageModelLoaded() {
                         semaphore.release();
@@ skipping 79 matching lines @@
         ThreadUtils.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 mBridge.savePageLater(url, namespace, mIsUserRequested);
             }
         });
     }
 
     private void processUrls(List<String> urls) throws InterruptedException, IOException {
         if (mBridge == null) {
-            fail("Test initialization error, aborting. No results would be written.");
+            Assert.fail("Test initialization error, aborting. No results would be written.");
             return;
         }
         int count = 0;
         log(TAG_PROGRESS, "# of Urls in file: " + mUrls.size());
         for (int i = 0; i < mUrls.size(); i++) {
             savePageLater(mUrls.get(i), NAMESPACE);
             count++;
             if (count == mScheduleBatchSize || i == mUrls.size() - 1) {
                 count = 0;
                 mCompletionLatch = new CountDownLatch(1);
@@ skipping 16 matching lines @@
                         mUrls.add(url);
                     }
                 }
             } finally {
                 if (bufferedReader != null) {
                     bufferedReader.close();
                 }
             }
         } catch (FileNotFoundException e) {
             Log.e(TAG, e.getMessage(), e);
-            fail(String.format("URL file %s is not found.", inputFilePath));
+            Assert.fail(String.format("URL file %s is not found.", inputFilePath));
         }
     }
 
     // Translate the int value of status to BackgroundSavePageResult.
     private String statusToString(int status) {
         switch (status) {
             case BackgroundSavePageResult.SUCCESS:
                 return "SUCCESS";
             case BackgroundSavePageResult.LOADING_FAILURE:
                 return "LOADING_FAILURE";
@@ skipping 107 matching lines @@
             File configFile = new File(Environment.getExternalStorageDirectory(), CONFIG_FILE_PATH);
             inputStream = new FileInputStream(configFile);
             properties.load(inputStream);
             mIsUserRequested = Boolean.parseBoolean(properties.getProperty("IsUserRequested"));
             mUseTestScheduler = Boolean.parseBoolean(properties.getProperty("UseTestScheduler"));
             mScheduleBatchSize = Integer.parseInt(properties.getProperty("ScheduleBatchSize"));
             mUseBackgroundLoader =
                     Boolean.parseBoolean(properties.getProperty("UseBackgroundLoader"));
         } catch (FileNotFoundException e) {
             Log.e(TAG, e.getMessage(), e);
-            fail(String.format(
+            Assert.fail(String.format(
                     "Config file %s is not found, aborting the test.", CONFIG_FILE_PATH));
         } catch (NumberFormatException e) {
             Log.e(TAG, e.getMessage(), e);
-            fail("Error parsing config file, aborting test.");
+            Assert.fail("Error parsing config file, aborting test.");
         } finally {
             if (inputStream != null) {
                 inputStream.close();
             }
         }
     }
 
     /**
      * The test is the entry point for all kinds of testing of SavePageLater.
      * It is encouraged to use run_offline_page_evaluation_test.py to run this test.
      * TimeoutScale is set to 4, in case we hit the hard limit for @Manual tests(10 hours)
      * and gets killed. It expand the timeout to 10 * 4 hours.
      * We won't be treating svelte devices differently so enable the feature which would let
      * immediate processing also works on svelte devices. This flag will *not* affect normal
      * devices.
      */
+    @Test
     @Manual
     @TimeoutScale(4)
-    @CommandLineFlags
-            .Add({"enable-features=OfflinePagesSvelteConcurrentLoading"})
+    @CommandLineFlags.Add({"enable-features=OfflinePagesSvelteConcurrentLoading"})
     @CommandLineFlags.Remove({"disable-features=OfflinePagesSvelteConcurrentLoading"})
     public void testFailureRate() throws IOException, InterruptedException {
         parseConfigFile();
         setUpIOAndBridge(mUseTestScheduler, mUseBackgroundLoader);
         processUrls(mUrls);
     }
 
     /**
      * Runs testFailureRate with background loader enabled.
      * We won't be treating svelte devices differently so enable the feature which would let
      * immediate processing also works on svelte devices. This flag will *not* affect normal
      * devices.
      */
+    @Test
     @Manual
     @TimeoutScale(4)
-    @CommandLineFlags
-            .Add({"enable-features=BackgroundLoader,OfflinePagesSvelteConcurrentLoading"})
-    @CommandLineFlags
-            .Remove({"disable-features=BackgroundLoader,OfflinePagesSvelteConcurrentLoading"})
+    @CommandLineFlags.Add({"enable-features=BackgroundLoaderOfflinePagesSvelteConcurrentLoading"})
+    @CommandLineFlags.Remove({
+            "disable-features=BackgroundLoaderOfflinePagesSvelteConcurrentLoading"})
     public void testBackgroundLoaderFailureRate() throws IOException, InterruptedException {
         testFailureRate();
     }
 }