Excise PowerMock and reenable like a bunch of ignored tests.

Co-authored-by: Rashad Sookram <rashad@signal.org>
2026-02-27 13:13:43 +00:00 · 2022-03-10 12:31:48 -04:00
parent 1f82ceecc6
commit 711148423d
25 changed files with 342 additions and 631 deletions
--- a/app/src/test/java/org/thoughtcrime/securesms/BaseUnitTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/BaseUnitTest.java
@@ -8,63 +8,75 @@ import android.preference.PreferenceManager;
 import android.text.TextUtils;

 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockedConstruction;
+import org.mockito.MockedStatic;
 import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.mockito.stubbing.Answer;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
 import org.signal.core.util.logging.Log;

-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyBoolean;
-import static org.mockito.Matchers.anyFloat;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.anyLong;
-import static org.mockito.Matchers.anyString;
-import static org.powermock.api.mockito.PowerMockito.mock;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
-import static org.powermock.api.mockito.PowerMockito.when;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyFloat;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;

-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ Log.class, Handler.class, Looper.class, TextUtils.class, PreferenceManager.class })
 public abstract class BaseUnitTest {

+  @Rule
+  public MockitoRule rule = MockitoJUnit.rule();
+
+  @Mock
+  private MockedStatic<Looper> looperMockedStatic;
+
+  @Mock
+  private MockedStatic<Log> logMockedStatic;
+
+  @Mock
+  private MockedStatic<Handler> handlerMockedStatic;
+
+  @Mock
+  private MockedStatic<TextUtils> textUtilsMockedStatic;
+
+  @Mock
+  private MockedStatic<PreferenceManager> preferenceManagerMockedStatic;
+
+  @Mock
+  private MockedConstruction<Handler> handlerMockedConstruction;
+
  protected Context           context           = mock(Context.class);
  protected SharedPreferences sharedPreferences = mock(SharedPreferences.class);

  @Before
  public void setUp() throws Exception {
-    mockStatic(Looper.class);
-    mockStatic(Log.class);
-    mockStatic(Handler.class);
-    mockStatic(TextUtils.class);
-    mockStatic(PreferenceManager.class);
-
    when(PreferenceManager.getDefaultSharedPreferences(any(Context.class))).thenReturn(sharedPreferences);
    when(Looper.getMainLooper()).thenReturn(null);
-    PowerMockito.whenNew(Handler.class).withAnyArguments().thenReturn(null);

-    Answer<?> logAnswer = new Answer<Void>() {
-      @Override public Void answer(InvocationOnMock invocation) throws Throwable {
-        final String tag = (String)invocation.getArguments()[0];
-        final String msg = (String)invocation.getArguments()[1];
-        System.out.println(invocation.getMethod().getName().toUpperCase() + "/[" + tag + "] " + msg);
-        return null;
-      }
+    Answer<?> logAnswer = (Answer<Void>) invocation -> {
+      final String tag = (String)invocation.getArguments()[0];
+      final String msg = (String)invocation.getArguments()[1];
+      System.out.println(invocation.getMethod().getName().toUpperCase() + "/[" + tag + "] " + msg);
+      return null;
    };
-    PowerMockito.doAnswer(logAnswer).when(Log.class, "d", anyString(), anyString());
-    PowerMockito.doAnswer(logAnswer).when(Log.class, "i", anyString(), anyString());
-    PowerMockito.doAnswer(logAnswer).when(Log.class, "w", anyString(), anyString());
-    PowerMockito.doAnswer(logAnswer).when(Log.class, "e", anyString(), anyString());

-    PowerMockito.doAnswer(new Answer<Boolean>() {
-      @Override
-      public Boolean answer(InvocationOnMock invocation) throws Throwable {
-        final String s = (String)invocation.getArguments()[0];
-        return s == null || s.length() == 0;
-      }
-    }).when(TextUtils.class, "isEmpty", anyString());
+    logMockedStatic.when(() -> Log.d(anyString(), anyString())).thenAnswer(logAnswer);
+    logMockedStatic.when(() -> Log.i(anyString(), anyString())).thenAnswer(logAnswer);
+    logMockedStatic.when(() -> Log.w(anyString(), anyString())).thenAnswer(logAnswer);
+    logMockedStatic.when(() -> Log.e(anyString(), anyString())).thenAnswer(logAnswer);
+
+    Answer<Boolean> isEmptyAnswer = invocation -> {
+      final String s = (String)invocation.getArguments()[0];
+      return s == null || s.length() == 0;
+    };
+
+    textUtilsMockedStatic.when(() -> TextUtils.isEmpty(anyString())).thenAnswer(isEmptyAnswer);

    when(sharedPreferences.getString(anyString(), anyString())).thenReturn("");
    when(sharedPreferences.getLong(anyString(), anyLong())).thenReturn(0L);
--- a/app/src/test/java/org/thoughtcrime/securesms/components/emoji/EmojiUtilTest_isEmoji.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/components/emoji/EmojiUtilTest_isEmoji.java
@@ -8,10 +8,11 @@ import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.rule.PowerMockRule;
+import org.mockito.Mock;
+import org.mockito.MockedConstruction;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.robolectric.ParameterizedRobolectricTestRunner;
 import org.robolectric.annotation.Config;
 import org.thoughtcrime.securesms.crypto.AttachmentSecretProvider;
@@ -25,15 +26,15 @@ import java.util.Collection;

 import static org.junit.Assert.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;

-@Ignore("PowerMock failing")
@RunWith(ParameterizedRobolectricTestRunner.class)
@Config(manifest = Config.NONE, application = Application.class)
-@PowerMockIgnore({"org.mockito.*", "org.robolectric.*", "android.*", "androidx.*", "org.powermock.*" })
-@PrepareForTest({ApplicationDependencies.class, AttachmentSecretProvider.class, SignalStore.class, InternalValues.class})
 public class EmojiUtilTest_isEmoji {

-  public @Rule PowerMockRule rule = new PowerMockRule();
+  @Rule
+  public MockitoRule rule = MockitoJUnit.rule();

  private final String  input;
  private final boolean output;
@@ -60,6 +61,17 @@ public class EmojiUtilTest_isEmoji {
    });
  }

+  @Mock
+  private MockedStatic<ApplicationDependencies> applicationDependenciesMockedStatic;
+
+  @Mock
+  private MockedStatic<AttachmentSecretProvider> attachmentSecretProviderMockedStatic;
+
+  @Mock
+  private MockedStatic<SignalStore> signalStoreMockedStatic;
+
+  @Mock
+  private MockedConstruction<SignalStore> signalStoreMockedConstruction;

  public EmojiUtilTest_isEmoji(String input, boolean output) {
    this.input  = input;
@@ -70,13 +82,9 @@ public class EmojiUtilTest_isEmoji {
  public void isEmoji() throws Exception {
    Application application = ApplicationProvider.getApplicationContext();

-    PowerMockito.mockStatic(ApplicationDependencies.class);
-    PowerMockito.when(ApplicationDependencies.getApplication()).thenReturn(application);
-    PowerMockito.mockStatic(AttachmentSecretProvider.class);
-    PowerMockito.when(AttachmentSecretProvider.getInstance(any())).thenThrow(RuntimeException.class);
-    PowerMockito.whenNew(SignalStore.class).withAnyArguments().thenReturn(null);
-    PowerMockito.mockStatic(SignalStore.class);
-    PowerMockito.when(SignalStore.internalValues()).thenReturn(PowerMockito.mock(InternalValues.class));
+    when(ApplicationDependencies.getApplication()).thenReturn(application);
+    when(AttachmentSecretProvider.getInstance(any())).thenThrow(RuntimeException.class);
+    when(SignalStore.internalValues()).thenReturn(mock(InternalValues.class));
    EmojiSource.refresh();

    assertEquals(output, EmojiUtil.isEmoji(input));
--- a/app/src/test/java/org/thoughtcrime/securesms/conversationlist/UnarchivedConversationListDataSourceTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/conversationlist/UnarchivedConversationListDataSourceTest.java
@@ -9,9 +9,10 @@ import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.rule.PowerMockRule;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 import org.thoughtcrime.securesms.conversationlist.model.ConversationReader;
@@ -23,22 +24,24 @@ import org.thoughtcrime.securesms.dependencies.ApplicationDependencies;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.anyLong;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
-import static org.powermock.api.mockito.PowerMockito.mock;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
-import static org.powermock.api.mockito.PowerMockito.when;
+import static org.mockito.Mockito.when;

-@Ignore("PowerMock failing")
@RunWith(RobolectricTestRunner.class)
@Config(manifest = Config.NONE, application = Application.class)
-@PowerMockIgnore({ "org.mockito.*", "org.robolectric.*", "android.*", "androidx.*", "org.powermock.*" })
-@PrepareForTest({ ApplicationDependencies.class, SignalDatabase.class, DatabaseObserver.class })
 public class UnarchivedConversationListDataSourceTest {

  @Rule
-  public PowerMockRule rule = new PowerMockRule();
+  public MockitoRule rule = MockitoJUnit.rule();
+
+  @Mock
+  private MockedStatic<ApplicationDependencies> applicationDependenciesMockedStatic;
+
+  @Mock
+  private MockedStatic<SignalDatabase> signalDatabaseMockedStatic;

  private ConversationListDataSource.UnarchivedConversationListDataSource testSubject;

@@ -46,9 +49,6 @@ public class UnarchivedConversationListDataSourceTest {

  @Before
  public void setUp() {
-    mockStatic(ApplicationDependencies.class);
-    mockStatic(SignalDatabase.class);
-
    threadDatabase = mock(ThreadDatabase.class);

    when(SignalDatabase.threads()).thenReturn(threadDatabase);
--- a/app/src/test/java/org/thoughtcrime/securesms/database/CursorRecyclerViewAdapterTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/database/CursorRecyclerViewAdapterTest.java
@@ -13,7 +13,7 @@ import org.junit.Test;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
-import static org.mockito.Matchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;

--- a/app/src/test/java/org/thoughtcrime/securesms/database/model/GroupsV2UpdateMessageProducerTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/database/model/GroupsV2UpdateMessageProducerTest.java
@@ -9,13 +9,15 @@ import androidx.test.core.app.ApplicationProvider;
 import com.annimon.stream.Stream;
 import com.google.common.collect.ImmutableMap;

+import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.rule.PowerMockRule;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 import org.signal.core.util.ThreadUtil;
@@ -24,8 +26,6 @@ import org.signal.storageservice.protos.groups.local.DecryptedGroup;
 import org.signal.storageservice.protos.groups.local.DecryptedGroupChange;
 import org.signal.storageservice.protos.groups.local.DecryptedMember;
 import org.signal.storageservice.protos.groups.local.DecryptedPendingMember;
-import org.thoughtcrime.securesms.testutil.MainThreadUtil;
-import org.whispersystems.signalservice.api.push.ACI;
 import org.whispersystems.signalservice.api.push.ServiceId;
 import org.whispersystems.signalservice.api.util.UuidUtil;

@@ -35,22 +35,21 @@ import java.util.Map;
 import java.util.UUID;
 import java.util.stream.Collectors;

-import static java.util.Collections.emptyList;
-import static java.util.Collections.singletonList;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mockStatic;
 import static org.thoughtcrime.securesms.groups.v2.ChangeBuilder.changeBy;
 import static org.thoughtcrime.securesms.groups.v2.ChangeBuilder.changeByUnknown;
 import static org.thoughtcrime.securesms.util.StringUtil.isolateBidi;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;

@RunWith(RobolectricTestRunner.class)
@Config(manifest = Config.NONE, application = Application.class)
-@PowerMockIgnore({ "org.mockito.*", "org.robolectric.*", "android.*", "androidx.*" })
-@PrepareForTest(ThreadUtil.class)
 public final class GroupsV2UpdateMessageProducerTest {

  private UUID you;
@@ -60,7 +59,10 @@ public final class GroupsV2UpdateMessageProducerTest {
  private GroupsV2UpdateMessageProducer producer;

  @Rule
-  public PowerMockRule powerMockRule = new PowerMockRule();
+  public MockitoRule rule = MockitoJUnit.rule();
+
+  @Mock
+  public MockedStatic<ThreadUtil> threadUtilMockedStatic;

  @Before
  public void setup() {
@@ -69,6 +71,9 @@ public final class GroupsV2UpdateMessageProducerTest {
    bob   = UUID.randomUUID();
    GroupsV2UpdateMessageProducer.DescribeMemberStrategy describeMember = createDescriber(ImmutableMap.of(alice, "Alice", bob, "Bob"));
    producer = new GroupsV2UpdateMessageProducer(ApplicationProvider.getApplicationContext(), describeMember, you);
+
+    threadUtilMockedStatic.when(ThreadUtil::assertMainThread).thenCallRealMethod();
+    threadUtilMockedStatic.when(ThreadUtil::assertNotMainThread).thenCallRealMethod();
  }

  @Test
@@ -1332,7 +1337,7 @@ public final class GroupsV2UpdateMessageProducerTest {
  private @NonNull List<String> describeChange(@Nullable DecryptedGroup previousGroupState,
                                               @NonNull DecryptedGroupChange change)
  {
-    MainThreadUtil.setMainThread(false);
+    threadUtilMockedStatic.when(ThreadUtil::isMainThread).thenReturn(false);
    return Stream.of(producer.describeChanges(previousGroupState, change))
                 .map(UpdateDescription::getString)
                 .toList();
@@ -1343,7 +1348,7 @@ public final class GroupsV2UpdateMessageProducerTest {
  }

  private @NonNull String describeNewGroup(@NonNull DecryptedGroup group, @NonNull DecryptedGroupChange groupChange) {
-    MainThreadUtil.setMainThread(false);
+    threadUtilMockedStatic.when(ThreadUtil::isMainThread).thenReturn(false);
    return producer.describeNewGroup(group, groupChange).getString();
  }

--- a/app/src/test/java/org/thoughtcrime/securesms/database/model/UpdateDescriptionTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/database/model/UpdateDescriptionTest.java
@@ -1,12 +1,13 @@
 package org.thoughtcrime.securesms.database.model;

 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.signal.core.util.ThreadUtil;
-import org.whispersystems.signalservice.api.push.ACI;
 import org.whispersystems.signalservice.api.push.ServiceId;

 import java.util.Arrays;
@@ -18,15 +19,20 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
-import static org.thoughtcrime.securesms.testutil.MainThreadUtil.setMainThread;

-@RunWith(PowerMockRunner.class)
-@PrepareForTest(ThreadUtil.class)
 public final class UpdateDescriptionTest {

+  @Rule
+  public MockitoRule rule = MockitoJUnit.rule();
+
+  @Mock
+  private MockedStatic<ThreadUtil> threadUtilMockedStatic;
+
  @Before
  public void setup() {
-    setMainThread(true);
+    threadUtilMockedStatic.when(ThreadUtil::isMainThread).thenReturn(true);
+    threadUtilMockedStatic.when(ThreadUtil::assertMainThread).thenCallRealMethod();
+    threadUtilMockedStatic.when(ThreadUtil::assertNotMainThread).thenCallRealMethod();
  }

  @Test
@@ -54,7 +60,7 @@ public final class UpdateDescriptionTest {
  public void stringFactory_cannot_run_on_main_thread() {
    UpdateDescription description = UpdateDescription.mentioning(Collections.singletonList(ServiceId.from(UUID.randomUUID())), () -> "update", 0);

-    setMainThread(true);
+    threadUtilMockedStatic.when(ThreadUtil::isMainThread).thenReturn(true);

    description.getString();
  }
@@ -79,7 +85,7 @@ public final class UpdateDescriptionTest {

    assertEquals(0, factoryCalls.get());

-    setMainThread(false);
+    threadUtilMockedStatic.when(ThreadUtil::isMainThread).thenReturn(false);

    String string = description.getString();

@@ -93,7 +99,7 @@ public final class UpdateDescriptionTest {
    UpdateDescription.StringFactory stringFactory = () -> "call" + factoryCalls.incrementAndGet();
    UpdateDescription               description   = UpdateDescription.mentioning(Collections.singletonList(ServiceId.from(UUID.randomUUID())), stringFactory, 0);

-    setMainThread(false);
+    threadUtilMockedStatic.when(ThreadUtil::isMainThread).thenReturn(false);

    assertEquals("call1", description.getString());
    assertEquals("call2", description.getString());
@@ -137,7 +143,7 @@ public final class UpdateDescriptionTest {

    assertFalse(description.isStringStatic());

-    setMainThread(false);
+    threadUtilMockedStatic.when(ThreadUtil::isMainThread).thenReturn(false);

    assertEquals("update.11\nupdate.21", description.getString());
    assertEquals("update.12\nupdate.22", description.getString());
@@ -161,7 +167,7 @@ public final class UpdateDescriptionTest {

    assertFalse(description.isStringStatic());

-    setMainThread(false);
+    threadUtilMockedStatic.when(ThreadUtil::isMainThread).thenReturn(false);

    assertEquals("update.101\nstatic\nupdate.201", description.getString());
    assertEquals("update.102\nstatic\nupdate.202", description.getString());
--- a/app/src/test/java/org/thoughtcrime/securesms/jobmanager/JobMigratorTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/jobmanager/JobMigratorTest.java
@@ -13,7 +13,7 @@ import java.util.Arrays;
 import java.util.Collections;

 import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
--- a/app/src/test/java/org/thoughtcrime/securesms/jobmanager/migrations/RecipientIdFollowUpJobMigrationTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/jobmanager/migrations/RecipientIdFollowUpJobMigrationTest.java
@@ -1,10 +1,12 @@
 package org.thoughtcrime.securesms.jobmanager.migrations;

 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.thoughtcrime.securesms.jobmanager.Data;
 import org.thoughtcrime.securesms.jobmanager.Job;
 import org.thoughtcrime.securesms.jobmanager.JobMigration.JobData;
@@ -15,18 +17,18 @@ import org.thoughtcrime.securesms.recipients.Recipient;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
-import static org.powermock.api.mockito.PowerMockito.mock;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
+import static org.mockito.Mockito.mock;

-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ Recipient.class, Job.Parameters.class })
 public class RecipientIdFollowUpJobMigrationTest {

-  @Before
-  public void init() {
-    mockStatic(Recipient.class);
-    mockStatic(Job.Parameters.class);
-  }
+  @Rule
+  public MockitoRule rule = MockitoJUnit.rule();
+
+  @Mock
+  private MockedStatic<Recipient> recipientMockedStatic;
+
+  @Mock
+  private MockedStatic<Job.Parameters> jobParametersMockedStatic;

  @Test
  public void migrate_requestGroupInfoJob_good() throws Exception {
--- a/app/src/test/java/org/thoughtcrime/securesms/jobmanager/migrations/RecipientIdJobMigrationTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/jobmanager/migrations/RecipientIdJobMigrationTest.java
@@ -4,10 +4,13 @@ import android.app.Application;
 import android.content.Context;

 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.thoughtcrime.securesms.jobmanager.Data;
 import org.thoughtcrime.securesms.jobmanager.Job;
 import org.thoughtcrime.securesms.jobmanager.JobMigration.JobData;
@@ -34,22 +37,22 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.powermock.api.mockito.PowerMockito.doReturn;
-import static org.powermock.api.mockito.PowerMockito.mock;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
-import static org.powermock.api.mockito.PowerMockito.when;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;

-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ Recipient.class, Job.Parameters.class })
 public class RecipientIdJobMigrationTest {

-  @Before
-  public void init() {
-    mockStatic(Recipient.class);
-    mockStatic(Job.Parameters.class);
-  }
+  @Rule
+  public MockitoRule rule = MockitoJUnit.rule();
+
+  @Mock
+  private MockedStatic<Recipient> recipientMockedStatic;
+
+  @Mock
+  private MockedStatic<Job.Parameters> jobParametersMockStatic;

  @Test
  public void migrate_multiDeviceContactUpdateJob() throws Exception {
@@ -348,8 +351,9 @@ public class RecipientIdJobMigrationTest {
    new SmsSendJob.Factory().create(mock(Job.Parameters.class), converted.getData());
  }

-  private void mockRecipientResolve(String address, long recipientId) throws Exception {
-    doReturn(mockRecipient(recipientId)).when(Recipient.class, "external", any(Context.class), eq(address));
+  private void mockRecipientResolve(String address, long recipientId) {
+    Recipient mockRecipient = mockRecipient(recipientId);
+    recipientMockedStatic.when(() -> Recipient.external(any(), eq(address))).thenReturn(mockRecipient);
  }

  private Recipient mockRecipient(long id) {
--- a/app/src/test/java/org/thoughtcrime/securesms/jobmanager/migrations/SendReadReceiptsJobMigrationTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/jobmanager/migrations/SendReadReceiptsJobMigrationTest.java
@@ -11,7 +11,7 @@ import java.util.ArrayList;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;

--- a/app/src/test/java/org/thoughtcrime/securesms/keyvalue/PaymentsValuesTest.kt
+++ b/app/src/test/java/org/thoughtcrime/securesms/keyvalue/PaymentsValuesTest.kt
@@ -7,10 +7,11 @@ import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.powermock.api.mockito.PowerMockito
-import org.powermock.core.classloader.annotations.PowerMockIgnore
-import org.powermock.core.classloader.annotations.PrepareForTest
-import org.powermock.modules.junit4.rule.PowerMockRule
+import org.mockito.Mock
+import org.mockito.MockedStatic
+import org.mockito.Mockito.`when`
+import org.mockito.junit.MockitoJUnit
+import org.mockito.junit.MockitoRule
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.annotation.Config
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
@@ -19,20 +20,19 @@ import org.thoughtcrime.securesms.util.FeatureFlags

@RunWith(RobolectricTestRunner::class)
@Config(manifest = Config.NONE, application = Application::class)
-@PowerMockIgnore("org.mockito.*", "org.robolectric.*", "android.*", "androidx.*", "org.powermock.*")
-@PrepareForTest(FeatureFlags::class)
 class PaymentsValuesTest {

-  @get:Rule
-  val powerMockRule = PowerMockRule()
+  @Rule
+  @JvmField val mockitoRule: MockitoRule = MockitoJUnit.rule()
+
+  @Mock
+  private lateinit var featureFlags: MockedStatic<FeatureFlags>

  @Before
  fun setup() {
    if (!ApplicationDependencies.isInitialized()) {
      ApplicationDependencies.init(ApplicationProvider.getApplicationContext(), MockApplicationDependencyProvider())
    }
-
-    PowerMockito.mockStatic(FeatureFlags::class.java)
  }

  @Test
@@ -56,8 +56,8 @@ class PaymentsValuesTest {
      }
    )

-    PowerMockito.`when`(FeatureFlags.payments()).thenReturn(false)
-    PowerMockito.`when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("")
+    `when`(FeatureFlags.payments()).thenReturn(false)
+    `when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("")

    assertEquals(PaymentsAvailability.DISABLED_REMOTELY, SignalStore.paymentsValues().paymentsAvailability)
  }
@@ -72,8 +72,8 @@ class PaymentsValuesTest {
      }
    )

-    PowerMockito.`when`(FeatureFlags.payments()).thenReturn(false)
-    PowerMockito.`when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("")
+    `when`(FeatureFlags.payments()).thenReturn(false)
+    `when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("")

    assertEquals(PaymentsAvailability.WITHDRAW_ONLY, SignalStore.paymentsValues().paymentsAvailability)
  }
@@ -88,8 +88,8 @@ class PaymentsValuesTest {
      }
    )

-    PowerMockito.`when`(FeatureFlags.payments()).thenReturn(true)
-    PowerMockito.`when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("")
+    `when`(FeatureFlags.payments()).thenReturn(true)
+    `when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("")

    assertEquals(PaymentsAvailability.REGISTRATION_AVAILABLE, SignalStore.paymentsValues().paymentsAvailability)
  }
@@ -104,8 +104,8 @@ class PaymentsValuesTest {
      }
    )

-    PowerMockito.`when`(FeatureFlags.payments()).thenReturn(true)
-    PowerMockito.`when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("")
+    `when`(FeatureFlags.payments()).thenReturn(true)
+    `when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("")

    assertEquals(PaymentsAvailability.WITHDRAW_AND_SEND, SignalStore.paymentsValues().paymentsAvailability)
  }
@@ -120,8 +120,8 @@ class PaymentsValuesTest {
      }
    )

-    PowerMockito.`when`(FeatureFlags.payments()).thenReturn(true)
-    PowerMockito.`when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("1")
+    `when`(FeatureFlags.payments()).thenReturn(true)
+    `when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("1")

    assertEquals(PaymentsAvailability.NOT_IN_REGION, SignalStore.paymentsValues().paymentsAvailability)
  }
@@ -136,8 +136,8 @@ class PaymentsValuesTest {
      }
    )

-    PowerMockito.`when`(FeatureFlags.payments()).thenReturn(true)
-    PowerMockito.`when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("1")
+    `when`(FeatureFlags.payments()).thenReturn(true)
+    `when`(FeatureFlags.paymentsCountryBlocklist()).thenReturn("1")

    assertEquals(PaymentsAvailability.WITHDRAW_ONLY, SignalStore.paymentsValues().paymentsAvailability)
  }
--- a/app/src/test/java/org/thoughtcrime/securesms/mediasend/MediaRepositoryTest.kt
+++ b/app/src/test/java/org/thoughtcrime/securesms/mediasend/MediaRepositoryTest.kt
@@ -10,11 +10,11 @@ import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.ArgumentMatchers
-import org.powermock.api.mockito.PowerMockito
-import org.powermock.api.mockito.PowerMockito.mockStatic
-import org.powermock.core.classloader.annotations.PowerMockIgnore
-import org.powermock.core.classloader.annotations.PrepareForTest
-import org.powermock.modules.junit4.rule.PowerMockRule
+import org.mockito.Mock
+import org.mockito.MockedStatic
+import org.mockito.Mockito.`when`
+import org.mockito.junit.MockitoJUnit
+import org.mockito.junit.MockitoRule
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.annotation.Config
 import org.signal.core.util.logging.Log
@@ -25,13 +25,13 @@ import org.whispersystems.libsignal.util.guava.Optional

@RunWith(RobolectricTestRunner::class)
@Config(manifest = Config.NONE, application = Application::class)
-@PowerMockIgnore("org.mockito.*", "org.robolectric.*", "android.*", "androidx.*")
-@PrepareForTest(MediaUtil::class)
 class MediaRepositoryTest {

  @Rule
-  @JvmField
-  val rule = PowerMockRule()
+  @JvmField val mockitoRule: MockitoRule = MockitoJUnit.rule()
+
+  @Mock
+  private lateinit var staticMediaUtilMock: MockedStatic<MediaUtil>

  private lateinit var context: Context

@@ -40,8 +40,7 @@ class MediaRepositoryTest {
    Log.initialize(EmptyLogger())

    context = ApplicationProvider.getApplicationContext()
-    mockStatic(MediaUtil::class.java)
-    PowerMockito.`when`(MediaUtil.isOctetStream(MediaUtil.OCTET)).thenReturn(true)
+    `when`(MediaUtil.isOctetStream(MediaUtil.OCTET)).thenReturn(true)
  }

  @Test
@@ -62,7 +61,7 @@ class MediaRepositoryTest {
    val media = buildMedia(mimeType = MediaUtil.OCTET)

    // WHEN
-    PowerMockito.`when`(MediaUtil.getMimeType(ArgumentMatchers.any(), ArgumentMatchers.any())).thenReturn(MediaUtil.IMAGE_JPEG)
+    `when`(MediaUtil.getMimeType(ArgumentMatchers.any(), ArgumentMatchers.any())).thenReturn(MediaUtil.IMAGE_JPEG)
    val result: Media = MediaRepository.fixMimeType(context, media)

    // THEN
--- a/app/src/test/java/org/thoughtcrime/securesms/notifications/MarkReadReceiverTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/notifications/MarkReadReceiverTest.java
@@ -7,11 +7,14 @@ import androidx.annotation.NonNull;
 import com.annimon.stream.Stream;

 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.mockito.stubbing.Answer;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
 import org.thoughtcrime.securesms.database.MessageDatabase;
 import org.thoughtcrime.securesms.database.model.MessageId;
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies;
@@ -31,16 +34,22 @@ import java.util.Set;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.powermock.api.mockito.PowerMockito.doAnswer;
-import static org.powermock.api.mockito.PowerMockito.mock;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
-import static org.powermock.api.mockito.PowerMockito.when;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;

-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ApplicationDependencies.class, Recipient.class})
 public class MarkReadReceiverTest {

+  @Rule
+  public MockitoRule rule = MockitoJUnit.rule();
+
+  @Mock
+  private MockedStatic<ApplicationDependencies> applicationDependenciesMockedStatic;
+
+  @Mock
+  private MockedStatic<Recipient> recipientMockedStatic;
+
  private final Context    mockContext    = mock(Context.class);
  private final JobManager mockJobManager = mock(JobManager.class);
  private final Recipient  mockSelf       = mock(Recipient.class);
@@ -48,14 +57,12 @@ public class MarkReadReceiverTest {

  @Before
  public void setUp() {
-    mockStatic(ApplicationDependencies.class);
-    mockStatic(Recipient.class);
-    when(ApplicationDependencies.getJobManager()).thenReturn(mockJobManager);
+    applicationDependenciesMockedStatic.when(ApplicationDependencies::getJobManager).thenReturn(mockJobManager);
    doAnswer((Answer<Void>) invocation -> {
      jobs.add((Job) invocation.getArguments()[0]);
      return null;
    }).when(mockJobManager).add(any());
-    when(Recipient.self()).thenReturn(mockSelf);
+    recipientMockedStatic.when(Recipient::self).thenReturn(mockSelf);
    when(mockSelf.getId()).thenReturn(RecipientId.from(-1));
  }

--- a/app/src/test/java/org/thoughtcrime/securesms/payments/GeographicalRestrictionsTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/payments/GeographicalRestrictionsTest.java
@@ -1,45 +1,42 @@
 package org.thoughtcrime.securesms.payments;

 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.signal.core.util.logging.Log;
-import org.thoughtcrime.securesms.BuildConfig;
 import org.thoughtcrime.securesms.testutil.EmptyLogger;
 import org.thoughtcrime.securesms.util.FeatureFlags;

 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeFalse;
-import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.when;

-@RunWith(PowerMockRunner.class)
-@PrepareForTest(FeatureFlags.class)
 public final class GeographicalRestrictionsTest {

-  @Before
-  public void setup() {
-    Log.initialize(new EmptyLogger());
-    PowerMockito.mockStatic(FeatureFlags.class);
-  }
+  @Rule
+  public MockitoRule rule = MockitoJUnit.rule();
+
+  @Mock
+  private MockedStatic<FeatureFlags> featureFlagsMockedStatic;

  @Test
  public void e164Allowed_general() {
-    PowerMockito.when(FeatureFlags.paymentsCountryBlocklist()).thenReturn("");
+    when(FeatureFlags.paymentsCountryBlocklist()).thenReturn("");
    assertTrue(GeographicalRestrictions.e164Allowed("+15551234567"));

-    PowerMockito.when(FeatureFlags.paymentsCountryBlocklist()).thenReturn("1");
+    when(FeatureFlags.paymentsCountryBlocklist()).thenReturn("1");
    assertFalse(GeographicalRestrictions.e164Allowed("+15551234567"));

-    PowerMockito.when(FeatureFlags.paymentsCountryBlocklist()).thenReturn("1,44");
+    when(FeatureFlags.paymentsCountryBlocklist()).thenReturn("1,44");
    assertFalse(GeographicalRestrictions.e164Allowed("+15551234567"));
    assertFalse(GeographicalRestrictions.e164Allowed("+445551234567"));
    assertTrue(GeographicalRestrictions.e164Allowed("+525551234567"));

-    PowerMockito.when(FeatureFlags.paymentsCountryBlocklist()).thenReturn("1 234,44");
+    when(FeatureFlags.paymentsCountryBlocklist()).thenReturn("1 234,44");
    assertFalse(GeographicalRestrictions.e164Allowed("+12341234567"));
    assertTrue(GeographicalRestrictions.e164Allowed("+15551234567"));
    assertTrue(GeographicalRestrictions.e164Allowed("+525551234567"));
--- a/app/src/test/java/org/thoughtcrime/securesms/recipients/BaseRecipientTest.kt
+++ b/app/src/test/java/org/thoughtcrime/securesms/recipients/BaseRecipientTest.kt
@@ -6,36 +6,42 @@ import org.junit.Before
 import org.junit.Rule
 import org.junit.runner.RunWith
 import org.mockito.ArgumentMatchers
-import org.powermock.api.mockito.PowerMockito
-import org.powermock.core.classloader.annotations.PowerMockIgnore
-import org.powermock.core.classloader.annotations.PrepareForTest
-import org.powermock.modules.junit4.rule.PowerMockRule
+import org.mockito.Mock
+import org.mockito.MockedConstruction
+import org.mockito.MockedStatic
+import org.mockito.Mockito.`when`
+import org.mockito.junit.MockitoJUnit
+import org.mockito.junit.MockitoRule
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.annotation.Config
 import org.thoughtcrime.securesms.crypto.AttachmentSecretProvider
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
-import org.thoughtcrime.securesms.keyvalue.ChatColorsValues
 import org.thoughtcrime.securesms.keyvalue.SignalStore
-import org.thoughtcrime.securesms.keyvalue.WallpaperValues

@RunWith(RobolectricTestRunner::class)
@Config(manifest = Config.NONE, application = Application::class)
-@PowerMockIgnore("org.mockito.*", "org.robolectric.*", "android.*", "androidx.*", "org.powermock.*")
-@PrepareForTest(ApplicationDependencies::class, AttachmentSecretProvider::class, SignalStore::class, WallpaperValues::class, ChatColorsValues::class)
 abstract class BaseRecipientTest {
+
  @Rule
-  @JvmField
-  var rule = PowerMockRule()
+  @JvmField val mockitoRule: MockitoRule = MockitoJUnit.rule()
+
+  @Mock
+  private lateinit var applicationDependenciesStaticMock: MockedStatic<ApplicationDependencies>
+
+  @Mock
+  private lateinit var attachmentSecretProviderStaticMock: MockedStatic<AttachmentSecretProvider>
+
+  @Mock
+  private lateinit var signalStoreStaticMock: MockedStatic<SignalStore>
+
+  @Mock
+  private lateinit var mockedSignalStoreConstruction: MockedConstruction<SignalStore>

  @Before
  fun superSetUp() {
    val application = ApplicationProvider.getApplicationContext<Application>()

-    PowerMockito.mockStatic(ApplicationDependencies::class.java)
-    PowerMockito.`when`(ApplicationDependencies.getApplication()).thenReturn(application)
-    PowerMockito.mockStatic(AttachmentSecretProvider::class.java)
-    PowerMockito.`when`(AttachmentSecretProvider.getInstance(ArgumentMatchers.any())).thenThrow(RuntimeException::class.java)
-    PowerMockito.whenNew(SignalStore::class.java).withAnyArguments().thenReturn(null)
-    PowerMockito.mockStatic(SignalStore::class.java)
+    `when`(ApplicationDependencies.getApplication()).thenReturn(application)
+    `when`(AttachmentSecretProvider.getInstance(ArgumentMatchers.any())).thenThrow(RuntimeException::class.java)
  }
 }
--- a/app/src/test/java/org/thoughtcrime/securesms/recipients/RecipientUtilTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/recipients/RecipientUtilTest.java
@@ -4,10 +4,12 @@ import android.content.Context;

 import org.junit.Before;
 import org.junit.Ignore;
+import org.junit.Rule;
 import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.thoughtcrime.securesms.database.MmsSmsDatabase;
 import org.thoughtcrime.securesms.database.RecipientDatabase;
 import org.thoughtcrime.securesms.database.SignalDatabase;
@@ -16,30 +18,34 @@ import org.thoughtcrime.securesms.util.FeatureFlags;

 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
-import static org.powermock.api.mockito.PowerMockito.when;
+import static org.mockito.Mockito.when;

-@RunWith(PowerMockRunner.class)
-@PrepareForTest({SignalDatabase.class, FeatureFlags.class})
 public class RecipientUtilTest {

+  @Rule
+  public MockitoRule rule = MockitoJUnit.rule();
+
  private Context           context               = mock(Context.class);
  private Recipient         recipient             = mock(Recipient.class);
  private ThreadDatabase    mockThreadDatabase    = mock(ThreadDatabase.class);
  private MmsSmsDatabase    mockMmsSmsDatabase    = mock(MmsSmsDatabase.class);
  private RecipientDatabase mockRecipientDatabase = mock(RecipientDatabase.class);

+  @Mock
+  private MockedStatic<SignalDatabase> signalDatabaseMockedStatic;
+
+  @Mock
+  private MockedStatic<FeatureFlags> featureFlagsMockedStatic;
+
  @Before
  public void setUp() {
-    mockStatic(SignalDatabase.class);
-    when(SignalDatabase.threads()).thenReturn(mockThreadDatabase);
-    when(SignalDatabase.mmsSms()).thenReturn(mockMmsSmsDatabase);
-    when(SignalDatabase.recipients()).thenReturn(mockRecipientDatabase);
-    mockStatic(FeatureFlags.class);
+    signalDatabaseMockedStatic.when(SignalDatabase::threads).thenReturn(mockThreadDatabase);
+    signalDatabaseMockedStatic.when(SignalDatabase::mmsSms).thenReturn(mockMmsSmsDatabase);
+    signalDatabaseMockedStatic.when(SignalDatabase::recipients).thenReturn(mockRecipientDatabase);

    when(recipient.getId()).thenReturn(RecipientId.from(5));
    when(recipient.resolve()).thenReturn(recipient);
--- a/app/src/test/java/org/thoughtcrime/securesms/recipients/Recipient_getChatColorsTest.kt
+++ b/app/src/test/java/org/thoughtcrime/securesms/recipients/Recipient_getChatColorsTest.kt
@@ -3,9 +3,9 @@ package org.thoughtcrime.securesms.recipients
 import android.graphics.Color
 import org.junit.Assert.assertEquals
 import org.junit.Before
-import org.junit.Ignore
 import org.junit.Test
-import org.powermock.api.mockito.PowerMockito
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.`when`
 import org.thoughtcrime.securesms.conversation.colors.ChatColors
 import org.thoughtcrime.securesms.conversation.colors.ChatColorsPalette
 import org.thoughtcrime.securesms.database.RecipientDatabaseTestUtils.createRecipient
@@ -14,7 +14,6 @@ import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.keyvalue.WallpaperValues
 import org.thoughtcrime.securesms.wallpaper.ChatWallpaper

-@Ignore("PowerMock failing")
@Suppress("ClassName")
 class Recipient_getChatColorsTest : BaseRecipientTest() {

@@ -27,14 +26,14 @@ class Recipient_getChatColorsTest : BaseRecipientTest() {

  @Before
  fun setUp() {
-    wallpaperValues = PowerMockito.mock(WallpaperValues::class.java)
-    chatColorsValues = PowerMockito.mock(ChatColorsValues::class.java)
+    wallpaperValues = mock(WallpaperValues::class.java)
+    chatColorsValues = mock(ChatColorsValues::class.java)

    val globalWallpaper = createWallpaper(globalWallpaperChatColor)
-    PowerMockito.`when`(wallpaperValues.wallpaper).thenReturn(globalWallpaper)
-    PowerMockito.`when`(chatColorsValues.chatColors).thenReturn(globalChatColor)
-    PowerMockito.`when`(SignalStore.wallpaper()).thenReturn(wallpaperValues)
-    PowerMockito.`when`(SignalStore.chatColorsValues()).thenReturn(chatColorsValues)
+    `when`(wallpaperValues.wallpaper).thenReturn(globalWallpaper)
+    `when`(chatColorsValues.chatColors).thenReturn(globalChatColor)
+    `when`(SignalStore.wallpaper()).thenReturn(wallpaperValues)
+    `when`(SignalStore.chatColorsValues()).thenReturn(chatColorsValues)
  }

  @Test
@@ -94,7 +93,7 @@ class Recipient_getChatColorsTest : BaseRecipientTest() {
  @Test
  fun `Given recipient has auto chat color set and no wallpaper set and no global wallpaper set, when I getChatColors, then I expect the default chat color`() {
    // GIVEN
-    PowerMockito.`when`(wallpaperValues.wallpaper).thenReturn(null)
+    `when`(wallpaperValues.wallpaper).thenReturn(null)
    val auto = ChatColors.forColor(ChatColors.Id.Auto, Color.BLACK)
    val recipient = createRecipient(chatColors = auto)

@@ -109,7 +108,7 @@ class Recipient_getChatColorsTest : BaseRecipientTest() {
  fun `Given recipient has no chat color set and there is a custom global chat color, when I getChatColors, then I expect the global chat color`() {
    // GIVEN
    val expected = globalChatColor.withId(ChatColors.Id.Custom(12))
-    PowerMockito.`when`(chatColorsValues.chatColors).thenReturn(expected)
+    `when`(chatColorsValues.chatColors).thenReturn(expected)
    val recipient = createRecipient()

    // WHEN
@@ -134,7 +133,7 @@ class Recipient_getChatColorsTest : BaseRecipientTest() {
  @Test
  fun `Given recipient has no chat color set and there is an auto global chat color and the recipient has a wallpaper, when I getChatColors, then I expect the wallpaper chat color`() {
    // GIVEN
-    PowerMockito.`when`(chatColorsValues.chatColors).thenReturn(globalChatColor.withId(ChatColors.Id.Auto))
+    `when`(chatColorsValues.chatColors).thenReturn(globalChatColor.withId(ChatColors.Id.Auto))
    val color = ChatColors.forColor(ChatColors.Id.BuiltIn, Color.CYAN)
    val recipient = createRecipient(wallpaper = createWallpaper(color))

@@ -148,7 +147,7 @@ class Recipient_getChatColorsTest : BaseRecipientTest() {
  @Test
  fun `Given recipient has no chat color set and there is no global chat color and the recipient has a wallpaper, when I getChatColors, then I expect the wallpaper chat color`() {
    // GIVEN
-    PowerMockito.`when`(chatColorsValues.chatColors).thenReturn(null)
+    `when`(chatColorsValues.chatColors).thenReturn(null)
    val color = ChatColors.forColor(ChatColors.Id.BuiltIn, Color.CYAN)
    val recipient = createRecipient(wallpaper = createWallpaper(color))

@@ -162,7 +161,7 @@ class Recipient_getChatColorsTest : BaseRecipientTest() {
  @Test
  fun `Given recipient has no chat color set and there is an auto global chat color and the recipient has no wallpaper and global wallpaper set, when I getChatColors, then I expect the global wallpaper chat color`() {
    // GIVEN
-    PowerMockito.`when`(chatColorsValues.chatColors).thenReturn(globalChatColor.withId(ChatColors.Id.Auto))
+    `when`(chatColorsValues.chatColors).thenReturn(globalChatColor.withId(ChatColors.Id.Auto))
    val recipient = createRecipient()

    // WHEN
@@ -175,7 +174,7 @@ class Recipient_getChatColorsTest : BaseRecipientTest() {
  @Test
  fun `Given recipient has no chat color set and there is no global chat color and the recipient has no wallpaper and global wallpaper set, when I getChatColors, then I expect the global wallpaper chat color`() {
    // GIVEN
-    PowerMockito.`when`(chatColorsValues.chatColors).thenReturn(null)
+    `when`(chatColorsValues.chatColors).thenReturn(null)
    val recipient = createRecipient()

    // WHEN
@@ -188,8 +187,8 @@ class Recipient_getChatColorsTest : BaseRecipientTest() {
  @Test
  fun `Given no recipient colors and auto global colors and no wallpaper set, when I getChatColors, then I expect default blue`() {
    // GIVEN
-    PowerMockito.`when`(wallpaperValues.wallpaper).thenReturn(null)
-    PowerMockito.`when`(chatColorsValues.chatColors).thenReturn(globalChatColor.withId(ChatColors.Id.Auto))
+    `when`(wallpaperValues.wallpaper).thenReturn(null)
+    `when`(chatColorsValues.chatColors).thenReturn(globalChatColor.withId(ChatColors.Id.Auto))
    val recipient = createRecipient()

    // WHEN
@@ -202,8 +201,8 @@ class Recipient_getChatColorsTest : BaseRecipientTest() {
  @Test
  fun `Given no colors or wallpaper set, when I getChatColors, then I expect default blue`() {
    // GIVEN
-    PowerMockito.`when`(wallpaperValues.wallpaper).thenReturn(null)
-    PowerMockito.`when`(chatColorsValues.chatColors).thenReturn(null)
+    `when`(wallpaperValues.wallpaper).thenReturn(null)
+    `when`(chatColorsValues.chatColors).thenReturn(null)
    val recipient = createRecipient()

    // WHEN
@@ -215,7 +214,7 @@ class Recipient_getChatColorsTest : BaseRecipientTest() {

  private fun createWallpaper(
    chatColors: ChatColors?
-  ): ChatWallpaper = PowerMockito.mock(ChatWallpaper::class.java).apply {
-    PowerMockito.`when`(autoChatColors).thenReturn(chatColors)
+  ): ChatWallpaper = mock(ChatWallpaper::class.java).apply {
+    `when`(autoChatColors).thenReturn(chatColors)
  }
 }
--- a/app/src/test/java/org/thoughtcrime/securesms/registration/PushChallengeRequestTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/registration/PushChallengeRequestTest.java
@@ -18,13 +18,13 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

@RunWith(RobolectricTestRunner.class)
@Config(manifest = Config.NONE, application = Application.class)
@@ -87,7 +87,7 @@ public final class PushChallengeRequestTest {

    Optional<String> challenge = PushChallengeRequest.getPushChallengeBlocking(signal, Optional.absent(), "+123456", 500L);

-    verifyZeroInteractions(signal);
+    verifyNoInteractions(signal);
    assertFalse(challenge.isPresent());
  }

--- a/app/src/test/java/org/thoughtcrime/securesms/service/VerificationCodeParserTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/service/VerificationCodeParserTest.java
@@ -10,8 +10,8 @@ import java.util.Collection;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.anyBoolean;
-import static org.mockito.Matchers.contains;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.contains;
 import static org.mockito.Mockito.when;

 public class VerificationCodeParserTest extends BaseUnitTest {
--- a/app/src/test/java/org/thoughtcrime/securesms/storage/StorageSyncHelperTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/storage/StorageSyncHelperTest.java
@@ -3,13 +3,14 @@ package org.thoughtcrime.securesms.storage;
 import com.annimon.stream.Stream;

 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-import org.powermock.modules.junit4.PowerMockRunnerDelegate;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.signal.core.util.logging.Log;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.storage.StorageSyncHelper.IdDifferenceResult;
@@ -34,17 +35,12 @@ import static junit.framework.TestCase.assertTrue;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
-import static org.powermock.api.mockito.PowerMockito.mock;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
 import static org.thoughtcrime.securesms.testutil.TestHelpers.assertContentsEqual;
 import static org.thoughtcrime.securesms.testutil.TestHelpers.byteArray;
 import static org.thoughtcrime.securesms.testutil.TestHelpers.byteListOf;

-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ Recipient.class, FeatureFlags.class})
-@PowerMockIgnore("javax.crypto.*")
-@PowerMockRunnerDelegate(JUnit4.class)
 public final class StorageSyncHelperTest {

  private static final ServiceId SID_A    = ServiceId.parseOrThrow("ebef429e-695e-4f51-bcc4-526a60ac68c7");
@@ -60,12 +56,19 @@ public final class StorageSyncHelperTest {
    when(SELF.resolve()).thenReturn(SELF);
  }

+  @Rule
+  public MockitoRule rule = MockitoJUnit.rule();
+
+  @Mock
+  private MockedStatic<Recipient> recipientMockedStatic;
+
+  @Mock
+  private MockedStatic<FeatureFlags> featureFlagsMockedStatic;
+
  @Before
  public void setup() {
-    mockStatic(Recipient.class);
-    when(Recipient.self()).thenReturn(SELF);
+    recipientMockedStatic.when(Recipient::self).thenReturn(SELF);
    Log.initialize(new Log.Logger[0]);
-    mockStatic(FeatureFlags.class);
    StorageSyncHelper.setTestKeyGenerator(null);
  }

--- a/app/src/test/java/org/thoughtcrime/securesms/testutil/MainThreadUtil.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/testutil/MainThreadUtil.java
@@ -1,30 +0,0 @@
-package org.thoughtcrime.securesms.testutil;
-
-import org.signal.core.util.ThreadUtil;
-
-import static org.mockito.Mockito.when;
-import static org.powermock.api.mockito.PowerMockito.doCallRealMethod;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
-
-public final class MainThreadUtil {
-
-  private MainThreadUtil() {
-  }
-
-  /**
-   * Makes {@link ThreadUtil}'s Main thread assertions pass or fail during tests.
-   * <p>
-   * Use with {@link org.powermock.modules.junit4.PowerMockRunner} or robolectric with powermock
-   * rule and {@code @PrepareForTest(Util.class)}
-   */
-  public static void setMainThread(boolean isMainThread) {
-    mockStatic(ThreadUtil.class);
-    when(ThreadUtil.isMainThread()).thenReturn(isMainThread);
-    try {
-      doCallRealMethod().when(ThreadUtil.class, "assertMainThread");
-      doCallRealMethod().when(ThreadUtil.class, "assertNotMainThread");
-    } catch (Exception e) {
-      throw new AssertionError();
-    }
-  }
-}
--- a/app/src/test/java/org/thoughtcrime/securesms/util/DelimiterUtilTest.java
+++ b/app/src/test/java/org/thoughtcrime/securesms/util/DelimiterUtilTest.java
@@ -4,24 +4,29 @@ package org.thoughtcrime.securesms.util;
 import android.text.TextUtils;

 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
 import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.mockito.stubbing.Answer;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;

 import static junit.framework.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.anyString;

-@RunWith(PowerMockRunner.class)
-@PrepareForTest(TextUtils.class)
 public class DelimiterUtilTest {

+  @Rule
+  public MockitoRule rule = MockitoJUnit.rule();
+
+  @Mock
+  private MockedStatic<TextUtils> textUtilsMockedStatic;
+
  @Before
  public void setup() {
-    PowerMockito.mockStatic(TextUtils.class);
-    PowerMockito.when(TextUtils.isEmpty(Mockito.anyString())).thenAnswer((Answer<Boolean>) invocation -> {
+    textUtilsMockedStatic.when(() -> TextUtils.isEmpty(anyString())).thenAnswer((Answer<Boolean>) invocation -> {
      if (invocation.getArguments()[0] == null) return true;
      return ((String) invocation.getArguments()[0]).isEmpty();
    });