import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void subscribeOnlyOnceFlowableOperatorErrorsWhenMultipleSubscribe() {
    SubscribeOnlyOnceFlowableOperator<Object> op = new SubscribeOnlyOnceFlowableOperator<Object>();
    Subscriber<Object> innerSub = mock(Subscriber.class);
    final Subscription subscription = mock(Subscription.class);

    final Subscriber<Object> outerSub = op.apply(innerSub);

    outerSub.onSubscribe(subscription);
    assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() {
            outerSub.onSubscribe(subscription);
        }
    })
            .isInstanceOf(NullPointerException.class)
            .hasMessageContaining("cannot directly subscribe to a gRPC service multiple times");

    verify(innerSub, times(1)).onSubscribe(subscription);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void subscribeOnlyOnceSingleOperatorErrorsWhenMultipleSubscribe() {
    SubscribeOnlyOnceSingleOperator<Object> op = new SubscribeOnlyOnceSingleOperator<Object>();
    SingleObserver<Object> innerSub = mock(SingleObserver.class);
    final Disposable disposable = mock(Disposable.class);

    final SingleObserver<Object> outerSub = op.apply(innerSub);

    outerSub.onSubscribe(disposable);
    assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() {
            outerSub.onSubscribe(disposable);
        }
    })
            .isInstanceOf(NullPointerException.class)
            .hasMessageContaining("cannot directly subscribe to a gRPC service multiple times");

    verify(innerSub, times(1)).onSubscribe(disposable);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void testExecutingTwiceThrowsIllegalStateException() throws Exception {
    Request request = RequestUtils.getUserInfoRequest(Endpoint.DEFAULT);
    mockConnection(createDummyConnection(request.endpoint(), MOCK_EMPTY_ARRAY_RESPONSE));

    final RealCall call = getMockRealCall(request, executor);

    call.execute();

    assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            call.execute();
        }
    }).isInstanceOf(IllegalStateException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void testEnqueueWithTimeoutBlocksUntilTimeout() throws Exception {
    Request request = RequestUtils.getUserInfoRequest(Endpoint.DEFAULT);
    final Connection connection = createDummyConnection(Endpoint.DEFAULT, MOCK_EMPTY_ARRAY_RESPONSE);
    mockConnection(connection);

    final RealCall call = getMockRealCall(request, realExecutor);

    doAnswer(new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
            Thread.sleep(MOCK_TIMEOUT_TIME);
            return connection.sink();
        }
    }).when(connection).sink();


    assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            call.enqueueAndWait(MOCK_TIMEOUT_TIME, TimeUnit.MILLISECONDS);
        }
    }).isInstanceOf(TimeoutException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void testExecutingTwiceThrowsIllegalStateException() throws Exception {
    Connection connection = createDummyConnection(Endpoint.DEFAULT, getMockByteDataResponse(1));
    retrofitConnectionProvider(connection);

    final MultiCall multiCall = createMultiCall(connection, executor);

    multiCall.execute();

    assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            multiCall.execute();
        }
    }).isInstanceOf(IllegalStateException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void testExecutingAfterCancelThrowsIOException() throws Exception {
    Connection connection = createDummyConnection(Endpoint.DEFAULT, getMockByteDataResponse(1));
    retrofitConnectionProvider(connection);

    final MultiCall multiCall = createMultiCall(connection, executor);

    multiCall.cancel();

    assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            multiCall.execute();
        }
    }).isInstanceOf(IOException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void testEnqueueWithTimeoutBlocksUntilTimeout() throws Exception {
    final Connection connection = createDummyConnection(Endpoint.DEFAULT, getMockByteDataResponse(1));
    retrofitConnectionProvider(connection);


    final MultiCall multiCall = createMultiCall(connection, realExecutor);

    doAnswer(new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
            Thread.sleep(MOCK_TIMEOUT_TIME);
            return connection.sink();
        }
    }).when(connection).sink();


    assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            multiCall.enqueueAndWait(MOCK_TIMEOUT_TIME, TimeUnit.MILLISECONDS);
        }
    }).isInstanceOf(TimeoutException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void fromBytes_withNullIntent_throwsBadParcelableException() {
    final byte[] intentBytes = toBytesUnchecked(null);

    assertThatThrownBy(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            IntentUtil.fromBytes(intentBytes);
        }
    }).isInstanceOf(BadParcelableException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void rollbackToPosition() throws Exception {
    // Populate a session state with dummy data for a single partition
    final SessionState sessionState = new SessionState();
    PartitionState partitionState = new PartitionState();
    partitionState.addToFailoverLog(5, 12345);
    partitionState.setStartSeqno(1);
    partitionState.setEndSeqno(1000);
    partitionState.setSnapshotStartSeqno(2);
    partitionState.setSnapshotEndSeqno(3);
    sessionState.set(0, partitionState);

    Throwable th = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            sessionState.rollbackToPosition((short) 0, 1L);
        }
    });

    assertThat(th).isNull();
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
private void verifyMetadata(final DefaultErrorDTO error, MetadataArgOption metadataArgOption, Map<String, Object> expectedMetadata) {
    switch(metadataArgOption) {
        case NULL:
        case EMPTY: // intentional fall-through
            assertThat(error.metadata)
                .isNotNull()
                .isEmpty();

            break;
        case NOT_EMPTY:
            assertThat(error.metadata)
                .isNotSameAs(expectedMetadata)
                .isEqualTo(expectedMetadata);
            Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
                @Override
                public void call() throws Throwable {
                    error.metadata.put("can't modify", "me");
                }
            });
            assertThat(ex).isInstanceOf(UnsupportedOperationException.class);

            break;
        default:
            throw new IllegalArgumentException("Unhandled case: " + metadataArgOption);
    }
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void findRandomApiErrorWithHttpStatusCode_throws_IllegalStateException_if_it_cannot_find_error_with_specified_status_code() {
    // given
    final ProjectApiErrorsTestBase base = new ProjectApiErrorsTestBase() {
        @Override
        protected ProjectApiErrors getProjectApiErrors() {
            return ProjectApiErrorsForTesting.withProjectSpecificData(null, null);
        }
    };

    // when
    Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            base.findRandomApiErrorWithHttpStatusCode(42424242);
        }
    });

    // then
    assertThat(ex).isInstanceOf(IllegalStateException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void getOwnerClass_throws_IllegalArgumentException_if_AnnotatedElement_is_not_Member_or_Class() {
    // given
    final AnnotatedElement notMemberOrClass = mock(AnnotatedElement.class);

    // when
    Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            ReflectionBasedJsr303AnnotationTrollerBase.getOwnerClass(notMemberOrClass);
        }
    });

    // then
    assertThat(ex).isInstanceOf(IllegalArgumentException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void extractMessageFromAnnotation_throws_wrapped_RuntimeException_if_annotation_blows_up() {
    // given
    RuntimeException exToThrow = new RuntimeException("kaboom");
    final Annotation annotation = mock(Annotation.class);
    doThrow(exToThrow).when(annotation).annotationType();

    // when
    Throwable actual = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            ReflectionBasedJsr303AnnotationTrollerBase.extractMessageFromAnnotation(annotation);
        }
    });

    // then
    assertThat(actual)
        .isNotEqualTo(exToThrow)
        .isInstanceOf(RuntimeException.class)
        .hasCause(exToThrow);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void MetadataPropertyWriter_serializeAsField_still_works_for_non_Error_objects() throws Exception {
    // given
    final MetadataPropertyWriter mpw = new MetadataPropertyWriter(mock(BeanPropertyWriter.class));

    // when
    Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            mpw.serializeAsField(new Object(), mock(JsonGenerator.class), mock(SerializerProvider.class));
        }
    });

    // then
    // We expect a NPE because mocking a base BeanPropertyWriter is incredibly difficult and not worth the effort.
    assertThat(ex).isInstanceOf(NullPointerException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void SmartErrorCodePropertyWriter_serializeAsField_still_works_for_non_Error_objects() throws Exception {
    // given
    final SmartErrorCodePropertyWriter secpw = new SmartErrorCodePropertyWriter(mock(BeanPropertyWriter.class));

    // when
    Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            secpw.serializeAsField(new Object(), mock(JsonGenerator.class), mock(SerializerProvider.class));
        }
    });

    // then
    // We expect a NPE because mocking a base BeanPropertyWriter is incredibly difficult and not worth the effort.
    assertThat(ex).isInstanceOf(NullPointerException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void constructor_throws_wrapped_MalformedURLException_if_url_is_malformed() {
    // given
    final String badUrl = "[email protected]#%^*&&*";

    // when
    Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            new ZipkinSpanSenderDefaultHttpImpl(badUrl, true);
        }
    });

    // then
    assertThat(ex)
        .isInstanceOf(RuntimeException.class)
        .hasCauseInstanceOf(MalformedURLException.class);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void sendSpans_with_span_list_does_not_propagate_IOException_error_thrown_by_sendSpans_with_byte_array() throws IOException {
    // given
    doThrow(new IOException("kaboom")).when(implSpy).sendSpans(any(byte[].class));

    // when
    Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            implSpy.sendSpans(Collections.singletonList(zipkinSpan(42, "foo")));
        }
    });

    // then
    verify(implSpy).sendSpans(any(byte[].class));
    assertThat(ex).isNull();
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void sendSpans_with_span_list_propagates_RuntimeExceptions_thrown_by_sendSpans_with_byte_array() throws IOException {
    // given
    RuntimeException runtimeException = new RuntimeException("kaboom");
    doThrow(runtimeException).when(implSpy).sendSpans(any(byte[].class));

    // when
    Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            implSpy.sendSpans(Collections.singletonList(zipkinSpan(42, "foo")));
        }
    });

    // then
    verify(implSpy).sendSpans(any(byte[].class));
    assertThat(ex).isSameAs(runtimeException);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void ZipkinSpanSenderJob_does_not_propagate_any_errors() {
    // given
    ZipkinSpanSenderDefaultHttpImpl senderImplMock = mock(ZipkinSpanSenderDefaultHttpImpl.class);
    BlockingQueue<zipkin.Span> spanBlockingQueueMock = mock(BlockingQueue.class);
    doThrow(new RuntimeException("kaboom")).when(spanBlockingQueueMock).isEmpty();

    final ZipkinSpanSenderDefaultHttpImpl.ZipkinSpanSenderJob senderJob =
        new ZipkinSpanSenderDefaultHttpImpl.ZipkinSpanSenderJob(senderImplMock, spanBlockingQueueMock);

    // when
    Throwable propagatedEx = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            senderJob.run();
        }
    });

    // then
    verify(spanBlockingQueueMock).isEmpty();
    assertThat(propagatedEx).isNull();

    verify(spanBlockingQueueMock, never()).drainTo(any(Collection.class));
    verifyZeroInteractions(senderImplMock);
}
 

import org.assertj.core.api.ThrowableAssert; //导入依赖的package包/类
@Test
public void sendSpans_does_not_propagate_5xx_errors() throws Exception {
    // given
    zipkinRule.enqueueFailure(HttpFailure.sendErrorResponse(500, "Server Error!"));

    // when
    Throwable ex = catchThrowable(new ThrowableAssert.ThrowingCallable() {
        @Override
        public void call() throws Throwable {
            implSpy.sendSpans(Collections.singletonList(zipkinSpan(42, "foo")));
        }
    });

    // then
    assertThat(ex).isNull();
}