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 <tabish...@gmail.com>
Authored: Fri Sep 16 14:50:38 2016 -0400
Committer: Timothy Bish <tabish...@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-unsubscr...@qpid.apache.org
For additional commands, e-mail: commits-h...@qpid.apache.org

Reply via email to