You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by ta...@apache.org on 2016/09/16 21:08:17 UTC
qpid-jms git commit: QPIDJMS-207 Test the JMSContext implementation
Repository: qpid-jms
Updated Branches:
refs/heads/master 8e02cfa6d -> 790198118
QPIDJMS-207 Test the JMSContext implementation
Adds path coverage of the JMSContext implementation and fixes an issue with preserving the exception thrown from the session on close of the context if the connection also throws.
Project: http://git-wip-us.apache.org/repos/asf/qpid-jms/repo
Commit: http://git-wip-us.apache.org/repos/asf/qpid-jms/commit/79019811
Tree: http://git-wip-us.apache.org/repos/asf/qpid-jms/tree/79019811
Diff: http://git-wip-us.apache.org/repos/asf/qpid-jms/diff/79019811
Branch: refs/heads/master
Commit: 790198118c68ce0c3049e979e3cd2f5bc35c5383
Parents: 8e02cfa
Author: Timothy Bish <ta...@gmail.com>
Authored: Fri Sep 16 14:50:38 2016 -0400
Committer: Timothy Bish <ta...@gmail.com>
Committed: Fri Sep 16 17:07:44 2016 -0400
----------------------------------------------------------------------
.../java/org/apache/qpid/jms/JmsContext.java | 4 +-
.../org/apache/qpid/jms/JmsContextTest.java | 1693 ++++++++++++++++++
2 files changed, 1696 insertions(+), 1 deletion(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/qpid-jms/blob/79019811/qpid-jms-client/src/main/java/org/apache/qpid/jms/JmsContext.java
----------------------------------------------------------------------
diff --git a/qpid-jms-client/src/main/java/org/apache/qpid/jms/JmsContext.java b/qpid-jms-client/src/main/java/org/apache/qpid/jms/JmsContext.java
index 008da24..2efe8e0 100644
--- a/qpid-jms-client/src/main/java/org/apache/qpid/jms/JmsContext.java
+++ b/qpid-jms-client/src/main/java/org/apache/qpid/jms/JmsContext.java
@@ -99,7 +99,9 @@ public class JmsContext implements JMSContext, AutoCloseable {
try {
connection.close();
} catch (JMSException jmse) {
- failure = JmsExceptionSupport.createRuntimeException(jmse);
+ if (failure == null) {
+ failure = JmsExceptionSupport.createRuntimeException(jmse);
+ }
}
}
}
http://git-wip-us.apache.org/repos/asf/qpid-jms/blob/79019811/qpid-jms-client/src/test/java/org/apache/qpid/jms/JmsContextTest.java
----------------------------------------------------------------------
diff --git a/qpid-jms-client/src/test/java/org/apache/qpid/jms/JmsContextTest.java b/qpid-jms-client/src/test/java/org/apache/qpid/jms/JmsContextTest.java
new file mode 100644
index 0000000..aa8b90e
--- /dev/null
+++ b/qpid-jms-client/src/test/java/org/apache/qpid/jms/JmsContextTest.java
@@ -0,0 +1,1693 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.qpid.jms;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.Serializable;
+import java.util.UUID;
+
+import javax.jms.BytesMessage;
+import javax.jms.Destination;
+import javax.jms.ExceptionListener;
+import javax.jms.IllegalStateException;
+import javax.jms.IllegalStateRuntimeException;
+import javax.jms.JMSContext;
+import javax.jms.JMSException;
+import javax.jms.JMSSecurityException;
+import javax.jms.MapMessage;
+import javax.jms.Message;
+import javax.jms.ObjectMessage;
+import javax.jms.Queue;
+import javax.jms.StreamMessage;
+import javax.jms.TextMessage;
+import javax.jms.Topic;
+
+import org.apache.qpid.jms.provider.ProviderConstants.ACK_TYPE;
+import org.apache.qpid.jms.provider.mock.MockRemotePeer;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Matchers;
+import org.mockito.Mockito;
+
+/**
+ * Test various aspects of the JmsContext class.
+ */
+public class JmsContextTest extends JmsConnectionTestSupport {
+
+ private final MockRemotePeer remotePeer = new MockRemotePeer();
+
+ private JmsContext context;
+
+ @Override
+ @Before
+ public void setUp() throws Exception {
+ super.setUp();
+ remotePeer.start();
+ context = createJMSContextToMockProvider();
+ }
+
+ //----- Test basic interface behaviors -----------------------------------//
+
+ @Test
+ public void testCreateContextWithNewAcknowledgementMode() {
+ JMSContext newContext = context.createContext(JMSContext.CLIENT_ACKNOWLEDGE);
+ assertNotNull(newContext);
+ assertEquals(JMSContext.CLIENT_ACKNOWLEDGE, newContext.getSessionMode());
+ }
+
+ @Test
+ public void testGetMeataData() {
+ assertNotNull(context.getMetaData());
+ }
+
+ @Test
+ public void testGetTransactedFromContext() {
+ assertFalse(context.getTransacted());
+ JMSContext newContext = context.createContext(JMSContext.SESSION_TRANSACTED);
+ assertNotNull(newContext);
+ assertEquals(JMSContext.SESSION_TRANSACTED, newContext.getSessionMode());
+ assertTrue(newContext.getTransacted());
+ }
+
+ @Test
+ public void testCreateContextFromClosedContextThrowsISRE() {
+ context.close();
+ try {
+ context.createContext(JMSContext.CLIENT_ACKNOWLEDGE);
+ fail("Should throw state exception");
+ } catch (IllegalStateRuntimeException isre) {
+ }
+ }
+
+ @Test
+ public void testCreateTextMessage() throws JMSException {
+ TextMessage message = context.createTextMessage();
+ assertNotNull(message);
+ assertNull(message.getText());
+ }
+
+ @Test
+ public void testCreateTextMessageWithBody() throws JMSException {
+ TextMessage message = context.createTextMessage("test");
+ assertNotNull(message);
+ assertEquals("test", message.getText());
+ }
+
+ @Test
+ public void testCreateBytesMessage() throws JMSException {
+ BytesMessage message = context.createBytesMessage();
+ assertNotNull(message);
+ }
+
+ @Test
+ public void testCreateMapMessage() throws JMSException {
+ MapMessage message = context.createMapMessage();
+ assertNotNull(message);
+ }
+
+ @Test
+ public void testCreateMessage() throws JMSException {
+ Message message = context.createMessage();
+ assertNotNull(message);
+ }
+
+ @Test
+ public void testCreateStreamMessage() throws JMSException {
+ StreamMessage message = context.createStreamMessage();
+ assertNotNull(message);
+ }
+
+ @Test
+ public void testCreateObjectMessage() throws JMSException {
+ ObjectMessage message = context.createObjectMessage();
+ assertNotNull(message);
+ }
+
+ @Test
+ public void testCreateObjectMessageWithBody() throws JMSException {
+ UUID payload = UUID.randomUUID();
+ ObjectMessage message = context.createObjectMessage(payload);
+ assertNotNull(message);
+ assertEquals(payload, message.getObject());
+ }
+
+ @Test
+ public void testInternalSessionLazyCreate() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ // No session until needed.
+ Mockito.verify(connection, Mockito.times(0)).createSession(Matchers.anyInt());
+ assertNotNull(context.createTemporaryQueue());
+ Mockito.verify(connection, Mockito.times(1)).createSession(Matchers.anyInt());
+
+ context.close();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionMessageConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createConsumer(Matchers.any(Destination.class))).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createConsumer(context.createTemporaryQueue());
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createConsumer(Matchers.any(Destination.class));
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionMessageConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createConsumer(Matchers.any(Destination.class))).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createConsumer(context.createTemporaryQueue());
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createConsumer(Matchers.any(Destination.class));
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionMessageConsumerSelector() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createConsumer(Matchers.any(Destination.class), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createConsumer(context.createTemporaryTopic(), "a = b");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionMessageConsumerSelector() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createConsumer(Matchers.any(Destination.class), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createConsumer(context.createTemporaryTopic(), "a = b");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionMessageConsumerSelectorNoLocal() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createConsumer(Matchers.any(Destination.class), Matchers.anyString(), Matchers.anyBoolean())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createConsumer(context.createTemporaryTopic(), "a = b", true);
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyBoolean());
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionMessageConsumerSelectorNoLocal() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createConsumer(Matchers.any(Destination.class), Matchers.anyString(), Matchers.anyBoolean())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createConsumer(context.createTemporaryTopic(), "a = b", true);
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyBoolean());
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionDurableMessageConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createDurableConsumer(context.createTemporaryTopic(), "name");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionDurableMessageConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createDurableConsumer(context.createTemporaryTopic(), "name");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionDurableMessageConsumerSelectorNoLocal() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString(), Matchers.anyBoolean())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createDurableConsumer(context.createTemporaryTopic(), "name", "a = b", true);
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString(), Matchers.anyBoolean());
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionDurableMessageConsumerSelectorNoLocal() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString(), Matchers.anyBoolean())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createDurableConsumer(context.createTemporaryTopic(), "name", "a = b", true);
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString(), Matchers.anyBoolean());
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionSharedMessageConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createSharedConsumer(context.createTemporaryTopic(), "name");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionSharedMessageConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createSharedConsumer(context.createTemporaryTopic(), "name");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionMessageSharedConsumerSelector() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createSharedConsumer(context.createTemporaryTopic(), "name", "a = b");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionSharedMessageConsumerSelector() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createSharedConsumer(context.createTemporaryTopic(), "name", "a = b");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionSharedDurableMessageConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createSharedDurableConsumer(context.createTemporaryTopic(), "name");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionSharedDurableMessageConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createSharedDurableConsumer(context.createTemporaryTopic(), "name");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionMessageSharedDurableConsumerSelector() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createSharedDurableConsumer(context.createTemporaryTopic(), "name", "a = b");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionSharedDurableMessageConsumerSelector() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsMessageConsumer consumer = Mockito.mock(JmsMessageConsumer.class);
+
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString())).thenReturn(consumer);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createSharedDurableConsumer(context.createTemporaryTopic(), "name", "a = b");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionQueueBrowser() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsQueueBrowser browser = Mockito.mock(JmsQueueBrowser.class);
+
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createBrowser(Matchers.any(Queue.class))).thenReturn(browser);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createBrowser(context.createTemporaryQueue());
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createBrowser(Matchers.any(Queue.class));
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionQueueBrowser() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsQueueBrowser browser = Mockito.mock(JmsQueueBrowser.class);
+
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createBrowser(Matchers.any(Queue.class))).thenReturn(browser);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createBrowser(context.createTemporaryQueue());
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createBrowser(Matchers.any(Queue.class));
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAutoStartOnDoesStartTheConnectionQueueBrowserWithSelector() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsQueueBrowser browser = Mockito.mock(JmsQueueBrowser.class);
+
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createBrowser(Matchers.any(Queue.class))).thenReturn(browser);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(true);
+
+ try {
+ context.createBrowser(context.createTemporaryQueue(), "a == b");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createBrowser(Matchers.any(Queue.class), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(1)).start();
+ }
+
+ @Test
+ public void testAutoStartOffDoesNotStartTheConnectionQueueBrowserWithSelector() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ JmsQueueBrowser browser = Mockito.mock(JmsQueueBrowser.class);
+
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ Mockito.when(session.createBrowser(Matchers.any(Queue.class))).thenReturn(browser);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+ context.setAutoStart(false);
+
+ try {
+ context.createBrowser(context.createTemporaryQueue(), "a == b");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createBrowser(Matchers.any(Queue.class), Matchers.anyString());
+ Mockito.verify(connection, Mockito.times(0)).start();
+ }
+
+ @Test
+ public void testAcknowledgeNoopAutoAcknowledge() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ try {
+ context.acknowledge();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(0)).acknowledge(ACK_TYPE.ACCEPTED);
+ }
+
+ @Test
+ public void testAcknowledgeNoopDupsOkAcknowledge() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.DUPS_OK_ACKNOWLEDGE);
+
+ try {
+ context.acknowledge();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(0)).acknowledge(ACK_TYPE.ACCEPTED);
+ }
+
+ @Test
+ public void testAcknowledgeNoopSessionTransacted() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.SESSION_TRANSACTED);
+
+ try {
+ context.acknowledge();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(0)).acknowledge(ACK_TYPE.ACCEPTED);
+ }
+
+ @Test
+ public void testAcknowledgeAcceptsMessages() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ try {
+ context.acknowledge();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).acknowledge(ACK_TYPE.ACCEPTED);
+ }
+
+ //----- Test that calls pass through to the underlying connection --------//
+
+ @Test
+ public void testStopPassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.SESSION_TRANSACTED);
+
+ try {
+ context.stop();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(connection, Mockito.times(1)).stop();
+ }
+
+ @Test
+ public void testCommitPassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.SESSION_TRANSACTED);
+
+ try {
+ context.commit();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).commit();
+ }
+
+ @Test
+ public void testRollbackPassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.SESSION_TRANSACTED);
+
+ try {
+ context.rollback();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).rollback();
+ }
+
+ @Test
+ public void testRecoverPassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ try {
+ context.recover();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).recover();
+ }
+
+ @Test
+ public void testUnsubscribePassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ try {
+ context.unsubscribe("subscription");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).unsubscribe(Matchers.anyString());
+ }
+
+ @Test
+ public void testCreateTopicPassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ try {
+ context.createTopic("test");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createTopic(Matchers.anyString());
+ }
+
+ @Test
+ public void testCreateQueuePassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ try {
+ context.createQueue("test");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createQueue(Matchers.anyString());
+ }
+
+ @Test
+ public void testCreateTemporaryQueuePassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ try {
+ context.createTemporaryQueue();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createTemporaryQueue();
+ }
+
+ @Test
+ public void testCreateTemporaryTopicPassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ try {
+ context.createTemporaryTopic();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createTemporaryTopic();
+ }
+
+ @Test
+ public void testGetClientIDPassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ try {
+ context.getClientID();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(connection, Mockito.times(1)).getClientID();
+ }
+
+ @Test
+ public void testSetClientIDPassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ try {
+ context.setClientID("test");
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(connection, Mockito.times(1)).setClientID("test");
+ }
+
+ @Test
+ public void testGetExceptionListenerPassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ try {
+ context.getExceptionListener();
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(connection, Mockito.times(1)).getExceptionListener();
+ }
+
+ @Test
+ public void testSetExceptionListenerPassthrough() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ ExceptionListener listener = new ExceptionListener() {
+
+ @Override
+ public void onException(JMSException exception) {
+ }
+ };
+
+ try {
+ context.setExceptionListener(listener);
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(connection, Mockito.times(1)).setExceptionListener(listener);
+ }
+
+ //----- Test JMSException handling ---------------------------------------//
+
+ @Test
+ public void testRuntimeExceptionOnConnectionClose() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(connection).close();
+
+ try {
+ context.close();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ }
+ }
+
+ @Test
+ public void testContextClosePreservesSessionCloseException() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).close();
+ Mockito.doThrow(JMSSecurityException.class).when(connection).close();
+
+ context.createTemporaryTopic();
+ Mockito.verify(connection, Mockito.times(1)).createSession(JMSContext.AUTO_ACKNOWLEDGE);
+
+ try {
+ context.close();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateProducer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createProducer(null);
+
+ try {
+ context.createProducer();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createConsumer(Matchers.any(Destination.class));
+
+ try {
+ context.createConsumer(context.createTemporaryQueue());
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createConsumer(Matchers.any(Destination.class));
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateConsumerWithSelector() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createConsumer(Matchers.any(Destination.class), Matchers.anyString());
+
+ try {
+ context.createConsumer(context.createTemporaryQueue(), "a = b");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createConsumer(Matchers.any(Destination.class), Matchers.anyString());
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateConsumerWithSelectorNoLocal() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createConsumer(Matchers.any(Destination.class), Matchers.anyString(), Matchers.anyBoolean());
+
+ try {
+ context.createConsumer(context.createTemporaryQueue(), "a = b", true);
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createConsumer(Matchers.any(Destination.class), Matchers.anyString(), Matchers.anyBoolean());
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateDurableConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString());
+
+ try {
+ context.createDurableConsumer(context.createTemporaryTopic(), "name");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateDurableConsumerSelectorNoLocal() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).
+ createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString(), Matchers.anyBoolean());
+
+ try {
+ context.createDurableConsumer(context.createTemporaryTopic(), "name", "a = b", true);
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString(), Matchers.anyBoolean());
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateSharedConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString());
+
+ try {
+ context.createSharedConsumer(context.createTemporaryTopic(), "name");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateSharedConsumerSelectorNoLocal() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).
+ createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString());
+
+ try {
+ context.createSharedConsumer(context.createTemporaryTopic(), "name", "a = b");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString());
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateSharedDurableConsumer() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString());
+
+ try {
+ context.createSharedDurableConsumer(context.createTemporaryTopic(), "name");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString());
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateSharedDurableConsumerSelectorNoLocal() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryTopic()).thenReturn(new JmsTemporaryTopic());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).
+ createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString());
+
+ try {
+ context.createSharedDurableConsumer(context.createTemporaryTopic(), "name", "a = b");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createSharedDurableConsumer(Matchers.any(Topic.class), Matchers.anyString(), Matchers.anyString());
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateQueueBrowser() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createBrowser(Matchers.any(Queue.class));
+
+ try {
+ context.createBrowser(context.createTemporaryQueue());
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createBrowser(Matchers.any(Queue.class));
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateQueueBrowserWithSelector() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createTemporaryQueue()).thenReturn(new JmsTemporaryQueue());
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createBrowser(Matchers.any(Queue.class), Matchers.anyString());
+
+ try {
+ context.createBrowser(context.createTemporaryQueue(), "a == b");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+
+ Mockito.verify(session, Mockito.times(1)).createBrowser(Matchers.any(Queue.class), Matchers.anyString());
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateSession() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(connection).createSession(Matchers.anyInt());
+
+ try {
+ context.createTemporaryQueue();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnStartFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(connection).start();
+
+ try {
+ context.start();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnStopFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ Mockito.doThrow(IllegalStateException.class).when(connection).stop();
+ JmsContext context = new JmsContext(connection, JMSContext.AUTO_ACKNOWLEDGE);
+
+ try {
+ context.stop();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCommitFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.SESSION_TRANSACTED);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).commit();
+
+ try {
+ context.commit();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnRollbackFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.SESSION_TRANSACTED);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).rollback();
+
+ try {
+ context.rollback();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnRecoverFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).recover();
+
+ try {
+ context.recover();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnAcknowledgeFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).acknowledge(ACK_TYPE.ACCEPTED);
+
+ try {
+ context.acknowledge();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnUnsubscribeFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).unsubscribe(Matchers.anyString());
+
+ try {
+ context.unsubscribe("subscription");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateTopicFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createTopic(Matchers.anyString());
+
+ try {
+ context.createTopic("test");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateQueueFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createQueue(Matchers.anyString());
+
+ try {
+ context.createQueue("test");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateTemporaryTopicFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createTemporaryTopic();
+
+ try {
+ context.createTemporaryTopic();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateTemporaryQueueFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createTemporaryQueue();
+
+ try {
+ context.createTemporaryQueue();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnGetClientIDFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(connection).getClientID();
+
+ try {
+ context.getClientID();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnSetClientIDFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(connection).setClientID(Matchers.anyString());
+
+ try {
+ context.setClientID("client");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnGetExceptionListenerFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(connection).getExceptionListener();
+
+ try {
+ context.getExceptionListener();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnSetExceptionListenerFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(connection).setExceptionListener(Matchers.any(ExceptionListener.class));
+
+ try {
+ context.setExceptionListener(null);
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnGetMetaDataFailure() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(connection).getMetaData();
+
+ try {
+ context.getMetaData();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateMessage() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createMessage();
+
+ try {
+ context.createMessage();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateTextMessage() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createTextMessage();
+
+ try {
+ context.createTextMessage();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateTextMessageWithBody() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createTextMessage(Matchers.anyString());
+
+ try {
+ context.createTextMessage("test");
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateBytesMessage() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createBytesMessage();
+
+ try {
+ context.createBytesMessage();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateStreamMessage() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createStreamMessage();
+
+ try {
+ context.createStreamMessage();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateMapMessage() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createMapMessage();
+
+ try {
+ context.createMapMessage();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateObjectMessage() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createObjectMessage();
+
+ try {
+ context.createObjectMessage();
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+
+ @Test
+ public void testRuntimeExceptionOnCreateObjectMessageWithBody() throws JMSException {
+ JmsConnection connection = Mockito.mock(JmsConnection.class);
+ JmsSession session = Mockito.mock(JmsSession.class);
+ Mockito.when(connection.createSession(Mockito.anyInt())).thenReturn(session);
+ JmsContext context = new JmsContext(connection, JMSContext.CLIENT_ACKNOWLEDGE);
+
+ Mockito.doThrow(IllegalStateException.class).when(session).createObjectMessage(Matchers.any(Serializable.class));
+
+ try {
+ context.createObjectMessage(UUID.randomUUID());
+ fail("Should throw ISRE");
+ } catch (IllegalStateRuntimeException isre) {
+ } finally {
+ context.close();
+ }
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org