grpc
/
grpc-java
mirror of https://github.com/grpc/grpc-java.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Replace usages of deprecated ExpectedException in grpc-api and grpc-core (#11962)

This commit is contained in:
Alex Panchenko 2025-03-21 09:30:24 +02:00 committed by GitHub
parent d2d72cda83
commit d60e6fc251
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
19 changed files with 185 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
api/build.gradle
View File

@ -47,6 +47,7 @@ dependencies {
testImplementation project(':grpc-core')
testImplementation project(':grpc-testing')
testImplementation libraries.guava.testlib
testImplementation libraries.truth
signature (libraries.signature.java) {
artifact {

35
api/src/test/java/io/grpc/MetadataTest.java
View File

@ -16,6 +16,7 @@
package io.grpc;
import static com.google.common.truth.Truth.assertThat;
import static java.nio.charset.StandardCharsets.US_ASCII;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertArrayEquals;
@ -24,6 +25,7 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@ -37,9 +39,7 @@ import java.io.InputStream;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Locale;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@ -49,9 +49,6 @@ import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class MetadataTest {
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule public final ExpectedException thrown = ExpectedException.none();
private static final Metadata.BinaryMarshaller<Fish> FISH_MARSHALLER =
new Metadata.BinaryMarshaller<Fish>() {
@Override
@ -65,7 +62,7 @@ public class MetadataTest {
}
};
private static class FishStreamMarsaller implements Metadata.BinaryStreamMarshaller<Fish> {
private static class FishStreamMarshaller implements Metadata.BinaryStreamMarshaller<Fish> {
@Override
public InputStream toStream(Fish fish) {
return new ByteArrayInputStream(FISH_MARSHALLER.toBytes(fish));
@ -82,7 +79,7 @@ public class MetadataTest {
}
private static final Metadata.BinaryStreamMarshaller<Fish> FISH_STREAM_MARSHALLER =
new FishStreamMarsaller();
new FishStreamMarshaller();
/** A pattern commonly used to avoid unnecessary serialization of immutable objects. */
private static final class FakeFishStream extends InputStream {
@ -121,10 +118,9 @@ public class MetadataTest {
@Test
public void noPseudoHeaders() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Invalid character");
Metadata.Key.of(":test-bin", FISH_MARSHALLER);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> Metadata.Key.of(":test-bin", FISH_MARSHALLER));
assertThat(e).hasMessageThat().isEqualTo("Invalid character ':' in key name ':test-bin'");
}
@Test
@ -186,8 +182,7 @@ public class MetadataTest {
Iterator<Fish> i = metadata.getAll(KEY).iterator();
assertEquals(lance, i.next());
thrown.expect(UnsupportedOperationException.class);
i.remove();
assertThrows(UnsupportedOperationException.class, i::remove);
}
@Test
@ -271,17 +266,15 @@ public class MetadataTest {
@Test
public void shortBinaryKeyName() {
thrown.expect(IllegalArgumentException.class);
Metadata.Key.of("-bin", FISH_MARSHALLER);
assertThrows(IllegalArgumentException.class, () -> Metadata.Key.of("-bin", FISH_MARSHALLER));
}
@Test
public void invalidSuffixBinaryKeyName() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Binary header is named");
Metadata.Key.of("nonbinary", FISH_MARSHALLER);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> Metadata.Key.of("nonbinary", FISH_MARSHALLER));
assertThat(e).hasMessageThat()
.isEqualTo("Binary header is named nonbinary. It must end with -bin");
}
@Test
@ -415,7 +408,7 @@ public class MetadataTest {
h.put(KEY_STREAMED, salmon);
// Get using a different marshaller instance.
Fish fish = h.get(copyKey(KEY_STREAMED, new FishStreamMarsaller()));
Fish fish = h.get(copyKey(KEY_STREAMED, new FishStreamMarshaller()));
assertEquals(salmon, fish);
}

6
api/src/test/java/io/grpc/MethodDescriptorTest.java
View File

@ -26,9 +26,7 @@ import static org.junit.Assert.assertTrue;
import io.grpc.MethodDescriptor.Marshaller;
import io.grpc.MethodDescriptor.MethodType;
import io.grpc.testing.TestMethodDescriptors;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@ -37,10 +35,6 @@ import org.junit.runners.JUnit4;
*/
@RunWith(JUnit4.class)
public class MethodDescriptorTest {
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void createMethodDescriptor() {
MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()

18
api/src/test/java/io/grpc/ServerInterceptorsTest.java
View File

@ -19,6 +19,7 @@ package io.grpc;
import static com.google.common.collect.Iterables.getOnlyElement;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.AdditionalAnswers.delegatesTo;
import static org.mockito.ArgumentMatchers.same;
@ -40,7 +41,6 @@ import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.ArgumentMatchers;
@ -55,10 +55,6 @@ public class ServerInterceptorsTest {
@Rule
public final MockitoRule mocks = MockitoJUnit.rule();
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Mock
private Marshaller<String> requestMarshaller;
@ -111,21 +107,21 @@ public class ServerInterceptorsTest {
public void npeForNullServiceDefinition() {
ServerServiceDefinition serviceDef = null;
List<ServerInterceptor> interceptors = Arrays.asList();
thrown.expect(NullPointerException.class);
ServerInterceptors.intercept(serviceDef, interceptors);
assertThrows(NullPointerException.class,
() -> ServerInterceptors.intercept(serviceDef, interceptors));
}
@Test
public void npeForNullInterceptorList() {
thrown.expect(NullPointerException.class);
ServerInterceptors.intercept(serviceDefinition, (List<ServerInterceptor>) null);
assertThrows(NullPointerException.class,
() -> ServerInterceptors.intercept(serviceDefinition, (List<ServerInterceptor>) null));
}
@Test
public void npeForNullInterceptor() {
List<ServerInterceptor> interceptors = Arrays.asList((ServerInterceptor) null);
thrown.expect(NullPointerException.class);
ServerInterceptors.intercept(serviceDefinition, interceptors);
assertThrows(NullPointerException.class,
() -> ServerInterceptors.intercept(serviceDefinition, interceptors));
}
@Test

19
api/src/test/java/io/grpc/ServerServiceDefinitionTest.java
View File

@ -18,14 +18,13 @@ package io.grpc;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.fail;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@ -52,9 +51,6 @@ public class ServerServiceDefinitionTest {
= ServerMethodDefinition.create(method1, methodHandler1);
private ServerMethodDefinition<String, Integer> methodDef2
= ServerMethodDefinition.create(method2, methodHandler2);
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule
public ExpectedException thrown = ExpectedException.none();
@Test
public void noMethods() {
@ -91,9 +87,7 @@ public class ServerServiceDefinitionTest {
ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1);
ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd)
.addMethod(method1, methodHandler1);
thrown.expect(IllegalStateException.class);
ssd.addMethod(diffMethod1, methodHandler2)
.build();
assertThrows(IllegalStateException.class, () -> ssd.addMethod(diffMethod1, methodHandler2));
}
@Test
@ -101,8 +95,7 @@ public class ServerServiceDefinitionTest {
ServiceDescriptor sd = new ServiceDescriptor(serviceName);
ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd)
.addMethod(methodDef1);
thrown.expect(IllegalStateException.class);
ssd.build();
assertThrows(IllegalStateException.class, ssd::build);
}
@Test
@ -110,16 +103,14 @@ public class ServerServiceDefinitionTest {
ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1);
ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd)
.addMethod(diffMethod1, methodHandler1);
thrown.expect(IllegalStateException.class);
ssd.build();
assertThrows(IllegalStateException.class, ssd::build);
}
@Test
public void buildMisaligned_missingMethod() {
ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1);
ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd);
thrown.expect(IllegalStateException.class);
ssd.build();
assertThrows(IllegalStateException.class, ssd::build);
}
@Test

51
api/src/test/java/io/grpc/ServiceDescriptorTest.java
View File

@ -16,17 +16,18 @@
package io.grpc;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import com.google.common.truth.StringSubject;
import io.grpc.MethodDescriptor.MethodType;
import io.grpc.testing.TestMethodDescriptors;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@ -36,32 +37,27 @@ import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class ServiceDescriptorTest {
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void failsOnNullName() {
thrown.expect(NullPointerException.class);
thrown.expectMessage("name");
new ServiceDescriptor(null, Collections.<MethodDescriptor<?, ?>>emptyList());
List<MethodDescriptor<?, ?>> methods = Collections.emptyList();
NullPointerException e = assertThrows(NullPointerException.class,
() -> new ServiceDescriptor(null, methods));
assertThat(e).hasMessageThat().isEqualTo("name");
}
@Test
public void failsOnNullMethods() {
thrown.expect(NullPointerException.class);
thrown.expectMessage("methods");
new ServiceDescriptor("name", (Collection<MethodDescriptor<?, ?>>) null);
NullPointerException e = assertThrows(NullPointerException.class,
() -> new ServiceDescriptor("name", (Collection<MethodDescriptor<?, ?>>) null));
assertThat(e).hasMessageThat().isEqualTo("methods");
}
@Test
public void failsOnNullMethod() {
thrown.expect(NullPointerException.class);
thrown.expectMessage("method");
new ServiceDescriptor("name", Collections.<MethodDescriptor<?, ?>>singletonList(null));
List<MethodDescriptor<?, ?>> methods = Collections.singletonList(null);
NullPointerException e = assertThrows(NullPointerException.class,
() -> new ServiceDescriptor("name", methods));
assertThat(e).hasMessageThat().isEqualTo("method");
}
@Test
@ -69,15 +65,17 @@ public class ServiceDescriptorTest {
List<MethodDescriptor<?, ?>> descriptors = Collections.<MethodDescriptor<?, ?>>singletonList(
MethodDescriptor.<Void, Void>newBuilder()
.setType(MethodType.UNARY)
.setFullMethodName(MethodDescriptor.generateFullMethodName("wrongservice", "method"))
.setFullMethodName(MethodDescriptor.generateFullMethodName("wrongService", "method"))
.setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
.setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
.build());
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("service names");
new ServiceDescriptor("name", descriptors);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> new ServiceDescriptor("fooService", descriptors));
StringSubject error = assertThat(e).hasMessageThat();
error.contains("service names");
error.contains("fooService");
error.contains("wrongService");
}
@Test
@ -96,10 +94,9 @@ public class ServiceDescriptorTest {
.setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
.build());
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("duplicate");
new ServiceDescriptor("name", descriptors);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> new ServiceDescriptor("name", descriptors));
assertThat(e).hasMessageThat().isEqualTo("duplicate name name/method");
}
@Test

23
core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java
View File

@ -23,6 +23,7 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.AdditionalAnswers.delegatesTo;
@ -57,7 +58,6 @@ import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.ArgumentCaptor;
@ -76,8 +76,6 @@ import org.mockito.stubbing.Answer;
public class AbstractClientStreamTest {
@Rule public final MockitoRule mocks = MockitoJUnit.rule();
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule public final ExpectedException thrown = ExpectedException.none();
private final StatsTraceContext statsTraceCtx = StatsTraceContext.NOOP;
private final TransportTracer transportTracer = new TransportTracer();
@ -136,9 +134,7 @@ public class AbstractClientStreamTest {
AbstractClientStream stream =
new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
stream.start(listener);
thrown.expect(NullPointerException.class);
stream.cancel(null);
assertThrows(NullPointerException.class, () -> stream.cancel(null));
}
@Test
@ -164,9 +160,7 @@ public class AbstractClientStreamTest {
AbstractClientStream stream =
new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
thrown.expect(NullPointerException.class);
stream.start(null);
assertThrows(NullPointerException.class, () -> stream.start(null));
}
@Test
@ -174,9 +168,7 @@ public class AbstractClientStreamTest {
AbstractClientStream stream =
new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
stream.start(mockListener);
thrown.expect(IllegalStateException.class);
stream.start(mockListener);
assertThrows(IllegalStateException.class, () -> stream.start(mockListener));
}
@Test
@ -188,8 +180,7 @@ public class AbstractClientStreamTest {
TransportState state = stream.transportState();
thrown.expect(NullPointerException.class);
state.inboundDataReceived(null);
assertThrows(NullPointerException.class, () -> state.inboundDataReceived(null));
}
@Test
@ -212,8 +203,8 @@ public class AbstractClientStreamTest {
TransportState state = stream.transportState();
thrown.expect(IllegalStateException.class);
state.inboundHeadersReceived(new Metadata());
Metadata headers = new Metadata();
assertThrows(IllegalStateException.class, () -> state.inboundHeadersReceived(headers));
}
@Test

30
core/src/test/java/io/grpc/internal/AbstractServerStreamTest.java
View File

@ -18,6 +18,7 @@ package io.grpc.internal;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.AdditionalAnswers.delegatesTo;
import static org.mockito.ArgumentMatchers.any;
@ -45,9 +46,7 @@ import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.TimeUnit;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.ArgumentCaptor;
@ -60,9 +59,6 @@ public class AbstractServerStreamTest {
private static final int TIMEOUT_MS = 1000;
private static final int MAX_MESSAGE_SIZE = 100;
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule public final ExpectedException thrown = ExpectedException.none();
private final WritableBufferAllocator allocator = new WritableBufferAllocator() {
@Override
public WritableBuffer allocate(int capacityHint) {
@ -226,9 +222,9 @@ public class AbstractServerStreamTest {
public void setListener_setOnlyOnce() {
TransportState state = stream.transportState();
state.setListener(new ServerStreamListenerBase());
thrown.expect(IllegalStateException.class);
state.setListener(new ServerStreamListenerBase());
ServerStreamListenerBase listener2 = new ServerStreamListenerBase();
assertThrows(IllegalStateException.class, () -> state.setListener(listener2));
}
@Test
@ -238,8 +234,7 @@ public class AbstractServerStreamTest {
TransportState state = stream.transportState();
thrown.expect(IllegalStateException.class);
state.onStreamAllocated();
assertThrows(IllegalStateException.class, state::onStreamAllocated);
}
@Test
@ -255,8 +250,7 @@ public class AbstractServerStreamTest {
public void setListener_failsOnNull() {
TransportState state = stream.transportState();
thrown.expect(NullPointerException.class);
state.setListener(null);
assertThrows(NullPointerException.class, () -> state.setListener(null));
}
// TODO(ericgribkoff) This test is only valid if deframeInTransportThread=true, as otherwise the
@ -284,9 +278,7 @@ public class AbstractServerStreamTest {
@Test
public void writeHeaders_failsOnNullHeaders() {
thrown.expect(NullPointerException.class);
stream.writeHeaders(null, true);
assertThrows(NullPointerException.class, () -> stream.writeHeaders(null, true));
}
@Test
@ -336,16 +328,13 @@ public class AbstractServerStreamTest {
@Test
public void close_failsOnNullStatus() {
thrown.expect(NullPointerException.class);
stream.close(null, new Metadata());
Metadata trailers = new Metadata();
assertThrows(NullPointerException.class, () -> stream.close(null, trailers));
}
@Test
public void close_failsOnNullMetadata() {
thrown.expect(NullPointerException.class);
stream.close(Status.INTERNAL, null);
assertThrows(NullPointerException.class, () -> stream.close(Status.INTERNAL, null));
}
@Test
@ -451,4 +440,3 @@ public class AbstractServerStreamTest {
}
}
}

6
core/src/test/java/io/grpc/internal/ConnectivityStateManagerTest.java
View File

@ -27,9 +27,7 @@ import com.google.common.util.concurrent.MoreExecutors;
import io.grpc.ConnectivityState;
import java.util.LinkedList;
import java.util.concurrent.Executor;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@ -38,10 +36,6 @@ import org.junit.runners.JUnit4;
*/
@RunWith(JUnit4.class)
public class ConnectivityStateManagerTest {
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule
public final ExpectedException thrown = ExpectedException.none();
private final FakeClock executor = new FakeClock();
private final ConnectivityStateManager state = new ConnectivityStateManager();
private final LinkedList<ConnectivityState> sink = new LinkedList<>();

28
core/src/test/java/io/grpc/internal/DnsNameResolverTest.java
View File

@ -22,6 +22,7 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
@ -35,6 +36,7 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import com.google.common.base.Stopwatch;
import com.google.common.base.VerifyException;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.google.common.net.InetAddresses;
@ -82,7 +84,6 @@ import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.DisableOnDebug;
import org.junit.rules.ExpectedException;
import org.junit.rules.TestRule;
import org.junit.rules.Timeout;
import org.junit.runner.RunWith;
@ -99,8 +100,6 @@ public class DnsNameResolverTest {
@Rule public final TestRule globalTimeout = new DisableOnDebug(Timeout.seconds(10));
@Rule public final MockitoRule mocks = MockitoJUnit.rule();
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule public final ExpectedException thrown = ExpectedException.none();
private final Map<String, ?> serviceConfig = new LinkedHashMap<>();
@ -914,9 +913,10 @@ public class DnsNameResolverTest {
public void maybeChooseServiceConfig_failsOnMisspelling() {
Map<String, Object> bad = new LinkedHashMap<>();
bad.put("parcentage", 1.0);
thrown.expectMessage("Bad key");
DnsNameResolver.maybeChooseServiceConfig(bad, new Random(), "host");
Random random = new Random();
VerifyException e = assertThrows(VerifyException.class,
() -> DnsNameResolver.maybeChooseServiceConfig(bad, random, "host"));
assertThat(e).hasMessageThat().isEqualTo("Bad key: parcentage=1.0");
}
@Test
@ -1155,25 +1155,25 @@ public class DnsNameResolverTest {
}
@Test
public void parseTxtResults_badTypeFails() throws Exception {
public void parseTxtResults_badTypeFails() {
List<String> txtRecords = new ArrayList<>();
txtRecords.add("some_record");
txtRecords.add("grpc_config={}");
thrown.expect(ClassCastException.class);
thrown.expectMessage("wrong type");
DnsNameResolver.parseTxtResults(txtRecords);
ClassCastException e = assertThrows(ClassCastException.class,
() -> DnsNameResolver.parseTxtResults(txtRecords));
assertThat(e).hasMessageThat().isEqualTo("wrong type {}");
}
@Test
public void parseTxtResults_badInnerTypeFails() throws Exception {
public void parseTxtResults_badInnerTypeFails() {
List<String> txtRecords = new ArrayList<>();
txtRecords.add("some_record");
txtRecords.add("grpc_config=[\"bogus\"]");
thrown.expect(ClassCastException.class);
thrown.expectMessage("not object");
DnsNameResolver.parseTxtResults(txtRecords);
ClassCastException e = assertThrows(ClassCastException.class,
() -> DnsNameResolver.parseTxtResults(txtRecords));
assertThat(e).hasMessageThat().isEqualTo("value bogus for idx 0 in [bogus] is not object");
}
@Test

23
core/src/test/java/io/grpc/internal/GrpcUtilTest.java
View File

@ -22,6 +22,7 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
@ -41,7 +42,6 @@ import io.grpc.testing.TestMethodDescriptors;
import java.util.ArrayList;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.ArgumentCaptor;
@ -57,8 +57,6 @@ public class GrpcUtilTest {
new ClientStreamTracer() {}
};
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule public final ExpectedException thrown = ExpectedException.none();
@Rule public final MockitoRule mocks = MockitoJUnit.rule();
@Captor
@ -201,9 +199,7 @@ public class GrpcUtilTest {
@Test
public void checkAuthority_failsOnNull() {
thrown.expect(NullPointerException.class);
GrpcUtil.checkAuthority(null);
assertThrows(NullPointerException.class, () -> GrpcUtil.checkAuthority(null));
}
@Test
@ -229,19 +225,18 @@ public class GrpcUtilTest {
@Test
public void checkAuthority_failsOnInvalidAuthority() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Invalid authority");
GrpcUtil.checkAuthority("[ : : 1]");
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> GrpcUtil.checkAuthority("[ : : 1]"));
assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [ : : 1]");
}
@Test
public void checkAuthority_userInfoNotAllowed() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Userinfo");
GrpcUtil.checkAuthority("foo@valid");
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> GrpcUtil.checkAuthority("foo@valid"));
assertThat(e).hasMessageThat()
.isEqualTo("Userinfo must not be present on authority: 'foo@valid'");
}
@Test

13
core/src/test/java/io/grpc/internal/InternalSubchannelTest.java
View File

@ -27,6 +27,7 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
@ -65,7 +66,6 @@ import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.Mock;
@ -79,9 +79,6 @@ import org.mockito.junit.MockitoRule;
public class InternalSubchannelTest {
@Rule
public final MockitoRule mocks = MockitoJUnit.rule();
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule
public final ExpectedException thrown = ExpectedException.none();
private static final String AUTHORITY = "fakeauthority";
private static final String USER_AGENT = "mosaic";
@ -544,8 +541,9 @@ public class InternalSubchannelTest {
public void updateAddresses_emptyEagList_throws() {
SocketAddress addr = new FakeSocketAddress();
createInternalSubchannel(addr);
thrown.expect(IllegalArgumentException.class);
internalSubchannel.updateAddresses(Arrays.<EquivalentAddressGroup>asList());
List<EquivalentAddressGroup> newAddressGroups = Collections.emptyList();
assertThrows(IllegalArgumentException.class,
() -> internalSubchannel.updateAddresses(newAddressGroups));
}
@Test
@ -553,8 +551,7 @@ public class InternalSubchannelTest {
SocketAddress addr = new FakeSocketAddress();
createInternalSubchannel(addr);
List<EquivalentAddressGroup> eags = Arrays.asList((EquivalentAddressGroup) null);
thrown.expect(NullPointerException.class);
internalSubchannel.updateAddresses(eags);
assertThrows(NullPointerException.class, () -> internalSubchannel.updateAddresses(eags));
}
@Test public void updateAddresses_intersecting_ready() {

49
core/src/test/java/io/grpc/internal/JsonParserTest.java
View File

@ -17,15 +17,14 @@
package io.grpc.internal;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;
import com.google.gson.stream.MalformedJsonException;
import java.io.EOFException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@ -35,10 +34,6 @@ import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class JsonParserTest {
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void emptyObject() throws IOException {
assertEquals(new LinkedHashMap<String, Object>(), JsonParser.parse("{}"));
@ -75,45 +70,33 @@ public class JsonParserTest {
}
@Test
public void nanFails() throws IOException {
thrown.expect(MalformedJsonException.class);
JsonParser.parse("NaN");
public void nanFails() {
assertThrows(MalformedJsonException.class, () -> JsonParser.parse("NaN"));
}
@Test
public void objectEarlyEnd() throws IOException {
thrown.expect(MalformedJsonException.class);
JsonParser.parse("{foo:}");
public void objectEarlyEnd() {
assertThrows(MalformedJsonException.class, () -> JsonParser.parse("{foo:}"));
}
@Test
public void earlyEndArray() throws IOException {
thrown.expect(EOFException.class);
JsonParser.parse("[1, 2, ");
public void earlyEndArray() {
assertThrows(EOFException.class, () -> JsonParser.parse("[1, 2, "));
}
@Test
public void arrayMissingElement() throws IOException {
thrown.expect(MalformedJsonException.class);
JsonParser.parse("[1, 2, ]");
public void arrayMissingElement() {
assertThrows(MalformedJsonException.class, () -> JsonParser.parse("[1, 2, ]"));
}
@Test
public void objectMissingElement() throws IOException {
thrown.expect(MalformedJsonException.class);
JsonParser.parse("{1: ");
public void objectMissingElement() {
assertThrows(MalformedJsonException.class, () -> JsonParser.parse("{1: "));
}
@Test
public void objectNoName() throws IOException {
thrown.expect(MalformedJsonException.class);
JsonParser.parse("{: 1");
public void objectNoName() {
assertThrows(MalformedJsonException.class, () -> JsonParser.parse("{: 1"));
}
@Test
@ -125,9 +108,7 @@ public class JsonParserTest {
}
@Test
public void duplicate() throws IOException {
thrown.expect(IllegalArgumentException.class);
JsonParser.parse("{\"hi\": 2, \"hi\": 3}");
public void duplicate() {
assertThrows(IllegalArgumentException.class, () -> JsonParser.parse("{\"hi\": 2, \"hi\": 3}"));
}
}

33
core/src/test/java/io/grpc/internal/ManagedChannelImplBuilderTest.java
View File

@ -23,6 +23,7 @@ import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.doReturn;
@ -67,7 +68,6 @@ import java.util.regex.Pattern;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.Mock;
@ -99,8 +99,6 @@ public class ManagedChannelImplBuilderTest {
};
@Rule public final MockitoRule mocks = MockitoJUnit.rule();
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule public final ExpectedException thrown = ExpectedException.none();
@Rule public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
@Mock private ClientTransportFactory mockClientTransportFactory;
@ -424,10 +422,9 @@ public class ManagedChannelImplBuilderTest {
@Test
public void checkAuthority_invalidAuthorityFailed() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Invalid authority");
builder.checkAuthority(DUMMY_AUTHORITY_INVALID);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> builder.checkAuthority(DUMMY_AUTHORITY_INVALID));
assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [ : : 1]");
}
@Test
@ -450,11 +447,10 @@ public class ManagedChannelImplBuilderTest {
@Test
public void disableCheckAuthority_invalidAuthorityFailed() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Invalid authority");
builder.disableCheckAuthority().enableCheckAuthority();
builder.checkAuthority(DUMMY_AUTHORITY_INVALID);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> builder.checkAuthority(DUMMY_AUTHORITY_INVALID));
assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [ : : 1]");
}
@Test
@ -680,14 +676,12 @@ public class ManagedChannelImplBuilderTest {
@Test
public void retryBufferSizeInvalidArg() {
thrown.expect(IllegalArgumentException.class);
builder.retryBufferSize(0L);
assertThrows(IllegalArgumentException.class, () -> builder.retryBufferSize(0L));
}
@Test
public void perRpcBufferLimitInvalidArg() {
thrown.expect(IllegalArgumentException.class);
builder.perRpcBufferLimit(0L);
assertThrows(IllegalArgumentException.class, () -> builder.perRpcBufferLimit(0L));
}
@Test
@ -710,8 +704,7 @@ public class ManagedChannelImplBuilderTest {
Map<String, Object> config = new HashMap<>();
config.put(null, "val");
thrown.expect(IllegalArgumentException.class);
builder.defaultServiceConfig(config);
assertThrows(IllegalArgumentException.class, () -> builder.defaultServiceConfig(config));
}
@Test
@ -721,8 +714,7 @@ public class ManagedChannelImplBuilderTest {
Map<String, Object> config = new HashMap<>();
config.put("key", subConfig);
thrown.expect(IllegalArgumentException.class);
builder.defaultServiceConfig(config);
assertThrows(IllegalArgumentException.class, () -> builder.defaultServiceConfig(config));
}
@Test
@ -730,8 +722,7 @@ public class ManagedChannelImplBuilderTest {
Map<String, Object> config = new HashMap<>();
config.put("key", 3);
thrown.expect(IllegalArgumentException.class);
builder.defaultServiceConfig(config);
assertThrows(IllegalArgumentException.class, () -> builder.defaultServiceConfig(config));
}
@Test

49
core/src/test/java/io/grpc/internal/ManagedChannelServiceConfigTest.java
View File

@ -20,6 +20,7 @@ import static com.google.common.truth.Truth.assertThat;
import static io.grpc.MethodDescriptor.MethodType.UNARY;
import static io.grpc.Status.Code.UNAVAILABLE;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.fail;
import com.google.common.collect.ImmutableList;
@ -34,19 +35,13 @@ import io.grpc.internal.ManagedChannelServiceConfig.MethodInfo;
import io.grpc.testing.TestMethodDescriptors;
import java.util.Collections;
import java.util.Map;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class ManagedChannelServiceConfigTest {
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void managedChannelServiceConfig_shouldParseHealthCheckingConfig() throws Exception {
Map<String, ?> rawServiceConfig =
@ -79,10 +74,9 @@ public class ManagedChannelServiceConfigTest {
Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name1, name2));
Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Duplicate method");
ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
assertThat(e).hasMessageThat().isEqualTo("Duplicate method name service/method");
}
@Test
@ -92,10 +86,9 @@ public class ManagedChannelServiceConfigTest {
Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name1, name2));
Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Duplicate service");
ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
assertThat(e).hasMessageThat().isEqualTo("Duplicate service service");
}
@Test
@ -107,10 +100,9 @@ public class ManagedChannelServiceConfigTest {
Map<String, ?> serviceConfig =
ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig1, methodConfig2));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Duplicate service");
ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
assertThat(e).hasMessageThat().isEqualTo("Duplicate service service");
}
@Test
@ -119,10 +111,9 @@ public class ManagedChannelServiceConfigTest {
Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name));
Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("missing service name for method method1");
ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
assertThat(e).hasMessageThat().isEqualTo("missing service name for method method1");
}
@Test
@ -131,10 +122,9 @@ public class ManagedChannelServiceConfigTest {
Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name));
Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("missing service name for method method1");
ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
assertThat(e).hasMessageThat().isEqualTo("missing service name for method method1");
}
@Test
@ -143,10 +133,9 @@ public class ManagedChannelServiceConfigTest {
Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name));
Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("missing service");
ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null);
IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
() -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
assertThat(e).hasMessageThat().isEqualTo("missing service name for method method");
}
@Test

28
core/src/test/java/io/grpc/internal/MessageDeframerTest.java
View File

@ -20,6 +20,7 @@ import static com.google.common.truth.Truth.assertThat;
import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;
import static org.mockito.ArgumentMatchers.anyInt;
@ -53,10 +54,8 @@ import java.util.Locale;
import java.util.concurrent.TimeUnit;
import java.util.zip.GZIPOutputStream;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.runners.Enclosed;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.junit.runners.Parameterized;
@ -341,9 +340,6 @@ public class MessageDeframerTest {
@RunWith(JUnit4.class)
public static class SizeEnforcingInputStreamTests {
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule
public final ExpectedException thrown = ExpectedException.none();
private TestBaseStreamTracer tracer = new TestBaseStreamTracer();
private StatsTraceContext statsTraceCtx = new StatsTraceContext(new StreamTracer[]{tracer});
@ -381,11 +377,12 @@ public class MessageDeframerTest {
new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx);
try {
thrown.expect(StatusRuntimeException.class);
thrown.expectMessage("RESOURCE_EXHAUSTED: Decompressed gRPC message exceeds");
StatusRuntimeException e = assertThrows(StatusRuntimeException.class, () -> {
while (stream.read() != -1) {
}
});
assertThat(e).hasMessageThat()
.isEqualTo("RESOURCE_EXHAUSTED: Decompressed gRPC message exceeds maximum size 2");
} finally {
stream.close();
}
@ -427,10 +424,10 @@ public class MessageDeframerTest {
byte[] buf = new byte[10];
try {
thrown.expect(StatusRuntimeException.class);
thrown.expectMessage("RESOURCE_EXHAUSTED: Decompressed gRPC message exceeds");
stream.read(buf, 0, buf.length);
StatusRuntimeException e = assertThrows(StatusRuntimeException.class,
() -> stream.read(buf, 0, buf.length));
assertThat(e).hasMessageThat()
.isEqualTo("RESOURCE_EXHAUSTED: Decompressed gRPC message exceeds maximum size 2");
} finally {
stream.close();
}
@ -470,10 +467,9 @@ public class MessageDeframerTest {
new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx);
try {
thrown.expect(StatusRuntimeException.class);
thrown.expectMessage("RESOURCE_EXHAUSTED: Decompressed gRPC message exceeds");
stream.skip(4);
StatusRuntimeException e = assertThrows(StatusRuntimeException.class, () -> stream.skip(4));
assertThat(e).hasMessageThat()
.isEqualTo("RESOURCE_EXHAUSTED: Decompressed gRPC message exceeds maximum size 2");
} finally {
stream.close();
}

42
core/src/test/java/io/grpc/internal/ServerCallImplTest.java
View File

@ -16,12 +16,14 @@
package io.grpc.internal;
import static com.google.common.truth.Truth.assertThat;
import static io.grpc.internal.GrpcUtil.CONTENT_LENGTH_KEY;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
@ -54,7 +56,6 @@ import java.io.InputStreamReader;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.ArgumentCaptor;
@ -64,8 +65,6 @@ import org.mockito.junit.MockitoRule;
@RunWith(JUnit4.class)
public class ServerCallImplTest {
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule public final ExpectedException thrown = ExpectedException.none();
@Rule public final MockitoRule mocks = MockitoJUnit.rule();
@Mock private ServerStream stream;
@ -175,20 +174,20 @@ public class ServerCallImplTest {
@Test
public void sendHeader_failsOnSecondCall() {
call.sendHeaders(new Metadata());
thrown.expect(IllegalStateException.class);
thrown.expectMessage("sendHeaders has already been called");
call.sendHeaders(new Metadata());
Metadata headers = new Metadata();
IllegalStateException e = assertThrows(IllegalStateException.class,
() -> call.sendHeaders(headers));
assertThat(e).hasMessageThat().isEqualTo("sendHeaders has already been called");
}
@Test
public void sendHeader_failsOnClosed() {
call.close(Status.CANCELLED, new Metadata());
thrown.expect(IllegalStateException.class);
thrown.expectMessage("call is closed");
call.sendHeaders(new Metadata());
Metadata headers = new Metadata();
IllegalStateException e = assertThrows(IllegalStateException.class,
() -> call.sendHeaders(headers));
assertThat(e).hasMessageThat().isEqualTo("call is closed");
}
@Test
@ -204,18 +203,16 @@ public class ServerCallImplTest {
call.sendHeaders(new Metadata());
call.close(Status.CANCELLED, new Metadata());
thrown.expect(IllegalStateException.class);
thrown.expectMessage("call is closed");
call.sendMessage(1234L);
IllegalStateException e = assertThrows(IllegalStateException.class,
() -> call.sendMessage(1234L));
assertThat(e).hasMessageThat().isEqualTo("call is closed");
}
@Test
public void sendMessage_failsIfheadersUnsent() {
thrown.expect(IllegalStateException.class);
thrown.expectMessage("sendHeaders has not been called");
call.sendMessage(1234L);
IllegalStateException e = assertThrows(IllegalStateException.class,
() -> call.sendMessage(1234L));
assertThat(e).hasMessageThat().isEqualTo("sendHeaders has not been called");
}
@Test
@ -490,9 +487,10 @@ public class ServerCallImplTest {
InputStream inputStream = UNARY_METHOD.streamRequest(1234L);
thrown.expect(RuntimeException.class);
thrown.expectMessage("unexpected exception");
streamListener.messagesAvailable(new SingleMessageProducer(inputStream));
SingleMessageProducer producer = new SingleMessageProducer(inputStream);
RuntimeException e = assertThrows(RuntimeException.class,
() -> streamListener.messagesAvailable(producer));
assertThat(e).hasMessageThat().isEqualTo("unexpected exception");
}
private static class LongMarshaller implements Marshaller<Long> {

14
core/src/test/java/io/grpc/internal/ServerImplTest.java
View File

@ -26,6 +26,7 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.AdditionalAnswers.delegatesTo;
@ -104,7 +105,6 @@ import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.ArgumentCaptor;
@ -140,8 +140,6 @@ public class ServerImplTest {
};
private static final String AUTHORITY = "some_authority";
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule public final ExpectedException thrown = ExpectedException.none();
@Rule public final MockitoRule mocks = MockitoJUnit.rule();
@BeforeClass
@ -1260,9 +1258,8 @@ public class ServerImplTest {
public void getPortBeforeStartedFails() {
transportServer = new SimpleServer();
createServer();
thrown.expect(IllegalStateException.class);
thrown.expectMessage("started");
server.getPort();
IllegalStateException e = assertThrows(IllegalStateException.class, () -> server.getPort());
assertThat(e).hasMessageThat().isEqualTo("Not started");
}
@Test
@ -1271,9 +1268,8 @@ public class ServerImplTest {
createAndStartServer();
server.shutdown();
server.awaitTermination();
thrown.expect(IllegalStateException.class);
thrown.expectMessage("terminated");
server.getPort();
IllegalStateException e = assertThrows(IllegalStateException.class, () -> server.getPort());
assertThat(e).hasMessageThat().isEqualTo("Already terminated");
}
@Test

10
core/src/testFixtures/java/io/grpc/internal/AbstractTransportTest.java
View File

@ -24,6 +24,7 @@ import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeTrue;
@ -76,9 +77,7 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.ArgumentCaptor;
@ -209,10 +208,6 @@ public abstract class AbstractTransportTest {
}
}));
@SuppressWarnings("deprecation") // https://github.com/grpc/grpc-java/issues/7467
@Rule
public ExpectedException thrown = ExpectedException.none();
@Before
public void setUp() {
server = newServer(Arrays.asList(serverStreamTracerFactory));
@ -396,8 +391,7 @@ public abstract class AbstractTransportTest {
port = ((InetSocketAddress) addr).getPort();
}
InternalServer server2 = newServer(port, Arrays.asList(serverStreamTracerFactory));
thrown.expect(IOException.class);
server2.start(new MockServerListener());
assertThrows(IOException.class, () -> server2.start(new MockServerListener()));
}
@Test