[Android] Update all Robolectric tests to Robolectric 3.0

content/public/android/junit/src/org/chromium/content/browser/BindingManagerImplTest.java

 // Copyright 2014 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.content.browser;
 
 import static android.content.ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL;
 import static android.content.ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW;
 import static android.content.ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE;
 
 import android.app.Activity;
 import android.app.Application;
 import android.os.Bundle;
 import android.util.Pair;
 
 import org.chromium.base.test.util.Feature;
 import org.chromium.content.common.IChildProcessCallback;
 import org.chromium.content.common.IChildProcessService;
 import org.chromium.testing.local.LocalRobolectricTestRunner;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.Robolectric;
 import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowLooper;
 
 import java.util.ArrayList;
 
 /**
  * Unit tests for BindingManagerImpl. The tests run agains mock ChildProcessConnection
  * implementation, thus testing only the BindingManagerImpl itself.
  *
  * Default property of being low-end device is overriden, so that both low-end and high-end policies
  * are tested.
  */
@@ skipping 235 matching lines @@
         Assert.assertTrue(connection.isInitialBindingBound());
 
         // Remove the strong binding, verify that the strong binding is not removed
         // immediately.
         manager.setInForeground(connection.getPid(), false);
         Assert.assertTrue(connection.isStrongBindingBound());
         Assert.assertTrue(connection.isInitialBindingBound());
 
         // Wait until the posted unbinding tasks get executed and verify that the strong binding was
         // removed while the initial binding is not affected.
-        Robolectric.runUiThreadTasksIncludingDelayedTasks();
+        ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
         Assert.assertFalse(connection.isStrongBindingBound());
         Assert.assertTrue(connection.isInitialBindingBound());
     }
 
     /**
      * Verifies the strong binding removal policies with moderate binding management, where the
      * moderate binding should be bound.
      */
     @Test
     @Feature({"ProcessManagement"})
@@ skipping 16 matching lines @@
 
         // Remove the strong binding, verify that the strong binding is not removed
         // immediately.
         manager.setInForeground(connection.getPid(), false);
         Assert.assertTrue(connection.isStrongBindingBound());
         Assert.assertTrue(connection.isInitialBindingBound());
         Assert.assertFalse(connection.isModerateBindingBound());
 
         // Wait until the posted unbinding tasks get executed and verify that the strong binding was
         // removed while the initial binding is not affected, and the moderate binding is bound.
-        Robolectric.runUiThreadTasksIncludingDelayedTasks();
+        ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
         Assert.assertFalse(connection.isStrongBindingBound());
         Assert.assertTrue(connection.isInitialBindingBound());
         Assert.assertTrue(connection.isModerateBindingBound());
     }
 
     /**
      * Verifies that the initial binding is removed after determinedVisibility() is called.
      */
     @Test
     @Feature({"ProcessManagement"})
@@ skipping 36 matching lines @@
             // Add a connection to the manager.
             MockChildProcessConnection connection = new MockChildProcessConnection(1);
             manager.addNewConnection(connection.getPid(), connection);
 
             // Initial binding is an oom binding.
             Assert.assertTrue(message, manager.isOomProtected(connection.getPid()));
 
             // After initial binding is removed, the connection is no longer oom protected.
             manager.setInForeground(connection.getPid(), false);
             manager.determinedVisibility(connection.getPid());
-            Robolectric.runUiThreadTasksIncludingDelayedTasks();
+            ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
             Assert.assertFalse(message, manager.isOomProtected(connection.getPid()));
 
             // Add a strong binding, restoring the oom protection.
             manager.setInForeground(connection.getPid(), true);
             Assert.assertTrue(message, manager.isOomProtected(connection.getPid()));
 
             // Simulate a process crash - clear a connection in binding manager and remove the
             // bindings.
             Assert.assertFalse(manager.isConnectionCleared(connection.getPid()));
             manager.clearConnection(connection.getPid());
@@ skipping 36 matching lines @@
             manager.addNewConnection(secondConnection.getPid(), secondConnection);
             manager.setInForeground(secondConnection.getPid(), true);
             manager.setInForeground(secondConnection.getPid(), false);
 
             // Add third connection, do not bind it.
             MockChildProcessConnection thirdConnection = new MockChildProcessConnection(3);
             manager.addNewConnection(thirdConnection.getPid(), thirdConnection);
             manager.setInForeground(thirdConnection.getPid(), false);
 
             // Sanity check: verify that no connection has a strong binding.
-            Robolectric.runUiThreadTasksIncludingDelayedTasks();
+            ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
             Assert.assertFalse(message, firstConnection.isStrongBindingBound());
             Assert.assertFalse(message, secondConnection.isStrongBindingBound());
             Assert.assertFalse(message, thirdConnection.isStrongBindingBound());
 
             // Call onSentToBackground() and verify that a strong binding was added for the second
             // connection:
             // - not the first one, because it was bound earlier than the second
             // - not the thirs one, because it was never bound at all
             manager.onSentToBackground();
             Assert.assertFalse(message, firstConnection.isStrongBindingBound());
             Assert.assertTrue(message, secondConnection.isStrongBindingBound());
             Assert.assertFalse(message, thirdConnection.isStrongBindingBound());
 
             // Call onBroughtToForeground() and verify that the strong binding was removed.
             manager.onBroughtToForeground();
-            Robolectric.runUiThreadTasksIncludingDelayedTasks();
+            ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
             Assert.assertFalse(message, firstConnection.isStrongBindingBound());
             Assert.assertFalse(message, secondConnection.isStrongBindingBound());
             Assert.assertFalse(message, thirdConnection.isStrongBindingBound());
         }
     }
 
     /**
      * Verifies that onSentToBackground() drops all the moderate bindings after some delay, and
      * onBroughtToForeground() doesn't recover them.
      */
     @Test
     @Feature({"ProcessManagement"})
     public void testModerateBindingDropOnBackground() {
         // This test applies only to the moderate-binding manager.
         final BindingManagerImpl manager = mModerateBindingManager;
 
         MockChildProcessConnection[] connections = new MockChildProcessConnection[3];
         for (int i = 0; i < connections.length; i++) {
             connections[i] = new MockChildProcessConnection(i + 1);
             manager.addNewConnection(connections[i].getPid(), connections[i]);
         }
 
         // Verify that each connection has a moderate binding after binding and releasing a strong
         // binding.
         for (MockChildProcessConnection connection : connections) {
             manager.setInForeground(connection.getPid(), true);
             manager.setInForeground(connection.getPid(), false);
-            Robolectric.runUiThreadTasksIncludingDelayedTasks();
+            ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
             Assert.assertTrue(connection.isModerateBindingBound());
         }
 
         // Exclude lastInForeground because it will be kept in foreground when onSentToBackground()
         // is called as |mLastInForeground|.
         MockChildProcessConnection lastInForeground = new MockChildProcessConnection(0);
         manager.addNewConnection(lastInForeground.getPid(), lastInForeground);
         manager.setInForeground(lastInForeground.getPid(), true);
         manager.setInForeground(lastInForeground.getPid(), false);
-        Robolectric.runUiThreadTasksIncludingDelayedTasks();
+        ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
 
         // Verify that leaving the application for a short time doesn't clear the moderate bindings.
         manager.onSentToBackground();
         for (MockChildProcessConnection connection : connections) {
             Assert.assertTrue(connection.isModerateBindingBound());
         }
         Assert.assertTrue(lastInForeground.isStrongBindingBound());
         Assert.assertFalse(lastInForeground.isModerateBindingBound());
         manager.onBroughtToForeground();
-        Robolectric.runUiThreadTasksIncludingDelayedTasks();
+        ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
         for (MockChildProcessConnection connection : connections) {
             Assert.assertTrue(connection.isModerateBindingBound());
         }
 
         // Call onSentToBackground() and verify that all the moderate bindings drop after some
         // delay.
         manager.onSentToBackground();
         for (MockChildProcessConnection connection : connections) {
             Assert.assertTrue(connection.isModerateBindingBound());
         }
         Assert.assertTrue(lastInForeground.isStrongBindingBound());
         Assert.assertFalse(lastInForeground.isModerateBindingBound());
-        Robolectric.runUiThreadTasksIncludingDelayedTasks();
+        ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
         for (MockChildProcessConnection connection : connections) {
             Assert.assertFalse(connection.isModerateBindingBound());
         }
 
         // Call onBroughtToForeground() and verify that the previous moderate bindings aren't
         // recovered.
         manager.onBroughtToForeground();
         for (MockChildProcessConnection connection : connections) {
             Assert.assertFalse(connection.isModerateBindingBound());
         }
@@ skipping 12 matching lines @@
         for (int i = 0; i < connections.length; i++) {
             connections[i] = new MockChildProcessConnection(i + 1);
             manager.addNewConnection(connections[i].getPid(), connections[i]);
         }
 
         // Verify that each connection has a moderate binding after binding and releasing a strong
         // binding.
         for (MockChildProcessConnection connection : connections) {
             manager.setInForeground(connection.getPid(), true);
             manager.setInForeground(connection.getPid(), false);
-            Robolectric.runUiThreadTasksIncludingDelayedTasks();
+            ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
             Assert.assertTrue(connection.isModerateBindingBound());
         }
 
         // Call onLowMemory() and verify that all the moderate bindings drop.
         app.onLowMemory();
         for (MockChildProcessConnection connection : connections) {
             Assert.assertFalse(connection.isModerateBindingBound());
         }
     }
 
@@ skipping 21 matching lines @@
             manager.addNewConnection(connections[i].getPid(), connections[i]);
         }
 
         for (Pair<Integer, Integer> pair : levelAndExpectedVictimCountList) {
             String message = "Failed for the level=" + pair.first;
             // Verify that each connection has a moderate binding after binding and releasing a
             // strong binding.
             for (MockChildProcessConnection connection : connections) {
                 manager.setInForeground(connection.getPid(), true);
                 manager.setInForeground(connection.getPid(), false);
-                Robolectric.runUiThreadTasksIncludingDelayedTasks();
+                ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
                 Assert.assertTrue(message, connection.isModerateBindingBound());
             }
 
             app.onTrimMemory(pair.first);
             // Verify that some of moderate bindings drop.
             for (int i = 0; i < connections.length; i++) {
                 Assert.assertEquals(
                         message, i >= pair.second, connections[i].isModerateBindingBound());
             }
         }
@@ skipping 12 matching lines @@
         for (int i = 0; i < connections.length; i++) {
             connections[i] = new MockChildProcessConnection(i + 1);
             manager.addNewConnection(connections[i].getPid(), connections[i]);
         }
 
         // Verify that each connection has a moderate binding after binding and releasing a strong
         // binding.
         for (MockChildProcessConnection connection : connections) {
             manager.setInForeground(connection.getPid(), true);
             manager.setInForeground(connection.getPid(), false);
-            Robolectric.runUiThreadTasksIncludingDelayedTasks();
+            ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
             Assert.assertTrue(connection.isModerateBindingBound());
         }
 
         // Call BindingManager.releaseAllModerateBindings() and verify that all the moderate
         // bindings drop.
         manager.releaseAllModerateBindings();
         for (MockChildProcessConnection connection : connections) {
             Assert.assertFalse(connection.isModerateBindingBound());
         }
     }
@@ skipping 75 matching lines @@
         BindingManagerImpl manager = BindingManagerImpl.createBindingManagerForTesting(false);
         manager.startModerateBindingManagement(mActivity, 4, true);
 
         MockChildProcessConnection connection = new MockChildProcessConnection(0);
         manager.addNewConnection(connection.getPid(), connection);
         manager.setInForeground(connection.getPid(), false);
         manager.determinedVisibility(connection.getPid());
         Assert.assertTrue(connection.isModerateBindingBound());
 
         manager.onSentToBackground();
-        Robolectric.runUiThreadTasksIncludingDelayedTasks();
+        ShadowLooper.runUiThreadTasksIncludingDelayedTasks();
         Assert.assertFalse(connection.isModerateBindingBound());
 
         // Bringing Chrome to the foreground should not re-add the moderate bindings.
         manager.onBroughtToForeground();
         Assert.assertFalse(connection.isModerateBindingBound());
     }
 }