all: update to truth 0.44

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

@@ -146,7 +146,7 @@ public class NettyTsiHandshakerTest {
       actualMethods.add(m.getName());
     }
 
-    assertThat(actualMethods).containsAllIn(expectedMethods);
+    assertThat(actualMethods).containsAtLeastElementsIn(expectedMethods);
   }
 
   static void doHandshake(

android-interop-testing/app/build.gradle

@@ -66,7 +66,7 @@ dependencies {
     implementation ('com.google.auth:google-auth-library-oauth2-http:0.9.0') {
         exclude group: 'org.apache.httpcomponents', module: 'httpclient'
     }
-    implementation 'com.google.truth:truth:0.36'
+    implementation 'com.google.truth:truth:0.44'
     implementation 'javax.annotation:javax.annotation-api:1.2'
     implementation 'junit:junit:4.12'
 

android/build.gradle

@@ -51,7 +51,7 @@ dependencies {
     testImplementation 'io.grpc:grpc-okhttp:1.21.0-SNAPSHOT' // CURRENT_GRPC_VERSION
     testImplementation 'junit:junit:4.12'
     testImplementation 'org.robolectric:robolectric:3.7.1'
-    testImplementation 'com.google.truth:truth:0.39'
+    testImplementation 'com.google.truth:truth:0.44'
 }
 
 signing {

android/src/test/java/io/grpc/android/AndroidChannelBuilderTest.java

@@ -97,7 +97,7 @@ public final class AndroidChannelBuilderTest {
   public void fromBuilderConstructor() {
     OkHttpChannelBuilder wrappedBuilder = OkHttpChannelBuilder.forTarget("target");
     AndroidChannelBuilder androidBuilder = AndroidChannelBuilder.fromBuilder(wrappedBuilder);
-    assertThat(androidBuilder.delegate()).isSameAs(wrappedBuilder);
+    assertThat(androidBuilder.delegate()).isSameInstanceAs(wrappedBuilder);
   }
 
   @Test

api/src/test/java/io/grpc/CallOptionsTest.java

@@ -81,13 +81,13 @@ public class CallOptionsTest {
 
   @Test
   public void allWiths() {
-    assertThat(allSet.getAuthority()).isSameAs(sampleAuthority);
+    assertThat(allSet.getAuthority()).isSameInstanceAs(sampleAuthority);
-    assertThat(allSet.getDeadline()).isSameAs(sampleDeadline);
+    assertThat(allSet.getDeadline()).isSameInstanceAs(sampleDeadline);
-    assertThat(allSet.getCredentials()).isSameAs(sampleCreds);
+    assertThat(allSet.getCredentials()).isSameInstanceAs(sampleCreds);
-    assertThat(allSet.getCompressor()).isSameAs(sampleCompressor);
+    assertThat(allSet.getCompressor()).isSameInstanceAs(sampleCompressor);
-    assertThat(allSet.getExecutor()).isSameAs(directExecutor());
+    assertThat(allSet.getExecutor()).isSameInstanceAs(directExecutor());
-    assertThat(allSet.getOption(OPTION_1)).isSameAs("value1");
+    assertThat(allSet.getOption(OPTION_1)).isSameInstanceAs("value1");
-    assertThat(allSet.getOption(OPTION_2)).isSameAs("value2");
+    assertThat(allSet.getOption(OPTION_2)).isSameInstanceAs("value2");
     assertThat(allSet.isWaitForReady()).isTrue();
   }
 
@@ -111,10 +111,10 @@ public class CallOptionsTest {
     Deadline deadline = Deadline.after(10, SECONDS);
     CallOptions options1 = CallOptions.DEFAULT.withDeadline(deadline);
     assertThat(CallOptions.DEFAULT.getDeadline()).isNull();
-    assertThat(deadline).isSameAs(options1.getDeadline());
+    assertThat(deadline).isSameInstanceAs(options1.getDeadline());
 
     CallOptions options2 = options1.withDeadline(null);
-    assertThat(deadline).isSameAs(options1.getDeadline());
+    assertThat(deadline).isSameInstanceAs(options1.getDeadline());
     assertThat(options2.getDeadline()).isNull();
   }
 
@@ -123,10 +123,10 @@ public class CallOptionsTest {
     Executor executor = directExecutor();
     CallOptions options1 = CallOptions.DEFAULT.withExecutor(executor);
     assertThat(CallOptions.DEFAULT.getExecutor()).isNull();
-    assertThat(executor).isSameAs(options1.getExecutor());
+    assertThat(executor).isSameInstanceAs(options1.getExecutor());
 
     CallOptions options2 = options1.withExecutor(null);
-    assertThat(executor).isSameAs(options1.getExecutor());
+    assertThat(executor).isSameInstanceAs(options1.getExecutor());
     assertThat(options2.getExecutor()).isNull();
   }
 

api/src/test/java/io/grpc/ForwardingChannelBuilderTest.java

@@ -83,7 +83,7 @@ public class ForwardingChannelBuilderTest {
 
       Object returnedValue = method.invoke(testChannelBuilder, args);
 
-      assertThat(returnedValue).isSameAs(testChannelBuilder);
+      assertThat(returnedValue).isSameInstanceAs(testChannelBuilder);
     }
   }
 
@@ -92,6 +92,6 @@ public class ForwardingChannelBuilderTest {
     ManagedChannel mockChannel = mock(ManagedChannel.class);
     doReturn(mockChannel).when(mockDelegate).build();
 
-    assertThat(testChannelBuilder.build()).isSameAs(mockChannel);
+    assertThat(testChannelBuilder.build()).isSameInstanceAs(mockChannel);
   }
 }

api/src/test/java/io/grpc/LoadBalancerRegistryTest.java

@@ -84,16 +84,16 @@ public class LoadBalancerRegistryTest {
     }
 
     assertThat(reg.providers()).hasSize(3);
-    assertThat(reg.getProvider("cool")).isSameAs(providers[1]);
+    assertThat(reg.getProvider("cool")).isSameInstanceAs(providers[1]);
-    assertThat(reg.getProvider("great")).isSameAs(providers[2]);
+    assertThat(reg.getProvider("great")).isSameInstanceAs(providers[2]);
-    assertThat(reg.getProvider("excellent")).isSameAs(providers[4]);
+    assertThat(reg.getProvider("excellent")).isSameInstanceAs(providers[4]);
 
     reg.deregister(providers[1]);
-    assertThat(reg.getProvider("cool")).isSameAs(providers[0]);
+    assertThat(reg.getProvider("cool")).isSameInstanceAs(providers[0]);
     reg.deregister(providers[2]);
-    assertThat(reg.getProvider("great")).isSameAs(providers[3]);
+    assertThat(reg.getProvider("great")).isSameInstanceAs(providers[3]);
     reg.deregister(providers[4]);
-    assertThat(reg.getProvider("excellent")).isSameAs(providers[5]);
+    assertThat(reg.getProvider("excellent")).isSameInstanceAs(providers[5]);
   }
 
   private static class FakeProvider extends LoadBalancerProvider {

api/src/test/java/io/grpc/LoadBalancerTest.java

@@ -52,8 +52,8 @@ public class LoadBalancerTest {
   @Test
   public void pickResult_withSubchannel() {
     PickResult result = PickResult.withSubchannel(subchannel);
-    assertThat(result.getSubchannel()).isSameAs(subchannel);
+    assertThat(result.getSubchannel()).isSameInstanceAs(subchannel);
-    assertThat(result.getStatus()).isSameAs(Status.OK);
+    assertThat(result.getStatus()).isSameInstanceAs(Status.OK);
     assertThat(result.getStreamTracerFactory()).isNull();
     assertThat(result.isDrop()).isFalse();
   }
@@ -61,9 +61,9 @@ public class LoadBalancerTest {
   @Test
   public void pickResult_withSubchannelAndTracer() {
     PickResult result = PickResult.withSubchannel(subchannel, tracerFactory);
-    assertThat(result.getSubchannel()).isSameAs(subchannel);
+    assertThat(result.getSubchannel()).isSameInstanceAs(subchannel);
-    assertThat(result.getStatus()).isSameAs(Status.OK);
+    assertThat(result.getStatus()).isSameInstanceAs(Status.OK);
-    assertThat(result.getStreamTracerFactory()).isSameAs(tracerFactory);
+    assertThat(result.getStreamTracerFactory()).isSameInstanceAs(tracerFactory);
     assertThat(result.isDrop()).isFalse();
   }
 
@@ -71,7 +71,7 @@ public class LoadBalancerTest {
   public void pickResult_withNoResult() {
     PickResult result = PickResult.withNoResult();
     assertThat(result.getSubchannel()).isNull();
-    assertThat(result.getStatus()).isSameAs(Status.OK);
+    assertThat(result.getStatus()).isSameInstanceAs(Status.OK);
     assertThat(result.getStreamTracerFactory()).isNull();
     assertThat(result.isDrop()).isFalse();
   }
@@ -80,7 +80,7 @@ public class LoadBalancerTest {
   public void pickResult_withError() {
     PickResult result = PickResult.withError(status);
     assertThat(result.getSubchannel()).isNull();
-    assertThat(result.getStatus()).isSameAs(status);
+    assertThat(result.getStatus()).isSameInstanceAs(status);
     assertThat(result.getStreamTracerFactory()).isNull();
     assertThat(result.isDrop()).isFalse();
   }
@@ -89,7 +89,7 @@ public class LoadBalancerTest {
   public void pickResult_withDrop() {
     PickResult result = PickResult.withDrop(status);
     assertThat(result.getSubchannel()).isNull();
-    assertThat(result.getStatus()).isSameAs(status);
+    assertThat(result.getStatus()).isSameInstanceAs(status);
     assertThat(result.getStreamTracerFactory()).isNull();
     assertThat(result.isDrop()).isTrue();
   }
@@ -134,15 +134,15 @@ public class LoadBalancerTest {
       @Override
       public Subchannel createSubchannel(List<EquivalentAddressGroup> addrsIn, Attributes attrsIn) {
         assertThat(addrsIn).hasSize(1);
-        assertThat(addrsIn.get(0)).isSameAs(eag);
+        assertThat(addrsIn.get(0)).isSameInstanceAs(eag);
-        assertThat(attrsIn).isSameAs(attrs);
+        assertThat(attrsIn).isSameInstanceAs(attrs);
         ran = true;
         return subchannel;
       }
     }
 
     OverrideCreateSubchannel helper = new OverrideCreateSubchannel();
-    assertThat(helper.createSubchannel(eag, attrs)).isSameAs(subchannel);
+    assertThat(helper.createSubchannel(eag, attrs)).isSameInstanceAs(subchannel);
     assertThat(helper.ran).isTrue();
   }
 
@@ -179,9 +179,9 @@ public class LoadBalancerTest {
       @Override
       public void updateSubchannelAddresses(
           Subchannel subchannelIn, List<EquivalentAddressGroup> addrsIn) {
-        assertThat(subchannelIn).isSameAs(emptySubchannel);
+        assertThat(subchannelIn).isSameInstanceAs(emptySubchannel);
         assertThat(addrsIn).hasSize(1);
-        assertThat(addrsIn.get(0)).isSameAs(eag);
+        assertThat(addrsIn.get(0)).isSameInstanceAs(eag);
         ran = true;
       }
     }

api/src/test/java/io/grpc/NameResolverRegistryTest.java

@@ -96,8 +96,8 @@ public class NameResolverRegistryTest {
         new BaseProvider(true, 5) {
           @Override
           public NameResolver newNameResolver(URI passedUri, NameResolver.Helper passedHelper) {
-            assertThat(passedUri).isSameAs(uri);
+            assertThat(passedUri).isSameInstanceAs(uri);
-            assertThat(passedHelper).isSameAs(helper);
+            assertThat(passedHelper).isSameInstanceAs(helper);
             return null;
           }
         });
@@ -141,7 +141,7 @@ public class NameResolverRegistryTest {
             throw new AssertionError();
           }
         });
-    assertThat(registry.asFactory().newNameResolver(uri, helper)).isSameAs(nr);
+    assertThat(registry.asFactory().newNameResolver(uri, helper)).isSameInstanceAs(nr);
   }
 
   @Test

build.gradle

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

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

@@ -48,8 +48,8 @@ public final class ThreadLocalContextStorageTest {
   public void detach_threadLocalClearedOnRoot() {
     Context context = Context.ROOT.withValue(KEY, new Object());
     Context old = storage.doAttach(context);
-    assertThat(storage.current()).isSameAs(context);
+    assertThat(storage.current()).isSameInstanceAs(context);
-    assertThat(ThreadLocalContextStorage.localContext.get()).isSameAs(context);
+    assertThat(ThreadLocalContextStorage.localContext.get()).isSameInstanceAs(context);
     storage.detach(context, old);
     // thread local must contain null to avoid leaking our ClassLoader via ROOT
     assertThat(ThreadLocalContextStorage.localContext.get()).isNull();

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

@@ -272,7 +272,7 @@ public class AbstractManagedChannelImplBuilderTest {
         .isInstanceOf(CensusTracingModule.TracingClientInterceptor.class);
     assertThat(effectiveInterceptors.get(1))
         .isInstanceOf(CensusStatsModule.StatsClientInterceptor.class);
-    assertThat(effectiveInterceptors.get(2)).isSameAs(DUMMY_USER_INTERCEPTOR);
+    assertThat(effectiveInterceptors.get(2)).isSameInstanceAs(DUMMY_USER_INTERCEPTOR);
   }
 
   @Test
@@ -283,7 +283,7 @@ public class AbstractManagedChannelImplBuilderTest {
     assertEquals(2, effectiveInterceptors.size());
     assertThat(effectiveInterceptors.get(0))
         .isInstanceOf(CensusTracingModule.TracingClientInterceptor.class);
-    assertThat(effectiveInterceptors.get(1)).isSameAs(DUMMY_USER_INTERCEPTOR);
+    assertThat(effectiveInterceptors.get(1)).isSameInstanceAs(DUMMY_USER_INTERCEPTOR);
   }
 
   @Test
@@ -294,7 +294,7 @@ public class AbstractManagedChannelImplBuilderTest {
     assertEquals(2, effectiveInterceptors.size());
     assertThat(effectiveInterceptors.get(0))
         .isInstanceOf(CensusStatsModule.StatsClientInterceptor.class);
-    assertThat(effectiveInterceptors.get(1)).isSameAs(DUMMY_USER_INTERCEPTOR);
+    assertThat(effectiveInterceptors.get(1)).isSameInstanceAs(DUMMY_USER_INTERCEPTOR);
   }
 
   @Test

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

@@ -53,7 +53,7 @@ public class AbstractServerImplBuilderTest {
     assertEquals(3, factories.size());
     assertThat(factories.get(0)).isInstanceOf(CensusStatsModule.ServerTracerFactory.class);
     assertThat(factories.get(1)).isInstanceOf(CensusTracingModule.ServerTracerFactory.class);
-    assertThat(factories.get(2)).isSameAs(DUMMY_USER_TRACER);
+    assertThat(factories.get(2)).isSameInstanceAs(DUMMY_USER_TRACER);
   }
 
   @Test
@@ -65,7 +65,7 @@ public class AbstractServerImplBuilderTest {
 
     assertEquals(2, factories.size());
     assertThat(factories.get(0)).isInstanceOf(CensusTracingModule.ServerTracerFactory.class);
-    assertThat(factories.get(1)).isSameAs(DUMMY_USER_TRACER);
+    assertThat(factories.get(1)).isSameInstanceAs(DUMMY_USER_TRACER);
   }
 
   @Test
@@ -77,7 +77,7 @@ public class AbstractServerImplBuilderTest {
 
     assertEquals(2, factories.size());
     assertThat(factories.get(0)).isInstanceOf(CensusStatsModule.ServerTracerFactory.class);
-    assertThat(factories.get(1)).isSameAs(DUMMY_USER_TRACER);
+    assertThat(factories.get(1)).isSameInstanceAs(DUMMY_USER_TRACER);
   }
 
   @Test

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

@@ -765,7 +765,7 @@ public abstract class AbstractTransportTest {
 
     // This attribute is available right after transport is started
     assertThat(((ConnectionClientTransport) client).getAttributes()
-        .get(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS)).isSameAs(EAG_ATTRS);
+        .get(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS)).isSameInstanceAs(EAG_ATTRS);
 
     MockServerTransportListener serverTransportListener
         = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
@@ -785,9 +785,9 @@ public abstract class AbstractTransportTest {
     clientInOrder.verify(clientStreamTracerFactory).newClientStreamTracer(
         streamInfoCaptor.capture(), same(clientHeaders));
     ClientStreamTracer.StreamInfo streamInfo = streamInfoCaptor.getValue();
-    assertThat(streamInfo.getTransportAttrs()).isSameAs(
+    assertThat(streamInfo.getTransportAttrs()).isSameInstanceAs(
         ((ConnectionClientTransport) client).getAttributes());
-    assertThat(streamInfo.getCallOptions()).isSameAs(callOptions);
+    assertThat(streamInfo.getCallOptions()).isSameInstanceAs(callOptions);
 
     ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
     clientStream.start(clientStreamListener);
@@ -813,7 +813,7 @@ public abstract class AbstractTransportTest {
 
     // This attribute is still available when the transport is connected
     assertThat(((ConnectionClientTransport) client).getAttributes()
-        .get(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS)).isSameAs(EAG_ATTRS);
+        .get(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS)).isSameInstanceAs(EAG_ATTRS);
 
     serverStream.request(1);
     assertTrue(clientStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));

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

@@ -132,8 +132,8 @@ public class AutoConfiguredLoadBalancerFactoryTest {
         (AutoConfiguredLoadBalancer) new AutoConfiguredLoadBalancerFactory("test_lb")
         .newLoadBalancer(new TestHelper());
 
-    assertThat(lb.getDelegateProvider()).isSameAs(testLbBalancerProvider);
+    assertThat(lb.getDelegateProvider()).isSameInstanceAs(testLbBalancerProvider);
-    assertThat(lb.getDelegate()).isSameAs(testLbBalancer);
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
   }
 
   @SuppressWarnings("deprecation")
@@ -194,7 +194,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
             .setAttributes(Attributes.EMPTY)
             .build());
 
-    assertThat(lb.getDelegate()).isSameAs(oldDelegate);
+    assertThat(lb.getDelegate()).isSameInstanceAs(oldDelegate);
   }
 
   @Test
@@ -263,7 +263,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
             .build());
 
     verify(testLbBalancerProvider).newLoadBalancer(same(helper));
-    assertThat(lb.getDelegate()).isSameAs(testLbBalancer);
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
     verify(testLbBalancer).handleResolvedAddresses(resultCaptor.capture());
@@ -323,7 +323,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
             .setAttributes(Attributes.EMPTY)
             .build());
 
-    assertThat(lb.getDelegate()).isSameAs(testLbBalancer);
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
     verify(testLbBalancer).handleResolvedAddresses(
         ResolvedAddresses.newBuilder()
             .setAddresses(Collections.singletonList(servers.get(0)))
@@ -347,7 +347,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
                 .set(GrpcAttributes.NAME_RESOLVER_SERVICE_CONFIG, serviceConfig).build())
             .build());
 
-    assertThat(lb.getDelegate()).isSameAs(testLbBalancer);
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
     assertThat(testLbBalancer.canHandleEmptyAddressListFromNameResolution()).isFalse();
     ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(null);
     verify(testLbBalancer).handleNameResolutionError(statusCaptor.capture());
@@ -372,7 +372,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
                 .set(GrpcAttributes.NAME_RESOLVER_SERVICE_CONFIG, serviceConfig).build())
             .build());
 
-    assertThat(lb.getDelegate()).isSameAs(testLbBalancer2);
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer2);
     assertThat(testLbBalancer2.canHandleEmptyAddressListFromNameResolution()).isTrue();
     ArgumentCaptor<ResolvedAddresses> resultCaptor =
         ArgumentCaptor.forClass(ResolvedAddresses.class);
@@ -383,7 +383,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
     Map<String, ?> lbConfig = actualAttributes.get(LoadBalancer.ATTR_LOAD_BALANCING_CONFIG);
     assertThat(lbConfig).isEqualTo(Collections.<String, Object>singletonMap("setting1", "high"));
     assertThat(actualAttributes.get(GrpcAttributes.NAME_RESOLVER_SERVICE_CONFIG))
-        .isSameAs(serviceConfig);
+        .isSameInstanceAs(serviceConfig);
   }
 
   @Test
@@ -413,7 +413,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
         Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
     PolicySelection selection = lb.decideLoadBalancerProvider(servers, serviceConfig);
 
-    assertThat(selection.provider).isSameAs(testLbBalancerProvider);
+    assertThat(selection.provider).isSameInstanceAs(testLbBalancerProvider);
     assertThat(selection.serverList).isEqualTo(servers);
     assertThat(selection.config).isNull();
     verifyZeroInteractions(channelLogger);
@@ -550,7 +550,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
             new EquivalentAddressGroup(new SocketAddress(){}));
     PolicySelection selection = lb.decideLoadBalancerProvider(servers, serviceConfig);
 
-    assertThat(selection.provider).isSameAs(fakeRoundRobinProvider);
+    assertThat(selection.provider).isSameInstanceAs(fakeRoundRobinProvider);
     assertThat(selection.config).isNull();
     verify(channelLogger).log(
         eq(ChannelLogLevel.ERROR),
@@ -559,7 +559,7 @@ public class AutoConfiguredLoadBalancerFactoryTest {
     // Called for the second time, the warning is only logged once
     selection = lb.decideLoadBalancerProvider(servers, serviceConfig);
 
-    assertThat(selection.provider).isSameAs(fakeRoundRobinProvider);
+    assertThat(selection.provider).isSameInstanceAs(fakeRoundRobinProvider);
     // Balancer addresses are filtered out in the server list passed to round_robin
     assertThat(selection.serverList).containsExactly(servers.get(1));
     assertThat(selection.config).isNull();

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

@@ -200,7 +200,7 @@ public class ClientCallImplTest {
         ArgumentMatchers.isA(Metadata.class));
     Status callListenerStatus = statusArgumentCaptor.getValue();
     assertThat(callListenerStatus.getCode()).isEqualTo(Status.Code.CANCELLED);
-    assertThat(callListenerStatus.getCause()).isSameAs(failure);
+    assertThat(callListenerStatus.getCause()).isSameInstanceAs(failure);
     verify(stream).cancel(same(callListenerStatus));
   }
 
@@ -236,7 +236,7 @@ public class ClientCallImplTest {
         ArgumentMatchers.isA(Metadata.class));
     Status callListenerStatus = statusArgumentCaptor.getValue();
     assertThat(callListenerStatus.getCode()).isEqualTo(Status.Code.CANCELLED);
-    assertThat(callListenerStatus.getCause()).isSameAs(failure);
+    assertThat(callListenerStatus.getCause()).isSameInstanceAs(failure);
     verify(stream).cancel(same(callListenerStatus));
   }
 
@@ -272,7 +272,7 @@ public class ClientCallImplTest {
         ArgumentMatchers.isA(Metadata.class));
     Status callListenerStatus = statusArgumentCaptor.getValue();
     assertThat(callListenerStatus.getCode()).isEqualTo(Status.Code.CANCELLED);
-    assertThat(callListenerStatus.getCause()).isSameAs(failure);
+    assertThat(callListenerStatus.getCause()).isSameInstanceAs(failure);
     verify(stream).cancel(same(callListenerStatus));
   }
 

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

@@ -56,7 +56,7 @@ public final class ClientTransportFactoryTest {
     assertThat(cto.getAuthority()).isEqualTo(authority);
     assertThat(cto.getEagAttributes()).isEqualTo(eagAttributes);
     assertThat(cto.getUserAgent()).isEqualTo(userAgent);
-    assertThat(cto.getHttpConnectProxiedSocketAddress()).isSameAs(proxySocketAddress);
+    assertThat(cto.getHttpConnectProxiedSocketAddress()).isSameInstanceAs(proxySocketAddress);
   }
 
   @Test

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

@@ -1176,32 +1176,32 @@ public class InternalSubchannelTest {
         new EquivalentAddressGroup(Arrays.asList(addr1, addr2), attr1),
         new EquivalentAddressGroup(Arrays.asList(addr3), attr2),
         new EquivalentAddressGroup(Arrays.asList(addr4, addr5), attr3)));
-    assertThat(index.getCurrentAddress()).isSameAs(addr1);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
-    assertThat(index.getCurrentEagAttributes()).isSameAs(attr1);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
     assertThat(index.isAtBeginning()).isTrue();
     assertThat(index.isValid()).isTrue();
 
     index.increment();
-    assertThat(index.getCurrentAddress()).isSameAs(addr2);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);
-    assertThat(index.getCurrentEagAttributes()).isSameAs(attr1);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
     assertThat(index.isAtBeginning()).isFalse();
     assertThat(index.isValid()).isTrue();
 
     index.increment();
-    assertThat(index.getCurrentAddress()).isSameAs(addr3);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr3);
-    assertThat(index.getCurrentEagAttributes()).isSameAs(attr2);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr2);
     assertThat(index.isAtBeginning()).isFalse();
     assertThat(index.isValid()).isTrue();
 
     index.increment();
-    assertThat(index.getCurrentAddress()).isSameAs(addr4);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr4);
-    assertThat(index.getCurrentEagAttributes()).isSameAs(attr3);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);
     assertThat(index.isAtBeginning()).isFalse();
     assertThat(index.isValid()).isTrue();
 
     index.increment();
-    assertThat(index.getCurrentAddress()).isSameAs(addr5);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr5);
-    assertThat(index.getCurrentEagAttributes()).isSameAs(attr3);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);
     assertThat(index.isAtBeginning()).isFalse();
     assertThat(index.isValid()).isTrue();
 
@@ -1210,8 +1210,8 @@ public class InternalSubchannelTest {
     assertThat(index.isValid()).isFalse();
 
     index.reset();
-    assertThat(index.getCurrentAddress()).isSameAs(addr1);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
-    assertThat(index.getCurrentEagAttributes()).isSameAs(attr1);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
     assertThat(index.isAtBeginning()).isTrue();
     assertThat(index.isValid()).isTrue();
 
@@ -1220,11 +1220,11 @@ public class InternalSubchannelTest {
     index.increment();
     index.increment();
     index.increment();
-    assertThat(index.getCurrentAddress()).isSameAs(addr5);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr5);
-    assertThat(index.getCurrentEagAttributes()).isSameAs(attr3);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);
     index.reset();
-    assertThat(index.getCurrentAddress()).isSameAs(addr1);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
-    assertThat(index.getCurrentEagAttributes()).isSameAs(attr1);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
   }
 
   @Test public void index_updateGroups_resets() {
@@ -1240,7 +1240,7 @@ public class InternalSubchannelTest {
     index.updateGroups(Arrays.asList(
         new EquivalentAddressGroup(Arrays.asList(addr1)),
         new EquivalentAddressGroup(Arrays.asList(addr2, addr3))));
-    assertThat(index.getCurrentAddress()).isSameAs(addr1);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
   }
 
   @Test public void index_seekTo() {
@@ -1251,14 +1251,14 @@ public class InternalSubchannelTest {
         new EquivalentAddressGroup(Arrays.asList(addr1, addr2)),
         new EquivalentAddressGroup(Arrays.asList(addr3))));
     assertThat(index.seekTo(addr3)).isTrue();
-    assertThat(index.getCurrentAddress()).isSameAs(addr3);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr3);
     assertThat(index.seekTo(addr1)).isTrue();
-    assertThat(index.getCurrentAddress()).isSameAs(addr1);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
     assertThat(index.seekTo(addr2)).isTrue();
-    assertThat(index.getCurrentAddress()).isSameAs(addr2);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);
     index.seekTo(new FakeSocketAddress());
     // Failed seekTo doesn't change the index
-    assertThat(index.getCurrentAddress()).isSameAs(addr2);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);
   }
 
   /** Create ClientTransportOptions. Should not be reused if it may be mutated. */

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

@@ -1576,7 +1576,7 @@ public class ManagedChannelImplTest {
     verify(mockTransport).newStream(same(method), same(headers), callOptionsCaptor.capture());
 
     CallOptions capturedCallOption = callOptionsCaptor.getValue();
-    assertThat(capturedCallOption.getDeadline()).isSameAs(callOptions.getDeadline());
+    assertThat(capturedCallOption.getDeadline()).isSameInstanceAs(callOptions.getDeadline());
     assertThat(capturedCallOption.getOption(GrpcUtil.CALL_OPTIONS_RPC_OWNED_BY_BALANCER)).isTrue();
   }
 
@@ -3432,7 +3432,7 @@ public class ManagedChannelImplTest {
     NameResolver.Helper helper = capturedHelper.get();
     assertThat(helper).isNotNull();
     assertThat(helper.getDefaultPort()).isEqualTo(DEFAULT_PORT);
-    assertThat(helper.getProxyDetector()).isSameAs(neverProxy);
+    assertThat(helper.getProxyDetector()).isSameInstanceAs(neverProxy);
   }
 
   @Test
@@ -3476,7 +3476,7 @@ public class ManagedChannelImplTest {
     Attributes attrs = capturedParams.get();
     assertThat(attrs).isNotNull();
     assertThat(attrs.get(NameResolver.Factory.PARAMS_DEFAULT_PORT)).isEqualTo(DEFAULT_PORT);
-    assertThat(attrs.get(NameResolver.Factory.PARAMS_PROXY_DETECTOR)).isSameAs(neverProxy);
+    assertThat(attrs.get(NameResolver.Factory.PARAMS_PROXY_DETECTOR)).isSameInstanceAs(neverProxy);
   }
 
   @Test
@@ -3534,8 +3534,8 @@ public class ManagedChannelImplTest {
     NameResolver.Helper helper = capturedHelper.get();
     assertThat(helper).isNotNull();
     assertThat(helper.getDefaultPort()).isEqualTo(DEFAULT_PORT);
-    assertThat(helper.getProxyDetector()).isSameAs(neverProxy);
+    assertThat(helper.getProxyDetector()).isSameInstanceAs(neverProxy);
-    assertThat(helper.getSynchronizationContext()).isSameAs(channel.syncContext);
+    assertThat(helper.getSynchronizationContext()).isSameInstanceAs(channel.syncContext);
   }
 
   @Test

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

@@ -163,7 +163,7 @@ public class RoundRobinLoadBalancerTest {
       capturedAddrs.add(arg.getAddresses());
     }
 
-    assertThat(capturedAddrs).containsAllIn(subchannels.keySet());
+    assertThat(capturedAddrs).containsAtLeastElementsIn(subchannels.keySet());
     for (Subchannel subchannel : subchannels.values()) {
       verify(subchannel).requestConnection();
       verify(subchannel, never()).shutdown();

examples/android/clientcache/app/build.gradle

@@ -55,6 +55,6 @@ dependencies {
     implementation 'javax.annotation:javax.annotation-api:1.2'
 
     testImplementation 'junit:junit:4.12'
-    testImplementation 'com.google.truth:truth:0.36'
+    testImplementation 'com.google.truth:truth:0.44'
     testImplementation 'io.grpc:grpc-testing:1.21.0-SNAPSHOT' // CURRENT_GRPC_VERSION
 }

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

@@ -132,7 +132,7 @@ public class CachedSubchannelPoolTest {
 
     Subchannel subchannel2 = pool.takeOrCreateSubchannel(EAG2, ATTRS2, mockListener);
     assertThat(subchannel2).isNotNull();
-    assertThat(subchannel2).isNotSameAs(subchannel1);
+    assertThat(subchannel2).isNotSameInstanceAs(subchannel1);
     verify(helper).createSubchannel(argsWith(EAG2, "2"));
 
     pool.returnSubchannel(subchannel1);
@@ -162,7 +162,7 @@ public class CachedSubchannelPoolTest {
 
     Subchannel subchannel2 = pool.takeOrCreateSubchannel(EAG2, ATTRS2, mockListener);
     assertThat(subchannel2).isNotNull();
-    assertThat(subchannel2).isNotSameAs(subchannel1);
+    assertThat(subchannel2).isNotSameInstanceAs(subchannel1);
     verify(helper).createSubchannel(argsWith(EAG2, "2"));
 
     pool.returnSubchannel(subchannel1);
@@ -172,7 +172,7 @@ public class CachedSubchannelPoolTest {
 
     // This will cancel the shutdown timer for subchannel1
     Subchannel subchannel1a = pool.takeOrCreateSubchannel(EAG1, ATTRS1, mockListener);
-    assertThat(subchannel1a).isSameAs(subchannel1);
+    assertThat(subchannel1a).isSameInstanceAs(subchannel1);
 
     pool.returnSubchannel(subchannel2);
 
@@ -184,7 +184,7 @@ public class CachedSubchannelPoolTest {
 
     // pool will create a new channel for EAG2 when requested
     Subchannel subchannel2a = pool.takeOrCreateSubchannel(EAG2, ATTRS2, mockListener);
-    assertThat(subchannel2a).isNotSameAs(subchannel2);
+    assertThat(subchannel2a).isNotSameInstanceAs(subchannel2);
     verify(helper, times(2)).createSubchannel(argsWith(EAG2, "2"));
 
     // subchannel1 expires SHUTDOWN_TIMEOUT_MS after being returned
@@ -222,11 +222,13 @@ public class CachedSubchannelPoolTest {
     SubchannelStateListener mockListener2 = mock(SubchannelStateListener.class);
 
     // Saved state is populated to new mockListeners
-    assertThat(pool.takeOrCreateSubchannel(EAG1, ATTRS1, mockListener1)).isSameAs(subchannel1);
+    assertThat(pool.takeOrCreateSubchannel(EAG1, ATTRS1, mockListener1))
+        .isSameInstanceAs(subchannel1);
     verify(mockListener1).onSubchannelState(same(subchannel1), same(anotherFailureState));
     verifyNoMoreInteractions(mockListener1);
 
-    assertThat(pool.takeOrCreateSubchannel(EAG2, ATTRS2, mockListener2)).isSameAs(subchannel2);
+    assertThat(pool.takeOrCreateSubchannel(EAG2, ATTRS2, mockListener2))
+        .isSameInstanceAs(subchannel2);
     verify(mockListener2).onSubchannelState(same(subchannel2), same(TRANSIENT_FAILURE_STATE));
     verifyNoMoreInteractions(mockListener2);
 
@@ -278,7 +280,7 @@ public class CachedSubchannelPoolTest {
             .setAddresses(EAG1).setStateListener(mockListener)
             .build());
     Subchannel subchannel1c = pool.takeOrCreateSubchannel(EAG1, ATTRS1, mockListener);
-    assertThat(subchannel1).isNotSameAs(subchannel1c);
+    assertThat(subchannel1).isNotSameInstanceAs(subchannel1c);
     try {
       pool.returnSubchannel(subchannel1);
       fail("Should throw");

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

@@ -444,7 +444,7 @@ public class GrpclbLoadBalancerTest {
     PickSubchannelArgs args = mock(PickSubchannelArgs.class);
 
     verify(subchannel, never()).requestConnection();
-    assertThat(picker.pickSubchannel(args)).isSameAs(PickResult.withNoResult());
+    assertThat(picker.pickSubchannel(args)).isSameInstanceAs(PickResult.withNoResult());
     verify(subchannel).requestConnection();
   }
 
@@ -463,13 +463,13 @@ public class GrpclbLoadBalancerTest {
     PickSubchannelArgs args = mock(PickSubchannelArgs.class);
 
     verify(subchannel, never()).requestConnection();
-    assertThat(picker.pickSubchannel(args)).isSameAs(PickResult.withNoResult());
+    assertThat(picker.pickSubchannel(args)).isSameInstanceAs(PickResult.withNoResult());
     verify(subchannel).requestConnection();
 
-    assertThat(picker.pickSubchannel(args)).isSameAs(DROP_PICK_RESULT);
+    assertThat(picker.pickSubchannel(args)).isSameInstanceAs(DROP_PICK_RESULT);
 
     verify(subchannel).requestConnection();
-    assertThat(picker.pickSubchannel(args)).isSameAs(PickResult.withNoResult());
+    assertThat(picker.pickSubchannel(args)).isSameInstanceAs(PickResult.withNoResult());
     verify(subchannel, times(2)).requestConnection();
   }
 
@@ -1820,7 +1820,7 @@ public class GrpclbLoadBalancerTest {
     // ... until it's selected
     PickSubchannelArgs args = mock(PickSubchannelArgs.class);
     PickResult pick = picker5.pickSubchannel(args);
-    assertThat(pick).isSameAs(PickResult.withNoResult());
+    assertThat(pick).isSameInstanceAs(PickResult.withNoResult());
     verify(subchannel).requestConnection();
 
     // ... or requested by application

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

@@ -70,7 +70,7 @@ public class TokenAttachingTracerFactoryTest {
 
     ClientStreamTracer tracer = factory.newClientStreamTracer(info, headers);
     verify(delegate).newClientStreamTracer(same(info), same(headers));
-    assertThat(tracer).isSameAs(fakeTracer);
+    assertThat(tracer).isSameInstanceAs(fakeTracer);
     assertThat(headers.getAll(GrpclbConstants.TOKEN_METADATA_KEY)).containsExactly("token0001");
   }
 
@@ -96,7 +96,7 @@ public class TokenAttachingTracerFactoryTest {
 
     ClientStreamTracer tracer = factory.newClientStreamTracer(info, headers);
     verify(delegate).newClientStreamTracer(same(info), same(headers));
-    assertThat(tracer).isSameAs(fakeTracer);
+    assertThat(tracer).isSameInstanceAs(fakeTracer);
     assertThat(headers.get(GrpclbConstants.TOKEN_METADATA_KEY)).isNull();
   }
 

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

@@ -110,7 +110,7 @@ public class NettyServerStreamTest extends NettyStreamTestBase<NettyServerStream
         ArgumentCaptor.forClass(SendResponseHeadersCommand.class);
     verify(writeQueue).enqueue(sendHeadersCap.capture(), eq(true));
     SendResponseHeadersCommand sendHeaders = sendHeadersCap.getValue();
-    assertThat(sendHeaders.stream()).isSameAs(stream.transportState());
+    assertThat(sendHeaders.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(sendHeaders.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(sendHeaders.endOfStream()).isFalse();
@@ -136,7 +136,7 @@ public class NettyServerStreamTest extends NettyStreamTestBase<NettyServerStream
         ArgumentCaptor.forClass(SendResponseHeadersCommand.class);
     verify(writeQueue).enqueue(sendHeadersCap.capture(), eq(true));
     SendResponseHeadersCommand sendHeaders = sendHeadersCap.getValue();
-    assertThat(sendHeaders.stream()).isSameAs(stream.transportState());
+    assertThat(sendHeaders.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(sendHeaders.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(sendHeaders.endOfStream()).isFalse();
@@ -156,7 +156,7 @@ public class NettyServerStreamTest extends NettyStreamTestBase<NettyServerStream
         ArgumentCaptor.forClass(SendResponseHeadersCommand.class);
     verify(writeQueue).enqueue(sendHeadersCap.capture(), eq(true));
     SendResponseHeadersCommand sendHeaders = sendHeadersCap.getValue();
-    assertThat(sendHeaders.stream()).isSameAs(stream.transportState());
+    assertThat(sendHeaders.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(sendHeaders.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(sendHeaders.endOfStream()).isTrue();
@@ -184,7 +184,7 @@ public class NettyServerStreamTest extends NettyStreamTestBase<NettyServerStream
         ArgumentCaptor.forClass(SendResponseHeadersCommand.class);
     verify(writeQueue).enqueue(sendHeadersCap.capture(), eq(true));
     SendResponseHeadersCommand sendHeaders = sendHeadersCap.getValue();
-    assertThat(sendHeaders.stream()).isSameAs(stream.transportState());
+    assertThat(sendHeaders.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(sendHeaders.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(sendHeaders.endOfStream()).isTrue();
@@ -218,7 +218,7 @@ public class NettyServerStreamTest extends NettyStreamTestBase<NettyServerStream
         ArgumentCaptor.forClass(SendResponseHeadersCommand.class);
     verify(writeQueue).enqueue(cmdCap.capture(), eq(true));
     SendResponseHeadersCommand cmd = cmdCap.getValue();
-    assertThat(cmd.stream()).isSameAs(stream.transportState());
+    assertThat(cmd.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(cmd.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(cmd.endOfStream()).isTrue();
@@ -266,7 +266,7 @@ public class NettyServerStreamTest extends NettyStreamTestBase<NettyServerStream
 
     verify(writeQueue).enqueue(cmdCap.capture(), eq(true));
     SendResponseHeadersCommand cmd = cmdCap.getValue();
-    assertThat(cmd.stream()).isSameAs(stream.transportState());
+    assertThat(cmd.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(cmd.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(cmd.endOfStream()).isTrue();

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

@@ -341,7 +341,7 @@ public class WriteBufferingAndExceptionHandlerTest {
     }).sync();
 
     assertThat(chan.pipeline().context(handler)).isNull();
-    assertThat(write.get().getClass()).isSameAs(Object.class);
+    assertThat(write.get().getClass()).isSameInstanceAs(Object.class);
     assertTrue(flush.get());
     assertThat(chan.pipeline()).doesNotContain(handler);
   }

repositories.bzl

@@ -265,9 +265,9 @@ def com_google_protobuf_nano_protobuf_javanano():
 def com_google_truth_truth():
     jvm_maven_import_external(
         name = "com_google_truth_truth",
-        artifact = "com.google.truth:truth:0.42",
+        artifact = "com.google.truth:truth:0.44",
         server_urls = ["http://central.maven.org/maven2"],
-        artifact_sha256 = "dd652bdf0c4427c59848ac0340fd6b6d20c2cbfaa3c569a8366604dbcda5214c",
+        artifact_sha256 = "a9e6796786c9c77a5fe19b08e72fe0a620d53166df423d8861af9ebef4dc4247",
         licenses = ["notice"],  # Apache 2.0
     )
 

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

@@ -268,7 +268,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
       Attributes attrs = Attributes.newBuilder()
           .set(SUBCHANNEL_ATTR_KEY, subchannelAttrValue).build();
       // We don't wrap Subchannels, thus origLb gets the original Subchannels.
-      assertThat(createSubchannel(i, attrs)).isSameAs(subchannels[i]);
+      assertThat(createSubchannel(i, attrs)).isSameInstanceAs(subchannels[i]);
       verify(origHelper, times(i + 1)).createSubchannel(createArgsCaptor.capture());
       assertThat(createArgsCaptor.getValue().getAddresses()).isEqualTo(eagLists[i]);
       assertThat(createArgsCaptor.getValue().getAttributes().get(SUBCHANNEL_ATTR_KEY))
@@ -442,7 +442,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
     verifyNoMoreInteractions(origLb);
 
     FakeSubchannel subchannel = (FakeSubchannel) createSubchannel(0, Attributes.EMPTY);
-    assertThat(subchannel).isSameAs(subchannels[0]);
+    assertThat(subchannel).isSameInstanceAs(subchannels[0]);
     SubchannelStateListener mockListener = mockStateListeners[0];
     InOrder inOrder = inOrder(mockListener, backoffPolicyProvider, backoffPolicy1, backoffPolicy2);
 
@@ -516,7 +516,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
 
     SubchannelStateListener mockStateListener = mockStateListeners[0];
     Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
-    assertThat(subchannel).isSameAs(subchannels[0]);
+    assertThat(subchannel).isSameInstanceAs(subchannels[0]);
     InOrder inOrder =
         inOrder(mockStateListener, backoffPolicyProvider, backoffPolicy1, backoffPolicy2);
 
@@ -657,7 +657,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
     verifyNoMoreInteractions(origLb);
 
     Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
-    assertThat(subchannel).isSameAs(subchannels[0]);
+    assertThat(subchannel).isSameInstanceAs(subchannels[0]);
     InOrder inOrder = inOrder(origLb, mockStateListeners[0]);
 
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
@@ -701,7 +701,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
     verifyNoMoreInteractions(origLb);
 
     Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
-    assertThat(subchannel).isSameAs(subchannels[0]);
+    assertThat(subchannel).isSameInstanceAs(subchannels[0]);
     InOrder inOrder = inOrder(origLb, mockStateListeners[0]);
 
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
@@ -755,7 +755,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
     verifyNoMoreInteractions(origLb);
 
     Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
-    assertThat(subchannel).isSameAs(subchannels[0]);
+    assertThat(subchannel).isSameInstanceAs(subchannels[0]);
     InOrder inOrder = inOrder(origLb, mockStateListeners[0]);
 
     // Underlying subchannel is not READY initially
@@ -803,7 +803,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
 
     Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
     SubchannelStateListener mockListener = mockStateListeners[0];
-    assertThat(subchannel).isSameAs(subchannels[0]);
+    assertThat(subchannel).isSameInstanceAs(subchannels[0]);
     InOrder inOrder = inOrder(origLb, mockListener);
 
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
@@ -863,7 +863,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
 
     Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
     SubchannelStateListener mockListener = mockStateListeners[0];
-    assertThat(subchannel).isSameAs(subchannels[0]);
+    assertThat(subchannel).isSameInstanceAs(subchannels[0]);
     InOrder inOrder = inOrder(origLb, mockListener);
 
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
@@ -935,7 +935,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
 
     Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
     SubchannelStateListener mockListener = mockStateListeners[0];
-    assertThat(subchannel).isSameAs(subchannels[0]);
+    assertThat(subchannel).isSameInstanceAs(subchannels[0]);
     InOrder inOrder = inOrder(origLb, mockListener);
     HealthImpl healthImpl = healthImpls[0];
 
@@ -1021,7 +1021,7 @@ public class HealthCheckingLoadBalancerFactoryTest {
 
     Subchannel subchannel = createSubchannel(0, Attributes.EMPTY);
     SubchannelStateListener mockListener = mockStateListeners[0];
-    assertThat(subchannel).isSameAs(subchannels[0]);
+    assertThat(subchannel).isSameInstanceAs(subchannels[0]);
 
     // Trigger the health check
     deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));

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

@@ -150,7 +150,7 @@ public class HealthStatusManagerTest {
   public void getHealthService_getterReturnsTheSameHealthRefAfterUpdate() throws Exception {
     BindableService health = manager.getHealthService();
     manager.setStatus(SERVICE1, ServingStatus.UNKNOWN);
-    assertThat(health).isSameAs(manager.getHealthService());
+    assertThat(health).isSameInstanceAs(manager.getHealthService());
   }
 
   @Test

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

@@ -131,23 +131,23 @@ public class InterLocalityPickerTest {
         fakeRandom);
 
     fakeRandom.nextInt = 0;
-    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameAs(pickResult1);
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult1);
     assertThat(fakeRandom.bound).isEqualTo(25);
 
     fakeRandom.nextInt = 1;
-    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameAs(pickResult1);
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult1);
     assertThat(fakeRandom.bound).isEqualTo(25);
 
     fakeRandom.nextInt = 14;
-    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameAs(pickResult1);
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult1);
     assertThat(fakeRandom.bound).isEqualTo(25);
 
     fakeRandom.nextInt = 15;
-    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameAs(pickResult3);
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult3);
     assertThat(fakeRandom.bound).isEqualTo(25);
 
     fakeRandom.nextInt = 24;
-    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameAs(pickResult3);
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult3);
     assertThat(fakeRandom.bound).isEqualTo(25);
   }
 
@@ -167,19 +167,19 @@ public class InterLocalityPickerTest {
         fakeRandom);
 
     fakeRandom.nextInt = 0;
-    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameAs(pickResult0);
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult0);
     assertThat(fakeRandom.bound).isEqualTo(4);
 
     fakeRandom.nextInt = 1;
-    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameAs(pickResult1);
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult1);
     assertThat(fakeRandom.bound).isEqualTo(4);
 
     fakeRandom.nextInt = 2;
-    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameAs(pickResult2);
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult2);
     assertThat(fakeRandom.bound).isEqualTo(4);
 
     fakeRandom.nextInt = 3;
-    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameAs(pickResult3);
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult3);
     assertThat(fakeRandom.bound).isEqualTo(4);
   }
 }

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

@@ -290,7 +290,7 @@ public class XdsLoadBalancerTest {
 
     XdsLbState xdsLbState2 = lb.getXdsLbStateForTest();
     assertThat(xdsLbState2.childPolicy).isNull();
-    assertThat(xdsLbState2).isSameAs(xdsLbState1);
+    assertThat(xdsLbState2).isSameInstanceAs(xdsLbState1);
 
     // verify oobChannel is unchanged
     verify(helper).createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>any(), anyString());

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

@@ -126,8 +126,8 @@ public class XdsLoadReportStoreTest {
     ArgumentCaptor<Metadata> metadataArgumentCaptor = ArgumentCaptor.forClass(null);
     verify(mockFactory).newClientStreamTracer(streamInfoArgumentCaptor.capture(),
         metadataArgumentCaptor.capture());
-    assertThat(streamInfoArgumentCaptor.getValue()).isSameAs(STREAM_INFO);
+    assertThat(streamInfoArgumentCaptor.getValue()).isSameInstanceAs(STREAM_INFO);
-    assertThat(metadataArgumentCaptor.getValue()).isSameAs(metadata);
+    assertThat(metadataArgumentCaptor.getValue()).isSameInstanceAs(metadata);
     verify(mockTracer).streamClosed(Status.OK);
   }
 
@@ -142,7 +142,7 @@ public class XdsLoadReportStoreTest {
     loadStore.addLocality(locality1);
     PickResult pickResult1 = PickResult.withSubchannel(fakeSubchannel);
     PickResult interceptedPickResult1 = loadStore.interceptPickResult(pickResult1, locality1);
-    assertThat(interceptedPickResult1.getSubchannel()).isSameAs(fakeSubchannel);
+    assertThat(interceptedPickResult1.getSubchannel()).isSameInstanceAs(fakeSubchannel);
     assertThat(localityLoadCounters).containsKey(locality1);
     ClientStreamTracer tracer =
         interceptedPickResult1