Convert chrome compositor test's InstrumentationTestCases

chrome/android/javatests/src/org/chromium/chrome/browser/compositor/bottombar/OverlayPanelBaseTest.java

Index: chrome/android/javatests/src/org/chromium/chrome/browser/compositor/bottombar/OverlayPanelBaseTest.java
diff --git a/chrome/android/javatests/src/org/chromium/chrome/browser/compositor/bottombar/OverlayPanelBaseTest.java b/chrome/android/javatests/src/org/chromium/chrome/browser/compositor/bottombar/OverlayPanelBaseTest.java
index 7cd35201f3e539c559e9299f959bf26f1edcd08f..7a4dc19404363f23302a7deefeef47c6854fd546 100644
--- a/chrome/android/javatests/src/org/chromium/chrome/browser/compositor/bottombar/OverlayPanelBaseTest.java
+++ b/chrome/android/javatests/src/org/chromium/chrome/browser/compositor/bottombar/OverlayPanelBaseTest.java
@@ -5,17 +5,26 @@
 package org.chromium.chrome.browser.compositor.bottombar;
 
 import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.annotation.UiThreadTest;
 import android.support.test.filters.SmallTest;
-import android.test.InstrumentationTestCase;
+import android.support.test.rule.UiThreadTestRule;
+
+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.test.util.Feature;
 import org.chromium.chrome.browser.compositor.bottombar.OverlayPanel.PanelState;
+import org.chromium.chrome.test.ChromeJUnit4ClassRunner;
 
 /**
  * Tests logic in the OverlayPanelBase.
  */
-public class OverlayPanelBaseTest extends InstrumentationTestCase {
-
+@RunWith(ChromeJUnit4ClassRunner.class)
+public class OverlayPanelBaseTest {
     private static final float UPWARD_VELOCITY = -1.0f;
     private static final float DOWNWARD_VELOCITY = 1.0f;
 
@@ -23,6 +32,9 @@ public class OverlayPanelBaseTest extends InstrumentationTestCase {
     private static final float MOCK_EXPANDED_HEIGHT = 400.0f;
     private static final float MOCK_MAXIMIZED_HEIGHT = 600.0f;
 
+    @Rule
+    public UiThreadTestRule mRule = new UiThreadTestRule();

[Ted C, 2017/03/22 16:32:51]

I'm confused why you need to add this here.  I thought this was only as a
replacement for android.test.UiThreadTest.

This also changes @Before and @After to run on the UI thread where previously it
was running on the instrumentation thread.

This seems like a behavioral change and I'm surprised to see that.

[the real yoland, 2017/03/22 17:43:33]

Currently, to make the @UiThreadTest annotation effective, UiThreadTestRule must
be added in the test suite. But UiThreadTestRule without the @UiThreadTest
doesn't do anything. UiThreadTestRule only makes test method annotated with
@UiThreadTest.

The next version of android test support library will support @UiThreadTest
without UiThreadTestRule, at that time, we can delete these UiThreadTestRules if
they are not used in test class

There is a CL to update this part of documentation:
https://codereview.chromium.org/2749353002

[Ted C, 2017/03/22 17:54:35]

Yes, but why did we need to add UiThreadTest at all?

Did these tests fail?  What exactly failed?  Looking at the documentation
you linked, I suspect there was some dependency on a handler/looper that
was previously on the instrumentation thread.  What was that?

[the real yoland, 2017/03/22 18:30:06]

Yes it does fail, it is usually because test would run something that requires
handler (e.g. create a new Activity).

Unlike Junit3's instrumentation runner, JUnit4 test runner prevent handler from
created. So the solution would be running
test on UiThread

In this specific case, it fails because in setUp stage, when creating
MockOverlayPanel, a GestureEventFilter is created, which require a new handler
(https://cs.chromium.org/chromium/src/chrome/android/java/src/org/chromium/chr...)

Since during real usage case, GestureEventFilter is probably created on Ui
thread. In test, it should be on ui thread as well.

+
     MockOverlayPanel mNoExpandPanel;
     MockOverlayPanel mExpandPanel;
 
@@ -80,13 +92,13 @@ public class OverlayPanelBaseTest extends InstrumentationTestCase {
         }
     }
 
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
+    @Before
+    public void setUp() throws Exception {
         OverlayPanelManager panelManager = new OverlayPanelManager();
-        mExpandPanel = new MockOverlayPanel(getInstrumentation().getTargetContext(), panelManager);
-        mNoExpandPanel = new NoExpandMockOverlayPanel(getInstrumentation().getTargetContext(),
-                panelManager);
+        mExpandPanel = new MockOverlayPanel(
+                InstrumentationRegistry.getInstrumentation().getTargetContext(), panelManager);
+        mNoExpandPanel = new NoExpandMockOverlayPanel(
+                InstrumentationRegistry.getInstrumentation().getTargetContext(), panelManager);
     }
 
     // Start OverlayPanelBase test suite.
@@ -95,8 +107,10 @@ public class OverlayPanelBaseTest extends InstrumentationTestCase {
      * Tests that a panel with the EXPANDED state disabled and a lower movement threshold will move
      * to the correct state based on current position and swipe velocity.
      */
+    @Test
     @SmallTest
     @Feature({"OverlayPanelBase"})
+    @UiThreadTest
     public void testNonExpandingPanelMovesToCorrectState() {
         final float threshold = mNoExpandPanel.getThresholdToNextState();
         final float height = MOCK_MAXIMIZED_HEIGHT - MOCK_PEEKED_HEIGHT;
@@ -106,30 +120,32 @@ public class OverlayPanelBaseTest extends InstrumentationTestCase {
         // Between PEEKING and MAXIMIZED past the threshold in the up direction.
         PanelState nextState = mNoExpandPanel.findNearestPanelStateFromHeight(
                 peekToMaxBound + 1, UPWARD_VELOCITY);
-        assertTrue(nextState == PanelState.MAXIMIZED);
+        Assert.assertTrue(nextState == PanelState.MAXIMIZED);
 
         // Between PEEKING and MAXIMIZED before the threshold in the up direction.
         nextState = mNoExpandPanel.findNearestPanelStateFromHeight(
                 peekToMaxBound - 1, UPWARD_VELOCITY);
-        assertTrue(nextState == PanelState.PEEKED);
+        Assert.assertTrue(nextState == PanelState.PEEKED);
 
         // Between PEEKING and MAXIMIZED before the threshold in the down direction.
         nextState = mNoExpandPanel.findNearestPanelStateFromHeight(
                 maxToPeekBound + 1, DOWNWARD_VELOCITY);
-        assertTrue(nextState == PanelState.MAXIMIZED);
+        Assert.assertTrue(nextState == PanelState.MAXIMIZED);
 
         // Between PEEKING and MAXIMIZED past the threshold in the down direction.
         nextState = mNoExpandPanel.findNearestPanelStateFromHeight(
                 maxToPeekBound - 1, DOWNWARD_VELOCITY);
-        assertTrue(nextState == PanelState.PEEKED);
+        Assert.assertTrue(nextState == PanelState.PEEKED);
     }
 
     /**
      * Tests that a panel will move to the correct state based on current position and swipe
      * velocity.
      */
+    @Test
     @SmallTest
     @Feature({"OverlayPanelBase"})
+    @UiThreadTest
     public void testExpandingPanelMovesToCorrectState() {
         final float threshold = mExpandPanel.getThresholdToNextState();
         final float peekToExpHeight = MOCK_EXPANDED_HEIGHT - MOCK_PEEKED_HEIGHT;
@@ -150,87 +166,91 @@ public class OverlayPanelBaseTest extends InstrumentationTestCase {
         // Between PEEKING and EXPANDED past the threshold in the up direction.
         PanelState nextState = mExpandPanel.findNearestPanelStateFromHeight(
                 peekToExpBound + 1, UPWARD_VELOCITY);
-        assertTrue(nextState == PanelState.EXPANDED);
+        Assert.assertTrue(nextState == PanelState.EXPANDED);
 
         // Between PEEKING and EXPANDED before the threshold in the up direction.
         nextState = mExpandPanel.findNearestPanelStateFromHeight(
                 peekToExpBound - 1, UPWARD_VELOCITY);
-        assertTrue(nextState == PanelState.PEEKED);
+        Assert.assertTrue(nextState == PanelState.PEEKED);
 
         // Between PEEKING and EXPANDED before the threshold in the down direction.
         nextState = mExpandPanel.findNearestPanelStateFromHeight(
                 expToPeekBound + 1, DOWNWARD_VELOCITY);
-        assertTrue(nextState == PanelState.EXPANDED);
+        Assert.assertTrue(nextState == PanelState.EXPANDED);
 
         // Between PEEKING and EXPANDED past the threshold in the down direction.
         nextState = mExpandPanel.findNearestPanelStateFromHeight(
                 expToPeekBound - 1, DOWNWARD_VELOCITY);
-        assertTrue(nextState == PanelState.PEEKED);
+        Assert.assertTrue(nextState == PanelState.PEEKED);
 
         // Between EXPANDED and MAXIMIZED past the threshold in the up direction.
         nextState = mExpandPanel.findNearestPanelStateFromHeight(
                 expToMaxBound + 1, UPWARD_VELOCITY);
-        assertTrue(nextState == PanelState.MAXIMIZED);
+        Assert.assertTrue(nextState == PanelState.MAXIMIZED);
 
         // Between EXPANDED and MAXIMIZED before the threshold in the up direction.
         nextState = mExpandPanel.findNearestPanelStateFromHeight(
                 expToMaxBound - 1, UPWARD_VELOCITY);
-        assertTrue(nextState == PanelState.EXPANDED);
+        Assert.assertTrue(nextState == PanelState.EXPANDED);
 
         // Between EXPANDED and MAXIMIZED past the threshold in the down direction.
         nextState = mExpandPanel.findNearestPanelStateFromHeight(
                 maxToExpBound - 1, DOWNWARD_VELOCITY);
-        assertTrue(nextState == PanelState.EXPANDED);
+        Assert.assertTrue(nextState == PanelState.EXPANDED);
 
         // Between EXPANDED and MAXIMIZED before the threshold in the down direction.
         nextState = mExpandPanel.findNearestPanelStateFromHeight(
                 maxToExpBound + 1, DOWNWARD_VELOCITY);
-        assertTrue(nextState == PanelState.MAXIMIZED);
+        Assert.assertTrue(nextState == PanelState.MAXIMIZED);
     }
 
     /**
      * Tests that a panel will be closed if the desired height is negative.
      */
+    @Test
     @SmallTest
     @Feature({"OverlayPanelBase"})
+    @UiThreadTest
     public void testNegativeHeightClosesPanel() {
         final float belowPeek = MOCK_PEEKED_HEIGHT - 1000;
 
         PanelState nextState =
                 mExpandPanel.findNearestPanelStateFromHeight(belowPeek, DOWNWARD_VELOCITY);
-        assertTrue(nextState == PanelState.CLOSED);
+        Assert.assertTrue(nextState == PanelState.CLOSED);
 
         nextState = mNoExpandPanel.findNearestPanelStateFromHeight(belowPeek, DOWNWARD_VELOCITY);
-        assertTrue(nextState == PanelState.CLOSED);
+        Assert.assertTrue(nextState == PanelState.CLOSED);
 
         // Make sure nothing bad happens if velocity is upward (this should never happen).
         nextState = mExpandPanel.findNearestPanelStateFromHeight(belowPeek, UPWARD_VELOCITY);
-        assertTrue(nextState == PanelState.CLOSED);
+        Assert.assertTrue(nextState == PanelState.CLOSED);
 
         nextState = mNoExpandPanel.findNearestPanelStateFromHeight(belowPeek, UPWARD_VELOCITY);
-        assertTrue(nextState == PanelState.CLOSED);
+        Assert.assertTrue(nextState == PanelState.CLOSED);
     }
 
     /**
      * Tests that a panel is only maximized when desired height is far above the max.
      */
+    @Test
     @SmallTest
     @Feature({"OverlayPanelBase"})
+    @UiThreadTest
     public void testLargeDesiredHeightIsMaximized() {
         final float aboveMax = MOCK_MAXIMIZED_HEIGHT + 1000;
 
         PanelState nextState =
                 mExpandPanel.findNearestPanelStateFromHeight(aboveMax, UPWARD_VELOCITY);
-        assertTrue(nextState == PanelState.MAXIMIZED);
+        Assert.assertTrue(nextState == PanelState.MAXIMIZED);
 
         nextState = mNoExpandPanel.findNearestPanelStateFromHeight(aboveMax, UPWARD_VELOCITY);
-        assertTrue(nextState == PanelState.MAXIMIZED);
+        Assert.assertTrue(nextState == PanelState.MAXIMIZED);
 
         // Make sure nothing bad happens if velocity is downward (this should never happen).
         nextState = mExpandPanel.findNearestPanelStateFromHeight(aboveMax, DOWNWARD_VELOCITY);
-        assertTrue(nextState == PanelState.MAXIMIZED);
+        Assert.assertTrue(nextState == PanelState.MAXIMIZED);
 
         nextState = mNoExpandPanel.findNearestPanelStateFromHeight(aboveMax, DOWNWARD_VELOCITY);
-        assertTrue(nextState == PanelState.MAXIMIZED);
+        Assert.assertTrue(nextState == PanelState.MAXIMIZED);
     }
 }