org.springframework.jms.listener.DefaultMessageListenerContainer

@Test
public void testDefaultContainerFactoryNoTransactionManager() {
    this.contextRunner.withUserConfiguration(EnableJmsConfiguration.clreplaced).run((context) -> {
        DefaultMessageListenerContainer container = getContainer(context, "jmsListenerContainerFactory");
        replacedertThat(container.isSessionTransacted()).isTrue();
        replacedertThat(new DirectFieldAccessor(container).getPropertyValue("transactionManager")).isNull();
    });
}

@Test
public void testDefaultContainerFactoryWithJtaTransactionManager() {
    this.contextRunner.withUserConfiguration(TestConfiguration7.clreplaced, EnableJmsConfiguration.clreplaced).run((context) -> {
        DefaultMessageListenerContainer container = getContainer(context, "jmsListenerContainerFactory");
        replacedertThat(container.isSessionTransacted()).isFalse();
        replacedertThat(new DirectFieldAccessor(container).getPropertyValue("transactionManager")).isSameAs(context.getBean(JtaTransactionManager.clreplaced));
    });
}

@Test
public void testCustomContainerFactoryWithConfigurer() {
    this.contextRunner.withUserConfiguration(TestConfiguration9.clreplaced, EnableJmsConfiguration.clreplaced).withPropertyValues("spring.jms.listener.autoStartup=false").run((context) -> {
        DefaultMessageListenerContainer container = getContainer(context, "customListenerContainerFactory");
        replacedertThat(container.getCacheLevel()).isEqualTo(DefaultMessageListenerContainer.CACHE_CONSUMER);
        replacedertThat(container.isAutoStartup()).isFalse();
    });
}

@Test
public void testDefaultContainerFactoryWithMessageConverters() {
    this.contextRunner.withUserConfiguration(MessageConvertersConfiguration.clreplaced, EnableJmsConfiguration.clreplaced).run((context) -> {
        DefaultMessageListenerContainer container = getContainer(context, "jmsListenerContainerFactory");
        replacedertThat(container.getMessageConverter()).isSameAs(context.getBean("myMessageConverter"));
    });
}

@Test
public void testDefaultContainerFactoryNonJtaTransactionManager() {
    this.contextRunner.withUserConfiguration(TestConfiguration8.clreplaced, EnableJmsConfiguration.clreplaced).run((context) -> {
        DefaultMessageListenerContainer container = getContainer(context, "jmsListenerContainerFactory");
        replacedertThat(container.isSessionTransacted()).isTrue();
        replacedertThat(new DirectFieldAccessor(container).getPropertyValue("transactionManager")).isNull();
    });
}

@Test
public void testPubSubDomainActive() {
    this.contextRunner.withUserConfiguration(TestConfiguration.clreplaced).withPropertyValues("spring.jms.pubSubDomain:true").run((context) -> {
        JmsTemplate jmsTemplate = context.getBean(JmsTemplate.clreplaced);
        DefaultMessageListenerContainer defaultMessageListenerContainer = context.getBean(DefaultJmsListenerContainerFactory.clreplaced).createListenerContainer(mock(JmsListenerEndpoint.clreplaced));
        replacedertThat(jmsTemplate.isPubSubDomain()).isTrue();
        replacedertThat(defaultMessageListenerContainer.isPubSubDomain()).isTrue();
    });
}

private void testJmsListenerContainerFactoryWithCustomSettings(replacedertableApplicationContext loaded) {
    DefaultMessageListenerContainer container = getContainer(loaded, "jmsListenerContainerFactory");
    replacedertThat(container.isAutoStartup()).isFalse();
    replacedertThat(container.getSessionAcknowledgeMode()).isEqualTo(Session.CLIENT_ACKNOWLEDGE);
    replacedertThat(container.getConcurrentConsumers()).isEqualTo(2);
    replacedertThat(container.getMaxConcurrentConsumers()).isEqualTo(10);
}

private void start(String beanName) {
    if (StringUtils.isEmpty(beanName)) {
        return;
    }
    DefaultMessageListenerContainer c = this.applicationContext.getBean(beanName, DefaultMessageListenerContainer.clreplaced);
    if (c != null)
        c.start();
}

/**
 * @author Stephane Nicoll
 */
public clreplaced MethodJmsListenerEndpointTests {

    private final DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();

    private final DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();

    private final JmsEndpointSampleBean sample = new JmsEndpointSampleBean();

    @Rule
    public final TestName name = new TestName();

    @Before
    public void setup() {
        initializeFactory(this.factory);
    }

    @Test
    public void createMessageListenerNoFactory() {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this);
        endpoint.setMethod(getTestMethod());
        replacedertThatIllegalStateException().isThrownBy(() -> endpoint.createMessageListener(this.container));
    }

    @Test
    public void createMessageListener() {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this);
        endpoint.setMethod(getTestMethod());
        endpoint.setMessageHandlerMethodFactory(this.factory);
        replacedertNotNull(endpoint.createMessageListener(this.container));
    }

    @Test
    public void setExtraCollaborators() {
        MessageConverter messageConverter = mock(MessageConverter.clreplaced);
        DestinationResolver destinationResolver = mock(DestinationResolver.clreplaced);
        this.container.setMessageConverter(messageConverter);
        this.container.setDestinationResolver(destinationResolver);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod("resolveObjectPayload", MyBean.clreplaced), this.container);
        DirectFieldAccessor accessor = new DirectFieldAccessor(listener);
        replacedertSame(messageConverter, accessor.getPropertyValue("messageConverter"));
        replacedertSame(destinationResolver, accessor.getPropertyValue("destinationResolver"));
    }

    @Test
    public void resolveMessageAndSession() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(javax.jms.Message.clreplaced, Session.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveGenericMessage() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Message.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveHeaderAndPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 55);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveCustomHeaderNameAndPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 24);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveCustomHeaderNameAndPayloadWithHeaderNameSet() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 24);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveHeaders() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, Map.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("customInt", 1234);
        message.setJMSMessageID("abcd-1234");
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveMessageHeaders() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(MessageHeaders.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setLongProperty("customLong", 4567L);
        message.setJMSType("myMessageType");
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveJmsMessageHeaderAccessor() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(JmsMessageHeaderAccessor.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setBooleanProperty("customBoolean", true);
        message.setJMSPriority(9);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveObjectPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(MyBean.clreplaced);
        MyBean myBean = new MyBean();
        myBean.name = "myBean name";
        Session session = mock(Session.clreplaced);
        ObjectMessage message = mock(ObjectMessage.clreplaced);
        given(message.getObject()).willReturn(myBean);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveConvertedPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Integer.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("33"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void processAndReply() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        String body = "echo text";
        String correlationId = "link-1234";
        Destination replyDestination = new Destination() {
        };
        TextMessage reply = mock(TextMessage.clreplaced);
        QueueSender queueSender = mock(QueueSender.clreplaced);
        Session session = mock(Session.clreplaced);
        given(session.createTextMessage(body)).willReturn(reply);
        given(session.createProducer(replyDestination)).willReturn(queueSender);
        listener.setDefaultResponseDestination(replyDestination);
        StubTextMessage inputMessage = createSimpleJmsTextMessage(body);
        inputMessage.setJMSCorrelationID(correlationId);
        listener.onMessage(inputMessage, session);
        replacedertDefaultListenerMethodInvocation();
        verify(reply).setJMSCorrelationID(correlationId);
        verify(queueSender).send(reply);
        verify(queueSender).close();
    }

    @Test
    public void processAndReplyWithSendToQueue() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void processFromTopicAndReplyWithSendToQueue() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setPubSubDomain(true);
        container.setReplyPubSubDomain(false);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void processAndReplyWithSendToTopic() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setPubSubDomain(true);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", true);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void processFromQueueAndReplyWithSendToTopic() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setReplyPubSubDomain(true);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", true);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void processAndReplyWithDefaultSendTo() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        processAndReplyWithSendTo(listener, "defaultReply", false);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void processAndReplyWithCustomReplyQosSettings() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        QosSettings replyQosSettings = new QosSettings(1, 6, 6000);
        container.setReplyQosSettings(replyQosSettings);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false, replyQosSettings);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void processAndReplyWithNullReplyQosSettings() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setReplyQosSettings(null);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    private void processAndReplyWithSendTo(MessagingMessageListenerAdapter listener, String replyDestinationName, boolean pubSubDomain) throws JMSException {
        processAndReplyWithSendTo(listener, replyDestinationName, pubSubDomain, null);
    }

    private void processAndReplyWithSendTo(MessagingMessageListenerAdapter listener, String replyDestinationName, boolean pubSubDomain, QosSettings replyQosSettings) throws JMSException {
        String body = "echo text";
        String correlationId = "link-1234";
        Destination replyDestination = new Destination() {
        };
        DestinationResolver destinationResolver = mock(DestinationResolver.clreplaced);
        TextMessage reply = mock(TextMessage.clreplaced);
        QueueSender queueSender = mock(QueueSender.clreplaced);
        Session session = mock(Session.clreplaced);
        given(destinationResolver.resolveDestinationName(session, replyDestinationName, pubSubDomain)).willReturn(replyDestination);
        given(session.createTextMessage(body)).willReturn(reply);
        given(session.createProducer(replyDestination)).willReturn(queueSender);
        listener.setDestinationResolver(destinationResolver);
        StubTextMessage inputMessage = createSimpleJmsTextMessage(body);
        inputMessage.setJMSCorrelationID(correlationId);
        listener.onMessage(inputMessage, session);
        verify(destinationResolver).resolveDestinationName(session, replyDestinationName, pubSubDomain);
        verify(reply).setJMSCorrelationID(correlationId);
        if (replyQosSettings != null) {
            verify(queueSender).send(reply, replyQosSettings.getDeliveryMode(), replyQosSettings.getPriority(), replyQosSettings.getTimeToLive());
        } else {
            verify(queueSender).send(reply);
        }
        verify(queueSender).close();
    }

    @Test
    public void emptySendTo() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        TextMessage reply = mock(TextMessage.clreplaced);
        Session session = mock(Session.clreplaced);
        given(session.createTextMessage("content")).willReturn(reply);
        replacedertThatExceptionOfType(ReplyFailureException.clreplaced).isThrownBy(() -> listener.onMessage(createSimpleJmsTextMessage("content"), session)).withCauseInstanceOf(InvalidDestinationException.clreplaced);
    }

    @Test
    public void invalidSendTo() {
        replacedertThatIllegalStateException().isThrownBy(() -> createDefaultInstance(String.clreplaced)).withMessageContaining("firstDestination").withMessageContaining("secondDestination");
    }

    @Test
    public void validatePayloadValid() throws JMSException {
        String methodName = "validatePayload";
        DefaultMessageHandlerMethodFactory customFactory = new DefaultMessageHandlerMethodFactory();
        customFactory.setValidator(testValidator("invalid value"));
        initializeFactory(customFactory);
        Method method = getListenerMethod(methodName, String.clreplaced);
        MessagingMessageListenerAdapter listener = createInstance(customFactory, method);
        Session session = mock(Session.clreplaced);
        // test is a valid value
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void validatePayloadInvalid() throws JMSException {
        DefaultMessageHandlerMethodFactory customFactory = new DefaultMessageHandlerMethodFactory();
        customFactory.setValidator(testValidator("invalid value"));
        Method method = getListenerMethod("validatePayload", String.clreplaced);
        MessagingMessageListenerAdapter listener = createInstance(customFactory, method);
        Session session = mock(Session.clreplaced);
        // test is an invalid value
        replacedertThatExceptionOfType(ListenerExecutionFailedException.clreplaced).isThrownBy(() -> listener.onMessage(createSimpleJmsTextMessage("invalid value"), session));
    }

    // failure scenario
    @Test
    public void invalidPayloadType() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Integer.clreplaced);
        Session session = mock(Session.clreplaced);
        // test is not a valid integer
        replacedertThatExceptionOfType(ListenerExecutionFailedException.clreplaced).isThrownBy(() -> listener.onMessage(createSimpleJmsTextMessage("test"), session)).withCauseInstanceOf(MessageConversionException.clreplaced).withMessageContaining(// ref to method
        getDefaultListenerMethod(Integer.clreplaced).toGenericString());
    }

    @Test
    public void invalidMessagePayloadType() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Message.clreplaced);
        Session session = mock(Session.clreplaced);
        // Message<String> as Message<Integer>
        replacedertThatExceptionOfType(ListenerExecutionFailedException.clreplaced).isThrownBy(() -> listener.onMessage(createSimpleJmsTextMessage("test"), session)).withCauseInstanceOf(MessageConversionException.clreplaced);
    }

    private MessagingMessageListenerAdapter createInstance(DefaultMessageHandlerMethodFactory factory, Method method, MessageListenerContainer container) {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this.sample);
        endpoint.setMethod(method);
        endpoint.setMessageHandlerMethodFactory(factory);
        return endpoint.createMessageListener(container);
    }

    private MessagingMessageListenerAdapter createInstance(DefaultMessageHandlerMethodFactory factory, Method method) {
        return createInstance(factory, method, new SimpleMessageListenerContainer());
    }

    private MessagingMessageListenerAdapter createDefaultInstance(Clreplaced<?>... parameterTypes) {
        return createInstance(this.factory, getDefaultListenerMethod(parameterTypes));
    }

    private StubTextMessage createSimpleJmsTextMessage(String body) {
        return new StubTextMessage(body);
    }

    private Method getListenerMethod(String methodName, Clreplaced<?>... parameterTypes) {
        Method method = ReflectionUtils.findMethod(JmsEndpointSampleBean.clreplaced, methodName, parameterTypes);
        replacedertNotNull("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes));
        return method;
    }

    private Method getDefaultListenerMethod(Clreplaced<?>... parameterTypes) {
        return getListenerMethod(this.name.getMethodName(), parameterTypes);
    }

    private void replacedertDefaultListenerMethodInvocation() {
        replacedertListenerMethodInvocation(this.sample, this.name.getMethodName());
    }

    private void replacedertListenerMethodInvocation(JmsEndpointSampleBean bean, String methodName) {
        replacedertTrue("Method " + methodName + " should have been invoked", bean.invocations.get(methodName));
    }

    private void initializeFactory(DefaultMessageHandlerMethodFactory factory) {
        factory.setBeanFactory(new StaticListableBeanFactory());
        factory.afterPropertiesSet();
    }

    private Validator testValidator(final String invalidValue) {
        return new Validator() {

            @Override
            public boolean supports(Clreplaced<?> clazz) {
                return String.clreplaced.isreplacedignableFrom(clazz);
            }

            @Override
            public void validate(@Nullable Object target, Errors errors) {
                String value = (String) target;
                if (invalidValue.equals(value)) {
                    errors.reject("not a valid value");
                }
            }
        };
    }

    private Method getTestMethod() {
        return ReflectionUtils.findMethod(MethodJmsListenerEndpointTests.clreplaced, this.name.getMethodName());
    }

    @SendTo("defaultReply")
    @SuppressWarnings("unused")
    static clreplaced JmsEndpointSampleBean {

        private final Map<String, Boolean> invocations = new HashMap<>();

        public void resolveMessageAndSession(javax.jms.Message message, Session session) {
            this.invocations.put("resolveMessageAndSession", true);
            replacedertNotNull("Message not injected", message);
            replacedertNotNull("Session not injected", session);
        }

        public void resolveGenericMessage(Message<String> message) {
            this.invocations.put("resolveGenericMessage", true);
            replacedertNotNull("Generic message not injected", message);
            replacedertEquals("Wrong message payload", "test", message.getPayload());
        }

        public void resolveHeaderAndPayload(@Payload String content, @Header int myCounter) {
            this.invocations.put("resolveHeaderAndPayload", true);
            replacedertEquals("Wrong @Payload resolution", "my payload", content);
            replacedertEquals("Wrong @Header resolution", 55, myCounter);
        }

        public void resolveCustomHeaderNameAndPayload(@Payload String content, @Header("myCounter") int counter) {
            this.invocations.put("resolveCustomHeaderNameAndPayload", true);
            replacedertEquals("Wrong @Payload resolution", "my payload", content);
            replacedertEquals("Wrong @Header resolution", 24, counter);
        }

        public void resolveCustomHeaderNameAndPayloadWithHeaderNameSet(@Payload String content, @Header(name = "myCounter") int counter) {
            this.invocations.put("resolveCustomHeaderNameAndPayloadWithHeaderNameSet", true);
            replacedertEquals("Wrong @Payload resolution", "my payload", content);
            replacedertEquals("Wrong @Header resolution", 24, counter);
        }

        public void resolveHeaders(String content, @Headers Map<String, Object> headers) {
            this.invocations.put("resolveHeaders", true);
            replacedertEquals("Wrong payload resolution", "my payload", content);
            replacedertNotNull("headers not injected", headers);
            replacedertEquals("Missing JMS message id header", "abcd-1234", headers.get(JmsHeaders.MESSAGE_ID));
            replacedertEquals("Missing custom header", 1234, headers.get("customInt"));
        }

        public void resolveMessageHeaders(MessageHeaders headers) {
            this.invocations.put("resolveMessageHeaders", true);
            replacedertNotNull("MessageHeaders not injected", headers);
            replacedertEquals("Missing JMS message type header", "myMessageType", headers.get(JmsHeaders.TYPE));
            replacedertEquals("Missing custom header", 4567L, (long) headers.get("customLong"), 0.0);
        }

        public void resolveJmsMessageHeaderAccessor(JmsMessageHeaderAccessor headers) {
            this.invocations.put("resolveJmsMessageHeaderAccessor", true);
            replacedertNotNull("MessageHeaders not injected", headers);
            replacedertEquals("Missing JMS message priority header", Integer.valueOf(9), headers.getPriority());
            replacedertEquals("Missing custom header", true, headers.getHeader("customBoolean"));
        }

        public void resolveObjectPayload(MyBean bean) {
            this.invocations.put("resolveObjectPayload", true);
            replacedertNotNull("Object payload not injected", bean);
            replacedertEquals("Wrong content for payload", "myBean name", bean.name);
        }

        public void resolveConvertedPayload(Integer counter) {
            this.invocations.put("resolveConvertedPayload", true);
            replacedertNotNull("Payload not injected", counter);
            replacedertEquals("Wrong content for payload", Integer.valueOf(33), counter);
        }

        public String processAndReply(@Payload String content) {
            this.invocations.put("processAndReply", true);
            return content;
        }

        @SendTo("replyDestination")
        public String processAndReplyWithSendTo(String content) {
            this.invocations.put("processAndReplyWithSendTo", true);
            return content;
        }

        public String processAndReplyWithDefaultSendTo(String content) {
            this.invocations.put("processAndReplyWithDefaultSendTo", true);
            return content;
        }

        @SendTo("")
        public String emptySendTo(String content) {
            this.invocations.put("emptySendTo", true);
            return content;
        }

        @SendTo({ "firstDestination", "secondDestination" })
        public String invalidSendTo(String content) {
            this.invocations.put("invalidSendTo", true);
            return content;
        }

        public void validatePayload(@Validated String payload) {
            this.invocations.put("validatePayload", true);
        }

        public void invalidPayloadType(@Payload Integer payload) {
            throw new IllegalStateException("Should never be called.");
        }

        public void invalidMessagePayloadType(Message<Integer> message) {
            throw new IllegalStateException("Should never be called.");
        }
    }

    @SuppressWarnings("serial")
    static clreplaced MyBean implements Serializable {

        private String name;
    }
}

@Test
public void testContainerConfiguration() throws Exception {
    Map<String, DefaultMessageListenerContainer> containers = context.getBeansOfType(DefaultMessageListenerContainer.clreplaced);
    ConnectionFactory defaultConnectionFactory = context.getBean(DEFAULT_CONNECTION_FACTORY, ConnectionFactory.clreplaced);
    ConnectionFactory explicitConnectionFactory = context.getBean(EXPLICIT_CONNECTION_FACTORY, ConnectionFactory.clreplaced);
    int defaultConnectionFactoryCount = 0;
    int explicitConnectionFactoryCount = 0;
    for (DefaultMessageListenerContainer container : containers.values()) {
        if (container.getConnectionFactory().equals(defaultConnectionFactory)) {
            defaultConnectionFactoryCount++;
        } else if (container.getConnectionFactory().equals(explicitConnectionFactory)) {
            explicitConnectionFactoryCount++;
        }
    }
    replacedertEquals("1 container should have the default connectionFactory", 1, defaultConnectionFactoryCount);
    replacedertEquals("2 containers should have the explicit connectionFactory", 2, explicitConnectionFactoryCount);
}

@Test
public void testResponseDestination() {
    // JMS
    DefaultMessageListenerContainer listener1 = this.context.getBean("listener1", DefaultMessageListenerContainer.clreplaced);
    DefaultMessageListenerContainer listener2 = this.context.getBean("listener2", DefaultMessageListenerContainer.clreplaced);
    replacedertEquals("Wrong destination type on listener1", true, listener1.isPubSubDomain());
    replacedertEquals("Wrong destination type on listener2", true, listener2.isPubSubDomain());
    replacedertEquals("Wrong response destination type on listener1", false, listener1.isReplyPubSubDomain());
    replacedertEquals("Wrong response destination type on listener2", false, listener2.isReplyPubSubDomain());
    // JCA
    JmsMessageEndpointManager listener3 = this.context.getBean("listener3", JmsMessageEndpointManager.clreplaced);
    JmsMessageEndpointManager listener4 = this.context.getBean("listener4", JmsMessageEndpointManager.clreplaced);
    replacedertEquals("Wrong destination type on listener3", true, listener3.isPubSubDomain());
    replacedertEquals("Wrong destination type on listener4", true, listener4.isPubSubDomain());
    replacedertEquals("Wrong response destination type on listener3", false, listener3.isReplyPubSubDomain());
    replacedertEquals("Wrong response destination type on listener4", false, listener4.isReplyPubSubDomain());
}

private ErrorHandler getErrorHandler(String containerBeanName) {
    DefaultMessageListenerContainer container = this.context.getBean(containerBeanName, DefaultMessageListenerContainer.clreplaced);
    return (ErrorHandler) new DirectFieldAccessor(container).getPropertyValue("errorHandler");
}

@Test
public void testJmsContainerFactoryConfiguration() {
    Map<String, DefaultJmsListenerContainerFactory> containers = context.getBeansOfType(DefaultJmsListenerContainerFactory.clreplaced);
    DefaultJmsListenerContainerFactory factory = containers.get("testJmsFactory");
    replacedertNotNull("No factory registered with testJmsFactory id", factory);
    DefaultMessageListenerContainer container = factory.createListenerContainer(createDummyEndpoint());
    replacedertEquals("explicit connection factory not set", context.getBean(EXPLICIT_CONNECTION_FACTORY), container.getConnectionFactory());
    replacedertEquals("explicit destination resolver not set", context.getBean("testDestinationResolver"), container.getDestinationResolver());
    replacedertEquals("explicit message converter not set", context.getBean("testMessageConverter"), container.getMessageConverter());
    replacedertEquals("Wrong pub/sub", true, container.isPubSubDomain());
    replacedertEquals("Wrong durable flag", true, container.isSubscriptionDurable());
    replacedertEquals("wrong cache", DefaultMessageListenerContainer.CACHE_CONNECTION, container.getCacheLevel());
    replacedertEquals("wrong concurrency", 3, container.getConcurrentConsumers());
    replacedertEquals("wrong concurrency", 5, container.getMaxConcurrentConsumers());
    replacedertEquals("wrong prefetch", 50, container.getMaxMessagesPerTask());
    replacedertEquals("Wrong phase", 99, container.getPhase());
    replacedertSame(context.getBean("testBackOff"), new DirectFieldAccessor(container).getPropertyValue("backOff"));
}

private BackOff getBackOff(String containerBeanName) {
    DefaultMessageListenerContainer container = this.context.getBean(containerBeanName, DefaultMessageListenerContainer.clreplaced);
    return (BackOff) new DirectFieldAccessor(container).getPropertyValue("backOff");
}

private MessageListener getListener(String containerBeanName) {
    DefaultMessageListenerContainer container = this.context.getBean(containerBeanName, DefaultMessageListenerContainer.clreplaced);
    return (MessageListener) container.getMessageListener();
}

@Test
public void setupMessageContainerNoListener() {
    DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
    SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
    replacedertThatIllegalStateException().isThrownBy(() -> endpoint.setupListenerContainer(container));
}

@Test
public void endpointConcurrencyTakesPrecedence() {
    DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
    factory.setConcurrency("2-10");
    SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
    MessageListener messageListener = new MessageListenerAdapter();
    endpoint.setMessageListener(messageListener);
    endpoint.setDestination("myQueue");
    endpoint.setConcurrency("4-6");
    DefaultMessageListenerContainer container = factory.createListenerContainer(endpoint);
    replacedertEquals(4, container.getConcurrentConsumers());
    replacedertEquals(6, container.getMaxConcurrentConsumers());
}

@Override
protected void initializeContainer(DefaultMessageListenerContainer container) {
    if (this.taskExecutor != null) {
        container.setTaskExecutor(this.taskExecutor);
    }
    if (this.transactionManager != null) {
        container.setTransactionManager(this.transactionManager);
    }
    if (this.cacheLevel != null) {
        container.setCacheLevel(this.cacheLevel);
    } else if (this.cacheLevelName != null) {
        container.setCacheLevelName(this.cacheLevelName);
    }
    if (this.concurrency != null) {
        container.setConcurrency(this.concurrency);
    }
    if (this.maxMessagesPerTask != null) {
        container.setMaxMessagesPerTask(this.maxMessagesPerTask);
    }
    if (this.receiveTimeout != null) {
        container.setReceiveTimeout(this.receiveTimeout);
    }
    if (this.backOff != null) {
        container.setBackOff(this.backOff);
        if (this.recoveryInterval != null) {
            logger.info("Ignoring recovery interval in DefaultJmsListenerContainerFactory in favor of BackOff");
        }
    } else if (this.recoveryInterval != null) {
        container.setRecoveryInterval(this.recoveryInterval);
    }
}

/**
 * @author Stephane Nicoll
 * @author Sam Brannen
 */
clreplaced MethodJmsListenerEndpointTests {

    private final DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();

    private final DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();

    private final JmsEndpointSampleBean sample = new JmsEndpointSampleBean();

    private String methodName;

    @BeforeEach
    void setup(TestInfo testInfo) {
        this.methodName = testInfo.getTestMethod().get().getName();
        initializeFactory(this.factory);
    }

    @Test
    void createMessageListenerNoFactory() {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this);
        endpoint.setMethod(getTestMethod());
        replacedertThatIllegalStateException().isThrownBy(() -> endpoint.createMessageListener(this.container));
    }

    @Test
    void createMessageListener() {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this);
        endpoint.setMethod(getTestMethod());
        endpoint.setMessageHandlerMethodFactory(this.factory);
        replacedertThat(endpoint.createMessageListener(this.container)).isNotNull();
    }

    @Test
    void setExtraCollaborators() {
        MessageConverter messageConverter = mock(MessageConverter.clreplaced);
        DestinationResolver destinationResolver = mock(DestinationResolver.clreplaced);
        this.container.setMessageConverter(messageConverter);
        this.container.setDestinationResolver(destinationResolver);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod("resolveObjectPayload", MyBean.clreplaced), this.container);
        DirectFieldAccessor accessor = new DirectFieldAccessor(listener);
        replacedertThat(accessor.getPropertyValue("messageConverter")).isSameAs(messageConverter);
        replacedertThat(accessor.getPropertyValue("destinationResolver")).isSameAs(destinationResolver);
    }

    @Test
    void resolveMessageAndSession() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(javax.jms.Message.clreplaced, Session.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void resolveGenericMessage() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Message.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void resolveHeaderAndPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 55);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void resolveCustomHeaderNameAndPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 24);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void resolveCustomHeaderNameAndPayloadWithHeaderNameSet() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 24);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void resolveHeaders() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, Map.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("customInt", 1234);
        message.setJMSMessageID("abcd-1234");
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void resolveMessageHeaders() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(MessageHeaders.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setLongProperty("customLong", 4567L);
        message.setJMSType("myMessageType");
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void resolveJmsMessageHeaderAccessor() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(JmsMessageHeaderAccessor.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setBooleanProperty("customBoolean", true);
        message.setJMSPriority(9);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void resolveObjectPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(MyBean.clreplaced);
        MyBean myBean = new MyBean();
        myBean.name = "myBean name";
        Session session = mock(Session.clreplaced);
        ObjectMessage message = mock(ObjectMessage.clreplaced);
        given(message.getObject()).willReturn(myBean);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void resolveConvertedPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Integer.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("33"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void processAndReply() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        String body = "echo text";
        String correlationId = "link-1234";
        Destination replyDestination = new Destination() {
        };
        TextMessage reply = mock(TextMessage.clreplaced);
        QueueSender queueSender = mock(QueueSender.clreplaced);
        Session session = mock(Session.clreplaced);
        given(session.createTextMessage(body)).willReturn(reply);
        given(session.createProducer(replyDestination)).willReturn(queueSender);
        listener.setDefaultResponseDestination(replyDestination);
        StubTextMessage inputMessage = createSimpleJmsTextMessage(body);
        inputMessage.setJMSCorrelationID(correlationId);
        listener.onMessage(inputMessage, session);
        replacedertDefaultListenerMethodInvocation();
        verify(reply).setJMSCorrelationID(correlationId);
        verify(queueSender).send(reply);
        verify(queueSender).close();
    }

    @Test
    void processAndReplyWithSendToQueue() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    void processFromTopicAndReplyWithSendToQueue() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setPubSubDomain(true);
        container.setReplyPubSubDomain(false);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    void processAndReplyWithSendToTopic() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setPubSubDomain(true);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", true);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    void processFromQueueAndReplyWithSendToTopic() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setReplyPubSubDomain(true);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", true);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    void processAndReplyWithDefaultSendTo() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        processAndReplyWithSendTo(listener, "defaultReply", false);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    void processAndReplyWithCustomReplyQosSettings() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        QosSettings replyQosSettings = new QosSettings(1, 6, 6000);
        container.setReplyQosSettings(replyQosSettings);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false, replyQosSettings);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    void processAndReplyWithNullReplyQosSettings() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setReplyQosSettings(null);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    private void processAndReplyWithSendTo(MessagingMessageListenerAdapter listener, String replyDestinationName, boolean pubSubDomain) throws JMSException {
        processAndReplyWithSendTo(listener, replyDestinationName, pubSubDomain, null);
    }

    private void processAndReplyWithSendTo(MessagingMessageListenerAdapter listener, String replyDestinationName, boolean pubSubDomain, QosSettings replyQosSettings) throws JMSException {
        String body = "echo text";
        String correlationId = "link-1234";
        Destination replyDestination = new Destination() {
        };
        DestinationResolver destinationResolver = mock(DestinationResolver.clreplaced);
        TextMessage reply = mock(TextMessage.clreplaced);
        QueueSender queueSender = mock(QueueSender.clreplaced);
        Session session = mock(Session.clreplaced);
        given(destinationResolver.resolveDestinationName(session, replyDestinationName, pubSubDomain)).willReturn(replyDestination);
        given(session.createTextMessage(body)).willReturn(reply);
        given(session.createProducer(replyDestination)).willReturn(queueSender);
        listener.setDestinationResolver(destinationResolver);
        StubTextMessage inputMessage = createSimpleJmsTextMessage(body);
        inputMessage.setJMSCorrelationID(correlationId);
        listener.onMessage(inputMessage, session);
        verify(destinationResolver).resolveDestinationName(session, replyDestinationName, pubSubDomain);
        verify(reply).setJMSCorrelationID(correlationId);
        if (replyQosSettings != null) {
            verify(queueSender).send(reply, replyQosSettings.getDeliveryMode(), replyQosSettings.getPriority(), replyQosSettings.getTimeToLive());
        } else {
            verify(queueSender).send(reply);
        }
        verify(queueSender).close();
    }

    @Test
    void emptySendTo() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        TextMessage reply = mock(TextMessage.clreplaced);
        Session session = mock(Session.clreplaced);
        given(session.createTextMessage("content")).willReturn(reply);
        replacedertThatExceptionOfType(ReplyFailureException.clreplaced).isThrownBy(() -> listener.onMessage(createSimpleJmsTextMessage("content"), session)).withCauseInstanceOf(InvalidDestinationException.clreplaced);
    }

    @Test
    void invalidSendTo() {
        replacedertThatIllegalStateException().isThrownBy(() -> createDefaultInstance(String.clreplaced)).withMessageContaining("firstDestination").withMessageContaining("secondDestination");
    }

    @Test
    void validatePayloadValid() throws JMSException {
        String methodName = "validatePayload";
        DefaultMessageHandlerMethodFactory customFactory = new DefaultMessageHandlerMethodFactory();
        customFactory.setValidator(testValidator("invalid value"));
        initializeFactory(customFactory);
        Method method = getListenerMethod(methodName, String.clreplaced);
        MessagingMessageListenerAdapter listener = createInstance(customFactory, method);
        Session session = mock(Session.clreplaced);
        // test is a valid value
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    void validatePayloadInvalid() throws JMSException {
        DefaultMessageHandlerMethodFactory customFactory = new DefaultMessageHandlerMethodFactory();
        customFactory.setValidator(testValidator("invalid value"));
        Method method = getListenerMethod("validatePayload", String.clreplaced);
        MessagingMessageListenerAdapter listener = createInstance(customFactory, method);
        Session session = mock(Session.clreplaced);
        // test is an invalid value
        replacedertThatExceptionOfType(ListenerExecutionFailedException.clreplaced).isThrownBy(() -> listener.onMessage(createSimpleJmsTextMessage("invalid value"), session));
    }

    // failure scenario
    @Test
    void invalidPayloadType() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Integer.clreplaced);
        Session session = mock(Session.clreplaced);
        // test is not a valid integer
        replacedertThatExceptionOfType(ListenerExecutionFailedException.clreplaced).isThrownBy(() -> listener.onMessage(createSimpleJmsTextMessage("test"), session)).withCauseInstanceOf(MessageConversionException.clreplaced).withMessageContaining(// ref to method
        getDefaultListenerMethod(Integer.clreplaced).toGenericString());
    }

    @Test
    void invalidMessagePayloadType() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Message.clreplaced);
        Session session = mock(Session.clreplaced);
        // Message<String> as Message<Integer>
        replacedertThatExceptionOfType(ListenerExecutionFailedException.clreplaced).isThrownBy(() -> listener.onMessage(createSimpleJmsTextMessage("test"), session)).withCauseInstanceOf(MessageConversionException.clreplaced);
    }

    private MessagingMessageListenerAdapter createInstance(DefaultMessageHandlerMethodFactory factory, Method method, MessageListenerContainer container) {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this.sample);
        endpoint.setMethod(method);
        endpoint.setMessageHandlerMethodFactory(factory);
        return endpoint.createMessageListener(container);
    }

    private MessagingMessageListenerAdapter createInstance(DefaultMessageHandlerMethodFactory factory, Method method) {
        return createInstance(factory, method, new SimpleMessageListenerContainer());
    }

    private MessagingMessageListenerAdapter createDefaultInstance(Clreplaced<?>... parameterTypes) {
        return createInstance(this.factory, getDefaultListenerMethod(parameterTypes));
    }

    private StubTextMessage createSimpleJmsTextMessage(String body) {
        return new StubTextMessage(body);
    }

    private Method getListenerMethod(String methodName, Clreplaced<?>... parameterTypes) {
        Method method = ReflectionUtils.findMethod(JmsEndpointSampleBean.clreplaced, methodName, parameterTypes);
        replacedertThat(("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes))).isNotNull();
        return method;
    }

    private Method getDefaultListenerMethod(Clreplaced<?>... parameterTypes) {
        return getListenerMethod(this.methodName, parameterTypes);
    }

    private void replacedertDefaultListenerMethodInvocation() {
        replacedertListenerMethodInvocation(this.sample, this.methodName);
    }

    private void replacedertListenerMethodInvocation(JmsEndpointSampleBean bean, String methodName) {
        replacedertThat((boolean) bean.invocations.get(methodName)).as("Method " + methodName + " should have been invoked").isTrue();
    }

    private void initializeFactory(DefaultMessageHandlerMethodFactory factory) {
        factory.setBeanFactory(new StaticListableBeanFactory());
        factory.afterPropertiesSet();
    }

    private Validator testValidator(final String invalidValue) {
        return new Validator() {

            @Override
            public boolean supports(Clreplaced<?> clazz) {
                return String.clreplaced.isreplacedignableFrom(clazz);
            }

            @Override
            public void validate(@Nullable Object target, Errors errors) {
                String value = (String) target;
                if (invalidValue.equals(value)) {
                    errors.reject("not a valid value");
                }
            }
        };
    }

    private Method getTestMethod() {
        return ReflectionUtils.findMethod(MethodJmsListenerEndpointTests.clreplaced, this.methodName);
    }

    @SendTo("defaultReply")
    @SuppressWarnings("unused")
    static clreplaced JmsEndpointSampleBean {

        private final Map<String, Boolean> invocations = new HashMap<>();

        public void resolveMessageAndSession(javax.jms.Message message, Session session) {
            this.invocations.put("resolveMessageAndSession", true);
            replacedertThat(message).as("Message not injected").isNotNull();
            replacedertThat(session).as("Session not injected").isNotNull();
        }

        public void resolveGenericMessage(Message<String> message) {
            this.invocations.put("resolveGenericMessage", true);
            replacedertThat(message).as("Generic message not injected").isNotNull();
            replacedertThat(message.getPayload()).as("Wrong message payload").isEqualTo("test");
        }

        public void resolveHeaderAndPayload(@Payload String content, @Header int myCounter) {
            this.invocations.put("resolveHeaderAndPayload", true);
            replacedertThat(content).as("Wrong @Payload resolution").isEqualTo("my payload");
            replacedertThat(myCounter).as("Wrong @Header resolution").isEqualTo(55);
        }

        public void resolveCustomHeaderNameAndPayload(@Payload String content, @Header("myCounter") int counter) {
            this.invocations.put("resolveCustomHeaderNameAndPayload", true);
            replacedertThat(content).as("Wrong @Payload resolution").isEqualTo("my payload");
            replacedertThat(counter).as("Wrong @Header resolution").isEqualTo(24);
        }

        public void resolveCustomHeaderNameAndPayloadWithHeaderNameSet(@Payload String content, @Header(name = "myCounter") int counter) {
            this.invocations.put("resolveCustomHeaderNameAndPayloadWithHeaderNameSet", true);
            replacedertThat(content).as("Wrong @Payload resolution").isEqualTo("my payload");
            replacedertThat(counter).as("Wrong @Header resolution").isEqualTo(24);
        }

        public void resolveHeaders(String content, @Headers Map<String, Object> headers) {
            this.invocations.put("resolveHeaders", true);
            replacedertThat(content).as("Wrong payload resolution").isEqualTo("my payload");
            replacedertThat(headers).as("headers not injected").isNotNull();
            replacedertThat(headers.get(JmsHeaders.MESSAGE_ID)).as("Missing JMS message id header").isEqualTo("abcd-1234");
            replacedertThat(headers.get("customInt")).as("Missing custom header").isEqualTo(1234);
        }

        public void resolveMessageHeaders(MessageHeaders headers) {
            this.invocations.put("resolveMessageHeaders", true);
            replacedertThat(headers).as("MessageHeaders not injected").isNotNull();
            replacedertThat(headers.get(JmsHeaders.TYPE)).as("Missing JMS message type header").isEqualTo("myMessageType");
            replacedertThat((long) headers.get("customLong")).as("Missing custom header").isEqualTo(4567);
        }

        public void resolveJmsMessageHeaderAccessor(JmsMessageHeaderAccessor headers) {
            this.invocations.put("resolveJmsMessageHeaderAccessor", true);
            replacedertThat(headers).as("MessageHeaders not injected").isNotNull();
            replacedertThat(headers.getPriority()).as("Missing JMS message priority header").isEqualTo(Integer.valueOf(9));
            replacedertThat(headers.getHeader("customBoolean")).as("Missing custom header").isEqualTo(true);
        }

        public void resolveObjectPayload(MyBean bean) {
            this.invocations.put("resolveObjectPayload", true);
            replacedertThat(bean).as("Object payload not injected").isNotNull();
            replacedertThat(bean.name).as("Wrong content for payload").isEqualTo("myBean name");
        }

        public void resolveConvertedPayload(Integer counter) {
            this.invocations.put("resolveConvertedPayload", true);
            replacedertThat(counter).as("Payload not injected").isNotNull();
            replacedertThat(counter).as("Wrong content for payload").isEqualTo(Integer.valueOf(33));
        }

        public String processAndReply(@Payload String content) {
            this.invocations.put("processAndReply", true);
            return content;
        }

        @SendTo("replyDestination")
        public String processAndReplyWithSendTo(String content) {
            this.invocations.put("processAndReplyWithSendTo", true);
            return content;
        }

        public String processAndReplyWithDefaultSendTo(String content) {
            this.invocations.put("processAndReplyWithDefaultSendTo", true);
            return content;
        }

        @SendTo("")
        public String emptySendTo(String content) {
            this.invocations.put("emptySendTo", true);
            return content;
        }

        @SendTo({ "firstDestination", "secondDestination" })
        public String invalidSendTo(String content) {
            this.invocations.put("invalidSendTo", true);
            return content;
        }

        public void validatePayload(@Validated String payload) {
            this.invocations.put("validatePayload", true);
        }

        public void invalidPayloadType(@Payload Integer payload) {
            throw new IllegalStateException("Should never be called.");
        }

        public void invalidMessagePayloadType(Message<Integer> message) {
            throw new IllegalStateException("Should never be called.");
        }
    }

    @SuppressWarnings("serial")
    static clreplaced MyBean implements Serializable {

        private String name;
    }
}

@Test
public void testJmsContainerFactoryConfiguration() {
    Map<String, DefaultJmsListenerContainerFactory> containers = context.getBeansOfType(DefaultJmsListenerContainerFactory.clreplaced);
    DefaultJmsListenerContainerFactory factory = containers.get("testJmsFactory");
    replacedertThat(factory).as("No factory registered with testJmsFactory id").isNotNull();
    DefaultMessageListenerContainer container = factory.createListenerContainer(createDummyEndpoint());
    replacedertThat(container.getConnectionFactory()).as("explicit connection factory not set").isEqualTo(context.getBean(EXPLICIT_CONNECTION_FACTORY));
    replacedertThat(container.getDestinationResolver()).as("explicit destination resolver not set").isEqualTo(context.getBean("testDestinationResolver"));
    replacedertThat(container.getMessageConverter()).as("explicit message converter not set").isEqualTo(context.getBean("testMessageConverter"));
    replacedertThat(container.isPubSubDomain()).as("Wrong pub/sub").isEqualTo(true);
    replacedertThat(container.isSubscriptionDurable()).as("Wrong durable flag").isEqualTo(true);
    replacedertThat(container.getCacheLevel()).as("wrong cache").isEqualTo(DefaultMessageListenerContainer.CACHE_CONNECTION);
    replacedertThat(container.getConcurrentConsumers()).as("wrong concurrency").isEqualTo(3);
    replacedertThat(container.getMaxConcurrentConsumers()).as("wrong concurrency").isEqualTo(5);
    replacedertThat(container.getMaxMessagesPerTask()).as("wrong prefetch").isEqualTo(50);
    replacedertThat(container.getPhase()).as("Wrong phase").isEqualTo(99);
    replacedertThat(new DirectFieldAccessor(container).getPropertyValue("backOff")).isSameAs(context.getBean("testBackOff"));
}

@Test
public void testResponseDestination() {
    // JMS
    DefaultMessageListenerContainer listener1 = this.context.getBean("listener1", DefaultMessageListenerContainer.clreplaced);
    DefaultMessageListenerContainer listener2 = this.context.getBean("listener2", DefaultMessageListenerContainer.clreplaced);
    replacedertThat(listener1.isPubSubDomain()).as("Wrong destination type on listener1").isEqualTo(true);
    replacedertThat(listener2.isPubSubDomain()).as("Wrong destination type on listener2").isEqualTo(true);
    replacedertThat(listener1.isReplyPubSubDomain()).as("Wrong response destination type on listener1").isEqualTo(false);
    replacedertThat(listener2.isReplyPubSubDomain()).as("Wrong response destination type on listener2").isEqualTo(false);
    // JCA
    JmsMessageEndpointManager listener3 = this.context.getBean("listener3", JmsMessageEndpointManager.clreplaced);
    JmsMessageEndpointManager listener4 = this.context.getBean("listener4", JmsMessageEndpointManager.clreplaced);
    replacedertThat(listener3.isPubSubDomain()).as("Wrong destination type on listener3").isEqualTo(true);
    replacedertThat(listener4.isPubSubDomain()).as("Wrong destination type on listener4").isEqualTo(true);
    replacedertThat(listener3.isReplyPubSubDomain()).as("Wrong response destination type on listener3").isEqualTo(false);
    replacedertThat(listener4.isReplyPubSubDomain()).as("Wrong response destination type on listener4").isEqualTo(false);
}

@Test
public void testContainerConfiguration() throws Exception {
    Map<String, DefaultMessageListenerContainer> containers = context.getBeansOfType(DefaultMessageListenerContainer.clreplaced);
    ConnectionFactory defaultConnectionFactory = context.getBean(DEFAULT_CONNECTION_FACTORY, ConnectionFactory.clreplaced);
    ConnectionFactory explicitConnectionFactory = context.getBean(EXPLICIT_CONNECTION_FACTORY, ConnectionFactory.clreplaced);
    int defaultConnectionFactoryCount = 0;
    int explicitConnectionFactoryCount = 0;
    for (DefaultMessageListenerContainer container : containers.values()) {
        if (container.getConnectionFactory().equals(defaultConnectionFactory)) {
            defaultConnectionFactoryCount++;
        } else if (container.getConnectionFactory().equals(explicitConnectionFactory)) {
            explicitConnectionFactoryCount++;
        }
    }
    replacedertThat(defaultConnectionFactoryCount).as("1 container should have the default connectionFactory").isEqualTo(1);
    replacedertThat(explicitConnectionFactoryCount).as("2 containers should have the explicit connectionFactory").isEqualTo(2);
}

@Test
public void endpointConcurrencyTakesPrecedence() {
    DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
    factory.setConcurrency("2-10");
    SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
    MessageListener messageListener = new MessageListenerAdapter();
    endpoint.setMessageListener(messageListener);
    endpoint.setDestination("myQueue");
    endpoint.setConcurrency("4-6");
    DefaultMessageListenerContainer container = factory.createListenerContainer(endpoint);
    replacedertThat(container.getConcurrentConsumers()).isEqualTo(4);
    replacedertThat(container.getMaxConcurrentConsumers()).isEqualTo(6);
}

@RequestMapping(value = "/subscription", method = RequestMethod.POST)
public ResponseEnreplacedy<String> addSubscription(@RequestBody SimpleSubscription subscription) {
    String subscriptionTopic = subscription.getSubscription();
    logger.info("Adding a subscription to topic: " + subscriptionTopic);
    if (this.listenerContainersMap.containsKey(subscriptionTopic)) {
        // Already subscribed
        logger.error("Already subscribed to topic " + subscriptionTopic);
        return new ResponseEnreplacedy<>("{'description': 'Already subscribed'}", HttpStatus.BAD_REQUEST);
    }
    // Then create a listener
    try {
        DefaultMessageListenerContainer listenercontainer = createListener(subscriptionTopic);
        listenercontainer.start();
        this.listenerContainersMap.put(subscriptionTopic, listenercontainer);
    } catch (Exception e) {
        logger.error("Service Creation failed.", e);
        return new ResponseEnreplacedy<>("{'description': '" + e.getMessage() + "'}", HttpStatus.BAD_REQUEST);
    }
    logger.info("Finished Adding a subscription to topic: " + subscriptionTopic);
    return new ResponseEnreplacedy<>("{}", HttpStatus.OK);
}

@RequestMapping(value = "/subscription/{subscriptionName}", method = RequestMethod.DELETE)
public ResponseEnreplacedy<String> deleteSubscription(@PathVariable("subscriptionName") String subscriptionTopic) {
    logger.info("Deleting a subscription to topic: " + subscriptionTopic);
    if (!this.listenerContainersMap.containsKey(subscriptionTopic)) {
        // Not subscribed
        logger.error("Not subscribed to topic " + subscriptionTopic);
        return new ResponseEnreplacedy<>("{'description': 'Was not subscribed'}", HttpStatus.BAD_REQUEST);
    }
    try {
        DefaultMessageListenerContainer listenercontainer = this.listenerContainersMap.get(subscriptionTopic);
        listenercontainer.stop();
        listenercontainer.destroy();
        this.listenerContainersMap.remove(subscriptionTopic);
    } catch (Exception e) {
        logger.error("Service Creation failed.", e);
        return new ResponseEnreplacedy<>("{'description': '" + e.getMessage() + "'}", HttpStatus.BAD_REQUEST);
    }
    logger.info("Finished Deleting a subscription to topic: " + subscriptionTopic);
    return new ResponseEnreplacedy<>("{}", HttpStatus.OK);
}

@RequestMapping(value = "/subscription", method = RequestMethod.POST)
public ResponseEnreplacedy<String> addSubscription(@RequestBody SimpleSubscription subscription) {
    String subscriptionTopic = subscription.getSubscription();
    logger.info("Adding a subscription to topic: " + subscriptionTopic);
    if (this.listenerContainersMap.containsKey(subscriptionTopic)) {
        // Already subscribed
        logger.error("Already subscribed to topic " + subscriptionTopic);
        return new ResponseEnreplacedy<>("{'description': 'Already subscribed'}", HttpStatus.BAD_REQUEST);
    }
    try {
        DefaultMessageListenerContainer listenercontainer = createListener(subscriptionTopic);
        listenercontainer.start();
        this.listenerContainersMap.put(subscriptionTopic, listenercontainer);
    } catch (Exception e) {
        logger.error("Service Creation failed.", e);
        return new ResponseEnreplacedy<>("{'description': '" + e.getMessage() + "'}", HttpStatus.BAD_REQUEST);
    }
    logger.info("Finished Adding a subscription to topic: " + subscriptionTopic);
    return new ResponseEnreplacedy<>("{}", HttpStatus.OK);
}

public DefaultMessageListenerContainer initMessageListenerContainer(final MessageListener messageListener, final ActiveMQDestination destination) {
    LOGGER.debug("Initializing message listener container for message listener: {}, and destination {}.", messageListener, destination);
    final DefaultMessageListenerContainer messageListenerContainer = this.initMessageListenerContainer();
    messageListenerContainer.setDestination(destination);
    messageListenerContainer.setMessageListener(messageListener);
    return messageListenerContainer;
}

private DefaultMessageListenerContainer initMessageListenerContainer() {
    LOGGER.debug("Initializing default message listener container.");
    final DefaultMessageListenerContainer defaultMessageListenerContainer = new DefaultMessageListenerContainer();
    defaultMessageListenerContainer.setConnectionFactory(this.pooledConnectionFactory);
    defaultMessageListenerContainer.setConcurrentConsumers(this.propertyReader.get(PROPERTY_NAME_CONCURRENT_CONSUMERS, int.clreplaced));
    defaultMessageListenerContainer.setMaxConcurrentConsumers(this.propertyReader.get(PROPERTY_NAME_MAX_CONCURRENT_CONSUMERS, int.clreplaced));
    defaultMessageListenerContainer.setSessionTransacted(true);
    return defaultMessageListenerContainer;
}

@Bean(name = "protocolIec61850InboundOsgpCoreRequestsMessageListenerContainer")
public DefaultMessageListenerContainer messageListenerContainer(@Qualifier("protocolIec61850InboundOsgpCoreRequestsMessageListener") final DeviceRequestMessageListener messageListener) {
    final DefaultMessageListenerContainer messageListenerContainer = this.jmsConfigurationFactory.initMessageListenerContainer(messageListener);
    // Setting ErrorHandler to prevent logging at WARN level
    // when JMSException is thrown: Execution of JMS message
    // listener failed, and no ErrorHandler has been set.
    messageListenerContainer.setErrorHandler(t -> LOGGER.debug("iec61850RequestsMessageListenerContainer.ErrorHandler.handleError()", t));
    return messageListenerContainer;
}

@Bean(name = "protocolIec60870InboundOsgpCoreRequestsMessageListenerContainer")
public DefaultMessageListenerContainer messageListenerContainer(@Qualifier("protocolIec60870InboundOsgpCoreRequestsMessageListener") final MessageListener messageListener) {
    final DefaultMessageListenerContainer messageListenerContainer = this.jmsConfigurationFactory.initMessageListenerContainer(messageListener);
    // Setting ErrorHandler to prevent logging at WARN level
    // when JMSException is thrown: Execution of JMS message
    // listener failed, and no ErrorHandler has been set.
    messageListenerContainer.setErrorHandler(t -> LOGGER.debug("iec60870RequestsMessageListenerContainer.ErrorHandler.handleError()", t));
    return messageListenerContainer;
}

@Bean(name = "protocolDlmsInboundOsgpCoreRequestsMessageListenerContainer")
public DefaultMessageListenerContainer messageListenerContainer(@Qualifier("protocolDlmsInboundOsgpCoreRequestsMessageListener") final MessageListener messageListener) {
    DefaultMessageListenerContainer container = this.jmsConfigurationFactory.initMessageListenerContainer(messageListener);
    LOGGER.info("Initializing protocolDlmsInboundOsgpCoreRequestsMessageListenerContainer bean at Destination {}", container.getDestination());
    return container;
}

@Override
protected void preUnregister(final String key) {
    final DefaultMessageListenerContainer messageListenerContainer = this.getValue(key);
    if (messageListenerContainer != null) {
        LOGGER.info("Stopping and destroying MessageListenerContainer {}", key);
        stopAndDestroy(messageListenerContainer);
    }
}

private static void stopAndDestroy(final DefaultMessageListenerContainer messageListenerContainer) {
    messageListenerContainer.stop();
    messageListenerContainer.destroy();
}

private void init(final DomainInfo domainInfo) throws SSLException {
    final JmsConfigurationFactory jmsConfigurationFactory = new JmsConfigurationFactory(this.environment, this.defaultDomainJmsConfiguration, domainInfo.getIncomingResponsesPropertyPrefix());
    final PooledConnectionFactory connectionFactory = jmsConfigurationFactory.getPooledConnectionFactory();
    this.connectionFactoryRegistry.register(domainInfo.getKey(), connectionFactory);
    connectionFactory.start();
    final DomainResponseMessageListener messageListener = new DomainResponseMessageListener(this.protocolResponseService, this.protocolInfos);
    final DefaultMessageListenerContainer messageListenerContainer = jmsConfigurationFactory.initMessageListenerContainer(messageListener);
    this.messageListenerRegistry.register(domainInfo.getKey(), messageListenerContainer);
    messageListenerContainer.afterPropertiesSet();
    messageListenerContainer.start();
}

private void init(final DomainInfo domainInfo) throws SSLException {
    final JmsConfigurationFactory jmsConfigurationFactory = new JmsConfigurationFactory(this.environment, this.defaultDomainJmsConfiguration, domainInfo.getIncomingRequestsPropertyPrefix());
    final PooledConnectionFactory connectionFactory = jmsConfigurationFactory.getPooledConnectionFactory();
    this.connectionFactoryRegistry.register(domainInfo.getKey(), connectionFactory);
    connectionFactory.start();
    final DomainRequestMessageListener messageListener = new DomainRequestMessageListener(domainInfo, this.deviceRequestMessageService, this.scheduledTaskRepository);
    final DefaultMessageListenerContainer messageListenerContainer = jmsConfigurationFactory.initMessageListenerContainer(messageListener);
    this.messageListenerContainerRegistry.register(domainInfo.getKey(), messageListenerContainer);
    messageListenerContainer.afterPropertiesSet();
    messageListenerContainer.start();
}

@Bean(name = "wsPublicLightingInboundDomainResponsesMessageListenerContainer")
public DefaultMessageListenerContainer messageListenerContainer(@Qualifier("wsPublicLightingInboundDomainResponsesMessageListener") final PublicLightingResponseMessageListener responseMessageListener) {
    LOGGER.info("Initializing wsPublicLightingInboundDomainResponsesMessageListenerContainer bean.");
    final DefaultMessageListenerContainer container = this.jmsConfigurationFactory.initMessageListenerContainer(responseMessageListener);
    // Only consume messages defined by the message selector string.
    // All other messages will be retrieved using
    // {@link PublicLightingResponseMessageFinder}
    container.setMessageSelector("JMSType = 'SET_LIGHT_SCHEDULE'");
    return container;
}

public void setListenerContainer(DefaultMessageListenerContainer listenerContainer) {
    this.listenerContainer = listenerContainer;
}

@Autowired
public void setDmlc(DefaultMessageListenerContainer dmlc) {
    this.dmlc = dmlc;
}

/**
 * @author Stephane Nicoll
 */
public clreplaced MethodJmsListenerEndpointTests {

    private final DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();

    private final DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();

    private final JmsEndpointSampleBean sample = new JmsEndpointSampleBean();

    @Rule
    public final TestName name = new TestName();

    @Rule
    public final ExpectedException thrown = ExpectedException.none();

    @Before
    public void setup() {
        initializeFactory(this.factory);
    }

    @Test
    public void createMessageListenerNoFactory() {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this);
        endpoint.setMethod(getTestMethod());
        this.thrown.expect(IllegalStateException.clreplaced);
        endpoint.createMessageListener(this.container);
    }

    @Test
    public void createMessageListener() {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this);
        endpoint.setMethod(getTestMethod());
        endpoint.setMessageHandlerMethodFactory(this.factory);
        replacedertNotNull(endpoint.createMessageListener(this.container));
    }

    @Test
    public void setExtraCollaborators() {
        MessageConverter messageConverter = mock(MessageConverter.clreplaced);
        DestinationResolver destinationResolver = mock(DestinationResolver.clreplaced);
        this.container.setMessageConverter(messageConverter);
        this.container.setDestinationResolver(destinationResolver);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod("resolveObjectPayload", MyBean.clreplaced), this.container);
        DirectFieldAccessor accessor = new DirectFieldAccessor(listener);
        replacedertSame(messageConverter, accessor.getPropertyValue("messageConverter"));
        replacedertSame(destinationResolver, accessor.getPropertyValue("destinationResolver"));
    }

    @Test
    public void resolveMessageAndSession() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(javax.jms.Message.clreplaced, Session.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveGenericMessage() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Message.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveHeaderAndPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 55);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveCustomHeaderNameAndPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 24);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveCustomHeaderNameAndPayloadWithHeaderNameSet() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 24);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveHeaders() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, Map.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("customInt", 1234);
        message.setJMSMessageID("abcd-1234");
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveMessageHeaders() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(MessageHeaders.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setLongProperty("customLong", 4567L);
        message.setJMSType("myMessageType");
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveJmsMessageHeaderAccessor() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(JmsMessageHeaderAccessor.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setBooleanProperty("customBoolean", true);
        message.setJMSPriority(9);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveObjectPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(MyBean.clreplaced);
        MyBean myBean = new MyBean();
        myBean.name = "myBean name";
        Session session = mock(Session.clreplaced);
        ObjectMessage message = mock(ObjectMessage.clreplaced);
        given(message.getObject()).willReturn(myBean);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveConvertedPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Integer.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("33"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void processAndReply() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        String body = "echo text";
        String correlationId = "link-1234";
        Destination replyDestination = new Destination() {
        };
        TextMessage reply = mock(TextMessage.clreplaced);
        QueueSender queueSender = mock(QueueSender.clreplaced);
        Session session = mock(Session.clreplaced);
        given(session.createTextMessage(body)).willReturn(reply);
        given(session.createProducer(replyDestination)).willReturn(queueSender);
        listener.setDefaultResponseDestination(replyDestination);
        StubTextMessage inputMessage = createSimpleJmsTextMessage(body);
        inputMessage.setJMSCorrelationID(correlationId);
        listener.onMessage(inputMessage, session);
        replacedertDefaultListenerMethodInvocation();
        verify(reply).setJMSCorrelationID(correlationId);
        verify(queueSender).send(reply);
        verify(queueSender).close();
    }

    @Test
    public void processAndReplyWithSendToQueue() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void processFromTopicAndReplyWithSendToQueue() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setPubSubDomain(true);
        container.setReplyPubSubDomain(false);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void processAndReplyWithSendToTopic() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setPubSubDomain(true);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", true);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void processFromQueueAndReplyWithSendToTopic() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setReplyPubSubDomain(true);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", true);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void processAndReplyWithDefaultSendTo() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        processAndReplyWithSendTo(listener, "defaultReply", false);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void processAndReplyWithCustomReplyQosSettings() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        QosSettings replyQosSettings = new QosSettings(1, 6, 6000);
        container.setReplyQosSettings(replyQosSettings);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false, replyQosSettings);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void processAndReplyWithNullReplyQosSettings() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setReplyQosSettings(null);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, "replyDestination", false);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    private void processAndReplyWithSendTo(MessagingMessageListenerAdapter listener, String replyDestinationName, boolean pubSubDomain) throws JMSException {
        processAndReplyWithSendTo(listener, replyDestinationName, pubSubDomain, null);
    }

    private void processAndReplyWithSendTo(MessagingMessageListenerAdapter listener, String replyDestinationName, boolean pubSubDomain, QosSettings replyQosSettings) throws JMSException {
        String body = "echo text";
        String correlationId = "link-1234";
        Destination replyDestination = new Destination() {
        };
        DestinationResolver destinationResolver = mock(DestinationResolver.clreplaced);
        TextMessage reply = mock(TextMessage.clreplaced);
        QueueSender queueSender = mock(QueueSender.clreplaced);
        Session session = mock(Session.clreplaced);
        given(destinationResolver.resolveDestinationName(session, replyDestinationName, pubSubDomain)).willReturn(replyDestination);
        given(session.createTextMessage(body)).willReturn(reply);
        given(session.createProducer(replyDestination)).willReturn(queueSender);
        listener.setDestinationResolver(destinationResolver);
        StubTextMessage inputMessage = createSimpleJmsTextMessage(body);
        inputMessage.setJMSCorrelationID(correlationId);
        listener.onMessage(inputMessage, session);
        verify(destinationResolver).resolveDestinationName(session, replyDestinationName, pubSubDomain);
        verify(reply).setJMSCorrelationID(correlationId);
        if (replyQosSettings != null) {
            verify(queueSender).send(reply, replyQosSettings.getDeliveryMode(), replyQosSettings.getPriority(), replyQosSettings.getTimeToLive());
        } else {
            verify(queueSender).send(reply);
        }
        verify(queueSender).close();
    }

    @Test
    public void emptySendTo() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        TextMessage reply = mock(TextMessage.clreplaced);
        Session session = mock(Session.clreplaced);
        given(session.createTextMessage("content")).willReturn(reply);
        this.thrown.expect(ReplyFailureException.clreplaced);
        this.thrown.expectCause(Matchers.isA(InvalidDestinationException.clreplaced));
        listener.onMessage(createSimpleJmsTextMessage("content"), session);
    }

    @Test
    public void invalidSendTo() {
        this.thrown.expect(IllegalStateException.clreplaced);
        this.thrown.expectMessage("firstDestination");
        this.thrown.expectMessage("secondDestination");
        createDefaultInstance(String.clreplaced);
    }

    @Test
    public void validatePayloadValid() throws JMSException {
        String methodName = "validatePayload";
        DefaultMessageHandlerMethodFactory customFactory = new DefaultMessageHandlerMethodFactory();
        customFactory.setValidator(testValidator("invalid value"));
        initializeFactory(customFactory);
        Method method = getListenerMethod(methodName, String.clreplaced);
        MessagingMessageListenerAdapter listener = createInstance(customFactory, method);
        Session session = mock(Session.clreplaced);
        // test is a valid value
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertListenerMethodInvocation(this.sample, methodName);
    }

    @Test
    public void validatePayloadInvalid() throws JMSException {
        DefaultMessageHandlerMethodFactory customFactory = new DefaultMessageHandlerMethodFactory();
        customFactory.setValidator(testValidator("invalid value"));
        Method method = getListenerMethod("validatePayload", String.clreplaced);
        MessagingMessageListenerAdapter listener = createInstance(customFactory, method);
        Session session = mock(Session.clreplaced);
        this.thrown.expect(ListenerExecutionFailedException.clreplaced);
        // test is an invalid value
        listener.onMessage(createSimpleJmsTextMessage("invalid value"), session);
    }

    // failure scenario
    @Test
    public void invalidPayloadType() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Integer.clreplaced);
        Session session = mock(Session.clreplaced);
        this.thrown.expect(ListenerExecutionFailedException.clreplaced);
        this.thrown.expectCause(Matchers.isA(MessageConversionException.clreplaced));
        // ref to method
        this.thrown.expectMessage(getDefaultListenerMethod(Integer.clreplaced).toGenericString());
        // test is not a valid integer
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
    }

    @Test
    public void invalidMessagePayloadType() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Message.clreplaced);
        Session session = mock(Session.clreplaced);
        this.thrown.expect(ListenerExecutionFailedException.clreplaced);
        this.thrown.expectCause(Matchers.isA(MessageConversionException.clreplaced));
        // Message<String> as Message<Integer>
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
    }

    private MessagingMessageListenerAdapter createInstance(DefaultMessageHandlerMethodFactory factory, Method method, MessageListenerContainer container) {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this.sample);
        endpoint.setMethod(method);
        endpoint.setMessageHandlerMethodFactory(factory);
        return endpoint.createMessageListener(container);
    }

    private MessagingMessageListenerAdapter createInstance(DefaultMessageHandlerMethodFactory factory, Method method) {
        return createInstance(factory, method, new SimpleMessageListenerContainer());
    }

    private MessagingMessageListenerAdapter createDefaultInstance(Clreplaced<?>... parameterTypes) {
        return createInstance(this.factory, getDefaultListenerMethod(parameterTypes));
    }

    private StubTextMessage createSimpleJmsTextMessage(String body) {
        return new StubTextMessage(body);
    }

    private Method getListenerMethod(String methodName, Clreplaced<?>... parameterTypes) {
        Method method = ReflectionUtils.findMethod(JmsEndpointSampleBean.clreplaced, methodName, parameterTypes);
        replacedertNotNull("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes));
        return method;
    }

    private Method getDefaultListenerMethod(Clreplaced<?>... parameterTypes) {
        return getListenerMethod(this.name.getMethodName(), parameterTypes);
    }

    private void replacedertDefaultListenerMethodInvocation() {
        replacedertListenerMethodInvocation(this.sample, this.name.getMethodName());
    }

    private void replacedertListenerMethodInvocation(JmsEndpointSampleBean bean, String methodName) {
        replacedertTrue("Method " + methodName + " should have been invoked", bean.invocations.get(methodName));
    }

    private void initializeFactory(DefaultMessageHandlerMethodFactory factory) {
        factory.setBeanFactory(new StaticListableBeanFactory());
        factory.afterPropertiesSet();
    }

    private Validator testValidator(final String invalidValue) {
        return new Validator() {

            @Override
            public boolean supports(Clreplaced<?> clazz) {
                return String.clreplaced.isreplacedignableFrom(clazz);
            }

            @Override
            public void validate(@Nullable Object target, Errors errors) {
                String value = (String) target;
                if (invalidValue.equals(value)) {
                    errors.reject("not a valid value");
                }
            }
        };
    }

    private Method getTestMethod() {
        return ReflectionUtils.findMethod(MethodJmsListenerEndpointTests.clreplaced, this.name.getMethodName());
    }

    @SendTo("defaultReply")
    @SuppressWarnings("unused")
    static clreplaced JmsEndpointSampleBean {

        private final Map<String, Boolean> invocations = new HashMap<>();

        public void resolveMessageAndSession(javax.jms.Message message, Session session) {
            this.invocations.put("resolveMessageAndSession", true);
            replacedertNotNull("Message not injected", message);
            replacedertNotNull("Session not injected", session);
        }

        public void resolveGenericMessage(Message<String> message) {
            this.invocations.put("resolveGenericMessage", true);
            replacedertNotNull("Generic message not injected", message);
            replacedertEquals("Wrong message payload", "test", message.getPayload());
        }

        public void resolveHeaderAndPayload(@Payload String content, @Header int myCounter) {
            this.invocations.put("resolveHeaderAndPayload", true);
            replacedertEquals("Wrong @Payload resolution", "my payload", content);
            replacedertEquals("Wrong @Header resolution", 55, myCounter);
        }

        public void resolveCustomHeaderNameAndPayload(@Payload String content, @Header("myCounter") int counter) {
            this.invocations.put("resolveCustomHeaderNameAndPayload", true);
            replacedertEquals("Wrong @Payload resolution", "my payload", content);
            replacedertEquals("Wrong @Header resolution", 24, counter);
        }

        public void resolveCustomHeaderNameAndPayloadWithHeaderNameSet(@Payload String content, @Header(name = "myCounter") int counter) {
            this.invocations.put("resolveCustomHeaderNameAndPayloadWithHeaderNameSet", true);
            replacedertEquals("Wrong @Payload resolution", "my payload", content);
            replacedertEquals("Wrong @Header resolution", 24, counter);
        }

        public void resolveHeaders(String content, @Headers Map<String, Object> headers) {
            this.invocations.put("resolveHeaders", true);
            replacedertEquals("Wrong payload resolution", "my payload", content);
            replacedertNotNull("headers not injected", headers);
            replacedertEquals("Missing JMS message id header", "abcd-1234", headers.get(JmsHeaders.MESSAGE_ID));
            replacedertEquals("Missing custom header", 1234, headers.get("customInt"));
        }

        public void resolveMessageHeaders(MessageHeaders headers) {
            this.invocations.put("resolveMessageHeaders", true);
            replacedertNotNull("MessageHeaders not injected", headers);
            replacedertEquals("Missing JMS message type header", "myMessageType", headers.get(JmsHeaders.TYPE));
            replacedertEquals("Missing custom header", 4567L, (long) headers.get("customLong"), 0.0);
        }

        public void resolveJmsMessageHeaderAccessor(JmsMessageHeaderAccessor headers) {
            this.invocations.put("resolveJmsMessageHeaderAccessor", true);
            replacedertNotNull("MessageHeaders not injected", headers);
            replacedertEquals("Missing JMS message priority header", Integer.valueOf(9), headers.getPriority());
            replacedertEquals("Missing custom header", true, headers.getHeader("customBoolean"));
        }

        public void resolveObjectPayload(MyBean bean) {
            this.invocations.put("resolveObjectPayload", true);
            replacedertNotNull("Object payload not injected", bean);
            replacedertEquals("Wrong content for payload", "myBean name", bean.name);
        }

        public void resolveConvertedPayload(Integer counter) {
            this.invocations.put("resolveConvertedPayload", true);
            replacedertNotNull("Payload not injected", counter);
            replacedertEquals("Wrong content for payload", Integer.valueOf(33), counter);
        }

        public String processAndReply(@Payload String content) {
            this.invocations.put("processAndReply", true);
            return content;
        }

        @SendTo("replyDestination")
        public String processAndReplyWithSendTo(String content) {
            this.invocations.put("processAndReplyWithSendTo", true);
            return content;
        }

        public String processAndReplyWithDefaultSendTo(String content) {
            this.invocations.put("processAndReplyWithDefaultSendTo", true);
            return content;
        }

        @SendTo("")
        public String emptySendTo(String content) {
            this.invocations.put("emptySendTo", true);
            return content;
        }

        @SendTo({ "firstDestination", "secondDestination" })
        public String invalidSendTo(String content) {
            this.invocations.put("invalidSendTo", true);
            return content;
        }

        public void validatePayload(@Validated String payload) {
            this.invocations.put("validatePayload", true);
        }

        public void invalidPayloadType(@Payload Integer payload) {
            throw new IllegalStateException("Should never be called.");
        }

        public void invalidMessagePayloadType(Message<Integer> message) {
            throw new IllegalStateException("Should never be called.");
        }
    }

    @SuppressWarnings("serial")
    static clreplaced MyBean implements Serializable {

        private String name;
    }
}

@Test
public void setupMessageContainerNoListener() {
    DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
    SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
    thrown.expect(IllegalStateException.clreplaced);
    endpoint.setupListenerContainer(container);
}

@Bean
public DefaultMessageListenerContainer containerListener() {
    final DefaultMessageListenerContainer listener = new DefaultMessageListenerContainer();
    listener.setConnectionFactory(jmsCommonConfig.connectionFactory());
    listener.setDestination(jmsCommonConfig.confirmationQueue());
    listener.setMessageListener(confirmationReceiver());
    return listener;
}

@Bean
public DefaultMessageListenerContainer containerListener() {
    DefaultMessageListenerContainer listener = new DefaultMessageListenerContainer();
    listener.setConnectionFactory(jmsCommonConfig.connectionFactory());
    listener.setDestination(jmsCommonConfig.userQueue());
    listener.setMessageListener(userReceiver());
    return listener;
}

/**
 * @author Stephane Nicoll
 */
public clreplaced MethodJmsListenerEndpointTests {

    private final DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();

    private final DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();

    private final JmsEndpointSampleBean sample = new JmsEndpointSampleBean();

    @Rule
    public final TestName name = new TestName();

    @Rule
    public final ExpectedException thrown = ExpectedException.none();

    @Before
    public void setup() {
        initializeFactory(factory);
    }

    @Test
    public void createMessageListenerNoFactory() {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this);
        endpoint.setMethod(getTestMethod());
        thrown.expect(IllegalStateException.clreplaced);
        endpoint.createMessageListener(container);
    }

    @Test
    public void createMessageListener() {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(this);
        endpoint.setMethod(getTestMethod());
        endpoint.setMessageHandlerMethodFactory(factory);
        replacedertNotNull(endpoint.createMessageListener(container));
    }

    @Test
    public void setExtraCollaborators() {
        MessageConverter messageConverter = mock(MessageConverter.clreplaced);
        DestinationResolver destinationResolver = mock(DestinationResolver.clreplaced);
        this.container.setMessageConverter(messageConverter);
        this.container.setDestinationResolver(destinationResolver);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod("resolveObjectPayload", MyBean.clreplaced), container);
        DirectFieldAccessor accessor = new DirectFieldAccessor(listener);
        replacedertSame(messageConverter, accessor.getPropertyValue("messageConverter"));
        replacedertSame(destinationResolver, accessor.getPropertyValue("destinationResolver"));
    }

    @Test
    public void resolveMessageAndSession() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(javax.jms.Message.clreplaced, Session.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveGenericMessage() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Message.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveHeaderAndPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 55);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveCustomHeaderNameAndPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 24);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveCustomHeaderNameAndPayloadWithHeaderNameSet() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, int.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("myCounter", 24);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveHeaders() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced, Map.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setIntProperty("customInt", 1234);
        message.setJMSMessageID("abcd-1234");
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveMessageHeaders() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(MessageHeaders.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setLongProperty("customLong", 4567L);
        message.setJMSType("myMessageType");
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveJmsMessageHeaderAccessor() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(JmsMessageHeaderAccessor.clreplaced);
        Session session = mock(Session.clreplaced);
        StubTextMessage message = createSimpleJmsTextMessage("my payload");
        message.setBooleanProperty("customBoolean", true);
        message.setJMSPriority(9);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveObjectPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(MyBean.clreplaced);
        MyBean myBean = new MyBean();
        myBean.name = "myBean name";
        Session session = mock(Session.clreplaced);
        ObjectMessage message = mock(ObjectMessage.clreplaced);
        given(message.getObject()).willReturn(myBean);
        listener.onMessage(message, session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void resolveConvertedPayload() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Integer.clreplaced);
        Session session = mock(Session.clreplaced);
        listener.onMessage(createSimpleJmsTextMessage("33"), session);
        replacedertDefaultListenerMethodInvocation();
    }

    @Test
    public void processAndReply() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        String body = "echo text";
        String correlationId = "link-1234";
        Destination replyDestination = new Destination() {
        };
        TextMessage reply = mock(TextMessage.clreplaced);
        QueueSender queueSender = mock(QueueSender.clreplaced);
        Session session = mock(Session.clreplaced);
        given(session.createTextMessage(body)).willReturn(reply);
        given(session.createProducer(replyDestination)).willReturn(queueSender);
        listener.setDefaultResponseDestination(replyDestination);
        StubTextMessage inputMessage = createSimpleJmsTextMessage(body);
        inputMessage.setJMSCorrelationID(correlationId);
        listener.onMessage(inputMessage, session);
        replacedertDefaultListenerMethodInvocation();
        verify(reply).setJMSCorrelationID(correlationId);
        verify(queueSender).send(reply);
        verify(queueSender).close();
    }

    @Test
    public void processAndReplyWithSendToQueue() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, false);
        replacedertListenerMethodInvocation(sample, methodName);
    }

    @Test
    public void processFromTopicAndReplyWithSendToQueue() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setPubSubDomain(true);
        container.setReplyPubSubDomain(false);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, false);
        replacedertListenerMethodInvocation(sample, methodName);
    }

    @Test
    public void processAndReplyWithSendToTopic() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setPubSubDomain(true);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, true);
        replacedertListenerMethodInvocation(sample, methodName);
    }

    @Test
    public void processFromQueueAndReplyWithSendToTopic() throws JMSException {
        String methodName = "processAndReplyWithSendTo";
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setReplyPubSubDomain(true);
        MessagingMessageListenerAdapter listener = createInstance(this.factory, getListenerMethod(methodName, String.clreplaced), container);
        processAndReplyWithSendTo(listener, true);
        replacedertListenerMethodInvocation(sample, methodName);
    }

    private void processAndReplyWithSendTo(MessagingMessageListenerAdapter listener, boolean pubSubDomain) throws JMSException {
        String body = "echo text";
        String correlationId = "link-1234";
        Destination replyDestination = new Destination() {
        };
        DestinationResolver destinationResolver = mock(DestinationResolver.clreplaced);
        TextMessage reply = mock(TextMessage.clreplaced);
        QueueSender queueSender = mock(QueueSender.clreplaced);
        Session session = mock(Session.clreplaced);
        given(destinationResolver.resolveDestinationName(session, "replyDestination", pubSubDomain)).willReturn(replyDestination);
        given(session.createTextMessage(body)).willReturn(reply);
        given(session.createProducer(replyDestination)).willReturn(queueSender);
        listener.setDestinationResolver(destinationResolver);
        StubTextMessage inputMessage = createSimpleJmsTextMessage(body);
        inputMessage.setJMSCorrelationID(correlationId);
        listener.onMessage(inputMessage, session);
        verify(destinationResolver).resolveDestinationName(session, "replyDestination", pubSubDomain);
        verify(reply).setJMSCorrelationID(correlationId);
        verify(queueSender).send(reply);
        verify(queueSender).close();
    }

    @Test
    public void emptySendTo() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(String.clreplaced);
        TextMessage reply = mock(TextMessage.clreplaced);
        Session session = mock(Session.clreplaced);
        given(session.createTextMessage("content")).willReturn(reply);
        thrown.expect(ReplyFailureException.clreplaced);
        thrown.expectCause(Matchers.isA(InvalidDestinationException.clreplaced));
        listener.onMessage(createSimpleJmsTextMessage("content"), session);
    }

    @Test
    public void invalidSendTo() {
        thrown.expect(IllegalStateException.clreplaced);
        thrown.expectMessage("firstDestination");
        thrown.expectMessage("secondDestination");
        createDefaultInstance(String.clreplaced);
    }

    @Test
    public void validatePayloadValid() throws JMSException {
        String methodName = "validatePayload";
        DefaultMessageHandlerMethodFactory customFactory = new DefaultMessageHandlerMethodFactory();
        customFactory.setValidator(testValidator("invalid value"));
        initializeFactory(customFactory);
        Method method = getListenerMethod(methodName, String.clreplaced);
        MessagingMessageListenerAdapter listener = createInstance(customFactory, method);
        Session session = mock(Session.clreplaced);
        // test is a valid value
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
        replacedertListenerMethodInvocation(sample, methodName);
    }

    @Test
    public void validatePayloadInvalid() throws JMSException {
        DefaultMessageHandlerMethodFactory customFactory = new DefaultMessageHandlerMethodFactory();
        customFactory.setValidator(testValidator("invalid value"));
        Method method = getListenerMethod("validatePayload", String.clreplaced);
        MessagingMessageListenerAdapter listener = createInstance(customFactory, method);
        Session session = mock(Session.clreplaced);
        thrown.expect(ListenerExecutionFailedException.clreplaced);
        // test is an invalid value
        listener.onMessage(createSimpleJmsTextMessage("invalid value"), session);
    }

    // failure scenario
    @Test
    public void invalidPayloadType() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Integer.clreplaced);
        Session session = mock(Session.clreplaced);
        thrown.expect(ListenerExecutionFailedException.clreplaced);
        thrown.expectCause(Matchers.isA(MessageConversionException.clreplaced));
        // ref to method
        thrown.expectMessage(getDefaultListenerMethod(Integer.clreplaced).toGenericString());
        // test is not a valid integer
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
    }

    @Test
    public void invalidMessagePayloadType() throws JMSException {
        MessagingMessageListenerAdapter listener = createDefaultInstance(Message.clreplaced);
        Session session = mock(Session.clreplaced);
        thrown.expect(ListenerExecutionFailedException.clreplaced);
        thrown.expectCause(Matchers.isA(MethodArgumentTypeMismatchException.clreplaced));
        // Message<String> as Message<Integer>
        listener.onMessage(createSimpleJmsTextMessage("test"), session);
    }

    private MessagingMessageListenerAdapter createInstance(DefaultMessageHandlerMethodFactory factory, Method method, MessageListenerContainer container) {
        MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
        endpoint.setBean(sample);
        endpoint.setMethod(method);
        endpoint.setMessageHandlerMethodFactory(factory);
        return endpoint.createMessageListener(container);
    }

    private MessagingMessageListenerAdapter createInstance(DefaultMessageHandlerMethodFactory factory, Method method) {
        return createInstance(factory, method, new SimpleMessageListenerContainer());
    }

    private MessagingMessageListenerAdapter createDefaultInstance(Clreplaced<?>... parameterTypes) {
        return createInstance(this.factory, getDefaultListenerMethod(parameterTypes));
    }

    private StubTextMessage createSimpleJmsTextMessage(String body) {
        return new StubTextMessage(body);
    }

    private Method getListenerMethod(String methodName, Clreplaced<?>... parameterTypes) {
        Method method = ReflectionUtils.findMethod(JmsEndpointSampleBean.clreplaced, methodName, parameterTypes);
        replacedertNotNull("no method found with name " + methodName + " and parameters " + Arrays.toString(parameterTypes));
        return method;
    }

    private Method getDefaultListenerMethod(Clreplaced<?>... parameterTypes) {
        return getListenerMethod(name.getMethodName(), parameterTypes);
    }

    private void replacedertDefaultListenerMethodInvocation() {
        replacedertListenerMethodInvocation(sample, name.getMethodName());
    }

    private void replacedertListenerMethodInvocation(JmsEndpointSampleBean bean, String methodName) {
        replacedertTrue("Method " + methodName + " should have been invoked", bean.invocations.get(methodName));
    }

    private void initializeFactory(DefaultMessageHandlerMethodFactory factory) {
        factory.setBeanFactory(new StaticListableBeanFactory());
        factory.afterPropertiesSet();
    }

    private Validator testValidator(final String invalidValue) {
        return new Validator() {

            @Override
            public boolean supports(Clreplaced<?> clazz) {
                return String.clreplaced.isreplacedignableFrom(clazz);
            }

            @Override
            public void validate(Object target, Errors errors) {
                String value = (String) target;
                if (invalidValue.equals(value)) {
                    errors.reject("not a valid value");
                }
            }
        };
    }

    private Method getTestMethod() {
        return ReflectionUtils.findMethod(MethodJmsListenerEndpointTests.clreplaced, name.getMethodName());
    }

    static clreplaced JmsEndpointSampleBean {

        private final Map<String, Boolean> invocations = new HashMap<String, Boolean>();

        public void resolveMessageAndSession(javax.jms.Message message, Session session) {
            invocations.put("resolveMessageAndSession", true);
            replacedertNotNull("Message not injected", message);
            replacedertNotNull("Session not injected", session);
        }

        public void resolveGenericMessage(Message<String> message) {
            invocations.put("resolveGenericMessage", true);
            replacedertNotNull("Generic message not injected", message);
            replacedertEquals("Wrong message payload", "test", message.getPayload());
        }

        public void resolveHeaderAndPayload(@Payload String content, @Header int myCounter) {
            invocations.put("resolveHeaderAndPayload", true);
            replacedertEquals("Wrong @Payload resolution", "my payload", content);
            replacedertEquals("Wrong @Header resolution", 55, myCounter);
        }

        public void resolveCustomHeaderNameAndPayload(@Payload String content, @Header("myCounter") int counter) {
            invocations.put("resolveCustomHeaderNameAndPayload", true);
            replacedertEquals("Wrong @Payload resolution", "my payload", content);
            replacedertEquals("Wrong @Header resolution", 24, counter);
        }

        public void resolveCustomHeaderNameAndPayloadWithHeaderNameSet(@Payload String content, @Header(name = "myCounter") int counter) {
            invocations.put("resolveCustomHeaderNameAndPayloadWithHeaderNameSet", true);
            replacedertEquals("Wrong @Payload resolution", "my payload", content);
            replacedertEquals("Wrong @Header resolution", 24, counter);
        }

        public void resolveHeaders(String content, @Headers Map<String, Object> headers) {
            invocations.put("resolveHeaders", true);
            replacedertEquals("Wrong payload resolution", "my payload", content);
            replacedertNotNull("headers not injected", headers);
            replacedertEquals("Missing JMS message id header", "abcd-1234", headers.get(JmsHeaders.MESSAGE_ID));
            replacedertEquals("Missing custom header", 1234, headers.get("customInt"));
        }

        public void resolveMessageHeaders(MessageHeaders headers) {
            invocations.put("resolveMessageHeaders", true);
            replacedertNotNull("MessageHeaders not injected", headers);
            replacedertEquals("Missing JMS message type header", "myMessageType", headers.get(JmsHeaders.TYPE));
            replacedertEquals("Missing custom header", 4567L, (long) headers.get("customLong"), 0.0);
        }

        public void resolveJmsMessageHeaderAccessor(JmsMessageHeaderAccessor headers) {
            invocations.put("resolveJmsMessageHeaderAccessor", true);
            replacedertNotNull("MessageHeaders not injected", headers);
            replacedertEquals("Missing JMS message priority header", Integer.valueOf(9), headers.getPriority());
            replacedertEquals("Missing custom header", true, headers.getHeader("customBoolean"));
        }

        public void resolveObjectPayload(MyBean bean) {
            invocations.put("resolveObjectPayload", true);
            replacedertNotNull("Object payload not injected", bean);
            replacedertEquals("Wrong content for payload", "myBean name", bean.name);
        }

        public void resolveConvertedPayload(Integer counter) {
            invocations.put("resolveConvertedPayload", true);
            replacedertNotNull("Payload not injected", counter);
            replacedertEquals("Wrong content for payload", Integer.valueOf(33), counter);
        }

        public String processAndReply(@Payload String content) {
            invocations.put("processAndReply", true);
            return content;
        }

        @SendTo("replyDestination")
        public String processAndReplyWithSendTo(String content) {
            invocations.put("processAndReplyWithSendTo", true);
            return content;
        }

        @SendTo("")
        public String emptySendTo(String content) {
            invocations.put("emptySendTo", true);
            return content;
        }

        @SendTo({ "firstDestination", "secondDestination" })
        public String invalidSendTo(String content) {
            invocations.put("invalidSendTo", true);
            return content;
        }

        public void validatePayload(@Validated String payload) {
            invocations.put("validatePayload", true);
        }

        public void invalidPayloadType(@Payload Integer payload) {
            throw new IllegalStateException("Should never be called.");
        }

        public void invalidMessagePayloadType(Message<Integer> message) {
            throw new IllegalStateException("Should never be called.");
        }
    }

    @SuppressWarnings("serial")
    static clreplaced MyBean implements Serializable {

        private String name;
    }
}

@Override
protected void initializeContainer(DefaultMessageListenerContainer container) {
    if (this.taskExecutor != null) {
        container.setTaskExecutor(this.taskExecutor);
    }
    if (this.transactionManager != null) {
        container.setTransactionManager(this.transactionManager);
    }
    if (this.cacheLevel != null) {
        container.setCacheLevel(this.cacheLevel);
    } else if (this.cacheLevelName != null) {
        container.setCacheLevelName(this.cacheLevelName);
    }
    if (this.concurrency != null) {
        container.setConcurrency(this.concurrency);
    }
    if (this.maxMessagesPerTask != null) {
        container.setMaxMessagesPerTask(this.maxMessagesPerTask);
    }
    if (this.receiveTimeout != null) {
        container.setReceiveTimeout(this.receiveTimeout);
    }
    if (this.backOff != null) {
        container.setBackOff(this.backOff);
        if (this.recoveryInterval != null) {
            logger.warn("Ignoring recovery interval in DefaultJmsListenerContainerFactory in favor of BackOff");
        }
    } else if (this.recoveryInterval != null) {
        container.setRecoveryInterval(this.recoveryInterval);
    }
}

public void afterPropertiesSet() {
    if (this.consumerConfig.getBrokerUrlList() != null && !this.consumerConfig.getBrokerUrlList().isEmpty() && !Strings.isNullOrEmpty(this.consumerConfig.getQueueName())) {
        for (String brokerUrl : this.consumerConfig.getBrokerUrlList()) {
            // ConnectionFactory connectionFactory = ConnectionFactoryContainer.getSingleConsumerConnectionFactory(brokerUrl);
            ConnectionFactory connectionFactory = ConnectionFactoryContainer.getConsumerConnectionFactory(brokerUrl);
            if (this.listenerContainerMap.containsKey(connectionFactory)) {
                continue;
            }
            DefaultMessageListenerContainer defaultMessageListenerContainer = new DefaultMessageListenerContainer();
            defaultMessageListenerContainer.setCacheLevel(this.consumerConfig.getCacheLevel());
            defaultMessageListenerContainer.setConcurrentConsumers(this.consumerConfig.getConcurrentConsumers());
            ActiveMQQueue activeMQQueue = new ActiveMQQueue();
            activeMQQueue.setPhysicalName(this.consumerConfig.getQueueName());
            if (this.consumerConfig.getAcknowledgemode() < 0 || this.consumerConfig.getAcknowledgemode() > 4) {
                this.consumerConfig.setAcknowledgemode(Session.AUTO_ACKNOWLEDGE);
            }
            if (this.consumerConfig.getAcknowledgemode() == Session.SESSION_TRANSACTED) {
                defaultMessageListenerContainer.setSessionTransacted(true);
            }
            defaultMessageListenerContainer.setSessionAcknowledgeMode(this.consumerConfig.getAcknowledgemode());
            defaultMessageListenerContainer.setConnectionFactory(connectionFactory);
            defaultMessageListenerContainer.setDestination(activeMQQueue);
            defaultMessageListenerContainer.setMessageListener(this);
            defaultMessageListenerContainer.initialize();
            defaultMessageListenerContainer.start();
            this.listenerContainerMap.put(connectionFactory, defaultMessageListenerContainer);
        }
    }
}

@Bean
public MessageListenerContainer messageListenerContainer() {
    DefaultMessageListenerContainer messageListenerContainer = new DefaultMessageListenerContainer();
    messageListenerContainer.setSessionTransacted(true);
    messageListenerContainer.setTransactionManager(transactionManager());
    messageListenerContainer.setConnectionFactory(connectionFactory());
    messageListenerContainer.setDestinationName("flowable-history-jobs");
    messageListenerContainer.setMessageListener(jmsListener());
    messageListenerContainer.setConcurrentConsumers(10);
    messageListenerContainer.start();
    return messageListenerContainer;
}

@Bean
public MessageListenerContainer messageListenerContainer() {
    DefaultMessageListenerContainer messageListenerContainer = new DefaultMessageListenerContainer();
    messageListenerContainer.setConnectionFactory(connectionFactory());
    messageListenerContainer.setDestinationName("flowable-history-jobs");
    messageListenerContainer.setMessageListener(historyJobsMessageListener());
    messageListenerContainer.setConcurrentConsumers(10);
    messageListenerContainer.start();
    return messageListenerContainer;
}

@Bean
public MessageListenerContainer messageListenerContainer(ConnectionFactory connectionFactory, JobMessageListener jobMessageListener) {
    DefaultMessageListenerContainer messageListenerContainer = new DefaultMessageListenerContainer();
    messageListenerContainer.setConnectionFactory(connectionFactory);
    messageListenerContainer.setDestinationName("flowable-jobs");
    messageListenerContainer.setMessageListener(jobMessageListener);
    messageListenerContainer.setConcurrentConsumers(2);
    messageListenerContainer.start();
    return messageListenerContainer;
}

@Bean
public MessageListenerContainer messageListenerContainer() {
    DefaultMessageListenerContainer messageListenerContainer = new DefaultMessageListenerContainer();
    messageListenerContainer.setConnectionFactory(connectionFactory());
    messageListenerContainer.setDestinationName("activiti-jobs");
    messageListenerContainer.setMessageListener(jobMessageListener());
    messageListenerContainer.setConcurrentConsumers(2);
    messageListenerContainer.start();
    return messageListenerContainer;
}

@RunWith(SpringRunner.clreplaced)
@SpringBootTest
@DirtiesContext
public clreplaced SpringJmsApplicationTest {

    @ClreplacedRule
    public static EmbeddedActiveMQBroker broker = new EmbeddedActiveMQBroker();

    @Autowired
    private Sender sender;

    @Autowired
    private DefaultMessageListenerContainer dmlc;

    @Autowired
    private SimpleMessageListenerContainer smlc;

    @Test
    public void testReceive() throws Exception {
        sender.send("order-002");
        StatusMessageListener status1MessageListener = (StatusMessageListener) dmlc.getMessageListener();
        status1MessageListener.getLatch().await(10000, TimeUnit.MILLISECONDS);
        replacedertThat(status1MessageListener.getLatch().getCount()).isEqualTo(0);
        StatusMessageListener status2MessageListener = (StatusMessageListener) smlc.getMessageListener();
        status2MessageListener.getLatch().await(10000, TimeUnit.MILLISECONDS);
        replacedertThat(status2MessageListener.getLatch().getCount()).isEqualTo(0);
    }
}

See More Examples