HBASE-27598 Upgrade mockito to 4.x (#4998)

Signed-off-by: Yulin Niu <niuyulin@apache.org>
(cherry picked from commit bd7a78add5aaac090d6ea0b1951778fe24542b70)

hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestHTableMultiplexerViaMocks.java

@@ -17,8 +17,8 @@
  */
 package org.apache.hadoop.hbase.client;
 
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;

hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestReversedScannerCallable.java

@@ -43,7 +43,7 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
 @Category({ ClientTests.class, SmallTests.class })

hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestScannerCallable.java

@@ -40,7 +40,7 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
 @Category({ ClientTests.class, SmallTests.class })

hbase-hbtop/src/test/java/org/apache/hadoop/hbase/hbtop/screen/field/TestFieldScreenPresenter.java

@@ -42,7 +42,7 @@ import org.junit.experimental.categories.Category;
 import org.junit.runner.RunWith;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 @Category(SmallTests.class)
 @RunWith(MockitoJUnitRunner.class)

hbase-hbtop/src/test/java/org/apache/hadoop/hbase/hbtop/screen/help/TestHelpScreenPresenter.java

@@ -32,7 +32,7 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 @Category(SmallTests.class)
 @RunWith(MockitoJUnitRunner.class)

hbase-hbtop/src/test/java/org/apache/hadoop/hbase/hbtop/screen/mode/TestModeScreenPresenter.java

@@ -35,7 +35,7 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 @Category(SmallTests.class)
 @RunWith(MockitoJUnitRunner.class)

hbase-hbtop/src/test/java/org/apache/hadoop/hbase/hbtop/screen/top/TestFilterDisplayModeScreenPresenter.java

@@ -37,7 +37,7 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 @Category(SmallTests.class)
 @RunWith(MockitoJUnitRunner.class)

hbase-hbtop/src/test/java/org/apache/hadoop/hbase/hbtop/screen/top/TestInputModeScreenPresenter.java

@@ -38,7 +38,7 @@ import org.junit.experimental.categories.Category;
 import org.junit.runner.RunWith;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 @Category(SmallTests.class)
 @RunWith(MockitoJUnitRunner.class)

hbase-hbtop/src/test/java/org/apache/hadoop/hbase/hbtop/screen/top/TestMessageModeScreenPresenter.java

@@ -30,7 +30,7 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 @Category(SmallTests.class)
 @RunWith(MockitoJUnitRunner.class)

hbase-hbtop/src/test/java/org/apache/hadoop/hbase/hbtop/screen/top/TestTopScreenModel.java

@@ -42,7 +42,7 @@ import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 @Category(SmallTests.class)
 @RunWith(MockitoJUnitRunner.class)

hbase-hbtop/src/test/java/org/apache/hadoop/hbase/hbtop/screen/top/TestTopScreenPresenter.java

@@ -40,7 +40,7 @@ import org.junit.experimental.categories.Category;
 import org.junit.runner.RunWith;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
 
 @Category(SmallTests.class)
 @RunWith(MockitoJUnitRunner.class)

hbase-http/src/test/java/org/apache/hadoop/hbase/http/lib/TestStaticUserWebFilter.java

@@ -18,7 +18,10 @@
 package org.apache.hadoop.hbase.http.lib;
 
 import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 import javax.servlet.FilterChain;
 import javax.servlet.FilterConfig;
@@ -36,7 +39,6 @@ import org.junit.ClassRule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
 
 @Category({ MiscTests.class, SmallTests.class })
 public class TestStaticUserWebFilter {
@@ -46,9 +48,8 @@ public class TestStaticUserWebFilter {
     HBaseClassTestRule.forClass(TestStaticUserWebFilter.class);
 
   private FilterConfig mockConfig(String username) {
-    FilterConfig mock = Mockito.mock(FilterConfig.class);
+    FilterConfig mock = mock(FilterConfig.class);
-    Mockito.doReturn(username).when(mock)
+    doReturn(username).when(mock).getInitParameter(ServerConfigurationKeys.HBASE_HTTP_STATIC_USER);
-      .getInitParameter(ServerConfigurationKeys.HBASE_HTTP_STATIC_USER);
     return mock;
   }
 
@@ -65,7 +66,7 @@ public class TestStaticUserWebFilter {
 
     suf.doFilter(mock(HttpServletRequest.class), mock(ServletResponse.class), chain);
 
-    Mockito.verify(chain).doFilter(wrapperArg.capture(), Mockito.<ServletResponse> anyObject());
+    verify(chain).doFilter(wrapperArg.capture(), any());
 
     HttpServletRequestWrapper wrapper = wrapperArg.getValue();
     assertEquals("myuser", wrapper.getUserPrincipal().getName());

hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapred/TestGroupingTableMap.java

@@ -19,12 +19,12 @@ package org.apache.hadoop.hbase.mapred;
 
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertNull;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
 import static org.mockito.Mockito.when;
 
 import java.io.IOException;
@@ -57,7 +57,7 @@ public class TestGroupingTableMap {
     HBaseClassTestRule.forClass(TestGroupingTableMap.class);
 
   @Test
-  @SuppressWarnings({ "deprecation", "unchecked" })
+  @SuppressWarnings("unchecked")
   public void shouldNotCallCollectonSinceFindUniqueKeyValueMoreThanOnes() throws Exception {
     GroupingTableMap gTableMap = null;
     try {
@@ -79,14 +79,14 @@ public class TestGroupingTableMap {
         mock(OutputCollector.class);
       gTableMap.map(null, result, outputCollectorMock, reporter);
       verify(result).listCells();
-      verifyZeroInteractions(outputCollectorMock);
+      verifyNoInteractions(outputCollectorMock);
     } finally {
       if (gTableMap != null) gTableMap.close();
     }
   }
 
   @Test
-  @SuppressWarnings({ "deprecation", "unchecked" })
+  @SuppressWarnings("unchecked")
   public void shouldCreateNewKeyAlthoughExtraKey() throws Exception {
     GroupingTableMap gTableMap = null;
     try {
@@ -116,7 +116,6 @@ public class TestGroupingTableMap {
   }
 
   @Test
-  @SuppressWarnings({ "deprecation" })
   public void shouldCreateNewKey() throws Exception {
     GroupingTableMap gTableMap = null;
     try {
@@ -164,7 +163,6 @@ public class TestGroupingTableMap {
   }
 
   @Test
-  @SuppressWarnings({ "deprecation" })
   public void shouldReturnNullFromCreateGroupKey() throws Exception {
     GroupingTableMap gTableMap = null;
     try {

hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapred/TestRowCounter.java

@@ -20,8 +20,8 @@ package org.apache.hadoop.hbase.mapred;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 

hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapred/TestTableInputFormat.java

@@ -20,7 +20,7 @@ package org.apache.hadoop.hbase.mapred;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.anyObject;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
@@ -207,7 +207,7 @@ public class TestTableInputFormat {
     };
 
     Table htable = spy(createTable(name));
-    doAnswer(a).when(htable).getScanner((Scan) anyObject());
+    doAnswer(a).when(htable).getScanner(any(Scan.class));
     return htable;
   }
 
@@ -240,7 +240,7 @@ public class TestTableInputFormat {
     };
 
     Table htable = spy(createTable(name));
-    doAnswer(a).when(htable).getScanner((Scan) anyObject());
+    doAnswer(a).when(htable).getScanner(any(Scan.class));
     return htable;
   }
 

hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestTableInputFormat.java

@@ -20,8 +20,7 @@ package org.apache.hadoop.hbase.mapreduce;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.*;
-import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
@@ -209,7 +208,7 @@ public class TestTableInputFormat {
     };
 
     Table htable = spy(createTable(name));
-    doAnswer(a).when(htable).getScanner((Scan) anyObject());
+    doAnswer(a).when(htable).getScanner(any(Scan.class));
     return htable;
   }
 
@@ -242,7 +241,7 @@ public class TestTableInputFormat {
     };
 
     Table htable = spy(createTable(name));
-    doAnswer(a).when(htable).getScanner((Scan) anyObject());
+    doAnswer(a).when(htable).getScanner(any(Scan.class));
     return htable;
   }
 

hbase-rest/src/test/java/org/apache/hadoop/hbase/rest/client/TestRemoteAdminRetries.java

@@ -19,8 +19,8 @@ package org.apache.hadoop.hbase.rest.client;
 
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyString;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;

hbase-rest/src/test/java/org/apache/hadoop/hbase/rest/client/TestRemoteHTableRetries.java

@@ -19,8 +19,8 @@ package org.apache.hadoop.hbase.rest.client;
 
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyString;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;

hbase-server/src/test/java/org/apache/hadoop/hbase/TestMetaTableAccessor.java

@@ -23,7 +23,7 @@ import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.anyObject;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.reset;
@@ -604,31 +604,31 @@ public class TestMetaTableAccessor {
     UTIL.countRows(table);
 
     MetaTableAccessor.Visitor visitor = mock(MetaTableAccessor.Visitor.class);
-    doReturn(true).when(visitor).visit((Result) anyObject());
+    doReturn(true).when(visitor).visit(any());
 
     // Scanning the entire table should give us three rows
     MetaTableAccessor.scanMetaForTableRegions(connection, visitor, tableName);
-    verify(visitor, times(3)).visit((Result) anyObject());
+    verify(visitor, times(3)).visit(any());
 
     // Scanning the table with a specified empty start row should also
     // give us three hbase:meta rows
     reset(visitor);
-    doReturn(true).when(visitor).visit((Result) anyObject());
+    doReturn(true).when(visitor).visit(any());
     MetaTableAccessor.scanMeta(connection, visitor, tableName, null, 1000);
-    verify(visitor, times(3)).visit((Result) anyObject());
+    verify(visitor, times(3)).visit(any());
 
     // Scanning the table starting in the middle should give us two rows:
     // region_a and region_b
     reset(visitor);
-    doReturn(true).when(visitor).visit((Result) anyObject());
+    doReturn(true).when(visitor).visit(any());
     MetaTableAccessor.scanMeta(connection, visitor, tableName, Bytes.toBytes("region_ac"), 1000);
-    verify(visitor, times(2)).visit((Result) anyObject());
+    verify(visitor, times(2)).visit(any());
 
     // Scanning with a limit of 1 should only give us one row
     reset(visitor);
-    doReturn(true).when(visitor).visit((Result) anyObject());
+    doReturn(true).when(visitor).visit(any());
     MetaTableAccessor.scanMeta(connection, visitor, tableName, Bytes.toBytes("region_ac"), 1);
-    verify(visitor, times(1)).visit((Result) anyObject());
+    verify(visitor, times(1)).visit(any());
     table.close();
   }
 

hbase-server/src/test/java/org/apache/hadoop/hbase/backup/example/TestZooKeeperTableArchiveClient.java

@@ -20,7 +20,11 @@ package org.apache.hadoop.hbase.backup.example;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -62,7 +66,6 @@ import org.junit.BeforeClass;
 import org.junit.ClassRule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
-import org.mockito.Mockito;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.slf4j.Logger;
@@ -186,7 +189,7 @@ public class TestZooKeeperTableArchiveClient {
     HRegion region = UTIL.createTestRegion(STRING_TABLE_NAME, hcd);
     List<HRegion> regions = new ArrayList<>();
     regions.add(region);
-    Mockito.doReturn(regions).when(rss).getRegions();
+    doReturn(regions).when(rss).getRegions();
     final CompactedHFilesDischarger compactionCleaner =
       new CompactedHFilesDischarger(100, stop, rss, false);
     loadFlushAndCompact(region, TEST_FAM);
@@ -239,7 +242,7 @@ public class TestZooKeeperTableArchiveClient {
     HRegion region = UTIL.createTestRegion(STRING_TABLE_NAME, hcd);
     List<HRegion> regions = new ArrayList<>();
     regions.add(region);
-    Mockito.doReturn(regions).when(rss).getRegions();
+    doReturn(regions).when(rss).getRegions();
     final CompactedHFilesDischarger compactionCleaner =
       new CompactedHFilesDischarger(100, stop, rss, false);
     loadFlushAndCompact(region, TEST_FAM);
@@ -249,7 +252,7 @@ public class TestZooKeeperTableArchiveClient {
     HRegion otherRegion = UTIL.createTestRegion(otherTable, hcd);
     regions = new ArrayList<>();
     regions.add(otherRegion);
-    Mockito.doReturn(regions).when(rss).getRegions();
+    doReturn(regions).when(rss).getRegions();
     final CompactedHFilesDischarger compactionCleaner1 =
       new CompactedHFilesDischarger(100, stop, rss, false);
     loadFlushAndCompact(otherRegion, TEST_FAM);
@@ -365,10 +368,10 @@ public class TestZooKeeperTableArchiveClient {
   private CountDownLatch setupCleanerWatching(LongTermArchivingHFileCleaner cleaner,
     List<BaseHFileCleanerDelegate> cleaners, final int expected) {
     // replace the cleaner with one that we can can check
-    BaseHFileCleanerDelegate delegateSpy = Mockito.spy(cleaner);
+    BaseHFileCleanerDelegate delegateSpy = spy(cleaner);
     final int[] counter = new int[] { 0 };
     final CountDownLatch finished = new CountDownLatch(1);
-    Mockito.doAnswer(new Answer<Iterable<FileStatus>>() {
+    doAnswer(new Answer<Iterable<FileStatus>>() {
 
       @Override
       public Iterable<FileStatus> answer(InvocationOnMock invocation) throws Throwable {
@@ -384,7 +387,7 @@ public class TestZooKeeperTableArchiveClient {
 
         return ret;
       }
-    }).when(delegateSpy).getDeletableFiles(Mockito.anyListOf(FileStatus.class));
+    }).when(delegateSpy).getDeletableFiles(anyList());
     cleaners.set(0, delegateSpy);
 
     return finished;

hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestHBaseAdminNoCluster.java

@@ -18,7 +18,12 @@
 package org.apache.hadoop.hbase.client;
 
 import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import com.google.protobuf.ServiceException;
@@ -44,26 +49,12 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.junit.rules.TestName;
-import org.mockito.Matchers;
 import org.mockito.Mockito;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import org.apache.hbase.thirdparty.com.google.protobuf.RpcController;
-
-import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.BalanceRequest;
-import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.CreateTableRequest;
-import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.EnableCatalogJanitorRequest;
-import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetTableDescriptorsRequest;
-import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetTableNamesRequest;
-import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.IsCatalogJanitorEnabledRequest;
-import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.MoveRegionRequest;
-import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.OfflineRegionRequest;
-import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.RunCatalogScanRequest;
-import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.SetBalancerRunningRequest;
-
 @Category({ SmallTests.class, ClientTests.class })
 public class TestHBaseAdminNoCluster {
 
@@ -97,12 +88,10 @@ public class TestHBaseAdminNoCluster {
     ClusterConnection connection = HConnectionTestingUtility.getMockedConnection(configuration);
     // Mock so we get back the master interface. Make it so when createTable is called, we throw
     // the PleaseHoldException.
-    MasterKeepAliveConnection masterAdmin = Mockito.mock(MasterKeepAliveConnection.class);
+    MasterKeepAliveConnection masterAdmin = mock(MasterKeepAliveConnection.class);
-    Mockito
+    when(masterAdmin.createTable(any(), any()))
-      .when(
-        masterAdmin.createTable((RpcController) Mockito.any(), (CreateTableRequest) Mockito.any()))
       .thenThrow(new ServiceException("Test fail").initCause(new PleaseHoldException("test")));
-    Mockito.when(connection.getMaster()).thenReturn(masterAdmin);
+    when(connection.getMaster()).thenReturn(masterAdmin);
     Admin admin = new HBaseAdmin(connection);
     try {
       HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(name.getMethodName()));
@@ -114,8 +103,7 @@ public class TestHBaseAdminNoCluster {
         LOG.info("Expected fail", e);
       }
       // Assert we were called 'count' times.
-      Mockito.verify(masterAdmin, Mockito.atLeast(count)).createTable((RpcController) Mockito.any(),
+      verify(masterAdmin, atLeast(count)).createTable(any(), any());
-        (CreateTableRequest) Mockito.any());
     } finally {
       admin.close();
       if (connection != null) connection.close();
@@ -134,8 +122,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count)).getTableDescriptors(
+        Mockito.verify(masterAdmin, atLeast(count)).getTableDescriptors(any(), any());
-          (RpcController) Mockito.any(), (GetTableDescriptorsRequest) Mockito.any());
       }
     });
 
@@ -148,8 +135,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count))
+        Mockito.verify(masterAdmin, atLeast(count)).getTableNames(any(), any());
-          .getTableNames((RpcController) Mockito.any(), (GetTableNamesRequest) Mockito.any());
       }
     });
 
@@ -162,8 +148,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count)).getTableDescriptors(
+        Mockito.verify(masterAdmin, atLeast(count)).getTableDescriptors(any(), any());
-          (RpcController) Mockito.any(), (GetTableDescriptorsRequest) Mockito.any());
       }
     });
 
@@ -176,8 +161,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count)).getTableDescriptors(
+        Mockito.verify(masterAdmin, atLeast(count)).getTableDescriptors(any(), any());
-          (RpcController) Mockito.any(), (GetTableDescriptorsRequest) Mockito.any());
       }
     });
 
@@ -190,8 +174,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count))
+        Mockito.verify(masterAdmin, atLeast(count)).moveRegion(any(), any());
-          .moveRegion((RpcController) Mockito.any(), (MoveRegionRequest) Mockito.any());
       }
     });
 
@@ -204,8 +187,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count))
+        Mockito.verify(masterAdmin, atLeast(count)).offlineRegion(any(), any());
-          .offlineRegion((RpcController) Mockito.any(), (OfflineRegionRequest) Mockito.any());
       }
     });
 
@@ -218,8 +200,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count)).setBalancerRunning(
+        Mockito.verify(masterAdmin, atLeast(count)).setBalancerRunning(any(), any());
-          (RpcController) Mockito.any(), (SetBalancerRunningRequest) Mockito.any());
       }
     });
 
@@ -232,8 +213,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count)).balance((RpcController) Mockito.any(),
+        Mockito.verify(masterAdmin, atLeast(count)).balance(any(), any());
-          (BalanceRequest) Mockito.any());
       }
     });
 
@@ -246,8 +226,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count)).enableCatalogJanitor(
+        Mockito.verify(masterAdmin, atLeast(count)).enableCatalogJanitor(any(), any());
-          (RpcController) Mockito.any(), (EnableCatalogJanitorRequest) Mockito.any());
       }
     });
 
@@ -260,8 +239,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count))
+        Mockito.verify(masterAdmin, atLeast(count)).runCatalogScan(any(), any());
-          .runCatalogScan((RpcController) Mockito.any(), (RunCatalogScanRequest) Mockito.any());
       }
     });
 
@@ -274,8 +252,7 @@ public class TestHBaseAdminNoCluster {
 
       @Override
       public void verify(MasterKeepAliveConnection masterAdmin, int count) throws Exception {
-        Mockito.verify(masterAdmin, Mockito.atLeast(count)).isCatalogJanitorEnabled(
+        Mockito.verify(masterAdmin, atLeast(count)).isCatalogJanitorEnabled(any(), any());
-          (RpcController) Mockito.any(), (IsCatalogJanitorEnabledRequest) Mockito.any());
       }
     });
   }
@@ -295,32 +272,30 @@ public class TestHBaseAdminNoCluster {
 
     ClusterConnection connection = mock(ClusterConnection.class);
     when(connection.getConfiguration()).thenReturn(configuration);
-    MasterKeepAliveConnection masterAdmin =
+    MasterKeepAliveConnection masterAdmin = mock(MasterKeepAliveConnection.class, new Answer() {
-      Mockito.mock(MasterKeepAliveConnection.class, new Answer() {
+      @Override
-        @Override
+      public Object answer(InvocationOnMock invocation) throws Throwable {
-        public Object answer(InvocationOnMock invocation) throws Throwable {
+        if (invocation.getMethod().getName().equals("close")) {
-          if (invocation.getMethod().getName().equals("close")) {
+          return null;
-            return null;
-          }
-          throw new MasterNotRunningException(); // all methods will throw an exception
         }
-      });
+        throw new MasterNotRunningException(); // all methods will throw an exception
-    Mockito.when(connection.getMaster()).thenReturn(masterAdmin);
+      }
-    RpcControllerFactory rpcControllerFactory = Mockito.mock(RpcControllerFactory.class);
+    });
-    Mockito.when(connection.getRpcControllerFactory()).thenReturn(rpcControllerFactory);
+    when(connection.getMaster()).thenReturn(masterAdmin);
-    Mockito.when(rpcControllerFactory.newController())
+    RpcControllerFactory rpcControllerFactory = mock(RpcControllerFactory.class);
-      .thenReturn(Mockito.mock(HBaseRpcController.class));
+    when(connection.getRpcControllerFactory()).thenReturn(rpcControllerFactory);
+    when(rpcControllerFactory.newController()).thenReturn(mock(HBaseRpcController.class));
 
     // we need a real retrying caller
     RpcRetryingCallerFactory callerFactory = new RpcRetryingCallerFactory(configuration);
-    Mockito.when(connection.getRpcRetryingCallerFactory()).thenReturn(callerFactory);
+    when(connection.getRpcRetryingCallerFactory()).thenReturn(callerFactory);
 
     Admin admin = null;
     try {
-      admin = Mockito.spy(new HBaseAdmin(connection));
+      admin = spy(new HBaseAdmin(connection));
       // mock the call to getRegion since in the absence of a cluster (which means the meta
       // is not assigned), getRegion can't function
-      Mockito.doReturn(null).when(((HBaseAdmin) admin)).getRegion(Matchers.<byte[]> any());
+      doReturn(null).when(((HBaseAdmin) admin)).getRegion(any());
       try {
         caller.call(admin); // invoke the HBaseAdmin method
         fail();

hbase-server/src/test/java/org/apache/hadoop/hbase/client/locking/TestEntityLocks.java

@@ -20,9 +20,9 @@ package org.apache.hadoop.hbase.client.locking;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;

hbase-server/src/test/java/org/apache/hadoop/hbase/errorhandling/TestTimeoutExceptionInjector.java

@@ -18,6 +18,12 @@
 package org.apache.hadoop.hbase.errorhandling;
 
 import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import org.apache.hadoop.hbase.HBaseClassTestRule;
 import org.apache.hadoop.hbase.testclassification.MasterTests;
@@ -25,7 +31,6 @@ import org.apache.hadoop.hbase.testclassification.SmallTests;
 import org.junit.ClassRule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
-import org.mockito.Mockito;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -47,11 +52,11 @@ public class TestTimeoutExceptionInjector {
   @Test
   public void testTimerTrigger() {
     final long time = 10000000; // pick a value that is very far in the future
-    ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class);
+    ForeignExceptionListener listener = mock(ForeignExceptionListener.class);
     TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time);
     timer.start();
     timer.trigger();
-    Mockito.verify(listener, Mockito.times(1)).receive(Mockito.any());
+    verify(listener, times(1)).receive(any());
   }
 
   /**
@@ -60,11 +65,11 @@ public class TestTimeoutExceptionInjector {
   @Test
   public void testTimerPassesOnErrorInfo() {
     final long time = 1000000;
-    ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class);
+    ForeignExceptionListener listener = mock(ForeignExceptionListener.class);
     TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time);
     timer.start();
     timer.trigger();
-    Mockito.verify(listener).receive(Mockito.any());
+    verify(listener).receive(any());
   }
 
   /**
@@ -74,7 +79,7 @@ public class TestTimeoutExceptionInjector {
   @Test
   public void testStartAfterComplete() throws InterruptedException {
     final long time = 10;
-    ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class);
+    ForeignExceptionListener listener = mock(ForeignExceptionListener.class);
     TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time);
     timer.complete();
     try {
@@ -84,7 +89,7 @@ public class TestTimeoutExceptionInjector {
       LOG.debug("Correctly failed timer: " + e.getMessage());
     }
     Thread.sleep(time + 1);
-    Mockito.verifyZeroInteractions(listener);
+    verifyNoInteractions(listener);
   }
 
   /**
@@ -94,7 +99,7 @@ public class TestTimeoutExceptionInjector {
   @Test
   public void testStartAfterTrigger() throws InterruptedException {
     final long time = 10;
-    ForeignExceptionListener listener = Mockito.mock(ForeignExceptionListener.class);
+    ForeignExceptionListener listener = mock(ForeignExceptionListener.class);
     TimeoutExceptionInjector timer = new TimeoutExceptionInjector(listener, time);
     timer.trigger();
     try {
@@ -104,7 +109,7 @@ public class TestTimeoutExceptionInjector {
       LOG.debug("Correctly failed timer: " + e.getMessage());
     }
     Thread.sleep(time * 2);
-    Mockito.verify(listener, Mockito.times(1)).receive(Mockito.any());
+    verify(listener, times(1)).receive(any());
-    Mockito.verifyNoMoreInteractions(listener);
+    verifyNoMoreInteractions(listener);
   }
 }

hbase-server/src/test/java/org/apache/hadoop/hbase/executor/TestExecutorService.java

@@ -19,7 +19,7 @@ package org.apache.hadoop.hbase.executor;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.anyObject;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
@@ -205,7 +205,7 @@ public class TestExecutorService {
       @Override
       public boolean evaluate() throws Exception {
         try {
-          verify(server, times(1)).abort(anyString(), (Throwable) anyObject());
+          verify(server, times(1)).abort(anyString(), any());
           return true;
         } catch (Throwable t) {
           return false;

hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestWarmupRegion.java

@@ -32,6 +32,7 @@ import org.apache.hadoop.hbase.client.CompactionState;
 import org.apache.hadoop.hbase.client.Put;
 import org.apache.hadoop.hbase.client.RegionInfo;
 import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.client.TableDescriptor;
 import org.apache.hadoop.hbase.regionserver.HRegion;
 import org.apache.hadoop.hbase.regionserver.HRegionServer;
 import org.apache.hadoop.hbase.testclassification.LargeTests;

hbase-server/src/test/java/org/apache/hadoop/hbase/procedure/TestProcedure.java

@@ -17,8 +17,8 @@
  */
 package org.apache.hadoop.hbase.procedure;
 
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyString;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;

hbase-server/src/test/java/org/apache/hadoop/hbase/procedure/TestProcedureCoordinator.java

@@ -19,10 +19,10 @@ package org.apache.hadoop.hbase.procedure;
 
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyListOf;
+import static org.mockito.ArgumentMatchers.anyList;
-import static org.mockito.Matchers.anyString;
+import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
@@ -111,7 +111,7 @@ public class TestProcedureCoordinator {
     Procedure proc2 = new Procedure(coordinator, monitor, WAKE_FREQUENCY, TIMEOUT, procName + "2",
       procData, expected);
     Procedure procSpy2 = spy(proc2);
-    when(coordinator.createProcedure(any(), eq(procName), eq(procData), anyListOf(String.class)))
+    when(coordinator.createProcedure(any(), eq(procName), eq(procData), anyList()))
       .thenReturn(procSpy, procSpy2);
 
     coordinator.startProcedure(procSpy.getErrorMonitor(), procName, procData, expected);
@@ -132,13 +132,12 @@ public class TestProcedureCoordinator {
       new Procedure(coordinator, WAKE_FREQUENCY, TIMEOUT, procName, procData, expected);
     final Procedure procSpy = spy(proc);
 
-    when(coordinator.createProcedure(any(), eq(procName), eq(procData), anyListOf(String.class)))
+    when(coordinator.createProcedure(any(), eq(procName), eq(procData), anyList()))
       .thenReturn(procSpy);
 
     // use the passed controller responses
     IOException cause = new IOException("Failed to reach comms during acquire");
-    doThrow(cause).when(controller).sendGlobalBarrierAcquire(eq(procSpy), eq(procData),
+    doThrow(cause).when(controller).sendGlobalBarrierAcquire(eq(procSpy), eq(procData), anyList());
-      anyListOf(String.class));
 
     // run the operation
     proc = coordinator.startProcedure(proc.getErrorMonitor(), procName, procData, expected);
@@ -148,7 +147,7 @@ public class TestProcedureCoordinator {
     verify(procSpy, atLeastOnce()).receive(any());
     verify(coordinator, times(1)).rpcConnectionFailure(anyString(), eq(cause));
     verify(controller, times(1)).sendGlobalBarrierAcquire(procSpy, procData, expected);
-    verify(controller, never()).sendGlobalBarrierReached(any(), anyListOf(String.class));
+    verify(controller, never()).sendGlobalBarrierReached(any(), anyList());
   }
 
   /**
@@ -163,14 +162,13 @@ public class TestProcedureCoordinator {
     final Procedure spy =
       spy(new Procedure(coordinator, WAKE_FREQUENCY, TIMEOUT, procName, procData, expected));
 
-    when(coordinator.createProcedure(any(), eq(procName), eq(procData), anyListOf(String.class)))
+    when(coordinator.createProcedure(any(), eq(procName), eq(procData), anyList())).thenReturn(spy);
-      .thenReturn(spy);
 
     // use the passed controller responses
     IOException cause = new IOException("Failed to reach controller during prepare");
     doAnswer(new AcquireBarrierAnswer(procName, new String[] { "cohort" })).when(controller)
-      .sendGlobalBarrierAcquire(eq(spy), eq(procData), anyListOf(String.class));
+      .sendGlobalBarrierAcquire(eq(spy), eq(procData), anyList());
-    doThrow(cause).when(controller).sendGlobalBarrierReached(eq(spy), anyListOf(String.class));
+    doThrow(cause).when(controller).sendGlobalBarrierReached(eq(spy), anyList());
 
     // run the operation
     Procedure task =
@@ -180,9 +178,8 @@ public class TestProcedureCoordinator {
       ;
     verify(spy, atLeastOnce()).receive(any());
     verify(coordinator, times(1)).rpcConnectionFailure(anyString(), eq(cause));
-    verify(controller, times(1)).sendGlobalBarrierAcquire(eq(spy), eq(procData),
+    verify(controller, times(1)).sendGlobalBarrierAcquire(eq(spy), eq(procData), anyList());
-      anyListOf(String.class));
+    verify(controller, times(1)).sendGlobalBarrierReached(any(), anyList());
-    verify(controller, times(1)).sendGlobalBarrierReached(any(), anyListOf(String.class));
   }
 
   @Test
@@ -273,13 +270,11 @@ public class TestProcedureCoordinator {
   public void runCoordinatedOperation(Procedure spy, AcquireBarrierAnswer prepareOperation,
     BarrierAnswer commitOperation, String... cohort) throws Exception {
     List<String> expected = Arrays.asList(cohort);
-    when(coordinator.createProcedure(any(), eq(procName), eq(procData), anyListOf(String.class)))
+    when(coordinator.createProcedure(any(), eq(procName), eq(procData), anyList())).thenReturn(spy);
-      .thenReturn(spy);
 
     // use the passed controller responses
     doAnswer(prepareOperation).when(controller).sendGlobalBarrierAcquire(spy, procData, expected);
-    doAnswer(commitOperation).when(controller).sendGlobalBarrierReached(eq(spy),
+    doAnswer(commitOperation).when(controller).sendGlobalBarrierReached(eq(spy), anyList());
-      anyListOf(String.class));
 
     // run the operation
     Procedure task =
@@ -294,7 +289,7 @@ public class TestProcedureCoordinator {
     inorder.verify(spy).sendGlobalBarrierStart();
     inorder.verify(controller).sendGlobalBarrierAcquire(task, procData, expected);
     inorder.verify(spy).sendGlobalBarrierReached();
-    inorder.verify(controller).sendGlobalBarrierReached(eq(task), anyListOf(String.class));
+    inorder.verify(controller).sendGlobalBarrierReached(eq(task), anyList());
   }
 
   private static abstract class OperationAnswer implements Answer<Void> {

hbase-server/src/test/java/org/apache/hadoop/hbase/procedure/TestProcedureMember.java

@@ -17,9 +17,9 @@
  */
 package org.apache.hadoop.hbase.procedure;
 
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyString;
+import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.inOrder;
@@ -27,7 +27,7 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
 import java.io.IOException;
@@ -420,7 +420,7 @@ public class TestProcedureMember {
     }
 
     // no request should reach the pool
-    verifyZeroInteractions(pool);
+    verifyNoInteractions(pool);
     // get two abort requests
     // TODO Need to do another refactor to get this to propagate to the coordinator.
     // verify(mockMemberComms, times(2)).sendMemberAborted(any(), any());

hbase-server/src/test/java/org/apache/hadoop/hbase/procedure/TestZKProcedure.java

@@ -19,9 +19,9 @@ package org.apache.hadoop.hbase.procedure;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyListOf;
+import static org.mockito.ArgumentMatchers.anyList;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.atMost;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
@@ -291,7 +291,7 @@ public class TestZKProcedure {
       Mockito.spy(new ForeignExceptionDispatcher());
     Procedure coordinatorTask = Mockito.spy(new Procedure(coordinator, coordinatorTaskErrorMonitor,
       WAKE_FREQUENCY, TIMEOUT, opName, data, expected));
-    when(coordinator.createProcedure(any(), eq(opName), eq(data), anyListOf(String.class)))
+    when(coordinator.createProcedure(any(), eq(opName), eq(data), anyList()))
       .thenReturn(coordinatorTask);
     // count down the error latch when we get the remote error
     Mockito.doAnswer(new Answer<Void>() {

hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestFileSystemUtilizationChore.java

@@ -19,8 +19,9 @@ package org.apache.hadoop.hbase.quotas;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -43,7 +44,6 @@ import org.apache.hadoop.hbase.testclassification.SmallTests;
 import org.junit.ClassRule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
-import org.mockito.Mockito;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
@@ -68,7 +68,7 @@ public class TestFileSystemUtilizationChore {
       .reportRegionSizesForQuotas(any(RegionSizeStore.class));
 
     final Region region = mockRegionWithSize(regionSizes);
-    Mockito.doReturn(Arrays.asList(region)).when(rs).getRegions();
+    doReturn(Arrays.asList(region)).when(rs).getRegions();
     chore.chore();
   }
 
@@ -83,7 +83,7 @@ public class TestFileSystemUtilizationChore {
       .reportRegionSizesForQuotas(any(RegionSizeStore.class));
 
     final Region region = mockRegionWithSize(regionSizes);
-    Mockito.doReturn(Arrays.asList(region)).when(rs).getRegions();
+    doReturn(Arrays.asList(region)).when(rs).getRegions();
     chore.chore();
   }
 
@@ -107,7 +107,7 @@ public class TestFileSystemUtilizationChore {
     final Region r1 = mockRegionWithSize(r1Sizes);
     final Region r2 = mockRegionWithSize(r2Sizes);
     final Region r3 = mockRegionWithSize(r3Sizes);
-    Mockito.doReturn(Arrays.asList(r1, r2, r3)).when(rs).getRegions();
+    doReturn(Arrays.asList(r1, r2, r3)).when(rs).getRegions();
     chore.chore();
   }
 
@@ -169,7 +169,7 @@ public class TestFileSystemUtilizationChore {
     final Region r1 = mockRegionWithSize(Arrays.asList(1024L, 2048L));
     final Region r2 = mockRegionWithSize(Arrays.asList(1024L * 1024L));
     final Region r3 = mockRegionWithSize(Arrays.asList(10L * 1024L * 1024L));
-    Mockito.doReturn(Arrays.asList(r1, r2, r3, lr1, lr2)).when(rs).getRegions();
+    doReturn(Arrays.asList(r1, r2, r3, lr1, lr2)).when(rs).getRegions();
 
     chore.chore();
   }
@@ -200,7 +200,7 @@ public class TestFileSystemUtilizationChore {
     final Region r2 = mockRegionWithSize(Arrays.asList(1024L * 1024L));
     final Region r3 = mockRegionWithSize(Arrays.asList(10L * 1024L * 1024L));
     // lr2 is no longer online, so it should be ignored
-    Mockito.doReturn(Arrays.asList(r1, r2, r3, lr1)).when(rs).getRegions();
+    doReturn(Arrays.asList(r1, r2, r3, lr1)).when(rs).getRegions();
 
     chore.chore();
   }
@@ -221,7 +221,7 @@ public class TestFileSystemUtilizationChore {
 
     final Region r1 = mockRegionWithSize(r1Sizes);
     final Region r2 = mockSplitParentRegionWithSize(r2Sizes);
-    Mockito.doReturn(Arrays.asList(r1, r2)).when(rs).getRegions();
+    doReturn(Arrays.asList(r1, r2)).when(rs).getRegions();
     chore.chore();
   }
 
@@ -241,7 +241,7 @@ public class TestFileSystemUtilizationChore {
 
     final Region r1 = mockRegionWithSize(r1Sizes);
     final Region r2 = mockRegionReplicaWithSize(r2Sizes);
-    Mockito.doReturn(Arrays.asList(r1, r2)).when(rs).getRegions();
+    doReturn(Arrays.asList(r1, r2)).when(rs).getRegions();
     chore.chore();
   }
 
@@ -267,7 +267,7 @@ public class TestFileSystemUtilizationChore {
 
     final Region r1 = mockRegionWithHFileLinks(r1StoreFileSizes, r1HFileSizes);
     final Region r2 = mockRegionWithHFileLinks(r2StoreFileSizes, r2HFileSizes);
-    Mockito.doReturn(Arrays.asList(r1, r2)).when(rs).getRegions();
+    doReturn(Arrays.asList(r1, r2)).when(rs).getRegions();
     chore.chore();
   }
 

hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestMasterQuotasObserverWithMocks.java

@@ -22,7 +22,7 @@ import static org.apache.hadoop.hbase.quotas.MasterQuotasObserver.REMOVE_QUOTA_O
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.mock;
 

hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestNamespaceQuotaViolationStore.java

@@ -20,7 +20,7 @@ package org.apache.hadoop.hbase.quotas;
 import static org.apache.hbase.thirdparty.com.google.common.collect.Iterables.size;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 

hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestSpaceQuotaViolationPolicyRefresherChore.java

@@ -19,7 +19,7 @@ package org.apache.hadoop.hbase.quotas;
 
 import static org.apache.hadoop.hbase.util.Bytes.toBytes;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -68,7 +68,6 @@ public class TestSpaceQuotaViolationPolicyRefresherChore {
   private Configuration conf;
   private Connection conn;
 
-  @SuppressWarnings("unchecked")
   @Before
   public void setup() throws IOException {
     conf = HBaseConfiguration.create();

hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestTableQuotaViolationStore.java

@@ -20,7 +20,7 @@ package org.apache.hadoop.hbase.quotas;
 import static org.apache.hbase.thirdparty.com.google.common.collect.Iterables.size;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 

hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestTableSpaceQuotaViolationNotifier.java

@@ -17,7 +17,7 @@
  */
 package org.apache.hadoop.hbase.quotas;
 
-import static org.mockito.Matchers.argThat;
+import static org.mockito.ArgumentMatchers.argThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/StatefulStoreMockMaker.java

@@ -17,8 +17,8 @@
  */
 package org.apache.hadoop.hbase.regionserver;
 
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;

hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestFailedAppendAndSync.java

@@ -19,7 +19,11 @@ package org.apache.hadoop.hbase.regionserver;
 
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import java.io.IOException;
@@ -53,7 +57,6 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.junit.rules.TestName;
-import org.mockito.Mockito;
 import org.mockito.exceptions.verification.WantedButNotInvoked;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -246,8 +249,7 @@ public class TestFailedAppendAndSync {
       // to just continue.
 
       // So, should be no abort at this stage. Verify.
-      Mockito.verify(services, Mockito.atLeast(0)).abort(Mockito.anyString(),
+      verify(services, atLeast(0)).abort(anyString(), any(Throwable.class));
-        (Throwable) Mockito.anyObject());
       try {
         dodgyWAL.throwAppendException = false;
         dodgyWAL.throwSyncException = true;
@@ -262,8 +264,7 @@ public class TestFailedAppendAndSync {
       // happens. If it don't we'll timeout the whole test. That is fine.
       while (true) {
         try {
-          Mockito.verify(services, Mockito.atLeast(1)).abort(Mockito.anyString(),
+          verify(services, atLeast(1)).abort(anyString(), any(Throwable.class));
-            (Throwable) Mockito.anyObject());
           break;
         } catch (WantedButNotInvoked t) {
           Threads.sleep(1);
@@ -283,8 +284,7 @@ public class TestFailedAppendAndSync {
       while (true) {
         try {
           // one more abort needs to be called
-          Mockito.verify(services, Mockito.atLeast(2)).abort(Mockito.anyString(),
+          verify(services, atLeast(2)).abort(anyString(), any());
-            (Throwable) Mockito.anyObject());
           break;
         } catch (WantedButNotInvoked t) {
           Threads.sleep(1);
@@ -292,7 +292,7 @@ public class TestFailedAppendAndSync {
       }
     } finally {
       // To stop logRoller, its server has to say it is stopped.
-      Mockito.when(services.isStopped()).thenReturn(true);
+      when(services.isStopped()).thenReturn(true);
       if (logRoller != null) logRoller.close();
       if (region != null) {
         try {

hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java

@@ -32,7 +32,9 @@ import static org.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -185,7 +187,6 @@ import org.junit.rules.ExpectedException;
 import org.junit.rules.TestName;
 import org.mockito.ArgumentCaptor;
 import org.mockito.ArgumentMatcher;
-import org.mockito.Mockito;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.slf4j.Logger;
@@ -421,9 +422,8 @@ public class TestHRegion {
     long onePutSize = region.getMemStoreDataSize();
     assertTrue(onePutSize > 0);
 
-    RegionCoprocessorHost mockedCPHost = Mockito.mock(RegionCoprocessorHost.class);
+    RegionCoprocessorHost mockedCPHost = mock(RegionCoprocessorHost.class);
-    doThrow(new IOException()).when(mockedCPHost)
+    doThrow(new IOException()).when(mockedCPHost).postBatchMutate(any());
-      .postBatchMutate(Mockito.<MiniBatchOperationInProgress<Mutation>> any());
     region.setCoprocessorHost(mockedCPHost);
 
     put = new Put(value);
@@ -3390,25 +3390,24 @@ public class TestHRegion {
     final long initSize = region.getDataInMemoryWithoutWAL();
     // save normalCPHost and replaced by mockedCPHost
     RegionCoprocessorHost normalCPHost = region.getCoprocessorHost();
-    RegionCoprocessorHost mockedCPHost = Mockito.mock(RegionCoprocessorHost.class);
+    RegionCoprocessorHost mockedCPHost = mock(RegionCoprocessorHost.class);
     // Because the preBatchMutate returns void, we can't do usual Mockito when...then form. Must
     // do below format (from Mockito doc).
-    Mockito.doAnswer(new Answer() {
+    doAnswer(new Answer<Void>() {
       @Override
-      public Object answer(InvocationOnMock invocation) throws Throwable {
+      public Void answer(InvocationOnMock invocation) throws Throwable {
         MiniBatchOperationInProgress<Mutation> mb = invocation.getArgument(0);
         mb.addOperationsFromCP(0, new Mutation[] { addPut });
         return null;
       }
-    }).when(mockedCPHost).preBatchMutate(Mockito.isA(MiniBatchOperationInProgress.class));
+    }).when(mockedCPHost).preBatchMutate(isA(MiniBatchOperationInProgress.class));
     ColumnFamilyDescriptorBuilder builder =
       ColumnFamilyDescriptorBuilder.newBuilder(COLUMN_FAMILY_BYTES);
     ScanInfo info = new ScanInfo(CONF, builder.build(), Long.MAX_VALUE, Long.MAX_VALUE,
       region.getCellComparator());
-    Mockito.when(mockedCPHost.preFlushScannerOpen(Mockito.any(HStore.class), Mockito.any()))
+    when(mockedCPHost.preFlushScannerOpen(any(HStore.class), any())).thenReturn(info);
-      .thenReturn(info);
+
-    Mockito
+    when(mockedCPHost.preFlush(any(), any(StoreScanner.class), any()))
-      .when(mockedCPHost.preFlush(Mockito.any(), Mockito.any(StoreScanner.class), Mockito.any()))
       .thenAnswer(i -> i.getArgument(1));
     region.setCoprocessorHost(mockedCPHost);
 
@@ -5107,8 +5106,8 @@ public class TestHRegion {
   public void testStatusSettingToAbortIfAnyExceptionDuringRegionInitilization() throws Exception {
     HRegionInfo info;
     try {
-      FileSystem fs = Mockito.mock(FileSystem.class);
+      FileSystem fs = mock(FileSystem.class);
-      Mockito.when(fs.exists((Path) Mockito.anyObject())).thenThrow(new IOException());
+      when(fs.exists(any())).thenThrow(new IOException());
       HTableDescriptor htd = new HTableDescriptor(tableName);
       htd.addFamily(new HColumnDescriptor("cf"));
       info = new HRegionInfo(htd.getTableName(), HConstants.EMPTY_BYTE_ARRAY,

hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerRegionSpaceUseReport.java

@@ -20,8 +20,8 @@ package org.apache.hadoop.hbase.regionserver;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.mock;
 

hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSplitWalDataLoss.java

@@ -19,11 +19,11 @@ package org.apache.hadoop.hbase.regionserver;
 
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.spy;
 
 import java.io.IOException;
-import java.util.Collection;
 import java.util.Map;
 import org.apache.commons.lang3.mutable.MutableBoolean;
 import org.apache.hadoop.hbase.DroppedSnapshotException;
@@ -40,19 +40,15 @@ import org.apache.hadoop.hbase.client.Put;
 import org.apache.hadoop.hbase.client.Result;
 import org.apache.hadoop.hbase.client.Table;
 import org.apache.hadoop.hbase.client.TableDescriptorBuilder;
-import org.apache.hadoop.hbase.monitoring.MonitoredTask;
 import org.apache.hadoop.hbase.regionserver.HRegion.FlushResult;
-import org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult;
 import org.apache.hadoop.hbase.testclassification.LargeTests;
 import org.apache.hadoop.hbase.util.Bytes;
 import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
-import org.apache.hadoop.hbase.wal.WAL;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.ClassRule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
-import org.mockito.Matchers;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.slf4j.Logger;
@@ -120,9 +116,7 @@ public class TestSplitWalDataLoss {
           .abortCacheFlush(region.getRegionInfo().getEncodedNameAsBytes());
         throw new DroppedSnapshotException("testcase");
       }
-    }).when(spiedRegion).internalFlushCacheAndCommit(Matchers.<WAL> any(),
+    }).when(spiedRegion).internalFlushCacheAndCommit(any(), any(), any(), any());
-      Matchers.<MonitoredTask> any(), Matchers.<PrepareFlushResult> any(),
-      Matchers.<Collection<HStore>> any());
     // Find region key; don't pick up key for hbase:meta by mistake.
     String key = null;
     for (Map.Entry<String, HRegion> entry : rs.getOnlineRegions().entrySet()) {

hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestCompactor.java

@@ -25,10 +25,10 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.ArgumentMatchers.anyCollection;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.Matchers.anyBoolean;
-import static org.mockito.Matchers.anyLong;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;

hbase-server/src/test/java/org/apache/hadoop/hbase/util/compaction/TestMajorCompactionRequest.java

@@ -21,8 +21,8 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.isA;
-import static org.mockito.Matchers.anyString;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;

pom.xml

@@ -589,7 +589,7 @@
     <opentelemetry.version>1.15.0</opentelemetry.version>
     <opentelemetry-javaagent.version>1.15.0</opentelemetry-javaagent.version>
     <log4j2.version>2.17.2</log4j2.version>
-    <mockito-core.version>2.28.2</mockito-core.version>
+    <mockito.version>4.11.0</mockito.version>
     <!--Internally we use a different version of protobuf. See hbase-protocol-shaded-->
     <external.protobuf.groupid>com.google.protobuf</external.protobuf.groupid>
     <external.protobuf.version>2.5.0</external.protobuf.version>
@@ -1331,9 +1331,10 @@
       </dependency>
       <dependency>
         <groupId>org.mockito</groupId>
-        <artifactId>mockito-core</artifactId>
+        <artifactId>mockito-bom</artifactId>
-        <version>${mockito-core.version}</version>
+        <version>${mockito.version}</version>
-        <scope>test</scope>
+        <type>pom</type>
+        <scope>import</scope>
       </dependency>
       <dependency>
         <groupId>io.opentelemetry</groupId>