all: Update to Mockito 2

This is the public port of cl/238445847

Fixes #5319

alts/src/test/java/io/grpc/alts/internal/AltsHandshakerClientTest.java

@@ -36,7 +36,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 
 /** Unit tests for {@link AltsHandshakerClient}. */
 @RunWith(JUnit4.class)
@@ -64,7 +64,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void startClientHandshakeFailure() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getErrorResponse());
 
     try {
@@ -77,7 +77,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void startClientHandshakeSuccess() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getOkResponse(0));
 
     ByteBuffer outFrame = handshaker.startClientHandshake();
@@ -90,7 +90,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void startClientHandshakeWithOptions() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getOkResponse(0));
 
     ByteBuffer outFrame = handshaker.startClientHandshake();
@@ -113,7 +113,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void startServerHandshakeFailure() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getErrorResponse());
 
     try {
@@ -127,7 +127,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void startServerHandshakeSuccess() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getOkResponse(BYTES_CONSUMED));
 
     ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
@@ -142,7 +142,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void startServerHandshakeEmptyOutFrame() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getEmptyOutFrameResponse(BYTES_CONSUMED));
 
     ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
@@ -157,7 +157,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void startServerHandshakeWithPrefixBuffer() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getOkResponse(BYTES_CONSUMED));
 
     ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
@@ -174,7 +174,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void nextFailure() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getErrorResponse());
 
     try {
@@ -188,7 +188,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void nextSuccess() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getOkResponse(BYTES_CONSUMED));
 
     ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
@@ -203,7 +203,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void nextEmptyOutFrame() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getEmptyOutFrameResponse(BYTES_CONSUMED));
 
     ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
@@ -218,7 +218,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void nextFinished() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getFinishedResponse(BYTES_CONSUMED));
 
     ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
@@ -232,7 +232,7 @@ public class AltsHandshakerClientTest {
 
   @Test
   public void setRpcVersions() throws Exception {
-    when(mockStub.send(Matchers.<HandshakerReq>any()))
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
         .thenReturn(MockAltsHandshakerResp.getOkResponse(0));
 
     RpcProtocolVersions rpcVersions =

alts/src/test/java/io/grpc/alts/internal/AltsTsiHandshakerTest.java

@@ -31,7 +31,7 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 
 /** Unit tests for {@link AltsTsiHandshaker}. */
 @RunWith(JUnit4.class)
@@ -98,8 +98,8 @@ public class AltsTsiHandshakerTest {
   @Test
   public void processBytesFromPeerFalseStart() throws Exception {
     verify(mockClient, never()).startClientHandshake();
-    verify(mockClient, never()).startServerHandshake(Matchers.<ByteBuffer>any());
+    verify(mockClient, never()).startServerHandshake(ArgumentMatchers.<ByteBuffer>any());
-    verify(mockClient, never()).next(Matchers.<ByteBuffer>any());
+    verify(mockClient, never()).next(ArgumentMatchers.<ByteBuffer>any());
 
     ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
     assertTrue(handshakerClient.processBytesFromPeer(transportBuffer));
@@ -110,7 +110,7 @@ public class AltsTsiHandshakerTest {
     ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
     ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
     verify(mockServer, never()).startClientHandshake();
-    verify(mockServer, never()).next(Matchers.<ByteBuffer>any());
+    verify(mockServer, never()).next(ArgumentMatchers.<ByteBuffer>any());
     // Mock transport buffer all consumed by processBytesFromPeer and there is an output frame.
     transportBuffer.position(transportBuffer.limit());
     when(mockServer.startServerHandshake(transportBuffer)).thenReturn(outputFrame);
@@ -124,7 +124,7 @@ public class AltsTsiHandshakerTest {
     ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
     ByteBuffer emptyOutputFrame = ByteBuffer.allocate(0);
     verify(mockServer, never()).startClientHandshake();
-    verify(mockServer, never()).next(Matchers.<ByteBuffer>any());
+    verify(mockServer, never()).next(ArgumentMatchers.<ByteBuffer>any());
     // Mock transport buffer all consumed by processBytesFromPeer and output frame is empty.
     // Expect processBytesFromPeer return False, because more data are needed from the peer.
     transportBuffer.position(transportBuffer.limit());
@@ -139,7 +139,7 @@ public class AltsTsiHandshakerTest {
     ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
     ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
     verify(mockServer, never()).startClientHandshake();
-    verify(mockServer, never()).next(Matchers.<ByteBuffer>any());
+    verify(mockServer, never()).next(ArgumentMatchers.<ByteBuffer>any());
     // Mock handshake complete after processBytesFromPeer.
     when(mockServer.startServerHandshake(transportBuffer)).thenReturn(outputFrame);
     when(mockServer.isFinished()).thenReturn(true);
@@ -152,7 +152,7 @@ public class AltsTsiHandshakerTest {
     ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
     ByteBuffer emptyOutputFrame = ByteBuffer.allocate(0);
     verify(mockServer, never()).startClientHandshake();
-    verify(mockServer, never()).next(Matchers.<ByteBuffer>any());
+    verify(mockServer, never()).next(ArgumentMatchers.<ByteBuffer>any());
     when(mockServer.startServerHandshake(transportBuffer)).thenReturn(emptyOutputFrame);
     when(mockServer.isFinished()).thenReturn(false);
 
@@ -168,7 +168,7 @@ public class AltsTsiHandshakerTest {
   public void processBytesFromPeerClientNext() throws Exception {
     ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
     ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
-    verify(mockClient, never()).startServerHandshake(Matchers.<ByteBuffer>any());
+    verify(mockClient, never()).startServerHandshake(ArgumentMatchers.<ByteBuffer>any());
     when(mockClient.startClientHandshake()).thenReturn(outputFrame);
     when(mockClient.next(transportBuffer)).thenReturn(outputFrame);
     when(mockClient.isFinished()).thenReturn(false);
@@ -182,7 +182,7 @@ public class AltsTsiHandshakerTest {
   public void processBytesFromPeerClientNextFinished() throws Exception {
     ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
     ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
-    verify(mockClient, never()).startServerHandshake(Matchers.<ByteBuffer>any());
+    verify(mockClient, never()).startServerHandshake(ArgumentMatchers.<ByteBuffer>any());
     when(mockClient.startClientHandshake()).thenReturn(outputFrame);
     when(mockClient.next(transportBuffer)).thenReturn(outputFrame);
     when(mockClient.isFinished()).thenReturn(true);
@@ -243,7 +243,8 @@ public class AltsTsiHandshakerTest {
   public void extractServerPeerSuccess() throws Exception {
     ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
     ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
-    when(mockServer.startServerHandshake(Matchers.<ByteBuffer>any())).thenReturn(outputFrame);
+    when(mockServer.startServerHandshake(ArgumentMatchers.<ByteBuffer>any()))
+        .thenReturn(outputFrame);
     when(mockServer.isFinished()).thenReturn(true);
     when(mockServer.getResult()).thenReturn(getHandshakerResult(/* isClient = */ false));
 

auth/src/test/java/io/grpc/auth/ClientAuthInterceptorTest.java

@@ -18,9 +18,9 @@ package io.grpc.auth;
 
 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.Matchers.isA;
+import static org.mockito.ArgumentMatchers.isA;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

auth/src/test/java/io/grpc/auth/GoogleAuthLibraryCallCredentialsTest.java

@@ -21,8 +21,8 @@ import static org.junit.Assert.assertArrayEquals;
 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.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;

build.gradle

@@ -232,7 +232,7 @@ subprojects {
 
             // Test dependencies.
             junit: 'junit:junit:4.12',
-            mockito: 'org.mockito:mockito-core:1.10.19',
+            mockito: 'org.mockito:mockito-core:2.25.1',
             truth: 'com.google.truth:truth:0.42',
             guava_testlib: "com.google.guava:guava-testlib:${guavaVersion}",
 

context/src/test/java/io/grpc/DeadlineTest.java

@@ -22,7 +22,7 @@ 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.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 

core/src/test/java/io/grpc/ClientInterceptorsTest.java

@@ -24,9 +24,9 @@ import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.isA;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;

core/src/test/java/io/grpc/ServerInterceptorsTest.java

@@ -21,7 +21,7 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;

core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java

@@ -25,10 +25,10 @@ import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.Matchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -58,7 +58,7 @@ import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.junit.MockitoJUnit;
@@ -89,7 +89,7 @@ public class AbstractClientStreamTest {
         while (producer.next() != null) {}
         return null;
       }
-    }).when(mockListener).messagesAvailable(Matchers.<StreamListener.MessageProducer>any());
+    }).when(mockListener).messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
   }
 
   private final WritableBufferAllocator allocator = new WritableBufferAllocator() {
@@ -454,7 +454,7 @@ public class AbstractClientStreamTest {
     stream.start(mockListener);
 
     ArgumentCaptor<Metadata> headersCaptor = ArgumentCaptor.forClass(Metadata.class);
-    verify(sink).writeHeaders(headersCaptor.capture(), any(byte[].class));
+    verify(sink).writeHeaders(headersCaptor.capture(), ArgumentMatchers.<byte[]>any());
 
     Metadata headers = headersCaptor.getValue();
     assertTrue(headers.containsKey(GrpcUtil.TIMEOUT_KEY));

core/src/test/java/io/grpc/internal/AbstractServerStreamTest.java

@@ -19,11 +19,11 @@ package io.grpc.internal;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.Matchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;

core/src/test/java/io/grpc/internal/AbstractTransportTest.java

@@ -28,11 +28,11 @@ import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.junit.Assume.assumeTrue;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyBoolean;
-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.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -82,8 +82,8 @@ import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.InOrder;
-import org.mockito.Matchers;
 
 /** Standard unit tests for {@link ClientTransport}s and {@link ServerTransport}s. */
 @RunWith(JUnit4.class)
@@ -548,7 +548,7 @@ public abstract class AbstractTransportTest {
       // Transport doesn't support ping, so this neither passes nor fails.
       assumeTrue(false);
     }
-    verify(mockPingCallback, timeout(TIMEOUT_MS)).onSuccess(Matchers.anyLong());
+    verify(mockPingCallback, timeout(TIMEOUT_MS)).onSuccess(ArgumentMatchers.anyLong());
     verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
   }
 
@@ -570,7 +570,7 @@ public abstract class AbstractTransportTest {
       // Transport doesn't support ping, so this neither passes nor fails.
       assumeTrue(false);
     }
-    verify(mockPingCallback, timeout(TIMEOUT_MS)).onSuccess(Matchers.anyLong());
+    verify(mockPingCallback, timeout(TIMEOUT_MS)).onSuccess(ArgumentMatchers.anyLong());
     stream.cancel(Status.CANCELLED);
   }
 

core/src/test/java/io/grpc/internal/AutoConfiguredLoadBalancerFactoryTest.java

@@ -21,10 +21,10 @@ import static io.grpc.LoadBalancer.ATTR_LOAD_BALANCING_CONFIG;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-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.same;
+import static org.mockito.ArgumentMatchers.same;
-import static org.mockito.Matchers.startsWith;
+import static org.mockito.ArgumentMatchers.startsWith;
 import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.mock;

core/src/test/java/io/grpc/internal/CallCredentials2ApplyingTest.java

@@ -19,8 +19,8 @@ package io.grpc.internal;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;

core/src/test/java/io/grpc/internal/CallCredentialsApplyingTest.java

@@ -19,8 +19,8 @@ package io.grpc.internal;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;

core/src/test/java/io/grpc/internal/CensusModulesTest.java

@@ -27,11 +27,10 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 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.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.isNull;
+import static org.mockito.ArgumentMatchers.same;
-import static org.mockito.Matchers.same;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
@@ -91,6 +90,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
 import org.mockito.InOrder;
 import org.mockito.Mock;
@@ -197,10 +197,10 @@ public class CensusModulesTest {
   @SuppressWarnings("unchecked")
   public void setUp() throws Exception {
     when(spyClientSpanBuilder.startSpan()).thenReturn(spyClientSpan);
-    when(tracer.spanBuilderWithExplicitParent(anyString(), any(Span.class)))
+    when(tracer.spanBuilderWithExplicitParent(anyString(), ArgumentMatchers.<Span>any()))
         .thenReturn(spyClientSpanBuilder);
     when(spyServerSpanBuilder.startSpan()).thenReturn(spyServerSpan);
-    when(tracer.spanBuilderWithRemoteParent(anyString(), any(SpanContext.class)))
+    when(tracer.spanBuilderWithRemoteParent(anyString(), ArgumentMatchers.<SpanContext>any()))
         .thenReturn(spyServerSpanBuilder);
     when(mockTracingPropagationHandler.toByteArray(any(SpanContext.class)))
         .thenReturn(binarySpanContext);
@@ -313,7 +313,7 @@ public class CensusModulesTest {
       verify(spyClientSpanBuilder).setRecordEvents(eq(true));
     } else {
       verify(tracer).spanBuilderWithExplicitParent(
-          eq("Sent.package1.service2.method3"), isNull(Span.class));
+          eq("Sent.package1.service2.method3"), ArgumentMatchers.<Span>isNull());
       verify(spyClientSpanBuilder).setRecordEvents(eq(true));
     }
     verify(spyClientSpan, never()).end(any(EndSpanOptions.class));
@@ -511,7 +511,7 @@ public class CensusModulesTest {
     Metadata headers = new Metadata();
     ClientStreamTracer clientStreamTracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
     verify(tracer).spanBuilderWithExplicitParent(
-        eq("Sent.package1.service2.method3"), isNull(Span.class));
+        eq("Sent.package1.service2.method3"), ArgumentMatchers.<Span>isNull());
     verify(spyClientSpan, never()).end(any(EndSpanOptions.class));
 
     clientStreamTracer.outboundMessage(0);
@@ -760,7 +760,7 @@ public class CensusModulesTest {
     Metadata headers = new Metadata();
     callTracer.newClientStreamTracer(STREAM_INFO, headers);
     assertFalse(headers.containsKey(censusStats.statsHeader));
-    // Clear recorded stats to satisfy the assertions in wrapUp() 
+    // Clear recorded stats to satisfy the assertions in wrapUp()
     statsRecorder.rolloverRecords();
   }
 
@@ -875,7 +875,7 @@ public class CensusModulesTest {
     censusTracing.getServerTracerFactory().newServerStreamTracer(
         method.getFullMethodName(), headers);
     verify(tracer).spanBuilderWithRemoteParent(
-        eq("Recv.package1.service2.method3"), isNull(SpanContext.class));
+        eq("Recv.package1.service2.method3"), ArgumentMatchers.<SpanContext>isNull());
     verify(spyServerSpanBuilder).setRecordEvents(eq(true));
   }
 
@@ -1027,7 +1027,7 @@ public class CensusModulesTest {
         tracerFactory.newServerStreamTracer(method.getFullMethodName(), new Metadata());
     verifyZeroInteractions(mockTracingPropagationHandler);
     verify(tracer).spanBuilderWithRemoteParent(
-        eq("Recv.package1.service2.method3"), isNull(SpanContext.class));
+        eq("Recv.package1.service2.method3"), ArgumentMatchers.<SpanContext>isNull());
     verify(spyServerSpanBuilder).setRecordEvents(eq(true));
 
     Context filteredContext = serverStreamTracer.filterContext(Context.ROOT);

core/src/test/java/io/grpc/internal/ClientCallImplTest.java

@@ -25,9 +25,9 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 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.eq;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.timeout;
@@ -75,8 +75,8 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
-import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -163,7 +163,7 @@ public class ClientCallImplTest {
     streamListener.closed(status , new Metadata());
     executor.release();
 
-    verify(callListener).onClose(same(status), Matchers.isA(Metadata.class));
+    verify(callListener).onClose(same(status), ArgumentMatchers.isA(Metadata.class));
   }
 
   @Test
@@ -183,7 +183,7 @@ public class ClientCallImplTest {
     streamListener.headersRead(new Metadata());
 
     RuntimeException failure = new RuntimeException("bad");
-    doThrow(failure).when(callListener).onMessage(Matchers.<Void>any());
+    doThrow(failure).when(callListener).onMessage(ArgumentMatchers.<Void>any());
 
     /*
      * In unary calls, the server closes the call right after responding, so the onClose call is
@@ -196,7 +196,8 @@ public class ClientCallImplTest {
     streamListener.closed(Status.OK, new Metadata());
     executor.release();
 
-    verify(callListener).onClose(statusArgumentCaptor.capture(), Matchers.isA(Metadata.class));
+    verify(callListener).onClose(statusArgumentCaptor.capture(),
+        ArgumentMatchers.isA(Metadata.class));
     Status callListenerStatus = statusArgumentCaptor.getValue();
     assertThat(callListenerStatus.getCode()).isEqualTo(Status.Code.CANCELLED);
     assertThat(callListenerStatus.getCause()).isSameAs(failure);
@@ -231,7 +232,8 @@ public class ClientCallImplTest {
     streamListener.closed(Status.OK, new Metadata());
     executor.release();
 
-    verify(callListener).onClose(statusArgumentCaptor.capture(), Matchers.isA(Metadata.class));
+    verify(callListener).onClose(statusArgumentCaptor.capture(),
+        ArgumentMatchers.isA(Metadata.class));
     Status callListenerStatus = statusArgumentCaptor.getValue();
     assertThat(callListenerStatus.getCode()).isEqualTo(Status.Code.CANCELLED);
     assertThat(callListenerStatus.getCause()).isSameAs(failure);
@@ -266,7 +268,8 @@ public class ClientCallImplTest {
     streamListener.closed(Status.OK, new Metadata());
     executor.release();
 
-    verify(callListener).onClose(statusArgumentCaptor.capture(), Matchers.isA(Metadata.class));
+    verify(callListener).onClose(statusArgumentCaptor.capture(),
+        ArgumentMatchers.isA(Metadata.class));
     Status callListenerStatus = statusArgumentCaptor.getValue();
     assertThat(callListenerStatus.getCode()).isEqualTo(Status.Code.CANCELLED);
     assertThat(callListenerStatus.getCause()).isSameAs(failure);

core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java

@@ -21,8 +21,8 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;

core/src/test/java/io/grpc/internal/DelayedStreamTest.java

@@ -20,9 +20,9 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 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.eq;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;

core/src/test/java/io/grpc/internal/DnsNameResolverTest.java

@@ -24,7 +24,8 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 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.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -82,8 +83,8 @@ import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
-import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -290,7 +291,7 @@ public class DnsNameResolverTest {
 
     DnsNameResolver resolver = newResolver(name, 81, isAndroid);
     AddressResolver mockResolver = mock(AddressResolver.class);
-    when(mockResolver.resolveAddress(Matchers.anyString())).thenReturn(answer1).thenReturn(answer2);
+    when(mockResolver.resolveAddress(anyString())).thenReturn(answer1).thenReturn(answer2);
     resolver.setAddressResolver(mockResolver);
 
     resolver.start(mockListener);
@@ -307,7 +308,7 @@ public class DnsNameResolverTest {
 
     resolver.shutdown();
 
-    verify(mockResolver, times(2)).resolveAddress(Matchers.anyString());
+    verify(mockResolver, times(2)).resolveAddress(anyString());
   }
 
   @Test
@@ -340,7 +341,7 @@ public class DnsNameResolverTest {
     DnsNameResolver resolver =
         newResolver(name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(fakeTicker));
     AddressResolver mockResolver = mock(AddressResolver.class);
-    when(mockResolver.resolveAddress(Matchers.anyString()))
+    when(mockResolver.resolveAddress(anyString()))
         .thenReturn(answer1)
         .thenThrow(new AssertionError("should not called twice"));
     resolver.setAddressResolver(mockResolver);
@@ -359,7 +360,7 @@ public class DnsNameResolverTest {
 
     resolver.shutdown();
 
-    verify(mockResolver).resolveAddress(Matchers.anyString());
+    verify(mockResolver).resolveAddress(anyString());
   }
 
   @Test
@@ -373,7 +374,7 @@ public class DnsNameResolverTest {
     DnsNameResolver resolver =
         newResolver(name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(fakeTicker));
     AddressResolver mockResolver = mock(AddressResolver.class);
-    when(mockResolver.resolveAddress(Matchers.anyString()))
+    when(mockResolver.resolveAddress(anyString()))
         .thenReturn(answer)
         .thenThrow(new AssertionError("should not reach here."));
     resolver.setAddressResolver(mockResolver);
@@ -393,7 +394,7 @@ public class DnsNameResolverTest {
 
     resolver.shutdown();
 
-    verify(mockResolver).resolveAddress(Matchers.anyString());
+    verify(mockResolver).resolveAddress(anyString());
   }
 
   @Test
@@ -408,7 +409,8 @@ public class DnsNameResolverTest {
     DnsNameResolver resolver =
         newResolver(name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(fakeTicker));
     AddressResolver mockResolver = mock(AddressResolver.class);
-    when(mockResolver.resolveAddress(Matchers.anyString())).thenReturn(answer1).thenReturn(answer2);
+    when(mockResolver.resolveAddress(anyString())).thenReturn(answer1)
+        .thenReturn(answer2);
     resolver.setAddressResolver(mockResolver);
 
     resolver.start(mockListener);
@@ -426,7 +428,7 @@ public class DnsNameResolverTest {
 
     resolver.shutdown();
 
-    verify(mockResolver, times(2)).resolveAddress(Matchers.anyString());
+    verify(mockResolver, times(2)).resolveAddress(anyString());
   }
 
   @Test
@@ -450,7 +452,7 @@ public class DnsNameResolverTest {
     DnsNameResolver resolver =
         newResolver(name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(fakeTicker));
     AddressResolver mockResolver = mock(AddressResolver.class);
-    when(mockResolver.resolveAddress(Matchers.anyString())).thenReturn(answer1).thenReturn(answer2);
+    when(mockResolver.resolveAddress(anyString())).thenReturn(answer1).thenReturn(answer2);
     resolver.setAddressResolver(mockResolver);
 
     resolver.start(mockListener);
@@ -474,7 +476,7 @@ public class DnsNameResolverTest {
 
     resolver.shutdown();
 
-    verify(mockResolver, times(2)).resolveAddress(Matchers.anyString());
+    verify(mockResolver, times(2)).resolveAddress(anyString());
   }
 
   @Test
@@ -483,7 +485,7 @@ public class DnsNameResolverTest {
     final Inet4Address backendAddr = InetAddresses.fromInteger(0x7f000001);
 
     AddressResolver mockResolver = mock(AddressResolver.class);
-    when(mockResolver.resolveAddress(Matchers.anyString()))
+    when(mockResolver.resolveAddress(anyString()))
         .thenReturn(Collections.<InetAddress>singletonList(backendAddr));
     ResourceResolver resourceResolver = null;
     boolean resovleSrv = true;
@@ -502,7 +504,7 @@ public class DnsNameResolverTest {
     final String hostname = "addr.fake";
 
     AddressResolver mockResolver = mock(AddressResolver.class);
-    when(mockResolver.resolveAddress(Matchers.anyString()))
+    when(mockResolver.resolveAddress(anyString()))
         .thenThrow(new IOException("no addr"));
     ResourceResolver resourceResolver = null;
     boolean resovleSrv = true;
@@ -521,12 +523,12 @@ public class DnsNameResolverTest {
     final EquivalentAddressGroup balancerAddr = new EquivalentAddressGroup(new SocketAddress() {});
 
     AddressResolver mockAddressResolver = mock(AddressResolver.class);
-    when(mockAddressResolver.resolveAddress(Matchers.anyString()))
+    when(mockAddressResolver.resolveAddress(anyString()))
         .thenReturn(Collections.<InetAddress>singletonList(backendAddr));
     ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
-    when(mockResourceResolver.resolveTxt(Matchers.anyString()))
+    when(mockResourceResolver.resolveTxt(anyString()))
         .thenReturn(Collections.singletonList("service config"));
-    when(mockResourceResolver.resolveSrv(Matchers.any(AddressResolver.class), Matchers.anyString()))
+    when(mockResourceResolver.resolveSrv(ArgumentMatchers.any(AddressResolver.class), anyString()))
         .thenReturn(Collections.singletonList(balancerAddr));
     boolean resovleSrv = true;
     boolean resolveTxt = true;
@@ -547,12 +549,12 @@ public class DnsNameResolverTest {
     EquivalentAddressGroup balancerAddr = new EquivalentAddressGroup(new SocketAddress() {});
 
     AddressResolver mockAddressResolver = mock(AddressResolver.class);
-    when(mockAddressResolver.resolveAddress(Matchers.anyString()))
+    when(mockAddressResolver.resolveAddress(anyString()))
         .thenThrow(new UnknownHostException("I really tried"));
     ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
-    when(mockResourceResolver.resolveTxt(Matchers.anyString()))
+    when(mockResourceResolver.resolveTxt(anyString()))
         .thenReturn(Collections.<String>emptyList());
-    when(mockResourceResolver.resolveSrv(Matchers.any(AddressResolver.class), Matchers.anyString()))
+    when(mockResourceResolver.resolveSrv(ArgumentMatchers.any(AddressResolver.class), anyString()))
         .thenReturn(Collections.singletonList(balancerAddr));
     boolean resovleSrv = true;
     boolean resolveTxt = true;
@@ -572,12 +574,12 @@ public class DnsNameResolverTest {
     final String hostname = "addr.fake";
     final Inet4Address backendAddr = InetAddresses.fromInteger(0x7f000001);
     AddressResolver mockAddressResolver = mock(AddressResolver.class);
-    when(mockAddressResolver.resolveAddress(Matchers.anyString()))
+    when(mockAddressResolver.resolveAddress(anyString()))
         .thenReturn(Collections.<InetAddress>singletonList(backendAddr));
     ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
-    when(mockResourceResolver.resolveTxt(Matchers.anyString()))
+    when(mockResourceResolver.resolveTxt(anyString()))
         .thenReturn(Collections.singletonList("service config"));
-    when(mockResourceResolver.resolveSrv(Matchers.any(AddressResolver.class), Matchers.anyString()))
+    when(mockResourceResolver.resolveSrv(ArgumentMatchers.any(AddressResolver.class), anyString()))
         .thenThrow(new Exception("something like javax.naming.NamingException"));
     boolean resovleSrv = true;
     boolean resolveTxt = true;
@@ -628,7 +630,7 @@ public class DnsNameResolverTest {
     DnsNameResolver resolver =
         newResolver(name, port, alwaysDetectProxy, Stopwatch.createUnstarted());
     AddressResolver mockAddressResolver = mock(AddressResolver.class);
-    when(mockAddressResolver.resolveAddress(Matchers.anyString())).thenThrow(new AssertionError());
+    when(mockAddressResolver.resolveAddress(anyString())).thenThrow(new AssertionError());
     resolver.setAddressResolver(mockAddressResolver);
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());

core/src/test/java/io/grpc/internal/FailingClientStreamTest.java

@@ -16,8 +16,8 @@
 
 package io.grpc.internal;
 
-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.Mockito.mock;
 import static org.mockito.Mockito.verify;
 

core/src/test/java/io/grpc/internal/FailingClientTransportTest.java

@@ -16,8 +16,8 @@
 
 package io.grpc.internal;
 
-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.Mockito.mock;
 import static org.mockito.Mockito.verify;
 

core/src/test/java/io/grpc/internal/ForwardingClientStreamListenerTest.java

@@ -16,7 +16,7 @@
 
 package io.grpc.internal;
 
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 

core/src/test/java/io/grpc/internal/ForwardingClientStreamTest.java

@@ -18,7 +18,7 @@ package io.grpc.internal;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -64,7 +64,7 @@ public class ForwardingClientStreamTest {
 
   @Test
   public void writeMessageTest() {
-    InputStream is = mock(InputStream.class); 
+    InputStream is = mock(InputStream.class);
     forward.writeMessage(is);
     verify(mock).writeMessage(same(is));
   }

core/src/test/java/io/grpc/internal/ForwardingManagedChannelTest.java

@@ -17,8 +17,8 @@
 package io.grpc.internal;
 
 import static org.junit.Assert.assertSame;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

core/src/test/java/io/grpc/internal/GrpcUtilTest.java

@@ -22,8 +22,8 @@ import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 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.Mockito.mock;
 import static org.mockito.Mockito.verify;
 

core/src/test/java/io/grpc/internal/HedgingPolicyTest.java

@@ -20,7 +20,7 @@ import static com.google.common.truth.Truth.assertThat;
 import static io.grpc.internal.ServiceConfigInterceptor.HEDGING_POLICY_KEY;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 

core/src/test/java/io/grpc/internal/Http2ClientStreamTransportStateTest.java

@@ -21,8 +21,8 @@ import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
 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.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
@@ -37,8 +37,8 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
-import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.junit.MockitoJUnit;
@@ -71,7 +71,7 @@ public class Http2ClientStreamTransportStateTest {
         while (producer.next() != null) {}
         return null;
       }
-    }).when(mockListener).messagesAvailable(Matchers.<StreamListener.MessageProducer>any());
+    }).when(mockListener).messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
   }
 
   @Test

core/src/test/java/io/grpc/internal/InternalSubchannelTest.java

@@ -28,10 +28,10 @@ import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 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.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;

core/src/test/java/io/grpc/internal/KeepAliveManagerTest.java

@@ -18,7 +18,7 @@ package io.grpc.internal;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;

core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java

@@ -23,9 +23,9 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-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.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;

core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java

@@ -33,11 +33,10 @@ import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyObject;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.same;
-import static org.mockito.Matchers.same;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
@@ -140,9 +139,9 @@ import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
 import org.mockito.InOrder;
-import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.junit.MockitoJUnit;
@@ -402,7 +401,7 @@ public class ManagedChannelImplTest {
             .build());
     createChannel();
     verify(executorPool).getObject();
-    verify(executorPool, never()).returnObject(anyObject());
+    verify(executorPool, never()).returnObject(any());
     channel.shutdown();
     assertTrue(channel.isShutdown());
     assertTrue(channel.isTerminated());
@@ -625,7 +624,7 @@ public class ManagedChannelImplTest {
     // Killing the remaining real transport will terminate the channel
     transportListener.transportShutdown(Status.UNAVAILABLE);
     assertFalse(channel.isTerminated());
-    verify(executorPool, never()).returnObject(anyObject());
+    verify(executorPool, never()).returnObject(any());
     transportListener.transportTerminated();
     assertTrue(channel.isTerminated());
     verify(executorPool).returnObject(executor.getScheduledExecutorService());
@@ -978,7 +977,7 @@ public class ManagedChannelImplTest {
 
     verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
     doThrow(ex).when(mockLoadBalancer).handleResolvedAddressGroups(
-        Matchers.<List<EquivalentAddressGroup>>anyObject(), any(Attributes.class));
+        ArgumentMatchers.<List<EquivalentAddressGroup>>any(), any(Attributes.class));
 
     // NameResolver returns addresses.
     nameResolverFactory.allResolved();
@@ -1694,7 +1693,7 @@ public class ManagedChannelImplTest {
       Subchannel subchannel = createSubchannelSafely(helper, addressGroup, Attributes.EMPTY);
       subchannel.requestConnection();
     }
-    
+
     MockClientTransportInfo transportInfo = transports.poll();
     assertNotNull(transportInfo);
 
@@ -3214,7 +3213,7 @@ public class ManagedChannelImplTest {
       @Override
       public void shutdown() {}
     }
-    
+
     final class FakeNameResolverFactory extends NameResolver.Factory {
       FakeNameResolver resolver;
 
@@ -3229,7 +3228,7 @@ public class ManagedChannelImplTest {
         return "fake";
       }
     }
-    
+
     FakeNameResolverFactory factory = new FakeNameResolverFactory();
     final class CustomBuilder extends AbstractManagedChannelImplBuilder<CustomBuilder> {
 

core/src/test/java/io/grpc/internal/MessageDeframerTest.java

@@ -22,7 +22,7 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assume.assumeTrue;
-import static org.mockito.Matchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.doAnswer;
@@ -62,7 +62,7 @@ import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameter;
 import org.junit.runners.Parameterized.Parameters;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
@@ -321,7 +321,7 @@ public class MessageDeframerTest {
             }
           })
           .when(listener)
-          .messagesAvailable(Matchers.<StreamListener.MessageProducer>any());
+          .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
       deframer.deframe(buffer(new byte[]{0, 0, 0, 0, 1, 3}));
       deframer.closeWhenComplete();
       verifyNoMoreInteractions(listener);

core/src/test/java/io/grpc/internal/MessageFramerTest.java

@@ -20,7 +20,7 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;

core/src/test/java/io/grpc/internal/OverrideAuthorityNameResolverTest.java

@@ -18,7 +18,7 @@ package io.grpc.internal;
 
 import static junit.framework.TestCase.assertNotNull;
 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.verify;
 import static org.mockito.Mockito.when;

core/src/test/java/io/grpc/internal/PickFirstLoadBalancerTest.java

@@ -21,10 +21,9 @@ import static io.grpc.ConnectivityState.IDLE;
 import static io.grpc.ConnectivityState.READY;
 import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyListOf;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
-import static org.mockito.Matchers.isA;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
@@ -53,6 +52,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
 import org.mockito.InOrder;
 import org.mockito.Mock;
@@ -92,7 +92,7 @@ public class PickFirstLoadBalancerTest {
 
     when(mockSubchannel.getAllAddresses()).thenThrow(new UnsupportedOperationException());
     when(mockHelper.createSubchannel(
-        anyListOf(EquivalentAddressGroup.class), any(Attributes.class)))
+        ArgumentMatchers.<EquivalentAddressGroup>anyList(), any(Attributes.class)))
         .thenReturn(mockSubchannel);
 
     loadBalancer = new PickFirstLoadBalancer(mockHelper);
@@ -124,13 +124,13 @@ public class PickFirstLoadBalancerTest {
     loadBalancer.handleResolvedAddressGroups(servers, affinity);
     verifyNoMoreInteractions(mockSubchannel);
 
-    verify(mockHelper).createSubchannel(anyListOf(EquivalentAddressGroup.class),
+    verify(mockHelper).createSubchannel(ArgumentMatchers.<EquivalentAddressGroup>anyList(),
         any(Attributes.class));
     verify(mockHelper)
         .updateBalancingState(isA(ConnectivityState.class), isA(SubchannelPicker.class));
     // Updating the subchannel addresses is unnecessary, but doesn't hurt anything
     verify(mockHelper).updateSubchannelAddresses(
-        eq(mockSubchannel), anyListOf(EquivalentAddressGroup.class));
+        eq(mockSubchannel), ArgumentMatchers.<EquivalentAddressGroup>anyList());
 
     verifyNoMoreInteractions(mockHelper);
   }

core/src/test/java/io/grpc/internal/ProxyDetectorImplTest.java

@@ -22,8 +22,9 @@ 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.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -44,6 +45,8 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.mockito.AdditionalMatchers;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
@@ -192,12 +195,12 @@ public class ProxyDetectorImplTest {
         proxyUser,
         proxyPassword.toCharArray());
     when(authenticator.requestPasswordAuthentication(
-            any(String.class),
+            anyString(),
-            any(InetAddress.class),
+            ArgumentMatchers.<InetAddress>any(),
             anyInt(),
-            any(String.class),
+            anyString(),
-            any(String.class),
+            anyString(),
-            any(String.class)))
+            AdditionalMatchers.or(anyString(), ArgumentMatchers.<String>any())))
       .thenReturn(auth);
     when(proxySelector.select(any(URI.class))).thenReturn(ImmutableList.of(proxy));
 

core/src/test/java/io/grpc/internal/RetriableStreamTest.java

@@ -27,9 +27,9 @@ import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-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.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;

core/src/test/java/io/grpc/internal/RetryPolicyTest.java

@@ -21,7 +21,7 @@ import static io.grpc.internal.ServiceConfigInterceptor.RETRY_POLICY_KEY;
 import static java.lang.Double.parseDouble;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 

core/src/test/java/io/grpc/internal/ServerCallImplTest.java

@@ -21,9 +21,9 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 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.isA;
+import static org.mockito.ArgumentMatchers.isA;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;

core/src/test/java/io/grpc/internal/ServerImplTest.java

@@ -28,13 +28,11 @@ import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-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.Matchers.isA;
+import static org.mockito.ArgumentMatchers.isA;
-import static org.mockito.Matchers.isNotNull;
+import static org.mockito.ArgumentMatchers.same;
-import static org.mockito.Matchers.notNull;
-import static org.mockito.Matchers.same;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
@@ -107,8 +105,8 @@ import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
-import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
@@ -796,7 +794,7 @@ public class ServerImplTest {
 
     assertEquals(1, executor.runDueTasks());
     verify(fallbackRegistry).lookupMethod("Waiter/serve", AUTHORITY);
-    verify(stream).close(same(status), notNull(Metadata.class));
+    verify(stream).close(same(status), ArgumentMatchers.<Metadata>notNull());
     verify(stream, atLeast(1)).statsTraceContext();
   }
 
@@ -972,7 +970,7 @@ public class ServerImplTest {
     assertTrue(onCancelCalled.get());
 
     // Close should never be called if asserts in listener pass.
-    verify(stream, times(0)).close(isA(Status.class), isNotNull(Metadata.class));
+    verify(stream, times(0)).close(isA(Status.class), ArgumentMatchers.<Metadata>isNotNull());
   }
 
   private ServerStreamListener testClientClose_setup(
@@ -1123,8 +1121,8 @@ public class ServerImplTest {
     // This call will be handled by callHandler from the internal registry
     transportListener.streamCreated(stream, "Waiter/serve", requestHeaders);
     assertEquals(1, executor.runDueTasks());
-    verify(callHandler).startCall(Matchers.<ServerCall<String, Integer>>anyObject(),
+    verify(callHandler).startCall(ArgumentMatchers.<ServerCall<String, Integer>>any(),
-        Matchers.<Metadata>anyObject());
+        ArgumentMatchers.<Metadata>any());
     // This call will be handled by the fallbackRegistry because it's not registred in the internal
     // registry.
     transportListener.streamCreated(stream, "Service1/Method2", requestHeaders);

core/src/test/java/io/grpc/internal/ServiceConfigInterceptorTest.java

@@ -19,7 +19,7 @@ package io.grpc.internal;
 import static com.google.common.truth.Truth.assertThat;
 import static io.grpc.internal.ServiceConfigInterceptor.HEDGING_POLICY_KEY;
 import static io.grpc.internal.ServiceConfigInterceptor.RETRY_POLICY_KEY;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.verify;
 
 import io.grpc.CallOptions;

core/src/test/java/io/grpc/internal/SharedResourceHolderTest.java

@@ -23,8 +23,8 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 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.anyLong;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 

core/src/test/java/io/grpc/internal/TestUtils.java

@@ -16,7 +16,7 @@
 
 package io.grpc.internal;
 
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;

core/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java

@@ -30,9 +30,9 @@ import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 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.atLeast;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doReturn;
@@ -235,7 +235,7 @@ public class RoundRobinLoadBalancerTest {
 
     verify(newSubchannel, times(1)).requestConnection();
     verify(removedSubchannel, times(1)).shutdown();
-    
+
     loadBalancer.handleSubchannelState(removedSubchannel,
             ConnectivityStateInfo.forNonError(SHUTDOWN));
 
@@ -734,7 +734,7 @@ public class RoundRobinLoadBalancerTest {
 
     assertSame(stickinessMap1, stickinessMap2);
   }
-  
+
   @Test(expected = IllegalArgumentException.class)
   public void readyPicker_emptyList() {
     // ready picker list must be non-empty

cronet/build.gradle

@@ -45,6 +45,6 @@ dependencies {
     implementation "org.chromium.net:cronet-embedded:66.3359.158"
 
     testImplementation 'junit:junit:4.12'
-    testImplementation 'org.mockito:mockito-core:1.10.19'
+    testImplementation 'org.mockito:mockito-core:2.25.1'
     testImplementation "org.robolectric:robolectric:3.5.1"
 }

cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java

@@ -19,9 +19,9 @@ package io.grpc.cronet;
 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.atLeast;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;

examples/build.gradle

@@ -9,8 +9,7 @@ plugins {
 
 repositories {
     maven { // The google mirror is less flaky than mavenCentral()
-        url "https://maven-central.storage-download.googleapis.com/repos/central/data/"
+        url "https://maven-central.storage-download.googleapis.com/repos/central/data/" }
-    }
     mavenLocal()
 }
 
@@ -38,7 +37,7 @@ dependencies {
 
     testImplementation "io.grpc:grpc-testing:${grpcVersion}"
     testImplementation "junit:junit:4.12"
-    testImplementation "org.mockito:mockito-core:1.10.19"
+    testImplementation "org.mockito:mockito-core:2.25.1"
 }
 
 protobuf {

examples/example-gauth/pom.xml

@@ -84,7 +84,7 @@
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
-      <version>1.10.19</version>
+      <version>2.25.1</version>
       <scope>test</scope>
     </dependency>
   </dependencies>

examples/example-kotlin/build.gradle

@@ -35,7 +35,7 @@ dependencies {
 
     testImplementation "io.grpc:grpc-testing:${grpcVersion}" // gRCP testing utilities
     testImplementation "junit:junit:4.12"
-    testImplementation "org.mockito:mockito-core:1.10.19"
+    testImplementation "org.mockito:mockito-core:2.25.1"
 }
 
 protobuf {

examples/example-kotlin/src/test/kotlin/io/grpc/examples/helloworld/HelloWorldClientTest.kt

@@ -32,7 +32,7 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 import org.mockito.ArgumentCaptor
-import org.mockito.Matchers
+import org.mockito.ArgumentMatchers
 
 /**
  * Unit tests for [HelloWorldClient].
@@ -86,7 +86,7 @@ class HelloWorldClientTest {
         client!!.greet("test name")
 
         verify<GreeterGrpc.GreeterImplBase>(serviceImpl)
-                .sayHello(requestCaptor.capture(), Matchers.any<StreamObserver<HelloReply>>())
+                .sayHello(requestCaptor.capture(), ArgumentMatchers.any<StreamObserver<HelloReply>>())
         assertEquals("test name", requestCaptor.value.name)
     }
 }

examples/pom.xml

@@ -71,7 +71,7 @@
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
-      <version>1.10.19</version>
+      <version>2.25.1</version>
       <scope>test</scope>
     </dependency>
   </dependencies>

examples/src/test/java/io/grpc/examples/authentication/AuthClientTest.java

@@ -41,7 +41,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 
 /**
  * Unit tests for {@link AuthClient} testing the default and non-default tokens
@@ -104,9 +104,9 @@ public class AuthClientTest {
     String retVal = client.greet("default token test");
 
     verify(mockServerInterceptor).interceptCall(
-        Matchers.<ServerCall<HelloRequest, HelloReply>>any(),
+        ArgumentMatchers.<ServerCall<HelloRequest, HelloReply>>any(),
         metadataCaptor.capture(),
-        Matchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
+        ArgumentMatchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
     assertEquals(
         "my-default-token",
         metadataCaptor.getValue().get(Constant.JWT_METADATA_KEY));
@@ -124,9 +124,9 @@ public class AuthClientTest {
     String retVal = client.greet("non default token test");
 
     verify(mockServerInterceptor).interceptCall(
-        Matchers.<ServerCall<HelloRequest, HelloReply>>any(),
+        ArgumentMatchers.<ServerCall<HelloRequest, HelloReply>>any(),
         metadataCaptor.capture(),
-        Matchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
+        ArgumentMatchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
     assertEquals(
         "non-default-token",
         metadataCaptor.getValue().get(Constant.JWT_METADATA_KEY));

examples/src/test/java/io/grpc/examples/header/HeaderClientInterceptorTest.java

@@ -44,7 +44,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 
 /**
  * Unit tests for {@link HeaderClientInterceptor}.
@@ -95,9 +95,9 @@ public class HeaderClientInterceptorTest {
     }
 
     verify(mockServerInterceptor).interceptCall(
-        Matchers.<ServerCall<HelloRequest, HelloReply>>any(),
+        ArgumentMatchers.<ServerCall<HelloRequest, HelloReply>>any(),
         metadataCaptor.capture(),
-        Matchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
+        ArgumentMatchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
     assertEquals(
         "customRequestValue",
         metadataCaptor.getValue().get(HeaderClientInterceptor.CUSTOM_HEADER_KEY));

examples/src/test/java/io/grpc/examples/helloworld/HelloWorldClientTest.java

@@ -32,7 +32,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 
 /**
  * Unit tests for {@link HelloWorldClient}.
@@ -83,7 +83,7 @@ public class HelloWorldClientTest {
     client.greet("test name");
 
     verify(serviceImpl)
-        .sayHello(requestCaptor.capture(), Matchers.<StreamObserver<HelloReply>>any());
+        .sayHello(requestCaptor.capture(), ArgumentMatchers.<StreamObserver<HelloReply>>any());
     assertEquals("test name", requestCaptor.getValue().getName());
   }
 }

examples/src/test/java/io/grpc/examples/routeguide/RouteGuideClientTest.java

@@ -18,7 +18,7 @@ package io.grpc.examples.routeguide;
 
 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.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;

examples/src/test/java/io/grpc/examples/routeguide/RouteGuideServerTest.java

@@ -19,7 +19,7 @@ package io.grpc.examples.routeguide;
 import static junit.framework.TestCase.fail;
 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.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.timeout;

grpclb/src/test/java/io/grpc/grpclb/CachedSubchannelPoolTest.java

@@ -19,7 +19,7 @@ package io.grpc.grpclb;
 import static com.google.common.truth.Truth.assertThat;
 import static io.grpc.grpclb.CachedSubchannelPool.SHUTDOWN_TIMEOUT_MS;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.atMost;

grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java

@@ -31,10 +31,10 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-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.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.inOrder;
@@ -1687,7 +1687,7 @@ public class GrpclbLoadBalancerTest {
     // Fail the retry after spending 4ns
     fakeClock.forwardNanos(4);
     lbResponseObserver.onError(Status.UNAVAILABLE.asException());
-    
+
     // Will be on the first retry (10ns) of backoff sequence 2.
     inOrder.verify(backoffPolicy2).nextBackoffNanos();
     assertEquals(1, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
@@ -1996,7 +1996,7 @@ public class GrpclbLoadBalancerTest {
                 new EquivalentAddressGroup(backends1.get(0).addr, eagAttrsWithToken("token0001")),
                 new EquivalentAddressGroup(backends1.get(1).addr, eagAttrsWithToken("token0002")))),
         any(Attributes.class));
-    
+
     inOrder.verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
   }
 

grpclb/src/test/java/io/grpc/grpclb/TokenAttachingTracerFactoryTest.java

@@ -18,7 +18,7 @@ package io.grpc.grpclb;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 

interop-testing/src/test/java/io/grpc/stub/StubConfigTest.java

@@ -20,8 +20,8 @@ import static java.util.concurrent.TimeUnit.NANOSECONDS;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertNull;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 

netty/src/test/java/io/grpc/netty/MaxConnectionIdleManagerTest.java

@@ -16,8 +16,8 @@
 
 package io.grpc.netty;
 
-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.Mockito.never;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;

netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java

@@ -35,10 +35,9 @@ 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.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.notNull;
+import static org.mockito.ArgumentMatchers.same;
-import static org.mockito.Matchers.same;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -96,7 +95,7 @@ import org.junit.rules.TestName;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
@@ -157,7 +156,7 @@ public class NettyClientHandlerTest extends NettyHandlerTestBase<NettyClientHand
             }
           })
       .when(streamListener)
-      .messagesAvailable(Matchers.<StreamListener.MessageProducer>any());
+      .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
 
     lifecycleManager = new ClientTransportLifecycleManager(listener);
     // This mocks the keepalive manager only for there's in which we verify it. For other tests
@@ -380,7 +379,8 @@ public class NettyClientHandlerTest extends NettyHandlerTestBase<NettyClientHand
     // Read a GOAWAY that indicates our stream was never processed by the server.
     channelRead(goAwayFrame(0, 8 /* Cancel */, Unpooled.copiedBuffer("this is a test", UTF_8)));
     ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
-    verify(streamListener).closed(captor.capture(), same(REFUSED), notNull(Metadata.class));
+    verify(streamListener).closed(captor.capture(), same(REFUSED),
+        ArgumentMatchers.<Metadata>notNull());
     assertEquals(Status.CANCELLED.getCode(), captor.getValue().getCode());
     assertEquals("HTTP/2 error code: CANCEL\nReceived Goaway\nthis is a test",
         captor.getValue().getDescription());
@@ -487,7 +487,8 @@ public class NettyClientHandlerTest extends NettyHandlerTestBase<NettyClientHand
 
     handler().channelInactive(ctx());
     ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
-    verify(streamListener).closed(captor.capture(), same(PROCESSED), notNull(Metadata.class));
+    verify(streamListener).closed(captor.capture(), same(PROCESSED),
+        ArgumentMatchers.<Metadata>notNull());
     assertEquals(Status.UNAVAILABLE.getCode(), captor.getValue().getCode());
   }
 

netty/src/test/java/io/grpc/netty/NettyClientStreamTest.java

@@ -29,11 +29,11 @@ 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.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyBoolean;
-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.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -73,7 +73,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.invocation.InvocationOnMock;
@@ -124,7 +124,7 @@ public class NettyClientStreamTest extends NettyStreamTestBase<NettyClientStream
             }
           })
       .when(listener)
-      .messagesAvailable(Matchers.<StreamListener.MessageProducer>any());
+      .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
   }
 
   @Override

netty/src/test/java/io/grpc/netty/NettyHandlerTestBase.java

@@ -20,8 +20,8 @@ import static com.google.common.base.Charsets.UTF_8;
 import static io.netty.handler.codec.http2.Http2CodecUtil.DEFAULT_WINDOW_SIZE;
 import static org.junit.Assert.assertEquals;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-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.atLeastOnce;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;

netty/src/test/java/io/grpc/netty/NettyServerHandlerTest.java

@@ -36,12 +36,12 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-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.Matchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyLong;
-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.Matchers.isA;
+import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;

netty/src/test/java/io/grpc/netty/NettyServerStreamTest.java

@@ -20,9 +20,9 @@ import static com.google.common.truth.Truth.assertThat;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
 import static io.grpc.netty.NettyTestUtil.messageFrame;
 import static org.junit.Assert.assertNull;
-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.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.never;
@@ -54,7 +54,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
@@ -94,7 +94,7 @@ public class NettyServerStreamTest extends NettyStreamTestBase<NettyServerStream
             }
           })
       .when(serverListener)
-      .messagesAvailable(Matchers.<StreamListener.MessageProducer>any());
+      .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
   }
 
   @Test

netty/src/test/java/io/grpc/netty/NettyStreamTestBase.java

@@ -22,8 +22,8 @@ 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.ArgumentMatchers.any;
-import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;

netty/src/test/java/io/grpc/netty/ProtocolNegotiatorsTest.java

@@ -23,7 +23,7 @@ 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.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 
@@ -104,6 +104,7 @@ import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mockito;
 
 @RunWith(JUnit4.class)
@@ -470,7 +471,7 @@ public class ProtocolNegotiatorsTest {
     channel.eventLoop().submit(NOOP_RUNNABLE).sync();
     ArgumentCaptor<Object> objectCaptor = ArgumentCaptor.forClass(Object.class);
     Mockito.verify(mockHandler)
-        .channelRead(any(ChannelHandlerContext.class), objectCaptor.capture());
+        .channelRead(ArgumentMatchers.<ChannelHandlerContext>any(), objectCaptor.capture());
     ByteBuf b = (ByteBuf) objectCaptor.getValue();
     String request = b.toString(UTF_8);
     b.release();
@@ -483,9 +484,9 @@ public class ProtocolNegotiatorsTest {
     negotiationFuture.sync();
 
     channel.eventLoop().submit(NOOP_RUNNABLE).sync();
-    objectCaptor.getAllValues().clear();
+    objectCaptor = ArgumentCaptor.forClass(Object.class);
     Mockito.verify(mockHandler, times(2))
-        .channelRead(any(ChannelHandlerContext.class), objectCaptor.capture());
+        .channelRead(ArgumentMatchers.<ChannelHandlerContext>any(), objectCaptor.capture());
     b = (ByteBuf) objectCaptor.getAllValues().get(1);
     // If we were using the real grpcHandler, this would have been the HTTP/2 preface
     String preface = b.toString(UTF_8);

netty/src/test/java/io/grpc/netty/WriteQueueTest.java

@@ -17,9 +17,9 @@
 package io.grpc.netty;
 
 import static org.junit.Assert.fail;
-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.doAnswer;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;

okhttp/src/test/java/io/grpc/okhttp/AsyncSinkTest.java

@@ -18,9 +18,9 @@ package io.grpc.okhttp;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
-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.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.CALLS_REAL_METHODS;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.inOrder;

okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java

@@ -20,8 +20,8 @@ import static com.google.common.truth.Truth.assertThat;
 import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-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.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;

okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java

@@ -32,12 +32,12 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 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.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.Matchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyInt;
-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.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -119,8 +119,8 @@ import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.AdditionalAnswers;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.InOrder;
-import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
@@ -1178,7 +1178,7 @@ public class OkHttpClientTransportTest {
         clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT);
     stream.start(listener);
     verify(frameWriter, timeout(TIME_OUT_MS)).synStream(
-        eq(false), eq(false), eq(3), eq(0), Matchers.anyListOf(Header.class));
+        eq(false), eq(false), eq(3), eq(0), ArgumentMatchers.<Header>anyList());
     if (shouldBeFlushed) {
       verify(frameWriter, timeout(TIME_OUT_MS)).flush();
     } else {

services/src/test/java/io/grpc/services/BinlogHelperTest.java

@@ -27,11 +27,11 @@ import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 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.anyLong;
+import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Matchers.isNull;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -88,7 +88,9 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.mockito.AdditionalMatchers;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 
 /** Tests for {@link BinlogHelper}. */
 @RunWith(JUnit4.class)
@@ -960,12 +962,12 @@ public final class BinlogHelperTest {
     verify(mockSinkWriter).logClientHeader(
         /*seq=*/ eq(1L),
         eq("service/method"),
-        isNull(String.class),
+        ArgumentMatchers.<String>isNull(),
         timeoutCaptor.capture(),
         any(Metadata.class),
         eq(Logger.LOGGER_SERVER),
         eq(CALL_ID),
-        isNull(SocketAddress.class));
+        ArgumentMatchers.<SocketAddress>isNull());
     verifyNoMoreInteractions(mockSinkWriter);
     Duration timeout = timeoutCaptor.getValue();
     assertThat(TimeUnit.SECONDS.toNanos(1) - Durations.toNanos(timeout))
@@ -1008,13 +1010,14 @@ public final class BinlogHelperTest {
     verify(mockSinkWriter)
         .logClientHeader(
             anyLong(),
-            any(String.class),
+            AdditionalMatchers.or(ArgumentMatchers.<String>isNull(), anyString()),
-            any(String.class),
+            AdditionalMatchers.or(ArgumentMatchers.<String>isNull(), anyString()),
             callOptTimeoutCaptor.capture(),
             any(Metadata.class),
             any(GrpcLogEntry.Logger.class),
             anyLong(),
-            any(SocketAddress.class));
+            AdditionalMatchers.or(ArgumentMatchers.<SocketAddress>isNull(),
+                ArgumentMatchers.<SocketAddress>any()));
     Duration timeout = callOptTimeoutCaptor.getValue();
     assertThat(TimeUnit.SECONDS.toNanos(1) - Durations.toNanos(timeout))
         .isAtMost(TimeUnit.MILLISECONDS.toNanos(250));
@@ -1065,13 +1068,14 @@ public final class BinlogHelperTest {
     verify(mockSinkWriter)
         .logClientHeader(
             anyLong(),
-            any(String.class),
+            anyString(),
-            any(String.class),
+            ArgumentMatchers.<String>any(),
             callOptTimeoutCaptor.capture(),
             any(Metadata.class),
             any(GrpcLogEntry.Logger.class),
             anyLong(),
-            any(SocketAddress.class));
+            AdditionalMatchers.or(ArgumentMatchers.<SocketAddress>isNull(),
+                ArgumentMatchers.<SocketAddress>any()));
     Duration timeout = callOptTimeoutCaptor.getValue();
     assertThat(TimeUnit.SECONDS.toNanos(1) - Durations.toNanos(timeout))
         .isAtMost(TimeUnit.MILLISECONDS.toNanos(250));
@@ -1152,11 +1156,11 @@ public final class BinlogHelperTest {
           /*seq=*/ eq(1L),
           eq("service/method"),
           eq("the-authority"),
-          isNull(Duration.class),
+          ArgumentMatchers.<Duration>isNull(),
           same(clientInitial),
           eq(Logger.LOGGER_CLIENT),
           eq(CALL_ID),
-          isNull(SocketAddress.class));
+          ArgumentMatchers.<SocketAddress>isNull());
       verifyNoMoreInteractions(mockSinkWriter);
       assertSame(clientInitial, actualClientInitial.get());
     }
@@ -1228,7 +1232,7 @@ public final class BinlogHelperTest {
           same(trailers),
           eq(Logger.LOGGER_CLIENT),
           eq(CALL_ID),
-          isNull(SocketAddress.class));
+          ArgumentMatchers.<SocketAddress>isNull());
       verifyNoMoreInteractions(mockSinkWriter);
       verify(mockListener).onClose(same(status), same(trailers));
     }
@@ -1302,13 +1306,13 @@ public final class BinlogHelperTest {
     interceptedCall.start(mockListener, clientInitial);
     verify(mockSinkWriter).logClientHeader(
         /*seq=*/ eq(1L),
-        any(String.class),
+        anyString(),
-        any(String.class),
+        anyString(),
         any(Duration.class),
         any(Metadata.class),
         eq(Logger.LOGGER_CLIENT),
         eq(CALL_ID),
-        isNull(SocketAddress.class));
+        ArgumentMatchers.<SocketAddress>isNull());
     verifyNoMoreInteractions(mockSinkWriter);
 
     // trailer only response
@@ -1405,7 +1409,7 @@ public final class BinlogHelperTest {
           /*seq=*/ eq(1L),
           eq("service/method"),
           eq("the-authority"),
-          isNull(Duration.class),
+          ArgumentMatchers.<Duration>isNull(),
           same(clientInitial),
           eq(Logger.LOGGER_SERVER),
           eq(CALL_ID),
@@ -1422,7 +1426,7 @@ public final class BinlogHelperTest {
           same(serverInital),
           eq(Logger.LOGGER_SERVER),
           eq(CALL_ID),
-          isNull(SocketAddress.class));
+          ArgumentMatchers.<SocketAddress>isNull());
       verifyNoMoreInteractions(mockSinkWriter);
       assertSame(serverInital, actualServerInitial.get());
     }
@@ -1479,7 +1483,7 @@ public final class BinlogHelperTest {
           same(trailers),
           eq(Logger.LOGGER_SERVER),
           eq(CALL_ID),
-          isNull(SocketAddress.class));
+          ArgumentMatchers.<SocketAddress>isNull());
       verifyNoMoreInteractions(mockSinkWriter);
       assertSame(status, actualStatus.get());
       assertSame(trailers, actualTrailers.get());

services/src/test/java/io/grpc/services/HealthCheckingLoadBalancerFactoryTest.java

@@ -26,10 +26,9 @@ import static io.grpc.ConnectivityState.SHUTDOWN;
 import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
 import static org.junit.Assert.fail;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Matchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.same;
-import static org.mockito.Matchers.same;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
@@ -93,6 +92,7 @@ import org.mockito.Captor;
 import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.mockito.hamcrest.MockitoHamcrest;
 
 /** Tests for {@link HealthCheckingLoadBalancerFactory}. */
 @RunWith(JUnit4.class)
@@ -173,7 +173,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
       eagLists[i] = eagList;
     }
     resolvedAddressList = Arrays.asList(eags);
-    
+
     when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2);
     when(backoffPolicy1.nextBackoffNanos()).thenReturn(11L, 21L, 31L);
     when(backoffPolicy2.nextBackoffNanos()).thenReturn(12L, 22L, 32L);
@@ -477,7 +477,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
 
     verifyRetryAfterNanos(inOrder, subchannel, healthImpl, 11);
     assertThat(clock.getPendingTasks()).isEmpty();
-    
+
     subchannel.logs.clear();
     // Server closes the health checking RPC without any response
     healthImpl.calls.poll().responseObserver.onError(Status.CANCELLED.asException());
@@ -496,7 +496,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
     inOrder.verify(backoffPolicy1).nextBackoffNanos();
 
     verifyRetryAfterNanos(inOrder, subchannel, healthImpl, 21);
-    
+
     // Server responds this time
     healthImpl.calls.poll().responseObserver.onNext(makeResponse(ServingStatus.SERVING));
 
@@ -1038,31 +1038,32 @@ public class HealthCheckingLoadBalancerFactoryTest {
   }
 
   private ConnectivityStateInfo unavailableStateWithMsg(final String expectedMsg) {
-    return argThat(new org.hamcrest.BaseMatcher<ConnectivityStateInfo>() {
+    return MockitoHamcrest.argThat(
-        @Override
+        new org.hamcrest.BaseMatcher<ConnectivityStateInfo>() {
-        public boolean matches(Object item) {
+          @Override
-          if (!(item instanceof ConnectivityStateInfo)) {
+          public boolean matches(Object item) {
-            return false;
+            if (!(item instanceof ConnectivityStateInfo)) {
+              return false;
+            }
+            ConnectivityStateInfo info = (ConnectivityStateInfo) item;
+            if (!info.getState().equals(TRANSIENT_FAILURE)) {
+              return false;
+            }
+            Status error = info.getStatus();
+            if (!error.getCode().equals(Code.UNAVAILABLE)) {
+              return false;
+            }
+            if (!error.getDescription().equals(expectedMsg)) {
+              return false;
+            }
+            return true;
           }
-          ConnectivityStateInfo info = (ConnectivityStateInfo) item;
-          if (!info.getState().equals(TRANSIENT_FAILURE)) {
-            return false;
-          }
-          Status error = info.getStatus();
-          if (!error.getCode().equals(Code.UNAVAILABLE)) {
-            return false;
-          }
-          if (!error.getDescription().equals(expectedMsg)) {
-            return false;
-          }
-          return true;
-        }
 
-        @Override
+          @Override
-        public void describeTo(org.hamcrest.Description desc) {
+          public void describeTo(org.hamcrest.Description desc) {
-          desc.appendText("Matches unavailable state with msg='" + expectedMsg + "'");
+            desc.appendText("Matches unavailable state with msg='" + expectedMsg + "'");
-        }
+          }
-      });
+        });
   }
 
   private static class HealthImpl extends HealthGrpc.HealthImplBase {

testing/src/test/java/io/grpc/testing/GrpcCleanupRuleTest.java

@@ -20,8 +20,8 @@ import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-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.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.inOrder;

xds/src/test/java/io/grpc/xds/FallbackManagerTest.java

@@ -17,8 +17,8 @@
 package io.grpc.xds;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
@@ -44,7 +44,7 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
@@ -123,7 +123,7 @@ public class FallbackManagerTest {
         eags, Attributes.EMPTY, fallbackPolicy);
 
     verify(fakeLb, never()).handleResolvedAddressGroups(
-        Matchers.<List<EquivalentAddressGroup>>any(), Matchers.<Attributes>any());
+        ArgumentMatchers.<List<EquivalentAddressGroup>>any(), ArgumentMatchers.<Attributes>any());
 
     fakeClock.forwardTime(FALLBACK_TIMEOUT_MS, TimeUnit.MILLISECONDS);
 
@@ -146,6 +146,6 @@ public class FallbackManagerTest {
     fakeClock.forwardTime(FALLBACK_TIMEOUT_MS, TimeUnit.MILLISECONDS);
 
     verify(fakeLb, never()).handleResolvedAddressGroups(
-        Matchers.<List<EquivalentAddressGroup>>any(), Matchers.<Attributes>any());
+        ArgumentMatchers.<List<EquivalentAddressGroup>>any(), ArgumentMatchers.<Attributes>any());
   }
 }

xds/src/test/java/io/grpc/xds/XdsLoadBalancerTest.java

@@ -21,7 +21,7 @@ import static io.grpc.LoadBalancer.ATTR_LOAD_BALANCING_CONFIG;
 import static io.grpc.xds.XdsLoadBalancer.STATE_INFO;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Matchers.anyString;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -68,7 +68,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
@@ -236,7 +236,7 @@ public class XdsLoadBalancerTest {
         delegatesTo(cleanupRule.register(channelBuilder.build())));
 
     doReturn(oobChannel1).doReturn(oobChannel2).doReturn(oobChannel3)
-      .when(helper).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+      .when(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());
   }
 
   @After
@@ -264,9 +264,10 @@ public class XdsLoadBalancerTest {
 
     XdsLbState xdsLbState1 = lb.getXdsLbStateForTest();
     assertThat(xdsLbState1.childPolicy).isNull();
-    verify(helper).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+    verify(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());
     verify(oobChannel1)
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
 
 
     lbConfigRaw = "{\"xds_experimental\" : { "
@@ -284,10 +285,11 @@ public class XdsLoadBalancerTest {
     assertThat(xdsLbState2).isSameAs(xdsLbState1);
 
     // verify oobChannel is unchanged
-    verify(helper).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+    verify(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());
     // verify ADS stream is unchanged
     verify(oobChannel1)
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
   }
 
   @Test
@@ -302,9 +304,10 @@ public class XdsLoadBalancerTest {
     Attributes attrs = Attributes.newBuilder().set(ATTR_LOAD_BALANCING_CONFIG, lbConfig).build();
 
     lb.handleResolvedAddressGroups(Collections.<EquivalentAddressGroup>emptyList(), attrs);
-    verify(helper).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+    verify(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());
     verify(oobChannel1)
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
 
     lbConfigRaw = "{\"xds_experimental\" : { "
         + "\"balancerName\" : \"dns:///balancer.example.com:8080\","
@@ -320,10 +323,11 @@ public class XdsLoadBalancerTest {
     assertThat(lb.getXdsLbStateForTest().childPolicy).isNotNull();
 
     // verify oobChannel is unchanged
-    verify(helper).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+    verify(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());
     // verify ADS stream is reset
     verify(oobChannel1, times(2))
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
   }
 
   @Test
@@ -338,9 +342,10 @@ public class XdsLoadBalancerTest {
     Attributes attrs = Attributes.newBuilder().set(ATTR_LOAD_BALANCING_CONFIG, lbConfig).build();
 
     lb.handleResolvedAddressGroups(Collections.<EquivalentAddressGroup>emptyList(), attrs);
-    verify(helper).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+    verify(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());
     verify(oobChannel1)
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
 
     assertThat(lb.getXdsLbStateForTest().childPolicy).isNotNull();
 
@@ -358,10 +363,11 @@ public class XdsLoadBalancerTest {
     assertThat(lb.getXdsLbStateForTest().childPolicy).isNull();
 
     // verify oobChannel is unchanged
-    verify(helper).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+    verify(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());
     // verify ADS stream is reset
     verify(oobChannel1, times(2))
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
   }
 
   @Test
@@ -378,9 +384,10 @@ public class XdsLoadBalancerTest {
     lb.handleResolvedAddressGroups(Collections.<EquivalentAddressGroup>emptyList(), attrs);
 
     assertThat(lb.getXdsLbStateForTest().childPolicy).isNotNull();
-    verify(helper).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+    verify(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());
     verify(oobChannel1)
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
 
     lbConfigRaw = "{\"xds_experimental\" : { "
         + "\"balancerName\" : \"dns:///balancer.example.com:8080\","
@@ -395,10 +402,11 @@ public class XdsLoadBalancerTest {
 
     assertThat(lb.getXdsLbStateForTest().childPolicy).isNotNull();
     // verify oobChannel is unchanged
-    verify(helper).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+    verify(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());
     // verify ADS stream is reset
     verify(oobChannel1, times(2))
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
   }
 
   @Test
@@ -413,9 +421,10 @@ public class XdsLoadBalancerTest {
     Attributes attrs = Attributes.newBuilder().set(ATTR_LOAD_BALANCING_CONFIG, lbConfig).build();
 
     lb.handleResolvedAddressGroups(Collections.<EquivalentAddressGroup>emptyList(), attrs);
-    verify(helper).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+    verify(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());
     verify(oobChannel1)
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
 
     lbConfigRaw = "{\"xds_experimental\" : { "
         + "\"balancerName\" : \"dns:///balancer.example.com:8443\","
@@ -431,11 +440,14 @@ public class XdsLoadBalancerTest {
     assertThat(lb.getXdsLbStateForTest().childPolicy).isNotNull();
 
     // verify oobChannel is unchanged
-    verify(helper, times(2)).createOobChannel(Matchers.<EquivalentAddressGroup>any(), anyString());
+    verify(helper, times(2)).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(),
+        anyString());
     verify(oobChannel1)
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
     verify(oobChannel2)
-        .newCall(Matchers.<MethodDescriptor<?, ?>>any(), Matchers.<CallOptions>any());
+        .newCall(ArgumentMatchers.<MethodDescriptor<?, ?>>any(),
+            ArgumentMatchers.<CallOptions>any());
     verifyNoMoreInteractions(oobChannel3);
   }
 
@@ -449,7 +461,7 @@ public class XdsLoadBalancerTest {
 
     ArgumentCaptor<Attributes> captor = ArgumentCaptor.forClass(Attributes.class);
     verify(fakeBalancer1).handleResolvedAddressGroups(
-        Matchers.<List<EquivalentAddressGroup>>any(), captor.capture());
+        ArgumentMatchers.<List<EquivalentAddressGroup>>any(), captor.capture());
     assertThat(captor.getValue().get(ATTR_LOAD_BALANCING_CONFIG))
         .containsExactly("supported_1_option", "yes");
   }
@@ -463,7 +475,7 @@ public class XdsLoadBalancerTest {
 
     assertThat(fakeClock.getPendingTasks()).isEmpty();
     verify(fakeBalancer1, never()).handleResolvedAddressGroups(
-        Matchers.<List<EquivalentAddressGroup>>any(), Matchers.<Attributes>any());
+        ArgumentMatchers.<List<EquivalentAddressGroup>>any(), ArgumentMatchers.<Attributes>any());
   }
 
   @Test
@@ -475,7 +487,7 @@ public class XdsLoadBalancerTest {
 
     ArgumentCaptor<Attributes> captor = ArgumentCaptor.forClass(Attributes.class);
     verify(fakeBalancer1).handleResolvedAddressGroups(
-        Matchers.<List<EquivalentAddressGroup>>any(), captor.capture());
+        ArgumentMatchers.<List<EquivalentAddressGroup>>any(), captor.capture());
     assertThat(captor.getValue().get(ATTR_LOAD_BALANCING_CONFIG))
         .containsExactly("supported_1_option", "yes");
 
@@ -484,7 +496,7 @@ public class XdsLoadBalancerTest {
 
     // verify handleResolvedAddressGroups() is not called again
     verify(fakeBalancer1).handleResolvedAddressGroups(
-        Matchers.<List<EquivalentAddressGroup>>any(), Matchers.<Attributes>any());
+        ArgumentMatchers.<List<EquivalentAddressGroup>>any(), ArgumentMatchers.<Attributes>any());
   }
 
   @Test
@@ -497,7 +509,7 @@ public class XdsLoadBalancerTest {
     serverResponseWriter.onError(new Exception("fake error"));
 
     verify(fakeBalancer1, never()).handleResolvedAddressGroups(
-        Matchers.<List<EquivalentAddressGroup>>any(), Matchers.<Attributes>any());
+        ArgumentMatchers.<List<EquivalentAddressGroup>>any(), ArgumentMatchers.<Attributes>any());
 
     Subchannel subchannel = new Subchannel() {
       @Override
@@ -523,7 +535,7 @@ public class XdsLoadBalancerTest {
 
     ArgumentCaptor<Attributes> captor = ArgumentCaptor.forClass(Attributes.class);
     verify(fakeBalancer1).handleResolvedAddressGroups(
-        Matchers.<List<EquivalentAddressGroup>>any(), captor.capture());
+        ArgumentMatchers.<List<EquivalentAddressGroup>>any(), captor.capture());
     assertThat(captor.getValue().get(ATTR_LOAD_BALANCING_CONFIG))
         .containsExactly("supported_1_option", "yes");
   }