import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
@Test
public void required_spec317_mustSupportACumulativePendingElementCountGreaterThenLongMaxValue() throws Throwable {
    final int totalElements = 50;

    activePublisherTest(totalElements, true, pub -> {
        final TestEnvironment.ManualSubscriber<Integer> sub = env.newManualSubscriber(pub);
        new Thread(() -> sub.request(Long.MAX_VALUE)).start();
        new Thread(() -> sub.request(Long.MAX_VALUE)).start();

        sub.nextElements(totalElements);
        sub.expectCompletion();

        try {
            env.verifyNoAsyncErrorsNoDelay();
        } finally {
            sub.cancel();
        }

    });
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public StreamPublisherTest() throws NoSuchFieldException, IllegalAccessException {
    super(new TestEnvironment(400));

    Field env = PublisherVerification.class.getDeclaredField("env");
    env.setAccessible(true);
    this.env = (TestEnvironment) env.get(this);
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
@Factory(dataProvider = "noScheduled")
public HandlerPublisherVerificationTest(int batchSize, int publishInitial, boolean scheduled) {
    super(new TestEnvironment(200));
    this.batchSize = batchSize;
    this.publishInitial = publishInitial;
    this.scheduled = scheduled;
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public RxGrpcPublisherOneToManyVerificationTest() {
    super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS, DEFAULT_TIMEOUT_MILLIS), PUBLISHER_REFERENCE_CLEANUP_TIMEOUT_MILLIS);
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public RxGrpcPublisherManyToOneVerificationTest() {
    super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS, DEFAULT_TIMEOUT_MILLIS), PUBLISHER_REFERENCE_CLEANUP_TIMEOUT_MILLIS);
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public RxGrpcPublisherOneToOneVerificationTest() {
    super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS, DEFAULT_TIMEOUT_MILLIS), PUBLISHER_REFERENCE_CLEANUP_TIMEOUT_MILLIS);
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public RxGrpcSubscriberWhiteboxVerificationTest() {
    super(new TestEnvironment());
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public RxGrpcPublisherManyToManyVerificationTest() {
    super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS, DEFAULT_TIMEOUT_MILLIS), PUBLISHER_REFERENCE_CLEANUP_TIMEOUT_MILLIS);
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public ReactorGrpcSubscriberWhiteboxVerificationTest() {
    super(new TestEnvironment());
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public ReactorGrpcPublisherManyToOneVerificationTest() {
    super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS, DEFAULT_TIMEOUT_MILLIS), PUBLISHER_REFERENCE_CLEANUP_TIMEOUT_MILLIS);
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public ReactorGrpcPublisherManyToManyVerificationTest() {
    super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS, DEFAULT_TIMEOUT_MILLIS), PUBLISHER_REFERENCE_CLEANUP_TIMEOUT_MILLIS);
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public ReactorGrpcPublisherOneToOneVerificationTest() {
    super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS, DEFAULT_TIMEOUT_MILLIS), PUBLISHER_REFERENCE_CLEANUP_TIMEOUT_MILLIS);
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public ReactorGrpcPublisherOneToManyVerificationTest() {
    super(new TestEnvironment(DEFAULT_TIMEOUT_MILLIS, DEFAULT_TIMEOUT_MILLIS), PUBLISHER_REFERENCE_CLEANUP_TIMEOUT_MILLIS);
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public SolocastProcessorTckTest() {
    super(new TestEnvironment(50));
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public MulticastProcessorTckTest() {
    super(new TestEnvironment(50));
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public KafkaSubscriberBlackboxTest() {
    super(new TestEnvironment());
    mockProducer = new MockProducer<Long, Long>(true, new LongSerializer(), new LongSerializer());
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public KafkaPublisherTest() {
    super(new TestEnvironment());
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public KafkaSubscriberWhiteboxTest() {
    super(new TestEnvironment());
    mockProducer = new MockProducer<Long, Long>(true, new LongSerializer(), new LongSerializer());
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
public AbstractProcessorTest() {
  super(new TestEnvironment(2000L, envDefaultNoSignalsTimeoutMillis(), true), 3500);
}
 

import org.reactivestreams.tck.TestEnvironment; //导入依赖的package包/类
/**
 * Instantiates a new simple publisher test.
 */
public SimplePublisherTest() {
	super(new TestEnvironment());
}