Convert ChromeActivityTestCaseBase direct children to JUnit4

chrome/android/javatests/src/org/chromium/chrome/browser/bookmarks/BookmarkTest.java

 // Copyright 2015 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.bookmarks;
 
+import android.support.test.InstrumentationRegistry;
 import android.support.test.filters.MediumTest;
 import android.support.test.filters.SmallTest;
 import android.support.v7.widget.RecyclerView;
 import android.support.v7.widget.RecyclerView.Adapter;
 import android.text.TextUtils;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.TextView;
 
-import junit.framework.Assert;
+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.ThreadUtils;
+import org.chromium.base.test.util.CommandLineFlags;
 import org.chromium.base.test.util.RetryOnFailure;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.ChromeActivity;
+import org.chromium.chrome.browser.ChromeSwitches;
 import org.chromium.chrome.browser.UrlConstants;
 import org.chromium.chrome.browser.bookmarks.BookmarkBridge.BookmarkItem;
 import org.chromium.chrome.browser.widget.selection.SelectableListToolbar;
-import org.chromium.chrome.test.ChromeActivityTestCaseBase;
+import org.chromium.chrome.test.ChromeActivityTestRule;
+import org.chromium.chrome.test.ChromeJUnit4ClassRunner;
 import org.chromium.chrome.test.util.ActivityUtils;
 import org.chromium.chrome.test.util.BookmarkTestUtil;
 import org.chromium.chrome.test.util.ChromeTabUtils;
 import org.chromium.chrome.test.util.MenuUtils;
 import org.chromium.components.bookmarks.BookmarkId;
 import org.chromium.components.bookmarks.BookmarkType;
 import org.chromium.content.browser.test.util.TouchCommon;
 import org.chromium.net.test.EmbeddedTestServer;
 import org.chromium.ui.base.DeviceFormFactor;
 
 import java.util.ArrayList;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 
 /**
  * Tests for the bookmark manager.
  */
+@RunWith(ChromeJUnit4ClassRunner.class)
+@CommandLineFlags.Add({ChromeSwitches.DISABLE_FIRST_RUN_EXPERIENCE,
+        ChromeActivityTestRule.DISABLE_NETWORK_PREDICTION_FLAG})
 @RetryOnFailure
-public class BookmarkTest extends ChromeActivityTestCaseBase<ChromeActivity> {
-
-    public BookmarkTest() {
-        super(ChromeActivity.class);
-    }
+public class BookmarkTest {
+    @Rule
+    public ChromeActivityTestRule<ChromeActivity> mActivityTestRule =
+            new ChromeActivityTestRule<>(ChromeActivity.class);
 
     private static final String TEST_PAGE_URL_GOOGLE = "/chrome/test/data/android/google.html";
     private static final String TEST_PAGE_TITLE_GOOGLE = "The Google";
     private static final String TEST_PAGE_TITLE_GOOGLE2 = "Google";
     private static final String TEST_PAGE_URL_FOO = "/chrome/test/data/android/test.html";
     private static final String TEST_PAGE_TITLE_FOO = "Foo";
 
     private BookmarkModel mBookmarkModel;
     protected RecyclerView mItemsContainer;
     private String mTestPage;
     private String mTestPageFoo;
     private EmbeddedTestServer mTestServer;
 
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        mTestServer = EmbeddedTestServer.createAndStartServer(getInstrumentation().getContext());
+    @Before
+    public void setUp() throws Exception {
+        mActivityTestRule.startMainActivityFromLauncher();
+        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
+            @Override
+            public void run() {
+                mBookmarkModel = new BookmarkModel(
+                        mActivityTestRule.getActivity().getActivityTab().getProfile());
+            }
+        });
+        BookmarkTestUtil.waitForBookmarkModelLoaded();
+        mTestServer = EmbeddedTestServer.createAndStartServer(
+                InstrumentationRegistry.getInstrumentation().getContext());
         mTestPage = mTestServer.getURL(TEST_PAGE_URL_GOOGLE);
         mTestPageFoo = mTestServer.getURL(TEST_PAGE_URL_FOO);
     }
 
-    @Override
-    protected void tearDown() throws Exception {
-        mTestServer.stopAndDestroyServer();
-        super.tearDown();
-    }
-
-    @Override
-    public void startMainActivity() throws InterruptedException {
-        startMainActivityFromLauncher();
-        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
-            @Override
-            public void run() {
-                mBookmarkModel = new BookmarkModel(getActivity().getActivityTab().getProfile());
-            }
-        });
-        BookmarkTestUtil.waitForBookmarkModelLoaded();
+    @After
+    public void tearDown() throws Exception {
+        if (mTestServer != null) {
+            mTestServer.stopAndDestroyServer();
+        }
     }
 
     private void openBookmarkManager() throws InterruptedException {
-        if (DeviceFormFactor.isTablet(getActivity())) {
-            loadUrl(UrlConstants.BOOKMARKS_URL);
-            mItemsContainer = (RecyclerView) getActivity().findViewById(R.id.recycler_view);
+        if (DeviceFormFactor.isTablet(mActivityTestRule.getActivity())) {
+            mActivityTestRule.loadUrl(UrlConstants.BOOKMARKS_URL);
+            mItemsContainer =
+                    (RecyclerView) mActivityTestRule.getActivity().findViewById(R.id.recycler_view);
         } else {
             // phone
-            BookmarkActivity activity = ActivityUtils.waitForActivity(getInstrumentation(),
-                    BookmarkActivity.class, new MenuUtils.MenuActivityTrigger(
-                            getInstrumentation(), getActivity(), R.id.all_bookmarks_menu_id));
+            BookmarkActivity activity = ActivityUtils.waitForActivity(
+                    InstrumentationRegistry.getInstrumentation(), BookmarkActivity.class,
+                    new MenuUtils.MenuActivityTrigger(InstrumentationRegistry.getInstrumentation(),
+                            mActivityTestRule.getActivity(), R.id.all_bookmarks_menu_id));
             mItemsContainer = (RecyclerView) activity.findViewById(R.id.recycler_view);
         }
     }
 
     private boolean isItemPresentInBookmarkList(final String expectedTitle) {
         return ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Boolean>() {
             @Override
             public Boolean call() throws Exception {
                 for (int i = 0; i < mItemsContainer.getAdapter().getItemCount(); i++) {
                     BookmarkId item =
                             ((BookmarkItemsAdapter) mItemsContainer.getAdapter()).getItem(i);
                     if (item == null) continue;
 
                     String actualTitle = mBookmarkModel.getBookmarkTitle(item);
                     if (TextUtils.equals(actualTitle, expectedTitle)) {
                         return true;
                     }
                 }
                 return false;
             }
         });
     }
 
+    @Test
     @SmallTest
     public void testAddBookmark() throws InterruptedException {
-        loadUrl(mTestPage);
+        mActivityTestRule.loadUrl(mTestPage);
         // Click star button to bookmark the curent tab.
-        MenuUtils.invokeCustomMenuActionSync(getInstrumentation(), getActivity(),
-                R.id.bookmark_this_page_id);
+        MenuUtils.invokeCustomMenuActionSync(InstrumentationRegistry.getInstrumentation(),
+                mActivityTestRule.getActivity(), R.id.bookmark_this_page_id);
         // All actions with BookmarkModel needs to run on UI thread.
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
-                long bookmarkIdLong = getActivity().getActivityTab().getUserBookmarkId();
+                long bookmarkIdLong =
+                        mActivityTestRule.getActivity().getActivityTab().getUserBookmarkId();
                 BookmarkId id = new BookmarkId(bookmarkIdLong, BookmarkType.NORMAL);
-                assertTrue("The test page is not added as bookmark: ",
+                Assert.assertTrue("The test page is not added as bookmark: ",
                         mBookmarkModel.doesBookmarkExist(id));
                 BookmarkItem item = mBookmarkModel.getBookmarkById(id);
-                assertEquals(mBookmarkModel.getDefaultFolder(), item.getParentId());
-                assertEquals(mTestPage, item.getUrl());
-                assertEquals(TEST_PAGE_TITLE_GOOGLE, item.getTitle());
+                Assert.assertEquals(mBookmarkModel.getDefaultFolder(), item.getParentId());
+                Assert.assertEquals(mTestPage, item.getUrl());
+                Assert.assertEquals(TEST_PAGE_TITLE_GOOGLE, item.getTitle());
             }
         });
     }
 
+    @Test
     @SmallTest
     public void testOpenBookmark() throws InterruptedException, ExecutionException {
         addBookmark(TEST_PAGE_TITLE_GOOGLE, mTestPage);
         openBookmarkManager();
-        assertTrue("Grid view does not contain added bookmark: ",
+        Assert.assertTrue("Grid view does not contain added bookmark: ",
                 isItemPresentInBookmarkList(TEST_PAGE_TITLE_GOOGLE));
         final View tile = getViewWithText(mItemsContainer, TEST_PAGE_TITLE_GOOGLE);
-        ChromeTabUtils.waitForTabPageLoaded(getActivity().getActivityTab(), new Runnable() {
-            @Override
-            public void run() {
-                TouchCommon.singleClickView(tile);
-            }
-        });
-        assertEquals(TEST_PAGE_TITLE_GOOGLE, getActivity().getActivityTab().getTitle());
+        ChromeTabUtils.waitForTabPageLoaded(
+                mActivityTestRule.getActivity().getActivityTab(), new Runnable() {
+                    @Override
+                    public void run() {
+                        TouchCommon.singleClickView(tile);
+                    }
+                });
+        Assert.assertEquals(TEST_PAGE_TITLE_GOOGLE,
+                mActivityTestRule.getActivity().getActivityTab().getTitle());
     }
 
+    @Test
     @SmallTest
     public void testUrlComposition() {
         BookmarkId mobileId = mBookmarkModel.getMobileFolderId();
         BookmarkId bookmarkBarId = mBookmarkModel.getDesktopFolderId();
         BookmarkId otherId = mBookmarkModel.getOtherFolderId();
-        assertEquals("chrome-native://bookmarks/folder/" + mobileId,
+        Assert.assertEquals("chrome-native://bookmarks/folder/" + mobileId,
                 BookmarkUIState.createFolderUrl(mobileId).toString());
-        assertEquals("chrome-native://bookmarks/folder/" + bookmarkBarId,
+        Assert.assertEquals("chrome-native://bookmarks/folder/" + bookmarkBarId,
                 BookmarkUIState.createFolderUrl(bookmarkBarId).toString());
-        assertEquals("chrome-native://bookmarks/folder/" + otherId,
+        Assert.assertEquals("chrome-native://bookmarks/folder/" + otherId,
                 BookmarkUIState.createFolderUrl(otherId).toString());
     }
 
+    @Test
     @SmallTest
     public void testOpenBookmarkManager() throws InterruptedException {
         openBookmarkManager();
         BookmarkDelegate delegate =
                 ((BookmarkItemsAdapter) mItemsContainer.getAdapter()).getDelegateForTesting();
-        assertEquals(BookmarkUIState.STATE_FOLDER, delegate.getCurrentState());
-        assertEquals("chrome-native://bookmarks/folder/3",
-                BookmarkUtils.getLastUsedUrl(getActivity()));
+        Assert.assertEquals(BookmarkUIState.STATE_FOLDER, delegate.getCurrentState());
+        Assert.assertEquals("chrome-native://bookmarks/folder/3",
+                BookmarkUtils.getLastUsedUrl(mActivityTestRule.getActivity()));
     }
 
+    @Test
     @MediumTest
     public void testTopLevelFolders() throws InterruptedException {
         openBookmarkManager();
         final BookmarkDelegate delegate =
                 ((BookmarkItemsAdapter) mItemsContainer.getAdapter()).getDelegateForTesting();
         final BookmarkActionBar toolbar = ((BookmarkManager) delegate).getToolbarForTests();
 
         // Open the "Mobile bookmarks" folder.
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 delegate.openFolder(mBookmarkModel.getMobileFolderId());
             }
         });
 
-        assertEquals(SelectableListToolbar.NAVIGATION_BUTTON_BACK,
+        Assert.assertEquals(SelectableListToolbar.NAVIGATION_BUTTON_BACK,
                 toolbar.getNavigationButtonForTests());
-        assertFalse(toolbar.getMenu().findItem(R.id.edit_menu_id).isVisible());
+        Assert.assertFalse(toolbar.getMenu().findItem(R.id.edit_menu_id).isVisible());
 
         // Call BookmarkActionBar#onClick() to activate the navigation button.
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 toolbar.onClick(toolbar);
             }
         });
 
         // Check that we are in the root folder.
-        assertEquals("Bookmarks", toolbar.getTitle());
-        assertEquals(SelectableListToolbar.NAVIGATION_BUTTON_NONE,
+        Assert.assertEquals("Bookmarks", toolbar.getTitle());
+        Assert.assertEquals(SelectableListToolbar.NAVIGATION_BUTTON_NONE,
                 toolbar.getNavigationButtonForTests());
-        assertFalse(toolbar.getMenu().findItem(R.id.edit_menu_id).isVisible());
+        Assert.assertFalse(toolbar.getMenu().findItem(R.id.edit_menu_id).isVisible());
     }
 
+    @Test
     @MediumTest
     public void testSearchBookmarks() throws Exception {
         BookmarkPromoHeader.setShouldShowForTests();
         addBookmark(TEST_PAGE_TITLE_GOOGLE, mTestPage);
         addBookmark(TEST_PAGE_TITLE_FOO, mTestPageFoo);
         openBookmarkManager();
 
         BookmarkItemsAdapter adapter = ((BookmarkItemsAdapter) mItemsContainer.getAdapter());
         final BookmarkDelegate delegate = adapter.getDelegateForTesting();
 
-        assertEquals(BookmarkUIState.STATE_FOLDER, delegate.getCurrentState());
+        Assert.assertEquals(BookmarkUIState.STATE_FOLDER, delegate.getCurrentState());
         assertBookmarkItems("Wrong number of items before starting search.", 3, adapter, delegate);
 
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 delegate.openSearchUI();
             }
         });
 
-        assertEquals(BookmarkUIState.STATE_SEARCHING, delegate.getCurrentState());
+        Assert.assertEquals(BookmarkUIState.STATE_SEARCHING, delegate.getCurrentState());
         assertBookmarkItems(
                 "Wrong number of items after showing search UI. The promo should be hidden.", 2,
                 adapter, delegate);
 
         searchBookmarks("Google");
         assertBookmarkItems("Wrong number of items after searching.", 1,
                 mItemsContainer.getAdapter(), delegate);
 
         BookmarkId newBookmark = addBookmark(TEST_PAGE_TITLE_GOOGLE2, mTestPage);
         assertBookmarkItems("Wrong number of items after bookmark added while searching.", 2,
                 mItemsContainer.getAdapter(), delegate);
 
         removeBookmark(newBookmark);
         assertBookmarkItems("Wrong number of items after bookmark removed while searching.", 1,
                 mItemsContainer.getAdapter(), delegate);
 
         searchBookmarks("Non-existent page");
         assertBookmarkItems("Wrong number of items after searching for non-existent item.", 0,
                 mItemsContainer.getAdapter(), delegate);
 
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 delegate.closeSearchUI();
             }
         });
         assertBookmarkItems("Wrong number of items after closing search UI.", 3,
                 mItemsContainer.getAdapter(), delegate);
-        assertEquals(BookmarkUIState.STATE_FOLDER, delegate.getCurrentState());
+        Assert.assertEquals(BookmarkUIState.STATE_FOLDER, delegate.getCurrentState());
     }
 
     /**
      * Asserts the number of bookmark items being shown, taking large device deviders into account.
      *
      * @param errorMessage              Error message to display in case the assert fails.
      * @param exepectedOnRegularDevice  Expected count of items on small tablets.
      * @param adapter                   Adapter to retrieve the bookmark item count from.
      * @param delegate                  BookmarkDelegate to check the bookmark UI state.
      */
     private void assertBookmarkItems(final String errorMessage, final int exepectedOnRegularDevice,
             final Adapter adapter, final BookmarkDelegate delegate) {
         // TODO(twellington): Remove after bookmarks redesign is complete.
         // The +1 for large devices stems from the divider being added to the state folder for now,
         // which will offset all counts by one.
-        final int expectedCount = DeviceFormFactor.isLargeTablet(getActivity())
+        final int expectedCount = DeviceFormFactor.isLargeTablet(mActivityTestRule.getActivity())
                         && BookmarkUIState.STATE_FOLDER == delegate.getCurrentState()
                 ? exepectedOnRegularDevice + 1
                 : exepectedOnRegularDevice;
-        assertEquals(errorMessage, expectedCount, adapter.getItemCount());
+        Assert.assertEquals(errorMessage, expectedCount, adapter.getItemCount());
     }
 
     /**
      * Returns the View that has the given text.
      *
      * @param viewGroup    The group to which the view belongs.
      * @param expectedText The expected description text.
      * @return The unique view, if one exists. Throws an exception if one doesn't exist.
      */
     private static View getViewWithText(final ViewGroup viewGroup, final String expectedText) {
@@ skipping 36 matching lines @@
 
     private void searchBookmarks(final String query) {
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 ((BookmarkItemsAdapter) mItemsContainer.getAdapter()).search(query);
             }
         });
     }
 }