Example usage for org.springframework.kafka.core KafkaTemplate sendDefault

Introduction

In this page you can find the example usage for org.springframework.kafka.core KafkaTemplate sendDefault.

Prototype

@Override
    public ListenableFuture<SendResult<K, V>> sendDefault(K key, @Nullable V data) 

Source Link

Usage

From source file:org.springframework.kafka.listener.ConcurrentMessageListenerContainerTests.java

@Test
public void testAutoCommit() throws Exception {
    this.logger.info("Start auto");
    Map<String, Object> props = KafkaTestUtils.consumerProps("test1", "true", embeddedKafka);
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<>(props);
    ContainerProperties containerProps = new ContainerProperties(topic1);

    final CountDownLatch latch = new CountDownLatch(4);
    final Set<String> listenerThreadNames = new ConcurrentSkipListSet<>();
    containerProps.setMessageListener((MessageListener<Integer, String>) message -> {
        ConcurrentMessageListenerContainerTests.this.logger.info("auto: " + message);
        listenerThreadNames.add(Thread.currentThread().getName());
        latch.countDown();/*  w w w  . j a  va 2  s. c o  m*/
    });

    ConcurrentMessageListenerContainer<Integer, String> container = new ConcurrentMessageListenerContainer<>(cf,
            containerProps);
    container.setConcurrency(2);
    container.setBeanName("testAuto");
    container.start();

    ContainerTestUtils.waitForAssignment(container, embeddedKafka.getPartitionsPerTopic());

    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic1);
    template.sendDefault(0, "foo");
    template.sendDefault(2, "bar");
    template.sendDefault(0, "baz");
    template.sendDefault(2, "qux");
    template.flush();
    assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(listenerThreadNames).allMatch(threadName -> threadName.contains("-consumer-"));
    @SuppressWarnings("unchecked")
    List<KafkaMessageListenerContainer<Integer, String>> containers = KafkaTestUtils.getPropertyValue(container,
            "containers", List.class);
    assertThat(containers.size()).isEqualTo(2);
    for (int i = 0; i < 2; i++) {
        assertThat(KafkaTestUtils.getPropertyValue(containers.get(i), "listenerConsumer.acks", Collection.class)
                .size()).isEqualTo(0);
    }
    container.stop();
    this.logger.info("Stop auto");
}

---

From source file:org.springframework.kafka.listener.ConcurrentMessageListenerContainerTests.java

@Test
public void testAutoCommitWithRebalanceListener() throws Exception {
    this.logger.info("Start auto");
    Map<String, Object> props = KafkaTestUtils.consumerProps("test10", "true", embeddedKafka);
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<>(props);
    ContainerProperties containerProps = new ContainerProperties(topic1);

    final CountDownLatch latch = new CountDownLatch(4);
    final Set<String> listenerThreadNames = new ConcurrentSkipListSet<>();
    containerProps.setMessageListener((MessageListener<Integer, String>) message -> {
        ConcurrentMessageListenerContainerTests.this.logger.info("auto: " + message);
        listenerThreadNames.add(Thread.currentThread().getName());
        latch.countDown();/*ww  w  . ja  v a2  s.  c o  m*/
    });
    final CountDownLatch rebalancePartitionsAssignedLatch = new CountDownLatch(2);
    final CountDownLatch rebalancePartitionsRevokedLatch = new CountDownLatch(2);
    containerProps.setConsumerRebalanceListener(new ConsumerRebalanceListener() {

        @Override
        public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
            ConcurrentMessageListenerContainerTests.this.logger
                    .info("In test, partitions revoked:" + partitions);
            rebalancePartitionsRevokedLatch.countDown();
        }

        @Override
        public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
            ConcurrentMessageListenerContainerTests.this.logger
                    .info("In test, partitions assigned:" + partitions);
            rebalancePartitionsAssignedLatch.countDown();
        }

    });

    ConcurrentMessageListenerContainer<Integer, String> container = new ConcurrentMessageListenerContainer<>(cf,
            containerProps);
    container.setConcurrency(2);
    container.setBeanName("testAuto");
    container.start();

    ContainerTestUtils.waitForAssignment(container, embeddedKafka.getPartitionsPerTopic());

    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic1);
    template.sendDefault(0, "foo");
    template.sendDefault(2, "bar");
    template.sendDefault(0, "baz");
    template.sendDefault(2, "qux");
    template.flush();
    assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(rebalancePartitionsAssignedLatch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(rebalancePartitionsRevokedLatch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(listenerThreadNames).allMatch(threadName -> threadName.contains("-consumer-"));
    container.stop();
    this.logger.info("Stop auto");
}

---

From source file:org.springframework.kafka.listener.ConcurrentMessageListenerContainerTests.java

@Test
public void testAfterListenCommit() throws Exception {
    this.logger.info("Start manual");
    Map<String, Object> props = KafkaTestUtils.consumerProps("test2", "false", embeddedKafka);
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<>(props);
    ContainerProperties containerProps = new ContainerProperties(topic2);

    final CountDownLatch latch = new CountDownLatch(4);
    final Set<String> listenerThreadNames = new ConcurrentSkipListSet<>();
    containerProps.setMessageListener((MessageListener<Integer, String>) message -> {
        ConcurrentMessageListenerContainerTests.this.logger.info("manual: " + message);
        listenerThreadNames.add(Thread.currentThread().getName());
        latch.countDown();//from   w  w w  . j a v a 2  s  .  c  o  m
    });

    ConcurrentMessageListenerContainer<Integer, String> container = new ConcurrentMessageListenerContainer<>(cf,
            containerProps);
    container.setConcurrency(2);
    container.setBeanName("testBatch");
    container.start();

    ContainerTestUtils.waitForAssignment(container, embeddedKafka.getPartitionsPerTopic());

    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic2);
    template.sendDefault(0, "foo");
    template.sendDefault(2, "bar");
    template.sendDefault(0, "baz");
    template.sendDefault(2, "qux");
    template.flush();
    assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(listenerThreadNames).allMatch(threadName -> threadName.contains("-listener-"));
    container.stop();
    this.logger.info("Stop manual");
}

---

From source file:org.springframework.kafka.listener.ConcurrentMessageListenerContainerTests.java

private void testManualCommitGuts(AckMode ackMode, String topic) throws Exception {
    this.logger.info("Start " + ackMode);
    Map<String, Object> props = KafkaTestUtils.consumerProps("test" + ackMode, "false", embeddedKafka);
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<>(props);
    ContainerProperties containerProps = new ContainerProperties(topic);
    final CountDownLatch latch = new CountDownLatch(4);
    containerProps.setMessageListener((AcknowledgingMessageListener<Integer, String>) (message, ack) -> {
        ConcurrentMessageListenerContainerTests.this.logger.info("manual: " + message);
        ack.acknowledge();//from  w  w w  .j a va  2  s  .  c o m
        latch.countDown();
    });

    containerProps.setAckMode(ackMode);
    ConcurrentMessageListenerContainer<Integer, String> container = new ConcurrentMessageListenerContainer<>(cf,
            containerProps);
    container.setConcurrency(2);
    container.setBeanName("test" + ackMode);
    container.start();

    ContainerTestUtils.waitForAssignment(container, embeddedKafka.getPartitionsPerTopic());

    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic);
    template.sendDefault(0, "foo");
    template.sendDefault(2, "bar");
    template.sendDefault(0, "baz");
    template.sendDefault(2, "qux");
    template.flush();
    assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
    container.stop();
    this.logger.info("Stop " + ackMode);
}

---

From source file:org.springframework.kafka.listener.ConcurrentMessageListenerContainerTests.java

@Test
@Ignore // TODO https://github.com/spring-projects/spring-kafka/issues/62 using SYNC for avoidance
public void testManualCommitExisting() throws Exception {
    this.logger.info("Start MANUAL_IMMEDIATE with Existing");
    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic7);/* ww w .j  a  v a  2s  . c o  m*/
    template.sendDefault(0, "foo");
    template.sendDefault(2, "bar");
    template.sendDefault(0, "baz");
    template.sendDefault(2, "qux");
    template.flush();
    Map<String, Object> props = KafkaTestUtils.consumerProps("testManualExisting", "false", embeddedKafka);
    props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<>(props);
    ContainerProperties containerProps = new ContainerProperties(topic7);
    final CountDownLatch latch = new CountDownLatch(8);
    containerProps.setMessageListener((AcknowledgingMessageListener<Integer, String>) (message, ack) -> {
        ConcurrentMessageListenerContainerTests.this.logger.info("manualExisting: " + message);
        ack.acknowledge();
        latch.countDown();
    });
    containerProps.setAckMode(AckMode.MANUAL_IMMEDIATE);

    final CountDownLatch commits = new CountDownLatch(8);
    final AtomicReference<Exception> exceptionRef = new AtomicReference<>();
    containerProps.setCommitCallback((offsets, exception) -> {
        commits.countDown();
        if (exception != null) {
            exceptionRef.compareAndSet(null, exception);
        }
    });

    ConcurrentMessageListenerContainer<Integer, String> container = new ConcurrentMessageListenerContainer<>(cf,
            containerProps);
    container.setConcurrency(1);
    container.setBeanName("testManualExisting");

    container.start();
    ContainerTestUtils.waitForAssignment(container, embeddedKafka.getPartitionsPerTopic());
    template.sendDefault(0, "fooo");
    template.sendDefault(2, "barr");
    template.sendDefault(0, "bazz");
    template.sendDefault(2, "quxx");
    template.flush();
    assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(commits.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(exceptionRef.get()).isNull();
    container.stop();
    this.logger.info("Stop MANUAL_IMMEDIATE with Existing");
}

---

From source file:org.springframework.kafka.listener.ConcurrentMessageListenerContainerTests.java

@Test
public void testManualCommitSyncExisting() throws Exception {
    this.logger.info("Start MANUAL_IMMEDIATE with Existing");
    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<Integer, String>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic8);/*from ww  w .j a va2s  . co  m*/
    template.sendDefault(0, "foo");
    template.sendDefault(2, "bar");
    template.sendDefault(0, "baz");
    template.sendDefault(2, "qux");
    template.flush();
    Map<String, Object> props = KafkaTestUtils.consumerProps("testManualExistingSync", "false", embeddedKafka);
    props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<Integer, String>(props);
    ContainerProperties containerProps = new ContainerProperties(topic8);
    containerProps.setSyncCommits(true);
    final CountDownLatch latch = new CountDownLatch(8);
    final BitSet bitSet = new BitSet(8);
    containerProps.setMessageListener((AcknowledgingMessageListener<Integer, String>) (message, ack) -> {
        ConcurrentMessageListenerContainerTests.this.logger.info("manualExisting: " + message);
        ack.acknowledge();
        bitSet.set((int) (message.partition() * 4 + message.offset()));
        latch.countDown();
    });
    containerProps.setAckMode(AckMode.MANUAL_IMMEDIATE);

    ConcurrentMessageListenerContainer<Integer, String> container = new ConcurrentMessageListenerContainer<>(cf,
            containerProps);
    container.setConcurrency(1);
    container.setBeanName("testManualExisting");
    container.start();
    ContainerTestUtils.waitForAssignment(container, embeddedKafka.getPartitionsPerTopic());
    template.sendDefault(0, "fooo");
    template.sendDefault(2, "barr");
    template.sendDefault(0, "bazz");
    template.sendDefault(2, "quxx");
    template.flush();
    assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(bitSet.cardinality()).isEqualTo(8);
    container.stop();
    this.logger.info("Stop MANUAL_IMMEDIATE with Existing");
}

---

From source file:org.springframework.kafka.listener.ConcurrentMessageListenerContainerTests.java

@Test
public void testListenerException() throws Exception {
    this.logger.info("Start exception");
    Map<String, Object> props = KafkaTestUtils.consumerProps("test1", "true", embeddedKafka);
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<>(props);
    ContainerProperties containerProps = new ContainerProperties(topic6);
    containerProps.setAckCount(23);/*ww  w  .j  ava2  s.c o  m*/
    ContainerProperties containerProps2 = new ContainerProperties(topic2);
    BeanUtils.copyProperties(containerProps, containerProps2, "topics", "topicPartitions", "topicPattern",
            "ackCount", "ackTime");
    final CountDownLatch latch = new CountDownLatch(4);
    final AtomicBoolean catchError = new AtomicBoolean(false);
    containerProps.setMessageListener((MessageListener<Integer, String>) message -> {
        ConcurrentMessageListenerContainerTests.this.logger.info("auto: " + message);
        latch.countDown();
        throw new RuntimeException("intended");
    });
    containerProps.setGenericErrorHandler((ErrorHandler) (thrownException, record) -> catchError.set(true));

    ConcurrentMessageListenerContainer<Integer, String> container = new ConcurrentMessageListenerContainer<>(cf,
            containerProps);
    container.setConcurrency(2);
    container.setBeanName("testException");

    container.start();
    ContainerTestUtils.waitForAssignment(container, embeddedKafka.getPartitionsPerTopic());
    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic6);
    template.sendDefault(0, "foo");
    template.sendDefault(2, "bar");
    template.sendDefault(0, "baz");
    template.sendDefault(2, "qux");
    template.flush();
    assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(catchError.get()).isTrue();
    container.stop();
    this.logger.info("Stop exception");

}

---

From source file:org.springframework.kafka.listener.KafkaMessageListenerContainerTests.java

@Test
public void testSlowListener() throws Exception {
    logger.info("Start " + this.testName.getMethodName());
    Map<String, Object> props = KafkaTestUtils.consumerProps("slow1", "false", embeddedKafka);
    //      props.put(ConsumerConfig.MAX_PARTITION_FETCH_BYTES_CONFIG, 6); // 2 per poll
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<Integer, String>(props);
    ContainerProperties containerProps = new ContainerProperties(topic1);

    final CountDownLatch latch = new CountDownLatch(6);
    final BitSet bitSet = new BitSet(6);
    containerProps.setMessageListener((MessageListener<Integer, String>) message -> {
        logger.info("slow1: " + message);
        bitSet.set((int) (message.partition() * 3 + message.offset()));
        try {/* w  w  w.  jav  a 2 s  .com*/
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        latch.countDown();
    });
    containerProps.setPauseAfter(100);
    KafkaMessageListenerContainer<Integer, String> container = new KafkaMessageListenerContainer<>(cf,
            containerProps);
    container.setBeanName("testSlow1");

    container.start();
    Consumer<?, ?> consumer = spyOnConsumer(container);
    ContainerTestUtils.waitForAssignment(container, embeddedKafka.getPartitionsPerTopic());

    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<Integer, String>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic1);
    template.sendDefault(0, "foo");
    template.sendDefault(2, "bar");
    template.sendDefault(0, "baz");
    template.sendDefault(2, "qux");
    template.flush();
    Thread.sleep(300);
    template.sendDefault(0, "fiz");
    template.sendDefault(2, "buz");
    template.flush();
    assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(bitSet.cardinality()).isEqualTo(6);
    verify(consumer, atLeastOnce()).pause(anyObject());
    verify(consumer, atLeastOnce()).resume(anyObject());
    container.stop();
    logger.info("Stop " + this.testName.getMethodName());
}

---

From source file:org.springframework.kafka.listener.KafkaMessageListenerContainerTests.java

private void testSlowListenerManualGuts(AckMode ackMode, String topic) throws Exception {
    logger.info("Start " + this.testName.getMethodName() + ackMode);
    Map<String, Object> props = KafkaTestUtils.consumerProps("slow2", "false", embeddedKafka);
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<Integer, String>(props);
    ContainerProperties containerProps = new ContainerProperties(topic);
    containerProps.setSyncCommits(true);

    final CountDownLatch latch = new CountDownLatch(6);
    final BitSet bitSet = new BitSet(4);
    containerProps.setMessageListener((AcknowledgingMessageListener<Integer, String>) (message, ack) -> {
        logger.info("slow2: " + message);
        bitSet.set((int) (message.partition() * 3 + message.offset()));
        try {/*from  w  w w .j  a  va  2  s . c  om*/
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        ack.acknowledge();
        latch.countDown();
    });
    containerProps.setPauseAfter(100);
    containerProps.setAckMode(ackMode);

    KafkaMessageListenerContainer<Integer, String> container = new KafkaMessageListenerContainer<>(cf,
            containerProps);
    container.setBeanName("testSlow2");
    container.start();

    Consumer<?, ?> consumer = spyOnConsumer(container);

    final CountDownLatch commitLatch = new CountDownLatch(7);

    willAnswer(invocation -> {

        try {
            return invocation.callRealMethod();
        } finally {
            commitLatch.countDown();
        }

    }).given(consumer).commitSync(any());

    ContainerTestUtils.waitForAssignment(container, embeddedKafka.getPartitionsPerTopic());

    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<Integer, String>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic);
    template.sendDefault(0, "foo");
    template.sendDefault(2, "bar");
    template.sendDefault(0, "baz");
    template.sendDefault(2, "qux");
    template.flush();
    Thread.sleep(300);
    template.sendDefault(0, "fiz");
    template.sendDefault(2, "buz");
    template.flush();
    assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(commitLatch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(bitSet.cardinality()).isEqualTo(6);
    verify(consumer, atLeastOnce()).pause(anyObject());
    verify(consumer, atLeastOnce()).resume(anyObject());
    container.stop();
    logger.info("Stop " + this.testName.getMethodName() + ackMode);
}

---

From source file:org.springframework.kafka.listener.KafkaMessageListenerContainerTests.java

@Test
public void testSlowConsumerWithException() throws Exception {
    logger.info("Start " + this.testName.getMethodName());
    Map<String, Object> props = KafkaTestUtils.consumerProps("slow3", "false", embeddedKafka);
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<Integer, String>(props);
    ContainerProperties containerProps = new ContainerProperties(topic3);

    final CountDownLatch latch = new CountDownLatch(18);
    final BitSet bitSet = new BitSet(6);
    final Map<String, AtomicInteger> faults = new HashMap<>();
    RetryingMessageListenerAdapter<Integer, String> adapter = new RetryingMessageListenerAdapter<>(
            new MessageListener<Integer, String>() {

                @Override// w  w  w . j ava2 s .  c  om
                public void onMessage(ConsumerRecord<Integer, String> message) {
                    logger.info("slow3: " + message);
                    bitSet.set((int) (message.partition() * 3 + message.offset()));
                    String key = message.topic() + message.partition() + message.offset();
                    if (faults.get(key) == null) {
                        faults.put(key, new AtomicInteger(1));
                    } else {
                        faults.get(key).incrementAndGet();
                    }
                    latch.countDown(); // 3 per = 18
                    if (faults.get(key).get() < 3) { // succeed on the third attempt
                        throw new FooEx();
                    }
                }

            }, buildRetry(), null);
    containerProps.setMessageListener(adapter);
    containerProps.setPauseAfter(100);

    KafkaMessageListenerContainer<Integer, String> container = new KafkaMessageListenerContainer<>(cf,
            containerProps);
    container.setBeanName("testSlow3");

    container.start();
    Consumer<?, ?> consumer = spyOnConsumer(container);
    ContainerTestUtils.waitForAssignment(container, embeddedKafka.getPartitionsPerTopic());

    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic3);
    template.sendDefault(0, "foo");
    template.sendDefault(2, "bar");
    template.sendDefault(0, "baz");
    template.sendDefault(2, "qux");
    template.flush();
    Thread.sleep(300);
    template.sendDefault(0, "fiz");
    template.sendDefault(2, "buz");
    template.flush();
    assertThat(latch.await(60, TimeUnit.SECONDS)).isTrue();
    assertThat(bitSet.cardinality()).isEqualTo(6);
    verify(consumer, atLeastOnce()).pause(anyObject());
    verify(consumer, atLeastOnce()).resume(anyObject());
    container.stop();
    logger.info("Stop " + this.testName.getMethodName());
}

---

• «
• 1
• 2
• »