Convert the rest of chrome_public_test_apk InstrumentationTestCases to JUnit4

chrome/android/javatests/src/org/chromium/chrome/browser/customtabs/CustomTabTabPersistencePolicyTest.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.customtabs;
 
-import static android.test.MoreAsserts.assertContentsInAnyOrder;
-import static android.test.MoreAsserts.assertEmpty;
-
 import android.app.Activity;
 import android.os.AsyncTask;
+import android.support.test.InstrumentationRegistry;
 import android.support.test.filters.MediumTest;
 import android.support.test.filters.SmallTest;
-import android.test.InstrumentationTestCase;
-import android.test.UiThreadTest;
+import android.support.test.rule.UiThreadTestRule;
+
+import org.hamcrest.Matchers;
+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.ActivityState;
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.Callback;
 import org.chromium.base.ContextUtils;
 import org.chromium.base.StreamUtil;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.test.util.AdvancedMockContext;
 import org.chromium.base.test.util.CallbackHelper;
 import org.chromium.base.test.util.Feature;
 import org.chromium.chrome.browser.ChromeTabbedActivity;
 import org.chromium.chrome.browser.TabState;
 import org.chromium.chrome.browser.compositor.layouts.content.TabContentManager;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tabmodel.TabModelSelector;
 import org.chromium.chrome.browser.tabmodel.TabModelSelectorImpl;
 import org.chromium.chrome.browser.tabmodel.TabPersistencePolicy;
 import org.chromium.chrome.browser.tabmodel.TabPersistentStore;
 import org.chromium.chrome.browser.tabmodel.TestTabModelDirectory;
+import org.chromium.chrome.test.ChromeJUnit4ClassRunner;
 import org.chromium.chrome.test.util.browser.tabmodel.MockTabModel;
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.concurrent.Executor;
 import java.util.concurrent.atomic.AtomicReference;
 
 import javax.annotation.Nullable;
 
 /**
  * Tests for the Custom Tab persistence logic.
  */
-public class CustomTabTabPersistencePolicyTest extends InstrumentationTestCase {
-
+@RunWith(ChromeJUnit4ClassRunner.class)
+public class CustomTabTabPersistencePolicyTest {
     private TestTabModelDirectory mMockDirectory;
     private AdvancedMockContext mAppContext;
 
-    @Override
+    @Rule
+    public UiThreadTestRule mRule = new UiThreadTestRule();
+
+    @Before
     public void setUp() throws Exception {
-        super.setUp();
-
-        mAppContext = new AdvancedMockContext(
-                getInstrumentation().getTargetContext().getApplicationContext());
+        mAppContext = new AdvancedMockContext(InstrumentationRegistry.getInstrumentation()
+                                                      .getTargetContext()
+                                                      .getApplicationContext());
         ContextUtils.initApplicationContextForTests(mAppContext);
 
         mMockDirectory = new TestTabModelDirectory(
                 mAppContext, "CustomTabTabPersistencePolicyTest",
                 CustomTabTabPersistencePolicy.SAVED_STATE_DIRECTORY);
         TabPersistentStore.setBaseStateDirectoryForTests(mMockDirectory.getBaseDirectory());
     }
 
-    @Override
+    @After
     public void tearDown() throws Exception {
         mMockDirectory.tearDown();
 
         List<WeakReference<Activity>> activities = ApplicationStatus.getRunningActivities();
         for (int i = 0; i < activities.size(); i++) {
             Activity activity = activities.get(i).get();
             if (activity == null) continue;
             ApplicationStatus.onStateChangeForTesting(activity, ActivityState.DESTROYED);
         }
-        super.tearDown();
     }
 
+    @Test
     @Feature("TabPersistentStore")
     @SmallTest
     public void testDeletableMetadataSelection_NoFiles() {
         List<File> deletableFiles = CustomTabTabPersistencePolicy.getMetadataFilesForDeletion(
                 System.currentTimeMillis(), new ArrayList<File>());
-        assertEmpty(deletableFiles);
+        Assert.assertThat(deletableFiles, Matchers.emptyIterableOf(File.class));
     }
 
+    @Test
     @Feature("TabPersistentStore")
     @SmallTest
     public void testDeletableMetadataSelection_MaximumValidFiles() {
         long currentTime = System.currentTimeMillis();
 
         // Test the maximum allowed number of state files where they are all valid in terms of age.
         List<File> filesToTest = new ArrayList<>();
         filesToTest.addAll(generateMaximumStateFiles(currentTime));
         List<File> deletableFiles = CustomTabTabPersistencePolicy.getMetadataFilesForDeletion(
                 currentTime, filesToTest);
-        assertEmpty(deletableFiles);
+        Assert.assertThat(deletableFiles, Matchers.emptyIterableOf(File.class));
     }
 
+    @Test
     @Feature("TabPersistentStore")
     @SmallTest
     public void testDeletableMetadataSelection_ExceedsMaximumValidFiles() {
         long currentTime = System.currentTimeMillis();
 
         // Test where we exceed the maximum number of allowed state files and ensure it chooses the
         // older file to delete.
         List<File> filesToTest = new ArrayList<>();
         filesToTest.addAll(generateMaximumStateFiles(currentTime));
         File slightlyOlderFile = buildTestFile("slightlyolderfile", currentTime - 1L);
         // Insert it into the middle just to ensure it is not picking the last file.
         filesToTest.add(filesToTest.size() / 2, slightlyOlderFile);
         List<File> deletableFiles = CustomTabTabPersistencePolicy.getMetadataFilesForDeletion(
                 currentTime, filesToTest);
-        assertContentsInAnyOrder(deletableFiles, slightlyOlderFile);
+        Assert.assertThat(deletableFiles, Matchers.containsInAnyOrder(slightlyOlderFile));
     }
 
+    @Test
     @Feature("TabPersistentStore")
     @SmallTest
     public void testDeletableMetadataSelection_ExceedExpiryThreshold() {
         long currentTime = System.currentTimeMillis();
 
         // Ensure that files that exceed the allowed time threshold are removed regardless of the
         // number of possible files.
         List<File> filesToTest = new ArrayList<>();
         File expiredFile = buildTestFile("expired_file",
                 currentTime - CustomTabTabPersistencePolicy.STATE_EXPIRY_THRESHOLD);
         filesToTest.add(expiredFile);
         List<File> deletableFiles = CustomTabTabPersistencePolicy.getMetadataFilesForDeletion(
                 currentTime, filesToTest);
-        assertContentsInAnyOrder(deletableFiles, expiredFile);
+        Assert.assertThat(deletableFiles, Matchers.containsInAnyOrder(expiredFile));
     }
 
     /**
      * Test to ensure that an existing metadata files are deleted if no restore is requested.
      */
+    @Test
     @Feature("TabPersistentStore")
     @MediumTest
     public void testExistingMetadataFileDeletedIfNoRestore() throws Exception {
         File baseStateDirectory = TabPersistentStore.getOrCreateBaseStateDirectory();
-        assertNotNull(baseStateDirectory);
+        Assert.assertNotNull(baseStateDirectory);
 
         CustomTabTabPersistencePolicy policy = new CustomTabTabPersistencePolicy(7, false);
         File stateDirectory = policy.getOrCreateStateDirectory();
-        assertNotNull(stateDirectory);
+        Assert.assertNotNull(stateDirectory);
 
         String stateFileName = policy.getStateFileName();
         File existingStateFile = new File(stateDirectory, stateFileName);
-        assertTrue(existingStateFile.createNewFile());
+        Assert.assertTrue(existingStateFile.createNewFile());
 
-        assertTrue(existingStateFile.exists());
+        Assert.assertTrue(existingStateFile.exists());
         policy.performInitialization(AsyncTask.SERIAL_EXECUTOR);
         policy.waitForInitializationToFinish();
-        assertFalse(existingStateFile.exists());
+        Assert.assertFalse(existingStateFile.exists());
     }
 
     /**
      * Test the logic that gets all the live tab and task IDs.
      */
+    @Test
     @Feature("TabPersistentStore")
     @SmallTest
-    @UiThreadTest
-    public void testGettingTabAndTaskIds() {
-        Set<Integer> tabIds = new HashSet<>();
-        Set<Integer> taskIds = new HashSet<>();
-        CustomTabTabPersistencePolicy.getAllLiveTabAndTaskIds(tabIds, taskIds);
-        assertEmpty(tabIds);
-        assertEmpty(taskIds);
+    public void testGettingTabAndTaskIds() throws Throwable {
+        mRule.runOnUiThread(new Runnable() {

[Ted C, 2017/03/29 00:06:41]

We should figure out a way to have our own annotation that allows just the test
body to be run on the UI thread w/o the Before and After as this super indenting
is pretty gross.

[the real yoland, 2017/03/29 01:13:23]

Aha, one thing we can do is move things that needed to be run on Instrumentation
thread to a separate TestRule and create a RuleChain (run a group of TestRule in
order) that runs the Instrumentation thread rule first and then UiThread
actions.

Example:
https://codereview.chromium.org/2778103002/diff/20001/chrome/android/javatest...

We don't want diverge from the android testing library's default behavior. And
supporting another annotation is pretty easy but would be even more confusing.

Create crbug.com/706225 to investigate once migration is done

+            @Override
+            public void run() {
+                Set<Integer> tabIds = new HashSet<>();
+                Set<Integer> taskIds = new HashSet<>();
+                CustomTabTabPersistencePolicy.getAllLiveTabAndTaskIds(tabIds, taskIds);
+                Assert.assertThat(tabIds, Matchers.emptyIterable());
+                Assert.assertThat(taskIds, Matchers.emptyIterable());
 
-        tabIds.clear();
-        taskIds.clear();
+                tabIds.clear();
+                taskIds.clear();
 
-        CustomTabActivity cct1 = buildTestCustomTabActivity(1, new int[] {4, 8, 9}, null);
-        ApplicationStatus.onStateChangeForTesting(cct1, ActivityState.CREATED);
+                CustomTabActivity cct1 = buildTestCustomTabActivity(1, new int[] {4, 8, 9}, null);
+                ApplicationStatus.onStateChangeForTesting(cct1, ActivityState.CREATED);
 
-        CustomTabActivity cct2 = buildTestCustomTabActivity(5, new int[] {458}, new int[] {9878});
-        ApplicationStatus.onStateChangeForTesting(cct2, ActivityState.CREATED);
+                CustomTabActivity cct2 =
+                        buildTestCustomTabActivity(5, new int[] {458}, new int[] {9878});
+                ApplicationStatus.onStateChangeForTesting(cct2, ActivityState.CREATED);
 
-        // Add a tabbed mode activity to ensure that its IDs are not included in the returned CCT
-        // ID sets.
-        final TabModelSelectorImpl tabbedSelector =
-                buildTestTabModelSelector(new int[] {12121212}, new int[] {1515151515});
-        ChromeTabbedActivity tabbedActivity = new ChromeTabbedActivity() {
-            @Override
-            public int getTaskId() {
-                return 888;
+                // Add a tabbed mode activity to ensure that its IDs are not included in the
+                // returned CCT ID sets.
+                final TabModelSelectorImpl tabbedSelector =
+                        buildTestTabModelSelector(new int[] {12121212}, new int[] {1515151515});
+                ChromeTabbedActivity tabbedActivity = new ChromeTabbedActivity() {
+                    @Override
+                    public int getTaskId() {
+                        return 888;
+                    }
+
+                    @Override
+                    public TabModelSelector getTabModelSelector() {
+                        return tabbedSelector;
+                    }
+                };
+                ApplicationStatus.onStateChangeForTesting(tabbedActivity, ActivityState.CREATED);
+
+                CustomTabTabPersistencePolicy.getAllLiveTabAndTaskIds(tabIds, taskIds);
+                Assert.assertThat(tabIds, Matchers.containsInAnyOrder(4, 8, 9, 458, 9878));
+                Assert.assertThat(taskIds, Matchers.containsInAnyOrder(1, 5));
             }
-
-            @Override
-            public TabModelSelector getTabModelSelector() {
-                return tabbedSelector;
-            }
-        };
-        ApplicationStatus.onStateChangeForTesting(tabbedActivity, ActivityState.CREATED);
-
-        CustomTabTabPersistencePolicy.getAllLiveTabAndTaskIds(tabIds, taskIds);
-        assertContentsInAnyOrder(tabIds, 4, 8, 9, 458, 9878);
-        assertContentsInAnyOrder(taskIds, 1, 5);
+        });
     }
 
     /**
      * Test the full cleanup task path that determines what files are eligible for deletion.
+     * @throws Throwable

[Ted C, 2017/03/29 00:06:41]

remove

[the real yoland, 2017/03/29 01:13:23]

Done

      */
+    @Test
     @Feature("TabPersistentStore")
     @MediumTest
-    public void testCleanupTask() throws Exception {
+    public void testCleanupTask() throws Throwable {
         File baseStateDirectory = TabPersistentStore.getOrCreateBaseStateDirectory();
-        assertNotNull(baseStateDirectory);
+        Assert.assertNotNull(baseStateDirectory);
 
         CustomTabTabPersistencePolicy policy = new CustomTabTabPersistencePolicy(2, false);
         File stateDirectory = policy.getOrCreateStateDirectory();
-        assertNotNull(stateDirectory);
+        Assert.assertNotNull(stateDirectory);
 
         final AtomicReference<List<String>> filesToDelete = new AtomicReference<>();
         final CallbackHelper callbackSignal = new CallbackHelper();
         Callback<List<String>> filesToDeleteCallback = new Callback<List<String>>() {
             @Override
             public void onResult(List<String> fileNames) {
                 filesToDelete.set(fileNames);
                 callbackSignal.notifyCalled();
             }
         };
 
         // Test when no files have been created.
         policy.cleanupUnusedFiles(filesToDeleteCallback);
         callbackSignal.waitForCallback(0);
-        assertEmpty(filesToDelete.get());
+        Assert.assertThat(filesToDelete.get(), Matchers.emptyIterable());
 
         // Create an unreferenced tab state file and ensure it is marked for deletion.
         File tab999File = TabState.getTabStateFile(stateDirectory, 999, false);
-        assertTrue(tab999File.createNewFile());
+        Assert.assertTrue(tab999File.createNewFile());
         policy.cleanupUnusedFiles(filesToDeleteCallback);
         callbackSignal.waitForCallback(1);
-        assertContentsInAnyOrder(filesToDelete.get(), tab999File.getName());
+        Assert.assertThat(filesToDelete.get(), Matchers.containsInAnyOrder(tab999File.getName()));
 
         // Reference the tab state file and ensure it is no longer marked for deletion.
-        CustomTabActivity cct1 = buildTestCustomTabActivity(1, new int[] {999}, null);
-        ApplicationStatus.onStateChangeForTesting(cct1, ActivityState.CREATED);
+        mRule.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                CustomTabActivity cct1 = buildTestCustomTabActivity(1, new int[] {999}, null);
+                ApplicationStatus.onStateChangeForTesting(cct1, ActivityState.CREATED);
+            }
+        });
         policy.cleanupUnusedFiles(filesToDeleteCallback);
         callbackSignal.waitForCallback(2);
-        assertEmpty(filesToDelete.get());
+        Assert.assertThat(filesToDelete.get(), Matchers.emptyIterable());
 
         // Create a tab model and associated tabs. Ensure it is not marked for deletion as it is
         // new enough.
-        final TabModelSelectorImpl selectorImpl = buildTestTabModelSelector(
-                new int[] {111, 222, 333 }, null);
         byte[] data = ThreadUtils.runOnUiThreadBlockingNoException(new Callable<byte[]>() {
             @Override
             public byte[] call() throws Exception {
+                TabModelSelectorImpl selectorImpl =
+                        buildTestTabModelSelector(new int[] {111, 222, 333}, null);
                 return TabPersistentStore.serializeTabModelSelector(selectorImpl, null);
             }
         });
         FileOutputStream fos = null;
         File metadataFile = new File(
                 stateDirectory, TabPersistentStore.getStateFileName("3"));
         try {
             fos = new FileOutputStream(metadataFile);
             fos.write(data);
         } finally {
             StreamUtil.closeQuietly(fos);
         }
         File tab111File = TabState.getTabStateFile(stateDirectory, 111, false);
-        assertTrue(tab111File.createNewFile());
+        Assert.assertTrue(tab111File.createNewFile());
         File tab222File = TabState.getTabStateFile(stateDirectory, 222, false);
-        assertTrue(tab222File.createNewFile());
+        Assert.assertTrue(tab222File.createNewFile());
         File tab333File = TabState.getTabStateFile(stateDirectory, 333, false);
-        assertTrue(tab333File.createNewFile());
+        Assert.assertTrue(tab333File.createNewFile());
         policy.cleanupUnusedFiles(filesToDeleteCallback);
         callbackSignal.waitForCallback(3);
-        assertEmpty(filesToDelete.get());
+        Assert.assertThat(filesToDelete.get(), Matchers.emptyIterable());
 
         // Set the age of the metadata file to be past the expiration threshold and ensure it along
         // with the associated tab files are marked for deletion.
-        assertTrue(metadataFile.setLastModified(1234));
+        Assert.assertTrue(metadataFile.setLastModified(1234));
         policy.cleanupUnusedFiles(filesToDeleteCallback);
         callbackSignal.waitForCallback(4);
-        assertContentsInAnyOrder(filesToDelete.get(), tab111File.getName(), tab222File.getName(),
-                tab333File.getName(), metadataFile.getName());
+        Assert.assertThat(filesToDelete.get(),
+                Matchers.containsInAnyOrder(tab111File.getName(), tab222File.getName(),
+                        tab333File.getName(), metadataFile.getName()));
     }
 
     /**
      * Ensure that the metadata file's last modified timestamp is updated on initialization.
      */
+    @Test
     @Feature("TabPersistentStore")
     @MediumTest
     public void testMetadataTimestampRefreshed() throws Exception {
         File baseStateDirectory = TabPersistentStore.getOrCreateBaseStateDirectory();
-        assertNotNull(baseStateDirectory);
+        Assert.assertNotNull(baseStateDirectory);
 
         CustomTabTabPersistencePolicy policy = new CustomTabTabPersistencePolicy(2, true);
         File stateDirectory = policy.getOrCreateStateDirectory();
-        assertNotNull(stateDirectory);
+        Assert.assertNotNull(stateDirectory);
 
         File metadataFile = new File(stateDirectory, policy.getStateFileName());
-        assertTrue(metadataFile.createNewFile());
+        Assert.assertTrue(metadataFile.createNewFile());
 
         long previousTimestamp =
                 System.currentTimeMillis() - CustomTabTabPersistencePolicy.STATE_EXPIRY_THRESHOLD;
-        assertTrue(metadataFile.setLastModified(previousTimestamp));
+        Assert.assertTrue(metadataFile.setLastModified(previousTimestamp));
 
         policy.performInitialization(AsyncTask.SERIAL_EXECUTOR);
         policy.waitForInitializationToFinish();
 
-        assertTrue(metadataFile.lastModified() > previousTimestamp);
+        Assert.assertTrue(metadataFile.lastModified() > previousTimestamp);
     }
 
     private static List<File> generateMaximumStateFiles(long currentTime) {
         List<File> validFiles = new ArrayList<>();
         for (int i = 0; i < CustomTabTabPersistencePolicy.MAXIMUM_STATE_FILES; i++) {
             validFiles.add(buildTestFile("testfile" + i, currentTime));
         }
         return validFiles;
     }
 
@@ skipping 112 matching lines @@
 
         CustomTabActivity activity = new CustomTabActivity();
         ApplicationStatus.onStateChangeForTesting(activity, ActivityState.CREATED);
         TabModelSelectorImpl selector = new TabModelSelectorImpl(
                 activity, activity, buildTestPersistencePolicy(), false, false);
         selector.initializeForTesting(normalTabModel, incognitoTabModel);
         ApplicationStatus.onStateChangeForTesting(activity, ActivityState.DESTROYED);
         return selector;
     }
 }