Creating a branch for experimenting with some ideas for JMS client.rajith_jms_client

git-svn-id: https://svn.apache.org/repos/asf/qpid/branches/rajith_jms_client@1128369 13f79535-47bb-0310-9956-ffa450edef68

9 files changed, 2921 insertions, 0 deletions

diff --git a/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/BrokerDetails/BrokerDetailsTest.java b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/BrokerDetails/BrokerDetailsTest.java
new file mode 100644
index 0000000000..1b27ff6300
--- /dev/null
+++ b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/BrokerDetails/BrokerDetailsTest.java
@@ -0,0 +1,99 @@
+/*
+ *  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.test.unit.client.BrokerDetails;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import junit.framework.TestCase;
+
+import org.apache.qpid.client.AMQBrokerDetails;
+import org.apache.qpid.client.AMQConnectionURL;
+import org.apache.qpid.jms.ConnectionURL;
+import org.apache.qpid.jms.BrokerDetails;
+import org.apache.qpid.url.URLSyntaxException;
+
+public class BrokerDetailsTest extends TestCase
+{
+    public void testMultiParameters() throws URLSyntaxException
+    {
+        String url = "tcp://localhost:5672?timeout='200',immediatedelivery='true'";
+
+        AMQBrokerDetails broker = new AMQBrokerDetails(url);
+
+        assertTrue(broker.getProperty("timeout").equals("200"));
+        assertTrue(broker.getProperty("immediatedelivery").equals("true"));
+    }
+
+    public void testVMBroker() throws URLSyntaxException
+    {
+        String url = "vm://:2";
+
+        AMQBrokerDetails broker = new AMQBrokerDetails(url);
+        assertTrue(broker.getTransport().equals("vm"));
+        assertEquals(broker.getPort(), 2);
+    }
+
+    public void testTransportsDefaultToTCP() throws URLSyntaxException
+    {
+        String url = "localhost:5672";
+
+        AMQBrokerDetails broker = new AMQBrokerDetails(url);
+        assertTrue(broker.getTransport().equals("tcp"));
+    }
+
+    public void testCheckDefaultPort() throws URLSyntaxException
+    {
+        String url = "tcp://localhost";
+
+        AMQBrokerDetails broker = new AMQBrokerDetails(url);
+        assertTrue(broker.getPort() == AMQBrokerDetails.DEFAULT_PORT);
+    }
+
+    public void testBothDefaults() throws URLSyntaxException
+    {
+        String url = "localhost";
+
+        AMQBrokerDetails broker = new AMQBrokerDetails(url);
+
+        assertTrue(broker.getTransport().equals("tcp"));
+        assertTrue(broker.getPort() == AMQBrokerDetails.DEFAULT_PORT);
+    }
+
+    public void testWrongOptionSeparatorInBroker()
+    {
+        String url = "tcp://localhost:5672+option='value'";
+        try
+        {
+            new AMQBrokerDetails(url);
+        }
+        catch (URLSyntaxException urise)
+        {
+            assertTrue(urise.getReason().equals("Illegal character in port number"));
+        }
+
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(BrokerDetailsTest.class);
+    }
+}
diff --git a/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/channelclose/ChannelCloseMethodHandlerNoCloseOk.java b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/channelclose/ChannelCloseMethodHandlerNoCloseOk.java
new file mode 100644
index 0000000000..66f220643c
--- /dev/null
+++ b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/channelclose/ChannelCloseMethodHandlerNoCloseOk.java
@@ -0,0 +1,97 @@
+/*
+ *  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.test.unit.client.channelclose;
+
+import org.apache.qpid.AMQChannelClosedException;
+import org.apache.qpid.AMQException;
+import org.apache.qpid.AMQInvalidArgumentException;
+import org.apache.qpid.AMQInvalidRoutingKeyException;
+import org.apache.qpid.client.AMQNoConsumersException;
+import org.apache.qpid.client.AMQNoRouteException;
+import org.apache.qpid.client.protocol.AMQProtocolSession;
+import org.apache.qpid.client.state.StateAwareMethodListener;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.framing.ChannelCloseBody;
+import org.apache.qpid.protocol.AMQConstant;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ChannelCloseMethodHandlerNoCloseOk implements StateAwareMethodListener<ChannelCloseBody>
+{
+    private static final Logger _logger = LoggerFactory.getLogger(ChannelCloseMethodHandlerNoCloseOk.class);
+
+    private static ChannelCloseMethodHandlerNoCloseOk _handler = new ChannelCloseMethodHandlerNoCloseOk();
+
+    public static ChannelCloseMethodHandlerNoCloseOk getInstance()
+    {
+        return _handler;
+    }
+
+    public void methodReceived(AMQProtocolSession session,  ChannelCloseBody method, int channelId)
+        throws AMQException
+    {
+        _logger.debug("ChannelClose method received");
+
+        AMQConstant errorCode = AMQConstant.getConstant(method.getReplyCode());
+        AMQShortString reason = method.getReplyText();
+        if (_logger.isDebugEnabled())
+        {
+            _logger.debug("Channel close reply code: " + errorCode + ", reason: " + reason);
+        }
+
+        // For this test Method Handler .. don't send Close-OK
+        // // TODO: Be aware of possible changes to parameter order as versions change.
+        // AMQFrame frame = ChannelCloseOkBody.createAMQFrame(evt.getChannelId(), method.getMajor(), method.getMinor());
+        // protocolSession.writeFrame(frame);
+        if (errorCode != AMQConstant.REPLY_SUCCESS)
+        {
+            _logger.error("Channel close received with errorCode " + errorCode + ", and reason " + reason);
+            if (errorCode == AMQConstant.NO_CONSUMERS)
+            {
+                throw new AMQNoConsumersException("Error: " + reason, null, null);
+            }
+            else if (errorCode == AMQConstant.NO_ROUTE)
+            {
+                throw new AMQNoRouteException("Error: " + reason, null, null);
+            }
+            else if (errorCode == AMQConstant.INVALID_ARGUMENT)
+            {
+                _logger.debug("Broker responded with Invalid Argument.");
+
+                throw new AMQInvalidArgumentException(String.valueOf(reason), null);
+            }
+            else if (errorCode == AMQConstant.INVALID_ROUTING_KEY)
+            {
+                _logger.debug("Broker responded with Invalid Routing Key.");
+
+                throw new AMQInvalidRoutingKeyException(String.valueOf(reason), null);
+            }
+            else
+            {
+                throw new AMQChannelClosedException(errorCode, "Error: " + reason, null);
+            }
+
+        }
+
+        session.channelClosed(channelId, errorCode, String.valueOf(reason));
+    }
+}
diff --git a/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/channelclose/NoCloseOKStateManager.java b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/channelclose/NoCloseOKStateManager.java
new file mode 100644
index 0000000000..c7eb745566
--- /dev/null
+++ b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/channelclose/NoCloseOKStateManager.java
@@ -0,0 +1,65 @@
+/*
+ *  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.test.unit.client.channelclose;
+
+import org.apache.qpid.client.state.AMQStateManager;
+import org.apache.qpid.client.state.AMQState;
+import org.apache.qpid.client.handler.ConnectionStartMethodHandler;
+import org.apache.qpid.client.handler.ConnectionCloseMethodHandler;
+import org.apache.qpid.client.handler.ConnectionTuneMethodHandler;
+import org.apache.qpid.client.handler.ConnectionSecureMethodHandler;
+import org.apache.qpid.client.handler.ConnectionOpenOkMethodHandler;
+import org.apache.qpid.client.handler.ChannelCloseOkMethodHandler;
+import org.apache.qpid.client.handler.BasicDeliverMethodHandler;
+import org.apache.qpid.client.handler.BasicReturnMethodHandler;
+import org.apache.qpid.client.handler.BasicCancelOkMethodHandler;
+import org.apache.qpid.client.handler.ChannelFlowOkMethodHandler;
+import org.apache.qpid.client.handler.QueueDeleteOkMethodHandler;
+import org.apache.qpid.client.handler.ExchangeBoundOkMethodHandler;
+import org.apache.qpid.client.protocol.AMQProtocolSession;
+import org.apache.qpid.framing.ConnectionStartBody;
+import org.apache.qpid.framing.ConnectionCloseBody;
+import org.apache.qpid.framing.ConnectionTuneBody;
+import org.apache.qpid.framing.ConnectionSecureBody;
+import org.apache.qpid.framing.ConnectionOpenOkBody;
+import org.apache.qpid.framing.ChannelCloseBody;
+import org.apache.qpid.framing.ChannelCloseOkBody;
+import org.apache.qpid.framing.BasicDeliverBody;
+import org.apache.qpid.framing.BasicReturnBody;
+import org.apache.qpid.framing.BasicCancelOkBody;
+import org.apache.qpid.framing.ChannelFlowOkBody;
+import org.apache.qpid.framing.QueueDeleteOkBody;
+import org.apache.qpid.framing.ExchangeBoundOkBody;
+
+import java.util.Map;
+import java.util.HashMap;
+
+public class NoCloseOKStateManager extends AMQStateManager
+{
+    public NoCloseOKStateManager(AMQProtocolSession protocolSession)
+    {
+        super(protocolSession);
+    }
+
+    
+
+
+}
diff --git a/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/connectionurl/ConnectionURLTest.java b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/connectionurl/ConnectionURLTest.java
new file mode 100644
index 0000000000..2c5fa0112e
--- /dev/null
+++ b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/connectionurl/ConnectionURLTest.java
@@ -0,0 +1,588 @@
+/*
+ *
+ * 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.test.unit.client.connectionurl;
+
+import junit.framework.TestCase;
+
+import org.apache.qpid.client.AMQBrokerDetails;
+import org.apache.qpid.client.AMQConnectionURL;
+import org.apache.qpid.jms.BrokerDetails;
+import org.apache.qpid.jms.ConnectionURL;
+import org.apache.qpid.url.URLSyntaxException;
+
+public class ConnectionURLTest extends TestCase
+{
+
+    public void testFailoverURL() throws URLSyntaxException
+    {
+        String url = "amqp://ritchiem:bob@/test?brokerlist='tcp://localhost:5672;tcp://fancyserver:3000/',failover='roundrobin?cyclecount='100''";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod().equals("roundrobin"));
+        assertEquals("100", connectionurl.getFailoverOption(ConnectionURL.OPTIONS_FAILOVER_CYCLE));        
+        assertTrue(connectionurl.getUsername().equals("ritchiem"));
+        assertTrue(connectionurl.getPassword().equals("bob"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+        assertTrue(connectionurl.getBrokerCount() == 2);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+        assertTrue(service.getHost().equals("localhost"));
+        assertTrue(service.getPort() == 5672);
+
+        service = connectionurl.getBrokerDetails(1);
+
+        assertTrue(service.getTransport().equals("tcp"));
+        assertTrue(service.getHost().equals("fancyserver"));
+        assertTrue(service.getPort() == 3000);
+
+    }
+
+    public void testSingleTransportUsernamePasswordURL() throws URLSyntaxException
+    {
+        String url = "amqp://ritchiem:bob@/test?brokerlist='tcp://localhost:5672'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("ritchiem"));
+        assertTrue(connectionurl.getPassword().equals("bob"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+        assertTrue(service.getHost().equals("localhost"));
+        assertTrue(service.getPort() == 5672);
+    }
+
+    public void testSingleTransportUsernameBlankPasswordURL() throws URLSyntaxException
+    {
+        String url = "amqp://ritchiem:@/test?brokerlist='tcp://localhost:5672'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("ritchiem"));
+        assertTrue(connectionurl.getPassword().equals(""));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+        assertTrue(service.getHost().equals("localhost"));
+        assertTrue(service.getPort() == 5672);
+    }
+
+    public void testFailedURLNullPassword()
+    {
+        String url = "amqp://ritchiem@/test?brokerlist='tcp://localhost:5672'";
+
+        try
+        {
+            new AMQConnectionURL(url);
+            fail("URL has null password");
+        }
+        catch (URLSyntaxException e)
+        {
+            assertTrue(e.getReason().equals("Null password in user information not allowed."));
+            assertTrue(e.getIndex() == 7);
+        }
+    }
+
+
+    public void testSingleTransportURL() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/test?brokerlist='tcp://localhost:5672'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+        assertTrue(service.getHost().equals("localhost"));
+        assertTrue(service.getPort() == 5672);
+    }
+
+    public void testSingleTransportWithClientURLURL() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@clientname/test?brokerlist='tcp://localhost:5672'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+        assertTrue(connectionurl.getClientName().equals("clientname"));
+
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+        assertTrue(service.getHost().equals("localhost"));
+        assertTrue(service.getPort() == 5672);
+    }
+
+    public void testSingleTransport1OptionURL() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/test?brokerlist='tcp://localhost:5672',routingkey='jim'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+
+        assertTrue(service.getHost().equals("localhost"));
+        assertTrue(service.getPort() == 5672);
+        assertTrue(connectionurl.getOption("routingkey").equals("jim"));
+    }
+
+    public void testSingleTransportDefaultedBroker() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/test?brokerlist='localhost'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+
+        assertTrue(service.getHost().equals("localhost"));
+        assertTrue(service.getPort() == 5672);
+    }
+
+    public void testSingleTransportDefaultedBrokerWithPort() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/test?brokerlist='localhost:1234'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+
+        assertTrue(service.getHost().equals("localhost"));
+        assertTrue(service.getPort() == 1234);
+    }
+
+    public void testSingleTransportDefaultedBrokerWithIP() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/test?brokerlist='127.0.0.1'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+
+        assertTrue(service.getHost().equals("127.0.0.1"));
+        assertTrue(service.getPort() == 5672);
+    }
+
+    public void testSingleTransportDefaultedBrokerWithIPandPort() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/test?brokerlist='127.0.0.1:1234'";
+
+//        ConnectionURL connectionurl = new AMQConnectionURL(url);
+//
+//        assertTrue(connectionurl.getFailoverMethod() == null);
+//        assertTrue(connectionurl.getUsername().equals("guest"));
+//        assertTrue(connectionurl.getPassword().equals("guest"));
+//        assertTrue(connectionurl.getVirtualHost().equals("/temp"));
+//
+//
+//        assertTrue(connectionurl.getBrokerCount() == 1);
+//
+//        BrokerDetails service = connectionurl.getBrokerDetails(0);
+//
+//        assertTrue(service.getTransport().equals("tcp"));
+//
+//        assertTrue(service.getHost().equals("127.0.0.1"));
+//        assertTrue(service.getPort() == 1234);
+    }
+
+
+    public void testSingleTransportMultiOptionURL() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/test?brokerlist='tcp://localhost:5672?foo='jim'&bar='bob'&fred='jimmy'',routingkey='jim',timeout='200',immediatedelivery='true'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+
+        assertTrue(service.getHost().equals("localhost"));
+        assertTrue(service.getPort() == 5672);
+
+        assertTrue(connectionurl.getOption("routingkey").equals("jim"));
+        assertTrue(connectionurl.getOption("timeout").equals("200"));
+        assertTrue(connectionurl.getOption("immediatedelivery").equals("true"));
+    }
+
+    public void testSinglevmURL() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/test?brokerlist='vm://:2'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("vm"));
+        assertTrue(service.getHost().equals(""));
+        assertTrue(service.getPort() == 2);
+
+    }
+
+    public void testFailoverVMURL() throws URLSyntaxException
+    {
+        String url = "amqp://ritchiem:bob@/test?brokerlist='vm://:2;vm://:3',failover='roundrobin'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod().equals("roundrobin"));
+        assertTrue(connectionurl.getUsername().equals("ritchiem"));
+        assertTrue(connectionurl.getPassword().equals("bob"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+        assertTrue(connectionurl.getBrokerCount() == 2);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("vm"));
+        assertTrue(service.getHost().equals(""));
+        assertTrue(service.getPort() == 2);
+
+        service = connectionurl.getBrokerDetails(1);
+        assertTrue(service.getTransport().equals("vm"));
+        assertTrue(service.getHost().equals(""));
+        assertTrue(service.getPort() == 3);
+    }
+
+
+    public void testNoVirtualHostURL()
+    {
+        String url = "amqp://user@?brokerlist='tcp://localhost:5672'";
+
+        try
+        {
+            new AMQConnectionURL(url);
+            fail("URL has no virtual host should not parse");
+        }
+        catch (URLSyntaxException e)
+        {
+            // This should occur.
+        }
+    }
+
+    public void testNoClientID() throws URLSyntaxException
+    {
+        String url = "amqp://user:@/test?brokerlist='tcp://localhost:5672'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getUsername().equals("user"));
+        assertTrue(connectionurl.getPassword().equals(""));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+    }
+
+    public void testClientIDWithUnderscore() throws URLSyntaxException
+    {
+        String url = "amqp://user:pass@client_id/test?brokerlist='tcp://localhost:5672'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getUsername().equals("user"));
+        assertTrue(connectionurl.getPassword().equals("pass"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+        assertTrue(connectionurl.getClientName().equals("client_id"));
+        
+        assertTrue(connectionurl.getBrokerCount() == 1);
+    }
+
+    public void testWrongOptionSeparatorInOptions()
+    {
+        String url = "amqp://guest:guest@/test?brokerlist='tcp://localhost:5672;tcp://localhost:5673'+failover='roundrobin'";
+        try
+        {
+            new AMQConnectionURL(url);
+            fail("URL Should not parse");
+        }
+        catch (URLSyntaxException urise)
+        {
+            assertTrue(urise.getReason().equals("Unterminated option. Possible illegal option separator:'+'"));
+        }
+
+    }
+
+
+    public void testNoUserDetailsProvidedWithClientID()
+
+    {
+        String url = "amqp://clientID/test?brokerlist='tcp://localhost:5672;tcp://localhost:5673'";
+        try
+        {
+            new AMQConnectionURL(url);
+            fail("URL Should not parse");
+        }
+        catch (URLSyntaxException urise)
+        {
+            assertTrue(urise.getMessage().startsWith("User information not found on url"));
+        }
+
+    }
+
+    public void testNoUserDetailsProvidedNOClientID()
+
+    {
+        String url = "amqp:///test?brokerlist='tcp://localhost:5672;tcp://localhost:5673'";
+        try
+        {
+            new AMQConnectionURL(url);
+            fail("URL Should not parse");
+        }
+        catch (URLSyntaxException urise)
+        {
+            assertTrue(urise.getMessage().startsWith("User information not found on url"));
+        }
+
+    }
+
+    public void testCheckVirtualhostFormat() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/t.-_+!=:?brokerlist='tcp://localhost:5672'";
+
+        AMQConnectionURL connection = new AMQConnectionURL(url);
+        assertTrue(connection.getVirtualHost().equals("/t.-_+!=:"));
+    }
+
+    public void testCheckDefaultPort() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/test=:?brokerlist='tcp://localhost'";
+
+        AMQConnectionURL connection = new AMQConnectionURL(url);
+
+        BrokerDetails broker = connection.getBrokerDetails(0);
+        assertTrue(broker.getPort() == AMQBrokerDetails.DEFAULT_PORT);
+
+    }
+
+    public void testCheckMissingFinalQuote() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@id/test" + "?brokerlist='tcp://localhost:5672";
+
+        try
+        {
+            new AMQConnectionURL(url);
+        }
+        catch (URLSyntaxException e)
+        {
+            assertEquals(e.getMessage(), "Unterminated option at index 32: brokerlist='tcp://localhost:5672");
+        }
+    }
+
+
+    public void testDefaultExchanges() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@id/test" + "?defaultQueueExchange='test.direct'&defaultTopicExchange='test.topic'&temporaryQueueExchange='tmp.direct'&temporaryTopicExchange='tmp.topic'";
+
+        AMQConnectionURL conn = new AMQConnectionURL(url);
+
+        assertEquals(conn.getDefaultQueueExchangeName(),"test.direct");
+
+        assertEquals(conn.getDefaultTopicExchangeName(),"test.topic");
+
+        assertEquals(conn.getTemporaryQueueExchangeName(),"tmp.direct");
+
+        assertEquals(conn.getTemporaryTopicExchangeName(),"tmp.topic");
+
+    }
+
+    public void testSocketProtocol() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@id/test" + "?brokerlist='socket://VM-Unique-socketID'";
+
+        try
+        {
+            AMQConnectionURL curl = new AMQConnectionURL(url);
+            assertNotNull(curl);
+            assertEquals(1, curl.getBrokerCount());
+            assertNotNull(curl.getBrokerDetails(0));
+            assertEquals(BrokerDetails.SOCKET, curl.getBrokerDetails(0).getTransport());
+            assertEquals("VM-Unique-socketID", curl.getBrokerDetails(0).getHost());
+            assertEquals("URL does not toString as expected",
+                         url.replace(":guest", ":********"), curl.toString());
+        }
+        catch (URLSyntaxException e)
+        {
+            fail(e.getMessage());
+        }
+    }
+
+    public void testSingleTransportMultiOptionOnBrokerURL() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@/test?brokerlist='tcp://localhost:5672?foo='jim'&bar='bob'&fred='jimmy'',routingkey='jim',timeout='200',immediatedelivery='true'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getFailoverMethod() == null);
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+
+        assertTrue(service.getTransport().equals("tcp"));
+
+        
+        assertTrue(service.getHost().equals("localhost"));
+        assertTrue(service.getPort() == 5672);
+        assertEquals("jim",service.getProperty("foo"));
+        assertEquals("bob",service.getProperty("bar"));
+        assertEquals("jimmy",service.getProperty("fred"));
+
+        assertTrue(connectionurl.getOption("routingkey").equals("jim"));
+        assertTrue(connectionurl.getOption("timeout").equals("200"));
+        assertTrue(connectionurl.getOption("immediatedelivery").equals("true"));
+    }
+    
+    /**
+     * Test that options other than failover and brokerlist are returned in the string representation.
+     * <p>
+     * QPID-2697
+     */
+    public void testOptionToString() throws Exception
+    {
+        ConnectionURL url = new AMQConnectionURL("amqp://user:pass@temp/test?maxprefetch='12345'&brokerlist='tcp://localhost:5672'");
+        
+        assertTrue("String representation should contain options and values", url.toString().contains("maxprefetch='12345'"));
+    }
+
+    public void testHostNamesWithUnderScore() throws URLSyntaxException
+    {
+        String url = "amqp://guest:guest@clientid/test?brokerlist='tcp://under_score:6672'";
+
+        ConnectionURL connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+        BrokerDetails service = connectionurl.getBrokerDetails(0);
+        assertTrue(service.getTransport().equals("tcp"));        
+        assertTrue(service.getHost().equals("under_score"));
+        assertTrue(service.getPort() == 6672);
+        
+        url = "amqp://guest:guest@clientid/test?brokerlist='tcp://under_score'";
+
+        connectionurl = new AMQConnectionURL(url);
+
+        assertTrue(connectionurl.getUsername().equals("guest"));
+        assertTrue(connectionurl.getPassword().equals("guest"));
+        assertTrue(connectionurl.getVirtualHost().equals("/test"));
+
+        assertTrue(connectionurl.getBrokerCount() == 1);
+        service = connectionurl.getBrokerDetails(0);
+        assertTrue(service.getTransport().equals("tcp"));        
+        assertTrue(service.getHost().equals("under_score"));
+        assertTrue(service.getPort() == 5672);
+    }
+    
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(ConnectionURLTest.class);
+    }
+}
+
diff --git a/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/destinationurl/DestinationURLTest.java b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/destinationurl/DestinationURLTest.java
new file mode 100644
index 0000000000..7de09cff45
--- /dev/null
+++ b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/destinationurl/DestinationURLTest.java
@@ -0,0 +1,197 @@
+/*
+ *
+ * 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.test.unit.client.destinationurl;
+
+import junit.framework.TestCase;
+
+import org.apache.qpid.exchange.ExchangeDefaults;
+import org.apache.qpid.url.AMQBindingURL;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URISyntaxException;
+
+public class DestinationURLTest extends TestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(DestinationURLTest.class);
+
+    public void testFullURL() throws URISyntaxException
+    {
+
+        String url = "exchange.Class://exchangeName/Destination/Queue";
+
+        AMQBindingURL dest = new AMQBindingURL(url);
+
+        assertTrue(url.equals(dest.toString()));
+
+        assertTrue(dest.getExchangeClass().equals("exchange.Class"));
+        assertTrue(dest.getExchangeName().equals("exchangeName"));
+        assertTrue(dest.getDestinationName().equals("Destination"));
+        assertTrue(dest.getQueueName().equals("Queue"));
+    }
+
+    public void testQueue() throws URISyntaxException
+    {
+
+        String url = "exchangeClass://exchangeName//Queue";
+
+        AMQBindingURL dest = new AMQBindingURL(url);
+
+        assertTrue(url.equals(dest.toString()));
+
+        assertTrue(dest.getExchangeClass().equals("exchangeClass"));
+        assertTrue(dest.getExchangeName().equals("exchangeName"));
+        assertTrue(dest.getDestinationName().equals(""));
+        assertTrue(dest.getQueueName().equals("Queue"));
+    }
+
+    public void testQueueWithOption() throws URISyntaxException
+    {
+
+        String url = "exchangeClass://exchangeName//Queue?option='value'";
+
+        AMQBindingURL dest = new AMQBindingURL(url);
+
+        assertTrue(url.equals(dest.toString()));
+
+        assertTrue(dest.getExchangeClass().equals("exchangeClass"));
+        assertTrue(dest.getExchangeName().equals("exchangeName"));
+        assertTrue(dest.getDestinationName().equals(""));
+        assertTrue(dest.getQueueName().equals("Queue"));
+        assertTrue(dest.getOption("option").equals("value"));
+    }
+
+
+    public void testDestination() throws URISyntaxException
+    {
+
+        String url = "exchangeClass://exchangeName/Destination/";
+
+        AMQBindingURL dest = new AMQBindingURL(url);
+
+        assertTrue(url.equals(dest.toString()));
+
+        assertTrue(dest.getExchangeClass().equals("exchangeClass"));
+        assertTrue(dest.getExchangeName().equals("exchangeName"));
+        assertTrue(dest.getDestinationName().equals("Destination"));
+        assertTrue(dest.getQueueName().equals(""));
+    }
+
+    public void testDestinationWithOption() throws URISyntaxException
+    {
+
+        String url = "exchangeClass://exchangeName/Destination/?option='value'";
+
+        AMQBindingURL dest = new AMQBindingURL(url);
+
+        assertTrue(url.equals(dest.toString()));
+
+        assertTrue(dest.getExchangeClass().equals("exchangeClass"));
+        assertTrue(dest.getExchangeName().equals("exchangeName"));
+        assertTrue(dest.getDestinationName().equals("Destination"));
+        assertTrue(dest.getQueueName().equals(""));
+
+        assertTrue(dest.getOption("option").equals("value"));
+    }
+
+    public void testDestinationWithMultiOption() throws URISyntaxException
+    {
+
+        String url = "exchangeClass://exchangeName/Destination/?option='value',option2='value2'";
+
+        AMQBindingURL dest = new AMQBindingURL(url);
+
+        assertTrue(dest.getExchangeClass().equals("exchangeClass"));
+        assertTrue(dest.getExchangeName().equals("exchangeName"));
+        assertTrue(dest.getDestinationName().equals("Destination"));
+        assertTrue(dest.getQueueName().equals(""));
+
+        assertTrue(dest.getOption("option").equals("value"));
+        assertTrue(dest.getOption("option2").equals("value2"));
+    }
+
+    public void testDestinationWithNoExchangeDefaultsToDirect() throws URISyntaxException
+    {
+
+        String url = "IBMPerfQueue1?durable='true'";
+
+        AMQBindingURL dest = new AMQBindingURL(url);
+
+        assertTrue(dest.getExchangeClass().equals(ExchangeDefaults.DIRECT_EXCHANGE_CLASS));
+        assertTrue(dest.getExchangeName().equals(""));
+        assertTrue(dest.getDestinationName().equals(""));
+        assertTrue(dest.getQueueName().equals("IBMPerfQueue1"));
+
+        assertTrue(dest.getOption("durable").equals("true"));
+    }
+
+    public void testDestinationWithMultiBindingKeys() throws URISyntaxException
+    {
+
+        String url = "exchangeClass://exchangeName/Destination/?bindingkey='key1',bindingkey='key2'";
+
+        AMQBindingURL dest = new AMQBindingURL(url);
+
+        assertTrue(dest.getExchangeClass().equals("exchangeClass"));
+        assertTrue(dest.getExchangeName().equals("exchangeName"));
+        assertTrue(dest.getDestinationName().equals("Destination"));
+        assertTrue(dest.getQueueName().equals(""));
+
+        assertTrue(dest.getBindingKeys().length == 2);
+    }
+
+    // You can only specify only a routing key or binding key, but not both.
+    public void testDestinationIfOnlyRoutingKeyOrBindingKeyIsSpecified() throws URISyntaxException
+    {
+
+        String url = "exchangeClass://exchangeName/Destination/?bindingkey='key1',routingkey='key2'";
+        boolean exceptionThrown = false;
+        try
+        {
+
+            new AMQBindingURL(url);
+        }
+        catch(URISyntaxException e)
+        {
+            exceptionThrown = true;
+            _logger.info("Exception thrown",e);
+        }
+
+        assertTrue("Failed to throw an URISyntaxException when both the bindingkey and routingkey is specified",exceptionThrown);
+    }
+    
+    public void testDestinationWithDurableTopic() throws URISyntaxException
+    {
+
+        String url = "topic://amq.topic//testTopicD?durable='true'&autodelete='true'&clientid='test'&subscription='testQueueD'";
+
+        AMQBindingURL dest = new AMQBindingURL(url);
+
+        assertTrue(dest.getExchangeClass().equals("topic"));
+        assertTrue(dest.getExchangeName().equals("amq.topic"));
+        assertTrue(dest.getQueueName().equals("test:testQueueD"));
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(DestinationURLTest.class);
+    }
+}
diff --git a/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/BytesMessageTest.java b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/BytesMessageTest.java
new file mode 100644
index 0000000000..65013e7e6d
--- /dev/null
+++ b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/BytesMessageTest.java
@@ -0,0 +1,569 @@
+/*
+ *
+ * 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.test.unit.client.message;
+
+import java.util.HashMap;
+
+import javax.jms.MessageEOFException;
+import javax.jms.MessageFormatException;
+import javax.jms.MessageNotReadableException;
+import javax.jms.MessageNotWriteableException;
+
+import junit.framework.TestCase;
+
+import org.apache.qpid.client.message.JMSBytesMessage;
+import org.apache.qpid.client.message.TestMessageHelper;
+
+public class BytesMessageTest extends TestCase
+{
+    /**
+     * Tests that on creation a call to getBodyLength() throws an exception
+     * if null was passed in during creation
+     */
+    public void testNotReadableOnCreationWithNull() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.getBodyLength();
+            fail("expected exception did not occur");
+        }
+        catch (MessageNotReadableException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageNotReadableException, got " + e);
+        }
+    }
+
+    public void testResetMakesReadble() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeInt(10);
+            bm.reset();
+            bm.writeInt(12);
+            fail("expected exception did not occur");
+        }
+        catch (MessageNotWriteableException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageNotWriteableException, got " + e);
+        }
+    }
+
+    public void testClearBodyMakesWritable() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeInt(10);
+        bm.reset();
+        bm.clearBody();
+        bm.writeInt(10);
+    }
+
+    public void testWriteBoolean() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeBoolean(true);
+        bm.writeBoolean(false);
+        bm.reset();
+        boolean val = bm.readBoolean();
+        assertEquals(true, val);
+        val = bm.readBoolean();
+        assertEquals(false, val);
+    }
+
+    public void testWriteInt() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeInt(10);
+        bm.reset();
+        long len = bm.getBodyLength();
+        assertTrue(len == 4);
+        int val = bm.readInt();
+        assertTrue(val == 10);
+    }
+
+    public void testWriteString() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeUTF("Bananas");
+        bm.reset();
+        String res = bm.readUTF();
+        assertEquals("Bananas", res);
+    }
+
+    public void testWriteBytes() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        byte[] bytes = {1,2,3,4};
+        bm.writeBytes(bytes, 1, 2);
+        bm.reset();
+        bytes = new byte[2];
+        bm.readBytes(bytes);
+        assertEquals(2, bytes[0]);
+        assertEquals(3, bytes[1]);
+    }
+
+    public void testWriteObject() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeObject(new Boolean(true));
+        bm.writeObject(new Boolean(false));
+        bm.writeObject(new Byte((byte)2));
+        bm.writeObject(new byte[]{1,2,3,4});
+        bm.writeObject(new Character('g'));
+        bm.writeObject(new Short((short) 29));
+        bm.writeObject(new Integer(101));
+        bm.writeObject(new Long(50003222L));
+        bm.writeObject("Foobar");
+        bm.writeObject(new Float(1.7f));
+        bm.writeObject(new Double(8.7d));
+        bm.reset();
+        assertTrue(bm.readBoolean());
+        assertTrue(!bm.readBoolean());
+        assertEquals((byte)2, bm.readByte());
+        byte[] bytes = new byte[4];
+        bm.readBytes(bytes);
+        assertEquals('g', bm.readChar());
+        assertEquals((short) 29, bm.readShort());
+        assertEquals(101, bm.readInt());
+        assertEquals(50003222L, bm.readLong());
+        assertEquals("Foobar", bm.readUTF());
+        assertEquals(1.7f, bm.readFloat());
+        assertEquals(8.7d, bm.readDouble());
+    }
+
+    public void testWriteObjectRejectsNonPrimitives() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeObject(new HashMap());
+            fail("expected MessageFormatException was not thrown");
+        }
+        catch (MessageFormatException e)
+        {
+            // pass
+        }
+    }
+
+    public void testWriteObjectThrowsNPE() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeObject(null);
+            fail("expected exception did not occur");
+        }
+        catch (NullPointerException n)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected NullPointerException, got " + e);
+        }
+    }
+
+    public void testReadBoolean() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeBoolean(true);
+        bm.reset();
+        boolean result = bm.readBoolean();
+        assertTrue(result);
+    }
+
+    public void testReadUnsignedByte() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeByte((byte) 9);
+        bm.reset();
+        int result = bm.readUnsignedByte();
+        assertEquals(9, result);
+    }
+
+    public void testReadUnsignedShort() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeShort((byte) 9);
+        bm.reset();
+        int result = bm.readUnsignedShort();
+        assertEquals(9, result);
+    }
+
+    public void testReadBytesChecksNull() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.readBytes(null);
+        }
+        catch (IllegalArgumentException e)
+        {
+            // pass
+        }
+
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.readBytes(null, 1);
+        }
+        catch (IllegalArgumentException e)
+        {
+            // pass
+        }
+    }
+
+    public void testReadBytesChecksMaxSize() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            byte[] bytes = new byte[100];
+            bm.readBytes(bytes, 120);
+        }
+        catch (IllegalArgumentException e)
+        {
+            // pass
+        }
+    }
+
+    public void testReadBytesReturnsCorrectLengths() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        byte[] bytes = {2, 3};
+        bm.writeBytes(bytes);
+        bm.reset();
+        int len = bm.readBytes(bytes);
+        assertEquals(2, len);
+        len = bm.readBytes(bytes);
+        assertEquals(-1, len);
+        len = bm.readBytes(bytes, 2);
+        assertEquals(-1, len);
+        bm.reset();
+        len = bm.readBytes(bytes, 2);
+        assertEquals(2, len);
+        bm.reset();
+        len = bm.readBytes(bytes, 1);
+        assertEquals(1, len);
+
+    }
+
+    public void testEOFByte() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeByte((byte)1);
+            bm.reset();
+            bm.readByte();
+            // should throw
+            bm.readByte();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFUnsignedByte() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeByte((byte)1);
+            bm.reset();
+            bm.readByte();
+            // should throw
+            bm.readUnsignedByte();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFBoolean() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeBoolean(true);
+            bm.reset();
+            bm.readBoolean();
+            // should throw
+            bm.readBoolean();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFChar() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeChar('A');
+            bm.reset();
+            bm.readChar();
+            // should throw
+            bm.readChar();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFDouble() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeDouble(1.3d);
+            bm.reset();
+            bm.readDouble();
+            // should throw
+            bm.readDouble();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFFloat() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeFloat(1.3f);
+            bm.reset();
+            bm.readFloat();
+            // should throw
+            bm.readFloat();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFInt() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeInt(99);
+            bm.reset();
+            bm.readInt();
+            // should throw
+            bm.readInt();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFLong() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeLong(4L);
+            bm.reset();
+            bm.readLong();
+            // should throw
+            bm.readLong();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFShort() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeShort((short)4);
+            bm.reset();
+            bm.readShort();
+            // should throw
+            bm.readShort();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFUnsignedShort() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeShort((short)4);
+            bm.reset();
+            bm.readUnsignedShort();
+            // should throw
+            bm.readUnsignedShort();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    /**
+     * Tests that the readBytes() method populates the passed in array
+     * correctly
+     * @throws Exception
+     */
+    public void testReadBytes() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeByte((byte)3);
+        bm.writeByte((byte)4);
+        bm.reset();
+        byte[] result = new byte[2];
+        int count = bm.readBytes(result);
+        assertEquals((byte)3, result[0]);
+        assertEquals((byte)4, result[1]);
+        assertEquals(2, count);
+    }
+
+    public void testReadBytesEOF() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeByte((byte)3);
+        bm.writeByte((byte)4);
+        bm.reset();
+        byte[] result = new byte[2];
+        bm.readBytes(result);
+        int count = bm.readBytes(result);
+        assertEquals(-1, count);
+    }
+
+    public void testReadBytesWithLargerArray() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeByte((byte)3);
+        bm.writeByte((byte)4);
+        bm.reset();
+        byte[] result = new byte[3];
+        int count = bm.readBytes(result);
+        assertEquals(2, count);
+        assertEquals((byte)3, result[0]);
+        assertEquals((byte)4, result[1]);
+        assertEquals((byte)0, result[2]);
+    }
+
+    public void testReadBytesWithCount() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeByte((byte)3);
+        bm.writeByte((byte)4);
+        bm.writeByte((byte)5);
+        bm.reset();
+        byte[] result = new byte[3];
+        int count = bm.readBytes(result, 2);
+        assertEquals(2, count);
+        assertEquals((byte)3, result[0]);
+        assertEquals((byte)4, result[1]);
+        assertEquals((byte)0, result[2]);
+    }
+
+    public void testToBodyStringWithNull() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.reset();
+        String result = bm.toBodyString();
+        assertEquals("\"\"", result);
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(BytesMessageTest.class);
+    }
+}
diff --git a/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/MapMessageTest.java b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/MapMessageTest.java
new file mode 100644
index 0000000000..3e04c36b38
--- /dev/null
+++ b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/MapMessageTest.java
@@ -0,0 +1,383 @@
+/*
+ *  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.test.unit.client.message;
+
+import javax.jms.JMSException;
+import javax.jms.MessageFormatException;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.apache.qpid.client.message.JMSMapMessage;
+import org.apache.qpid.client.message.TestMessageHelper;
+
+
+public class MapMessageTest extends TestCase
+{
+
+    //Test Lookups
+
+    public void testBooleanLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+
+            mm.setBoolean("value", true);
+            Assert.assertEquals(true, mm.getBoolean("value"));
+            Assert.assertEquals("true", mm.getString("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testByteLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setByte("value", Byte.MAX_VALUE);
+
+            Assert.assertEquals(Byte.MAX_VALUE, mm.getByte("value"));
+            Assert.assertEquals((short) Byte.MAX_VALUE, mm.getShort("value"));
+            Assert.assertEquals(Byte.MAX_VALUE, mm.getInt("value"));
+            Assert.assertEquals((long) Byte.MAX_VALUE, mm.getLong("value"));
+            Assert.assertEquals("" + Byte.MAX_VALUE, mm.getString("value"));
+
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testShortLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setShort("value", Short.MAX_VALUE);
+            Assert.assertEquals(Short.MAX_VALUE, mm.getShort("value"));
+            Assert.assertEquals((int) Short.MAX_VALUE, mm.getInt("value"));
+            Assert.assertEquals((long) Short.MAX_VALUE, mm.getLong("value"));
+            Assert.assertEquals("" + Short.MAX_VALUE, mm.getString("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+
+    public void testCharLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+
+            mm.setChar("value", 'c');
+            Assert.assertEquals('c', mm.getChar("value"));
+            Assert.assertEquals("c", mm.getString("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+
+            mm.setString("value", null);
+            mm.getChar("value");
+            fail("Expected NullPointerException");
+
+        }
+        catch (NullPointerException e)
+        {
+            ; // pass
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+
+
+
+    }
+
+    public void testDoubleLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setDouble("value", Double.MAX_VALUE);
+            Assert.assertEquals(Double.MAX_VALUE, mm.getDouble("value"));
+            Assert.assertEquals("" + Double.MAX_VALUE, mm.getString("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testFloatLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setFloat("value", Float.MAX_VALUE);
+            Assert.assertEquals(Float.MAX_VALUE, mm.getFloat("value"));
+            Assert.assertEquals((double) Float.MAX_VALUE, mm.getDouble("value"));
+            Assert.assertEquals("" + Float.MAX_VALUE, mm.getString("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testIntLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setInt("value", Integer.MAX_VALUE);
+            Assert.assertEquals(Integer.MAX_VALUE, mm.getInt("value"));
+            Assert.assertEquals((long) Integer.MAX_VALUE, mm.getLong("value"));
+            Assert.assertEquals("" + Integer.MAX_VALUE, mm.getString("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testLongLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setLong("value", Long.MAX_VALUE);
+            Assert.assertEquals(Long.MAX_VALUE, mm.getLong("value"));
+            Assert.assertEquals("" + Long.MAX_VALUE, mm.getString("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testBytesLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            byte[] bytes = {99, 98, 97, 96, 95};
+            mm.setBytes("bytes", bytes);
+            assertBytesEqual(bytes, mm.getBytes("bytes"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    // Failed Lookups
+
+    public void testFailedBooleanLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            Assert.assertEquals(false, mm.getBoolean("int"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testFailedByteLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getByte("random");
+            Assert.fail("NumberFormatException expected");
+        }
+        catch (NumberFormatException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+
+    }
+
+    public void testFailedBytesLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getBytes("random");
+            Assert.fail("MessageFormatException expected");
+        }
+        catch (MessageFormatException mfe)
+        {
+            //normal path
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+    public void testFailedCharLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getChar("random");
+            Assert.fail("MessageFormatException expected");
+        }
+        catch (MessageFormatException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+    public void testFailedDoubleLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getDouble("random");
+            Assert.fail("NullPointerException should be received.");
+        }
+        catch (NullPointerException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+    public void testFailedFloatLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getFloat("random");
+            Assert.fail("NullPointerException should be received.");
+        }
+        catch (NullPointerException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+    public void testFailedIntLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getInt("random");
+            Assert.fail("NumberFormatException should be received.");
+        }
+        catch (NumberFormatException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+    public void testFailedLongLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getLong("random");
+            Assert.fail("NumberFormatException should be received.");
+        }
+        catch (NumberFormatException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+    public void testFailedShortLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getShort("random");
+            Assert.fail("NumberFormatException  should be received.");
+        }
+        catch (NumberFormatException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+
+    private void assertBytesEqual(byte[] expected, byte[] actual)
+    {
+        Assert.assertEquals(expected.length, actual.length);
+
+        for (int index = 0; index < expected.length; index++)
+        {
+            Assert.assertEquals(expected[index], actual[index]);
+        }
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(MapMessageTest.class);
+    }
+
+
+}
diff --git a/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/StreamMessageTest.java b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/StreamMessageTest.java
new file mode 100644
index 0000000000..085dd81079
--- /dev/null
+++ b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/StreamMessageTest.java
@@ -0,0 +1,623 @@
+/*
+ *
+ * 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.test.unit.client.message;
+
+import java.util.HashMap;
+
+import javax.jms.JMSException;
+import javax.jms.MessageEOFException;
+import javax.jms.MessageFormatException;
+import javax.jms.MessageNotReadableException;
+import javax.jms.MessageNotWriteableException;
+import javax.jms.StreamMessage;
+
+import junit.framework.TestCase;
+
+import org.apache.qpid.client.message.JMSStreamMessage;
+import org.apache.qpid.client.message.TestMessageHelper;
+
+/**
+ * @author Apache Software Foundation
+ */
+public class StreamMessageTest extends TestCase
+{
+    /**
+     * Tests that on creation a call to getBodyLength() throws an exception
+     * if null was passed in during creation
+     */
+    public void testNotReadableOnCreationWithNull() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.readByte();
+            fail("expected exception did not occur");
+        }
+        catch (MessageNotReadableException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageNotReadableException, got " + e);
+        }
+    }
+
+    public void testResetMakesReadble() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeInt(10);
+            bm.reset();
+            bm.writeInt(12);
+            fail("expected exception did not occur");
+        }
+        catch (MessageNotWriteableException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageNotWriteableException, got " + e);
+        }
+    }
+
+    public void testClearBodyMakesWritable() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeInt(10);
+        bm.reset();
+        bm.clearBody();
+        bm.writeInt(10);
+    }
+
+    public void testWriteBoolean() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeBoolean(true);
+        bm.writeBoolean(false);
+        bm.reset();
+        boolean val = bm.readBoolean();
+        assertEquals(true, val);
+        val = bm.readBoolean();
+        assertEquals(false, val);
+    }
+
+    public void testWriteInt() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeInt(10);
+        bm.reset();
+        int val = bm.readInt();
+        assertTrue(val == 10);
+    }
+
+    public void testWriteString() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeString("Bananas");
+        bm.reset();
+        String res = bm.readString();
+        assertEquals("Bananas", res);
+    }
+
+    public void testWriteBytes() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        byte[] bytes = {1,2,3,4};
+        bm.writeBytes(bytes, 1, 2);
+        bm.reset();
+        bytes = new byte[2];
+        bm.readBytes(bytes);
+        assertEquals(2, bytes[0]);
+        assertEquals(3, bytes[1]);
+    }
+
+    public void testWriteObject() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeObject(new Boolean(true));
+        bm.writeObject(new Boolean(false));
+        bm.writeObject(new Byte((byte)2));
+        bm.writeObject(new byte[]{1,2,3,4});
+        bm.writeObject(new Character('g'));
+        bm.writeObject(new Short((short) 29));
+        bm.writeObject(new Integer(101));
+        bm.writeObject(new Long(50003222L));
+        bm.writeObject("Foobar");
+        bm.writeObject(new Float(1.7f));
+        bm.writeObject(new Double(8.7d));
+        bm.reset();
+        assertTrue(bm.readBoolean());
+        assertTrue(!bm.readBoolean());
+        assertEquals((byte)2, bm.readByte());
+        byte[] bytes = new byte[4];
+        bm.readBytes(bytes);
+        assertEquals('g', bm.readChar());
+        assertEquals((short) 29, bm.readShort());
+        assertEquals(101, bm.readInt());
+        assertEquals(50003222L, bm.readLong());
+        assertEquals("Foobar", bm.readString());
+        assertEquals(1.7f, bm.readFloat());
+        assertEquals(8.7d, bm.readDouble());
+    }
+
+    public void testWriteObjectRejectsNonPrimitives() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeObject(new HashMap());
+            fail("expected MessageFormatException was not thrown");
+        }
+        catch (MessageFormatException e)
+        {
+            // pass
+        }
+    }
+
+    public void testReadBoolean() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeBoolean(true);
+        bm.reset();
+        boolean result = bm.readBoolean();
+        assertTrue(result);
+    }
+
+    public void testReadBytesChecksNull() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.readBytes(null);
+        }
+        catch (IllegalArgumentException e)
+        {
+            // pass
+        }
+    }
+
+    public void testReadBytesReturnsCorrectLengths() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        byte[] bytes = {2, 3};
+        bm.writeBytes(bytes);
+        bm.writeBytes(null);
+        bm.writeBytes(new byte[]{});
+        bm.reset();
+        int len = bm.readBytes(bytes);
+        assertEquals(2, len);
+        len = bm.readBytes(bytes);
+        assertEquals(-1, len);
+        len = bm.readBytes(bytes);
+        assertEquals(-1, len);
+        len = bm.readBytes(bytes);
+        assertEquals(0, len);
+    }
+
+    public void testReadBytesFollowedByPrimitive() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeBytes(new byte[]{2, 3, 4, 5, 6, 7, 8});
+        bm.writeBytes(new byte[]{2, 3, 4, 5, 6, 7});
+        bm.writeString("Foo");
+        bm.reset();
+        int len;
+        do
+        {
+            len = bm.readBytes(new byte[2]);
+        }
+        while (len == 2);
+
+        do
+        {
+            len = bm.readBytes(new byte[2]);
+        }
+        while (len == 2);
+
+        assertEquals("Foo", bm.readString());
+    }
+
+    public void testReadMultipleByteArrays() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        byte[] bytes = {2, 3, 4};
+        bm.writeBytes(bytes);
+        bm.writeBytes(bytes);
+        bm.reset();
+        byte[] result = new byte[2];
+        int len = bm.readBytes(result);
+        assertEquals(2, len);
+        len = bm.readBytes(result);
+        assertEquals(1, len);
+        len = bm.readBytes(result);
+        assertEquals(2, len);
+    }
+
+    public void testEOFByte() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeByte((byte)1);
+            bm.reset();
+            bm.readByte();
+            // should throw
+            bm.readByte();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFBoolean() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeBoolean(true);
+            bm.reset();
+            bm.readBoolean();
+            // should throw
+            bm.readBoolean();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFChar() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeChar('A');
+            bm.reset();
+            bm.readChar();
+            // should throw
+            bm.readChar();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFDouble() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeDouble(1.3d);
+            bm.reset();
+            bm.readDouble();
+            // should throw
+            bm.readDouble();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFFloat() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeFloat(1.3f);
+            bm.reset();
+            bm.readFloat();
+            // should throw
+            bm.readFloat();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFInt() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeInt(99);
+            bm.reset();
+            bm.readInt();
+            // should throw
+            bm.readInt();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFLong() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeLong(4L);
+            bm.reset();
+            bm.readLong();
+            // should throw
+            bm.readLong();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFShort() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeShort((short)4);
+            bm.reset();
+            bm.readShort();
+            // should throw
+            bm.readShort();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testToBodyStringWithNull() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.reset();
+        String result = bm.toBodyString();
+        assertEquals("\"\"", result);
+    }
+
+    private void checkConversionsFail(StreamMessage sm, int[] conversions) throws JMSException
+    {
+        for (int conversion : conversions)
+        {
+            try
+            {
+                switch (conversion)
+                {
+                    case 0:
+                        sm.readBoolean();
+                        break;
+                    case 1:
+                        sm.readByte();
+                        break;
+                    case 2:
+                        sm.readShort();
+                        break;
+                    case 3:
+                        sm.readChar();
+                        break;
+                    case 4:
+                        sm.readInt();
+                        break;
+                    case 5:
+                        sm.readLong();
+                        break;
+                    case 6:
+                        sm.readFloat();
+                        break;
+                    case 7:
+                        sm.readDouble();
+                        break;
+                    case 8:
+                        sm.readString();
+                        break;
+                    case 9:
+                        sm.readBytes(new byte[3]);
+                        break;
+                }
+                fail("MessageFormatException was not thrown");
+            }
+            catch (MessageFormatException e)
+            {
+                // PASS
+            }
+            sm.reset();
+        }
+    }
+    public void testBooleanConversions() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeBoolean(true);
+        bm.reset();
+        String result = bm.readString();
+        assertEquals("true", result);
+        bm.reset();
+        checkConversionsFail(bm, new int[]{1,2,3,4,5,6,7,9});
+    }
+
+    public void testByteConversions() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeByte((byte) 43);
+        bm.reset();
+        assertEquals(43, bm.readShort());
+        bm.reset();
+        assertEquals(43, bm.readInt());
+        bm.reset();
+        assertEquals(43, bm.readLong());
+        bm.reset();
+        String result = bm.readString();
+        assertEquals("43", result);
+        bm.reset();
+        checkConversionsFail(bm, new int[]{0, 3, 6, 7, 9});
+    }
+
+    public void testShortConversions() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeShort((short) 87);
+        bm.reset();
+        assertEquals(87, bm.readInt());
+        bm.reset();
+        assertEquals(87, bm.readLong());
+        bm.reset();
+        assertEquals("87", bm.readString());
+        bm.reset();
+        checkConversionsFail(bm, new int[]{0, 1, 3, 6, 7, });
+    }
+
+    public void testCharConversions() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeChar('d');
+        bm.reset();
+        assertEquals("d", bm.readString());
+        bm.reset();
+        checkConversionsFail(bm, new int[]{0, 1, 2, 4, 5, 6, 7, 9});
+    }
+
+    public void testIntConversions() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeInt(167);
+        bm.reset();
+        assertEquals(167, bm.readLong());
+        bm.reset();
+        assertEquals("167", bm.readString());
+        bm.reset();
+        checkConversionsFail(bm, new int[]{0, 1, 2, 3, 6, 7, 9});
+    }
+
+    public void testLongConversions() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeLong(1678);
+        bm.reset();
+        assertEquals("1678", bm.readString());
+        bm.reset();
+        checkConversionsFail(bm, new int[]{0, 1, 2, 3, 4, 6, 7, 9});
+    }
+
+    public void testFloatConversions() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeFloat(6.2f);
+        bm.reset();
+        assertEquals(6.2d, bm.readDouble(), 0.01);
+        bm.reset();
+        assertEquals("6.2", bm.readString());
+        bm.reset();
+        checkConversionsFail(bm, new int[]{0, 1, 2, 3, 4, 5, 9});
+    }
+
+    public void testDoubleConversions() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeDouble(88.35d);
+        bm.reset();
+        assertEquals("88.35", bm.readString());
+        bm.reset();
+        checkConversionsFail(bm, new int[]{0, 1, 2, 3, 4, 5, 6, 9});
+    }
+
+    public void testStringConversions() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeString("true");
+        bm.reset();
+        assertEquals(true, bm.readBoolean());
+        bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeString("2");
+        bm.reset();
+        assertEquals((byte)2, bm.readByte());
+        bm.reset();
+        assertEquals((short)2, bm.readShort());
+        bm.reset();
+        assertEquals(2, bm.readInt());
+        bm.reset();
+        assertEquals((long)2, bm.readLong());
+        bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeString("5.7");
+        bm.reset();
+        assertEquals(5.7f, bm.readFloat());
+        bm.reset();
+        assertEquals(5.7d, bm.readDouble());
+    }
+
+    public void testNulls() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeString(null);
+        bm.writeObject(null);
+        bm.reset();
+        assertNull(bm.readObject());
+        assertNull(bm.readObject());
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(StreamMessageTest.class);
+    }
+}
diff --git a/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/TextMessageTest.java b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/TextMessageTest.java
new file mode 100644
index 0000000000..30f3b0b4eb
--- /dev/null
+++ b/qpid/java/client/src/test/java/org/apache/qpid/test/unit/client/message/TextMessageTest.java
@@ -0,0 +1,300 @@
+/*
+ *
+ * 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.test.unit.client.message;
+
+import javax.jms.JMSException;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import org.apache.qpid.client.message.JMSMapMessage;
+import org.apache.qpid.client.message.JMSTextMessage;
+import org.apache.qpid.client.message.TestMessageHelper;
+
+public class TextMessageTest extends TestCase
+{
+    public void testTextOnConstruction() throws Exception
+    {
+        JMSTextMessage tm = TestMessageHelper.newJMSTextMessage();
+        tm.setText("pies");
+        String val = tm.getText();
+        assertEquals(val, "pies");
+    }
+
+    public void testClearBody() throws Exception
+    {
+        JMSTextMessage tm = TestMessageHelper.newJMSTextMessage();
+        tm.setText("pies");
+        tm.clearBody();
+        String val = tm.getText();
+        assertNull(val);
+        tm.setText("Banana");
+        val = tm.getText();
+        assertEquals(val, "Banana");
+    }
+
+
+    public void testBooleanPropertyLookup()
+    {
+        try
+        {
+            JMSTextMessage tm = TestMessageHelper.newJMSTextMessage();
+
+            tm.setBooleanProperty("value", true);
+            Assert.assertEquals(true, tm.getBooleanProperty("value"));
+            Assert.assertEquals("true", tm.getStringProperty("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testBytePropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setByteProperty("value", Byte.MAX_VALUE);
+
+            Assert.assertEquals(Byte.MAX_VALUE, mm.getByteProperty("value"));
+            Assert.assertEquals((short) Byte.MAX_VALUE, mm.getShortProperty("value"));
+            Assert.assertEquals(Byte.MAX_VALUE, mm.getIntProperty("value"));
+            Assert.assertEquals((long) Byte.MAX_VALUE, mm.getLongProperty("value"));
+            Assert.assertEquals("" + Byte.MAX_VALUE, mm.getStringProperty("value"));
+
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testShortPropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setShortProperty("value", Short.MAX_VALUE);
+            Assert.assertEquals(Short.MAX_VALUE, mm.getShortProperty("value"));
+            Assert.assertEquals((int) Short.MAX_VALUE, mm.getIntProperty("value"));
+            Assert.assertEquals((long) Short.MAX_VALUE, mm.getLongProperty("value"));
+            Assert.assertEquals("" + Short.MAX_VALUE, mm.getStringProperty("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testDoublePropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setDoubleProperty("value", Double.MAX_VALUE);
+            Assert.assertEquals(Double.MAX_VALUE, mm.getDoubleProperty("value"));
+            Assert.assertEquals("" + Double.MAX_VALUE, mm.getStringProperty("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testFloatPropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setFloatProperty("value", Float.MAX_VALUE);
+            Assert.assertEquals(Float.MAX_VALUE, mm.getFloatProperty("value"));
+            Assert.assertEquals((double) Float.MAX_VALUE, mm.getDoubleProperty("value"));
+            Assert.assertEquals("" + Float.MAX_VALUE, mm.getStringProperty("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testIntPropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setIntProperty("value", Integer.MAX_VALUE);
+            Assert.assertEquals(Integer.MAX_VALUE, mm.getIntProperty("value"));
+            Assert.assertEquals((long) Integer.MAX_VALUE, mm.getLongProperty("value"));
+            Assert.assertEquals("" + Integer.MAX_VALUE, mm.getStringProperty("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testLongPropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.setLongProperty("value", Long.MAX_VALUE);
+            Assert.assertEquals(Long.MAX_VALUE, mm.getLongProperty("value"));
+            Assert.assertEquals("" + Long.MAX_VALUE, mm.getStringProperty("value"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+
+    // Failed Lookups
+
+    public void testFailedBooleanPropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            Assert.assertEquals(false, mm.getBooleanProperty("int"));
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received." + e);
+        }
+    }
+
+    public void testFailedBytePropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getByteProperty("random");
+            Assert.fail("NumberFormatException expected");
+        }
+        catch (NumberFormatException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+
+    }
+
+    public void testFailedDoublePropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getDoubleProperty("random");
+            Assert.fail("NullPointerException should be received.");
+        }
+        catch (NullPointerException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+    public void testFailedFloatPropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getFloatProperty("random");
+            Assert.fail("NullPointerException should be received.");
+        }
+        catch (NullPointerException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+    public void testFailedIntPropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getIntProperty("random");
+            Assert.fail("NumberFormatException should be received.");
+        }
+        catch (NumberFormatException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+    public void testFailedLongPropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getLongProperty("random");
+            Assert.fail("NumberFormatException should be received.");
+        }
+        catch (NumberFormatException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+    public void testFailedShortPropertyLookup()
+    {
+        try
+        {
+            JMSMapMessage mm = TestMessageHelper.newJMSMapMessage();
+            mm.getShortProperty("random");
+            Assert.fail("NumberFormatException should be received.");
+        }
+        catch (NumberFormatException e)
+        {
+            //normal execution
+        }
+        catch (JMSException e)
+        {
+            Assert.fail("JMSException received:" + e);
+        }
+    }
+
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(TextMessageTest.class);
+    }
+}