updated qpid.0-10/java to match trunk/qpid/java@686097

git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/branches/qpid.0-10@686136 13f79535-47bb-0310-9956-ffa450edef68

109 files changed, 16927 insertions, 1455 deletions

diff --git a/java/systests/pom.xml b/java/systests/pom.xml
index 49f088ec1a..73c8fb7351 100644
--- a/java/systests/pom.xml
+++ b/java/systests/pom.xml
@@ -151,7 +151,6 @@
                         <MessageReturnTest>-n MessageReturnTest org.apache.qpid.server.queue.MessageReturnTest </MessageReturnTest>
                         <QueueDepthWithSelectorTest>-n QueueDepthWithSelectorTest org.apache.qpid.server.queue.QueueDepthWithSelectorTest </QueueDepthWithSelectorTest>
                         <!--<SubscriptionManagerTest>-n SubscriptionManagerTest org.apache.qpid.server.queue.SubscriptionManagerTest </SubscriptionManagerTest>-->
-                        <SubscriptionSetTest>-n SubscriptionSetTest org.apache.qpid.server.queue.SubscriptionSetTest </SubscriptionSetTest>
                         <TimeToLiveTest>-n TimeToLiveTest org.apache.qpid.server.queue.TimeToLiveTest </TimeToLiveTest>
                         <TxnBufferTest>-n TxnBufferTest org.apache.qpid.server.txn.TxnBufferTest </TxnBufferTest>
                         <!--<TxnTest>-n TxnTest org.apache.qpid.server.txn.TxnTest </TxnTest>-->
diff --git a/java/systests/src/main/java/org/apache/mina/transport/vmpipe/support/VmPipeIdleStatusChecker.java b/java/systests/src/main/java/org/apache/mina/transport/vmpipe/support/VmPipeIdleStatusChecker.java
new file mode 100644
index 0000000000..5323ad28bf
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/mina/transport/vmpipe/support/VmPipeIdleStatusChecker.java
@@ -0,0 +1,125 @@
+/*
+ *
+ * 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.mina.transport.vmpipe.support;
+
+import org.apache.mina.common.IdleStatus;
+
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * This file is a patch to override MINA, because of the IdentityHashMap bug. Workaround to be supplied in MINA 1.0.7.
+ * This patched file will be removed once upgraded onto a newer MINA.
+ *
+ * Dectects idle sessions and fires <tt>sessionIdle</tt> events to them.
+ *
+ * @author The Apache Directory Project (mina-dev@directory.apache.org)
+ */
+public class VmPipeIdleStatusChecker
+{
+    private static final VmPipeIdleStatusChecker INSTANCE = new VmPipeIdleStatusChecker();
+
+    public static VmPipeIdleStatusChecker getInstance()
+    {
+        return INSTANCE;
+    }
+
+    private final Map sessions = new HashMap(); // will use as a set
+
+    private final Worker worker = new Worker();
+
+    private VmPipeIdleStatusChecker()
+    {
+        worker.start();
+    }
+
+    public void addSession(VmPipeSessionImpl session)
+    {
+        synchronized (sessions)
+        {
+            sessions.put(session, session);
+        }
+    }
+
+    private class Worker extends Thread
+    {
+        private Worker()
+        {
+            super("VmPipeIdleStatusChecker");
+            setDaemon(true);
+        }
+
+        public void run()
+        {
+            for (;;)
+            {
+                try
+                {
+                    Thread.sleep(1000);
+                }
+                catch (InterruptedException e)
+                { }
+
+                long currentTime = System.currentTimeMillis();
+
+                synchronized (sessions)
+                {
+                    Iterator it = sessions.keySet().iterator();
+                    while (it.hasNext())
+                    {
+                        VmPipeSessionImpl session = (VmPipeSessionImpl) it.next();
+                        if (!session.isConnected())
+                        {
+                            it.remove();
+                        }
+                        else
+                        {
+                            notifyIdleSession(session, currentTime);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private void notifyIdleSession(VmPipeSessionImpl session, long currentTime)
+    {
+        notifyIdleSession0(session, currentTime, session.getIdleTimeInMillis(IdleStatus.BOTH_IDLE), IdleStatus.BOTH_IDLE,
+            Math.max(session.getLastIoTime(), session.getLastIdleTime(IdleStatus.BOTH_IDLE)));
+        notifyIdleSession0(session, currentTime, session.getIdleTimeInMillis(IdleStatus.READER_IDLE), IdleStatus.READER_IDLE,
+            Math.max(session.getLastReadTime(), session.getLastIdleTime(IdleStatus.READER_IDLE)));
+        notifyIdleSession0(session, currentTime, session.getIdleTimeInMillis(IdleStatus.WRITER_IDLE), IdleStatus.WRITER_IDLE,
+            Math.max(session.getLastWriteTime(), session.getLastIdleTime(IdleStatus.WRITER_IDLE)));
+    }
+
+    private void notifyIdleSession0(VmPipeSessionImpl session, long currentTime, long idleTime, IdleStatus status,
+        long lastIoTime)
+    {
+        if ((idleTime > 0) && (lastIoTime != 0) && ((currentTime - lastIoTime) >= idleTime))
+        {
+            session.increaseIdleCount(status);
+            session.getFilterChain().fireSessionIdle(session, status);
+        }
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/client/AMQQueueDeferredOrderingTest.java b/java/systests/src/main/java/org/apache/qpid/client/AMQQueueDeferredOrderingTest.java
new file mode 100644
index 0000000000..fe418535d6
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/client/AMQQueueDeferredOrderingTest.java
@@ -0,0 +1,152 @@
+/*
+ *
+ * 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.client;
+
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.TextMessage;
+
+import junit.framework.TestCase;
+
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.jms.Session;
+import org.apache.qpid.client.transport.TransportConnection;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class tests all the alerts an AMQQueue can throw based on threshold
+ * values of different parameters
+ */
+public class AMQQueueDeferredOrderingTest extends TestCase
+{
+
+    private static final int NUM_MESSAGES = 1000;
+
+    private AMQConnection con;
+    private Session session;
+    private AMQQueue queue;
+    private MessageConsumer consumer;
+
+    private static final Logger _logger = LoggerFactory.getLogger(AMQQueueDeferredOrderingTest.class);
+
+    private ASyncProducer producerThread;
+    private static final String BROKER = "vm://:1";
+
+    private class ASyncProducer extends Thread
+    {
+
+        private MessageProducer producer;
+        private final Logger _logger = LoggerFactory.getLogger(ASyncProducer.class);
+        private Session session;
+        private int start;
+        private int end;
+
+        public ASyncProducer(AMQQueue q, int start, int end) throws Exception
+        {
+            this.session = con.createSession(false, Session.AUTO_ACKNOWLEDGE);
+            this._logger.info("Create Consumer of Q1");
+            this.producer = this.session.createProducer(q);
+            this.start = start;
+            this.end = end;
+        }
+
+        public void run()
+        {
+            try
+            {
+                this._logger.info("Starting to send messages");
+                for (int i = start; i < end && !interrupted(); i++)
+                {
+                    producer.send(session.createTextMessage(Integer.toString(i)));
+                }
+                this._logger.info("Sent " + (end - start) + " messages");
+            }
+            catch (JMSException e)
+            {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        TransportConnection.createVMBroker(1);
+
+        _logger.info("Create Connection");
+        con = new AMQConnection(BROKER, "guest", "guest", "OrderingTest", "test");
+        _logger.info("Create Session");
+        session = con.createSession(false, Session.AUTO_ACKNOWLEDGE);
+        _logger.info("Create Q");
+        queue = new AMQQueue(session.getDefaultQueueExchangeName(), new AMQShortString("Q"), new AMQShortString("Q"),
+                false, true);
+        _logger.info("Create Consumer of Q");
+        consumer = session.createConsumer(queue);
+        _logger.info("Start Connection");
+        con.start();
+    }
+
+    public void testPausedOrder() throws Exception
+    {
+
+        // Setup initial messages
+        _logger.info("Creating first producer thread");
+        producerThread = new ASyncProducer(queue, 0, NUM_MESSAGES / 2);
+        producerThread.start();
+        // Wait for them to be done
+        producerThread.join();
+
+        // Setup second set of messages to produce while we consume
+        _logger.info("Creating second producer thread");
+        producerThread = new ASyncProducer(queue, NUM_MESSAGES / 2, NUM_MESSAGES);
+        producerThread.start();
+
+        // Start consuming and checking they're in order
+        _logger.info("Consuming messages");
+        for (int i = 0; i < NUM_MESSAGES; i++)
+        {
+            Message msg = consumer.receive(3000);
+            assertNotNull("Message should not be null", msg);
+            assertTrue("Message should be a text message", msg instanceof TextMessage);
+            assertEquals("Message content does not match expected", Integer.toString(i), ((TextMessage) msg).getText());
+        }
+    }
+
+    protected void tearDown() throws Exception
+    {
+        _logger.info("Interuptting producer thread");
+        producerThread.interrupt();
+        _logger.info("Closing connection");
+        con.close();
+
+        TransportConnection.killAllVMBrokers();
+        super.tearDown();
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(AMQQueueDeferredOrderingTest.class);
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/client/DispatcherTest.java b/java/systests/src/main/java/org/apache/qpid/client/DispatcherTest.java
new file mode 100644
index 0000000000..7cca22de6c
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/client/DispatcherTest.java
@@ -0,0 +1,252 @@
+/*
+ *  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.client;
+
+import junit.framework.TestCase;
+
+import org.apache.qpid.client.transport.TransportConnection;
+import org.apache.qpid.jndi.PropertiesFileInitialContextFactory;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.ConnectionFactory;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.Session;
+import javax.naming.Context;
+import javax.naming.spi.InitialContextFactory;
+
+import java.util.Hashtable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * QPID-293 Setting MessageListener after connection has started can cause messages to be "lost" on a internal delivery queue
+ * <p/>
+ * The message delivery process:
+ * Mina puts a message on _queue in AMQSession and the dispatcher thread take()s
+ * from here and dispatches to the _consumers. If the _consumer doesn't have a message listener set at connection start
+ * then messages are stored on _synchronousQueue (which needs to be > 1 to pass JMS TCK as multiple consumers on a
+ * session can run in any order and a synchronous put/poll will block the dispatcher).
+ * <p/>
+ * When setting the message listener later the _synchronousQueue is just poll()'ed and the first message delivered
+ * the remaining messages will be left on the queue and lost, subsequent messages on the session will arrive first.
+ */
+public class DispatcherTest extends TestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(DispatcherTest.class);
+
+    Context _context;
+
+    private static final int MSG_COUNT = 6;
+    private int _receivedCount = 0;
+    private int _receivedCountWhileStopped = 0;
+    private Connection _clientConnection, _producerConnection;
+    private MessageConsumer _consumer;
+    MessageProducer _producer;
+    Session _clientSession, _producerSession;
+
+    private final CountDownLatch _allFirstMessagesSent = new CountDownLatch(1); // all messages Sent Lock
+    private final CountDownLatch _allSecondMessagesSent = new CountDownLatch(1); // all messages Sent Lock
+
+    private volatile boolean _connectionStopped = false;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        TransportConnection.createVMBroker(1);
+
+        InitialContextFactory factory = new PropertiesFileInitialContextFactory();
+
+        Hashtable<String, String> env = new Hashtable<String, String>();
+
+        env.put("connectionfactory.connection", "amqp://guest:guest@MLT_ID/test?brokerlist='vm://:1'");
+        env.put("queue.queue", "MessageListenerTest");
+
+        _context = factory.getInitialContext(env);
+
+        Queue queue = (Queue) _context.lookup("queue");
+
+        // Create Client 1
+        _clientConnection = ((ConnectionFactory) _context.lookup("connection")).createConnection();
+
+        _clientSession = _clientConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        _consumer = _clientSession.createConsumer(queue);
+
+        // Create Producer
+        _producerConnection = ((ConnectionFactory) _context.lookup("connection")).createConnection();
+
+        _producerConnection.start();
+
+        _producerSession = _producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        _producer = _producerSession.createProducer(queue);
+
+        for (int msg = 0; msg < MSG_COUNT; msg++)
+        {
+            _producer.send(_producerSession.createTextMessage("Message " + msg));
+        }
+    }
+
+    protected void tearDown() throws Exception
+    {
+
+        _clientConnection.close();
+
+        _producerConnection.close();
+        super.tearDown();
+        TransportConnection.killAllVMBrokers();
+    }
+
+    public void testAsynchronousRecieve()
+    {
+        _logger.info("Test Start");
+
+        assertTrue(!((AMQConnection) _clientConnection).started());
+
+        // Set default Message Listener
+        try
+        {
+            _consumer.setMessageListener(new MessageListener()
+                {
+                    public void onMessage(Message message)
+                    {
+                        _logger.info("Client 1 ML 1 Received Message(" + _receivedCount + "):" + message);
+
+                        _receivedCount++;
+
+                        if (_receivedCount == MSG_COUNT)
+                        {
+                            _allFirstMessagesSent.countDown();
+                        }
+
+                        if (_connectionStopped)
+                        {
+                            _logger.info("Running with Message:" + _receivedCount);
+                        }
+
+                        if (_connectionStopped && (_allFirstMessagesSent.getCount() == 0))
+                        {
+                            _receivedCountWhileStopped++;
+                        }
+
+                        if (_allFirstMessagesSent.getCount() == 0)
+                        {
+                            if (_receivedCount == (MSG_COUNT * 2))
+                            {
+                                _allSecondMessagesSent.countDown();
+                            }
+                        }
+                    }
+                });
+
+            assertTrue("Connecion should not be started", !((AMQConnection) _clientConnection).started());
+            _clientConnection.start();
+        }
+        catch (JMSException e)
+        {
+            _logger.error("Error Setting Default ML on consumer1");
+        }
+
+        try
+        {
+            _allFirstMessagesSent.await(1000, TimeUnit.MILLISECONDS);
+        }
+        catch (InterruptedException e)
+        {
+            // do nothing
+        }
+
+        try
+        {
+            assertTrue("Connecion should be started", ((AMQConnection) _clientConnection).started());
+            _clientConnection.stop();
+            _connectionStopped = true;
+        }
+        catch (JMSException e)
+        {
+            _logger.error("Error stopping connection");
+        }
+
+        try
+        {
+            _logger.error("Send additional messages");
+
+            for (int msg = 0; msg < MSG_COUNT; msg++)
+            {
+                _producer.send(_producerSession.createTextMessage("Message " + msg));
+            }
+        }
+        catch (JMSException e)
+        {
+            _logger.error("Unable to send additional messages", e);
+        }
+
+        try
+        {
+            Thread.sleep(1000);
+        }
+        catch (InterruptedException e)
+        {
+            // ignore
+        }
+
+        try
+        {
+            _logger.info("Restarting connection");
+
+            _connectionStopped = false;
+            _clientConnection.start();
+        }
+        catch (JMSException e)
+        {
+            _logger.error("Error Setting Better ML on consumer1", e);
+        }
+
+        _logger.info("Waiting upto 2 seconds for messages");
+
+        try
+        {
+            _allSecondMessagesSent.await(1000, TimeUnit.MILLISECONDS);
+        }
+        catch (InterruptedException e)
+        {
+            // do nothing
+        }
+
+        assertEquals("Messages not received correctly", 0, _allFirstMessagesSent.getCount());
+        assertEquals("Messages not received correctly", 0, _allSecondMessagesSent.getCount());
+        assertEquals("Client didn't get all messages", MSG_COUNT * 2, _receivedCount);
+        assertEquals("Messages received while stopped is not 0", 0, _receivedCountWhileStopped);
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(DispatcherTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/client/MessageListenerMultiConsumerImmediatePrefetch.java b/java/systests/src/main/java/org/apache/qpid/client/MessageListenerMultiConsumerImmediatePrefetch.java
new file mode 100644
index 0000000000..7461f6c200
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/client/MessageListenerMultiConsumerImmediatePrefetch.java
@@ -0,0 +1,44 @@
+/*
+ *  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.client;
+
+/**
+ * QPID-293 Setting MessageListener after connection has started can cause messages to be "lost" on a internal delivery
+ * queue <p/> The message delivery process: Mina puts a message on _queue in AMQSession and the dispatcher thread
+ * take()s from here and dispatches to the _consumers. If the _consumer1 doesn't have a message listener set at
+ * connection start then messages are stored on _synchronousQueue (which needs to be > 1 to pass JMS TCK as multiple
+ * consumers on a session can run in any order and a synchronous put/poll will block the dispatcher). <p/> When setting
+ * the message listener later the _synchronousQueue is just poll()'ed and the first message delivered the remaining
+ * messages will be left on the queue and lost, subsequent messages on the session will arrive first.
+ */
+public class MessageListenerMultiConsumerImmediatePrefetch extends MessageListenerMultiConsumerTest
+{
+    protected void setUp() throws Exception
+    {
+        System.setProperty(AMQSession.IMMEDIATE_PREFETCH, "true");
+        super.setUp();
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(MessageListenerMultiConsumerImmediatePrefetch.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/client/MessageListenerMultiConsumerTest.java b/java/systests/src/main/java/org/apache/qpid/client/MessageListenerMultiConsumerTest.java
new file mode 100644
index 0000000000..b438304892
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/client/MessageListenerMultiConsumerTest.java
@@ -0,0 +1,245 @@
+/*
+ *  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.client;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.Session;
+import javax.naming.Context;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * QPID-293 Setting MessageListener after connection has started can cause messages to be "lost" on a internal delivery
+ * queue <p/> The message delivery process: Mina puts a message on _queue in AMQSession and the dispatcher thread
+ * take()s from here and dispatches to the _consumers. If the _consumer1 doesn't have a message listener set at
+ * connection start then messages are stored on _synchronousQueue (which needs to be > 1 to pass JMS TCK as multiple
+ * consumers on a session can run in any order and a synchronous put/poll will block the dispatcher). <p/> When setting
+ * the message listener later the _synchronousQueue is just poll()'ed and the first message delivered the remaining
+ * messages will be left on the queue and lost, subsequent messages on the session will arrive first.
+ */
+public class MessageListenerMultiConsumerTest extends QpidTestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(MessageListenerMultiConsumerTest.class);
+
+    Context _context;
+
+    private static final int MSG_COUNT = 6;
+    private int receivedCount1 = 0;
+    private int receivedCount2 = 0;
+    private Connection _clientConnection;
+    private MessageConsumer _consumer1;
+    private MessageConsumer _consumer2;
+    private Session _clientSession1;
+    private Queue _queue;
+    private final CountDownLatch _allMessagesSent = new CountDownLatch(2); // all messages Sent Lock
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+
+        // Create Client 1
+        _clientConnection = getConnection("guest", "guest");
+
+        _clientConnection.start();
+
+        _clientSession1 = _clientConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        _queue =_clientSession1.createQueue("queue");
+
+        _consumer1 = _clientSession1.createConsumer(_queue);
+
+        // Create Client 2
+        Session clientSession2 = _clientConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+       _consumer2 = clientSession2.createConsumer(_queue);
+
+        // Create Producer
+        Connection producerConnection = getConnection("guest", "guest");
+
+        producerConnection.start();
+
+        Session producerSession = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        MessageProducer producer = producerSession.createProducer(_queue);
+
+        for (int msg = 0; msg < MSG_COUNT; msg++)
+        {
+            producer.send(producerSession.createTextMessage("Message " + msg));
+        }
+
+        producerConnection.close();
+
+    }
+
+    protected void tearDown() throws Exception
+    {
+        _clientConnection.close();
+        super.tearDown();
+    }
+
+    public void testRecieveInterleaved() throws Exception
+    {
+        int msg = 0;
+        int MAX_LOOPS = MSG_COUNT * 2;
+        for (int loops = 0; (msg < MSG_COUNT) || (loops < MAX_LOOPS); loops++)
+        {
+
+            if (_consumer1.receive(100) != null)
+            {
+                msg++;
+            }
+
+            if (_consumer2.receive(100) != null)
+            {
+                msg++;
+            }
+        }
+
+        assertEquals("Not all messages received.", MSG_COUNT, msg);
+    }
+
+    public void testAsynchronousRecieve() throws Exception
+    {
+        _consumer1.setMessageListener(new MessageListener()
+            {
+                public void onMessage(Message message)
+                {
+                    _logger.info("Client 1 Received Message(" + receivedCount1 + "):" + message);
+
+                    receivedCount1++;
+
+                    if (receivedCount1 == (MSG_COUNT / 2))
+                    {
+                        _allMessagesSent.countDown();
+                    }
+
+                }
+            });
+
+        _consumer2.setMessageListener(new MessageListener()
+            {
+                public void onMessage(Message message)
+                {
+                    _logger.info("Client 2 Received Message(" + receivedCount2 + "):" + message);
+
+                    receivedCount2++;
+                    if (receivedCount2 == (MSG_COUNT / 2))
+                    {
+                        _allMessagesSent.countDown();
+                    }
+                }
+            });
+
+        _logger.info("Waiting upto 2 seconds for messages");
+
+        try
+        {
+            _allMessagesSent.await(4000, TimeUnit.MILLISECONDS);
+        }
+        catch (InterruptedException e)
+        {
+            // do nothing
+        }
+
+        assertEquals(MSG_COUNT, receivedCount1 + receivedCount2);
+    }
+
+    public void testRecieveC2Only() throws Exception
+    {
+        if (
+            !Boolean.parseBoolean(
+                    System.getProperties().getProperty(AMQSession.IMMEDIATE_PREFETCH,
+                        AMQSession.IMMEDIATE_PREFETCH_DEFAULT)))
+        {
+            _logger.info("Performing Receive only on C2");
+            for (int msg = 0; msg < MSG_COUNT; msg++)
+            {
+                assertTrue(MSG_COUNT + " msg should be received. Only received:" + msg, _consumer2.receive(1000) != null);
+            }
+        }
+    }
+
+    public void testRecieveBoth() throws Exception
+    {
+        if (
+            !Boolean.parseBoolean(
+                    System.getProperties().getProperty(AMQSession.IMMEDIATE_PREFETCH,
+                        AMQSession.IMMEDIATE_PREFETCH_DEFAULT)))
+        {
+            _logger.info("Performing Receive only with two consumers on one session ");
+
+            MessageConsumer consumer2 = _clientSession1.createConsumer(_queue);
+
+            int msg;
+            for (msg = 0; msg < (MSG_COUNT / 2); msg++)
+            {
+
+
+                final Message message = _consumer1.receive(1000);
+                if(message == null)
+                {
+                    break;
+                }
+
+            }
+
+            _consumer1.close();
+            _clientSession1.close();
+
+            for (; msg < MSG_COUNT ; msg++)
+            {
+                assertTrue("Failed at msg id" + msg, _consumer2.receive(1000) != null);
+            }
+
+        }
+        else
+        {
+            _logger.info("Performing Receive only on both C1 and C2");
+
+            for (int msg = 0; msg < (MSG_COUNT / 2); msg++)
+            {
+
+                assertTrue(_consumer1.receive(3000) != null);
+            }
+
+            for (int msg = 0; msg < (MSG_COUNT / 2); msg++)
+            {
+                assertTrue(_consumer2.receive(3000) != null);
+            }
+        }
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(MessageListenerMultiConsumerTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/client/MessageListenerTest.java b/java/systests/src/main/java/org/apache/qpid/client/MessageListenerTest.java
new file mode 100644
index 0000000000..e1c0f0ccef
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/client/MessageListenerTest.java
@@ -0,0 +1,169 @@
+/*
+ *  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.client;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.Session;
+import javax.naming.Context;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * QPID-293 Setting MessageListener after connection has started can cause messages to be "lost" on a internal delivery
+ * queue <p/> The message delivery process: Mina puts a message on _queue in AMQSession and the dispatcher thread
+ * take()s from here and dispatches to the _consumers. If the _consumer doesn't have a message listener set at
+ * connection start then messages are stored on _synchronousQueue (which needs to be > 1 to pass JMS TCK as multiple
+ * consumers on a session can run in any order and a synchronous put/poll will block the dispatcher). <p/> When setting
+ * the message listener later the _synchronousQueue is just poll()'ed and the first message delivered the remaining
+ * messages will be left on the queue and lost, subsequent messages on the session will arrive first.
+ */
+public class MessageListenerTest extends QpidTestCase implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(MessageListenerTest.class);
+
+    Context _context;
+
+    private static final int MSG_COUNT = 5;
+    private int receivedCount = 0;
+    private MessageConsumer _consumer;
+    private Connection _clientConnection;
+    private CountDownLatch _awaitMessages = new CountDownLatch(MSG_COUNT);
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+
+        // Create Client
+        _clientConnection = getConnection("guest", "guest");
+
+        _clientConnection.start();
+
+        Session clientSession = _clientConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        Queue queue =clientSession.createQueue("message-listener-test-queue");
+
+        _consumer = clientSession.createConsumer(queue);
+
+        // Create Producer
+
+        Connection producerConnection = getConnection("guest", "guest");
+
+        producerConnection.start();
+
+        Session producerSession = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        MessageProducer producer = producerSession.createProducer(queue);
+
+        for (int msg = 0; msg < MSG_COUNT; msg++)
+        {
+            producer.send(producerSession.createTextMessage("Message " + msg));
+        }
+
+        producerConnection.close();
+
+    }
+
+    protected void tearDown() throws Exception
+    {
+        _clientConnection.close();
+        super.tearDown();
+    }
+
+    public void testSynchronousRecieve() throws Exception
+    {
+        for (int msg = 0; msg < MSG_COUNT; msg++)
+        {
+            assertTrue(_consumer.receive(2000) != null);
+        }
+    }
+
+    public void testAsynchronousRecieve() throws Exception
+    {
+        _consumer.setMessageListener(this);
+
+        _logger.info("Waiting 3 seconds for messages");
+
+        try
+        {
+            _awaitMessages.await(3000, TimeUnit.MILLISECONDS);
+        }
+        catch (InterruptedException e)
+        {
+            // do nothing
+        }
+        // Should have recieved all async messages
+        assertEquals(MSG_COUNT, receivedCount);
+
+    }
+
+    public void testRecieveThenUseMessageListener() throws Exception
+    {
+
+        _logger.error("Test disabled as initial receive is not called first");
+        // Perform initial receive to start connection
+        assertTrue(_consumer.receive(2000) != null);
+        receivedCount++;
+
+        // Sleep to ensure remaining 4 msgs end up on _synchronousQueue
+        Thread.sleep(1000);
+
+        // Set the message listener and wait for the messages to come in.
+        _consumer.setMessageListener(this);
+
+        _logger.info("Waiting 3 seconds for messages");
+
+        try
+        {
+            _awaitMessages.await(3000, TimeUnit.MILLISECONDS);
+        }
+        catch (InterruptedException e)
+        {
+            // do nothing
+        }
+        // Should have recieved all async messages
+        assertEquals(MSG_COUNT, receivedCount);
+
+    }
+
+    public void onMessage(Message message)
+    {
+        _logger.info("Received Message(" + receivedCount + "):" + message);
+
+        receivedCount++;
+        _awaitMessages.countDown();
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(MessageListenerTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/client/ResetMessageListenerTest.java b/java/systests/src/main/java/org/apache/qpid/client/ResetMessageListenerTest.java
new file mode 100644
index 0000000000..a0bb31192f
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/client/ResetMessageListenerTest.java
@@ -0,0 +1,386 @@
+/*
+ *  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.client;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+import javax.naming.Context;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * QPID-293 Setting MessageListener after connection has started can cause messages to be "lost" on a internal delivery
+ * queue <p/> The message delivery process: Mina puts a message on _queue in AMQSession and the dispatcher thread
+ * take()s from here and dispatches to the _consumers. If the _consumer1 doesn't have a message listener set at
+ * connection start then messages are stored on _synchronousQueue (which needs to be > 1 to pass JMS TCK as multiple
+ * consumers on a session can run in any order and a synchronous put/poll will block the dispatcher). <p/> When setting
+ * the message listener later the _synchronousQueue is just poll()'ed and the first message delivered the remaining
+ * messages will be left on the queue and lost, subsequent messages on the session will arrive first.
+ */
+public class ResetMessageListenerTest extends QpidTestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(ResetMessageListenerTest.class);
+
+    Context _context;
+
+    private static final int MSG_COUNT = 6;
+    private int receivedCount1ML1 = 0;
+    private int receivedCount1ML2 = 0;
+    private int receivedCount2 = 0;
+    private Connection _clientConnection, _producerConnection;
+    private MessageConsumer _consumer1;
+    private MessageConsumer _consumer2;
+    MessageProducer _producer;
+    Session _clientSession, _producerSession;
+
+    private final CountDownLatch _allFirstMessagesSent = new CountDownLatch(2); // all messages Sent Lock
+    private final CountDownLatch _allSecondMessagesSent = new CountDownLatch(2); // all messages Sent Lock
+    private final CountDownLatch _allFirstMessagesSent010 = new CountDownLatch(MSG_COUNT); // all messages Sent Lock
+	private final CountDownLatch _allSecondMessagesSent010 = new CountDownLatch(MSG_COUNT); // all messages Sent Lock
+    
+    private String oldImmediatePrefetch;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+
+        oldImmediatePrefetch = System.getProperty(AMQSession.IMMEDIATE_PREFETCH);
+        System.setProperty(AMQSession.IMMEDIATE_PREFETCH, "true");
+
+        _clientConnection = getConnection("guest", "guest");
+
+        // Create Client 1
+
+        _clientSession = _clientConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        Queue queue = _clientSession.createQueue("reset-message-listener-test-queue");
+
+        _consumer1 = _clientSession.createConsumer(queue);
+
+        // Create Client 2 on same session
+        _consumer2 = _clientSession.createConsumer(queue);
+
+        // Create Producer
+        _producerConnection = getConnection("guest", "guest");
+
+        _producerConnection.start();
+
+        _producerSession = _producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        _producer = _producerSession.createProducer(queue);
+
+        TextMessage m = _producerSession.createTextMessage();
+        m.setStringProperty("rank", "first");
+        for (int msg = 0; msg < MSG_COUNT; msg++)
+        {
+            m.setText("Message " + msg);
+            _producer.send(m);
+        }
+
+    }
+
+    protected void tearDown() throws Exception
+    {
+        _clientConnection.close();
+
+        super.tearDown();
+        if (oldImmediatePrefetch == null)
+        {
+            oldImmediatePrefetch = AMQSession.IMMEDIATE_PREFETCH_DEFAULT;
+        }
+        System.setProperty(AMQSession.IMMEDIATE_PREFETCH, oldImmediatePrefetch);
+    }
+
+    public void testAsynchronousRecieve()
+    {
+
+        _logger.info("Test Start");
+        if (isBroker08())
+        {
+            // Set default Message Listener
+            try
+            {
+                _consumer1.setMessageListener(new MessageListener()
+                {
+                    public void onMessage(Message message)
+                    {
+                        _logger.info("Client 1 ML 1 Received Message(" + receivedCount1ML1 + "):" + message);
+
+                        receivedCount1ML1++;
+                        if (receivedCount1ML1 == (MSG_COUNT / 2))
+                        {
+                            _allFirstMessagesSent.countDown();
+                        }
+                    }
+                });
+            }
+            catch (JMSException e)
+            {
+                _logger.error("Error Setting Default ML on consumer1");
+            }
+
+            try
+            {
+                _consumer2.setMessageListener(new MessageListener()
+                {
+                    public void onMessage(Message message)
+                    {
+                        _logger.info("Client 2 Received Message(" + receivedCount2 + "):" + message);
+
+                        receivedCount2++;
+                        if (receivedCount2 == (MSG_COUNT / 2))
+                        {
+                            _logger.info("Client 2 received all its messages1");
+                            _allFirstMessagesSent.countDown();
+                        }
+
+                        if (receivedCount2 == MSG_COUNT)
+                        {
+                            _logger.info("Client 2 received all its messages2");
+                            _allSecondMessagesSent.countDown();
+                        }
+                    }
+                });
+
+                _clientConnection.start();
+            }
+            catch (JMSException e)
+            {
+                _logger.error("Error Setting Default ML on consumer2");
+
+            }
+
+            try
+            {
+                _allFirstMessagesSent.await(1000, TimeUnit.MILLISECONDS);
+                _logger.info("Received first batch of messages");
+            }
+            catch (InterruptedException e)
+            {
+                // do nothing
+            }
+
+            try
+            {
+                _clientConnection.stop();
+            }
+            catch (JMSException e)
+            {
+                _logger.error("Error stopping connection");
+            }
+
+            _logger.info("Reset Message Listener to better listener while connection stopped, will restart session");
+            try
+            {
+                _consumer1.setMessageListener(new MessageListener()
+                {
+                    public void onMessage(Message message)
+                    {
+                        _logger.info("Client 1 ML2 Received Message(" + receivedCount1ML1 + "):" + message);
+
+                        receivedCount1ML2++;
+                        if (receivedCount1ML2 == (MSG_COUNT / 2))
+                        {
+                            _allSecondMessagesSent.countDown();
+                        }
+                    }
+                });
+
+                _clientConnection.start();
+            }
+            catch (javax.jms.IllegalStateException e)
+            {
+                _logger.error("Connection not stopped while setting ML", e);
+                fail("Unable to change message listener:" + e.getCause());
+            }
+            catch (JMSException e)
+            {
+                _logger.error("Error Setting Better ML on consumer1", e);
+            }
+
+            try
+            {
+                _logger.info("Send additional messages");
+
+                for (int msg = 0; msg < MSG_COUNT; msg++)
+                {
+                    _producer.send(_producerSession.createTextMessage("Message " + msg));
+                }
+            }
+            catch (JMSException e)
+            {
+                _logger.error("Unable to send additional messages", e);
+            }
+
+            _logger.info("Waiting upto 2 seconds for messages");
+
+            try
+            {
+            _allSecondMessagesSent.await(5000, TimeUnit.MILLISECONDS);
+            }
+            catch (InterruptedException e)
+            {
+                // do nothing
+            }
+            assertEquals("First batch of messages not received correctly", 0, _allFirstMessagesSent.getCount());
+            assertEquals("Second batch of messages not received correctly", 0, _allSecondMessagesSent.getCount());
+            assertEquals("Client 1 ML1 didn't get all messages", MSG_COUNT / 2, receivedCount1ML1);
+            assertEquals("Client 2 didn't get all messages", MSG_COUNT, receivedCount2);
+            assertEquals("Client 1 ML2 didn't get all messages", MSG_COUNT / 2, receivedCount1ML2);
+        }
+        else
+        {
+            try
+            {
+                 _consumer2.close();
+                _consumer1.setMessageListener(new MessageListener()
+                {
+                    public void onMessage(Message message)
+                    {
+                        _logger.info("Received Message(" + receivedCount1ML1 + "):" + message);
+
+                        try
+                        {
+                            if (message.getStringProperty("rank").equals("first"))
+                            {
+                                _allFirstMessagesSent010.countDown();
+                            }
+                        }
+                        catch (JMSException e)
+                        {
+                            e.printStackTrace();
+                            fail("error receiving message");
+                        }
+                    }
+                });
+            }
+            catch (JMSException e)
+            {
+                _logger.error("Error Setting Default ML on consumer1");
+            }
+            try
+            {
+                _allFirstMessagesSent.await(1000, TimeUnit.MILLISECONDS);
+                _logger.info("Received first batch of messages");
+            }
+            catch (InterruptedException e)
+            {
+                // do nothing
+            }
+
+            try
+            {
+                _clientConnection.stop();
+            }
+            catch (JMSException e)
+            {
+                _logger.error("Error stopping connection");
+            }
+
+            _logger.info("Reset Message Listener ");
+            try
+            {
+                _consumer1.setMessageListener(new MessageListener()
+                {
+                    public void onMessage(Message message)
+                    {
+                        _logger.info("Received Message(" + receivedCount1ML1 + "):" + message);
+
+                        try
+                        {
+                            if (message.getStringProperty("rank").equals("first"))
+                            {
+                                _allFirstMessagesSent010.countDown();
+                            }
+                            else
+                            {
+                                _allSecondMessagesSent010.countDown();
+                            }
+                        }
+                        catch (JMSException e)
+                        {
+                            e.printStackTrace();
+                            fail("error receiving message");
+                        }
+                    }
+                });
+
+                _clientConnection.start();
+            }
+            catch (javax.jms.IllegalStateException e)
+            {
+                _logger.error("Connection not stopped while setting ML", e);
+                fail("Unable to change message listener:" + e.getCause());
+            }
+            catch (JMSException e)
+            {
+                _logger.error("Error Setting Better ML on consumer1", e);
+            }
+
+            try
+            {
+                _logger.info("Send additional messages");
+                TextMessage m = _producerSession.createTextMessage();
+                m.setStringProperty("rank", "second");
+                for (int msg = 0; msg < MSG_COUNT; msg++)
+                {
+                    m.setText("Message " + msg);
+                    _producer.send(m);
+                }
+            }
+            catch (JMSException e)
+            {
+                _logger.error("Unable to send additional messages", e);
+            }
+
+            _logger.info("Waiting upto 2 seconds for messages");
+
+            try
+            {
+                _allSecondMessagesSent.await(1000, TimeUnit.MILLISECONDS);
+            }
+            catch (InterruptedException e)
+            {
+                // do nothing
+            }
+            assertEquals("First batch of messages not received correctly", 0, _allFirstMessagesSent010.getCount());
+            assertEquals("Second batch of messages not received correctly", 0, _allSecondMessagesSent010.getCount());                  
+        }
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(ResetMessageListenerTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/client/message/NonQpidObjectMessage.java b/java/systests/src/main/java/org/apache/qpid/client/message/NonQpidObjectMessage.java
new file mode 100644
index 0000000000..857adaf82c
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/client/message/NonQpidObjectMessage.java
@@ -0,0 +1,236 @@
+/*
+ *
+ * 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.client.message;
+
+import java.io.Serializable;
+import java.util.Enumeration;
+
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.ObjectMessage;
+import javax.jms.Session;
+
+public class NonQpidObjectMessage implements ObjectMessage {
+
+    private ObjectMessage _realMessage;
+    private String _contentString;
+
+    /**
+     * Allows us to construct a JMS message which
+     * does not inherit from the Qpid message superclasses
+     * and expand our unit testing of MessageConverter et al
+     * @param session
+     */
+    public NonQpidObjectMessage(Session session) throws JMSException
+    {
+        _realMessage = session.createObjectMessage();
+    }
+
+    public String getJMSMessageID() throws JMSException {
+        return _realMessage.getJMSMessageID();
+    }
+
+    public void setJMSMessageID(String string) throws JMSException {
+        _realMessage.setJMSMessageID(string);
+    }
+
+    public long getJMSTimestamp() throws JMSException {
+        return _realMessage.getJMSTimestamp();
+    }
+
+    public void setJMSTimestamp(long l) throws JMSException {
+        _realMessage.setJMSTimestamp(l);
+    }
+
+    public byte[] getJMSCorrelationIDAsBytes() throws JMSException {
+        return _realMessage.getJMSCorrelationIDAsBytes();
+    }
+
+    public void setJMSCorrelationIDAsBytes(byte[] bytes) throws JMSException {
+        _realMessage.setJMSCorrelationIDAsBytes(bytes);
+    }
+
+    public void setJMSCorrelationID(String string) throws JMSException {
+        _realMessage.setJMSCorrelationID(string);
+    }
+
+    public String getJMSCorrelationID() throws JMSException {
+        return _realMessage.getJMSCorrelationID();
+    }
+
+    public Destination getJMSReplyTo() throws JMSException {
+        return _realMessage.getJMSReplyTo();
+    }
+
+    public void setJMSReplyTo(Destination destination) throws JMSException {
+        _realMessage.setJMSReplyTo(destination);
+    }
+
+    public Destination getJMSDestination() throws JMSException {
+        return _realMessage.getJMSDestination();
+    }
+
+    public void setJMSDestination(Destination destination) throws JMSException {
+        _realMessage.setJMSDestination(destination);
+    }
+
+    public int getJMSDeliveryMode() throws JMSException {
+        return _realMessage.getJMSDeliveryMode();
+    }
+
+    public void setJMSDeliveryMode(int i) throws JMSException {
+        _realMessage.setJMSDeliveryMode(i);
+    }
+
+    public boolean getJMSRedelivered() throws JMSException {
+        return _realMessage.getJMSRedelivered();
+    }
+
+    public void setJMSRedelivered(boolean b) throws JMSException {
+        _realMessage.setJMSRedelivered(b);
+    }
+
+    public String getJMSType() throws JMSException {
+        return _realMessage.getJMSType();
+    }
+
+    public void setJMSType(String string) throws JMSException {
+        _realMessage.setJMSType(string);
+    }
+
+    public long getJMSExpiration() throws JMSException {
+        return _realMessage.getJMSExpiration();
+    }
+
+    public void setJMSExpiration(long l) throws JMSException {
+        _realMessage.setJMSExpiration(l);
+    }
+
+    public int getJMSPriority() throws JMSException {
+        return _realMessage.getJMSPriority();
+    }
+
+    public void setJMSPriority(int i) throws JMSException {
+        _realMessage.setJMSPriority(i);
+    }
+
+    public void clearProperties() throws JMSException {
+        _realMessage.clearProperties();
+    }
+
+    public boolean propertyExists(String string) throws JMSException {
+        return _realMessage.propertyExists(string);
+    }
+
+    public boolean getBooleanProperty(String string) throws JMSException {
+        return _realMessage.getBooleanProperty(string);
+    }
+
+    public byte getByteProperty(String string) throws JMSException {
+        return _realMessage.getByteProperty(string);
+    }
+
+    public short getShortProperty(String string) throws JMSException {
+        return _realMessage.getShortProperty(string);
+    }
+
+    public int getIntProperty(String string) throws JMSException {
+        return _realMessage.getIntProperty(string);
+    }
+
+    public long getLongProperty(String string) throws JMSException {
+        return _realMessage.getLongProperty(string);
+    }
+
+    public float getFloatProperty(String string) throws JMSException {
+        return _realMessage.getFloatProperty(string);
+    }
+
+    public double getDoubleProperty(String string) throws JMSException {
+        return _realMessage.getDoubleProperty(string);
+    }
+
+    public String getStringProperty(String string) throws JMSException {
+        return _realMessage.getStringProperty(string);
+    }
+
+    public Object getObjectProperty(String string) throws JMSException {
+        return _realMessage.getObjectProperty(string);
+    }
+
+    public Enumeration getPropertyNames() throws JMSException {
+        return _realMessage.getPropertyNames();
+    }
+
+    public void setBooleanProperty(String string, boolean b) throws JMSException {
+        _realMessage.setBooleanProperty(string,b);
+    }
+
+    public void setByteProperty(String string, byte b) throws JMSException {
+        _realMessage.setByteProperty(string,b);
+    }
+
+    public void setShortProperty(String string, short i) throws JMSException {
+        _realMessage.setShortProperty(string,i);
+    }
+
+    public void setIntProperty(String string, int i) throws JMSException {
+        _realMessage.setIntProperty(string,i);
+    }
+
+    public void setLongProperty(String string, long l) throws JMSException {
+        _realMessage.setLongProperty(string,l);
+    }
+
+    public void setFloatProperty(String string, float v) throws JMSException {
+        _realMessage.setFloatProperty(string,v);
+    }
+
+    public void setDoubleProperty(String string, double v) throws JMSException {
+        _realMessage.setDoubleProperty(string,v);
+    }
+
+    public void setStringProperty(String string, String string1) throws JMSException {
+        _realMessage.setStringProperty(string,string1);
+    }
+
+    public void setObjectProperty(String string, Object object) throws JMSException {
+        _realMessage.setObjectProperty(string,object);
+    }
+
+    public void acknowledge() throws JMSException {
+        _realMessage.acknowledge();
+    }
+
+    public void clearBody() throws JMSException {
+        _realMessage.clearBody();
+    }
+
+    public void setObject(Serializable serializable) throws JMSException {
+        if (serializable instanceof String)
+        {
+            _contentString = (String)serializable;
+        }
+    }
+
+    public Serializable getObject() throws JMSException {
+        return _contentString;      }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/server/ack/TxAckTest.java b/java/systests/src/main/java/org/apache/qpid/server/ack/TxAckTest.java
index 2bb16aff2e..aafddb810a 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/ack/TxAckTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/ack/TxAckTest.java
@@ -26,12 +26,16 @@ import org.apache.qpid.framing.AMQShortString;
 import org.apache.qpid.framing.ContentHeaderBody;
 import org.apache.qpid.framing.abstraction.MessagePublishInfo;
 import org.apache.qpid.server.RequiredDeliveryException;
-import org.apache.qpid.server.store.MemoryMessageStore;
+import org.apache.qpid.server.virtualhost.VirtualHost;
 import org.apache.qpid.server.queue.AMQMessage;
+import org.apache.qpid.server.queue.MessageHandleFactory;
 import org.apache.qpid.server.queue.QueueEntry;
-import org.apache.qpid.server.store.TestableMemoryMessageStore;
+import org.apache.qpid.server.queue.AMQMessageHandle;
+import org.apache.qpid.server.queue.AMQQueueFactory;
+import org.apache.qpid.server.queue.AMQQueue;
+import org.apache.qpid.server.store.TestMemoryMessageStore;
 import org.apache.qpid.server.store.StoreContext;
-import org.apache.qpid.server.store.TestableMemoryMessageStore;
+import org.apache.qpid.server.store.MemoryMessageStore;
 import org.apache.qpid.server.txn.NonTransactionalContext;
 import org.apache.qpid.server.txn.TransactionalContext;
 
@@ -99,12 +103,16 @@ public class TxAckTest extends TestCase
         private final List<Long> _unacked;
         private StoreContext _storeContext = new StoreContext();
 
-        Scenario(int messageCount, List<Long> acked, List<Long> unacked)
+        Scenario(int messageCount, List<Long> acked, List<Long> unacked) throws Exception
         {
-            TransactionalContext txnContext = new NonTransactionalContext(new MemoryMessageStore(),
+            TransactionalContext txnContext = new NonTransactionalContext(new TestMemoryMessageStore(),
                                                                           _storeContext, null,
                                                                           new LinkedList<RequiredDeliveryException>()
             );
+            AMQQueue queue =
+                    AMQQueueFactory.createAMQQueueImpl(new AMQShortString("test"), false, null, false, new VirtualHost("test", new MemoryMessageStore()),
+                                                       null);
+
             for (int i = 0; i < messageCount; i++)
             {
                 long deliveryTag = i + 1;
@@ -138,8 +146,8 @@ public class TxAckTest extends TestCase
                     }
                 };
 
-                TestMessage message = new TestMessage(deliveryTag, i, info, txnContext);
-                _map.add(deliveryTag, new UnacknowledgedMessage(new QueueEntry(null,message), null, deliveryTag, _map));
+                TestMessage message = new TestMessage(deliveryTag, i, info, txnContext.getStoreContext());
+                _map.add(deliveryTag, queue.enqueue(new StoreContext(), message));
             }
             _acked = acked;
             _unacked = unacked;
@@ -154,7 +162,7 @@ public class TxAckTest extends TestCase
         {
             for (long tag : tags)
             {
-                UnacknowledgedMessage u = _map.get(tag);
+                QueueEntry u = _map.get(tag);
                 assertTrue("Message not found for tag " + tag, u != null);
                 ((TestMessage) u.getMessage()).assertCountEquals(expected);
             }
@@ -175,7 +183,7 @@ public class TxAckTest extends TestCase
             _op.consolidate();
             _op.undoPrepare();
 
-            assertCount(_acked, 1); //DTX Changed to 0, but that is wrong msg 5 is acked!
+            assertCount(_acked, 1);
             assertCount(_unacked, 0);
         }
 
@@ -195,34 +203,50 @@ public class TxAckTest extends TestCase
         }
     }
 
+    private static AMQMessageHandle createMessageHandle(final long messageId, final MessagePublishInfo publishBody)
+    {
+        final AMQMessageHandle amqMessageHandle = (new MessageHandleFactory()).createMessageHandle(messageId,
+                                                                                                   null,
+                                                                                                   false);
+        try
+        {
+            amqMessageHandle.setPublishAndContentHeaderBody(new StoreContext(),
+                                                              publishBody,
+                                                              new ContentHeaderBody()
+            {
+                public int getSize()
+                {
+                    return 1;
+                }
+            });
+        }
+        catch (AMQException e)
+        {
+            // won't happen
+        }
+
+
+        return amqMessageHandle;
+    }
+
+
     private class TestMessage extends AMQMessage
     {
         private final long _tag;
         private int _count;
 
-        TestMessage(long tag, long messageId, MessagePublishInfo publishBody, TransactionalContext txnContext)
+        TestMessage(long tag, long messageId, MessagePublishInfo publishBody, StoreContext storeContext)
+                throws AMQException
         {
-            super(messageId, publishBody, txnContext);
-            try
-            {
-                setContentHeaderBody(new ContentHeaderBody()
-                {
-                    public int getSize()
-                    {
-                        return 1;
-                    }
-                });
-            }
-            catch (AMQException e)
-            {
-                // won't happen
-            }
+            super(createMessageHandle(messageId, publishBody), storeContext, publishBody);
             _tag = tag;
         }
 
-        public void incrementReference()
+
+        public boolean incrementReference()
         {
             _count++;
+            return true;
         }
 
         public void decrementReference(StoreContext context)
diff --git a/java/systests/src/main/java/org/apache/qpid/server/exchange/AbstractHeadersExchangeTestBase.java b/java/systests/src/main/java/org/apache/qpid/server/exchange/AbstractHeadersExchangeTestBase.java
index 0968f0c468..adb7a7cd0c 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/exchange/AbstractHeadersExchangeTestBase.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/exchange/AbstractHeadersExchangeTestBase.java
@@ -24,18 +24,17 @@ import junit.framework.TestCase;
 import org.apache.qpid.AMQException;
 import org.apache.qpid.framing.*;
 import org.apache.qpid.framing.abstraction.MessagePublishInfo;
-import org.apache.qpid.server.queue.AMQMessage;
-import org.apache.qpid.server.queue.AMQQueue;
-import org.apache.qpid.server.queue.MessageHandleFactory;
-import org.apache.qpid.server.queue.QueueEntry;
+import org.apache.qpid.server.queue.*;
 import org.apache.qpid.server.registry.ApplicationRegistry;
 import org.apache.qpid.server.store.MessageStore;
+import org.apache.qpid.server.store.SkeletonMessageStore;
 import org.apache.qpid.server.store.MemoryMessageStore;
 import org.apache.qpid.server.store.StoreContext;
-import org.apache.qpid.server.store.SkeletonMessageStore;
 import org.apache.qpid.server.txn.NonTransactionalContext;
 import org.apache.qpid.server.txn.TransactionalContext;
 import org.apache.qpid.server.RequiredDeliveryException;
+import org.apache.qpid.server.subscription.Subscription;
+import org.apache.qpid.server.protocol.AMQProtocolSession;
 import org.apache.log4j.Logger;
 
 import java.util.*;
@@ -50,7 +49,7 @@ public class AbstractHeadersExchangeTestBase extends TestCase
     /**
      * Not used in this test, just there to stub out the routing calls
      */
-    private MessageStore _store = new SkeletonMessageStore();
+    private MessageStore _store = new MemoryMessageStore();
 
     private StoreContext _storeContext = new StoreContext();
 
@@ -94,7 +93,11 @@ public class AbstractHeadersExchangeTestBase extends TestCase
     protected void route(Message m) throws AMQException
     {
         m.route(exchange);
-        m.routingComplete(_store, _storeContext, _handleFactory);
+        m.getIncomingMessage().routingComplete(_store, _handleFactory);
+        if(m.getIncomingMessage().allContentReceived())
+        {
+            m.getIncomingMessage().deliverToQueues();
+        }
     }
 
     protected void routeAndTest(Message m, TestQueue... expected) throws AMQException
@@ -122,12 +125,12 @@ public class AbstractHeadersExchangeTestBase extends TestCase
             {
                 if (expected.contains(q))
                 {
-                    assertTrue("Expected " + m + " to be delivered to " + q, m.isInQueue(q));
+                    assertTrue("Expected " + m + " to be delivered to " + q, q.isInQueue(m));
                     //assert m.isInQueue(q) : "Expected " + m + " to be delivered to " + q;
                 }
                 else
                 {
-                    assertFalse("Did not expect " + m + " to be delivered to " + q, m.isInQueue(q));
+                    assertFalse("Did not expect " + m + " to be delivered to " + q, q.isInQueue(m));
                     //assert !m.isInQueue(q) : "Did not expect " + m + " to be delivered to " + q;
                 }
             }
@@ -234,7 +237,7 @@ public class AbstractHeadersExchangeTestBase extends TestCase
         return properties;
     }
 
-    static class TestQueue extends AMQQueue
+    static class TestQueue extends SimpleAMQQueue
     {
         final List<HeadersExchangeTest.Message> messages = new ArrayList<HeadersExchangeTest.Message>();
 
@@ -248,13 +251,167 @@ public class AbstractHeadersExchangeTestBase extends TestCase
          * not invoked. It is unnecessary since for this test we only care to know whether the message was
          * sent to the queue; the queue processing logic is not being tested.
          * @param msg
-         * @param deliverFirst
          * @throws AMQException
          */
-        public void process(StoreContext context, QueueEntry msg, boolean deliverFirst) throws AMQException
+        @Override
+        public QueueEntry enqueue(StoreContext context, AMQMessage msg) throws AMQException
+        {
+            messages.add( new HeadersExchangeTest.Message(msg));
+            return new QueueEntry()
+            {
+
+                public AMQQueue getQueue()
+                {
+                    return null;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public AMQMessage getMessage()
+                {
+                    return null;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public long getSize()
+                {
+                    return 0;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public boolean getDeliveredToConsumer()
+                {
+                    return false;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public boolean expired() throws AMQException
+                {
+                    return false;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public boolean isAcquired()
+                {
+                    return false;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public boolean acquire()
+                {
+                    return false;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public boolean acquire(Subscription sub)
+                {
+                    return false;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public boolean delete()
+                {
+                    return false;
+                }
+
+                public boolean isDeleted()
+                {
+                    return false;
+                }
+
+                public boolean acquiredBySubscription()
+                {
+                    return false;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void setDeliveredToSubscription()
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void release()
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public String debugIdentity()
+                {
+                    return null;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public boolean immediateAndNotDelivered()
+                {
+                    return false;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void setRedelivered(boolean b)
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public Subscription getDeliveredSubscription()
+                {
+                    return null;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void reject()
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void reject(Subscription subscription)
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public boolean isRejectedBy(Subscription subscription)
+                {
+                    return false;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void requeue(StoreContext storeContext) throws AMQException
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void dequeue(final StoreContext storeContext) throws FailedDequeueException
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void dispose(final StoreContext storeContext) throws MessageCleanupException
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void restoreCredit()
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void discard(StoreContext storeContext) throws FailedDequeueException, MessageCleanupException
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public boolean isQueueDeleted()
+                {
+                    return false;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public void addStateChangeListener(StateChangeListener listener)
+                {
+                    //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public boolean removeStateChangeListener(StateChangeListener listener)
+                {
+                    return false;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+
+                public int compareTo(final QueueEntry o)
+                {
+                    return 0;  //To change body of implemented methods use File | Settings | File Templates.
+                }
+            };
+        }
+
+        boolean isInQueue(Message msg)
         {
-            messages.add(new HeadersExchangeTest.Message(msg.getMessage()));
+            return messages.contains(msg);
         }
+
     }
 
     /**
@@ -262,10 +419,44 @@ public class AbstractHeadersExchangeTestBase extends TestCase
      */
     static class Message extends AMQMessage
     {
-        private static MessageStore _messageStore = new MemoryMessageStore();
+        private class TestIncomingMessage extends IncomingMessage
+        {
+
+            public TestIncomingMessage(final long messageId,
+                                       final MessagePublishInfo info,
+                                       final TransactionalContext txnContext,
+                                       final AMQProtocolSession publisher)
+            {
+                super(messageId, info, txnContext, publisher);
+            }
+
+
+            public AMQMessage getUnderlyingMessage()
+            {
+                return Message.this;
+            }
+
+
+            public ContentHeaderBody getContentHeaderBody()
+            {
+                try
+                {
+                    return Message.this.getContentHeaderBody();
+                }
+                catch (AMQException e)
+                {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+
+        private IncomingMessage _incoming;
+
+        private static MessageStore _messageStore = new SkeletonMessageStore();
 
         private static StoreContext _storeContext = new StoreContext();
 
+
         private static TransactionalContext _txnContext = new NonTransactionalContext(_messageStore, _storeContext,
                                                                                       null,
                                                                          new LinkedList<RequiredDeliveryException>()
@@ -278,12 +469,47 @@ public class AbstractHeadersExchangeTestBase extends TestCase
 
         Message(String id, FieldTable headers) throws AMQException
         {
-            this(getPublishRequest(id), getContentHeader(headers), null);
+            this(_messageStore.getNewMessageId(),getPublishRequest(id), getContentHeader(headers), null);
+        }
+
+        public IncomingMessage getIncomingMessage()
+        {
+            return _incoming;
+        }
+
+        private Message(long messageId,
+                        MessagePublishInfo publish,
+                        ContentHeaderBody header,
+                        List<ContentBody> bodies) throws AMQException
+        {
+            super(createMessageHandle(messageId, publish, header), _txnContext.getStoreContext(), publish);
+
+
+            
+            _incoming = new TestIncomingMessage(getMessageId(),publish,_txnContext,new MockProtocolSession(_messageStore));
+            _incoming.setContentHeaderBody(header);
+
+
         }
 
-        private Message(MessagePublishInfo publish, ContentHeaderBody header, List<ContentBody> bodies) throws AMQException
+        private static AMQMessageHandle createMessageHandle(final long messageId,
+                                                            final MessagePublishInfo publish,
+                                                            final ContentHeaderBody header)
         {
-            super(_messageStore.getNewMessageId(), publish, _txnContext, header);
+
+            final AMQMessageHandle amqMessageHandle = (new MessageHandleFactory()).createMessageHandle(messageId,
+                                                                                                       _messageStore,
+                                                                                                       true);
+
+            try
+            {
+                amqMessageHandle.setPublishAndContentHeaderBody(new StoreContext(),publish,header);
+            }
+            catch (AMQException e)
+            {
+                
+            }
+            return amqMessageHandle;
         }
 
         private Message(AMQMessage msg) throws AMQException
@@ -291,15 +517,13 @@ public class AbstractHeadersExchangeTestBase extends TestCase
             super(msg);
         }
 
+
+
         void route(Exchange exchange) throws AMQException
         {
-            exchange.route(this);
+            exchange.route(_incoming);
         }
 
-        boolean isInQueue(TestQueue queue)
-        {
-            return queue.messages.contains(this);
-        }
 
         public int hashCode()
         {
diff --git a/java/systests/src/main/java/org/apache/qpid/server/exchange/HeadersExchangeTest.java b/java/systests/src/main/java/org/apache/qpid/server/exchange/HeadersExchangeTest.java
index eca642b556..fd11ddeae2 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/exchange/HeadersExchangeTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/exchange/HeadersExchangeTest.java
@@ -30,7 +30,12 @@ public class HeadersExchangeTest extends AbstractHeadersExchangeTestBase
     protected void setUp() throws Exception
     {
         super.setUp();
-        ApplicationRegistry.initialise(new NullApplicationRegistry());
+        ApplicationRegistry.initialise(new NullApplicationRegistry(), 1);
+    }
+
+    protected void tearDown()
+    {
+        ApplicationRegistry.remove(1);
     }
 
     public void testSimple() throws AMQException
diff --git a/java/systests/src/main/java/org/apache/qpid/server/exchange/ReturnUnroutableMandatoryMessageTest.java b/java/systests/src/main/java/org/apache/qpid/server/exchange/ReturnUnroutableMandatoryMessageTest.java
index bae3f844d7..e14efe03a7 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/exchange/ReturnUnroutableMandatoryMessageTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/exchange/ReturnUnroutableMandatoryMessageTest.java
@@ -29,13 +29,16 @@ import org.apache.qpid.client.*;
 import org.apache.qpid.client.transport.TransportConnection;
 import org.apache.qpid.url.AMQBindingURL;
 import org.apache.qpid.url.BindingURL;
+import org.apache.qpid.url.URLSyntaxException;
 import org.apache.qpid.exchange.ExchangeDefaults;
 import org.apache.qpid.framing.FieldTable;
+import org.apache.qpid.AMQException;
 
 import javax.jms.*;
 import java.util.List;
 import java.util.Collections;
 import java.util.ArrayList;
+import java.net.URISyntaxException;
 
 public class ReturnUnroutableMandatoryMessageTest extends TestCase implements ExceptionListener
 {
@@ -68,6 +71,7 @@ public class ReturnUnroutableMandatoryMessageTest extends TestCase implements Ex
     {
         super.tearDown();
         TransportConnection.killAllVMBrokers();
+        ApplicationRegistry.remove(1);
     }
 
     /**
@@ -75,78 +79,90 @@ public class ReturnUnroutableMandatoryMessageTest extends TestCase implements Ex
      *
      * @throws Exception
      */
-    public void testReturnUnroutableMandatoryMessage_HEADERS() throws Exception
+    public void testReturnUnroutableMandatoryMessage_HEADERS() throws URISyntaxException, AMQException, JMSException
     {
         _bouncedMessageList.clear();
-        Connection con = new AMQConnection(BROKER, "guest", "guest", "consumer1", VIRTUALHOST);
-
-
-        AMQSession consumerSession = (AMQSession) con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
-
-        AMQHeadersExchange queue = new AMQHeadersExchange(new AMQBindingURL(ExchangeDefaults.HEADERS_EXCHANGE_CLASS + "://" + ExchangeDefaults.HEADERS_EXCHANGE_NAME + "/test/queue1?" + BindingURL.OPTION_ROUTING_KEY + "='F0000=1'"));
-        FieldTable ft = new FieldTable();
-        ft.setString("F1000", "1");
-        MessageConsumer consumer = consumerSession.createConsumer(queue, AMQSession.DEFAULT_PREFETCH_LOW_MARK, AMQSession.DEFAULT_PREFETCH_HIGH_MARK, false, false, (String) null, ft);
-
-        //force synch to ensure the consumer has resulted in a bound queue
-        //((AMQSession) consumerSession).declareExchangeSynch(ExchangeDefaults.HEADERS_EXCHANGE_NAME, ExchangeDefaults.HEADERS_EXCHANGE_CLASS);
-        // This is the default now
-
-        Connection con2 = new AMQConnection(BROKER, "guest", "guest", "producer1", VIRTUALHOST);
-
-        con2.setExceptionListener(this);
-        AMQSession producerSession = (AMQSession) con2.createSession(false, Session.CLIENT_ACKNOWLEDGE);
-
-        // Need to start the "producer" connection in order to receive bounced messages
-        _logger.info("Starting producer connection");
-        con2.start();
-
+        MessageConsumer consumer = null;
+        AMQSession producerSession = null;
+        AMQHeadersExchange queue = null;
+        Connection con=null, con2 = null;
+        try
+        {
+            con = new AMQConnection(BROKER, "guest", "guest", "consumer1", VIRTUALHOST);
 
-        MessageProducer nonMandatoryProducer = producerSession.createProducer(queue, false, false);
-        MessageProducer mandatoryProducer = producerSession.createProducer(queue);
+            AMQSession consumerSession = (AMQSession) con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
 
-        // First test - should neither be bounced nor routed
-        _logger.info("Sending non-routable non-mandatory message");
-        TextMessage msg1 = producerSession.createTextMessage("msg1");
-        nonMandatoryProducer.send(msg1);
+            queue = new AMQHeadersExchange(new AMQBindingURL(ExchangeDefaults.HEADERS_EXCHANGE_CLASS + "://" + ExchangeDefaults.HEADERS_EXCHANGE_NAME + "/test/queue1?" + BindingURL.OPTION_ROUTING_KEY + "='F0000=1'"));
+            FieldTable ft = new FieldTable();
+            ft.setString("F1000", "1");
+            consumer = consumerSession.createConsumer(queue, AMQSession.DEFAULT_PREFETCH_LOW_MARK, AMQSession.DEFAULT_PREFETCH_HIGH_MARK, false, false, (String) null, ft);
 
-        // Second test - should be bounced
-        _logger.info("Sending non-routable mandatory message");
-        TextMessage msg2 = producerSession.createTextMessage("msg2");
-        mandatoryProducer.send(msg2);
+            //force synch to ensure the consumer has resulted in a bound queue
+            //((AMQSession) consumerSession).declareExchangeSynch(ExchangeDefaults.HEADERS_EXCHANGE_NAME, ExchangeDefaults.HEADERS_EXCHANGE_CLASS);
+            // This is the default now
 
-        // Third test - should be routed
-        _logger.info("Sending routable message");
-        TextMessage msg3 = producerSession.createTextMessage("msg3");
-        msg3.setStringProperty("F1000", "1");
-        mandatoryProducer.send(msg3);
+            con2 = new AMQConnection(BROKER, "guest", "guest", "producer1", VIRTUALHOST);
 
+            con2.setExceptionListener(this);
+            producerSession = (AMQSession) con2.createSession(false, Session.CLIENT_ACKNOWLEDGE);
 
-        _logger.info("Starting consumer connection");
-        con.start();
-        TextMessage tm = (TextMessage) consumer.receive(1000L);
-
-        assertTrue("No message routed to receiver", tm != null);
-        assertTrue("Wrong message routed to receiver: " + tm.getText(), "msg3".equals(tm.getText()));
+            // Need to start the "producer" connection in order to receive bounced messages
+            _logger.info("Starting producer connection");
+            con2.start();
+        }
+        catch (JMSException jmse)
+        {
+            fail(jmse.getMessage());
+        }
 
         try
         {
-            Thread.sleep(1000L);
+            MessageProducer nonMandatoryProducer = producerSession.createProducer(queue, false, false);
+            MessageProducer mandatoryProducer = producerSession.createProducer(queue);
+
+            // First test - should neither be bounced nor routed
+            _logger.info("Sending non-routable non-mandatory message");
+            TextMessage msg1 = producerSession.createTextMessage("msg1");
+            nonMandatoryProducer.send(msg1);
+
+            // Second test - should be bounced
+            _logger.info("Sending non-routable mandatory message");
+            TextMessage msg2 = producerSession.createTextMessage("msg2");
+            mandatoryProducer.send(msg2);
+
+            // Third test - should be routed
+            _logger.info("Sending routable message");
+            TextMessage msg3 = producerSession.createTextMessage("msg3");
+            msg3.setStringProperty("F1000", "1");
+            mandatoryProducer.send(msg3);
+
+            _logger.info("Starting consumer connection");
+            con.start();
+            TextMessage tm = (TextMessage) consumer.receive(1000L);
+
+            assertTrue("No message routed to receiver", tm != null);
+            assertTrue("Wrong message routed to receiver: " + tm.getText(), "msg3".equals(tm.getText()));
+
+            try
+            {
+                Thread.sleep(1000L);
+            }
+            catch (InterruptedException e)
+            {
+                ;
+            }
+
+            assertTrue("Wrong number of messages bounced (expect 1): " + _bouncedMessageList.size(), _bouncedMessageList.size() == 1);
+            Message m = _bouncedMessageList.get(0);
+            assertTrue("Wrong message bounced: " + m.toString(), m.toString().contains("msg2"));
         }
-        catch (InterruptedException e)
+        catch (JMSException jmse)
         {
-            ;
-        }
-
-        assertTrue("Wrong number of messages bounced (expect 1): " + _bouncedMessageList.size(), _bouncedMessageList.size() == 1);
-        Message m = _bouncedMessageList.get(0);
-        assertTrue("Wrong message bounced: " + m.toString(), m.toString().contains("msg2"));
-
 
+        }
         con.close();
         con2.close();
 
-
     }
 
     public void testReturnUnroutableMandatoryMessage_QUEUE() throws Exception
@@ -154,7 +170,6 @@ public class ReturnUnroutableMandatoryMessageTest extends TestCase implements Ex
         _bouncedMessageList.clear();
         Connection con = new AMQConnection(BROKER, "guest", "guest", "consumer1", VIRTUALHOST);
 
-
         AMQSession consumerSession = (AMQSession) con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
 
         AMQQueue valid_queue = new AMQQueue(ExchangeDefaults.DIRECT_EXCHANGE_CLASS, "testReturnUnroutableMandatoryMessage_QUEUE");
@@ -174,7 +189,6 @@ public class ReturnUnroutableMandatoryMessageTest extends TestCase implements Ex
         _logger.info("Starting producer connection");
         con2.start();
 
-
         MessageProducer nonMandatoryProducer = producerSession.createProducer(valid_queue, false, false);
         MessageProducer mandatoryProducer = producerSession.createProducer(invalid_queue);
 
@@ -188,7 +202,6 @@ public class ReturnUnroutableMandatoryMessageTest extends TestCase implements Ex
         TextMessage msg2 = producerSession.createTextMessage("msg2");
         mandatoryProducer.send(msg2);
 
-
         _logger.info("Starting consumer connection");
         con.start();
         TextMessage tm = (TextMessage) consumer.receive(1000L);
@@ -209,18 +222,15 @@ public class ReturnUnroutableMandatoryMessageTest extends TestCase implements Ex
         Message m = _bouncedMessageList.get(0);
         assertTrue("Wrong message bounced: " + m.toString(), m.toString().contains("msg2"));
 
-
         con.close();
         con2.close();
     }
 
-
     public void testReturnUnroutableMandatoryMessage_TOPIC() throws Exception
     {
         _bouncedMessageList.clear();
         Connection con = new AMQConnection(BROKER, "guest", "guest", "consumer1", VIRTUALHOST);
 
-
         AMQSession consumerSession = (AMQSession) con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
 
         AMQTopic valid_topic = new AMQTopic(ExchangeDefaults.TOPIC_EXCHANGE_CLASS, "test.Return.Unroutable.Mandatory.Message.TOPIC");
@@ -240,7 +250,6 @@ public class ReturnUnroutableMandatoryMessageTest extends TestCase implements Ex
         _logger.info("Starting producer connection");
         con2.start();
 
-
         MessageProducer nonMandatoryProducer = producerSession.createProducer(valid_topic, false, false);
         MessageProducer mandatoryProducer = producerSession.createProducer(invalid_topic);
 
@@ -254,7 +263,6 @@ public class ReturnUnroutableMandatoryMessageTest extends TestCase implements Ex
         TextMessage msg2 = producerSession.createTextMessage("msg2");
         mandatoryProducer.send(msg2);
 
-
         _logger.info("Starting consumer connection");
         con.start();
         TextMessage tm = (TextMessage) consumer.receive(1000L);
@@ -275,12 +283,10 @@ public class ReturnUnroutableMandatoryMessageTest extends TestCase implements Ex
         Message m = _bouncedMessageList.get(0);
         assertTrue("Wrong message bounced: " + m.toString(), m.toString().contains("msg2"));
 
-
         con.close();
         con2.close();
     }
 
-
     public static junit.framework.Test suite()
     {
         return new junit.framework.TestSuite(ReturnUnroutableMandatoryMessageTest.class);
@@ -293,7 +299,8 @@ public class ReturnUnroutableMandatoryMessageTest extends TestCase implements Ex
         try
         {
             linkedException = jmsException.getLinkedException();
-        } catch (Exception e)
+        }
+        catch (Exception e)
         {
             e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
         }
diff --git a/java/systests/src/main/java/org/apache/qpid/server/failure/HeapExhaustion.java b/java/systests/src/main/java/org/apache/qpid/server/failure/HeapExhaustion.java
index 012a983be5..22a1b119fa 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/failure/HeapExhaustion.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/failure/HeapExhaustion.java
@@ -22,7 +22,7 @@
 package org.apache.qpid.server.failure;
 
 import junit.framework.TestCase;
-import org.apache.qpid.testutil.QpidClientConnectionHelper;
+import org.apache.qpid.test.utils.QpidClientConnectionHelper;
 import org.apache.qpid.client.failover.FailoverException;
 import org.apache.qpid.AMQException;
 import org.apache.qpid.protocol.AMQConstant;
diff --git a/java/systests/src/main/java/org/apache/qpid/server/protocol/AMQProtocolSessionMBeanTest.java b/java/systests/src/main/java/org/apache/qpid/server/protocol/AMQProtocolSessionMBeanTest.java
index e4555e020e..8e7038eec3 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/protocol/AMQProtocolSessionMBeanTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/protocol/AMQProtocolSessionMBeanTest.java
@@ -28,16 +28,15 @@ import org.apache.qpid.AMQException;
 import org.apache.qpid.codec.AMQCodecFactory;
 import org.apache.qpid.framing.AMQShortString;
 import org.apache.qpid.server.AMQChannel;
+import org.apache.qpid.server.queue.AMQQueueFactory;
 import org.apache.qpid.server.queue.AMQQueue;
 import org.apache.qpid.server.registry.ApplicationRegistry;
 import org.apache.qpid.server.registry.IApplicationRegistry;
 import org.apache.qpid.server.store.MessageStore;
 import org.apache.qpid.server.store.SkeletonMessageStore;
-import org.apache.qpid.server.virtualhost.VirtualHost;
 
 import javax.management.JMException;
 
-
 /**
  * Test class to test MBean operations for AMQMinaProtocolSession.
  */
@@ -56,13 +55,12 @@ public class AMQProtocolSessionMBeanTest extends TestCase
         // check the channel count is correct
         int channelCount = _mbean.channels().size();
         assertTrue(channelCount == 1);
-        AMQQueue queue = new org.apache.qpid.server.queue.AMQQueue(new AMQShortString("testQueue_" + System.currentTimeMillis()),
+        AMQQueue queue = AMQQueueFactory.createAMQQueueImpl(new AMQShortString("testQueue_" + System.currentTimeMillis()),
                                                                    false,
                                                                    new AMQShortString("test"),
                                                                    true,
-                                                                   _protocolSession.getVirtualHost());
-        AMQChannel channel = new AMQChannel(_protocolSession, 2, _messageStore);
-	
+                                                                   _protocolSession.getVirtualHost(), null);
+        AMQChannel channel = new AMQChannel(_protocolSession,2, _messageStore);
         channel.setDefaultQueue(queue);
         _protocolSession.addChannel(channel);
         channelCount = _mbean.channels().size();
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/AckTest.java b/java/systests/src/main/java/org/apache/qpid/server/queue/AckTest.java
index 2416442b10..9c2932c5e2 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/queue/AckTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/queue/AckTest.java
@@ -23,24 +23,28 @@ package org.apache.qpid.server.queue;
 import junit.framework.TestCase;
 import org.apache.log4j.Logger;
 import org.apache.qpid.AMQException;
-import org.apache.qpid.framing.AMQShortString;
 import org.apache.qpid.framing.BasicContentHeaderProperties;
 import org.apache.qpid.framing.ContentHeaderBody;
+import org.apache.qpid.framing.AMQShortString;
 import org.apache.qpid.framing.abstraction.MessagePublishInfo;
 import org.apache.qpid.server.AMQChannel;
 import org.apache.qpid.server.RequiredDeliveryException;
-import org.apache.qpid.server.ack.UnacknowledgedMessage;
+import org.apache.qpid.server.subscription.Subscription;
+import org.apache.qpid.server.subscription.SubscriptionFactoryImpl;
+import org.apache.qpid.server.flow.LimitlessCreditManager;
+import org.apache.qpid.server.flow.Pre0_10CreditManager;
 import org.apache.qpid.server.ack.UnacknowledgedMessageMap;
 import org.apache.qpid.server.registry.ApplicationRegistry;
+import org.apache.qpid.server.store.TestMemoryMessageStore;
 import org.apache.qpid.server.store.StoreContext;
-import org.apache.qpid.server.store.TestableMemoryMessageStore;
 import org.apache.qpid.server.txn.NonTransactionalContext;
 import org.apache.qpid.server.txn.TransactionalContext;
 import org.apache.qpid.server.util.NullApplicationRegistry;
 
-import java.util.HashSet;
+import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.Set;
+import java.util.Collections;
 
 /**
  * Tests that acknowledgements are handled correctly.
@@ -49,37 +53,38 @@ public class AckTest extends TestCase
 {
     private static final Logger _log = Logger.getLogger(AckTest.class);
 
-    private SubscriptionImpl _subscription;
+    private Subscription _subscription;
 
     private MockProtocolSession _protocolSession;
 
-    private TestableMemoryMessageStore _messageStore;
+    private TestMemoryMessageStore _messageStore;
 
     private StoreContext _storeContext = new StoreContext();
 
     private AMQChannel _channel;
 
-    private SubscriptionSet _subscriptionManager;
-
     private AMQQueue _queue;
 
     private static final AMQShortString DEFAULT_CONSUMER_TAG = new AMQShortString("conTag");
 
-    public AckTest() throws Exception
-    {
-        ApplicationRegistry.initialise(new NullApplicationRegistry());
-    }
-
     protected void setUp() throws Exception
     {
         super.setUp();
-        _messageStore = new TestableMemoryMessageStore();
+        ApplicationRegistry.initialise(new NullApplicationRegistry(), 1);
+
+        _messageStore = new TestMemoryMessageStore();
         _protocolSession = new MockProtocolSession(_messageStore);
-        _channel = new AMQChannel(_protocolSession, 5, _messageStore);
+        _channel = new AMQChannel(_protocolSession,5, _messageStore /*dont need exchange registry*/);
 
         _protocolSession.addChannel(_channel);
-        _subscriptionManager = new SubscriptionSet();
-        _queue = new AMQQueue(new AMQShortString("myQ"), false, new AMQShortString("guest"), true, ApplicationRegistry.getInstance().getVirtualHostRegistry().getVirtualHost("test"), _subscriptionManager);
+
+        _queue = AMQQueueFactory.createAMQQueueImpl(new AMQShortString("myQ"), false, new AMQShortString("guest"), true, ApplicationRegistry.getInstance().getVirtualHostRegistry().getVirtualHost("test"),
+                                                    null);
+    }
+
+    protected void tearDown()
+    {
+        ApplicationRegistry.remove(1);
     }
 
     private void publishMessages(int count) throws AMQException
@@ -92,6 +97,7 @@ public class AckTest extends TestCase
         TransactionalContext txnContext = new NonTransactionalContext(_messageStore, _storeContext, null,
                                                                       new LinkedList<RequiredDeliveryException>()
         );
+        _queue.registerSubscription(_subscription,false);
         MessageHandleFactory factory = new MessageHandleFactory();
         for (int i = 1; i <= count; i++)
         {
@@ -125,7 +131,8 @@ public class AckTest extends TestCase
                     return new AMQShortString("rk");
                 }
             };
-            AMQMessage msg = new AMQMessage(_messageStore.getNewMessageId(), publishBody, txnContext);
+            IncomingMessage msg = new IncomingMessage(_messageStore.getNewMessageId(), publishBody, txnContext,_protocolSession);
+            //IncomingMessage msg2 = null;
             if (persistent)
             {
                 BasicContentHeaderProperties b = new BasicContentHeaderProperties();
@@ -142,10 +149,16 @@ public class AckTest extends TestCase
             // we increment the reference here since we are not delivering the messaging to any queues, which is where
             // the reference is normally incremented. The test is easier to construct if we have direct access to the
             // subscription
-            msg.incrementReference();
-            msg.routingComplete(_messageStore, _storeContext, factory);
+            ArrayList<AMQQueue> qs = new ArrayList<AMQQueue>();
+            qs.add(_queue);
+            msg.enqueue(qs);
+            msg.routingComplete(_messageStore, factory);
+            if(msg.allContentReceived())
+            {
+                msg.deliverToQueues();
+            }
             // we manually send the message to the subscription
-            _subscription.send(new QueueEntry(_queue,msg), _queue);
+            //_subscription.send(new QueueEntry(_queue,msg), _queue);
         }
     }
 
@@ -155,16 +168,13 @@ public class AckTest extends TestCase
      */
     public void testAckChannelAssociationTest() throws AMQException
     {
-        _subscription = new SubscriptionImpl(5, _protocolSession, DEFAULT_CONSUMER_TAG, true);
+        _subscription = SubscriptionFactoryImpl.INSTANCE.createSubscription(5, _protocolSession, DEFAULT_CONSUMER_TAG, true, null, false, new LimitlessCreditManager());
         final int msgCount = 10;
         publishMessages(msgCount, true);
 
         UnacknowledgedMessageMap map = _channel.getUnacknowledgedMessageMap();
         assertTrue(map.size() == msgCount);
         assertTrue(_messageStore.getMessageMetaDataMap().size() == msgCount);
-        
-        //DTX
-        //       assertTrue(_messageStore.getNumberStoredMessages() == msgCount);
 
         Set<Long> deliveryTagSet = map.getDeliveryTags();
         int i = 1;
@@ -172,15 +182,12 @@ public class AckTest extends TestCase
         {
             assertTrue(deliveryTag == i);
             i++;
-            UnacknowledgedMessage unackedMsg = map.get(deliveryTag);
+            QueueEntry unackedMsg = map.get(deliveryTag);
             assertTrue(unackedMsg.getQueue() == _queue);
         }
 
         assertTrue(map.size() == msgCount);
         assertTrue(_messageStore.getMessageMetaDataMap().size() == msgCount);
-        
-        //DTX
-//        assertTrue(_messageStore.getNumberStoredMessages() == msgCount);
     }
 
     /**
@@ -189,15 +196,32 @@ public class AckTest extends TestCase
     public void testNoAckMode() throws AMQException
     {
         // false arg means no acks expected
-        _subscription = new SubscriptionImpl(5, _protocolSession, DEFAULT_CONSUMER_TAG, false);
+        _subscription = SubscriptionFactoryImpl.INSTANCE.createSubscription(5, _protocolSession, DEFAULT_CONSUMER_TAG, false, null, false, new LimitlessCreditManager());
         final int msgCount = 10;
         publishMessages(msgCount);
 
         UnacknowledgedMessageMap map = _channel.getUnacknowledgedMessageMap();
         assertTrue(map.size() == 0);
         assertTrue(_messageStore.getMessageMetaDataMap().size() == 0);
-        //DTX MessageStore
-//        assertTrue(_messageStore.getNumberStoredMessages() == 0);
+        assertTrue(_messageStore.getContentBodyMap().size() == 0);
+
+    }
+
+    /**
+     * Tests that in no-ack mode no messages are retained
+     */
+    public void testPersistentNoAckMode() throws AMQException
+    {
+        // false arg means no acks expected
+        _subscription = SubscriptionFactoryImpl.INSTANCE.createSubscription(5, _protocolSession, DEFAULT_CONSUMER_TAG, false,null,false, new LimitlessCreditManager());
+        final int msgCount = 10;
+        publishMessages(msgCount, true);
+
+        UnacknowledgedMessageMap map = _channel.getUnacknowledgedMessageMap();
+        assertTrue(map.size() == 0);
+        assertTrue(_messageStore.getMessageMetaDataMap().size() == 0);
+        assertTrue(_messageStore.getContentBodyMap().size() == 0);
+
     }
 
     /**
@@ -206,7 +230,7 @@ public class AckTest extends TestCase
      */
     public void testSingleAckReceivedTest() throws AMQException
     {
-        _subscription = new SubscriptionImpl(5, _protocolSession, DEFAULT_CONSUMER_TAG, true);
+        _subscription = SubscriptionFactoryImpl.INSTANCE.createSubscription(5, _protocolSession, DEFAULT_CONSUMER_TAG, true,null,false, new LimitlessCreditManager());
         final int msgCount = 10;
         publishMessages(msgCount);
 
@@ -219,7 +243,7 @@ public class AckTest extends TestCase
         for (long deliveryTag : deliveryTagSet)
         {
             assertTrue(deliveryTag == i);
-            UnacknowledgedMessage unackedMsg = map.get(deliveryTag);
+            QueueEntry unackedMsg = map.get(deliveryTag);
             assertTrue(unackedMsg.getQueue() == _queue);
             // 5 is the delivery tag of the message that *should* be removed
             if (++i == 5)
@@ -235,7 +259,7 @@ public class AckTest extends TestCase
      */
     public void testMultiAckReceivedTest() throws AMQException
     {
-        _subscription = new SubscriptionImpl(5, _protocolSession, DEFAULT_CONSUMER_TAG, true);
+        _subscription = SubscriptionFactoryImpl.INSTANCE.createSubscription(5, _protocolSession, DEFAULT_CONSUMER_TAG, true,null,false, new LimitlessCreditManager());
         final int msgCount = 10;
         publishMessages(msgCount);
 
@@ -248,7 +272,7 @@ public class AckTest extends TestCase
         for (long deliveryTag : deliveryTagSet)
         {
             assertTrue(deliveryTag == i + 5);
-            UnacknowledgedMessage unackedMsg = map.get(deliveryTag);
+            QueueEntry unackedMsg = map.get(deliveryTag);
             assertTrue(unackedMsg.getQueue() == _queue);
             ++i;
         }
@@ -259,7 +283,7 @@ public class AckTest extends TestCase
      */
     public void testMultiAckAllReceivedTest() throws AMQException
     {
-        _subscription = new SubscriptionImpl(5, _protocolSession, DEFAULT_CONSUMER_TAG, true);
+        _subscription = SubscriptionFactoryImpl.INSTANCE.createSubscription(5, _protocolSession, DEFAULT_CONSUMER_TAG, true,null,false, new LimitlessCreditManager());
         final int msgCount = 10;
         publishMessages(msgCount);
 
@@ -272,18 +296,44 @@ public class AckTest extends TestCase
         for (long deliveryTag : deliveryTagSet)
         {
             assertTrue(deliveryTag == i + 5);
-            UnacknowledgedMessage unackedMsg = map.get(deliveryTag);
+            QueueEntry unackedMsg = map.get(deliveryTag);
             assertTrue(unackedMsg.getQueue() == _queue);
             ++i;
         }
     }
 
+            /**
+     * A regression fixing QPID-1136 showed this up
+     *
+     * @throws Exception
+     */
+    public void testMessageDequeueRestoresCreditTest() throws Exception
+    {
+        // Send 10 messages
+        Pre0_10CreditManager creditManager = new Pre0_10CreditManager(0l, 1);
+
+        _subscription = SubscriptionFactoryImpl.INSTANCE.createSubscription(5, _protocolSession,
+                                                                            DEFAULT_CONSUMER_TAG, true, null, false, creditManager);
+        final int msgCount = 1;
+        publishMessages(msgCount);
+
+        _queue.deliverAsync(_subscription);
+
+        _channel.acknowledgeMessage(1, false);
+
+        // Check credit available
+        assertTrue("No credit available", creditManager.hasCredit());
+
+    }
+
+
+/*
     public void testPrefetchHighLow() throws AMQException
     {
         int lowMark = 5;
         int highMark = 10;
 
-        _subscription = new SubscriptionImpl(5, _protocolSession, DEFAULT_CONSUMER_TAG, true);
+        _subscription = SubscriptionFactoryImpl.INSTANCE.createSubscription(5, _protocolSession, DEFAULT_CONSUMER_TAG, true,null,false, new LimitlessCreditManager());
         _channel.setPrefetchLowMarkCount(lowMark);
         _channel.setPrefetchHighMarkCount(highMark);
 
@@ -332,10 +382,12 @@ public class AckTest extends TestCase
         assertTrue(map.size() == 0);
     }
 
+*/
+/*
     public void testPrefetch() throws AMQException
     {
-        _subscription = new SubscriptionImpl(5, _protocolSession, DEFAULT_CONSUMER_TAG, true);
-        _channel.setPrefetchCount(5);
+        _subscription = SubscriptionFactoryImpl.INSTANCE.createSubscription(5, _protocolSession, DEFAULT_CONSUMER_TAG, true,null,false, new LimitlessCreditManager());
+        _channel.setMessageCredit(5);
 
         assertTrue(_channel.getPrefetchCount() == 5);
 
@@ -360,6 +412,7 @@ public class AckTest extends TestCase
         assertTrue(map.size() == 0);
     }
 
+*/
     public static junit.framework.Test suite()
     {
         return new junit.framework.TestSuite(AckTest.class);
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/ConcurrencyTestDisabled.java b/java/systests/src/main/java/org/apache/qpid/server/queue/ConcurrencyTestDisabled.java
deleted file mode 100644
index 4f92cc94b7..0000000000
--- a/java/systests/src/main/java/org/apache/qpid/server/queue/ConcurrencyTestDisabled.java
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
- *
- * 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.server.queue;
-
-import org.apache.qpid.AMQException;
-import org.apache.qpid.framing.AMQShortString;
-import org.apache.qpid.server.handler.OnCurrentThreadExecutor;
-import org.apache.qpid.server.registry.IApplicationRegistry;
-import org.apache.qpid.server.registry.ApplicationRegistry;
-import org.apache.qpid.server.virtualhost.VirtualHost;
-
-import java.util.*;
-import java.util.concurrent.Executor;
-
-/**
- * Tests delivery in the face of concurrent incoming _messages, subscription alterations
- * and attempts to asynchronously process queued _messages.
- */
-public class ConcurrencyTestDisabled extends MessageTestHelper
-{
-    private final Random random = new Random();
-
-    private final int numMessages = 10;
-
-    private final List<SubscriptionTestHelper> _subscribers = new ArrayList<SubscriptionTestHelper>();
-    private final Set<Subscription> _active = new HashSet<Subscription>();
-    private final List<QueueEntry> _messages = new ArrayList<QueueEntry>();
-    private int next = 0;//index to next message to send
-    private final List<QueueEntry> _received = Collections.synchronizedList(new ArrayList<QueueEntry>());
-    private final Executor _executor = new OnCurrentThreadExecutor();
-    private final List<Thread> _threads = new ArrayList<Thread>();
-
-    private final SubscriptionSet _subscriptionMgr = new SubscriptionSet();
-    private final DeliveryManager _deliveryMgr;
-
-    private boolean isComplete;
-    private boolean failed;
-    private VirtualHost _virtualHost;
-
-    public ConcurrencyTestDisabled() throws Exception
-    {
-
-        IApplicationRegistry applicationRegistry = ApplicationRegistry.getInstance();
-        _virtualHost = applicationRegistry.getVirtualHostRegistry().getVirtualHost("test");
-        _deliveryMgr = new ConcurrentSelectorDeliveryManager(_subscriptionMgr, new AMQQueue(new AMQShortString("myQ"), false, new AMQShortString("guest"), false,
-                                                                          _virtualHost));
-    }
-
-    public void testConcurrent1() throws InterruptedException, AMQException
-    {
-        initSubscriptions(10);
-        initMessages(numMessages);
-        initThreads(1, 4, 4, 4);
-        doRun();
-        check();
-    }
-
-    public void testConcurrent2() throws InterruptedException, AMQException
-    {
-        initSubscriptions(10);
-        initMessages(numMessages);
-        initThreads(4, 2, 2, 2);
-        doRun();
-        check();
-    }
-
-    void check()
-    {
-        assertFalse("Failed", failed);
-
-        _deliveryMgr.processAsync(_executor);
-
-        assertEquals("Did not recieve the correct number of messages", _messages.size(), _received.size());
-        for(int i = 0; i < _messages.size(); i++)
-        {
-            assertEquals("Wrong message at " + i, _messages.get(i), _received.get(i));
-        }
-    }
-
-    void initSubscriptions(int subscriptions)
-    {
-        for(int i = 0; i < subscriptions; i++)
-        {
-            _subscribers.add(new SubscriptionTestHelper("Subscriber" + i, _received));
-        }
-    }
-
-    void initMessages(int messages) throws AMQException
-    {
-        for(int i = 0; i < messages; i++)
-        {
-            _messages.add(message());
-        }
-    }
-
-    void initThreads(int senders, int subscribers, int suspenders, int processors)
-    {
-        addThreads(senders, senders == 1 ? new Sender() : new OrderedSender());
-        addThreads(subscribers, new Subscriber());
-        addThreads(suspenders, new Suspender());
-        addThreads(processors, new Processor());
-    }
-
-    void addThreads(int count, Runnable runner)
-    {
-        for(int i = 0; i < count; i++)
-        {
-            _threads.add(new Thread(runner, runner.toString()));
-        }
-    }
-
-    void doRun() throws InterruptedException
-    {
-        for(Thread t : _threads)
-        {
-            t.start();
-        }
-
-        for(Thread t : _threads)
-        {
-            t.join();
-        }
-    }
-
-    private void toggle(Subscription s)
-    {
-        synchronized (_active)
-        {
-            if (_active.contains(s))
-            {
-                _active.remove(s);
-                Subscription result = _subscriptionMgr.removeSubscriber(s);
-                assertTrue("Removed subscription " + result + " but trying to remove subscription " + s,
-                        result != null && result.equals(s));
-            }
-            else
-            {
-                _active.add(s);
-                _subscriptionMgr.addSubscriber(s);
-            }
-        }
-    }
-
-    private QueueEntry nextMessage()
-    {
-        synchronized (_messages)
-        {
-            if (next < _messages.size())
-            {
-                return _messages.get(next++);
-            }
-            else
-            {
-                if (!_deliveryMgr.hasQueuedMessages()) {
-                    isComplete = true;
-                }
-                return null;
-            }
-        }
-    }
-
-    private boolean randomBoolean()
-    {
-        return random.nextBoolean();
-    }
-
-    private SubscriptionTestHelper randomSubscriber()
-    {
-        return _subscribers.get(random.nextInt(_subscribers.size()));
-    }
-
-    private class Sender extends Runner
-    {
-        void doRun() throws Throwable
-        {
-            QueueEntry msg = nextMessage();
-            if (msg != null)
-            {
-                _deliveryMgr.deliver(null, new AMQShortString(toString()), msg, false);
-            }
-        }
-    }
-
-    private class OrderedSender extends Sender
-    {
-        synchronized void doRun() throws Throwable
-        {
-            super.doRun();
-        }
-    }
-
-    private class Suspender extends Runner
-    {
-        void doRun() throws Throwable
-        {
-            randomSubscriber().setSuspended(randomBoolean());
-        }
-    }
-
-    private class Subscriber extends Runner
-    {
-        void doRun() throws Throwable
-        {
-            toggle(randomSubscriber());
-        }
-    }
-
-    private class Processor extends Runner
-    {
-        void doRun() throws Throwable
-        {
-            _deliveryMgr.processAsync(_executor);
-        }
-    }
-
-    private abstract class Runner implements Runnable
-    {
-        public void run()
-        {
-            try
-            {
-                while (!stop())
-                {
-                    doRun();
-                }
-            }
-            catch (Throwable t)
-            {
-                failed = true;
-                t.printStackTrace();
-            }
-        }
-
-        abstract void doRun() throws Throwable;
-
-        boolean stop()
-        {
-            return isComplete || failed;
-        }
-    }
-
-    public static junit.framework.Test suite()
-    {
-        return new junit.framework.TestSuite(ConcurrencyTestDisabled.class);
-    }
-
-}
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/DeliveryManagerTest.java b/java/systests/src/main/java/org/apache/qpid/server/queue/DeliveryManagerTest.java
deleted file mode 100644
index b33259cfba..0000000000
--- a/java/systests/src/main/java/org/apache/qpid/server/queue/DeliveryManagerTest.java
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- *
- * 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.server.queue;
-
-import org.apache.qpid.server.handler.OnCurrentThreadExecutor;
-import org.apache.qpid.server.store.StoreContext;
-import org.apache.qpid.AMQException;
-import org.apache.qpid.framing.AMQShortString;
-
-import junit.framework.TestSuite;
-
-abstract public class DeliveryManagerTest extends MessageTestHelper
-{
-    protected final SubscriptionSet _subscriptions = new SubscriptionSet();
-    protected DeliveryManager _mgr;
-    protected StoreContext _storeContext = new StoreContext();
-    private static final AMQShortString DEFAULT_QUEUE_NAME = new AMQShortString("Me");
-
-    public DeliveryManagerTest() throws Exception
-    {
-    }
-
-    public void testStartInQueueingMode() throws AMQException
-    {
-        QueueEntry[] messages = new QueueEntry[10];
-        for (int i = 0; i < messages.length; i++)
-        {
-            messages[i] = message();
-        }
-        int batch = messages.length / 2;
-
-        for (int i = 0; i < batch; i++)
-        {
-            _mgr.deliver(_storeContext, DEFAULT_QUEUE_NAME, messages[i], false);
-        }
-
-        SubscriptionTestHelper s1 = new SubscriptionTestHelper("1");
-        SubscriptionTestHelper s2 = new SubscriptionTestHelper("2");
-        _subscriptions.addSubscriber(s1);
-        _subscriptions.addSubscriber(s2);
-
-        for (int i = batch; i < messages.length; i++)
-        {
-            _mgr.deliver(_storeContext, DEFAULT_QUEUE_NAME, messages[i], false);
-        }
-
-        assertTrue(s1.getMessages().isEmpty());
-        assertTrue(s2.getMessages().isEmpty());
-
-        _mgr.processAsync(new OnCurrentThreadExecutor());
-
-        assertEquals(messages.length / 2, s1.getMessages().size());
-        assertEquals(messages.length / 2, s2.getMessages().size());
-
-        for (int i = 0; i < messages.length; i++)
-        {
-            if (i % 2 == 0)
-            {
-                assertTrue(s1.getMessages().get(i / 2) == messages[i]);
-            }
-            else
-            {
-                assertTrue(s2.getMessages().get(i / 2) == messages[i]);
-            }
-        }
-    }
-
-    public void testStartInDirectMode() throws AMQException
-    {
-        QueueEntry[] messages = new QueueEntry[10];
-        for (int i = 0; i < messages.length; i++)
-        {
-            messages[i] = message();
-        }
-        int batch = messages.length / 2;
-
-        SubscriptionTestHelper s1 = new SubscriptionTestHelper("1");
-        _subscriptions.addSubscriber(s1);
-
-        for (int i = 0; i < batch; i++)
-        {
-            _mgr.deliver(_storeContext, DEFAULT_QUEUE_NAME, messages[i], false);
-        }
-
-        assertEquals(batch, s1.getMessages().size());
-        for (int i = 0; i < batch; i++)
-        {
-            assertTrue(messages[i] == s1.getMessages().get(i));
-        }
-        s1.getMessages().clear();
-        assertEquals(0, s1.getMessages().size());
-
-        s1.setSuspended(true);
-        for (int i = batch; i < messages.length; i++)
-        {
-            _mgr.deliver(_storeContext, DEFAULT_QUEUE_NAME, messages[i], false);
-        }
-
-        _mgr.processAsync(new OnCurrentThreadExecutor());
-        assertEquals(0, s1.getMessages().size());
-        s1.setSuspended(false);
-
-        _mgr.processAsync(new OnCurrentThreadExecutor());
-        assertEquals(messages.length - batch, s1.getMessages().size());
-
-        for (int i = batch; i < messages.length; i++)
-        {
-            assertTrue(messages[i] == s1.getMessages().get(i - batch));
-        }
-
-    }
-
-    public void testNoConsumers() throws AMQException
-    {
-        try
-        {
-            QueueEntry msg = message(true);
-            _mgr.deliver(_storeContext, DEFAULT_QUEUE_NAME, msg, false);
-            msg.checkDeliveredToConsumer();
-            fail("expected exception did not occur");
-        }
-        catch (NoConsumersException m)
-        {
-            // ok
-        }
-        catch (Exception e)
-        {
-            fail("expected NoConsumersException, got " + e);
-        }
-    }
-
-    public void testNoActiveConsumers() throws AMQException
-    {
-        try
-        {
-            SubscriptionTestHelper s = new SubscriptionTestHelper("A");
-            _subscriptions.addSubscriber(s);
-            s.setSuspended(true);
-            QueueEntry msg = message(true);
-            _mgr.deliver(_storeContext, DEFAULT_QUEUE_NAME, msg, false);
-            msg.checkDeliveredToConsumer();
-            fail("expected exception did not occur");
-        }
-        catch (NoConsumersException m)
-        {
-            // ok
-        }
-        catch (Exception e)
-        {
-            fail("expected NoConsumersException, got " + e);
-        }
-    }
-
-    public static junit.framework.Test suite()
-    {
-        TestSuite suite = new TestSuite();
-        return suite;
-    }
-}
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/MessageTestHelper.java b/java/systests/src/main/java/org/apache/qpid/server/queue/MessageTestHelper.java
index 114c8cac32..b2a4216f8d 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/queue/MessageTestHelper.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/queue/MessageTestHelper.java
@@ -24,7 +24,7 @@ import org.apache.qpid.framing.ContentHeaderBody;
 import org.apache.qpid.framing.AMQShortString;
 import org.apache.qpid.framing.abstraction.MessagePublishInfo;
 import org.apache.qpid.server.store.MessageStore;
-import org.apache.qpid.server.store.MemoryMessageStore;
+import org.apache.qpid.server.store.SkeletonMessageStore;
 import org.apache.qpid.server.store.StoreContext;
 import org.apache.qpid.server.registry.ApplicationRegistry;
 import org.apache.qpid.server.util.NullApplicationRegistry;
@@ -39,7 +39,7 @@ import java.util.LinkedList;
 
 class MessageTestHelper extends TestCase
 {
-    private final MessageStore _messageStore = new MemoryMessageStore();
+    private final MessageStore _messageStore = new SkeletonMessageStore();
 
     private final StoreContext _storeContext = new StoreContext();
 
@@ -52,12 +52,12 @@ class MessageTestHelper extends TestCase
         ApplicationRegistry.initialise(new NullApplicationRegistry());
     }
 
-    QueueEntry message() throws AMQException
+    QueueEntryImpl message() throws AMQException
     {
         return message(false);
     }
 
-    QueueEntry message(final boolean immediate) throws AMQException
+    QueueEntryImpl message(final boolean immediate) throws AMQException
     {
         MessagePublishInfo publish = new MessagePublishInfo()
         {
@@ -87,9 +87,16 @@ class MessageTestHelper extends TestCase
                 return null;
             }
         };
-                              
-        return new QueueEntry(null,new AMQMessage(_messageStore.getNewMessageId(), publish, _txnContext,
-                              new ContentHeaderBody()));
+
+        //public AMQMessage(Long messageId, AMQMessageHandle messageHandle , TransactionalContext txnConext, MessagePublishInfo info)
+        long messageId = _messageStore.getNewMessageId();
+        final AMQMessageHandle messageHandle =
+                (new MessageHandleFactory()).createMessageHandle(messageId, _messageStore, false);
+        messageHandle.setPublishAndContentHeaderBody(new StoreContext(),publish,new ContentHeaderBody());
+        AMQMessage msg = new AMQMessage(messageHandle, _txnContext.getStoreContext(), publish);
+        
+
+        return new QueueEntryImpl(null,msg, Long.MIN_VALUE);
     }
 
 }
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/MockProtocolSession.java b/java/systests/src/main/java/org/apache/qpid/server/queue/MockProtocolSession.java
index cf986e7803..99c88fac3e 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/queue/MockProtocolSession.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/queue/MockProtocolSession.java
@@ -21,6 +21,7 @@
 package org.apache.qpid.server.queue;
 
 import org.apache.qpid.AMQException;
+import org.apache.qpid.AMQConnectionException;
 import org.apache.qpid.framing.*;
 import org.apache.qpid.server.AMQChannel;
 import org.apache.qpid.server.output.ProtocolOutputConverter;
@@ -28,6 +29,7 @@ import org.apache.qpid.server.output.ProtocolOutputConverterRegistry;
 import org.apache.qpid.server.virtualhost.VirtualHost;
 import org.apache.qpid.server.protocol.AMQProtocolSession;
 import org.apache.qpid.server.store.MessageStore;
+import org.apache.qpid.transport.Sender;
 
 import javax.security.sasl.SaslServer;
 import java.util.HashMap;
@@ -117,6 +119,10 @@ public class MockProtocolSession implements AMQProtocolSession
     {
     }
 
+    public void closeConnection(int channelId, AMQConnectionException e, boolean closeIoSession) throws AMQException
+    {        
+    }
+
     public Object getKey()
     {
         return null;
@@ -215,6 +221,11 @@ public class MockProtocolSession implements AMQProtocolSession
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
+    public ProtocolSessionIdentifier getSessionIdentifier()
+    {
+        return null;
+    }
+
     public byte getProtocolMajorVersion()
     {
         return getProtocolVersion().getMajorVersion();
@@ -236,4 +247,16 @@ public class MockProtocolSession implements AMQProtocolSession
     {
         return null;  //To change body of implemented methods use File | Settings | File Templates.
     }
+
+    public void setSender(Sender<java.nio.ByteBuffer> sender)
+    {
+        // FIXME AS TODO
+        
+    }
+
+    public void init()
+    {
+        // TODO Auto-generated method stub
+        
+    }
 }
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/PriorityTest.java b/java/systests/src/main/java/org/apache/qpid/server/queue/PriorityTest.java
new file mode 100644
index 0000000000..0dbf95052f
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/server/queue/PriorityTest.java
@@ -0,0 +1,176 @@
+/*
+*
+* 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.server.queue;
+
+import junit.framework.TestCase;
+import junit.framework.Assert;
+import org.apache.log4j.Logger;
+import org.apache.qpid.client.transport.TransportConnection;
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQDestination;
+import org.apache.qpid.jndi.PropertiesFileInitialContextFactory;
+import org.apache.qpid.url.URLSyntaxException;
+import org.apache.qpid.AMQException;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.framing.FieldTable;
+
+import javax.jms.*;
+import javax.naming.NamingException;
+import javax.naming.Context;
+import javax.naming.spi.InitialContextFactory;
+import java.util.Hashtable;
+import java.util.HashMap;
+import java.util.Map;
+
+/** Test Case provided by client Non-functional Test NF101: heap exhaustion behaviour */
+public class PriorityTest extends TestCase
+{
+    private static final Logger _logger = Logger.getLogger(PriorityTest.class);
+
+
+    protected final String BROKER = "vm://:1";
+    protected final String VHOST = "/test";
+    protected final String QUEUE = "PriorityQueue";
+
+
+    private static final int MSG_COUNT = 50;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+
+        if (usingInVMBroker())
+        {
+            TransportConnection.createVMBroker(1);
+        }
+
+
+    }
+
+    private boolean usingInVMBroker()
+    {
+        return BROKER.startsWith("vm://");
+    }
+
+    protected void tearDown() throws Exception
+    {
+        if (usingInVMBroker())
+        {
+            TransportConnection.killAllVMBrokers();
+        }
+        super.tearDown();
+    }
+
+    public void testPriority() throws JMSException, NamingException, AMQException
+    {
+        InitialContextFactory factory = new PropertiesFileInitialContextFactory();
+
+        Hashtable<String, String> env = new Hashtable<String, String>();
+
+        env.put("connectionfactory.connection", "amqp://guest:guest@PRIORITY_TEST_ID" + VHOST + "?brokerlist='" + BROKER + "'");
+        env.put("queue.queue", QUEUE);
+
+        Context context = factory.getInitialContext(env);
+
+        Connection producerConnection = ((ConnectionFactory) context.lookup("connection")).createConnection();
+
+        Session producerSession = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        final Map<String,Object> arguments = new HashMap<String, Object>();
+        arguments.put("x-qpid-priorities",10);
+
+        ((AMQSession) producerSession).createQueue(new AMQShortString(QUEUE), true, false, false, arguments);
+
+        Queue queue = new AMQQueue("amq.direct",QUEUE);
+
+        ((AMQSession) producerSession).declareAndBind((AMQDestination)queue);
+
+
+
+
+
+
+        producerConnection.start();
+
+
+        MessageProducer producer = producerSession.createProducer(queue);
+
+
+
+
+
+        for (int msg = 0; msg < MSG_COUNT; msg++)
+        {
+            producer.setPriority(msg % 10);
+            producer.send(nextMessage(msg, false, producerSession, producer));
+        }
+
+        producer.close();
+        producerSession.close();
+        producerConnection.close();
+
+
+        Connection consumerConnection = ((ConnectionFactory) context.lookup("connection")).createConnection();
+        Session consumerSession = consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+        MessageConsumer consumer = consumerSession.createConsumer(queue);
+
+
+
+
+        consumerConnection.start();
+
+        Message received;
+        //Receive Message 0
+        StringBuilder buf = new StringBuilder();
+        int receivedCount = 0;
+        Message previous = null;
+        int messageCount = 0;
+        while((received = consumer.receive(1000))!=null)
+        {   
+            messageCount++;
+            if(previous != null)
+            {
+                assertTrue("Messages arrived in unexpected order " + messageCount + " " + previous.getIntProperty("msg") + " " + received.getIntProperty("msg") + " " + previous.getJMSPriority() + " " + received.getJMSPriority(), (previous.getJMSPriority() > received.getJMSPriority()) || ((previous.getJMSPriority() == received.getJMSPriority()) && previous.getIntProperty("msg") < received.getIntProperty("msg")) );
+            }
+
+            previous = received;
+            receivedCount++;
+        }
+
+        assertEquals("Incorrect number of message received", 50, receivedCount);
+
+        producerSession.close();
+        producer.close();
+
+    }
+
+    private Message nextMessage(int msg, boolean first, Session producerSession, MessageProducer producer) throws JMSException
+    {
+        Message send = producerSession.createTextMessage("Message: " + msg);
+        send.setIntProperty("msg", msg);
+
+        return send;
+    }
+
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/QueueDepthWithSelectorTest.java b/java/systests/src/main/java/org/apache/qpid/server/queue/QueueDepthWithSelectorTest.java
index f82fec61b0..280d897852 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/queue/QueueDepthWithSelectorTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/queue/QueueDepthWithSelectorTest.java
@@ -81,14 +81,6 @@ public class QueueDepthWithSelectorTest extends TestCase
         System.err.println("_logger.isDebug:" + _logger.isDebugEnabled() + ":" + _logger.isEnabledFor(Level.DEBUG));
         System.err.println("_logger.isTrace:" + _logger.isTraceEnabled() + ":" + _logger.isEnabledFor(Level.TRACE));
 
-        Logger csdm = Logger.getLogger(ConcurrentSelectorDeliveryManager.class);
-        System.err.println("csdm.isE-Error:" + csdm.isEnabledFor(Level.ERROR));
-        System.err.println("csdm.isE-Warn:" + csdm.isEnabledFor(Level.WARN));
-        System.err.println("csdm.isInfo:" + csdm.isInfoEnabled() + ":" + csdm.isEnabledFor(Level.INFO));
-        System.err.println("csdm.isDebug:" + csdm.isDebugEnabled() + ":" + csdm.isEnabledFor(Level.DEBUG));
-        System.err.println("csdm.isTrace:" + csdm.isTraceEnabled() + ":" + csdm.isEnabledFor(Level.TRACE));
-
-
         System.err.println(Logger.getRootLogger().getLoggerRepository());
 
         if (BROKER.startsWith("vm://"))
@@ -184,9 +176,14 @@ public class QueueDepthWithSelectorTest extends TestCase
 
         try
         {
+            Thread.sleep(2000);
             long queueDepth = ((AMQSession) _clientSession).getQueueDepth((AMQDestination) _context.lookup("queue"));
             assertEquals("Session reports Queue depth not as expected", 0, queueDepth);
         }
+        catch (InterruptedException e)
+        {
+            fail(e.getMessage());
+        }
         catch (NamingException e)
         {
             fail(e.getMessage());
@@ -209,7 +206,7 @@ public class QueueDepthWithSelectorTest extends TestCase
 
     }
 
-    private void verifyAllMessagesRecevied() throws JMSException
+    private void verifyAllMessagesRecevied() throws Exception
     {
 
         boolean[] msgIdRecevied = new boolean[MSG_COUNT];
@@ -219,6 +216,8 @@ public class QueueDepthWithSelectorTest extends TestCase
             _messages[i] = _consumer.receive(1000);
             assertNotNull("should have received a message but didn't", _messages[i]);
         }
+        long queueDepth = ((AMQSession) _clientSession).getQueueDepth((AMQDestination) _context.lookup("queue"));
+        assertEquals("Session reports Queue depth not as expected", 0, queueDepth);
 
         //Check received messages
         int msgId = 0;
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/SubscriptionManagerTest.java b/java/systests/src/main/java/org/apache/qpid/server/queue/SubscriptionManagerTest.java
deleted file mode 100644
index d3ec3c11d4..0000000000
--- a/java/systests/src/main/java/org/apache/qpid/server/queue/SubscriptionManagerTest.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- *
- * 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.server.queue;
-
-import junit.framework.TestCase;
-
-public class SubscriptionManagerTest extends TestCase
-{
-    private final SubscriptionSet mgr = new SubscriptionSet();
-
-    public void testBasicSubscriptionManagement()
-    {
-        assertTrue(mgr.isEmpty());
-        assertFalse(mgr.hasActiveSubscribers());
-        SubscriptionTestHelper s1 = new SubscriptionTestHelper("S1");
-        mgr.addSubscriber(s1);
-        assertFalse(mgr.isEmpty());
-        assertTrue(mgr.hasActiveSubscribers());
-
-        SubscriptionTestHelper s2 = new SubscriptionTestHelper("S2");
-        mgr.addSubscriber(s2);
-
-        s2.setSuspended(true);
-        assertFalse(mgr.isEmpty());
-        assertTrue(mgr.hasActiveSubscribers());
-        assertTrue(s2.isSuspended());
-        assertFalse(s1.isSuspended());
-
-        s1.setSuspended(true);
-        assertFalse(mgr.hasActiveSubscribers());
-
-        mgr.removeSubscriber(new SubscriptionTestHelper("S1"));
-        assertFalse(mgr.isEmpty());
-        mgr.removeSubscriber(new SubscriptionTestHelper("S2"));
-        assertTrue(mgr.isEmpty());
-    }
-
-    public void testRoundRobin()
-    {
-        SubscriptionTestHelper a = new SubscriptionTestHelper("A");
-        SubscriptionTestHelper b = new SubscriptionTestHelper("B");
-        SubscriptionTestHelper c = new SubscriptionTestHelper("C");
-        SubscriptionTestHelper d = new SubscriptionTestHelper("D");
-        mgr.addSubscriber(a);
-        mgr.addSubscriber(b);
-        mgr.addSubscriber(c);
-        mgr.addSubscriber(d);
-
-        for (int i = 0; i < 3; i++)
-        {
-            assertEquals(a, mgr.nextSubscriber(null));
-            assertEquals(b, mgr.nextSubscriber(null));
-            assertEquals(c, mgr.nextSubscriber(null));
-            assertEquals(d, mgr.nextSubscriber(null));
-        }
-
-        c.setSuspended(true);
-
-        for (int i = 0; i < 3; i++)
-        {
-            assertEquals(a, mgr.nextSubscriber(null));
-            assertEquals(b, mgr.nextSubscriber(null));
-            assertEquals(d, mgr.nextSubscriber(null));
-        }
-
-        mgr.removeSubscriber(a);
-        d.setSuspended(true);
-        c.setSuspended(false);
-        Subscription e = new SubscriptionTestHelper("D");
-        mgr.addSubscriber(e);
-
-        for (int i = 0; i < 3; i++)
-        {
-            assertEquals(b, mgr.nextSubscriber(null));
-            assertEquals(c, mgr.nextSubscriber(null));
-            assertEquals(e, mgr.nextSubscriber(null));
-        }
-    }
-
-    public static junit.framework.Test suite()
-    {
-        return new junit.framework.TestSuite(SubscriptionManagerTest.class);
-    }
-}
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/SubscriptionSetTest.java b/java/systests/src/main/java/org/apache/qpid/server/queue/SubscriptionSetTest.java
deleted file mode 100644
index bcf54693d3..0000000000
--- a/java/systests/src/main/java/org/apache/qpid/server/queue/SubscriptionSetTest.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- *
- * 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.server.queue;
-
-import junit.framework.TestCase;
-
-public class SubscriptionSetTest extends TestCase
-{
-    /**
-     * A SubscriptionSet that counts the number of items scanned.
-     */
-    static class TestSubscriptionSet extends SubscriptionSet
-    {
-        private int scanned = 0;
-
-        void resetScanned()
-        {
-            scanned = 0;
-        }
-
-        protected void subscriberScanned()
-        {
-            ++scanned;
-        }
-
-        int getScanned()
-        {
-            return scanned;
-        }
-    }
-
-    final SubscriptionTestHelper sub1 = new SubscriptionTestHelper("1");
-    final SubscriptionTestHelper sub2 = new SubscriptionTestHelper("2");
-    final SubscriptionTestHelper sub3 = new SubscriptionTestHelper("3");
-
-    final SubscriptionTestHelper suspendedSub1 = new SubscriptionTestHelper("sus1", true);
-    final SubscriptionTestHelper suspendedSub2 = new SubscriptionTestHelper("sus2", true);
-    final SubscriptionTestHelper suspendedSub3 = new SubscriptionTestHelper("sus3", true);
-
-    public void testNextMessage()
-    {
-        SubscriptionSet ss = new SubscriptionSet();
-        assertNull(ss.nextSubscriber(null));
-        assertEquals(0, ss.getCurrentSubscriber());
-
-        ss.addSubscriber(sub1);
-        assertEquals(sub1, ss.nextSubscriber(null));
-        assertEquals(1, ss.getCurrentSubscriber());
-        assertEquals(sub1, ss.nextSubscriber(null));
-        assertEquals(1, ss.getCurrentSubscriber());
-
-        ss.addSubscriber(sub2);
-        ss.addSubscriber(sub3);
-
-        assertEquals(sub2, ss.nextSubscriber(null));
-        assertEquals(2, ss.getCurrentSubscriber());
-
-        assertEquals(sub3, ss.nextSubscriber(null));
-        assertEquals(3, ss.getCurrentSubscriber());
-    }
-
-    public void testNextMessageWhenAllSuspended()
-    {
-        SubscriptionSet ss = createAllSuspendedSubscriptionSet();
-        assertNull(ss.nextSubscriber(null));
-        assertEquals(3, ss.getCurrentSubscriber());
-
-        assertNull(ss.nextSubscriber(null));
-        assertEquals(3, ss.getCurrentSubscriber());
-    }
-
-    private TestSubscriptionSet createAllSuspendedSubscriptionSet()
-    {
-        TestSubscriptionSet ss = new TestSubscriptionSet();
-        ss.addSubscriber(suspendedSub1);
-        ss.addSubscriber(suspendedSub2);
-        ss.addSubscriber(suspendedSub3);
-        return ss;
-    }
-
-    public void testNextMessageAfterRemove()
-    {
-        SubscriptionSet ss = new SubscriptionSet();
-        ss.addSubscriber(suspendedSub1);
-        ss.addSubscriber(suspendedSub2);
-        ss.addSubscriber(sub3);
-        assertEquals(sub3, ss.nextSubscriber(null));
-        assertEquals(3, ss.getCurrentSubscriber());
-
-        assertEquals(suspendedSub1, ss.removeSubscriber(suspendedSub1));
-
-        assertEquals(sub3, ss.nextSubscriber(null)); // Current implementation handles OutOfBoundsException here.
-        assertEquals(2, ss.getCurrentSubscriber());
-    }
-
-    public void testNextMessageOverScanning()
-    {
-        TestSubscriptionSet ss = new TestSubscriptionSet();
-        SubscriptionTestHelper sub = new SubscriptionTestHelper("test");
-        ss.addSubscriber(suspendedSub1);
-        ss.addSubscriber(sub);
-        ss.addSubscriber(suspendedSub3);
-        assertEquals(sub, ss.nextSubscriber(null));
-        assertEquals(2, ss.getCurrentSubscriber());
-        assertEquals(2, ss.getScanned());
-
-        ss.resetScanned();
-        sub.setSuspended(true);
-        assertNull(ss.nextSubscriber(null));
-        assertEquals(3, ss.getCurrentSubscriber());
-         // Current implementation overscans by one item here.
-        assertEquals(ss.size() + 1, ss.getScanned());
-    }
-
-    public void testNextMessageOverscanWorstCase() {
-        TestSubscriptionSet ss = createAllSuspendedSubscriptionSet();
-        ss.nextSubscriber(null);
-        // Scans the subscriptions twice.
-        assertEquals(ss.size() * 2, ss.getScanned());
-    }
-
-    public static junit.framework.Test suite()
-    {
-        return new junit.framework.TestSuite(SubscriptionSetTest.class);
-    }
-}
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/SubscriptionTestHelper.java b/java/systests/src/main/java/org/apache/qpid/server/queue/SubscriptionTestHelper.java
index 1fa70a08d4..eed60a1a7c 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/queue/SubscriptionTestHelper.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/queue/SubscriptionTestHelper.java
@@ -21,6 +21,8 @@
 package org.apache.qpid.server.queue;
 
 import org.apache.qpid.server.AMQChannel;
+import org.apache.qpid.server.subscription.Subscription;
+import org.apache.qpid.framing.AMQShortString;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -54,7 +56,12 @@ public class SubscriptionTestHelper implements Subscription
         return messages;
     }
 
-    public void send(QueueEntry msg, AMQQueue queue)
+    public void setQueue(AMQQueue queue)
+    {
+        
+    }
+
+    public void send(QueueEntry msg)
     {
         messages.add(msg);
     }
@@ -79,9 +86,39 @@ public class SubscriptionTestHelper implements Subscription
         //no-op
     }
 
-    public Object getSendLock()
+    public void getSendLock()
+    {
+        return;
+    }
+
+    public void releaseSendLock()
+    {
+        //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public void resend(final QueueEntry entry)
+    {
+        //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public void restoreCredit(final QueueEntry queueEntry)
+    {
+
+    }
+
+    public void setStateListener(final StateListener listener)
+    {
+        //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public QueueEntry getLastSeenEntry()
+    {
+        return null;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public boolean setLastSeenEntry(QueueEntry expected, QueueEntry newValue)
     {
-        return new Object();
+        return false;  //To change body of implemented methods use File | Settings | File Templates.
     }
 
     public AMQChannel getChannel()
@@ -94,6 +131,26 @@ public class SubscriptionTestHelper implements Subscription
         //no-op
     }
 
+    public AMQShortString getConsumerTag()
+    {
+        return null;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public boolean isActive()
+    {
+        return false;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    public AMQQueue getQueue()
+    {
+        return null;
+    }
+
+    public QueueEntry.SubscriptionAcquiredState getOwningState()
+    {
+        return null;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
     public void queueDeleted(AMQQueue queue)
     {
     }
@@ -108,6 +165,11 @@ public class SubscriptionTestHelper implements Subscription
         return true;
     }
 
+    public boolean isAutoClose()
+    {
+        return false;
+    }
+
     public Queue<QueueEntry> getPreDeliveryQueue()
     {
         return null;
@@ -157,5 +219,4 @@ public class SubscriptionTestHelper implements Subscription
     {
         return key.toString();
     }
-    
 }
diff --git a/java/systests/src/main/java/org/apache/qpid/server/queue/TimeToLiveTest.java b/java/systests/src/main/java/org/apache/qpid/server/queue/TimeToLiveTest.java
index a803bf7da5..c60748b5cb 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/queue/TimeToLiveTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/queue/TimeToLiveTest.java
@@ -30,6 +30,7 @@ import org.apache.qpid.client.AMQDestination;
 import org.apache.qpid.jndi.PropertiesFileInitialContextFactory;
 import org.apache.qpid.url.URLSyntaxException;
 import org.apache.qpid.AMQException;
+import org.apache.qpid.server.registry.ApplicationRegistry;
 import org.apache.log4j.Logger;
 
 import javax.jms.JMSException;
@@ -82,7 +83,8 @@ public class TimeToLiveTest extends TestCase
     {
         if (usingInVMBroker())
         {
-            TransportConnection.killAllVMBrokers();
+            TransportConnection.killVMBroker(1);
+            ApplicationRegistry.remove(1);
         }
         super.tearDown();
     }
@@ -95,7 +97,7 @@ public class TimeToLiveTest extends TestCase
 
         env.put("connectionfactory.connection", "amqp://guest:guest@TTL_TEST_ID" + VHOST + "?brokerlist='" + BROKER + "'");
         env.put("queue.queue", QUEUE);
-
+                                           
         Context context = factory.getInitialContext(env);
 
         Queue queue = (Queue) context.lookup("queue");
diff --git a/java/systests/src/main/java/org/apache/qpid/server/security/acl/SimpleACLTest.java b/java/systests/src/main/java/org/apache/qpid/server/security/acl/SimpleACLTest.java
index e39b1122cf..db29b2d5f9 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/security/acl/SimpleACLTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/security/acl/SimpleACLTest.java
@@ -35,7 +35,6 @@ import javax.jms.*;
 import javax.jms.IllegalStateException;
 import java.io.File;
 
-
 public class SimpleACLTest extends TestCase implements ConnectionListener
 {
     private String BROKER = "vm://:1";//"tcp://localhost:5672";
@@ -52,7 +51,7 @@ public class SimpleACLTest extends TestCase implements ConnectionListener
             fail("Configuration file not found:" + defaultaclConfigFile);
         }
 
-        if (System.getProperty("QPID_HOME") == null)
+        if (System.getProperty("QPID_HOME") == null)                                                                                            
         {
             fail("QPID_HOME not set");
         }
@@ -73,7 +72,7 @@ public class SimpleACLTest extends TestCase implements ConnectionListener
     public String createConnectionString(String username, String password, String broker)
     {
 
-        return "amqp://" + username + ":" + password + "@clientid/test?brokerlist='" + broker + "'";
+        return "amqp://" + username + ":" + password + "@clientid/test?brokerlist='" + broker + "?retries='0''";
     }
 
     public void testAccessAuthorized() throws AMQException, URLSyntaxException
@@ -113,15 +112,9 @@ public class SimpleACLTest extends TestCase implements ConnectionListener
         }
         catch (AMQException amqe)
         {
-            if (amqe.getCause().getClass() == Exception.class)
-            {
-                System.err.println("QPID-594 : WARNING RACE CONDITION. Unable to determine cause of Connection Failure.");
-                return;
-            }
-            assertEquals("Linked Exception Incorrect", JMSException.class, amqe.getCause().getClass());
-            Exception linked = ((JMSException) amqe.getCause()).getLinkedException();
-            assertEquals("Exception was wrong type", AMQAuthenticationException.class, linked.getClass());
-            assertEquals("Incorrect error code thrown", 403, ((AMQAuthenticationException) linked).getErrorCode().getCode());
+            Throwable cause = amqe.getCause();
+            assertEquals("Exception was wrong type", AMQAuthenticationException.class, cause.getClass());
+            assertEquals("Incorrect error code thrown", 403, ((AMQAuthenticationException) cause).getErrorCode().getCode());
         }
     }
 
@@ -304,11 +297,6 @@ public class SimpleACLTest extends TestCase implements ConnectionListener
 
             fail("Close is not expected to succeed.");
         }
-        catch (IllegalStateException ise)
-        {
-            System.err.println("QPID-826 : WARNING : Unable to determine cause of failure due to closure as we don't " +
-                               "record it for reporting after connection closed asynchronously");
-        }
         catch (JMSException e)
         {
             Throwable cause = e.getLinkedException();
@@ -567,15 +555,10 @@ public class SimpleACLTest extends TestCase implements ConnectionListener
 
             fail("Close is not expected to succeed.");
         }
-        catch (IllegalStateException ise)
-        {
-            System.err.println("QPID-826 : WARNING : Unable to determine cause of failure due to closure as we don't " +
-                               "record it for reporting after connection closed asynchronously");
-        }
         catch (JMSException e)
         {
             Throwable cause = e.getLinkedException();
-            cause.printStackTrace();
+
             assertEquals("Incorrect exception", AMQAuthenticationException.class, cause.getClass());
             assertEquals("Incorrect error code thrown", 403, ((AMQAuthenticationException) cause).getErrorCode().getCode());
         }
diff --git a/java/systests/src/main/java/org/apache/qpid/server/store/SkeletonMessageStore.java b/java/systests/src/main/java/org/apache/qpid/server/store/SkeletonMessageStore.java
index 6ffa3e0e02..f08a15a8a7 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/store/SkeletonMessageStore.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/store/SkeletonMessageStore.java
@@ -22,12 +22,11 @@ package org.apache.qpid.server.store;
 
 import org.apache.commons.configuration.Configuration;
 import org.apache.qpid.AMQException;
-import org.apache.qpid.framing.ContentBody;
 import org.apache.qpid.framing.AMQShortString;
 import org.apache.qpid.framing.FieldTable;
 import org.apache.qpid.framing.abstraction.ContentChunk;
-import org.apache.qpid.server.queue.AMQQueue;
 import org.apache.qpid.server.queue.MessageMetaData;
+import org.apache.qpid.server.queue.AMQQueue;
 import org.apache.qpid.server.virtualhost.VirtualHost;
 import org.apache.qpid.server.exchange.Exchange;
 
@@ -81,6 +80,10 @@ public class SkeletonMessageStore implements MessageStore
 
     public void createQueue(AMQQueue queue) throws AMQException
     {
+    }
+
+    public void createQueue(AMQQueue queue, FieldTable arguments) throws AMQException
+    {
     }        
 
     public void beginTran(StoreContext s) throws AMQException
@@ -130,17 +133,22 @@ public class SkeletonMessageStore implements MessageStore
         return null;
     }
 
-    public void removeQueue(AMQShortString name) throws AMQException
+    public boolean isPersistent()
+    {
+        return false;
+    }
+
+    public void removeQueue(final AMQQueue queue) throws AMQException
     {
 
     }
 
-    public void enqueueMessage(StoreContext context, AMQShortString name, Long messageId) throws AMQException
+    public void enqueueMessage(StoreContext context, final AMQQueue queue, Long messageId) throws AMQException
     {
 
     }
 
-    public void dequeueMessage(StoreContext context, AMQShortString name, Long messageId) throws AMQException
+    public void dequeueMessage(StoreContext context, final AMQQueue queue, Long messageId) throws AMQException
     {
 
     }
diff --git a/java/systests/src/main/java/org/apache/qpid/server/store/TestableMemoryMessageStore.java b/java/systests/src/main/java/org/apache/qpid/server/store/TestMemoryMessageStore.java
index 79d428fee8..4e48435962 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/store/TestableMemoryMessageStore.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/store/TestMemoryMessageStore.java
@@ -31,9 +31,9 @@ import java.util.List;
 /**
  * Adds some extra methods to the memory message store for testing purposes.
  */
-public class TestableMemoryMessageStore extends MemoryMessageStore
+public class TestMemoryMessageStore extends MemoryMessageStore
 {
-    public TestableMemoryMessageStore()
+    public TestMemoryMessageStore()
     {
         _metaDataMap = new ConcurrentHashMap<Long, MessageMetaData>();
         _contentBodyMap = new ConcurrentHashMap<Long, List<ContentChunk>>();
diff --git a/java/systests/src/main/java/org/apache/qpid/server/store/TestReferenceCounting.java b/java/systests/src/main/java/org/apache/qpid/server/store/TestReferenceCounting.java
index c7984d5d33..2346660d25 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/store/TestReferenceCounting.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/store/TestReferenceCounting.java
@@ -28,21 +28,22 @@ import org.apache.qpid.framing.AMQShortString;
 import org.apache.qpid.framing.abstraction.MessagePublishInfo;
 import org.apache.qpid.server.queue.AMQMessage;
 import org.apache.qpid.server.queue.MessageHandleFactory;
-import org.apache.qpid.server.txn.NonTransactionalContext;
+import org.apache.qpid.server.queue.AMQMessageHandle;
 
 /**
  * Tests that reference counting works correctly with AMQMessage and the message store
  */
 public class TestReferenceCounting extends TestCase
 {
-    private TestableMemoryMessageStore _store;
+    private TestMemoryMessageStore _store;
 
     private StoreContext _storeContext = new StoreContext();
 
+
     protected void setUp() throws Exception
     {
         super.setUp();
-        _store = new TestableMemoryMessageStore();
+        _store = new TestMemoryMessageStore();
     }
 
     /**
@@ -50,7 +51,7 @@ public class TestReferenceCounting extends TestCase
      */
     public void testMessageGetsRemoved() throws AMQException
     {
-        createPersistentContentHeader();
+        ContentHeaderBody chb = createPersistentContentHeader();
 
         MessagePublishInfo info = new MessagePublishInfo()
         {
@@ -81,16 +82,22 @@ public class TestReferenceCounting extends TestCase
             }
         };
 
-        AMQMessage message = new AMQMessage(_store.getNewMessageId(), info,
-                                            new NonTransactionalContext(_store, _storeContext, null, null),
-                                            createPersistentContentHeader());
+
+        final long messageId = _store.getNewMessageId();
+        AMQMessageHandle messageHandle = (new MessageHandleFactory()).createMessageHandle(messageId, _store, true);
+        messageHandle.setPublishAndContentHeaderBody(_storeContext,info, chb);
+        AMQMessage message = new AMQMessage(messageHandle,
+                                             _storeContext,info);
+
         message = message.takeReference();
 
         // we call routing complete to set up the handle
-        message.routingComplete(_store, _storeContext, new MessageHandleFactory());
-        assertTrue(_store.getMessageMetaDataMap().size() == 1);
+ //       message.routingComplete(_store, _storeContext, new MessageHandleFactory());
+
+
+        assertEquals(1, _store.getMessageMetaDataMap().size());
         message.decrementReference(_storeContext);
-        assertTrue(_store.getMessageMetaDataMap().size() == 0);
+        assertEquals(1, _store.getMessageMetaDataMap().size());
     }
 
     private ContentHeaderBody createPersistentContentHeader()
@@ -134,18 +141,25 @@ public class TestReferenceCounting extends TestCase
             }
         };
 
-        AMQMessage message = new AMQMessage(_store.getNewMessageId(),
-                                            info,
-                                            new NonTransactionalContext(_store, _storeContext, null, null),
-                                            createPersistentContentHeader());
+        final Long messageId = _store.getNewMessageId();
+        final ContentHeaderBody chb = createPersistentContentHeader();
+        AMQMessageHandle messageHandle = (new MessageHandleFactory()).createMessageHandle(messageId, _store, true);
+        messageHandle.setPublishAndContentHeaderBody(_storeContext,info,chb);
+        AMQMessage message = new AMQMessage(messageHandle,
+                                             _storeContext,
+                                            info);
+        
         
         message = message.takeReference();
         // we call routing complete to set up the handle
-        message.routingComplete(_store, _storeContext, new MessageHandleFactory());
-        assertTrue(_store.getMessageMetaDataMap().size() == 1);
+     //   message.routingComplete(_store, _storeContext, new MessageHandleFactory());
+
+
+
+        assertEquals(1, _store.getMessageMetaDataMap().size());
         message = message.takeReference();
         message.decrementReference(_storeContext);
-        assertTrue(_store.getMessageMetaDataMap().size() == 1);
+        assertEquals(1, _store.getMessageMetaDataMap().size());
     }
 
     public static junit.framework.Test suite()
diff --git a/java/systests/src/main/java/org/apache/qpid/server/txn/TxnBufferTest.java b/java/systests/src/main/java/org/apache/qpid/server/txn/TxnBufferTest.java
index b34f28b1a8..84d3d313d1 100644
--- a/java/systests/src/main/java/org/apache/qpid/server/txn/TxnBufferTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/server/txn/TxnBufferTest.java
@@ -23,7 +23,7 @@ package org.apache.qpid.server.txn;
 import junit.framework.TestCase;
 import org.apache.qpid.AMQException;
 import org.apache.qpid.server.store.MessageStore;
-import org.apache.qpid.server.store.TestableMemoryMessageStore;
+import org.apache.qpid.server.store.TestMemoryMessageStore;
 import org.apache.qpid.server.store.StoreContext;
 
 import java.util.LinkedList;
@@ -194,7 +194,7 @@ public class TxnBufferTest extends TestCase
         }
     }
 
-    class MockStore extends TestableMemoryMessageStore
+    class MockStore extends TestMemoryMessageStore
     {
         final Object BEGIN = "BEGIN";
         final Object ABORT = "ABORT";
diff --git a/java/systests/src/main/java/org/apache/qpid/server/util/TestApplicationRegistry.java b/java/systests/src/main/java/org/apache/qpid/server/util/TestApplicationRegistry.java
deleted file mode 100644
index 83b4665be6..0000000000
--- a/java/systests/src/main/java/org/apache/qpid/server/util/TestApplicationRegistry.java
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- *
- * 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.server.util;
-
-import org.apache.qpid.server.exchange.ExchangeFactory;
-import org.apache.qpid.server.exchange.ExchangeRegistry;
-import org.apache.qpid.server.management.ManagedObjectRegistry;
-import org.apache.qpid.server.plugins.PluginManager;
-import org.apache.qpid.server.queue.QueueRegistry;
-import org.apache.qpid.server.registry.ApplicationRegistry;
-import org.apache.qpid.server.registry.IApplicationRegistry;
-import org.apache.qpid.server.security.auth.manager.AuthenticationManager;
-import org.apache.qpid.server.security.auth.manager.PrincipalDatabaseAuthenticationManager;
-import org.apache.qpid.server.security.auth.database.PrincipalDatabaseManager;
-import org.apache.qpid.server.security.auth.database.PropertiesPrincipalDatabaseManager;
-import org.apache.qpid.server.security.access.ACLPlugin;
-import org.apache.qpid.server.security.access.plugins.AllowAll;
-import org.apache.qpid.server.store.MessageStore;
-import org.apache.qpid.server.store.TestableMemoryMessageStore;
-import org.apache.qpid.server.virtualhost.VirtualHost;
-import org.apache.qpid.server.virtualhost.VirtualHostRegistry;
-import org.apache.commons.configuration.Configuration;
-import org.apache.commons.configuration.MapConfiguration;
-
-import java.util.HashMap;
-import java.util.Collection;
-import java.util.Properties;
-
-public class TestApplicationRegistry extends ApplicationRegistry
-{
-    private QueueRegistry _queueRegistry;
-
-    private ExchangeRegistry _exchangeRegistry;
-
-    private ExchangeFactory _exchangeFactory;
-
-    private ManagedObjectRegistry _managedObjectRegistry;
-
-    private ACLPlugin _accessManager;
-
-    private PrincipalDatabaseManager _databaseManager;
-
-    private AuthenticationManager _authenticationManager;
-
-    private MessageStore _messageStore;
-    private VirtualHost _vHost;
-
-    public TestApplicationRegistry()
-    {
-        super(new MapConfiguration(new HashMap()));
-    }
-
-    public void initialise() throws Exception
-    {
-        Properties users = new Properties();
-
-        users.put("guest", "guest");
-
-        _databaseManager = new PropertiesPrincipalDatabaseManager("default", users);
-
-        _accessManager = new AllowAll();
-
-        _authenticationManager = new PrincipalDatabaseAuthenticationManager(null, null);
-
-        IApplicationRegistry appRegistry = ApplicationRegistry.getInstance();
-        _managedObjectRegistry = appRegistry.getManagedObjectRegistry();
-        _vHost = appRegistry.getVirtualHostRegistry().getVirtualHost("test");
-        _queueRegistry = _vHost.getQueueRegistry();
-        _exchangeFactory = _vHost.getExchangeFactory();
-        _exchangeRegistry = _vHost.getExchangeRegistry();
-
-        _messageStore = new TestableMemoryMessageStore();
-
-        _configuration.addProperty("heartbeat.delay", 10 * 60); // 10 minutes
-    }
-
-    public Configuration getConfiguration()
-    {
-        return _configuration;
-    }
-
-    public QueueRegistry getQueueRegistry()
-    {
-        return _queueRegistry;
-    }
-
-    public ExchangeRegistry getExchangeRegistry()
-    {
-        return _exchangeRegistry;
-    }
-
-    public ExchangeFactory getExchangeFactory()
-    {
-        return _exchangeFactory;
-    }
-
-    public ManagedObjectRegistry getManagedObjectRegistry()
-    {
-        return _managedObjectRegistry;
-    }
-
-    public PrincipalDatabaseManager getDatabaseManager()
-    {
-        return _databaseManager;
-    }
-
-    public AuthenticationManager getAuthenticationManager()
-    {
-        return _authenticationManager;
-    }
-
-    public Collection<String> getVirtualHostNames()
-    {
-        return null;  //To change body of implemented methods use File | Settings | File Templates.
-    }
-
-    public VirtualHostRegistry getVirtualHostRegistry()
-    {
-        return null;  //To change body of implemented methods use File | Settings | File Templates.
-    }
-
-    public ACLPlugin getAccessManager()
-    {
-        return _accessManager;
-    }
-
-    public void setAccessManager(ACLPlugin newManager)
-    {
-        _accessManager = newManager;
-    }
-
-    public MessageStore getMessageStore()
-    {
-        return _messageStore;
-    }
-
-    public PluginManager getPluginManager()
-    {
-        return null;
-    }
-}
-
-
diff --git a/java/systests/src/main/java/org/apache/qpid/test/VMTestCase.java b/java/systests/src/main/java/org/apache/qpid/test/VMTestCase.java
deleted file mode 100644
index dcdfb11618..0000000000
--- a/java/systests/src/main/java/org/apache/qpid/test/VMTestCase.java
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * 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;
-
-import junit.framework.TestCase;
-import org.apache.qpid.client.AMQDestination;
-import org.apache.qpid.client.AMQSession;
-import org.apache.qpid.client.transport.TransportConnection;
-import org.apache.qpid.framing.AMQShortString;
-import org.apache.qpid.jndi.PropertiesFileInitialContextFactory;
-import org.apache.qpid.server.registry.ApplicationRegistry;
-import org.apache.qpid.AMQException;
-
-import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSException;
-import javax.jms.Queue;
-import javax.jms.Session;
-import javax.naming.Context;
-import javax.naming.NamingException;
-import javax.naming.spi.InitialContextFactory;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Hashtable;
-import java.util.LinkedList;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.HashMap;
-
-public class VMTestCase extends TestCase
-{
-    protected long RECEIVE_TIMEOUT = 1000l;    // 1 sec
-    protected long CLOSE_TIMEOUT = 10000l;     // 10 secs
-
-    protected Context _context;
-    protected String _clientID;
-    protected String _virtualhost;
-    protected String _brokerlist;
-
-    protected final Map<String, String> _connections = new HashMap<String, String>();
-    protected final Map<String, String> _queues = new HashMap<String, String>();
-    protected final Map<String, String> _topics = new HashMap<String, String>();
-
-    protected void setUp() throws Exception
-    {
-        super.setUp();
-        try
-        {
-            TransportConnection.createVMBroker(1);
-        }
-        catch (Exception e)
-        {
-            fail("Unable to create broker: " + e);
-        }
-
-        InitialContextFactory factory = new PropertiesFileInitialContextFactory();
-
-        Hashtable<String, String> env = new Hashtable<String, String>();
-
-        if (_clientID == null)
-        {
-            _clientID = this.getClass().getName();
-        }
-
-        if (_virtualhost == null)
-        {
-            _virtualhost = "/test";
-        }
-
-        if (_brokerlist == null)
-        {
-            _brokerlist = "vm://:1";
-        }
-
-        env.put("connectionfactory.connection", "amqp://guest:guest@" + _clientID + _virtualhost + "?brokerlist='"
-                                                + _brokerlist + "'");
-
-        for (Map.Entry<String, String> c : _connections.entrySet())
-        {
-            env.put("connectionfactory." + c.getKey(), c.getValue());
-        }
-
-        _queues.put("queue", "queue");
-
-        for (Map.Entry<String, String> q : _queues.entrySet())
-        {
-            env.put("queue." + q.getKey(), q.getValue());
-        }
-
-        _topics.put("topic", "topic");
-
-        for (Map.Entry<String, String> t : _topics.entrySet())
-        {
-            env.put("topic." + t.getKey(), t.getValue());
-        }
-
-        _context = factory.getInitialContext(env);
-    }
-
-    protected void tearDown() throws Exception
-    {
-        //Disabled
-//        checkQueuesClean();
-
-        TransportConnection.killVMBroker(1);
-        ApplicationRegistry.remove(1);
-        
-        super.tearDown();
-    }
-
-    private void checkQueuesClean() throws NamingException, JMSException
-    {
-        Connection connection = ((ConnectionFactory) _context.lookup("connection")).createConnection();
-
-        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
-        connection.start();
-
-        Iterator<String> queueNames = new HashSet<String>(_queues.values()).iterator();
-
-        assertTrue("QueueNames doesn't have next", queueNames.hasNext());
-
-        while (queueNames.hasNext())
-        {
-            Queue queue = session.createQueue(queueNames.next());
-
-            //Validate that the queue are  reporting empty.
-            long queueDepth = 0;
-            try
-            {
-                queueDepth = ((AMQSession) session).getQueueDepth((AMQDestination) queue);
-            }
-            catch (AMQException e)
-            {
-                //ignore
-            }
-
-            assertEquals("Session reports Queue depth not as expected", 0, queueDepth);
-        }
-
-        connection.close();
-    }
-
-    public int getMessageCount(String queueName)
-    {
-        return ApplicationRegistry.getInstance().getVirtualHostRegistry().getVirtualHost(_virtualhost.substring(1))
-                .getQueueRegistry().getQueue(new AMQShortString(queueName)).getMessageCount();
-    }
-}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/client/CancelTest.java b/java/systests/src/main/java/org/apache/qpid/test/client/CancelTest.java
index 7b6d6eadba..25b9b0ba14 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/client/CancelTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/client/CancelTest.java
@@ -22,7 +22,7 @@
 package org.apache.qpid.test.client;
 
 import org.apache.log4j.Logger;
-import org.apache.qpid.testutil.QpidTestCase;
+import org.apache.qpid.test.utils.QpidTestCase;
 
 import javax.jms.Connection;
 import javax.jms.MessageConsumer;
diff --git a/java/systests/src/main/java/org/apache/qpid/test/client/DupsOkTest.java b/java/systests/src/main/java/org/apache/qpid/test/client/DupsOkTest.java
index 57370f490f..d1bcaa1bb8 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/client/DupsOkTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/client/DupsOkTest.java
@@ -1,7 +1,6 @@
 package org.apache.qpid.test.client;
 
-import org.apache.qpid.AMQException;
-import org.apache.qpid.testutil.QpidTestCase;
+import org.apache.qpid.test.utils.QpidTestCase;
 import org.apache.qpid.client.AMQDestination;
 import org.apache.qpid.client.AMQSession;
 
@@ -53,6 +52,10 @@ public class DupsOkTest extends QpidTestCase
         _queue = (Queue)  getInitialContext().lookup("queue");
 
 
+        //Declare the queue
+        Connection consumerConnection = getConnection();
+        consumerConnection.createSession(false,Session.AUTO_ACKNOWLEDGE).createConsumer(_queue).close();
+
         //Create Producer put some messages on the queue
         Connection producerConnection = getConnection();
 
@@ -84,12 +87,14 @@ public class DupsOkTest extends QpidTestCase
         //Create Client
         Connection clientConnection = getConnection();
 
-        clientConnection.start();
-
         final Session clientSession = clientConnection.createSession(false, Session.DUPS_OK_ACKNOWLEDGE);
 
         MessageConsumer consumer = clientSession.createConsumer(_queue);
 
+        assertEquals("The queue should have msgs at start", MSG_COUNT, ((AMQSession) clientSession).getQueueDepth((AMQDestination) _queue));
+
+        clientConnection.start();        
+
         consumer.setMessageListener(new MessageListener()
         {
             int _msgCount = 0;
@@ -110,13 +115,10 @@ public class DupsOkTest extends QpidTestCase
                         {
                             try
                             {
-                                long remainingMessages = ((AMQSession) clientSession).getQueueDepth((AMQDestination) _queue);
-                                fail("The queue should have 0 msgs left, seen " + _msgCount + " messages, left: "
-                                        + remainingMessages);
-                            }
-                            catch (AMQException e)
-                            {
-                                fail("Got AMQException" + e.getMessage());
+                                if(_msgCount != MSG_COUNT)
+                                {
+                                    assertEquals("Wrong number of messages seen.", MSG_COUNT, _msgCount);
+                                }
                             }
                             finally
                             {
@@ -124,7 +126,6 @@ public class DupsOkTest extends QpidTestCase
                                 _awaitCompletion.countDown();
                             }
                         }
-
                     }
                     catch (JMSException e)
                     {
@@ -140,14 +141,24 @@ public class DupsOkTest extends QpidTestCase
 
         try
         {
-            _awaitCompletion.await(60, TimeUnit.SECONDS);
+            if (!_awaitCompletion.await(120, TimeUnit.SECONDS))
+            {
+                fail("Test did not complete in 120 seconds");
+            }
         }
         catch (InterruptedException e)
         {
             fail("Unable to wait for test completion");
             throw e;
         }
+
+        //Close consumer to give broker time to process in bound Acks. As The main thread will be released while
+        // before the dispatcher has sent the ack back to the broker.
+        consumer.close();
+
         assertEquals("The queue should have 0 msgs left", 0, ((AMQSession) clientSession).getQueueDepth((AMQDestination) _queue));
+
+        clientConnection.close();
     }
 
 }
diff --git a/java/systests/src/main/java/org/apache/qpid/test/client/FlowControlTest.java b/java/systests/src/main/java/org/apache/qpid/test/client/FlowControlTest.java
new file mode 100644
index 0000000000..94096e412d
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/client/FlowControlTest.java
@@ -0,0 +1,211 @@
+/*
+*
+* 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.client;
+
+import org.apache.qpid.client.AMQSession_0_8;
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.log4j.Logger;
+
+import javax.jms.*;
+
+public class FlowControlTest extends QpidTestCase
+{
+    private static final Logger _logger = Logger.getLogger(FlowControlTest.class);
+
+    private Connection _clientConnection;
+    private Session _clientSession;
+    private Queue _queue;
+
+    /**
+     * Simply
+     *
+     * @throws Exception
+     */
+    public void testBasicBytesFlowControl() throws Exception
+    {
+        _queue = (Queue) getInitialContext().lookup("queue");
+
+        //Create Client
+        _clientConnection = getConnection();
+
+        _clientConnection.start();
+
+        _clientSession = _clientConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        //Ensure _queue is created
+        _clientSession.createConsumer(_queue).close();
+
+        Connection producerConnection = getConnection();
+
+        producerConnection.start();
+
+        Session producerSession = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+        MessageProducer producer = producerSession.createProducer(_queue);
+
+        BytesMessage m1 = producerSession.createBytesMessage();
+        m1.writeBytes(new byte[128]);
+        m1.setIntProperty("msg", 1);
+        producer.send(m1);
+        BytesMessage m2 = producerSession.createBytesMessage();
+        m2.writeBytes(new byte[128]);
+        m2.setIntProperty("msg", 2);
+        producer.send(m2);
+        BytesMessage m3 = producerSession.createBytesMessage();
+        m3.writeBytes(new byte[256]);
+        m3.setIntProperty("msg", 3);
+        producer.send(m3);
+
+        producer.close();
+        producerSession.close();
+        producerConnection.close();
+
+        Connection consumerConnection = getConnection();
+        Session consumerSession = consumerConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        ((AMQSession_0_8) consumerSession).setPrefecthLimits(0, 256);
+        MessageConsumer recv = consumerSession.createConsumer(_queue);
+        consumerConnection.start();
+
+        Message r1 = recv.receive(RECEIVE_TIMEOUT);
+        assertNotNull("First message not received", r1);
+        assertEquals("Messages in wrong order", 1, r1.getIntProperty("msg"));
+
+        Message r2 = recv.receive(RECEIVE_TIMEOUT);
+        assertNotNull("Second message not received", r2);
+        assertEquals("Messages in wrong order", 2, r2.getIntProperty("msg"));
+
+        Message r3 = recv.receiveNoWait();
+        assertNull("Third message incorrectly delivered", r3);
+
+        r1.acknowledge();
+
+        r3 = recv.receiveNoWait();
+        assertNull("Third message incorrectly delivered", r3);
+
+        r2.acknowledge();
+
+        r3 = recv.receive(RECEIVE_TIMEOUT);
+        assertNotNull("Third message not received", r3);
+        assertEquals("Messages in wrong order", 3, r3.getIntProperty("msg"));
+
+        r3.acknowledge();
+        recv.close();
+        consumerSession.close();
+        consumerConnection.close();
+
+    }
+
+    public void testTwoConsumersBytesFlowControl() throws Exception
+    {
+        _queue = (Queue) getInitialContext().lookup("queue");
+
+        //Create Client
+        _clientConnection = getConnection();
+
+        _clientConnection.start();
+
+        _clientSession = _clientConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        //Ensure _queue is created
+        _clientSession.createConsumer(_queue).close();
+
+        Connection producerConnection = getConnection();
+
+        producerConnection.start();
+
+        Session producerSession = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+        MessageProducer producer = producerSession.createProducer(_queue);
+
+        BytesMessage m1 = producerSession.createBytesMessage();
+        m1.writeBytes(new byte[128]);
+        m1.setIntProperty("msg", 1);
+        producer.send(m1);
+        BytesMessage m2 = producerSession.createBytesMessage();
+        m2.writeBytes(new byte[256]);
+        m2.setIntProperty("msg", 2);
+        producer.send(m2);
+        BytesMessage m3 = producerSession.createBytesMessage();
+        m3.writeBytes(new byte[128]);
+        m3.setIntProperty("msg", 3);
+        producer.send(m3);
+
+        producer.close();
+        producerSession.close();
+        producerConnection.close();
+
+        Connection consumerConnection = getConnection();
+        Session consumerSession1 = consumerConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        ((AMQSession_0_8) consumerSession1).setPrefecthLimits(0, 256);
+        MessageConsumer recv1 = consumerSession1.createConsumer(_queue);
+
+        consumerConnection.start();
+
+        Message r1 = recv1.receive(RECEIVE_TIMEOUT);
+        assertNotNull("First message not received", r1);
+        assertEquals("Messages in wrong order", 1, r1.getIntProperty("msg"));
+
+        Message r2 = recv1.receiveNoWait();
+        assertNull("Second message incorrectly delivered", r2);
+
+        Session consumerSession2 = consumerConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        ((AMQSession_0_8) consumerSession2).setPrefecthLimits(0, 256);
+        MessageConsumer recv2 = consumerSession2.createConsumer(_queue);
+
+        r2 = recv2.receive(100000L);//RECEIVE_TIMEOUT);
+        assertNotNull("Second message not received", r2);
+        assertEquals("Messages in wrong order", 2, r2.getIntProperty("msg"));
+
+        Message r3 = recv2.receiveNoWait();
+        assertNull("Third message incorrectly delivered", r3);
+
+        r3 = recv1.receive(100000L);//RECEIVE_TIMEOUT);
+        assertNotNull("Third message not received", r3);
+        assertEquals("Messages in wrong order", 3, r3.getIntProperty("msg"));
+
+        r2.acknowledge();
+        r3.acknowledge();                                                                 
+        recv1.close();
+        recv2.close();
+        consumerSession1.close();
+        consumerSession2.close();
+        consumerConnection.close();
+
+    }
+
+    public static void main(String args[]) throws Throwable
+    {
+        FlowControlTest test = new FlowControlTest();
+
+        int run = 0;
+        while (true)
+        {
+            System.err.println("Test Run:" + ++run);
+            Thread.sleep(1000);
+
+            test.startBroker();
+            test.testBasicBytesFlowControl();
+
+            Thread.sleep(1000);
+            
+            test.stopBroker();
+        }
+    }
+}
+
diff --git a/java/systests/src/main/java/org/apache/qpid/test/client/QueueBrowserAutoAckTest.java b/java/systests/src/main/java/org/apache/qpid/test/client/QueueBrowserAutoAckTest.java
index 2dbac84fc5..9f3a8f3cb4 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/client/QueueBrowserAutoAckTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/client/QueueBrowserAutoAckTest.java
@@ -24,10 +24,9 @@ import org.apache.log4j.Logger;
 import org.apache.qpid.AMQException;
 import org.apache.qpid.client.AMQDestination;
 import org.apache.qpid.client.AMQSession;
-import org.apache.qpid.test.FailoverBaseCase;
+import org.apache.qpid.test.utils.FailoverBaseCase;
 
 import javax.jms.Connection;
-import javax.jms.ConnectionFactory;
 import javax.jms.JMSException;
 import javax.jms.Message;
 import javax.jms.MessageConsumer;
@@ -112,7 +111,7 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
     }
 
 
-    protected void sendMessages(Connection producerConnection, int num) throws JMSException
+    protected void sendMessages(Connection producerConnection, int messageSendCount) throws JMSException
     {
         producerConnection.start();
 
@@ -123,7 +122,7 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
 
         MessageProducer producer = producerSession.createProducer(_queue);
 
-        for (int messsageID = 0; messsageID < num; messsageID++)
+        for (int messsageID = 0; messsageID < messageSendCount; messsageID++)
         {
             TextMessage textMsg = producerSession.createTextMessage("Message " + messsageID);
             textMsg.setIntProperty(MESSAGE_ID_PROPERTY, messsageID);
@@ -133,7 +132,15 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         producerConnection.close();
     }
 
-    protected void checkQueueDepth(int depth) throws JMSException
+    /**
+     * Using the Protocol getQueueDepth method ensure that the correct number of messages are on the queue.
+     *
+     * Also uses a QueueBrowser as a second method of validating the message count on the queue.
+     *
+     * @param expectedDepth The expected Queue depth
+     * @throws JMSException on error
+     */
+    protected void checkQueueDepth(int expectedDepth) throws JMSException
     {
 
         // create QueueBrowser
@@ -144,7 +151,7 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         // check for messages
         if (_logger.isDebugEnabled())
         {
-            _logger.debug("Checking for " + depth + " messages with QueueBrowser");
+            _logger.debug("Checking for " + expectedDepth + " messages with QueueBrowser");
         }
 
         //Check what the session believes the queue count to be.
@@ -158,7 +165,9 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         {
         }
 
-        assertEquals("Session reports Queue depth not as expected", depth, queueDepth);
+        assertEquals("Session reports Queue expectedDepth not as expected", expectedDepth, queueDepth);
+
+
 
         // Browse the queue to get a second opinion
         int msgCount = 0;
@@ -176,7 +185,7 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         }
 
         // check to see if all messages found
-        assertEquals("Browser did not find all messages", depth, msgCount);
+        assertEquals("Browser did not find all messages", expectedDepth, msgCount);
 
         //Close browser
         queueBrowser.close();
@@ -206,13 +215,20 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         }
     }
 
-
-    protected void checkMultipleGetEnum(int sentMessages, int browserCount) throws JMSException
+    /**
+     * This method checks that multiple calls to getEnumeration() on a queueBrowser provide the same behaviour.
+     *
+     * @param sentMessages The number of messages sent
+     * @param browserEnumerationCount The number of times to call getEnumeration()
+     * @throws JMSException
+     */
+    protected void checkMultipleGetEnum(int sentMessages, int browserEnumerationCount) throws JMSException
     {
         QueueBrowser queueBrowser = _clientSession.createBrowser(_queue);
 
-        for (int count = 0; count < browserCount; count++)
+        for (int count = 0; count < browserEnumerationCount; count++)
         {
+            _logger.info("Checking getEnumeration:" + count);
             Enumeration msgs = queueBrowser.getEnumeration();
 
             int msgCount = 0;
@@ -222,7 +238,9 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
                 msgs.nextElement();
                 msgCount++;
             }
-            assertEquals(msgCount, sentMessages);
+
+            // Verify that the browser can see all the messages sent.
+            assertEquals(sentMessages, msgCount);
         }
 
         try
@@ -235,22 +253,22 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         }
     }
 
-    protected void checkOverlappingMultipleGetEnum(int browserCount, int expectedMessages) throws JMSException
+    protected void checkOverlappingMultipleGetEnum(int expectedMessages, int browserEnumerationCount) throws JMSException
     {
-        checkOverlappingMultipleGetEnum(browserCount, expectedMessages, null);
+        checkOverlappingMultipleGetEnum(expectedMessages, browserEnumerationCount, null);
     }
 
-    protected void checkOverlappingMultipleGetEnum(int browserCount, int expectedMessages, String selector) throws JMSException
+    protected void checkOverlappingMultipleGetEnum(int expectedMessages, int browserEnumerationCount, String selector) throws JMSException
     {
         QueueBrowser queueBrowser = selector == null ?
                                     _clientSession.createBrowser(_queue, selector) :
                                     _clientSession.createBrowser(_queue);
 
-        Enumeration[] msgs = new Enumeration[browserCount];
-        int[] msgCount = new int[browserCount];
+        Enumeration[] msgs = new Enumeration[browserEnumerationCount];
+        int[] msgCount = new int[browserEnumerationCount];
 
         //create Enums
-        for (int count = 0; count < browserCount; count++)
+        for (int count = 0; count < browserEnumerationCount; count++)
         {
             msgs[count] = queueBrowser.getEnumeration();
         }
@@ -258,7 +276,7 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         //interleave reads
         for (int cnt = 0; cnt < expectedMessages; cnt++)
         {
-            for (int count = 0; count < browserCount; count++)
+            for (int count = 0; count < browserEnumerationCount; count++)
             {
                 if (msgs[count].hasMoreElements())
                 {
@@ -269,7 +287,7 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         }
 
         //validate all browsers get right message count.
-        for (int count = 0; count < browserCount; count++)
+        for (int count = 0; count < browserEnumerationCount; count++)
         {
             assertEquals(msgCount[count], expectedMessages);
         }
@@ -326,12 +344,12 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         checkQueueDepth(0);
     }
 
-    protected void checkQueueDepthWithSelectors(int clients, int totalMessages) throws JMSException
+    protected void checkQueueDepthWithSelectors(int totalMessages, int clients) throws JMSException
     {
 
         String selector = MESSAGE_ID_PROPERTY + " % " + clients;
 
-        checkOverlappingMultipleGetEnum(clients, totalMessages / clients, selector);
+        checkOverlappingMultipleGetEnum(totalMessages / clients, clients, selector);
     }
 
 
@@ -376,9 +394,14 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
 
     }
 
+    /**
+     * This tests that multiple getEnumerations on a QueueBrowser return the required number of messages.
+     * @throws NamingException
+     * @throws JMSException
+     */
     public void testMultipleGetEnum() throws NamingException, JMSException
     {
-        int messages = 100;
+        int messages = 10;
 
         sendMessages(messages);
 
@@ -397,7 +420,7 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
 
         checkQueueDepth(messages);
 
-        checkOverlappingMultipleGetEnum(5, messages);
+        checkOverlappingMultipleGetEnum(messages, 5);
 
         validate(messages);
     }
@@ -413,16 +436,21 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
 
         for (int clients = 2; clients <= 10; clients++)
         {
-            checkQueueDepthWithSelectors(clients, messages);
+            checkQueueDepthWithSelectors(messages, clients);
         }
 
         validate(messages);
     }
 
+    /**
+     * Testing that a QueueBrowser doesn't actually consume messages from a broker when it fails over.
+     * @throws JMSException
+     */
     public void testFailoverWithQueueBrowser() throws JMSException
     {
         int messages = 5;
 
+
         sendMessages("connection1", messages);
         sendMessages("connection2", messages);
 
@@ -476,7 +504,9 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         //Close browser
         queueBrowser.close();
 
-        //Validate all messages still on Broker 1
+        _logger.info("Closed Queue Browser, validating messages on broker.");
+
+        //Validate all messages still on Broker
         validate(messages);
     }
 
@@ -497,20 +527,4 @@ public class QueueBrowserAutoAckTest extends FailoverBaseCase
         validate(messages);
     }
 
-    public void loop() throws JMSException
-    {
-        int run = 0;
-        try
-        {
-            while (true)
-            {
-                System.err.println(run++ + ":************************************************************************");
-                testQueueBrowserMsgsRemainOnQueue();
-            }
-        }
-        catch (Exception e)
-        {
-            _logger.error(e, e);
-        }
-    }
 }
diff --git a/java/systests/src/main/java/org/apache/qpid/test/client/failover/FailoverTest.java b/java/systests/src/main/java/org/apache/qpid/test/client/failover/FailoverTest.java
index e7d7c7eba6..bf87e8e84f 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/client/failover/FailoverTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/client/failover/FailoverTest.java
@@ -21,14 +21,15 @@
 
 package org.apache.qpid.test.client.failover;
 
-import junit.framework.TestCase;
 import org.apache.qpid.client.AMQConnection;
 import org.apache.qpid.client.AMQConnectionFactory;
-import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQConnectionURL;
 import org.apache.qpid.client.transport.TransportConnection;
 import org.apache.qpid.jms.ConnectionListener;
+import org.apache.qpid.jms.ConnectionURL;
+import org.apache.qpid.jms.BrokerDetails;
 import org.apache.qpid.server.registry.ApplicationRegistry;
-import org.apache.qpid.url.URLSyntaxException;
+import org.apache.qpid.test.utils.FailoverBaseCase;
 import org.apache.log4j.Logger;
 
 import javax.jms.Connection;
@@ -38,82 +39,66 @@ import javax.jms.MessageConsumer;
 import javax.jms.MessageProducer;
 import javax.jms.Session;
 import javax.jms.TextMessage;
+import javax.jms.Queue;
+import javax.naming.NamingException;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 
-public class FailoverTest extends TestCase implements ConnectionListener
+public class FailoverTest extends FailoverBaseCase implements ConnectionListener
 {
     private static final Logger _logger = Logger.getLogger(FailoverTest.class);
 
-    private static final int NUM_BROKERS = 2;
-    private static final String BROKER = "amqp://guest:guest@/test?brokerlist='vm://:%d;vm://:%d'";
     private static final String QUEUE = "queue";
     private static final int NUM_MESSAGES = 10;
-    private Connection con;
-    private AMQConnectionFactory conFactory;
-    private Session prodSess;
-    private AMQQueue q;
-    private MessageProducer prod;
-    private Session conSess;
+    private Connection connnection;
+    private Session producerSession;
+    private Queue queue;
+    private MessageProducer producer;
+    private Session consumerSession;
     private MessageConsumer consumer;
 
     private static int usedBrokers = 0;
     private CountDownLatch failoverComplete;
+    private static final long DEFAULT_FAILOVER_TIME = 10000L;
 
     @Override
     protected void setUp() throws Exception
     {
         super.setUp();
-        // Create two VM brokers
 
-        for (int i = 0; i < NUM_BROKERS; i++)
-        {
-            usedBrokers++;
-
-            TransportConnection.createVMBroker(usedBrokers);
-        }
-
-        conFactory = new AMQConnectionFactory(String.format(BROKER, usedBrokers - 1, usedBrokers));
-        _logger.info("Connecting on:" + conFactory.getConnectionURL());
-        con = conFactory.createConnection();
-        ((AMQConnection) con).setConnectionListener(this);
-        con.start();
+        connnection = getConnection();
+        ((AMQConnection) connnection).setConnectionListener(this);
+        connnection.start();
         failoverComplete = new CountDownLatch(1);
     }
 
-    private void init(boolean transacted, int mode) throws JMSException
+    private void init(boolean transacted, int mode) throws JMSException, NamingException
     {
-        prodSess = con.createSession(transacted, mode);
-        q = new AMQQueue("amq.direct", QUEUE);
-        prod = prodSess.createProducer(q);
-        conSess = con.createSession(transacted, mode);
-        consumer = conSess.createConsumer(q);
+        queue = (Queue) getInitialContext().lookup(QUEUE);
+
+        consumerSession = connnection.createSession(transacted, mode);
+        consumer = consumerSession.createConsumer(queue);
+
+        producerSession = connnection.createSession(transacted, mode);
+        producer = producerSession.createProducer(queue);
     }
 
     @Override
-    protected void tearDown() throws Exception
+    public void tearDown() throws Exception
     {
         try
         {
-            con.close();
+            connnection.close();
         }
         catch (Exception e)
         {
 
         }
 
-        try
-        {
-            TransportConnection.killAllVMBrokers();
-            ApplicationRegistry.removeAll();
-        }
-        catch (Exception e)
-        {
-            fail("Unable to clean up");
-        }
         super.tearDown();
     }
 
-    private void consumeMessages(int toConsume) throws JMSException
+    private void consumeMessages(int toConsume, boolean transacted) throws JMSException
     {
         Message msg;
         for (int i = 0; i < toConsume; i++)
@@ -122,40 +107,43 @@ public class FailoverTest extends TestCase implements ConnectionListener
             assertNotNull("Message " + i + " was null!", msg);
             assertEquals("message " + i, ((TextMessage) msg).getText());
         }
+        if (transacted) {
+            consumerSession.commit();
+        }
     }
 
-    private void sendMessages(int totalMessages) throws JMSException
+    private void sendMessages(int totalMessages, boolean transacted) throws JMSException
     {
         for (int i = 0; i < totalMessages; i++)
         {
-            prod.send(prodSess.createTextMessage("message " + i));
+            producer.send(producerSession.createTextMessage("message " + i));
+        }
+        if (transacted)
+        {
+            producerSession.commit();
         }
-
-//        try
-//        {
-//            Thread.sleep(100 * totalMessages);
-//        }
-//        catch (InterruptedException e)
-//        {
-//            //evil ignoring of IE
-//        }
     }
 
     public void testP2PFailover() throws Exception
     {
-        testP2PFailover(NUM_MESSAGES, true);
+        testP2PFailover(NUM_MESSAGES, true, false);
     }
 
     public void testP2PFailoverWithMessagesLeft() throws Exception
     {
-        testP2PFailover(NUM_MESSAGES, false);
+        testP2PFailover(NUM_MESSAGES, false, false);
+    }
+
+    public void testP2PFailoverTransacted() throws Exception
+    {
+        testP2PFailover(NUM_MESSAGES, true, false);
     }
 
-    private void testP2PFailover(int totalMessages, boolean consumeAll) throws JMSException
+    private void testP2PFailover(int totalMessages, boolean consumeAll, boolean transacted) throws JMSException, NamingException
     {
         Message msg = null;
-        init(false, Session.AUTO_ACKNOWLEDGE);
-        sendMessages(totalMessages);
+        init(transacted, Session.AUTO_ACKNOWLEDGE);
+        sendMessages(totalMessages, transacted);
 
         // Consume some messages
         int toConsume = totalMessages;
@@ -164,31 +152,29 @@ public class FailoverTest extends TestCase implements ConnectionListener
             toConsume = totalMessages / 2;
         }
 
-        consumeMessages(toConsume);
+        consumeMessages(toConsume, transacted);
 
         _logger.info("Failing over");
 
-        causeFailure();
+        causeFailure(DEFAULT_FAILOVER_TIME);
 
         msg = consumer.receive(500);
-        //todo: reinstate
+
         assertNull("Should not have received message from new broker!", msg);
         // Check that messages still sent / received
-        sendMessages(totalMessages);
-        consumeMessages(totalMessages);
+        sendMessages(totalMessages, transacted);
+        consumeMessages(totalMessages, transacted);
     }
 
-    private void causeFailure()
+    private void causeFailure(long delay)
     {
-        _logger.info("Failover");
 
-        TransportConnection.killVMBroker(usedBrokers - 1);
-        ApplicationRegistry.remove(usedBrokers - 1);
+        failBroker();
 
         _logger.info("Awaiting Failover completion");
         try
         {
-            failoverComplete.await();
+            failoverComplete.await(delay, TimeUnit.MILLISECONDS);
         }
         catch (InterruptedException e)
         {
@@ -199,12 +185,11 @@ public class FailoverTest extends TestCase implements ConnectionListener
     public void testClientAckFailover() throws Exception
     {
         init(false, Session.CLIENT_ACKNOWLEDGE);
-        sendMessages(1);
+        sendMessages(1, false);
         Message msg = consumer.receive();
         assertNotNull("Expected msgs not received", msg);
 
-
-        causeFailure();
+        causeFailure(DEFAULT_FAILOVER_TIME);
 
         Exception failure = null;
         try
@@ -218,18 +203,41 @@ public class FailoverTest extends TestCase implements ConnectionListener
         assertNotNull("Exception should be thrown", failure);
     }
 
-    // This test disabled so that it doesn't add 4 minnutes to the length of time it takes to run, which would be lame
-    public void txest4MinuteFailover() throws Exception
+    /**
+     * The client used to have a fixed timeout of 4 minutes after which failover would no longer work.
+     * Check that this code has not regressed
+     *
+     * @throws Exception if something unexpected occurs in the test.
+     */
+    public void test4MinuteFailover() throws Exception
     {
-        conFactory = new AMQConnectionFactory("amqp://guest:guest@/test?brokerlist='vm://:"+(usedBrokers-1)+"?connectdelay='60000'&retries='2''");
-        _logger.info("Connecting on:" + conFactory.getConnectionURL());
-        con = conFactory.createConnection();
-        ((AMQConnection) con).setConnectionListener(this);
-        con.start();
-
-        long failTime = System.currentTimeMillis() + 60000;
-        causeFailure();
-        assertTrue("Failover did not take long enough", System.currentTimeMillis() > failTime);
+        ConnectionURL connectionURL = getConnectionFactory().getConnectionURL();
+
+        int RETRIES = 4;
+        int DELAY = 60000;
+
+        //Set up a long delay on and large number of retries
+        BrokerDetails details = connectionURL.getBrokerDetails(1);
+        details.setProperty(BrokerDetails.OPTIONS_RETRY, String.valueOf(RETRIES));
+        details.setProperty(BrokerDetails.OPTIONS_CONNECT_DELAY, String.valueOf(DELAY));
+
+        connnection = new AMQConnection(connectionURL, null);
+
+        ((AMQConnection) connnection).setConnectionListener(this);
+
+        //Start the connection
+        connnection.start();
+
+        long FAILOVER_DELAY = (RETRIES * DELAY);
+
+        // Use Nano seconds as it is more accurate for comparision.
+        long failTime = System.nanoTime() + FAILOVER_DELAY * 1000000;
+
+        //Fail the first broker
+        causeFailure(FAILOVER_DELAY + DEFAULT_FAILOVER_TIME);
+
+        //Reconnection should occur
+        assertTrue("Failover did not take long enough", System.nanoTime() > failTime);
     }
 
     public void bytesSent(long count)
diff --git a/java/systests/src/main/java/org/apache/qpid/test/client/message/MessageToStringTest.java b/java/systests/src/main/java/org/apache/qpid/test/client/message/MessageToStringTest.java
new file mode 100644
index 0000000000..1744b92d62
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/client/message/MessageToStringTest.java
@@ -0,0 +1,251 @@
+/*
+ *
+ * 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.client.message;
+
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import javax.jms.BytesMessage;
+import javax.jms.Connection;
+import javax.jms.ConnectionFactory;
+import javax.jms.JMSException;
+import javax.jms.MapMessage;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.ObjectMessage;
+import javax.jms.Queue;
+import javax.jms.Session;
+import javax.jms.StreamMessage;
+import javax.jms.TextMessage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectOutput;
+import java.io.ObjectOutputStream;
+import java.util.UUID;
+
+public class MessageToStringTest extends QpidTestCase
+{
+    private Connection _connection;
+    private Session _session;
+    private Queue _queue;
+    MessageConsumer _consumer;
+    private static final String BYTE_TEST = "MapByteTest";
+
+    public void setUp() throws Exception
+    {
+        super.setUp();
+
+        //Create Producer put some messages on the queue
+        _connection = getConnection();
+
+        //Create Queue
+        _queue = new AMQQueue("amq.direct", "queue");
+
+        //Create Consumer
+        _session = _connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        _consumer = _session.createConsumer(_queue);
+
+        _connection.start();
+    }
+
+    public void tearDown() throws Exception
+    {
+        //clean up
+        _connection.close();
+
+        super.tearDown();
+    }
+
+    public void testBytesMessage() throws JMSException
+    {
+        //Create Sample Message using UUIDs
+        UUID test = UUID.randomUUID();
+
+        BytesMessage testMessage = _session.createBytesMessage();
+
+        //Convert UUID into bytes for transit
+        byte[] testBytes = test.toString().getBytes();
+
+        testMessage.writeBytes(testBytes);
+
+        sendAndTest(testMessage, testBytes);
+    }
+
+    public void testMapMessage() throws JMSException, IOException
+    {
+        //Create Sample Message using UUIDs
+        UUID test = UUID.randomUUID();
+
+        MapMessage testMessage = _session.createMapMessage();
+
+        byte[] testBytes = convertToBytes(test);
+
+        testMessage.setBytes(BYTE_TEST, testBytes);
+
+        sendAndTest(testMessage, testBytes);
+    }
+
+    public void testObjectMessage() throws JMSException
+    {
+        MessageProducer producer = _session.createProducer(_queue);
+
+        //Create Sample Message using UUIDs
+        UUID test = UUID.randomUUID();
+
+        Message testMessage = _session.createObjectMessage(test);
+
+        sendAndTest(testMessage, test);
+    }
+
+    public void testStreamMessage() throws JMSException, IOException
+    {
+        //Create Sample Message using UUIDs
+        UUID test = UUID.randomUUID();
+
+        StreamMessage testMessage = _session.createStreamMessage();
+
+        byte[] testBytes = convertToBytes(test);
+
+        testMessage.writeBytes(testBytes);
+
+        sendAndTest(testMessage, testBytes);
+    }
+
+    public void testTextMessage() throws JMSException, IOException
+    {
+        //Create Sample Message using UUIDs
+        UUID test = UUID.randomUUID();
+
+        TextMessage testMessage = _session.createTextMessage();
+
+        String stringValue = String.valueOf(test);
+        byte[] testBytes = stringValue.getBytes();
+
+        testMessage.setText(stringValue);
+        
+        sendAndTest(testMessage, testBytes);
+    }
+
+    //***************** Helpers
+
+    private void sendAndTest(Message message, Object testBytes) throws JMSException
+    {
+        MessageProducer producer = _session.createProducer(_queue);
+
+        producer.send(message);
+
+        Message receivedMessage = _consumer.receive(1000);
+
+        assertNotNull("Message was not received.", receivedMessage);
+
+        //Ensure that to calling toString doesn't error and that doing this doesn't break next tests.
+        assertNotNull("Message returned null from toString", receivedMessage.toString());
+
+        byte[] byteResults;
+        UUID result;
+
+        try
+        {
+            if (receivedMessage instanceof ObjectMessage)
+            {
+                result = (UUID) ((ObjectMessage) receivedMessage).getObject();
+                assertEquals("UUIDs were not equal", testBytes, result);
+            }
+            else
+            {
+                byteResults = getBytes(receivedMessage, ((byte[]) testBytes).length);
+                assertBytesEquals("UUIDs were not equal", (byte[]) testBytes, byteResults);
+            }
+        }
+        catch (Exception e)
+        {
+            fail(e.getMessage());
+        }
+
+    }
+
+    private void assertBytesEquals(String message, byte[] expected, byte[] actual)
+    {
+        if (expected.length == actual.length)
+        {
+            int index = 0;
+            boolean failed = false;
+            for (byte b : expected)
+            {
+                if (actual[index++] != b)
+                {
+                    failed = true;
+                    break;
+                }
+            }
+
+            if (!failed)
+            {
+                return;
+            }
+
+        }
+
+        fail(message);
+    }
+
+    private byte[] getBytes(Message receivedMessage, int testBytesLength) throws JMSException
+    {
+        byte[] byteResults = new byte[testBytesLength];
+
+        if (receivedMessage instanceof BytesMessage)
+        {
+            assertEquals(testBytesLength, ((BytesMessage) receivedMessage).readBytes(byteResults));
+        }
+        else if (receivedMessage instanceof StreamMessage)
+        {
+            assertEquals(testBytesLength, ((StreamMessage) receivedMessage).readBytes(byteResults));
+        }
+        else if (receivedMessage instanceof MapMessage)
+        {
+            byteResults = ((MapMessage) receivedMessage).getBytes(BYTE_TEST);
+            assertEquals(testBytesLength, byteResults.length);
+        }
+        else if (receivedMessage instanceof TextMessage)
+        {
+            byteResults = ((TextMessage) receivedMessage).getText().getBytes();
+            assertEquals(testBytesLength, byteResults.length);
+        }
+
+
+        return byteResults;
+    }
+
+    private byte[] convertToBytes(UUID test) throws IOException
+    {
+        //Convert UUID into bytes for transit
+        ObjectOutput out;
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        out = new ObjectOutputStream(bos);
+        out.writeObject(test);
+        out.close();
+
+        return bos.toByteArray();
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/CircuitEnd.java b/java/systests/src/main/java/org/apache/qpid/test/framework/CircuitEnd.java
index 8f85d4a356..824edd7022 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/CircuitEnd.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/CircuitEnd.java
@@ -33,7 +33,7 @@ import javax.jms.*;
  * <tr><td> Provide a message consumer for receiving messages.
  * </table>
  *
- * @todo Update the {@link org.apache.qpid.util.ConversationFactory} so that it accepts these as the basic conversation
+ * @todo Update the {@link org.apache.qpid.test.utils.ConversationFactory} so that it accepts these as the basic conversation
  *       connection units.
  */
 public interface CircuitEnd
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/FrameworkBaseCase.java b/java/systests/src/main/java/org/apache/qpid/test/framework/FrameworkBaseCase.java
index 082f3f29bd..eb51a32166 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/FrameworkBaseCase.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/FrameworkBaseCase.java
@@ -25,12 +25,12 @@ import org.apache.log4j.NDC;
 
 import org.apache.qpid.test.framework.BrokerLifecycleAware;
 import org.apache.qpid.test.framework.sequencers.CircuitFactory;
+import org.apache.qpid.test.utils.QpidTestCase;
 
 import org.apache.qpid.junit.extensions.SetupTaskAware;
 import org.apache.qpid.junit.extensions.SetupTaskHandler;
 import org.apache.qpid.junit.extensions.util.ParsedProperties;
 import org.apache.qpid.junit.extensions.util.TestContextProperties;
-import org.apache.qpid.testutil.QpidTestCase;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/LocalCircuitFactory.java b/java/systests/src/main/java/org/apache/qpid/test/framework/LocalCircuitFactory.java
index 41766b9fae..ec70759cf7 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/LocalCircuitFactory.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/LocalCircuitFactory.java
@@ -26,7 +26,7 @@ import org.apache.qpid.test.framework.localcircuit.LocalCircuitImpl;
 import org.apache.qpid.test.framework.localcircuit.LocalPublisherImpl;
 import org.apache.qpid.test.framework.localcircuit.LocalReceiverImpl;
 import org.apache.qpid.test.framework.sequencers.CircuitFactory;
-import org.apache.qpid.util.ConversationFactory;
+import org.apache.qpid.test.utils.ConversationFactory;
 
 import org.apache.qpid.junit.extensions.util.ParsedProperties;
 
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedcircuit/DistributedCircuitImpl.java b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedcircuit/DistributedCircuitImpl.java
index aefeb17d59..f375eda4d1 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedcircuit/DistributedCircuitImpl.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedcircuit/DistributedCircuitImpl.java
@@ -23,7 +23,7 @@ package org.apache.qpid.test.framework.distributedcircuit;
 import org.apache.log4j.Logger;
 
 import org.apache.qpid.test.framework.*;
-import org.apache.qpid.util.ConversationFactory;
+import org.apache.qpid.test.utils.ConversationFactory;
 
 import org.apache.qpid.junit.extensions.TimingController;
 import org.apache.qpid.junit.extensions.TimingControllerAware;
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/Coordinator.java b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/Coordinator.java
index 55f05ec6f2..d532109dc3 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/Coordinator.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/Coordinator.java
@@ -37,7 +37,7 @@ import org.apache.qpid.test.framework.MessagingTestConfigProperties;
 import org.apache.qpid.test.framework.TestClientDetails;
 import org.apache.qpid.test.framework.TestUtils;
 import org.apache.qpid.test.framework.clocksynch.UDPClockReference;
-import org.apache.qpid.util.ConversationFactory;
+import org.apache.qpid.test.utils.ConversationFactory;
 
 import org.apache.qpid.junit.extensions.TKTestRunner;
 import org.apache.qpid.junit.extensions.WrappedSuiteTestDecorator;
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/DistributedTestDecorator.java b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/DistributedTestDecorator.java
index d2f8ca896c..bdcfc996d6 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/DistributedTestDecorator.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/DistributedTestDecorator.java
@@ -27,7 +27,7 @@ import org.apache.log4j.Logger;
 import org.apache.qpid.test.framework.FrameworkBaseCase;
 import org.apache.qpid.test.framework.TestClientDetails;
 import org.apache.qpid.test.framework.sequencers.CircuitFactory;
-import org.apache.qpid.util.ConversationFactory;
+import org.apache.qpid.test.utils.ConversationFactory;
 
 import org.apache.qpid.junit.extensions.WrappedSuiteTestDecorator;
 
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/FanOutTestDecorator.java b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/FanOutTestDecorator.java
index d6ae390a4a..eed9b1f290 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/FanOutTestDecorator.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/FanOutTestDecorator.java
@@ -30,7 +30,7 @@ import org.apache.qpid.test.framework.FrameworkBaseCase;
 import org.apache.qpid.test.framework.TestClientDetails;
 import org.apache.qpid.test.framework.sequencers.CircuitFactory;
 import org.apache.qpid.test.framework.sequencers.FanOutCircuitFactory;
-import org.apache.qpid.util.ConversationFactory;
+import org.apache.qpid.test.utils.ConversationFactory;
 
 import org.apache.qpid.junit.extensions.WrappedSuiteTestDecorator;
 
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/InteropTestDecorator.java b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/InteropTestDecorator.java
index 38ab66d6ae..413d5558f2 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/InteropTestDecorator.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/InteropTestDecorator.java
@@ -29,7 +29,7 @@ import org.apache.qpid.test.framework.FrameworkBaseCase;
 import org.apache.qpid.test.framework.TestClientDetails;
 import org.apache.qpid.test.framework.sequencers.CircuitFactory;
 import org.apache.qpid.test.framework.sequencers.InteropCircuitFactory;
-import org.apache.qpid.util.ConversationFactory;
+import org.apache.qpid.test.utils.ConversationFactory;
 
 import org.apache.qpid.junit.extensions.WrappedSuiteTestDecorator;
 
@@ -47,7 +47,7 @@ import java.util.*;
  *
  * <p><table id="crc"><caption>CRC Card</caption>
  * <tr><th> Responsibilities <th> Collaborations
- * <tr><td> Broadcast test invitations and collect enlists. <td> {@link org.apache.qpid.util.ConversationFactory}.
+ * <tr><td> Broadcast test invitations and collect enlists. <td> {@link org.apache.qpid.test.utils.ConversationFactory}.
  * <tr><td> Output test failures for clients unwilling to run the test case. <td> {@link Coordinator}
  * <tr><td> Execute distributed test cases. <td> {@link FrameworkBaseCase}
  * <tr><td> Fail non-participating pairings. <td> {@link OptOutTestCase}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/TestClient.java b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/TestClient.java
index 9eba36e1e9..642c690376 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/TestClient.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/distributedtesting/TestClient.java
@@ -27,8 +27,8 @@ import org.apache.qpid.test.framework.MessagingTestConfigProperties;
 import org.apache.qpid.test.framework.TestUtils;
 import org.apache.qpid.test.framework.clocksynch.ClockSynchThread;
 import org.apache.qpid.test.framework.clocksynch.UDPClockSynchronizer;
-import org.apache.qpid.util.ReflectionUtils;
-import org.apache.qpid.util.ReflectionUtilsException;
+import org.apache.qpid.test.utils.ReflectionUtils;
+import org.apache.qpid.test.utils.ReflectionUtilsException;
 
 import org.apache.qpid.junit.extensions.SleepThrottle;
 import org.apache.qpid.junit.extensions.util.ParsedProperties;
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/BaseCircuitFactory.java b/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/BaseCircuitFactory.java
index c7bde1ae03..bd27fc3d90 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/BaseCircuitFactory.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/BaseCircuitFactory.java
@@ -24,7 +24,7 @@ import org.apache.log4j.Logger;
 
 import org.apache.qpid.test.framework.Circuit;
 import org.apache.qpid.test.framework.TestClientDetails;
-import org.apache.qpid.util.ConversationFactory;
+import org.apache.qpid.test.utils.ConversationFactory;
 
 import java.util.LinkedList;
 import java.util.List;
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/CircuitFactory.java b/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/CircuitFactory.java
index 0a48d66981..e69952918d 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/CircuitFactory.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/CircuitFactory.java
@@ -23,7 +23,7 @@ package org.apache.qpid.test.framework.sequencers;
 import org.apache.qpid.test.framework.Assertion;
 import org.apache.qpid.test.framework.Circuit;
 import org.apache.qpid.test.framework.TestClientDetails;
-import org.apache.qpid.util.ConversationFactory;
+import org.apache.qpid.test.utils.ConversationFactory;
 
 import org.apache.qpid.junit.extensions.util.ParsedProperties;
 
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/FanOutCircuitFactory.java b/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/FanOutCircuitFactory.java
index 7f8a821c69..8a9c48d8e7 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/FanOutCircuitFactory.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/FanOutCircuitFactory.java
@@ -27,7 +27,7 @@ import org.apache.qpid.test.framework.Circuit;
 import org.apache.qpid.test.framework.TestClientDetails;
 import org.apache.qpid.test.framework.TestUtils;
 import org.apache.qpid.test.framework.distributedcircuit.DistributedCircuitImpl;
-import org.apache.qpid.util.ConversationFactory;
+import org.apache.qpid.test.utils.ConversationFactory;
 
 import org.apache.qpid.junit.extensions.util.ParsedProperties;
 
diff --git a/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/InteropCircuitFactory.java b/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/InteropCircuitFactory.java
index 8604dd7800..7df80bbf10 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/InteropCircuitFactory.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/framework/sequencers/InteropCircuitFactory.java
@@ -27,7 +27,7 @@ import org.apache.qpid.test.framework.Circuit;
 import org.apache.qpid.test.framework.TestClientDetails;
 import org.apache.qpid.test.framework.TestUtils;
 import org.apache.qpid.test.framework.distributedcircuit.DistributedCircuitImpl;
-import org.apache.qpid.util.ConversationFactory;
+import org.apache.qpid.test.utils.ConversationFactory;
 
 import org.apache.qpid.junit.extensions.util.ParsedProperties;
 
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/ack/AcknowledgeTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/ack/AcknowledgeTest.java
index 4852cab3a6..d0814ca5fc 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/unit/ack/AcknowledgeTest.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/ack/AcknowledgeTest.java
@@ -31,9 +31,7 @@ import javax.jms.Session;
 
 import org.apache.qpid.client.AMQDestination;
 import org.apache.qpid.client.AMQSession;
-import org.apache.qpid.client.transport.TransportConnection;
-import org.apache.qpid.server.registry.ApplicationRegistry;
-import org.apache.qpid.testutil.QpidTestCase;
+import org.apache.qpid.test.utils.QpidTestCase;
 
 public class AcknowledgeTest extends QpidTestCase
 {
@@ -63,21 +61,6 @@ public class AcknowledgeTest extends QpidTestCase
         _consumerA = _consumerSession.createConsumer(_queue);
 	}
 
-    @Override
-    protected void tearDown() throws Exception
-    {
-    	super.tearDown();
-    	try
-    	{
-    		TransportConnection.killAllVMBrokers();
-    		ApplicationRegistry.removeAll();
-    	}
-    	catch (Exception e)
-    	{
-    		fail("Unable to clean up");
-    	}
-
-    }
 
 
     private void sendMessages(int totalMessages) throws JMSException
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/ack/RecoverTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/ack/RecoverTest.java
new file mode 100644
index 0000000000..7434fcbb30
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/ack/RecoverTest.java
@@ -0,0 +1,331 @@
+/*
+ * 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.ack;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.jms.Session;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.TextMessage;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class RecoverTest extends QpidTestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(RecoverTest.class);
+
+    private Exception _error;
+    private AtomicInteger count;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        _error = null;
+        count = new AtomicInteger();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+        count = null;
+    }
+
+    public void testRecoverResendsMsgs() throws Exception
+    {
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+
+        Session consumerSession = con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        Queue queue =
+            new AMQQueue(consumerSession.getDefaultQueueExchangeName(), new AMQShortString("someQ"),
+                new AMQShortString("someQ"), false, true);
+        MessageConsumer consumer = consumerSession.createConsumer(queue);
+        // force synch to ensure the consumer has resulted in a bound queue
+        // ((AMQSession) consumerSession).declareExchangeSynch(ExchangeDefaults.DIRECT_EXCHANGE_NAME, ExchangeDefaults.DIRECT_EXCHANGE_CLASS);
+        // This is the default now
+
+        AMQConnection con2 = (AMQConnection) getConnection("guest", "guest");
+        Session producerSession = con2.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        MessageProducer producer = producerSession.createProducer(queue);
+
+        _logger.info("Sending four messages");
+        producer.send(producerSession.createTextMessage("msg1"));
+        producer.send(producerSession.createTextMessage("msg2"));
+        producer.send(producerSession.createTextMessage("msg3"));
+        producer.send(producerSession.createTextMessage("msg4"));
+
+        con2.close();
+
+        _logger.info("Starting connection");
+        con.start();
+        TextMessage tm = (TextMessage) consumer.receive();
+        tm.acknowledge();
+        _logger.info("Received and acknowledged first message");
+        consumer.receive();
+        consumer.receive();
+        consumer.receive();
+        _logger.info("Received all four messages. Calling recover with three outstanding messages");
+        // no ack for last three messages so when I call recover I expect to get three messages back
+        consumerSession.recover();
+        tm = (TextMessage) consumer.receive(3000);
+        assertEquals("msg2", tm.getText());
+
+        tm = (TextMessage) consumer.receive(3000);
+        assertEquals("msg3", tm.getText());
+
+        tm = (TextMessage) consumer.receive(3000);
+        assertEquals("msg4", tm.getText());
+
+        _logger.info("Received redelivery of three messages. Acknowledging last message");
+        tm.acknowledge();
+
+        _logger.info("Calling acknowledge with no outstanding messages");
+        // all acked so no messages to be delivered
+        consumerSession.recover();
+
+        tm = (TextMessage) consumer.receiveNoWait();
+        assertNull(tm);
+        _logger.info("No messages redelivered as is expected");
+
+        con.close();
+    }
+
+    public void testRecoverResendsMsgsAckOnEarlier() throws Exception
+    {
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+
+        Session consumerSession = con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        Queue queue =
+            new AMQQueue(consumerSession.getDefaultQueueExchangeName(), new AMQShortString("someQ"),
+                new AMQShortString("someQ"), false, true);
+        MessageConsumer consumer = consumerSession.createConsumer(queue);
+        // force synch to ensure the consumer has resulted in a bound queue
+        // ((AMQSession) consumerSession).declareExchangeSynch(ExchangeDefaults.DIRECT_EXCHANGE_NAME, ExchangeDefaults.DIRECT_EXCHANGE_CLASS);
+        // This is the default now
+
+        AMQConnection con2 = (AMQConnection) getConnection("guest", "guest");
+        Session producerSession = con2.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        MessageProducer producer = producerSession.createProducer(queue);
+
+        _logger.info("Sending four messages");
+        producer.send(producerSession.createTextMessage("msg1"));
+        producer.send(producerSession.createTextMessage("msg2"));
+        producer.send(producerSession.createTextMessage("msg3"));
+        producer.send(producerSession.createTextMessage("msg4"));
+
+        con2.close();
+
+        _logger.info("Starting connection");
+        con.start();
+        TextMessage tm = (TextMessage) consumer.receive();
+        consumer.receive();
+        tm.acknowledge();
+        _logger.info("Received 2 messages, acknowledge() first message, should acknowledge both");
+
+        consumer.receive();
+        consumer.receive();
+        _logger.info("Received all four messages. Calling recover with two outstanding messages");
+        // no ack for last three messages so when I call recover I expect to get three messages back
+        consumerSession.recover();
+        TextMessage tm3 = (TextMessage) consumer.receive(3000);
+        assertEquals("msg3", tm3.getText());
+
+        TextMessage tm4 = (TextMessage) consumer.receive(3000);
+        assertEquals("msg4", tm4.getText());
+
+        _logger.info("Received redelivery of two messages. calling acknolwedgeThis() first of those message");
+        ((org.apache.qpid.jms.Message) tm3).acknowledgeThis();
+
+        _logger.info("Calling recover");
+        // all acked so no messages to be delivered
+        consumerSession.recover();
+
+        tm4 = (TextMessage) consumer.receive(3000);
+        assertEquals("msg4", tm4.getText());
+        ((org.apache.qpid.jms.Message) tm4).acknowledgeThis();
+
+        _logger.info("Calling recover");
+        // all acked so no messages to be delivered
+        consumerSession.recover();
+
+        tm = (TextMessage) consumer.receiveNoWait();
+        assertNull(tm);
+        _logger.info("No messages redelivered as is expected");
+
+        con.close();
+    }
+
+    public void testAcknowledgePerConsumer() throws Exception
+    {
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+
+        Session consumerSession = con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        Queue queue =
+            new AMQQueue(consumerSession.getDefaultQueueExchangeName(), new AMQShortString("Q1"), new AMQShortString("Q1"),
+                false, true);
+        Queue queue2 =
+            new AMQQueue(consumerSession.getDefaultQueueExchangeName(), new AMQShortString("Q2"), new AMQShortString("Q2"),
+                false, true);
+        MessageConsumer consumer = consumerSession.createConsumer(queue);
+        MessageConsumer consumer2 = consumerSession.createConsumer(queue2);
+
+        AMQConnection con2 = (AMQConnection) getConnection("guest", "guest");
+        Session producerSession = con2.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        MessageProducer producer = producerSession.createProducer(queue);
+        MessageProducer producer2 = producerSession.createProducer(queue2);
+
+        producer.send(producerSession.createTextMessage("msg1"));
+        producer2.send(producerSession.createTextMessage("msg2"));
+
+        con2.close();
+
+        _logger.info("Starting connection");
+        con.start();
+
+        TextMessage tm2 = (TextMessage) consumer2.receive(2000);
+        assertNotNull(tm2);
+        assertEquals("msg2", tm2.getText());
+
+        tm2.acknowledge();
+
+        consumerSession.recover();
+
+        TextMessage tm1 = (TextMessage) consumer.receive(2000);
+        assertNotNull(tm1);
+        assertEquals("msg1", tm1.getText());
+
+        con.close();
+
+    }
+
+    public void testRecoverInAutoAckListener() throws Exception
+    {
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+
+        final Session consumerSession = con.createSession(false, Session.AUTO_ACKNOWLEDGE);
+        Queue queue =
+            new AMQQueue(consumerSession.getDefaultQueueExchangeName(), new AMQShortString("Q3"), new AMQShortString("Q3"),
+                false, true);
+        MessageConsumer consumer = consumerSession.createConsumer(queue);
+        MessageProducer producer = consumerSession.createProducer(queue);
+        producer.send(consumerSession.createTextMessage("hello"));
+
+        final Object lock = new Object();
+
+        consumer.setMessageListener(new MessageListener()
+            {
+
+                public void onMessage(Message message)
+                {
+                    try
+                    {
+                        count.incrementAndGet();
+                        if (count.get() == 1)
+                        {
+                            if (message.getJMSRedelivered())
+                            {
+                                setError(
+                                    new Exception("Message marked as redilvered on what should be first delivery attempt"));
+                            }
+
+                            consumerSession.recover();
+                        }
+                        else if (count.get() == 2)
+                        {
+                            if (!message.getJMSRedelivered())
+                            {
+                                setError(
+                                    new Exception(
+                                        "Message not marked as redilvered on what should be second delivery attempt"));
+                            }
+                        }
+                        else
+                        {
+                            System.err.println(message);
+                            fail("Message delivered too many times!: " + count);
+                        }
+                    }
+                    catch (JMSException e)
+                    {
+                        _logger.error("Error recovering session: " + e, e);
+                        setError(e);
+                    }
+
+                    synchronized (lock)
+                    {
+                        lock.notify();
+                    }
+                }
+            });
+
+        con.start();
+
+        long waitTime = 30000L;
+        long waitUntilTime = System.currentTimeMillis() + waitTime;
+
+        synchronized (lock)
+        {
+            while ((count.get() <= 1) && (waitTime > 0))
+            {
+                lock.wait(waitTime);
+                if (count.get() <= 1)
+                {
+                    waitTime = waitUntilTime - System.currentTimeMillis();
+                }
+            }
+        }
+
+        Thread.sleep(1000);
+
+        if (count.get() != 2)
+        {
+            System.err.println("Count != 2 : " + count);
+        }
+
+        assertTrue(count.get() == 2);
+
+        con.close();
+
+        if (_error != null)
+        {
+            throw _error;
+        }
+    }
+
+    private void setError(Exception e)
+    {
+        _error = e;
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(RecoverTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/BytesMessageTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/BytesMessageTest.java
new file mode 100644
index 0000000000..9a7fe7c039
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/BytesMessageTest.java
@@ -0,0 +1,282 @@
+/*
+ * 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.basic;
+
+import junit.framework.Assert;
+
+import org.apache.mina.common.ByteBuffer;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQDestination;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.message.JMSBytesMessage;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.BytesMessage;
+import javax.jms.Connection;
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.MessageNotReadableException;
+import javax.jms.MessageNotWriteableException;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class BytesMessageTest extends QpidTestCase implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(BytesMessageTest.class);
+
+    private Connection _connection;
+    private Destination _destination;
+    private Session _session;
+    private final List<JMSBytesMessage> received = new ArrayList<JMSBytesMessage>();
+    private final List<byte[]> messages = new ArrayList<byte[]>();
+    private int _count = 100;
+    public String _connectionString = "vm://:1";
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        init((AMQConnection) getConnection("guest", "guest"));
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    void init(AMQConnection connection) throws Exception
+    {
+        init(connection, new AMQQueue(connection, randomize("BytesMessageTest"), true));
+    }
+
+    void init(AMQConnection connection, AMQDestination destination) throws Exception
+    {
+        _connection = connection;
+        _destination = destination;
+        _session = connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+
+        // Set up a slow consumer.
+        _session.createConsumer(destination).setMessageListener(this);
+        connection.start();
+    }
+
+    public void test() throws Exception
+    {
+        try
+        {
+            send(_count);
+            waitFor(_count);
+            check();
+            _logger.info("Completed without failure");
+        }
+        finally
+        {
+            _connection.close();
+        }
+    }
+
+    void send(int count) throws JMSException
+    {
+        // create a publisher
+        MessageProducer producer = _session.createProducer(_destination);
+        for (int i = 0; i < count; i++)
+        {
+            BytesMessage msg = _session.createBytesMessage();
+
+            try
+            {
+                msg.readFloat();
+                Assert.fail("Message should not be readable");
+            }
+            catch (MessageNotReadableException mnwe)
+            {
+                // normal execution
+            }
+
+            byte[] data = ("Message " + i).getBytes();
+            msg.writeBytes(data);
+            messages.add(data);
+            producer.send(msg);
+        }
+    }
+
+    void waitFor(int count) throws InterruptedException
+    {
+        synchronized (received)
+        {
+            while (received.size() < count)
+            {
+                received.wait();
+            }
+        }
+    }
+
+    void check() throws JMSException
+    {
+        List<byte[]> actual = new ArrayList<byte[]>();
+        for (JMSBytesMessage m : received)
+        {
+            ByteBuffer buffer = m.getData();
+            byte[] data = new byte[buffer.remaining()];
+            buffer.get(data);
+            actual.add(data);
+
+            // Check Body Write Status
+            try
+            {
+                m.writeBoolean(true);
+                Assert.fail("Message should not be writeable");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                // normal execution
+            }
+
+            m.clearBody();
+
+            try
+            {
+                m.writeBoolean(true);
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                Assert.fail("Message should be writeable");
+            }
+
+            // Check property write status
+            try
+            {
+                m.setStringProperty("test", "test");
+                Assert.fail("Message should not be writeable");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                // normal execution
+            }
+
+            m.clearProperties();
+
+            try
+            {
+                m.setStringProperty("test", "test");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                Assert.fail("Message should be writeable");
+            }
+
+        }
+
+        assertEqual(messages.iterator(), actual.iterator());
+    }
+
+    private static void assertEqual(Iterator expected, Iterator actual)
+    {
+        List<String> errors = new ArrayList<String>();
+        while (expected.hasNext() && actual.hasNext())
+        {
+            try
+            {
+                assertEquivalent((byte[]) expected.next(), (byte[]) actual.next());
+            }
+            catch (Exception e)
+            {
+                errors.add(e.getMessage());
+            }
+        }
+        while (expected.hasNext())
+        {
+            errors.add("Expected " + expected.next() + " but no more actual values.");
+        }
+        while (actual.hasNext())
+        {
+            errors.add("Found " + actual.next() + " but no more expected values.");
+        }
+
+        if (!errors.isEmpty())
+        {
+            throw new RuntimeException(errors.toString());
+        }
+    }
+
+    private static void assertEquivalent(byte[] expected, byte[] actual)
+    {
+        if (expected.length != actual.length)
+        {
+            throw new RuntimeException("Expected length " + expected.length + " got " + actual.length);
+        }
+
+        for (int i = 0; i < expected.length; i++)
+        {
+            if (expected[i] != actual[i])
+            {
+                throw new RuntimeException("Failed on byte " + i + " of " + expected.length);
+            }
+        }
+    }
+
+    public void onMessage(Message message)
+    {
+        synchronized (received)
+        {
+            received.add((JMSBytesMessage) message);
+            received.notify();
+        }
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        final String connectionString;
+        final int count;
+        if (argv.length == 0)
+        {
+            connectionString = "vm://:1";
+            count = 100;
+        }
+        else
+        {
+            connectionString = argv[0];
+            count = Integer.parseInt(argv[1]);
+        }
+
+        System.out.println("connectionString = " + connectionString);
+        System.out.println("count = " + count);
+
+        BytesMessageTest test = new BytesMessageTest();
+        test._connectionString = connectionString;
+        test._count = count;
+        test.test();
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/FieldTableMessageTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/FieldTableMessageTest.java
new file mode 100644
index 0000000000..979023d4b6
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/FieldTableMessageTest.java
@@ -0,0 +1,163 @@
+/*
+ *
+ * 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.basic;
+
+import org.apache.mina.common.ByteBuffer;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQDestination;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.message.JMSBytesMessage;
+import org.apache.qpid.framing.AMQFrameDecodingException;
+import org.apache.qpid.framing.FieldTable;
+import org.apache.qpid.framing.FieldTableFactory;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.BytesMessage;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class FieldTableMessageTest extends QpidTestCase implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(FieldTableMessageTest.class);
+
+    private AMQConnection _connection;
+    private AMQDestination _destination;
+    private AMQSession _session;
+    private final ArrayList<JMSBytesMessage> received = new ArrayList<JMSBytesMessage>();
+    private FieldTable _expected;
+    private int _count = 10;
+    public String _connectionString = "vm://:1";
+    private CountDownLatch _waitForCompletion;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        init( (AMQConnection) getConnection("guest", "guest"));
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    private void init(AMQConnection connection) throws Exception
+    {
+        init(connection, new AMQQueue(connection, randomize("FieldTableMessageTest"), true));
+    }
+
+    private void init(AMQConnection connection, AMQDestination destination) throws Exception
+    {
+        _connection = connection;
+        _destination = destination;
+        _session = (AMQSession) connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+
+        // set up a slow consumer
+        _session.createConsumer(destination).setMessageListener(this);
+        connection.start();
+
+        // _expected = new FieldTableTest().load("FieldTableTest2.properties");
+        _expected = load();
+    }
+
+    private FieldTable load() throws IOException
+    {
+        FieldTable result = FieldTableFactory.newFieldTable();
+        result.setLong("one", 1L);
+        result.setLong("two", 2L);
+        result.setLong("three", 3L);
+        result.setLong("four", 4L);
+        result.setLong("five", 5L);
+
+        return result;
+    }
+
+    public void test() throws Exception
+    {
+        int count = _count;
+        _waitForCompletion = new CountDownLatch(_count);
+        send(count);        
+        _waitForCompletion.await(20, TimeUnit.SECONDS);
+        check();
+        _logger.info("Completed without failure");
+        _connection.close();
+    }
+
+    void send(int count) throws JMSException, IOException
+    {
+        // create a publisher
+        MessageProducer producer = _session.createProducer(_destination);
+        for (int i = 0; i < count; i++)
+        {
+            BytesMessage msg = _session.createBytesMessage();
+            msg.writeBytes(_expected.getDataAsBytes());
+            producer.send(msg);
+        }
+    }
+
+
+    void check() throws JMSException, AMQFrameDecodingException
+    {
+        for (Object m : received)
+        {
+            ByteBuffer buffer = ((JMSBytesMessage) m).getData();
+            FieldTable actual = FieldTableFactory.newFieldTable(buffer, buffer.remaining());
+            for (String key : _expected.keys())
+            {
+                assertEquals("Values for " + key + " did not match", _expected.getObject(key), actual.getObject(key));
+            }
+        }
+    }
+
+    public void onMessage(Message message)
+    {
+        synchronized (received)
+        {
+            received.add((JMSBytesMessage) message);
+            _waitForCompletion.countDown();
+        }
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        FieldTableMessageTest test = new FieldTableMessageTest();
+        test._connectionString = (argv.length == 0) ? "vm://:1" : argv[0];
+        test.setUp();
+        test._count = (argv.length > 1) ? Integer.parseInt(argv[1]) : 5;
+        test.test();
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/InvalidDestinationTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/InvalidDestinationTest.java
new file mode 100644
index 0000000000..06f4a6464f
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/InvalidDestinationTest.java
@@ -0,0 +1,104 @@
+/*
+ *
+ * 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.basic;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import javax.jms.Session;
+import javax.jms.QueueSession;
+import javax.jms.Queue;
+import javax.jms.QueueSender;
+import javax.jms.TextMessage;
+import javax.jms.InvalidDestinationException;
+
+public class InvalidDestinationTest extends QpidTestCase
+{
+    private AMQConnection _connection;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        _connection = (AMQConnection) getConnection("guest", "guest");
+    }
+
+    protected void tearDown() throws Exception
+    {
+        _connection.close();
+        super.tearDown();
+    }
+
+
+
+    public void testInvalidDestination() throws Exception
+    {
+        Queue invalidDestination = new AMQQueue("amq.direct","unknownQ");
+        AMQQueue validDestination = new AMQQueue("amq.direct","knownQ");
+        QueueSession queueSession = _connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        // This is the only easy way to create and bind a queue from the API :-(
+        queueSession.createConsumer(validDestination);
+
+        QueueSender sender = queueSession.createSender(invalidDestination);
+        TextMessage msg = queueSession.createTextMessage("Hello");
+        try
+        {
+            sender.send(msg);
+            fail("Expected InvalidDestinationException");
+        }
+        catch (InvalidDestinationException ex)
+        {
+            // pass
+        }
+        sender.close();
+
+        sender = queueSession.createSender(null);
+        invalidDestination = new AMQQueue("amq.direct","unknownQ");
+
+        try
+        {
+            sender.send(invalidDestination,msg);
+            fail("Expected InvalidDestinationException");
+        }
+        catch (InvalidDestinationException ex)
+        {
+            // pass
+        }
+        sender.send(validDestination,msg);
+        sender.close();
+        validDestination = new AMQQueue("amq.direct","knownQ");
+        sender = queueSession.createSender(validDestination);
+        sender.send(msg);
+
+
+
+
+    }
+
+
+    public static junit.framework.Test suite()
+    {
+
+        return new junit.framework.TestSuite(InvalidDestinationTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/LargeMessageTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/LargeMessageTest.java
new file mode 100644
index 0000000000..24fef48028
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/LargeMessageTest.java
@@ -0,0 +1,184 @@
+/*
+ *  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.basic;
+
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+
+public class LargeMessageTest extends QpidTestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(LargeMessageTest.class);
+
+    private Destination _destination;
+    private AMQSession _session;
+    private AMQConnection _connection;
+    
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        try
+        {
+            _connection = (AMQConnection) getConnection("guest", "guest");
+            init( _connection );
+        }
+        catch (Exception e)
+        {
+            fail("Unable to initialilse connection: " + e);
+        }
+    }
+
+    protected void tearDown() throws Exception
+    {
+        _connection.close();
+        super.tearDown();
+    }
+
+    private void init(AMQConnection connection) throws Exception
+    {
+        Destination destination = new AMQQueue(connection, "LargeMessageTest", true);
+        init(connection, destination);
+    }
+
+    private void init(AMQConnection connection, Destination destination) throws Exception
+    {
+         _destination = destination;
+        _session = (AMQSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        connection.start();
+    }
+
+    // Test boundary of 1 packet to 2 packets
+    public void test64kminus1()
+    {
+        checkLargeMessage((64 * 1024) - 1);
+    }
+
+    public void test64k()
+    {
+        checkLargeMessage(64 * 1024);
+    }
+
+    public void test64kplus1()
+    {
+        checkLargeMessage((64 * 1024) + 1);
+    }
+
+    // Test packet boundary of 3 packtes
+    public void test128kminus1()
+    {
+        checkLargeMessage((128 * 1024) - 1);
+    }
+
+    public void test128k()
+    {
+        checkLargeMessage(128 * 1024);
+    }
+
+    public void test128kplus1()
+    {
+        checkLargeMessage((128 * 1024) + 1);
+    }
+
+    // Testing larger messages
+
+    public void test256k()
+    {
+        checkLargeMessage(256 * 1024);
+    }
+
+    public void test512k()
+    {
+        checkLargeMessage(512 * 1024);
+    }
+
+    public void test1024k()
+    {
+        checkLargeMessage(1024 * 1024);
+    }
+
+    protected void checkLargeMessage(int messageSize)
+    {
+        try
+        {
+            MessageConsumer consumer = _session.createConsumer(_destination);
+            MessageProducer producer = _session.createProducer(_destination);
+            _logger.info("Testing message of size:" + messageSize);
+
+            String _messageText = buildLargeMessage(messageSize);
+
+            _logger.debug("Message built");
+
+            producer.send(_session.createTextMessage(_messageText));
+
+            TextMessage result = (TextMessage) consumer.receive(1000);
+
+            assertNotNull("Null message recevied", result);
+            assertEquals("Message Size", _messageText.length(), result.getText().length());
+            assertEquals("Message content differes", _messageText, result.getText());
+        }
+        catch (JMSException e)
+        {
+            e.printStackTrace();
+            fail("Excpetion occured:" + e.getCause());
+        }
+    }
+
+    private String buildLargeMessage(int size)
+    {
+        StringBuilder builder = new StringBuilder(size);
+
+        char ch = 'a';
+
+        for (int i = 1; i <= size; i++)
+        {
+            builder.append(ch);
+
+            if ((i % 1000) == 0)
+            {
+                ch++;
+                if (ch == ('z' + 1))
+                {
+                    ch = 'a';
+                }
+            }
+        }
+
+        return builder.toString();
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(LargeMessageTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/MapMessageTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/MapMessageTest.java
new file mode 100644
index 0000000000..390850185c
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/MapMessageTest.java
@@ -0,0 +1,1271 @@
+/*
+ *
+ * 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.basic;
+
+import junit.framework.Assert;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.message.JMSMapMessage;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.MapMessage;
+import javax.jms.Message;
+import javax.jms.MessageFormatException;
+import javax.jms.MessageListener;
+import javax.jms.MessageNotWriteableException;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class MapMessageTest extends QpidTestCase implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(MapMessageTest.class);
+
+    private AMQConnection _connection;
+    private Destination _destination;
+    private AMQSession _session;
+    private final List<JMSMapMessage> received = new ArrayList<JMSMapMessage>();
+
+    private static final String MESSAGE = "Message ";
+    private int _count = 100;
+    public String _connectionString = "vm://:1";
+    private byte[] _bytes = { 99, 98, 97, 96, 95 };
+    private static final float _smallfloat = 100.0f;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        try
+        {
+            init((AMQConnection) getConnection("guest", "guest"));
+        }
+        catch (Exception e)
+        {
+            fail("Unable to initialilse connection: " + e);
+        }
+    }
+
+    protected void tearDown() throws Exception
+    {
+        _logger.info("Tearing Down unit.basic.MapMessageTest");
+        super.tearDown();
+    }
+
+    private void init(AMQConnection connection) throws Exception
+    {
+        Destination destination = new AMQQueue(connection, randomize("MapMessageTest"), true);
+        init(connection, destination);
+    }
+
+    private void init(AMQConnection connection, Destination destination) throws Exception
+    {
+        _connection = connection;
+        _destination = destination;
+        _session = (AMQSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        // set up a slow consumer
+        _session.createConsumer(destination).setMessageListener(this);
+        connection.start();
+    }
+
+    public void test() throws Exception
+    {
+        int count = _count;
+        send(count);
+        waitFor(count);
+        check();
+        _connection.close();
+    }
+
+    void send(int count) throws JMSException
+    {
+        // create a publisher
+        MessageProducer producer = _session.createProducer(_destination);
+        for (int i = 0; i < count; i++)
+        {
+            MapMessage message = _session.createMapMessage();
+
+            setMapValues(message, i);
+
+            producer.send(message);
+        }
+    }
+
+    private void setMapValues(MapMessage message, int i) throws JMSException
+    {
+        message.setBoolean("odd", (i / 2) == 0);
+        message.setByte("byte",Byte.MAX_VALUE);
+        message.setBytes("bytes", _bytes);
+        message.setChar("char",'c');
+        message.setDouble("double", Double.MAX_VALUE);
+        message.setFloat("float", Float.MAX_VALUE);
+        message.setFloat("smallfloat", 100);
+        message.setInt("messageNumber", i);
+        message.setInt("int",  Integer.MAX_VALUE);
+        message.setLong("long",  Long.MAX_VALUE);
+        message.setShort("short", Short.MAX_VALUE);
+        message.setString("message", MESSAGE + i);
+
+        // Test Setting Object Values
+        message.setObject("object-bool", true);
+        message.setObject("object-byte", Byte.MAX_VALUE);
+        message.setObject("object-bytes", _bytes);
+        message.setObject("object-char", 'c');
+        message.setObject("object-double", Double.MAX_VALUE);
+        message.setObject("object-float", Float.MAX_VALUE);
+        message.setObject("object-int", Integer.MAX_VALUE);
+        message.setObject("object-long", Long.MAX_VALUE);
+        message.setObject("object-short", Short.MAX_VALUE);
+
+        // Set a null String value
+        message.setString("nullString", null);
+        // Highlight protocol problem
+        message.setString("emptyString", "");
+
+    }
+
+    void waitFor(int count) throws Exception
+    {
+        long waitTime = 30000L;
+        long waitUntilTime = System.currentTimeMillis() + 30000L;
+
+        synchronized (received)
+        {
+            while ((received.size() < count) && (waitTime > 0))
+            {
+                if (received.size() < count)
+                {
+                    received.wait(waitTime);
+                }
+
+                if (received.size() < count)
+                {
+                    waitTime = waitUntilTime - System.currentTimeMillis();
+                }
+            }
+
+            if (received.size() < count)
+            {
+                throw new Exception("Timed-out.  Waiting for " + count + " only got " + received.size());
+            }
+        }
+    }
+
+    void check() throws JMSException
+    {
+         int count = 0;
+        for (JMSMapMessage m : received)
+        {
+             testMapValues(m, count);
+
+            testCorrectExceptions(m);
+
+            testMessageWriteStatus(m);
+
+            testPropertyWriteStatus(m);
+
+            count++;
+        }
+    }
+
+    private void testCorrectExceptions(JMSMapMessage m) throws JMSException
+    {
+        testBoolean(m);
+
+        testByte(m);
+
+        testBytes(m);
+
+        testChar(m);
+
+        testDouble(m);
+
+        testFloat(m);
+
+        testInt(m);
+
+        testLong(m);
+
+        testShort(m);
+
+        testString(m);
+    }
+
+    private void testString(JMSMapMessage m) throws JMSException
+    {
+
+        Assert.assertFalse(m.getBoolean("message"));
+
+        try
+        {
+            m.getByte("message");
+            fail("Exception Expected.");
+        }
+        catch (NumberFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getShort("message");
+            fail("Exception Expected.");
+        }
+        catch (NumberFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getChar("message");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException npe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getInt("message");
+            fail("Exception Expected.");
+        }
+        catch (NumberFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getLong("message");
+            fail("Exception Expected.");
+        }
+        catch (NumberFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getFloat("message");
+            fail("Exception Expected.");
+        }
+        catch (NumberFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getDouble("message");
+            fail("Exception Expected.");
+        }
+        catch (NumberFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getBytes("message");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals(MESSAGE + m.getInt("messageNumber"), m.getString("message"));
+    }
+
+    private void testShort(JMSMapMessage m) throws JMSException
+    {
+
+        // Try bad reads
+        try
+        {
+            m.getBoolean("short");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getByte("short");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals(Short.MAX_VALUE, m.getShort("short"));
+
+        // Try bad reads
+        try
+        {
+            m.getChar("short");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException npe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals(Short.MAX_VALUE, m.getInt("short"));
+
+        Assert.assertEquals(Short.MAX_VALUE, m.getLong("short"));
+
+        // Try bad reads
+        try
+        {
+            m.getFloat("short");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getDouble("short");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getBytes("short");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals("" + Short.MAX_VALUE, m.getString("short"));
+    }
+
+    private void testLong(JMSMapMessage m) throws JMSException
+    {
+
+        // Try bad reads
+        try
+        {
+            m.getBoolean("long");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getByte("long");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getShort("long");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getChar("long");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException npe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getInt("long");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals(Long.MAX_VALUE, m.getLong("long"));
+
+        // Try bad reads
+        try
+        {
+            m.getFloat("long");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getDouble("long");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getBytes("long");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals("" + Long.MAX_VALUE, m.getString("long"));
+    }
+
+    private void testDouble(JMSMapMessage m) throws JMSException
+    {
+
+        // Try bad reads
+        try
+        {
+            m.getBoolean("double");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getByte("double");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getShort("double");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getChar("double");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException npe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getInt("double");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getLong("double");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getFloat("double");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals(Double.MAX_VALUE, m.getDouble("double"));
+
+        // Try bad reads
+        try
+        {
+            m.getBytes("double");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals("" + Double.MAX_VALUE, m.getString("double"));
+    }
+
+    private void testFloat(JMSMapMessage m) throws JMSException
+    {
+
+        // Try bad reads
+        try
+        {
+            m.getBoolean("float");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getByte("float");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getShort("float");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getChar("float");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException npe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getInt("float");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getLong("float");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals(Float.MAX_VALUE, m.getFloat("float"));
+
+        Assert.assertEquals(_smallfloat, (float) m.getDouble("smallfloat"));
+
+        // Try bad reads
+        try
+        {
+            m.getBytes("float");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals("" + Float.MAX_VALUE, m.getString("float"));
+    }
+
+    private void testInt(JMSMapMessage m) throws JMSException
+    {
+
+        // Try bad reads
+        try
+        {
+            m.getBoolean("int");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getByte("int");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getShort("int");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getChar("int");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException npe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals(Integer.MAX_VALUE, m.getInt("int"));
+
+        Assert.assertEquals(Integer.MAX_VALUE, (int) m.getLong("int"));
+
+        // Try bad reads
+        try
+        {
+            m.getFloat("int");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getDouble("int");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getBytes("int");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals("" + Integer.MAX_VALUE, m.getString("int"));
+    }
+
+    private void testChar(JMSMapMessage m) throws JMSException
+    {
+
+        // Try bad reads
+        try
+        {
+            m.getBoolean("char");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getByte("char");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getShort("char");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals('c', m.getChar("char"));
+
+        try
+        {
+            m.getInt("char");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getLong("char");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getFloat("char");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getDouble("char");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getBytes("char");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals("" + 'c', m.getString("char"));
+    }
+
+    private void testBytes(JMSMapMessage m) throws JMSException
+    {
+        // Try bad reads
+        try
+        {
+            m.getBoolean("bytes");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getByte("bytes");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getShort("bytes");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getChar("bytes");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException npe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getInt("bytes");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        try
+        {
+            m.getLong("bytes");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getFloat("bytes");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getDouble("bytes");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        assertBytesEqual(_bytes, m.getBytes("bytes"));
+
+        try
+        {
+            m.getString("bytes");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+    }
+
+    private void testByte(JMSMapMessage m) throws JMSException
+    {
+        // Try bad reads
+        try
+        {
+            m.getBoolean("byte");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals(Byte.MAX_VALUE, m.getByte("byte"));
+
+        Assert.assertEquals((short) Byte.MAX_VALUE, m.getShort("byte"));
+
+        // Try bad reads
+        try
+        {
+            m.getChar("byte");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException npe)
+        {
+            // normal execution
+        }
+
+        // Reading a byte as an int is ok
+        Assert.assertEquals((short) Byte.MAX_VALUE, m.getInt("byte"));
+
+        Assert.assertEquals((short) Byte.MAX_VALUE, m.getLong("byte"));
+
+        // Try bad reads
+        try
+        {
+            m.getFloat("byte");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getDouble("byte");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getBytes("byte");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals("" + Byte.MAX_VALUE, m.getString("byte"));
+
+    }
+
+    private void testBoolean(JMSMapMessage m) throws JMSException
+    {
+
+        Assert.assertEquals((m.getInt("messageNumber") / 2) == 0, m.getBoolean("odd"));
+
+        // Try bad reads
+        try
+        {
+            m.getByte("odd");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        // Try bad reads
+        try
+        {
+            m.getShort("odd");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getChar("odd");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException npe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getInt("odd");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getLong("odd");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getFloat("odd");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getDouble("odd");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+        // Try bad reads
+        try
+        {
+            m.getBytes("odd");
+            fail("Exception Expected.");
+        }
+        catch (MessageFormatException nfe)
+        {
+            // normal execution
+        }
+
+        Assert.assertEquals("" + ((m.getInt("messageNumber") / 2) == 0), m.getString("odd"));
+    }
+
+    private void testPropertyWriteStatus(JMSMapMessage m) throws JMSException
+    {
+        // Check property write status
+        try
+        {
+            m.setStringProperty("test", "test");
+            Assert.fail("Message should not be writeable");
+        }
+        catch (MessageNotWriteableException mnwe)
+        {
+            // normal execution
+        }
+
+        m.clearProperties();
+
+        try
+        {
+            m.setStringProperty("test", "test");
+        }
+        catch (MessageNotWriteableException mnwe)
+        {
+            Assert.fail("Message should be writeable");
+        }
+    }
+
+    private void testMessageWriteStatus(JMSMapMessage m) throws JMSException
+    {
+        try
+        {
+            m.setInt("testint", 3);
+            fail("Message should not be writeable");
+        }
+        catch (MessageNotWriteableException mnwe)
+        {
+            // normal execution
+        }
+
+        m.clearBody();
+
+        try
+        {
+            m.setInt("testint", 3);
+        }
+        catch (MessageNotWriteableException mnwe)
+        {
+            Assert.fail("Message should be writeable");
+        }
+    }
+
+    private void testMapValues(JMSMapMessage m, int count) throws JMSException
+    {
+        // Test get<Primiative>
+
+        // Boolean
+        assertEqual((count / 2) == 0, m.getBoolean("odd"));
+        assertEqual("" + ((count / 2) == 0), m.getString("odd"));
+
+        // Byte
+        assertEqual(Byte.MAX_VALUE, m.getByte("byte"));
+        assertEqual("" + Byte.MAX_VALUE, m.getString("byte"));
+
+        // Bytes
+        assertBytesEqual(_bytes, m.getBytes("bytes"));
+
+        // Char
+        assertEqual('c', m.getChar("char"));
+
+        // Double
+        assertEqual(Double.MAX_VALUE, m.getDouble("double"));
+        assertEqual("" + Double.MAX_VALUE, m.getString("double"));
+
+        // Float
+        assertEqual(Float.MAX_VALUE, m.getFloat("float"));
+        assertEqual(_smallfloat, (float) m.getDouble("smallfloat"));
+        assertEqual("" + Float.MAX_VALUE, m.getString("float"));
+
+        // Integer
+        assertEqual(Integer.MAX_VALUE, m.getInt("int"));
+        assertEqual("" + Integer.MAX_VALUE, m.getString("int"));
+        assertEqual(count, m.getInt("messageNumber"));
+
+        // long
+        assertEqual(Long.MAX_VALUE, m.getLong("long"));
+        assertEqual("" + Long.MAX_VALUE, m.getString("long"));
+
+        // Short
+        assertEqual(Short.MAX_VALUE, m.getShort("short"));
+        assertEqual("" + Short.MAX_VALUE, m.getString("short"));
+        assertEqual((int) Short.MAX_VALUE, m.getInt("short"));
+
+        // String
+        assertEqual(MESSAGE + count, m.getString("message"));
+
+        // Test getObjects
+        assertEqual(true, m.getObject("object-bool"));
+        assertEqual(Byte.MAX_VALUE, m.getObject("object-byte"));
+        assertBytesEqual(_bytes, (byte[]) m.getObject("object-bytes"));
+        assertEqual('c', m.getObject("object-char"));
+        assertEqual(Double.MAX_VALUE, m.getObject("object-double"));
+        assertEqual(Float.MAX_VALUE, m.getObject("object-float"));
+        assertEqual(Integer.MAX_VALUE, m.getObject("object-int"));
+        assertEqual(Long.MAX_VALUE, m.getObject("object-long"));
+        assertEqual(Short.MAX_VALUE, m.getObject("object-short"));
+
+        // Check Special values
+        assertTrue(m.getString("nullString") == null);
+        assertEqual("", m.getString("emptyString"));
+    }
+
+    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]);
+        }
+    }
+
+    private static void assertEqual(Iterator expected, Iterator actual)
+    {
+        List<String> errors = new ArrayList<String>();
+        while (expected.hasNext() && actual.hasNext())
+        {
+            try
+            {
+                assertEqual(expected.next(), actual.next());
+            }
+            catch (Exception e)
+            {
+                errors.add(e.getMessage());
+            }
+        }
+        while (expected.hasNext())
+        {
+            errors.add("Expected " + expected.next() + " but no more actual values.");
+        }
+        while (actual.hasNext())
+        {
+            errors.add("Found " + actual.next() + " but no more expected values.");
+        }
+
+        if (!errors.isEmpty())
+        {
+            throw new RuntimeException(errors.toString());
+        }
+    }
+
+    private static void assertEqual(Object expected, Object actual)
+    {
+        if (!expected.equals(actual))
+        {
+            throw new RuntimeException("Expected '" + expected + "' found '" + actual + "'");
+        }
+    }
+
+    public void onMessage(Message message)
+    {
+        synchronized (received)
+        {
+            _logger.info("****************** Recevied Messgage:" + message);
+            received.add((JMSMapMessage) message);
+            received.notify();
+        }
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        MapMessageTest test = new MapMessageTest();
+        test._connectionString = (argv.length == 0) ? "vm://:1" : argv[0];
+        test.setUp();
+        if (argv.length > 1)
+        {
+            test._count = Integer.parseInt(argv[1]);
+        }
+
+        test.test();
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(MapMessageTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/MultipleConnectionTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/MultipleConnectionTest.java
new file mode 100644
index 0000000000..658cf26135
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/MultipleConnectionTest.java
@@ -0,0 +1,230 @@
+/*
+ * 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.basic;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQDestination;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.AMQTopic;
+import org.apache.qpid.client.transport.TransportConnection;
+import org.apache.qpid.exchange.ExchangeDefaults;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+
+public class MultipleConnectionTest extends QpidTestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(MultipleConnectionTest.class);
+
+    public static final String _defaultBroker = "vm://:1";
+    public String _connectionString = _defaultBroker;
+
+    private class Receiver
+    {
+        private AMQConnection _connection;
+        private Session[] _sessions;
+        private MessageCounter[] _counters;
+
+        Receiver(String broker, AMQDestination dest, int sessions) throws Exception
+        {
+            this((AMQConnection) getConnection("guest", "guest"), dest, sessions);
+        }
+
+        Receiver(AMQConnection connection, AMQDestination dest, int sessions) throws Exception
+        {
+            _connection = connection;
+            _sessions = new AMQSession[sessions];
+            _counters = new MessageCounter[sessions];
+            for (int i = 0; i < sessions; i++)
+            {
+                _sessions[i] = _connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+                _counters[i] = new MessageCounter(_sessions[i].toString());
+                _sessions[i].createConsumer(dest).setMessageListener(_counters[i]);
+            }
+
+            _connection.start();
+        }
+
+        void close() throws JMSException
+        {
+            _connection.close();
+        }
+    }
+
+    private class Publisher
+    {
+        private AMQConnection _connection;
+        private Session _session;
+        private MessageProducer _producer;
+
+        Publisher(String broker, AMQDestination dest) throws Exception
+        {
+            this((AMQConnection) getConnection("guest", "guest"), dest);
+        }
+
+        Publisher(AMQConnection connection, AMQDestination dest) throws Exception
+        {
+            _connection = connection;
+            _session = _connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+            _producer = _session.createProducer(dest);
+        }
+
+        void send(String msg) throws JMSException
+        {
+            _producer.send(_session.createTextMessage(msg));
+        }
+
+        void close() throws JMSException
+        {
+            _connection.close();
+        }
+    }
+
+    private static class MessageCounter implements MessageListener
+    {
+        private final String _name;
+        private int _count;
+
+        MessageCounter(String name)
+        {
+            _name = name;
+        }
+
+        public synchronized void onMessage(Message message)
+        {
+            _count++;
+            notify();
+        }
+
+        synchronized boolean waitUntil(int expected, long maxWait) throws InterruptedException
+        {
+            long start = System.currentTimeMillis();
+            while (expected > _count)
+            {
+                long timeLeft = maxWait - timeSince(start);
+                if (timeLeft < 0)
+                {
+                    break;
+                }
+
+                wait(timeLeft);
+            }
+
+            return expected <= _count;
+        }
+
+        private long timeSince(long start)
+        {
+            return System.currentTimeMillis() - start;
+        }
+
+        public synchronized String toString()
+        {
+            return _name + ": " + _count;
+        }
+    }
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        TransportConnection.createVMBroker(1);
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+        TransportConnection.killAllVMBrokers();
+    }
+
+    private static void waitForCompletion(int expected, long wait, Receiver[] receivers) throws InterruptedException
+    {
+        for (int i = 0; i < receivers.length; i++)
+        {
+            waitForCompletion(expected, wait, receivers[i]._counters);
+        }
+    }
+
+    private static void waitForCompletion(int expected, long wait, MessageCounter[] counters) throws InterruptedException
+    {
+        for (int i = 0; i < counters.length; i++)
+        {
+            if (!counters[i].waitUntil(expected, wait))
+            {
+                throw new RuntimeException("Expected: " + expected + " got " + counters[i]);
+            }
+        }
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        String broker = (argv.length > 0) ? argv[0] : _defaultBroker;
+
+        MultipleConnectionTest test = new MultipleConnectionTest();
+        test._connectionString = broker;
+        test.test();
+    }
+
+    public void test() throws Exception
+    {
+        String broker = _connectionString;
+        int messages = 10;
+
+        AMQTopic topic = new AMQTopic(ExchangeDefaults.TOPIC_EXCHANGE_NAME, "amq.topic");
+
+        Receiver[] receivers = new Receiver[] { new Receiver(broker, topic, 2), new Receiver(broker, topic, 14) };
+
+        Publisher publisher = new Publisher(broker, topic);
+        for (int i = 0; i < messages; i++)
+        {
+            publisher.send("Message " + (i + 1));
+        }
+
+        try
+        {
+            waitForCompletion(messages, 5000, receivers);
+            _logger.info("All receivers received all expected messages");
+        }
+        finally
+        {
+            publisher.close();
+            for (int i = 0; i < receivers.length; i++)
+            {
+                receivers[i].close();
+            }
+        }
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(MultipleConnectionTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/ObjectMessageTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/ObjectMessageTest.java
new file mode 100644
index 0000000000..d2965bd52a
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/ObjectMessageTest.java
@@ -0,0 +1,278 @@
+/*
+ * 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.basic;
+
+import junit.framework.Assert;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQDestination;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.message.JMSObjectMessage;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.MessageNotWriteableException;
+import javax.jms.MessageProducer;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class ObjectMessageTest extends QpidTestCase implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(ObjectMessageTest.class);
+
+    private AMQConnection _connection;
+    private AMQDestination _destination;
+    private AMQSession _session;
+    private final List<JMSObjectMessage> received = new ArrayList<JMSObjectMessage>();
+    private final List<Payload> messages = new ArrayList<Payload>();
+    private int _count = 100;
+    public String _connectionString = "vm://:1";
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        try
+        {
+            init( (AMQConnection) getConnection("guest", "guest"));
+        }
+        catch (Exception e)
+        {
+            fail("Uable to initialise: " + e);
+        }
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    private void init(AMQConnection connection) throws Exception
+    {
+        init(connection, new AMQQueue(connection, randomize("ObjectMessageTest"), true));
+    }
+
+    private void init(AMQConnection connection, AMQDestination destination) throws Exception
+    {
+        _connection = connection;
+        _destination = destination;
+        _session = (AMQSession) connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+
+        // set up a slow consumer
+        _session.createConsumer(destination).setMessageListener(this);
+        connection.start();
+    }
+
+    public void test() throws Exception
+    {
+        int count = _count;
+        send(count);
+        waitFor(count);
+        check();
+        _logger.info("Completed without failure");
+        _connection.close();
+    }
+
+    void send(int count) throws JMSException
+    {
+        // create a publisher
+        MessageProducer producer = _session.createProducer(_destination);
+        for (int i = 0; i < count; i++)
+        {
+            Payload payload = new Payload("Message " + i);
+            messages.add(payload);
+            producer.send(_session.createObjectMessage(payload));
+        }
+    }
+
+    void waitFor(int count) throws InterruptedException
+    {
+        synchronized (received)
+        {
+            long endTime = System.currentTimeMillis() + 30000L;
+            while (received.size() < count)
+            {
+                received.wait(30000);
+                if(received.size() < count && System.currentTimeMillis() > endTime)
+                {
+                    throw new RuntimeException("Only received " + received.size() + " messages, was expecting " + count);
+                }
+            }
+        }
+    }
+
+    void check() throws JMSException
+    {
+        List<Object> actual = new ArrayList<Object>();
+        for (JMSObjectMessage m : received)
+        {
+            actual.add(m.getObject());
+
+            try
+            {
+                m.setObject("Test text");
+                Assert.fail("Message should not be writeable");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                // normal execution
+            }
+
+            m.clearBody();
+
+            try
+            {
+                m.setObject("Test text");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                Assert.fail("Message should be writeable");
+            }
+
+            // Check property write status
+            try
+            {
+                m.setStringProperty("test", "test");
+                Assert.fail("Message should not be writeable");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                // normal execution
+            }
+
+            m.clearProperties();
+
+            try
+            {
+                m.setStringProperty("test", "test");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                Assert.fail("Message should be writeable");
+            }
+
+        }
+
+        assertEqual(messages.iterator(), actual.iterator());
+
+    }
+
+    private static void assertEqual(Iterator expected, Iterator actual)
+    {
+        List<String> errors = new ArrayList<String>();
+        while (expected.hasNext() && actual.hasNext())
+        {
+            try
+            {
+                assertEqual(expected.next(), actual.next());
+            }
+            catch (Exception e)
+            {
+                errors.add(e.getMessage());
+            }
+        }
+        while (expected.hasNext())
+        {
+            errors.add("Expected " + expected.next() + " but no more actual values.");
+        }
+        while (actual.hasNext())
+        {
+            errors.add("Found " + actual.next() + " but no more expected values.");
+        }
+
+        if (!errors.isEmpty())
+        {
+            throw new RuntimeException(errors.toString());
+        }
+    }
+
+    private static void assertEqual(Object expected, Object actual)
+    {
+        if (!expected.equals(actual))
+        {
+            throw new RuntimeException("Expected '" + expected + "' found '" + actual + "'");
+        }
+    }
+
+    public void onMessage(Message message)
+    {
+        synchronized (received)
+        {
+            received.add((JMSObjectMessage) message);
+            received.notify();
+        }
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+
+    private static class Payload implements Serializable
+    {
+        private final String data;
+
+        Payload(String data)
+        {
+            this.data = data;
+        }
+
+        public int hashCode()
+        {
+            return data.hashCode();
+        }
+
+        public boolean equals(Object o)
+        {
+            return (o instanceof Payload) && ((Payload) o).data.equals(data);
+        }
+
+        public String toString()
+        {
+            return "Payload[" + data + "]";
+        }
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        ObjectMessageTest test = new ObjectMessageTest();
+        test._connectionString = (argv.length == 0) ? "vm://:1" : argv[0];
+        test.setUp();
+        if (argv.length > 1)
+        {
+            test._count = Integer.parseInt(argv[1]);
+        }
+
+        test.test();
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(ObjectMessageTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/PropertyValueTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/PropertyValueTest.java
new file mode 100644
index 0000000000..96a162dec3
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/PropertyValueTest.java
@@ -0,0 +1,408 @@
+/*
+ *
+ * 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.basic;
+
+import junit.framework.Assert;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.AMQDestination;
+import org.apache.qpid.client.message.JMSTextMessage;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.url.BindingURL;
+import org.apache.qpid.url.AMQBindingURL;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageFormatException;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.Session;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.net.URISyntaxException;
+
+import java.lang.reflect.*;
+
+public class PropertyValueTest extends QpidTestCase implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(PropertyValueTest.class);
+
+    private int count = 0;
+    private AMQConnection _connection;
+    private Destination _destination;
+    private AMQSession _session;
+    private final List<JMSTextMessage> received = new ArrayList<JMSTextMessage>();
+    private final List<String> messages = new ArrayList<String>();
+    private int _count = 1;
+    public String _connectionString = "vm://:1";
+    private static final String USERNAME = "guest";
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    private void init(AMQConnection connection) throws Exception
+    {
+        Destination destination = new AMQQueue(connection, randomize("PropertyValueTest"), true);
+        init(connection, destination);
+    }
+
+    private void init(AMQConnection connection, Destination destination) throws Exception
+    {
+        _connection = connection;
+        _destination = destination;
+        _session = (AMQSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        // set up a slow consumer
+        _session.createConsumer(destination).setMessageListener(this);
+        connection.start();
+    }
+
+    private Message getTestMessage() throws Exception
+    {
+        Connection conn = getConnection();
+        Session ssn = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
+        return ssn.createTextMessage();
+    }
+
+    public void testGetNonexistent() throws Exception
+    {
+        Message m = getTestMessage();
+        String s = m.getStringProperty("nonexistent");
+        assertNull(s);
+    }
+
+    private static final String[] NAMES = {
+        "setBooleanProperty", "setByteProperty", "setShortProperty",
+        "setIntProperty", "setLongProperty", "setFloatProperty",
+        "setDoubleProperty", "setObjectProperty"
+    };
+
+    private static final Class[] TYPES = {
+        boolean.class, byte.class, short.class, int.class, long.class,
+        float.class, double.class, Object.class
+    };
+
+    private static final Object[] VALUES = {
+        true, (byte) 0, (short) 0, 0, (long) 0, (float) 0, (double) 0,
+        new Object()
+    };
+
+    public void testSetEmptyPropertyName() throws Exception
+    {
+        Message m = getTestMessage();
+
+        for (int i = 0; i < NAMES.length; i++)
+        {
+            Method meth = m.getClass().getMethod(NAMES[i], String.class, TYPES[i]);
+            try
+            {
+                meth.invoke(m, "", VALUES[i]);
+                fail("expected illegal argument exception");
+            }
+            catch (InvocationTargetException e)
+            {
+                assertEquals(e.getCause().getClass(), IllegalArgumentException.class);
+            }
+        }
+    }
+
+    public void testSetDisallowedClass() throws Exception
+    {
+        Message m = getTestMessage();
+        try
+        {
+            m.setObjectProperty("foo", new Object());
+            fail("expected a MessageFormatException");
+        }
+        catch (MessageFormatException e)
+        {
+            // pass
+        }
+    }
+
+    public void testOnce()
+    {
+        runBatch(1);
+    }
+
+    public void test50()
+    {
+        runBatch(50);
+    }
+
+    private void runBatch(int runSize)
+    {
+        try
+        {
+            int run = 0;
+            while (run < runSize)
+            {
+                _logger.error("Run Number:" + run++);
+                try
+                {
+                    init( (AMQConnection) getConnection("guest", "guest"));
+                }
+                catch (Exception e)
+                {
+                    _logger.error("exception:", e);
+                    fail("Unable to initialilse connection: " + e);
+                }
+
+                int count = _count;
+                send(count);
+                waitFor(count);
+                check();
+                _logger.info("Completed without failure");
+
+                Thread.sleep(10);
+                _connection.close();
+
+                _logger.error("End Run Number:" + (run - 1));
+            }
+        }
+        catch (Exception e)
+        {
+            _logger.error(e.getMessage(), e);
+            e.printStackTrace();
+        }
+    }
+
+    void send(int count) throws JMSException
+    {
+        // create a publisher
+        MessageProducer producer = _session.createProducer(_destination);
+        for (int i = 0; i < count; i++)
+        {
+            String text = "Message " + i;
+            messages.add(text);
+            Message m = _session.createTextMessage(text);
+
+            m.setBooleanProperty("Bool", true);
+
+            m.setByteProperty("Byte", (byte) Byte.MAX_VALUE);
+            m.setDoubleProperty("Double", (double) Double.MAX_VALUE);
+            m.setFloatProperty("Float", (float) Float.MAX_VALUE);
+            m.setIntProperty("Int", (int) Integer.MAX_VALUE);
+
+            m.setJMSCorrelationID("Correlation");
+            // fixme the m.setJMSMessage has no effect
+            producer.setPriority(8);
+            m.setJMSPriority(3);
+
+            // Queue
+            Queue q;
+
+            if ((i / 2) == 0)
+            {
+                q = _session.createTemporaryQueue();
+            }
+            else
+            {
+                q = new AMQQueue(_connection, "TestReply");
+            }
+
+            m.setJMSReplyTo(q);
+            m.setStringProperty("TempQueue", q.toString());
+
+            _logger.debug("Message:" + m);
+
+            Assert.assertEquals("Check temp queue has been set correctly", m.getJMSReplyTo().toString(),
+                m.getStringProperty("TempQueue"));
+
+            m.setJMSType("Test");
+            m.setLongProperty("UnsignedInt", (long) 4294967295L);
+            m.setLongProperty("Long", (long) Long.MAX_VALUE);
+
+            m.setShortProperty("Short", (short) Short.MAX_VALUE);
+            m.setStringProperty("String", "Test");
+
+            _logger.debug("Sending Msg:" + m);
+            producer.send(m);
+        }
+    }
+
+    void waitFor(int count) throws InterruptedException
+    {
+        synchronized (received)
+        {
+            while (received.size() < count)
+            {
+                received.wait();
+            }
+        }
+    }
+
+    void check() throws JMSException, URISyntaxException
+    {
+        List<String> actual = new ArrayList<String>();
+        for (JMSTextMessage m : received)
+        {
+            actual.add(m.getText());
+
+            // Check Properties
+
+            Assert.assertEquals("Check Boolean properties are correctly transported", true, m.getBooleanProperty("Bool"));
+            Assert.assertEquals("Check Byte properties are correctly transported", (byte) Byte.MAX_VALUE,
+                m.getByteProperty("Byte"));
+            Assert.assertEquals("Check Double properties are correctly transported", (double) Double.MAX_VALUE,
+                m.getDoubleProperty("Double"));
+            Assert.assertEquals("Check Float properties are correctly transported", (float) Float.MAX_VALUE,
+                m.getFloatProperty("Float"));
+            Assert.assertEquals("Check Int properties are correctly transported", (int) Integer.MAX_VALUE,
+                m.getIntProperty("Int"));
+            Assert.assertEquals("Check CorrelationID properties are correctly transported", "Correlation",
+                m.getJMSCorrelationID());
+            Assert.assertEquals("Check Priority properties are correctly transported", 8, m.getJMSPriority());
+
+            // Queue
+            Assert.assertEquals("Check ReplyTo properties are correctly transported", AMQDestination.createDestination(new AMQBindingURL(m.getStringProperty("TempQueue"))),
+                m.getJMSReplyTo());
+
+            Assert.assertEquals("Check Type properties are correctly transported", "Test", m.getJMSType());
+
+            Assert.assertEquals("Check Short properties are correctly transported", (short) Short.MAX_VALUE,
+                m.getShortProperty("Short"));
+            Assert.assertEquals("Check UnsignedInt properties are correctly transported", (long) 4294967295L,
+                m.getLongProperty("UnsignedInt"));
+            Assert.assertEquals("Check Long properties are correctly transported", (long) Long.MAX_VALUE,
+                m.getLongProperty("Long"));
+            Assert.assertEquals("Check String properties are correctly transported", "Test", m.getStringProperty("String"));
+/*
+            // AMQP Tests Specific values
+
+            Assert.assertEquals("Check Timestamp properties are correctly transported", m.getStringProperty("time-str"),
+                ((AMQMessage) m).getTimestampProperty(new AMQShortString("time")).toString());
+
+            // Decimal
+            BigDecimal bd = new BigDecimal(Integer.MAX_VALUE);
+
+            Assert.assertEquals("Check decimal properties are correctly transported", bd.setScale(Byte.MAX_VALUE),
+                ((AMQMessage) m).getDecimalProperty(new AMQShortString("decimal")));
+
+            // Void
+            ((AMQMessage) m).setVoidProperty(new AMQShortString("void"));
+
+            Assert.assertTrue("Check void properties are correctly transported",
+                              ((AMQMessage) m).getPropertyHeaders().containsKey("void"));
+*/
+            //JMSXUserID
+            if (m.getStringProperty("JMSXUserID") != null)
+            {
+                Assert.assertEquals("Check 'JMSXUserID' is supported ", USERNAME,
+                                    m.getStringProperty("JMSXUserID"));
+            }
+        }
+
+        received.clear();
+
+        assertEqual(messages.iterator(), actual.iterator());
+
+        messages.clear();
+    }
+
+    private static void assertEqual(Iterator expected, Iterator actual)
+    {
+        List<String> errors = new ArrayList<String>();
+        while (expected.hasNext() && actual.hasNext())
+        {
+            try
+            {
+                assertEqual(expected.next(), actual.next());
+            }
+            catch (Exception e)
+            {
+                errors.add(e.getMessage());
+            }
+        }
+        while (expected.hasNext())
+        {
+            errors.add("Expected " + expected.next() + " but no more actual values.");
+        }
+        while (actual.hasNext())
+        {
+            errors.add("Found " + actual.next() + " but no more expected values.");
+        }
+
+        if (!errors.isEmpty())
+        {
+            throw new RuntimeException(errors.toString());
+        }
+    }
+
+    private static void assertEqual(Object expected, Object actual)
+    {
+        if (!expected.equals(actual))
+        {
+            throw new RuntimeException("Expected '" + expected + "' found '" + actual + "'");
+        }
+    }
+
+    public void onMessage(Message message)
+    {
+        synchronized (received)
+        {
+            received.add((JMSTextMessage) message);
+            received.notify();
+        }
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        PropertyValueTest test = new PropertyValueTest();
+        test._connectionString = (argv.length == 0) ? "vm://:1" : argv[0];
+        test.setUp();
+        if (argv.length > 1)
+        {
+            test._count = Integer.parseInt(argv[1]);
+        }
+
+        test.testOnce();
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(PropertyValueTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/PubSubTwoConnectionTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/PubSubTwoConnectionTest.java
new file mode 100644
index 0000000000..66c5a5b07e
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/PubSubTwoConnectionTest.java
@@ -0,0 +1,75 @@
+/*
+ *
+ * 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.basic;
+
+import javax.jms.Connection;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+import javax.jms.Topic;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.AMQTopic;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+/**
+ * @author Apache Software Foundation
+ */
+public class PubSubTwoConnectionTest extends QpidTestCase
+{
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    /**
+     * This tests that a consumer is set up synchronously
+     * @throws Exception
+     */
+    public void testTwoConnections() throws Exception
+    {
+
+        AMQConnection con1 = (AMQConnection) getConnection("guest", "guest");
+
+        Topic topic = new AMQTopic(con1, "MyTopic");
+
+        Session session1 = con1.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+        MessageProducer producer = session1.createProducer(topic);
+
+        Connection con2 = (AMQConnection) getConnection("guest", "guest") ;
+        Session session2 = con2.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+        MessageConsumer consumer = session2.createConsumer(topic);
+        con2.start();        
+        producer.send(session1.createTextMessage("Hello"));
+        TextMessage tm1 = (TextMessage) consumer.receive(2000);
+        assertNotNull(tm1);
+        assertEquals("Hello", tm1.getText());
+        con1.close();
+        con2.close();
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/ReceiveTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/ReceiveTest.java
new file mode 100644
index 0000000000..eec3db8c5f
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/ReceiveTest.java
@@ -0,0 +1,82 @@
+/*
+ *
+ * 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.basic;
+
+import javax.jms.MessageConsumer;
+import javax.jms.Message;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQDestination;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+public class ReceiveTest extends QpidTestCase
+{
+    private AMQConnection _connection;
+    private AMQDestination _destination;
+    private AMQSession _session;
+    private MessageConsumer _consumer;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+       init((AMQConnection) getConnection("guest", "guest"));
+    }
+
+   protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    private void init(AMQConnection connection) throws Exception
+    {
+        init(connection, new AMQQueue(connection,"ReceiveTest", true));
+    }
+
+    private void init(AMQConnection connection, AMQDestination destination) throws Exception
+    {
+        _connection = connection;
+        _destination = destination;
+        _session = (AMQSession) connection.createSession(true, AMQSession.NO_ACKNOWLEDGE);
+        _consumer = _session.createConsumer(_destination);
+        _connection.start();
+    }
+
+    public void test() throws Exception
+    {
+        Message m = _consumer.receive(5000);
+        assertNull("should not have received a message", m);
+        _connection.close();
+    }
+
+
+    public static junit.framework.Test suite()
+    {
+        // TODO: note that this test doesn't use the VMBrokerSetup
+        // test helper class to create and tear down its
+        // VMBroker. This is because the main() above seems to
+        // indicate that it's also used outside of the surefire test
+        // framework. If it isn't, then this test should also be
+        // changed to use VMBrokerSetup here.
+        return new junit.framework.TestSuite(ReceiveTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/SelectorTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/SelectorTest.java
new file mode 100644
index 0000000000..c42e4c7582
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/SelectorTest.java
@@ -0,0 +1,306 @@
+/*
+ *
+ * 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.basic;
+
+import org.apache.qpid.AMQException;
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQDestination;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.BasicMessageProducer;
+import org.apache.qpid.client.state.StateWaiter;
+import org.apache.qpid.url.URLSyntaxException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.DeliveryMode;
+import javax.jms.InvalidSelectorException;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import java.util.concurrent.CountDownLatch;
+
+public class SelectorTest extends QpidTestCase implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(SelectorTest.class);
+
+    private AMQConnection _connection;
+    private AMQDestination _destination;
+    private AMQSession _session;
+    private int count;
+    public String _connectionString = "vm://:1";
+    private static final String INVALID_SELECTOR = "Cost LIKE 5";
+    CountDownLatch _responseLatch = new CountDownLatch(1);
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        init((AMQConnection) getConnection("guest", "guest"));
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    private void init(AMQConnection connection) throws JMSException
+    {
+        init(connection, new AMQQueue(connection, randomize("SessionStartTest"), true));
+    }
+
+    private void init(AMQConnection connection, AMQDestination destination) throws JMSException
+    {
+        _connection = connection;
+        _destination = destination;
+        connection.start();
+
+        String selector = null;
+        selector = "Cost = 2 AND \"property-with-hyphen\" = 'wibble'";
+        // selector = "JMSType = Special AND Cost = 2 AND AMQMessageID > 0 AND JMSDeliveryMode=" + DeliveryMode.NON_PERSISTENT;
+
+        _session = (AMQSession) connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+        // _session.createConsumer(destination).setMessageListener(this);
+        _session.createConsumer(destination, selector).setMessageListener(this);
+    }
+
+    public void test() throws Exception
+    {
+        try
+        {
+
+            init((AMQConnection) getConnection("guest", "guest", randomize("Client")));
+
+            Message msg = _session.createTextMessage("Message");
+            msg.setJMSPriority(1);
+            msg.setIntProperty("Cost", 2);
+            msg.setStringProperty("property-with-hyphen", "wibble");
+            msg.setJMSType("Special");
+
+            _logger.info("Sending Message:" + msg);
+
+            ((BasicMessageProducer) _session.createProducer(_destination)).send(msg, DeliveryMode.NON_PERSISTENT);
+            _logger.info("Message sent, waiting for response...");
+
+            _responseLatch.await();
+
+            if (count > 0)
+            {
+                _logger.info("Got message");
+            }
+
+            if (count == 0)
+            {
+                fail("Did not get message!");
+                // throw new RuntimeException("Did not get message!");
+            }
+        }
+        catch (JMSException e)
+        {
+            _logger.debug("JMS:" + e.getClass().getSimpleName() + ":" + e.getMessage());
+            if (!(e instanceof InvalidSelectorException))
+            {
+                fail("Wrong exception:" + e.getMessage());
+            }
+            else
+            {
+                System.out.println("SUCCESS!!");
+            }
+        }
+        catch (InterruptedException e)
+        {
+            _logger.debug("IE :" + e.getClass().getSimpleName() + ":" + e.getMessage());
+        }
+        catch (URLSyntaxException e)
+        {
+            _logger.debug("URL:" + e.getClass().getSimpleName() + ":" + e.getMessage());
+            fail("Wrong exception");
+        }
+        catch (AMQException e)
+        {
+            _logger.debug("AMQ:" + e.getClass().getSimpleName() + ":" + e.getMessage());
+            fail("Wrong exception");
+        }
+
+        finally
+        {
+            if (_session != null)
+            {
+                _session.close();
+            }
+            if (_connection != null)
+            {
+                _connection.close();
+            }
+        }
+    }
+
+
+    public void testInvalidSelectors() throws Exception
+    {
+        Connection connection = null;
+
+        try
+        {
+            connection = getConnection("guest", "guest", randomize("Client"));
+            _session = (AMQSession) connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+        }
+        catch (JMSException e)
+        {
+            fail(e.getMessage());
+        }
+        catch (AMQException e)
+        {
+            fail(e.getMessage());
+        }
+        catch (URLSyntaxException e)
+        {
+            fail("Error:" + e.getMessage());
+        }
+
+        //Try Creating a Browser
+        try
+        {
+            _session.createBrowser(_session.createQueue("Ping"), INVALID_SELECTOR);
+        }
+        catch (JMSException e)
+        {
+            _logger.debug("JMS:" + e.getClass().getSimpleName() + ":" + e.getMessage());
+            if (!(e instanceof InvalidSelectorException))
+            {
+                fail("Wrong exception:" + e.getMessage());
+            }
+            else
+            {
+                _logger.debug("SUCCESS!!");
+            }
+        }
+
+        //Try Creating a Consumer
+        try
+        {
+            _session.createConsumer(_session.createQueue("Ping"), INVALID_SELECTOR);
+        }
+        catch (JMSException e)
+        {
+            _logger.debug("JMS:" + e.getClass().getSimpleName() + ":" + e.getMessage());
+            if (!(e instanceof InvalidSelectorException))
+            {
+                fail("Wrong exception:" + e.getMessage());
+            }
+            else
+            {
+                _logger.debug("SUCCESS!!");
+            }
+        }
+
+        //Try Creating a Receiever
+        try
+        {
+            _session.createReceiver(_session.createQueue("Ping"), INVALID_SELECTOR);
+        }
+        catch (JMSException e)
+        {
+            _logger.debug("JMS:" + e.getClass().getSimpleName() + ":" + e.getMessage());
+            if (!(e instanceof InvalidSelectorException))
+            {
+                fail("Wrong exception:" + e.getMessage());
+            }
+            else
+            {
+                _logger.debug("SUCCESS!!");
+            }
+        }
+
+        finally
+        {
+            if (_session != null)
+            {
+                try
+                {
+                    _session.close();
+                }
+                catch (JMSException e)
+                {
+                    fail("Error cleaning up:" + e.getMessage());
+                }
+            }
+            if (_connection != null)
+            {
+                try
+                {
+                    _connection.close();
+                }
+                catch (JMSException e)
+                {
+                    fail("Error cleaning up:" + e.getMessage());
+                }
+            }
+        }
+    }
+
+    public void onMessage(Message message)
+    {
+        count++;
+        _logger.info("Got Message:" + message);
+        _responseLatch.countDown();
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        SelectorTest test = new SelectorTest();
+        test._connectionString = (argv.length == 0) ? "localhost:3000" : argv[0];
+
+        try
+        {
+            while (true)
+            {
+                if (test._connectionString.contains("vm://:1"))
+                {
+                    test.setUp();
+                }
+                test.test();
+
+                if (test._connectionString.contains("vm://:1"))
+                {
+                    test.tearDown();
+                }
+            }
+        }
+        catch (Exception e)
+        {
+            System.err.println(e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(SelectorTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/SessionStartTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/SessionStartTest.java
new file mode 100644
index 0000000000..10320914fe
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/SessionStartTest.java
@@ -0,0 +1,115 @@
+/*
+ *
+ * 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.basic;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQDestination;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+
+public class SessionStartTest extends QpidTestCase implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(SessionStartTest.class);
+
+    private AMQConnection _connection;
+    private AMQDestination _destination;
+    private AMQSession _session;
+    private int count;
+    public String _connectionString = "vm://:1";
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        init((AMQConnection) getConnection("guest", "guest"));
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    private void init(AMQConnection connection) throws Exception
+    {
+        init(connection,
+            new AMQQueue(connection.getDefaultQueueExchangeName(), new AMQShortString(randomize("SessionStartTest")), true));
+    }
+
+    private void init(AMQConnection connection, AMQDestination destination) throws Exception
+    {
+        _connection = connection;
+        _destination = destination;
+        connection.start();
+
+        _session = (AMQSession) connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+        _session.createConsumer(destination).setMessageListener(this);
+    }
+
+    public synchronized void test() throws JMSException, InterruptedException
+    {
+        try
+        {
+            _session.createProducer(_destination).send(_session.createTextMessage("Message"));
+            _logger.info("Message sent, waiting for response...");
+            wait(1000);
+            if (count > 0)
+            {
+                _logger.info("Got message");
+            }
+            else
+            {
+                throw new RuntimeException("Did not get message!");
+            }
+        }
+        finally
+        {
+            _session.close();
+            _connection.close();
+        }
+    }
+
+    public synchronized void onMessage(Message message)
+    {
+        count++;
+        notify();
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        SessionStartTest test = new SessionStartTest();
+        test._connectionString = (argv.length == 0) ? "localhost:5672" : argv[0];
+        test.setUp();
+        test.test();
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/TextMessageTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/TextMessageTest.java
new file mode 100644
index 0000000000..29943161d4
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/TextMessageTest.java
@@ -0,0 +1,248 @@
+/*
+ *
+ * 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.basic;
+
+import junit.framework.Assert;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.message.JMSTextMessage;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.MessageNotWriteableException;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class TextMessageTest extends QpidTestCase implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(TextMessageTest.class);
+
+    private AMQConnection _connection;
+    private Destination _destination;
+    private AMQSession _session;
+    private final List<JMSTextMessage> received = new ArrayList<JMSTextMessage>();
+    private final List<String> messages = new ArrayList<String>();
+    private int _count = 100;
+    public String _connectionString = "vm://:1";
+    private CountDownLatch _waitForCompletion;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        try
+        {
+            init((AMQConnection) getConnection("guest", "guest"));
+        }
+        catch (Exception e)
+        {
+            fail("Unable to initialilse connection: " + e);
+        }
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    private void init(AMQConnection connection) throws Exception
+    {
+        Destination destination =
+            new AMQQueue(connection.getDefaultQueueExchangeName(), new AMQShortString(randomize("TextMessageTest")), true);
+        init(connection, destination);
+    }
+
+    private void init(AMQConnection connection, Destination destination) throws Exception
+    {
+        _connection = connection;
+        _destination = destination;
+        _session = (AMQSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        // set up a slow consumer
+        try
+        {
+            _session.createConsumer(destination).setMessageListener(this);
+        }
+        catch (Throwable  e)
+        {
+            e.printStackTrace();
+        }
+        connection.start();
+    }
+
+    public void test() throws Exception
+    {
+        int count = _count;
+        _waitForCompletion = new CountDownLatch(_count);
+        send(count);
+        _waitForCompletion.await(20, TimeUnit.SECONDS);
+        check();
+        _logger.info("Completed without failure");
+        _connection.close();
+    }
+
+    void send(int count) throws JMSException
+    {
+        // create a publisher
+        MessageProducer producer = _session.createProducer(_destination);
+        for (int i = 0; i < count; i++)
+        {
+            String text = "Message " + i;
+            messages.add(text);
+            Message m = _session.createTextMessage(text);
+            //m.setStringProperty("String", "hello");
+
+            _logger.info("Sending Msg:" + m);
+            producer.send(m);
+        }
+        _logger.info("sent " + count  + " mesages");
+    }
+
+
+    void check() throws JMSException
+    {
+        List<String> actual = new ArrayList<String>();
+        for (JMSTextMessage m : received)
+        {
+            actual.add(m.getText());
+
+            // Check body write status
+            try
+            {
+                m.setText("Test text");
+                Assert.fail("Message should not be writeable");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                // normal execution
+            }
+
+            m.clearBody();
+
+            try
+            {
+                m.setText("Test text");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                Assert.fail("Message should be writeable");
+            }
+
+            // Check property write status
+            try
+            {
+                m.setStringProperty("test", "test");
+                Assert.fail("Message should not be writeable");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                // normal execution
+            }
+
+            m.clearProperties();
+
+            try
+            {
+                m.setStringProperty("test", "test");
+            }
+            catch (MessageNotWriteableException mnwe)
+            {
+                Assert.fail("Message should be writeable");
+            }
+
+        }
+
+        assertEqual(messages.iterator(), actual.iterator());
+    }
+
+    private static void assertEqual(Iterator expected, Iterator actual)
+    {
+        List<String> errors = new ArrayList<String>();
+        while (expected.hasNext() && actual.hasNext())
+        {
+            try
+            {
+                assertEqual(expected.next(), actual.next());
+            }
+            catch (Exception e)
+            {
+                errors.add(e.getMessage());
+            }
+        }
+        while (expected.hasNext())
+        {
+            errors.add("Expected " + expected.next() + " but no more actual values.");
+        }
+        while (actual.hasNext())
+        {
+            errors.add("Found " + actual.next() + " but no more expected values.");
+        }
+
+        if (!errors.isEmpty())
+        {
+            throw new RuntimeException(errors.toString());
+        }
+    }
+
+    private static void assertEqual(Object expected, Object actual)
+    {
+        if (!expected.equals(actual))
+        {
+            throw new RuntimeException("Expected '" + expected + "' found '" + actual + "'");
+        }
+    }
+
+    public void onMessage(Message message)
+    {
+        synchronized (received)
+        {
+            _logger.info("===== received one message");
+            received.add((JMSTextMessage) message);
+            _waitForCompletion.countDown();
+        }
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+
+
+
+    public static junit.framework.Test suite()
+    {
+         return new junit.framework.TestSuite(TextMessageTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/basic/close/CloseTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/close/CloseTest.java
new file mode 100644
index 0000000000..21eaad6d5b
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/basic/close/CloseTest.java
@@ -0,0 +1,70 @@
+/*
+ *  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.basic.close;
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.url.AMQBindingURL;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+
+public class CloseTest extends QpidTestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(CloseTest.class);
+
+    private static final String BROKER = "vm://:1";
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.setUp();
+    }
+
+    public void testCloseQueueReceiver() throws  Exception
+    {
+        AMQConnection connection = (AMQConnection) getConnection("guest", "guest");
+
+        Session session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        AMQQueue queue = new AMQQueue(new AMQBindingURL("test-queue"));
+        MessageConsumer consumer = session.createConsumer(queue);
+
+        MessageProducer producer_not_used_but_created_for_testing = session.createProducer(queue);
+
+        connection.start();
+
+        _logger.info("About to close consumer");
+
+        consumer.close();
+
+        _logger.info("Closed Consumer");
+        connection.close();
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/AMQConnectionTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/AMQConnectionTest.java
new file mode 100644
index 0000000000..c91c27e894
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/AMQConnectionTest.java
@@ -0,0 +1,194 @@
+/*
+ *
+ * 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;
+
+import javax.jms.JMSException;
+import javax.jms.QueueSession;
+import javax.jms.TopicSession;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.AMQTopic;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+public class AMQConnectionTest extends QpidTestCase
+{
+    private static AMQConnection _connection;
+    private static AMQTopic _topic;
+    private static AMQQueue _queue;
+    private static QueueSession _queueSession;
+    private static TopicSession _topicSession;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        _connection = (AMQConnection) getConnection("guest", "guest");
+        _topic = new AMQTopic(_connection.getDefaultTopicExchangeName(), new AMQShortString("mytopic"));
+        _queue = new AMQQueue(_connection.getDefaultQueueExchangeName(), new AMQShortString("myqueue"));
+    }
+
+    protected void tearDown() throws Exception
+    {
+        _connection.close();
+        super.tearDown();
+    }
+
+    /**
+     * Simple tests to check we can create TopicSession and QueueSession ok
+     * And that they throw exceptions where appropriate as per JMS spec
+     */
+
+    public void testCreateQueueSession() throws JMSException
+    {
+        _queueSession = _connection.createQueueSession(false, AMQSession.NO_ACKNOWLEDGE);
+    }
+
+    public void testCreateTopicSession() throws JMSException
+    {
+        _topicSession = _connection.createTopicSession(false, AMQSession.NO_ACKNOWLEDGE);
+    }
+
+    public void testTopicSessionCreateBrowser() throws JMSException
+    {
+        try
+        {
+            _topicSession.createBrowser(_queue);
+            fail("expected exception did not occur");
+        }
+        catch (javax.jms.IllegalStateException s)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected javax.jms.IllegalStateException, got " + e);
+        }
+    }
+
+    public void testTopicSessionCreateQueue() throws JMSException
+    {
+        try
+        {
+            _topicSession.createQueue("abc");
+            fail("expected exception did not occur");
+        }
+        catch (javax.jms.IllegalStateException s)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected javax.jms.IllegalStateException, got " + e);
+        }
+    }
+
+    public void testTopicSessionCreateTemporaryQueue() throws JMSException
+    {
+        try
+        {
+            _topicSession.createTemporaryQueue();
+            fail("expected exception did not occur");
+        }
+        catch (javax.jms.IllegalStateException s)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected javax.jms.IllegalStateException, got " + e);
+        }
+    }
+
+    public void testQueueSessionCreateTemporaryTopic() throws JMSException
+    {
+        try
+        {
+            _queueSession.createTemporaryTopic();
+            fail("expected exception did not occur");
+        }
+        catch (javax.jms.IllegalStateException s)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected javax.jms.IllegalStateException, got " + e);
+        }
+    }
+
+    public void testQueueSessionCreateTopic() throws JMSException
+    {
+        try
+        {
+            _queueSession.createTopic("abc");
+            fail("expected exception did not occur");
+        }
+        catch (javax.jms.IllegalStateException s)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected javax.jms.IllegalStateException, got " + e);
+        }
+    }
+
+    public void testQueueSessionDurableSubscriber() throws JMSException
+    {
+        try
+        {
+            _queueSession.createDurableSubscriber(_topic, "abc");
+            fail("expected exception did not occur");
+        }
+        catch (javax.jms.IllegalStateException s)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected javax.jms.IllegalStateException, got " + e);
+        }
+    }
+
+    public void testQueueSessionUnsubscribe() throws JMSException
+    {
+        try
+        {
+            _queueSession.unsubscribe("abc");
+            fail("expected exception did not occur");
+        }
+        catch (javax.jms.IllegalStateException s)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected javax.jms.IllegalStateException, got " + e);
+        }
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(AMQConnectionTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/AMQSessionTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/AMQSessionTest.java
new file mode 100644
index 0000000000..417b9b75f0
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/AMQSessionTest.java
@@ -0,0 +1,108 @@
+/*
+ *
+ * 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;
+
+import javax.jms.JMSException;
+import javax.jms.QueueReceiver;
+import javax.jms.TopicSubscriber;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.AMQTopic;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+/**
+ * Tests for QueueReceiver and TopicSubscriber creation methods on AMQSession
+ */
+public class AMQSessionTest extends QpidTestCase
+{
+
+    private static AMQSession _session;
+    private static AMQTopic _topic;
+    private static AMQQueue _queue;
+    private static AMQConnection _connection;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        _connection = (AMQConnection) getConnection("guest", "guest");
+        _topic = new AMQTopic(_connection,"mytopic");
+        _queue = new AMQQueue(_connection,"myqueue");
+        _session = (AMQSession) _connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+    }
+
+    protected void tearDown() throws Exception
+    {
+        try
+        {
+            _connection.close();
+        }
+        catch (JMSException e)
+        {
+            //just close
+        }
+        super.tearDown();
+    }
+
+    public void testCreateSubscriber() throws JMSException
+    {
+        TopicSubscriber subscriber = _session.createSubscriber(_topic);
+        assertEquals("Topic names should match from TopicSubscriber", _topic.getTopicName(), subscriber.getTopic().getTopicName());
+
+        subscriber = _session.createSubscriber(_topic, "abc", false);
+        assertEquals("Topic names should match from TopicSubscriber with selector", _topic.getTopicName(), subscriber.getTopic().getTopicName());
+    }
+
+    public void testCreateDurableSubscriber() throws JMSException
+    {
+       TopicSubscriber subscriber = _session.createDurableSubscriber(_topic, "mysubname");
+        assertEquals("Topic names should match from durable TopicSubscriber", _topic.getTopicName(), subscriber.getTopic().getTopicName());
+
+        subscriber = _session.createDurableSubscriber(_topic, "mysubname2", "abc", false);
+        assertEquals("Topic names should match from durable TopicSubscriber with selector", _topic.getTopicName(), subscriber.getTopic().getTopicName());
+    }
+
+    public void testCreateQueueReceiver() throws JMSException
+    {
+        QueueReceiver receiver = _session.createQueueReceiver(_queue);
+        assertEquals("Queue names should match from QueueReceiver", _queue.getQueueName(), receiver.getQueue().getQueueName());
+
+        receiver = _session.createQueueReceiver(_queue, "abc");
+        assertEquals("Queue names should match from QueueReceiver with selector", _queue.getQueueName(), receiver.getQueue().getQueueName());
+    }
+
+    public void testCreateReceiver() throws JMSException
+    {
+        QueueReceiver receiver = _session.createReceiver(_queue);
+        assertEquals("Queue names should match from QueueReceiver", _queue.getQueueName(), receiver.getQueue().getQueueName());
+
+        receiver = _session.createReceiver(_queue, "abc");
+        assertEquals("Queue names should match from QueueReceiver with selector", _queue.getQueueName(), receiver.getQueue().getQueueName());
+    }
+
+    public static void stopVmBrokers()
+    {
+        _queue = null;
+        _topic = null;
+        _session = null;
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/channelclose/ChannelCloseOkTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/channelclose/ChannelCloseOkTest.java
new file mode 100644
index 0000000000..b843f7c9c0
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/channelclose/ChannelCloseOkTest.java
@@ -0,0 +1,241 @@
+/*
+ *
+ * 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 junit.textui.TestRunner;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.transport.TransportConnection;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Destination;
+import javax.jms.ExceptionListener;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Due to bizarre exception handling all sessions are closed if you get
+ * a channel close request and no exception listener is registered.
+ * <p/>
+ * JIRA issue IBTBLZ-10.
+ * <p/>
+ * Simulate by:
+ * <p/>
+ * 0. Create two sessions with no exception listener.
+ * 1. Publish message to queue/topic that does not exist (wrong routing key).
+ * 2. This will cause a channel close.
+ * 3. Since client does not have an exception listener, currently all sessions are
+ * closed.
+ */
+public class ChannelCloseOkTest extends QpidTestCase
+{
+    private AMQConnection _connection;
+    private Destination _destination1;
+    private Destination _destination2;
+    private Session _session1;
+    private Session _session2;
+    private final List<Message> _received1 = new ArrayList<Message>();
+    private final List<Message> _received2 = new ArrayList<Message>();
+
+    private static final Logger _log = LoggerFactory.getLogger(ChannelCloseOkTest.class);
+    public String _connectionString = "vm://:1";
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+
+        TransportConnection.createVMBroker(1);
+        _connection =  (AMQConnection) getConnection("guest", "guest");
+
+        _destination1 = new AMQQueue(_connection, "q1", true);
+        _destination2 = new AMQQueue(_connection, "q2", true);
+        _session1 = _connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+        _session1.createConsumer(_destination1).setMessageListener(new MessageListener()
+            {
+                public void onMessage(Message message)
+                {
+                    _log.debug("consumer 1 got message [" + getTextMessage(message) + "]");
+                    synchronized (_received1)
+                    {
+                        _received1.add(message);
+                        _received1.notify();
+                    }
+                }
+            });
+        _session2 = _connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+        _session2.createConsumer(_destination2).setMessageListener(new MessageListener()
+            {
+                public void onMessage(Message message)
+                {
+                    _log.debug("consumer 2 got message [" + getTextMessage(message) + "]");
+                    synchronized (_received2)
+                    {
+                        _received2.add(message);
+                        _received2.notify();
+                    }
+                }
+            });
+
+        _connection.start();
+    }
+
+    private String getTextMessage(Message message)
+    {
+        TextMessage tm = (TextMessage) message;
+        try
+        {
+            return tm.getText();
+        }
+        catch (JMSException e)
+        {
+            return "oops " + e;
+        }
+    }
+
+    protected void tearDown() throws Exception
+    {
+        closeConnection();
+        super.tearDown();
+    }
+
+    public void closeConnection() throws JMSException
+    {
+        if (_connection != null)
+        {
+            _log.info(">>>>>>>>>>>>>>.. closing");
+            _connection.close();
+        }
+    }
+
+    public void testWithoutExceptionListener() throws Exception
+    {
+        doTest();
+    }
+
+    public void testWithExceptionListener() throws Exception
+    {
+        _connection.setExceptionListener(new ExceptionListener()
+            {
+                public void onException(JMSException jmsException)
+                {
+                    _log.warn("onException - " + jmsException.getMessage());
+                }
+            });
+
+        doTest();
+    }
+
+    public void doTest() throws Exception
+    {
+        // Check both sessions are ok.
+        sendAndWait(_session1, _destination1, "first", _received1, 1);
+        sendAndWait(_session2, _destination2, "second", _received2, 1);
+        assertEquals(1, _received1.size());
+        assertEquals(1, _received2.size());
+
+        // Now send message to incorrect destination on session 1.
+        Destination destination = new AMQQueue(_connection, "incorrect");
+        send(_session1, destination, "third"); // no point waiting as message will never be received.
+
+        // Ensure both sessions are still ok.
+        // Send a bunch of messages as this give time for the sessions to be erroneously closed.
+        final int num = 300;
+        for (int i = 0; i < num; ++i)
+        {
+            send(_session1, _destination1, "" + i);
+            send(_session2, _destination2, "" + i);
+        }
+
+        waitFor(_received1, num + 1);
+        waitFor(_received2, num + 1);
+
+        // Note that the third message is never received as it is sent to an incorrect destination.
+        assertEquals(num + 1, _received1.size());
+        assertEquals(num + 1, _received2.size());
+    }
+
+    private void sendAndWait(Session session, Destination destination, String message, List<Message> received, int count)
+        throws JMSException, InterruptedException
+    {
+        send(session, destination, message);
+        waitFor(received, count);
+    }
+
+    private void send(Session session, Destination destination, String message) throws JMSException
+    {
+        _log.debug("sending message " + message);
+        MessageProducer producer1 = session.createProducer(destination);
+        producer1.send(session.createTextMessage(message));
+    }
+
+    private void waitFor(List<Message> received, int count) throws InterruptedException
+    {
+        long timeout = 20000;
+
+        synchronized (received)
+        {
+            long start = System.currentTimeMillis();
+            while (received.size() < count)
+            {
+                if (System.currentTimeMillis() - start > timeout)
+                {
+                    fail("timeout expired waiting for messages");
+                }
+                try
+                {
+                     received.wait(timeout);
+                }
+                catch (InterruptedException e)
+                {
+                    _log.info("Interrupted: " + e);
+                    throw e;
+                }
+
+            }
+        }
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+
+    public static void main(String[] args)
+    {
+        TestRunner.run(ChannelCloseOkTest.class);
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(ChannelCloseOkTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/channelclose/ChannelCloseTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/channelclose/ChannelCloseTest.java
new file mode 100644
index 0000000000..d210f5e1a1
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/channelclose/ChannelCloseTest.java
@@ -0,0 +1,418 @@
+/*
+ *  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.AMQException;
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.failover.FailoverException;
+import org.apache.qpid.client.protocol.AMQProtocolHandler;
+import org.apache.qpid.client.transport.TransportConnection;
+import org.apache.qpid.framing.*;
+import org.apache.qpid.jms.ConnectionListener;
+import org.apache.qpid.protocol.AMQConstant;
+import org.apache.qpid.url.URLSyntaxException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.ExceptionListener;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+
+public class ChannelCloseTest extends QpidTestCase implements ExceptionListener, ConnectionListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(ChannelCloseTest.class);
+
+    Connection _connection;
+    private String _brokerlist = "vm://:1";
+    private Session _session;
+    private static final long SYNC_TIMEOUT = 500;
+    private int TEST = 0;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        TransportConnection.createVMBroker(1);
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+        TransportConnection.killAllVMBrokers();
+    }
+
+    /*
+          close channel, use chanel with same id ensure error.
+     */
+    public void testReusingChannelAfterFullClosure() throws Exception
+    {
+        // this is testing an 0.8 conneciton 
+        if(isBroker08())
+        {
+            _connection=newConnection();
+
+            // Create Producer
+            try
+            {
+                _connection.start();
+
+                createChannelAndTest(1);
+
+                // Cause it to close
+                try
+                {
+                    _logger.info("Testing invalid exchange");
+                    declareExchange(1, "", "name_that_will_lookup_to_null", false);
+                    fail("Exchange name is empty so this should fail ");
+                }
+                catch (AMQException e)
+                {
+                    assertEquals("Exchange should not be found", AMQConstant.NOT_FOUND, e.getErrorCode());
+                }
+
+                // Check that
+                try
+                {
+                    _logger.info("Testing valid exchange should fail");
+                    declareExchange(1, "topic", "amq.topic", false);
+                    fail("This should not succeed as the channel should be closed ");
+                }
+                catch (AMQException e)
+                {
+                    if (_logger.isInfoEnabled())
+                    {
+                        _logger.info("Exception occured was:" + e.getErrorCode());
+                    }
+
+                    assertEquals("Connection should be closed", AMQConstant.CHANNEL_ERROR, e.getErrorCode());
+
+                    _connection=newConnection();
+                }
+
+                checkSendingMessage();
+
+                _session.close();
+                _connection.close();
+
+            }
+            catch (JMSException e)
+            {
+                e.printStackTrace();
+                fail(e.getMessage());
+            }
+        }
+    }
+
+    /*
+    close channel and send guff then send ok no errors
+    REMOVE TEST - The behaviour after server has sent close is undefined.
+    the server should be free to fail as it may wish to reclaim its resources
+    immediately after close.
+     */
+    /*public void testSendingMethodsAfterClose() throws Exception
+    {
+        // this is testing an 0.8 connection
+        if(isBroker08())
+        {
+            try
+            {
+                _connection=new AMQConnection("amqp://guest:guest@CCTTest/test?brokerlist='" + _brokerlist + "'");
+
+                ((AMQConnection) _connection).setConnectionListener(this);
+
+                _connection.setExceptionListener(this);
+
+                // Change the StateManager for one that doesn't respond with Close-OKs
+                AMQStateManager oldStateManager=((AMQConnection) _connection).getProtocolHandler().getStateManager();
+
+                _session=_connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+
+                _connection.start();
+
+                // Test connection
+                checkSendingMessage();
+
+                // Set StateManager to manager that ignores Close-oks
+                AMQProtocolSession protocolSession=
+                        ((AMQConnection) _connection).getProtocolHandler().getProtocolSession();
+                
+                MethodDispatcher d = protocolSession.getMethodDispatcher();
+
+                MethodDispatcher wrappedDispatcher = (MethodDispatcher)
+                        Proxy.newProxyInstance(d.getClass().getClassLoader(),
+                                               d.getClass().getInterfaces(),
+                                               new MethodDispatcherProxyHandler(
+                                                     (ClientMethodDispatcherImpl) d));
+
+                protocolSession.setMethodDispatcher(wrappedDispatcher);
+
+
+		AMQStateManager newStateManager=new NoCloseOKStateManager(protocolSession);
+                newStateManager.changeState(oldStateManager.getCurrentState());
+
+                ((AMQConnection) _connection).getProtocolHandler().setStateManager(newStateManager);
+
+                final int TEST_CHANNEL=1;
+                _logger.info("Testing Channel(" + TEST_CHANNEL + ") Creation");
+
+                createChannelAndTest(TEST_CHANNEL);
+
+                // Cause it to close
+                try
+                {
+                    _logger.info("Closing Channel - invalid exchange");
+                    declareExchange(TEST_CHANNEL, "", "name_that_will_lookup_to_null", false);
+                    fail("Exchange name is empty so this should fail ");
+                }
+                catch (AMQException e)
+                {
+                    assertEquals("Exchange should not be found", AMQConstant.NOT_FOUND, e.getErrorCode());
+                }
+
+                try
+                {
+                    // Send other methods that should be ignored
+                    // send them no wait as server will ignore them
+                    _logger.info("Tested known exchange - should ignore");
+                    declareExchange(TEST_CHANNEL, "topic", "amq.topic", true);
+
+                    _logger.info("Tested known invalid exchange - should ignore");
+                    declareExchange(TEST_CHANNEL, "", "name_that_will_lookup_to_null", true);
+
+                    _logger.info("Tested known invalid exchange - should ignore");
+                    declareExchange(TEST_CHANNEL, "", "name_that_will_lookup_to_null", true);
+
+                    // Send sync .. server will igore and timy oue
+                    _logger.info("Tested known invalid exchange - should ignore");
+                    declareExchange(TEST_CHANNEL, "", "name_that_will_lookup_to_null", false);
+                }
+                catch (AMQTimeoutException te)
+                {
+                    assertEquals("Request should timeout", AMQConstant.REQUEST_TIMEOUT, te.getErrorCode());
+                }
+                catch (AMQException e)
+                {
+                    fail("This should not fail as all requests should be ignored");
+                }
+
+                _logger.info("Sending Close");
+                // Send Close-ok
+                sendClose(TEST_CHANNEL);
+
+                _logger.info("Re-opening channel");
+
+                createChannelAndTest(TEST_CHANNEL);
+
+                // Test connection is still ok
+
+                checkSendingMessage();
+
+            }
+            catch (JMSException e)
+            {
+                e.printStackTrace();
+                fail(e.getMessage());
+            }
+            catch (AMQException e)
+            {
+                fail(e.getMessage());
+
+            }
+            catch (URLSyntaxException e)
+            {
+                fail(e.getMessage());
+            }
+            finally
+            {
+                try
+                {
+                    _session.close();
+                    _connection.close();
+                }
+                catch (JMSException e)
+                {
+                    e.printStackTrace();
+                    fail(e.getMessage());
+                }
+            }
+        }
+    }
+*/
+    private void createChannelAndTest(int channel) throws FailoverException
+    {
+        // Create A channel
+        try
+        {
+            createChannel(channel);
+        }
+        catch (AMQException e)
+        {
+            fail(e.getMessage());
+        }
+
+        // Test it is ok
+        try
+        {
+            declareExchange(channel, "topic", "amq.topic", false);
+            _logger.info("Tested known exchange");
+        }
+        catch (AMQException e)
+        {
+            fail("This should not fail as this is the default exchange details");
+        }
+    }
+
+    private void sendClose(int channel)
+    {
+        ChannelCloseOkBody body =
+                ((AMQConnection) _connection).getProtocolHandler().getMethodRegistry().createChannelCloseOkBody();
+        AMQFrame frame = body.generateFrame(channel);
+
+        ((AMQConnection) _connection).getProtocolHandler().writeFrame(frame);
+    }
+
+    private void checkSendingMessage() throws JMSException
+    {
+        TEST++;
+        _logger.info("Test creating producer which will use channel id 1");
+
+        Queue queue = _session.createQueue("CCT_test_validation_queue" + TEST);
+
+        MessageConsumer consumer = _session.createConsumer(queue);
+
+        MessageProducer producer = _session.createProducer(queue);
+
+        final String MESSAGE = "CCT_Test_Message";
+        producer.send(_session.createTextMessage(MESSAGE));
+
+        Message msg = consumer.receive(2000);
+
+        assertNotNull("Received messages should not be null.", msg);
+        assertEquals("Message received not what we sent", MESSAGE, ((TextMessage) msg).getText());
+    }
+
+    private Connection newConnection()
+    {
+        AMQConnection connection = null;
+        try
+        {
+            connection = new AMQConnection("amqp://guest:guest@CCTTest/test?brokerlist='" + _brokerlist + "'");
+
+            connection.setConnectionListener(this);
+
+            _session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+
+            connection.start();
+
+        }
+        catch (JMSException e)
+        {
+            fail("Creating new connection when:" + e.getMessage());
+        }
+        catch (AMQException e)
+        {
+            fail("Creating new connection when:" + e.getMessage());
+        }
+        catch (URLSyntaxException e)
+        {
+            fail("Creating new connection when:" + e.getMessage());
+        }
+
+        return connection;
+    }
+
+    private void declareExchange(int channelId, String _type, String _name, boolean nowait)
+        throws AMQException, FailoverException
+    {
+        ExchangeDeclareBody body =
+                ((AMQConnection) _connection).getProtocolHandler()
+                        .getMethodRegistry()
+                        .createExchangeDeclareBody(0,
+                                                   new AMQShortString(_name),
+                                                   new AMQShortString(_type),
+                                                   true,
+                                                   false,
+                                                   false,
+                                                   false,
+                                                   nowait,
+                                                   null);
+                AMQFrame exchangeDeclare = body.generateFrame(channelId);
+                AMQProtocolHandler protocolHandler = ((AMQConnection) _connection).getProtocolHandler();
+
+
+                if (nowait)
+                {
+                    protocolHandler.writeFrame(exchangeDeclare);
+                }
+                else
+                {
+                    protocolHandler.syncWrite(exchangeDeclare, ExchangeDeclareOkBody.class, SYNC_TIMEOUT);
+                }
+
+//                return null;
+//            }
+//        }, (AMQConnection)_connection).execute();
+
+    }
+
+    private void createChannel(int channelId) throws AMQException, FailoverException
+    {
+        ChannelOpenBody body =
+                ((AMQConnection) _connection).getProtocolHandler().getMethodRegistry().createChannelOpenBody(null);
+
+        ((AMQConnection) _connection).getProtocolHandler().syncWrite(body.generateFrame(channelId), // outOfBand
+            ChannelOpenOkBody.class);
+
+    }
+
+    public void onException(JMSException jmsException)
+    {
+        // _logger.info("CCT" + jmsException);
+        fail(jmsException.getMessage());
+    }
+
+    public void bytesSent(long count)
+    { }
+
+    public void bytesReceived(long count)
+    { }
+
+    public boolean preFailover(boolean redirect)
+    {
+        return false;
+    }
+
+    public boolean preResubscribe()
+    {
+        return false;
+    }
+
+    public void failoverComplete()
+    { }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/channelclose/CloseWithBlockingReceiveTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/channelclose/CloseWithBlockingReceiveTest.java
new file mode 100644
index 0000000000..d4d19a34ea
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/channelclose/CloseWithBlockingReceiveTest.java
@@ -0,0 +1,81 @@
+/*
+ *
+ * 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 javax.jms.MessageConsumer;
+import javax.jms.Session;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQTopic;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+/**
+ * @author Apache Software Foundation
+ */
+public class CloseWithBlockingReceiveTest extends QpidTestCase
+{
+
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+
+    public void testReceiveReturnsNull() throws Exception
+    {
+        final AMQConnection connection =  (AMQConnection) getConnection("guest", "guest");
+        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+        MessageConsumer consumer = session.createConsumer(new AMQTopic(connection, "banana"));
+        connection.start();
+
+        Runnable r = new Runnable()
+        {
+
+            public void run()
+            {
+                try
+                {
+                    Thread.sleep(1000);
+                    connection.close();
+                }
+                catch (Exception e)
+                {
+                }
+            }
+        };
+        long startTime = System.currentTimeMillis();
+        new Thread(r).start();
+        consumer.receive(10000);
+        assertTrue(System.currentTimeMillis() - startTime < 10000);
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(CloseWithBlockingReceiveTest.class);
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ConnectionCloseTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ConnectionCloseTest.java
new file mode 100644
index 0000000000..b932b1d784
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ConnectionCloseTest.java
@@ -0,0 +1,108 @@
+/*
+ *
+ * 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.connection;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.transport.util.Logger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.jms.Connection;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+
+/**
+ * ConnectionCloseTest
+ *
+ */
+
+public class ConnectionCloseTest extends QpidTestCase
+{
+
+    private static final Logger log = Logger.get(ConnectionCloseTest.class);
+
+    public void testSendReceiveClose() throws Exception
+    {
+        Map<Thread,StackTraceElement[]> before = Thread.getAllStackTraces();
+
+        for (int i = 0; i < 500; i++)
+        {
+            if ((i % 10) == 0)
+            {
+                log.warn("%d messages sent and received", i);
+            }
+
+            Connection receiver = getConnection();
+            receiver.start();
+            Session rssn = receiver.createSession(false, Session.AUTO_ACKNOWLEDGE);
+            Queue queue = rssn.createQueue("connection-close-test-queue");
+            MessageConsumer cons = rssn.createConsumer(queue);
+
+            Connection sender = getConnection();
+            sender.start();
+            Session sssn = sender.createSession(false, Session.AUTO_ACKNOWLEDGE);
+            MessageProducer prod = sssn.createProducer(queue);
+            prod.send(sssn.createTextMessage("test"));
+            sender.close();
+
+            TextMessage m = (TextMessage) cons.receive(2000);
+            assertNotNull("message was lost", m);
+            assertEquals(m.getText(), "test");
+            receiver.close();
+        }
+
+        // The finalizer is notifying connector thread waiting on a selector key.
+        // This should leave the finalizer enough time to notify those threads 
+        synchronized (this)
+        {
+            this.wait(1000);
+        }
+
+        Map<Thread,StackTraceElement[]> after = Thread.getAllStackTraces();
+
+        Map<Thread,StackTraceElement[]> delta = new HashMap<Thread,StackTraceElement[]>(after);
+        for (Thread t : before.keySet())
+        {
+            delta.remove(t);
+        }
+
+        dumpStacks(delta);
+
+        assertTrue("Spurious thread creation exceeded threshold, " +
+                   delta.size() + " threads created.",
+                   delta.size() < 10);
+    }
+
+    private void dumpStacks(Map<Thread,StackTraceElement[]> map)
+    {
+        for (Map.Entry<Thread,StackTraceElement[]> entry : map.entrySet())
+        {
+            Throwable t = new Throwable();
+            t.setStackTrace(entry.getValue());
+            log.warn(t, entry.getKey().toString());
+        }
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ConnectionStartTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ConnectionStartTest.java
new file mode 100644
index 0000000000..72691f3543
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ConnectionStartTest.java
@@ -0,0 +1,158 @@
+/*
+ *
+ * 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.connection;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+public class ConnectionStartTest extends QpidTestCase
+{
+
+    String _broker = "vm://:1";
+
+    AMQConnection _connection;
+    private Session _consumerSess;
+    private MessageConsumer _consumer;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        try
+        {
+
+
+            AMQConnection pubCon = (AMQConnection) getConnection("guest", "guest");
+
+            AMQQueue queue = new AMQQueue(pubCon,"ConnectionStartTest");
+
+            Session pubSess = pubCon.createSession(false, AMQSession.AUTO_ACKNOWLEDGE);
+
+            MessageProducer pub = pubSess.createProducer(queue);
+
+            _connection = (AMQConnection) getConnection("guest", "guest");
+
+            _consumerSess = _connection.createSession(false, AMQSession.AUTO_ACKNOWLEDGE);
+
+            _consumer = _consumerSess.createConsumer(queue);
+
+            //publish after queue is created to ensure it can be routed as expected
+            pub.send(pubSess.createTextMessage("Initial Message"));
+
+            pubCon.close();
+
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+            fail("Connection to " + _broker + " should succeed. Reason: " + e);
+        }
+    }
+
+    protected void tearDown() throws Exception
+    {
+        _connection.close();
+        super.tearDown();
+    }
+
+    public void testSimpleReceiveConnection()
+    {
+        try
+        {
+            assertTrue("Connection should not be started", !_connection.started());
+            //Note that this next line will start the dispatcher in the session
+            // should really not be called before _connection start
+            //assertTrue("There should not be messages waiting for the consumer", _consumer.receiveNoWait() == null);
+            _connection.start();
+            assertTrue("There should be messages waiting for the consumer", _consumer.receive(10*1000) != null);
+            assertTrue("Connection should be started", _connection.started());
+
+        }
+        catch (JMSException e)
+        {
+            fail("An error occured during test because:" + e);
+        }
+
+    }
+
+    public void testMessageListenerConnection()
+    {
+        final CountDownLatch _gotMessage = new CountDownLatch(1);
+
+        try
+        {
+            assertTrue("Connection should not be started", !_connection.started());
+            _consumer.setMessageListener(new MessageListener()
+            {
+                public void onMessage(Message message)
+                {
+                    try
+                    {
+                        assertTrue("Connection should be started", _connection.started());
+                        assertEquals("Mesage Received", "Initial Message", ((TextMessage) message).getText());
+                        _gotMessage.countDown();
+                    }
+                    catch (JMSException e)
+                    {
+                        fail("Couldn't get message text because:" + e.getCause());
+                    }
+                }
+            });
+
+            assertTrue("Connection should not be started", !_connection.started());
+            _connection.start();
+            assertTrue("Connection should be started", _connection.started());
+
+            try
+            {
+                assertTrue("Listener was never called", _gotMessage.await(10 * 1000, TimeUnit.MILLISECONDS));
+            }
+            catch (InterruptedException e)
+            {
+                fail("Timed out awaiting message via onMessage");
+            }
+
+        }
+        catch (JMSException e)
+        {
+            fail("Failed because:" + e.getCause());
+        }
+
+    }
+
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(ConnectionStartTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ConnectionTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ConnectionTest.java
new file mode 100644
index 0000000000..a6e8b80c9c
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ConnectionTest.java
@@ -0,0 +1,267 @@
+/*
+ *
+ * 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.connection;
+
+import org.apache.qpid.AMQConnectionFailureException;
+import org.apache.qpid.AMQException;
+import org.apache.qpid.AMQUnresolvedAddressException;
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.client.AMQAuthenticationException;
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQTopic;
+import org.apache.qpid.jms.Session;
+
+import javax.jms.Connection;
+import javax.jms.QueueSession;
+import javax.jms.TopicSession;
+import javax.naming.NamingException;
+
+public class ConnectionTest extends QpidTestCase
+{
+
+    String _broker_NotRunning = "vm://:2";
+    String _broker_BadDNS = "tcp://hg3sgaaw4lgihjs";
+
+    public String getBroker()
+    {
+        try
+        {
+            if (getConnectionFactory().getConnectionURL().getBrokerCount() > 0)
+            {
+                return getConnectionFactory().getConnectionURL().getBrokerDetails(0).toString();
+            }
+            else
+            {
+                fail("No broker details are available.");
+            }
+        }
+        catch (NamingException e)
+        {
+            fail(e.getMessage());
+        }
+
+        //keep compiler happy 
+        return null;
+    }
+
+    public void testSimpleConnection() throws Exception
+    {
+        AMQConnection conn = null;
+        try
+        {
+            conn = new AMQConnection(getBroker(), "guest", "guest", "fred", "test");
+        }
+        catch (Exception e)
+        {
+            fail("Connection to " + getBroker() + " should succeed. Reason: " + e);
+        }
+        finally
+        {
+            conn.close();
+        }
+    }
+
+    public void testDefaultExchanges() throws Exception
+    {
+        AMQConnection conn = null;
+        try
+        {
+            conn = new AMQConnection("amqp://guest:guest@clientid/test?brokerlist='"
+                                     + getBroker()
+                                     + "?retries='1''&defaultQueueExchange='test.direct'"
+                                     + "&defaultTopicExchange='test.topic'"
+                                     + "&temporaryQueueExchange='tmp.direct'"
+                                     + "&temporaryTopicExchange='tmp.topic'");
+
+            QueueSession queueSession = conn.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
+
+            AMQQueue queue = (AMQQueue) queueSession.createQueue("MyQueue");
+
+            assertEquals(queue.getExchangeName().toString(), "test.direct");
+
+            AMQQueue tempQueue = (AMQQueue) queueSession.createTemporaryQueue();
+
+            assertEquals(tempQueue.getExchangeName().toString(), "tmp.direct");
+
+            queueSession.close();
+
+            TopicSession topicSession = conn.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+
+            AMQTopic topic = (AMQTopic) topicSession.createTopic("silly.topic");
+
+            assertEquals(topic.getExchangeName().toString(), "test.topic");
+
+            AMQTopic tempTopic = (AMQTopic) topicSession.createTemporaryTopic();
+
+            assertEquals(tempTopic.getExchangeName().toString(), "tmp.topic");
+
+            topicSession.close();
+
+        }
+        catch (Exception e)
+        {
+            fail("Connection to " + getBroker() + " should succeed. Reason: " + e);
+        }
+        finally
+        {
+            conn.close();
+        }
+    }
+
+    public void testPasswordFailureConnection() throws Exception
+    {
+        AMQConnection conn = null;
+        try
+        {
+            conn = new AMQConnection("amqp://guest:rubbishpassword@clientid/test?brokerlist='" + getBroker() + "?retries='0''");
+            fail("Connection should not be established password is wrong.");
+        }
+        catch (AMQConnectionFailureException amqe)
+        {
+            assertNotNull("No cause set:" + amqe.getMessage(), amqe.getCause());
+            assertEquals("Exception was wrong type", AMQAuthenticationException.class, amqe.getCause().getClass());
+        }
+        finally
+        {
+            if (conn != null)
+            {
+                conn.close();
+            }
+        }
+    }
+
+    public void testConnectionFailure() throws Exception
+    {
+        AMQConnection conn = null;
+        try
+        {
+            conn = new AMQConnection("amqp://guest:guest@clientid/testpath?brokerlist='" + _broker_NotRunning + "?retries='0''");
+            fail("Connection should not be established");
+        }
+        catch (AMQException amqe)
+        {
+            if (!(amqe instanceof AMQConnectionFailureException))
+            {
+                fail("Correct exception not thrown. Excpected 'AMQConnectionException' got: " + amqe);
+            }
+        }
+        finally
+        {
+            if (conn != null)
+            {
+                conn.close();
+            }
+        }
+
+    }
+
+    public void testUnresolvedHostFailure() throws Exception
+    {
+        AMQConnection conn = null;
+        try
+        {
+            conn = new AMQConnection("amqp://guest:guest@clientid/testpath?brokerlist='" + _broker_BadDNS + "?retries='0''");
+            fail("Connection should not be established");
+        }
+        catch (AMQException amqe)
+        {
+            if (!(amqe instanceof AMQUnresolvedAddressException))
+            {
+                fail("Correct exception not thrown. Excpected 'AMQUnresolvedAddressException' got: " + amqe);
+            }
+        }
+        finally
+        {
+            if (conn != null)
+            {
+                conn.close();
+            }
+        }
+
+    }
+
+    public void testUnresolvedVirtualHostFailure() throws Exception
+    {
+        AMQConnection conn = null;
+        try
+        {
+            conn = new AMQConnection("amqp://guest:guest@clientid/rubbishhost?brokerlist='" + getBroker() + "?retries='0''");
+            fail("Connection should not be established");
+        }
+        catch (AMQException amqe)
+        {
+            if (!(amqe instanceof AMQConnectionFailureException))
+            {
+                fail("Correct exception not thrown. Excpected 'AMQConnectionFailureException' got: " + amqe);
+            }
+        }
+        finally
+        {
+            if (conn != null)
+            {
+                conn.close();
+            }
+        }
+    }
+
+    public void testClientIdCannotBeChanged() throws Exception
+    {
+        Connection connection = new AMQConnection(getBroker(), "guest", "guest",
+                                                  "fred", "test");
+        try
+        {
+            connection.setClientID("someClientId");
+            fail("No IllegalStateException thrown when resetting clientid");
+        }
+        catch (javax.jms.IllegalStateException e)
+        {
+            // PASS
+        }
+        finally
+        {
+            if (connection != null)
+            {
+                connection.close();
+            }
+        }
+    }
+
+    public void testClientIdIsPopulatedAutomatically() throws Exception
+    {
+        Connection connection = new AMQConnection(getBroker(), "guest", "guest",
+                                                  null, "test");
+        try
+        {
+            assertNotNull(connection.getClientID());
+        }
+        finally
+        {
+            connection.close();
+        }
+        connection.close();
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(ConnectionTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ExceptionListenerTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ExceptionListenerTest.java
new file mode 100644
index 0000000000..6f31f7bc65
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/connection/ExceptionListenerTest.java
@@ -0,0 +1,62 @@
+/*
+ *
+ * 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.connection;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.apache.qpid.util.concurrent.Condition;
+
+import javax.jms.Connection;
+import javax.jms.ExceptionListener;
+import javax.jms.JMSException;
+
+/**
+ * ExceptionListenerTest
+ *
+ */
+
+public class ExceptionListenerTest extends QpidTestCase
+{
+
+    public void testBrokerDeath() throws Exception
+    {
+        Connection conn = getConnection("guest", "guest");
+
+        conn.start();
+
+        final Condition fired = new Condition();
+        conn.setExceptionListener(new ExceptionListener()
+        {
+            public void onException(JMSException e)
+            {
+                fired.set();
+            }
+        });
+
+        stopBroker();
+
+        if (!fired.get(3000))
+        {
+            fail("exception listener was not fired");
+        }
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/Client.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/Client.java
new file mode 100644
index 0000000000..0be11011b4
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/Client.java
@@ -0,0 +1,133 @@
+/*
+ *
+ * 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.forwardall;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+
+/**
+ * Declare a private temporary response queue,
+ * send a message to amq.direct with a well known routing key with the
+ * private response queue as the reply-to destination
+ * consume responses.
+ */
+public class Client implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(Client.class);
+
+    private final AMQConnection _connection;
+    private final AMQSession _session;
+    private final int _expected;
+    private int _count;
+    private static QpidTestCase _qct;
+
+    Client(String broker, int expected) throws Exception
+    {
+        this(connect(broker), expected);
+    }
+
+    public static void setQTC(QpidTestCase qtc)
+    {
+        _qct = qtc;
+    }
+    Client(AMQConnection connection, int expected) throws Exception
+    {
+        _connection = connection;
+        _expected = expected;
+        _session = (AMQSession) _connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+        AMQQueue response =
+            new AMQQueue(_connection.getDefaultQueueExchangeName(), new AMQShortString("ResponseQueue"), true);
+        _session.createConsumer(response).setMessageListener(this);
+        _connection.start();
+      //  AMQQueue service = new SpecialQueue(_connection, "ServiceQueue");
+        AMQQueue service  = (AMQQueue)  _session.createQueue("ServiceQueue") ;
+        Message request = _session.createTextMessage("Request!");
+        request.setJMSReplyTo(response);
+        MessageProducer prod = _session.createProducer(service);
+        prod.send(request);
+    }
+
+    void shutdownWhenComplete() throws Exception
+    {
+        waitUntilComplete();
+        _connection.close();
+    }
+
+    public synchronized void onMessage(Message response)
+    {
+
+        _logger.info("Received " + (++_count) + " of " + _expected + " responses.");
+        if (_count == _expected)
+        {
+
+            notifyAll();
+        }
+
+    }
+
+    synchronized void waitUntilComplete() throws Exception
+    {
+
+        if (_count < _expected)
+        {
+            wait(60000);
+        }
+
+        if (_count < _expected)
+        {
+            throw new Exception("Didn't receive all messages... got " + _count + " expected " + _expected);
+        }
+    }
+
+    static AMQConnection connect(String broker) throws Exception
+    {
+        //return new AMQConnection(broker, "guest", "guest", "Client" + System.currentTimeMillis(), "test");
+         return (AMQConnection) _qct.getConnection("guest", "guest") ;
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        final String connectionString;
+        final int expected;
+        if (argv.length == 0)
+        {
+            connectionString = "localhost:5672";
+            expected = 100;
+        }
+        else
+        {
+            connectionString = argv[0];
+            expected = Integer.parseInt(argv[1]);
+        }
+
+        new Client(connect(connectionString), expected).shutdownWhenComplete();
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/CombinedTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/CombinedTest.java
new file mode 100644
index 0000000000..a1001a6f5d
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/CombinedTest.java
@@ -0,0 +1,69 @@
+/*
+ *
+ * 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.forwardall;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Runs the Service's and Client parts of the test in the same process
+ * as the broker
+ */
+public class CombinedTest extends QpidTestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(CombinedTest.class);
+    private int run = 0;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        Service.setQTC(this);
+        Client.setQTC(this);
+    }
+
+    protected void tearDown() throws Exception
+    {
+        ServiceCreator.closeAll();
+        super.tearDown();
+    }
+
+    public void testForwardAll() throws Exception
+    {
+        while (run < 10)
+        {
+            int services =1;
+            ServiceCreator.start("vm://:1", services);
+
+            _logger.info("Starting " + ++run + " client...");
+
+            new Client("vm://:1", services).shutdownWhenComplete();
+
+
+            _logger.info("Completed " + run + " successfully!");
+        }
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(CombinedTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/Service.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/Service.java
new file mode 100644
index 0000000000..9cd8b183af
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/Service.java
@@ -0,0 +1,94 @@
+/*
+ *
+ * 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.forwardall;
+
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+/**
+ * Declare a queue and bind it to amq.direct with a 'well known' routing key,
+ * register a consumer for this queue and send a response to every message received.
+ */
+public class Service implements MessageListener
+{
+    private final AMQConnection _connection;
+    private final AMQSession _session;
+
+    private static QpidTestCase _qct;
+     
+
+    public static void setQTC(QpidTestCase qtc)
+    {
+        _qct = qtc;
+    }
+    Service(String broker) throws Exception
+    {
+        this(connect(broker));
+    }
+
+    Service(AMQConnection connection) throws Exception
+    {
+        _connection = connection;
+        //AMQQueue queue = new SpecialQueue(connection, "ServiceQueue");
+        _session = (AMQSession) _connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+          AMQQueue queue  = (AMQQueue)  _session.createQueue("ServiceQueue") ;
+        _session.createConsumer(queue).setMessageListener(this);
+        _connection.start();
+    }
+
+    public void onMessage(Message request)
+    {
+        try
+        {
+            Message response = _session.createTextMessage("Response!");
+            Destination replyTo = request.getJMSReplyTo();
+            _session.createProducer(replyTo).send(response);
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace(System.out);
+        }
+    }
+
+    public void close() throws JMSException
+    {
+        _connection.close();
+    }
+
+    static AMQConnection connect(String broker) throws Exception
+    {
+        //return new AMQConnection(broker, "guest", "guest", "Client" + System.currentTimeMillis(), "test");
+          return (AMQConnection) _qct.getConnection("guest", "guest") ;
+    }
+
+//    public static void main(String[] argv) throws Exception
+//    {
+//        String broker = argv.length == 0? "localhost:5672" : argv[0];
+//        new Service(broker);
+//    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/ServiceCreator.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/ServiceCreator.java
new file mode 100644
index 0000000000..be16f6b7ae
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/ServiceCreator.java
@@ -0,0 +1,112 @@
+/*
+ *
+ * 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.forwardall;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.JMSException;
+
+public class ServiceCreator implements Runnable
+{
+    private static final Logger _logger = LoggerFactory.getLogger(ServiceCreator.class);
+
+    private static Thread[] threads;
+    private static ServiceCreator[] _services;
+
+    private final String broker;
+    private Service service;
+
+    ServiceCreator(String broker)
+    {
+        this.broker = broker;
+    }
+
+    public void run()
+    {
+        try
+        {
+            service = new Service(broker);
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace(System.out);
+        }
+    }
+
+    public void closeSC() throws JMSException
+    {
+        service.close();
+    }
+
+    static void closeAll()
+    {
+        for (int i = 0; i < _services.length; i++)
+        {
+            try
+            {
+                _services[i].closeSC();
+            }
+            catch (JMSException e)
+            {
+                // ignore
+            }
+        }
+    }
+
+    static void start(String broker, int services) throws InterruptedException
+    {
+        threads = new Thread[services];
+        _services = new ServiceCreator[services];
+        ServiceCreator runner = new ServiceCreator(broker);
+        // start services
+        _logger.info("Starting " + services + " services...");
+        for (int i = 0; i < services; i++)
+        {
+            threads[i] = new Thread(runner);
+            _services[i] = runner;
+            threads[i].start();
+        }
+
+        for (int i = 0; i < threads.length; i++)
+        {
+            threads[i].join();
+        }
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        final String connectionString;
+        final int services;
+        if (argv.length == 0)
+        {
+            connectionString = "localhost:5672";
+            services = 100;
+        }
+        else
+        {
+            connectionString = argv[0];
+            services = Integer.parseInt(argv[1]);
+        }
+
+        start(connectionString, services);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/VMBrokerSetup.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/SpecialQueue.java
index e859fac4af..27371b0397 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/VMBrokerSetup.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/forwardall/SpecialQueue.java
@@ -1,4 +1,5 @@
 /*
+ *
  * 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
@@ -17,36 +18,29 @@
  * under the License.
  *
  */
-package org.apache.qpid.test;
-
-import junit.extensions.TestSetup;
-import junit.framework.Test;
+package org.apache.qpid.test.unit.client.forwardall;
 
-import org.apache.qpid.client.transport.TransportConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.framing.AMQShortString;
 
-public class VMBrokerSetup extends TestSetup
+/**
+ * Queue that allows several private queues to be registered and bound
+ * to an exchange with the same routing key.
+ *
+ */
+class SpecialQueue extends AMQQueue
 {
-    public VMBrokerSetup(Test t)
-    {
-        super(t);
-    }
+    private final AMQShortString name;
 
-    protected void setUp() throws Exception
+    SpecialQueue(AMQConnection con, String name)
     {
-        super.setUp();
-        try
-        {
-            TransportConnection.createVMBroker(1);
-        }
-        catch (Exception e)
-        {
-            fail("Unable to create broker: " + e);
-        }
+        super(con, name, true);
+        this.name = new AMQShortString(name);
     }
 
-    protected void tearDown() throws Exception
+    public AMQShortString getRoutingKey()
     {
-        TransportConnection.killVMBroker(1);
-        super.tearDown();
+        return name;
     }
 }
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/message/ObjectMessageTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/message/ObjectMessageTest.java
new file mode 100644
index 0000000000..e67760a6c3
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/message/ObjectMessageTest.java
@@ -0,0 +1,335 @@
+/*
+ *
+ * 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 org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQDestination;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.ObjectMessage;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+
+public class ObjectMessageTest extends QpidTestCase implements MessageListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(ObjectMessageTest.class);
+
+    private AMQConnection connection;
+    private AMQDestination destination;
+    private AMQSession session;
+    private MessageProducer producer;
+    private Serializable[] data;
+    private volatile boolean waiting;
+    private int received;
+    private final ArrayList items = new ArrayList();
+
+    private String _broker = "vm://:1";
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        connection =  (AMQConnection) getConnection("guest", "guest");
+        destination = new AMQQueue(connection, randomize("LatencyTest"), true);
+        session = (AMQSession) connection.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+
+        // set up a consumer
+        session.createConsumer(destination).setMessageListener(this);
+        connection.start();
+
+        // create a publisher
+        producer = session.createProducer(destination, false, false, true);
+        A a1 = new A(1, "A");
+        A a2 = new A(2, "a");
+        B b = new B(1, "B");
+        C c = new C();
+        c.put("A1", a1);
+        c.put("a2", a2);
+        c.put("B", b);
+        c.put("String", "String");
+
+        data = new Serializable[] { a1, a2, b, c, "Hello World!", new Integer(1001) };
+    }
+
+    protected void tearDown() throws Exception
+    {
+        close();
+        super.tearDown();
+    }
+
+    public ObjectMessageTest()
+    { }
+
+    ObjectMessageTest(String broker) throws Exception
+    {
+        _broker = broker;
+    }
+
+    public void testSendAndReceive() throws Exception
+    {
+        try
+        {
+            send();
+            waitUntilReceived(data.length);
+            check();
+            _logger.info("All " + data.length + " items matched.");
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+            fail("This Test should succeed but failed due to: " + e);
+        }
+    }
+
+    public void testSetObjectPropertyForString() throws Exception
+    {
+        String testStringProperty = "TestStringProperty";
+        ObjectMessage msg = session.createObjectMessage(data[0]);
+        msg.setObjectProperty("TestStringProperty", testStringProperty);
+        assertEquals(testStringProperty, msg.getObjectProperty("TestStringProperty"));
+    }
+
+    public void testSetObjectPropertyForBoolean() throws Exception
+    {
+        ObjectMessage msg = session.createObjectMessage(data[0]);
+        msg.setObjectProperty("TestBooleanProperty", Boolean.TRUE);
+        assertEquals(Boolean.TRUE, msg.getObjectProperty("TestBooleanProperty"));
+    }
+
+    public void testSetObjectPropertyForByte() throws Exception
+    {
+        ObjectMessage msg = session.createObjectMessage(data[0]);
+        msg.setObjectProperty("TestByteProperty", Byte.MAX_VALUE);
+        assertEquals(Byte.MAX_VALUE, msg.getObjectProperty("TestByteProperty"));
+    }
+
+    public void testSetObjectPropertyForShort() throws Exception
+    {
+        ObjectMessage msg = session.createObjectMessage(data[0]);
+        msg.setObjectProperty("TestShortProperty", Short.MAX_VALUE);
+        assertEquals(Short.MAX_VALUE, msg.getObjectProperty("TestShortProperty"));
+    }
+
+    public void testSetObjectPropertyForInteger() throws Exception
+    {
+        ObjectMessage msg = session.createObjectMessage(data[0]);
+        msg.setObjectProperty("TestIntegerProperty", Integer.MAX_VALUE);
+        assertEquals(Integer.MAX_VALUE, msg.getObjectProperty("TestIntegerProperty"));
+    }
+
+    public void testSetObjectPropertyForDouble() throws Exception
+    {
+        ObjectMessage msg = session.createObjectMessage(data[0]);
+        msg.setObjectProperty("TestDoubleProperty", Double.MAX_VALUE);
+        assertEquals(Double.MAX_VALUE, msg.getObjectProperty("TestDoubleProperty"));
+    }
+
+    public void testSetObjectPropertyForFloat() throws Exception
+    {
+        ObjectMessage msg = session.createObjectMessage(data[0]);
+        msg.setObjectProperty("TestFloatProperty", Float.MAX_VALUE);
+        assertEquals(Float.MAX_VALUE, msg.getObjectProperty("TestFloatProperty"));
+    }
+
+    public void testSetObjectPropertyForByteArray() throws Exception
+    {
+        byte[] array = { 1, 2, 3, 4, 5 };
+        ObjectMessage msg = session.createObjectMessage(data[0]);
+        msg.setObjectProperty("TestByteArrayProperty", array);
+        assertTrue(Arrays.equals(array, (byte[]) msg.getObjectProperty("TestByteArrayProperty")));
+    }
+
+    public void testSetObjectForNull() throws Exception
+    {
+        ObjectMessage msg = session.createObjectMessage();
+        msg.setObject(null);
+        assertNull(msg.getObject());
+    }
+
+    private void send() throws Exception
+    {
+        for (int i = 0; i < data.length; i++)
+        {
+            ObjectMessage msg;
+            if ((i % 2) == 0)
+            {
+                msg = session.createObjectMessage(data[i]);
+            }
+            else
+            {
+                msg = session.createObjectMessage();
+                msg.setObject(data[i]);
+            }
+
+            producer.send(msg);
+        }
+    }
+
+    public void check() throws Exception
+    {
+        Object[] actual = (Object[]) items.toArray();
+        if (actual.length != data.length)
+        {
+            throw new Exception("Expected " + data.length + " objects, got " + actual.length);
+        }
+
+        for (int i = 0; i < data.length; i++)
+        {
+            if (actual[i] instanceof Exception)
+            {
+                throw new Exception("Error on receive of " + data[i], ((Exception) actual[i]));
+            }
+
+            if (actual[i] == null)
+            {
+                throw new Exception("Expected " + data[i] + " got null");
+            }
+
+            if (!data[i].equals(actual[i]))
+            {
+                throw new Exception("Expected " + data[i] + " got " + actual[i]);
+            }
+        }
+    }
+
+    private void close() throws Exception
+    {
+        session.close();
+        connection.close();
+    }
+
+    private synchronized void waitUntilReceived(int count) throws InterruptedException
+    {
+        waiting = true;
+        while (received < count)
+        {
+            wait();
+        }
+
+        waiting = false;
+    }
+
+    public void onMessage(Message message)
+    {
+
+        try
+        {
+            if (message instanceof ObjectMessage)
+            {
+                items.add(((ObjectMessage) message).getObject());
+            }
+            else
+            {
+                _logger.error("ERROR: Got " + message.getClass().getName() + " not ObjectMessage");
+                items.add(message);
+            }
+        }
+        catch (JMSException e)
+        {
+            e.printStackTrace();
+            items.add(e);
+        }
+
+        synchronized (this)
+        {
+            received++;
+            notify();
+        }
+    }
+
+    public static void main(String[] argv) throws Exception
+    {
+        String broker = (argv.length > 0) ? argv[0] : "vm://:1";
+        if ("-help".equals(broker))
+        {
+            System.out.println("Usage: <broker>");
+        }
+
+        new ObjectMessageTest(broker).testSendAndReceive();
+    }
+
+    private static class A implements Serializable
+    {
+        private String sValue;
+        private int iValue;
+
+        A(int i, String s)
+        {
+            sValue = s;
+            iValue = i;
+        }
+
+        public int hashCode()
+        {
+            return iValue;
+        }
+
+        public boolean equals(Object o)
+        {
+            return (o instanceof A) && equals((A) o);
+        }
+
+        protected boolean equals(A a)
+        {
+            return areEqual(a.sValue, sValue) && (a.iValue == iValue);
+        }
+    }
+
+    private static class B extends A
+    {
+        private long time;
+
+        B(int i, String s)
+        {
+            super(i, s);
+            time = System.currentTimeMillis();
+        }
+
+        protected boolean equals(A a)
+        {
+            return super.equals(a) && (a instanceof B) && (time == ((B) a).time);
+        }
+    }
+
+    private static class C extends HashMap implements Serializable
+    { }
+
+    private static boolean areEqual(Object a, Object b)
+    {
+        return (a == null) ? (b == null) : a.equals(b);
+    }
+
+    private static String randomize(String in)
+    {
+        return in + System.currentTimeMillis();
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/protocol/AMQProtocolSessionTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/protocol/AMQProtocolSessionTest.java
new file mode 100644
index 0000000000..91cb37e455
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/protocol/AMQProtocolSessionTest.java
@@ -0,0 +1,120 @@
+/*
+ *
+ * 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.protocol;
+
+import org.apache.mina.common.IoSession;
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.protocol.AMQProtocolHandler;
+import org.apache.qpid.client.protocol.AMQProtocolSession;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.test.utils.protocol.TestIoSession;
+
+public class AMQProtocolSessionTest extends QpidTestCase
+{
+    private static class AMQProtSession extends AMQProtocolSession
+    {
+
+        public AMQProtSession(AMQProtocolHandler protocolHandler, IoSession protocolSession, AMQConnection connection)
+        {
+            super(protocolHandler,protocolSession,connection);
+        }
+
+        public TestIoSession getMinaProtocolSession()
+        {
+            return (TestIoSession) _minaProtocolSession;
+        }
+
+        public AMQShortString genQueueName()
+        {
+            return generateQueueName();
+        }
+    }
+
+    //private Strings for test values and expected results
+    private String _brokenAddress = "tcp://myAddress;:";;
+    private String _generatedAddress;
+    private String _emptyAddress;
+    private String _generatedAddress_2;
+    private String _validAddress;
+    private String _generatedAddress_3;
+    private int _port;
+    private AMQProtSession _testSession;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+
+        //don't care about the values set here apart from the dummy IoSession
+        _testSession = new AMQProtSession(null,new TestIoSession(), (AMQConnection) getConnection("guest", "guest"));
+
+        //initialise addresses for test and expected results
+        _port = 123;
+        _brokenAddress = "tcp://myAddress;:";
+        _generatedAddress = "tmp_tcpmyAddress123_1";
+        _emptyAddress = "";
+        _generatedAddress_2 = "tmp_localhost127.0.0.1123_2";
+        _validAddress = "abc";
+        _generatedAddress_3 = "tmp_abc123_3";
+    }
+
+    public void testGenerateQueueName()
+    {
+        AMQShortString testAddress;
+
+        //test address with / and ; chars which generateQueueName should removeKey
+        _testSession.getMinaProtocolSession().setStringLocalAddress(_brokenAddress);
+        _testSession.getMinaProtocolSession().setLocalPort(_port);
+
+        testAddress = _testSession.genQueueName();
+        assertEquals("Failure when generating a queue exchange from an address with special chars",_generatedAddress,testAddress.toString());
+
+        //test empty address
+        _testSession.getMinaProtocolSession().setStringLocalAddress(_emptyAddress);
+
+        testAddress = _testSession.genQueueName();
+        assertEquals("Failure when generating a queue exchange from an empty address",_generatedAddress_2,testAddress.toString());
+
+        //test address with no special chars
+        _testSession.getMinaProtocolSession().setStringLocalAddress(_validAddress);
+
+        testAddress = _testSession.genQueueName();
+        assertEquals("Failure when generating a queue exchange from an address with no special chars",_generatedAddress_3,testAddress.toString());
+
+    }
+
+    protected void tearDown() throws Exception
+    {
+        _testSession = null;
+        _brokenAddress = null;
+        _generatedAddress = null;
+        _emptyAddress = null;
+        _generatedAddress_2 = null;
+        _validAddress = null;
+        _generatedAddress_3 = null;
+        super.tearDown();
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(AMQProtocolSessionTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/client/temporaryqueue/TemporaryQueueTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/client/temporaryqueue/TemporaryQueueTest.java
new file mode 100644
index 0000000000..7a65b06dd4
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/client/temporaryqueue/TemporaryQueueTest.java
@@ -0,0 +1,220 @@
+/*
+ *
+ * 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.temporaryqueue;
+
+import javax.jms.Connection;
+import javax.jms.JMSException;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+import javax.jms.TemporaryQueue;
+import javax.jms.TextMessage;
+import junit.framework.Assert;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.client.AMQQueue;
+
+import java.util.List;
+import java.util.LinkedList;
+
+public class TemporaryQueueTest extends QpidTestCase
+{
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+       super.tearDown();
+    }
+
+    protected Connection createConnection() throws Exception
+    {
+        return  getConnection("guest", "guest");
+    }
+
+    public void testTempoaryQueue() throws Exception
+    {
+        Connection conn = createConnection();
+        Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
+        TemporaryQueue queue = session.createTemporaryQueue();
+        assertNotNull(queue);
+        MessageProducer producer = session.createProducer(queue);
+        MessageConsumer consumer = session.createConsumer(queue);
+        conn.start();
+        producer.send(session.createTextMessage("hello"));
+        TextMessage tm = (TextMessage) consumer.receive(2000);
+        assertNotNull(tm);
+        assertEquals("hello", tm.getText());
+
+        try
+        {
+            queue.delete();
+            fail("Expected JMSException : should not be able to delete while there are active consumers");
+        }
+        catch (JMSException je)
+        {
+            ; //pass
+        }
+
+        consumer.close();
+
+        try
+        {
+            queue.delete();
+        }
+        catch (JMSException je)
+        {
+            fail("Unexpected Exception: " + je.getMessage());
+        }
+
+        conn.close();
+    }
+
+    public void tUniqueness() throws Exception
+    {
+        int numProcs = Runtime.getRuntime().availableProcessors();
+        final int threadsProc = 5;
+
+        runUniqueness(1, 10);
+        runUniqueness(numProcs * threadsProc, 10);
+        runUniqueness(numProcs * threadsProc, 100);
+        runUniqueness(numProcs * threadsProc, 500);
+    }
+
+    void runUniqueness(int makers, int queues) throws Exception
+    {
+        Connection connection = createConnection();
+
+        Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+
+        List<TempQueueMaker> tqList = new LinkedList<TempQueueMaker>();
+
+        //Create Makers
+        for (int m = 0; m < makers; m++)
+        {
+            tqList.add(new TempQueueMaker(session, queues));
+        }
+
+
+        List<Thread> threadList = new LinkedList<Thread>();
+
+        //Create Makers
+        for (TempQueueMaker maker : tqList)
+        {
+            threadList.add(new Thread(maker));
+        }
+
+        //Start threads
+        for (Thread thread : threadList)
+        {
+            thread.start();
+        }
+
+        // Join Threads
+        for (Thread thread : threadList)
+        {
+            try
+            {
+                thread.join();
+            }
+            catch (InterruptedException e)
+            {
+                fail("Couldn't correctly join threads");
+            }
+        }
+
+
+        List<AMQQueue> list = new LinkedList<AMQQueue>();
+
+        // Test values
+        for (TempQueueMaker maker : tqList)
+        {
+            check(maker, list);
+        }
+
+        Assert.assertEquals("Not enough queues made.", makers * queues, list.size());
+
+        connection.close();
+    }
+
+    private void check(TempQueueMaker tq, List<AMQQueue> list)
+    {
+        for (AMQQueue q : tq.getList())
+        {
+            if (list.contains(q))
+            {
+                fail(q + " already exists.");
+            }
+            else
+            {
+                list.add(q);
+            }
+        }
+    }
+
+
+    class TempQueueMaker implements Runnable
+    {
+        List<AMQQueue> _queues;
+        Session _session;
+        private int _count;
+
+
+        TempQueueMaker(Session session, int queues) throws JMSException
+        {
+            _queues = new LinkedList<AMQQueue>();
+
+            _count = queues;
+
+            _session = session;
+        }
+
+        public void run()
+        {
+            int i = 0;
+            try
+            {
+                for (; i < _count; i++)
+                {
+                    _queues.add((AMQQueue) _session.createTemporaryQueue());
+                }
+            }
+            catch (JMSException jmse)
+            {
+                //stop
+            }
+        }
+
+        List<AMQQueue> getList()
+        {
+            return _queues;
+        }
+    }
+
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(TemporaryQueueTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/close/CloseBeforeAckTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/close/CloseBeforeAckTest.java
new file mode 100644
index 0000000000..a61bcca049
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/close/CloseBeforeAckTest.java
@@ -0,0 +1,142 @@
+/*
+ *
+ * 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.close;
+
+import junit.framework.Assert;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.qpid.junit.concurrency.TestRunnable;
+import org.apache.qpid.junit.concurrency.ThreadTestCoordinator;
+
+import javax.jms.Connection;
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.Session;
+
+/**
+ * This test forces the situation where a session is closed whilst a message consumer is still in its onMessage method.
+ * Running in AUTO_ACK mode, the close call ought to wait until the onMessage method completes, and the ack is sent
+ * before closing the connection.
+ *
+ * <p><table id="crc"><caption>CRC Card</caption> <tr><th> Responsibilities <th> Collaborations <tr><td> Check that
+ * closing a connection whilst handling a message, blocks till completion of the handler. </table>
+ */
+public class CloseBeforeAckTest extends QpidTestCase
+{
+    private static final Logger log = LoggerFactory.getLogger(CloseBeforeAckTest.class);
+
+    Connection connection;
+    Session session;
+    public static final String TEST_QUEUE_NAME = "TestQueue";
+    private int TEST_COUNT = 25;
+
+    class TestThread1 extends TestRunnable implements MessageListener
+    {
+        public void runWithExceptions() throws Exception
+        {
+            // Set this up to listen for message on the test session.
+            session.createConsumer(session.createQueue(TEST_QUEUE_NAME)).setMessageListener(this);
+        }
+
+        public void onMessage(Message message)
+        {
+            // Give thread 2 permission to close the session.
+            allow(new int[] { 1 });
+
+            // Wait until thread 2 has closed the connection, or is blocked waiting for this to complete.
+            waitFor(new int[] { 1 }, true);
+        }
+    }
+
+    TestThread1 testThread1 = new TestThread1();
+
+    TestRunnable testThread2 =
+        new TestRunnable()
+        {
+            public void runWithExceptions() throws Exception
+            {
+                // Send a message to be picked up by thread 1.
+                session.createProducer(null).send(session.createQueue(TEST_QUEUE_NAME),
+                    session.createTextMessage("Hi there thread 1!"));
+
+                // Wait for thread 1 to pick up the message and give permission to continue.
+                waitFor(new int[] { 0 }, false);
+
+                // Close the connection.
+                session.close();
+
+                // Allow thread 1 to continue to completion, if it is erronously still waiting.
+                allow(new int[] { 1 });
+            }
+        };
+
+    public void testCloseBeforeAutoAck_QPID_397() throws Exception
+    {
+        // Create a session in auto acknowledge mode. This problem shows up in auto acknowledge if the client acks
+        // message at the end of the onMessage method, after a close has been sent.
+        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
+
+        ThreadTestCoordinator tt = new ThreadTestCoordinator(2);
+
+        tt.addTestThread(testThread1, 0);
+        tt.addTestThread(testThread2, 1);
+        tt.setDeadlockTimeout(500);
+        tt.run();
+
+        String errorMessage = tt.joinAndRetrieveMessages();
+
+        // Print any error messages or exceptions.
+        log.debug(errorMessage);
+
+        if (!tt.getExceptions().isEmpty())
+        {
+            for (Exception e : tt.getExceptions())
+            {
+                log.debug("Exception thrown during test thread: ", e);
+            }
+        }
+
+        Assert.assertTrue(errorMessage, "".equals(errorMessage));
+    }
+
+    public void closeBeforeAutoAckManyTimes() throws Exception
+    {
+        for (int i = 0; i < TEST_COUNT; i++)
+        {
+            testCloseBeforeAutoAck_QPID_397();
+        }
+    }
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        connection =  getConnection("guest", "guest");
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/close/MessageRequeueTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/close/MessageRequeueTest.java
new file mode 100644
index 0000000000..ec23256f38
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/close/MessageRequeueTest.java
@@ -0,0 +1,372 @@
+/*
+ *  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.close;
+
+import org.apache.qpid.AMQException;
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.test.utils.QpidClientConnection;
+import org.apache.qpid.client.message.AbstractJMSMessage;
+import org.apache.qpid.url.URLSyntaxException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.Queue;
+import javax.jms.Session;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class MessageRequeueTest extends QpidTestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(MessageRequeueTest.class);
+
+    protected static AtomicInteger consumerIds = new AtomicInteger(0);
+    protected final Integer numTestMessages = 150;
+
+    protected final int consumeTimeout = 3000;
+
+    protected final String queue = "direct://amq.direct//message-requeue-test-queue";
+    protected String payload = "Message:";
+
+    protected final String BROKER = "vm://:1";
+    private boolean testReception = true;
+
+    private long[] receieved = new long[numTestMessages + 1];
+    private boolean passed = false;
+    QpidClientConnection conn;
+
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+
+        conn = new QpidClientConnection(BROKER);
+
+        conn.connect();
+        // clear queue
+        conn.consume(queue, consumeTimeout);
+        // load test data
+        _logger.info("creating test data, " + numTestMessages + " messages");
+        conn.put(queue, payload, numTestMessages);
+        // close this connection
+        conn.disconnect();
+    }
+
+    protected void tearDown() throws Exception
+    {
+
+        if (!passed) // clean up
+        {
+            QpidClientConnection conn = new QpidClientConnection(BROKER);
+
+            conn.connect();
+            // clear queue
+            conn.consume(queue, consumeTimeout);
+
+            conn.disconnect();
+        }
+
+        super.tearDown();
+    }
+
+    /**
+     * multiple consumers
+     *
+     * @throws javax.jms.JMSException if a JMS problem occurs
+     * @throws InterruptedException   on timeout
+     */
+    public void testDrain() throws Exception
+    {
+        QpidClientConnection conn = new QpidClientConnection(BROKER);
+
+        conn.connect();
+
+        _logger.info("consuming queue " + queue);
+        Queue q = conn.getSession().createQueue(queue);
+
+        final MessageConsumer consumer = conn.getSession().createConsumer(q);
+        int messagesReceived = 0;
+
+        long[] messageLog = new long[numTestMessages + 1];
+
+        _logger.info("consuming...");
+        Message msg = consumer.receive(1000);
+        while (msg != null)
+        {
+            messagesReceived++;
+
+            long dt = ((AbstractJMSMessage) msg).getDeliveryTag();
+
+            int msgindex = msg.getIntProperty("index");
+            if (messageLog[msgindex] != 0)
+            {
+                _logger.error("Received Message(" + msgindex + ":" + ((AbstractJMSMessage) msg).getDeliveryTag()
+                              + ") more than once.");
+            }
+
+            if (_logger.isInfoEnabled())
+            {
+                _logger.info("Received Message(" + System.identityHashCode(msgindex) + ") " + "DT:" + dt + "IN:" + msgindex);
+            }
+
+            if (dt == 0)
+            {
+                _logger.error("DT is zero for msg:" + msgindex);
+            }
+
+            messageLog[msgindex] = dt;
+
+            // get Next message
+            msg = consumer.receive(1000);
+        }
+
+        _logger.info("consuming done.");
+        conn.getSession().commit();
+        consumer.close();
+
+        int index = 0;
+        StringBuilder list = new StringBuilder();
+        list.append("Failed to receive:");
+        int failed = 0;
+
+        _logger.info("consumed: " + messagesReceived);
+
+        assertEquals("number of consumed messages does not match initial data", (int) numTestMessages, messagesReceived);
+        // wit 0_10 we can have a delivery tag of 0
+        if (conn.isBroker08())
+        {
+            for (long b : messageLog)
+            {
+                if ((b == 0) && (index != 0)) // delivery tag of zero shouldn't exist
+                {
+                    _logger.error("Index: " + index + " was not received.");
+                    list.append(" ");
+                    list.append(index);
+                    list.append(":");
+                    list.append(b);
+                    failed++;
+                }
+
+                index++;
+            }
+
+            assertEquals(list.toString(), 0, failed);
+        }
+
+        conn.disconnect();
+        passed = true;
+    }
+
+    /** multiple consumers
+     * Based on code subbmitted by client FT-304
+     */
+    public void testTwoCompetingConsumers()
+    {
+        Consumer c1 = new Consumer();
+        Consumer c2 = new Consumer();
+        Consumer c3 = new Consumer();
+        Consumer c4 = new Consumer();
+
+        Thread t1 = new Thread(c1);
+        Thread t2 = new Thread(c2);
+        Thread t3 = new Thread(c3);
+        Thread t4 = new Thread(c4);
+
+        t1.start();
+        t2.start();
+        t3.start();
+        // t4.start();
+
+        try
+        {
+            t1.join();
+            t2.join();
+            t3.join();
+            t4.join();
+        }
+        catch (InterruptedException e)
+        {
+            fail("Unable to join to Consumer theads");
+        }
+
+        _logger.info("consumer 1 count is " + c1.getCount());
+        _logger.info("consumer 2 count is " + c2.getCount());
+        _logger.info("consumer 3 count is " + c3.getCount());
+        _logger.info("consumer 4 count is " + c4.getCount());
+
+        Integer totalConsumed = c1.getCount() + c2.getCount() + c3.getCount() + c4.getCount();
+
+        // Check all messages were correctly delivered
+        int index = 0;
+        StringBuilder list = new StringBuilder();
+        list.append("Failed to receive:");
+        int failed = 0;
+        if (conn.isBroker08())
+        {
+            for (long b : receieved)
+            {
+                if ((b == 0) && (index != 0)) // delivery tag of zero shouldn't exist (and we don't have msg 0)
+                {
+                    _logger.error("Index: " + index + " was not received.");
+                    list.append(" ");
+                    list.append(index);
+                    list.append(":");
+                    list.append(b);
+                    failed++;
+                }
+
+                index++;
+            }
+
+            assertEquals(list.toString() + "-" + numTestMessages + "-" + totalConsumed, 0, failed);
+        }
+        assertEquals("number of consumed messages does not match initial data", numTestMessages, totalConsumed);
+        passed = true;
+    }
+
+    class Consumer implements Runnable
+    {
+        private Integer count = 0;
+        private Integer id;
+
+        public Consumer()
+        {
+            id = consumerIds.addAndGet(1);
+        }
+
+        public void run()
+        {
+            try
+            {
+                _logger.info("consumer-" + id + ": starting");
+                QpidClientConnection conn = new QpidClientConnection(BROKER);
+
+                conn.connect();
+
+                _logger.info("consumer-" + id + ": connected, consuming...");
+                Message result;
+                do
+                {
+                    result = conn.getNextMessage(queue, consumeTimeout);
+                    if (result != null)
+                    {
+
+                        long dt = ((AbstractJMSMessage) result).getDeliveryTag();
+
+                        if (testReception)
+                        {
+                            int msgindex = result.getIntProperty("index");
+                            if (receieved[msgindex] != 0)
+                            {
+                                _logger.error("Received Message(" + msgindex + ":"
+                                    + ((AbstractJMSMessage) result).getDeliveryTag() + ") more than once.");
+                            }
+
+                            if (_logger.isInfoEnabled())
+                            {
+                                _logger.info("Received Message(" + System.identityHashCode(msgindex) + ") " + "DT:" + dt
+                                    + "IN:" + msgindex);
+                            }
+
+                            if (dt == 0)
+                            {
+                                _logger.error("DT is zero for msg:" + msgindex);
+                            }
+
+                            receieved[msgindex] = dt;
+                        }
+
+                        count++;
+                        if ((count % 100) == 0)
+                        {
+                            _logger.info("consumer-" + id + ": got " + result + ", new count is " + count);
+                        }
+                    }
+                }
+                while (result != null);
+
+                _logger.info("consumer-" + id + ": complete");
+                conn.disconnect();
+
+            }
+            catch (Exception e)
+            {
+                e.printStackTrace();
+            }
+        }
+
+        public Integer getCount()
+        {
+            return count;
+        }
+
+        public Integer getId()
+        {
+            return id;
+        }
+    }
+
+    public void testRequeue() throws JMSException, AMQException, URLSyntaxException
+    {
+        int run = 0;
+        // while (run < 10)
+        {
+            run++;
+
+            if (_logger.isInfoEnabled())
+            {
+                _logger.info("testRequeue run " + run);
+            }
+
+            String virtualHost = "/test";
+            String brokerlist = BROKER;
+            String brokerUrl = "amqp://guest:guest@" + virtualHost + "?brokerlist='" + brokerlist + "'";
+            QpidClientConnection qpc =      new QpidClientConnection(BROKER);
+            qpc.connect();
+            Connection conn = qpc. getConnection();
+
+            Session session = conn.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+            Queue q = session.createQueue(queue);
+
+            _logger.debug("Create Consumer");
+            MessageConsumer consumer = session.createConsumer(q);
+
+            conn.start();
+
+            _logger.debug("Receiving msg");
+            Message msg = consumer.receive(2000);
+
+            assertNotNull("Message should not be null", msg);
+
+            // As we have not ack'd message will be requeued.
+            _logger.debug("Close Consumer");
+            consumer.close();
+
+            _logger.debug("Close Connection");
+            conn.close();
+        }
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/close/TopicPublisherCloseTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/close/TopicPublisherCloseTest.java
new file mode 100644
index 0000000000..da7642fb3c
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/close/TopicPublisherCloseTest.java
@@ -0,0 +1,69 @@
+/*
+ *
+ * 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.close;
+
+import javax.jms.Session;
+import javax.jms.Topic;
+import javax.jms.TopicPublisher;
+import javax.jms.TopicSession;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQTopic;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+/**
+ * @author Apache Software Foundation
+ */
+public class TopicPublisherCloseTest extends QpidTestCase
+{
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    public void testAllMethodsThrowAfterConnectionClose() throws Exception
+    {
+        // give external brokers a chance to start up
+        Thread.sleep(3000);
+
+        AMQConnection connection =   (AMQConnection) getConnection("guest", "guest");
+
+        Topic destination1 = new AMQTopic(connection, "t1");
+        TopicSession session1 = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+        TopicPublisher pub = session1.createPublisher(destination1);
+        connection.close();
+        try
+        {
+            pub.getDeliveryMode();
+            fail("Expected exception not thrown");
+        }
+        catch (javax.jms.IllegalStateException e)
+        {
+            // PASS
+        }
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/ct/DurableSubscriberTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/ct/DurableSubscriberTest.java
new file mode 100644
index 0000000000..19b73fcc7c
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/ct/DurableSubscriberTest.java
@@ -0,0 +1,167 @@
+/* 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.ct;
+
+import javax.jms.*;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+
+/**
+ *   Crash Recovery tests for durable subscription
+ *
+ */
+public class DurableSubscriberTest extends QpidTestCase
+{
+    private final String _topicName = "durableSubscriberTopic";
+
+    /**
+     * test strategy:
+     * create and register a durable subscriber then close it
+     * create a publisher and send a persistant message followed by a non persistant message
+     * crash and restart the broker
+     * recreate the durable subscriber and check that only the first message is received
+     */
+    public void testDurSubRestoredAfterNonPersistentMessageSent() throws Exception
+    {
+        if (!isBroker08())
+        {
+            TopicConnectionFactory factory = getConnectionFactory();
+            Topic topic = (Topic) getInitialContext().lookup(_topicName);
+            //create and register a durable subscriber then close it
+            TopicConnection durConnection = factory.createTopicConnection("guest", "guest");
+            TopicSession durSession = durConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+            TopicSubscriber durSub1 = durSession.createDurableSubscriber(topic, "dursub");
+            durConnection.start();
+            durSub1.close();
+            durSession.close();
+            durConnection.stop();
+
+            //create a publisher and send a persistant message followed by a non persistant message
+            TopicConnection pubConnection = factory.createTopicConnection("guest", "guest");
+            TopicSession pubSession = pubConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+            TopicPublisher publisher = pubSession.createPublisher(topic);
+            Message message = pubSession.createMessage();
+            message.setIntProperty("count", 1);
+            publisher.publish(message, javax.jms.DeliveryMode.PERSISTENT, javax.jms.Message.DEFAULT_PRIORITY,
+                              javax.jms.Message.DEFAULT_TIME_TO_LIVE);
+            message.setIntProperty("count", 2);
+            publisher.publish(message, javax.jms.DeliveryMode.NON_PERSISTENT, javax.jms.Message.DEFAULT_PRIORITY,
+                              javax.jms.Message.DEFAULT_TIME_TO_LIVE);
+            publisher.close();
+            pubSession.close();
+            //now stop the server
+            try
+            {
+                restartBroker();
+            }
+            catch (Exception e)
+            {
+                System.out.println("problems shutting down arjuna-ms");
+                throw e;
+            }
+            //now recreate the durable subscriber and check the received messages
+            factory = getConnectionFactory();
+            topic = (Topic) getInitialContext().lookup(_topicName);
+            TopicConnection durConnection2 = factory.createTopicConnection("guest", "guest");
+            TopicSession durSession2 = durConnection2.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+            TopicSubscriber durSub2 = durSession2.createDurableSubscriber(topic, "dursub");
+            durConnection2.start();
+            Message m1 = durSub2.receive(1000);
+            if (m1 == null)
+            {
+                assertTrue("testDurSubRestoredAfterNonPersistentMessageSent test failed. no message was returned",
+                           false);
+            }
+            assertTrue("testDurSubRestoredAfterNonPersistentMessageSent test failed. Wrong message was returned.",
+                       m1.getIntProperty("count") == 1);
+            durSession2.unsubscribe("dursub");
+            durConnection2.close();
+        }
+    }
+
+    /**
+     * create and register a durable subscriber with a message selector and then close it
+     * crash the broker
+     * create a publisher and send  5 right messages and 5 wrong messages
+     * recreate the durable subscriber and check the received the 5 expected messages
+     */
+    public void testDurSubRestoresMessageSelector() throws Exception
+    {
+        if (!isBroker08())
+        {
+            TopicConnectionFactory factory = getConnectionFactory();
+            Topic topic = (Topic) getInitialContext().lookup(_topicName);
+            //create and register a durable subscriber with a message selector and then close it
+            TopicConnection durConnection = factory.createTopicConnection("guest", "guest");
+            TopicSession durSession = durConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+            TopicSubscriber durSub1 = durSession.createDurableSubscriber(topic, "dursub", "testprop='true'", false);
+            durConnection.start();
+            durSub1.close();
+            durSession.close();
+            durConnection.stop();
+            //now stop the server
+            try
+            {
+                restartBroker();
+            }
+            catch (Exception e)
+            {
+                System.out.println("problems shutting down arjuna-ms");
+                throw e;
+            }
+            topic = (Topic) getInitialContext().lookup(_topicName);
+            factory = getConnectionFactory();
+            TopicConnection pubConnection = factory.createTopicConnection("guest", "guest");
+            TopicSession pubSession = pubConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+            TopicPublisher publisher = pubSession.createPublisher(topic);
+            for (int i = 0; i < 5; i++)
+            {
+                Message message = pubSession.createMessage();
+                message.setStringProperty("testprop", "true");
+                publisher.publish(message);
+                message = pubSession.createMessage();
+                message.setStringProperty("testprop", "false");
+                publisher.publish(message);
+            }
+            publisher.close();
+            pubSession.close();
+
+            //now recreate the durable subscriber and check the received messages
+            TopicConnection durConnection2 = factory.createTopicConnection("guest", "guest");
+            TopicSession durSession2 = durConnection2.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+            TopicSubscriber durSub2 = durSession2.createDurableSubscriber(topic, "dursub");
+            durConnection2.start();
+            for (int i = 0; i < 5; i++)
+            {
+                Message message = durSub2.receive(1000);
+                if (message == null)
+                {
+                    assertTrue("testDurSubRestoresMessageSelector test failed. no message was returned", false);
+                }
+                else
+                {
+                    assertTrue("testDurSubRestoresMessageSelector test failed. message selector not reset",
+                               message.getStringProperty("testprop").equals("true"));
+                }
+            }
+            durSession2.unsubscribe("dursub");
+            durConnection2.close();
+        }
+    }
+}
+
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/message/JMSDestinationTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/message/JMSDestinationTest.java
new file mode 100644
index 0000000000..b30e3c1c1c
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/message/JMSDestinationTest.java
@@ -0,0 +1,89 @@
+/*
+ *
+ * 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.message;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+
+/**
+ * @author Apache Software Foundation
+ */
+public class JMSDestinationTest extends QpidTestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(JMSDestinationTest.class);
+
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    public void testJMSDestination() throws Exception
+    {
+        AMQConnection con =  (AMQConnection) getConnection("guest", "guest");
+        AMQSession consumerSession = (AMQSession) con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        Queue queue =
+            new AMQQueue(con.getDefaultQueueExchangeName(), new AMQShortString("someQ"), new AMQShortString("someQ"), false,
+                true);
+        MessageConsumer consumer = consumerSession.createConsumer(queue);
+
+        Connection con2 =  (AMQConnection) getConnection("guest", "guest");
+        Session producerSession = con2.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        MessageProducer producer = producerSession.createProducer(queue);
+
+        TextMessage sentMsg = producerSession.createTextMessage("hello");
+        assertNull(sentMsg.getJMSDestination());
+
+        producer.send(sentMsg);
+
+        assertEquals(sentMsg.getJMSDestination(), queue);
+
+        con2.close();
+
+        con.start();
+
+        TextMessage rm = (TextMessage) consumer.receive();
+        assertNotNull(rm);
+
+        assertEquals(rm.getJMSDestination(), queue);
+        con.close();
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/message/JMSPropertiesTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/message/JMSPropertiesTest.java
new file mode 100644
index 0000000000..1f90f1e29f
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/message/JMSPropertiesTest.java
@@ -0,0 +1,135 @@
+/*
+ *
+ * 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.message;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.message.NonQpidObjectMessage;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Destination;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.ObjectMessage;
+import javax.jms.Queue;
+import javax.jms.Session;
+import java.util.Enumeration;
+
+/**
+ * @author Apache Software Foundation
+ */
+public class JMSPropertiesTest extends QpidTestCase
+{
+
+    private static final Logger _logger = LoggerFactory.getLogger(JMSPropertiesTest.class);
+
+    public String _connectionString = "vm://:1";
+
+    public static final String JMS_CORR_ID = "QPIDID_01";
+    public static final int JMS_DELIV_MODE = 1;
+    public static final String JMS_TYPE = "test.jms.type";
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    public void testJMSProperties() throws Exception
+    {
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+        AMQSession consumerSession = (AMQSession) con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        Queue queue =
+            new AMQQueue(con.getDefaultQueueExchangeName(), new AMQShortString("someQ"), new AMQShortString("someQ"), false,
+                true);
+        MessageConsumer consumer = consumerSession.createConsumer(queue);
+
+        AMQConnection con2 = (AMQConnection) getConnection("guest", "guest");
+        Session producerSession = con2.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        MessageProducer producer = producerSession.createProducer(queue);
+        Destination JMS_REPLY_TO = new AMQQueue(con2, "my.replyto");
+        // create a test message to send
+        ObjectMessage sentMsg = new NonQpidObjectMessage(producerSession);
+        sentMsg.setJMSCorrelationID(JMS_CORR_ID);
+        sentMsg.setJMSDeliveryMode(JMS_DELIV_MODE);
+        sentMsg.setJMSType(JMS_TYPE);
+        sentMsg.setJMSReplyTo(JMS_REPLY_TO);
+
+        String JMSXGroupID_VALUE = "group";
+        sentMsg.setStringProperty("JMSXGroupID", JMSXGroupID_VALUE);
+        
+        int JMSXGroupSeq_VALUE = 1;
+        sentMsg.setIntProperty("JMSXGroupSeq", JMSXGroupSeq_VALUE);
+
+        // send it
+        producer.send(sentMsg);
+
+        con2.close();
+
+        con.start();
+
+        // get message and check JMS properties
+        ObjectMessage rm = (ObjectMessage) consumer.receive(2000);
+        assertNotNull(rm);
+
+        assertEquals("JMS Correlation ID mismatch", sentMsg.getJMSCorrelationID(), rm.getJMSCorrelationID());
+        // TODO: Commented out as always overwritten by send delivery mode value - prob should not set in conversion
+        // assertEquals("JMS Delivery Mode mismatch",sentMsg.getJMSDeliveryMode(),rm.getJMSDeliveryMode());
+        assertEquals("JMS Type mismatch", sentMsg.getJMSType(), rm.getJMSType());
+        assertEquals("JMS Reply To mismatch", sentMsg.getJMSReplyTo(), rm.getJMSReplyTo());
+        assertTrue("JMSMessageID Does not start ID:", rm.getJMSMessageID().startsWith("ID:"));
+
+        //Validate that the JMSX values are correct
+        assertEquals("JMSXGroupID is not as expected:", JMSXGroupID_VALUE, rm.getStringProperty("JMSXGroupID"));
+        assertEquals("JMSXGroupSeq is not as expected:", JMSXGroupSeq_VALUE, rm.getIntProperty("JMSXGroupSeq"));
+
+        boolean JMSXGroupID_Available = false;
+        boolean JMSXGroupSeq_Available = false;
+        Enumeration props = con.getMetaData().getJMSXPropertyNames();
+        while (props.hasMoreElements())
+        {
+            String name = (String) props.nextElement();
+            if (name.equals("JMSXGroupID"))
+            {
+                JMSXGroupID_Available = true;
+            }
+            if (name.equals("JMSXGroupSeq"))
+            {
+                JMSXGroupSeq_Available = true;
+            }
+        }
+
+        assertTrue("JMSXGroupID not available.",JMSXGroupID_Available);
+        assertTrue("JMSXGroupSeq not available.",JMSXGroupSeq_Available);
+
+        con.close();
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/message/StreamMessageTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/message/StreamMessageTest.java
new file mode 100644
index 0000000000..6fa0172ae3
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/message/StreamMessageTest.java
@@ -0,0 +1,161 @@
+/*
+ *
+ * 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.message;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQHeadersExchange;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.exchange.ExchangeDefaults;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.framing.FieldTable;
+import org.apache.qpid.url.AMQBindingURL;
+import org.apache.qpid.url.BindingURL;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageEOFException;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+import javax.jms.StreamMessage;
+
+/**
+ * @author Apache Software Foundation
+ */
+public class StreamMessageTest extends QpidTestCase
+{
+
+    private static final Logger _logger = LoggerFactory.getLogger(StreamMessageTest.class);
+
+    public String _connectionString = "vm://:1";
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    public void testStreamMessageEOF() throws Exception
+    {
+        Connection con = (AMQConnection) getConnection("guest", "guest");
+        AMQSession consumerSession = (AMQSession) con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+
+        AMQHeadersExchange queue =
+            new AMQHeadersExchange(new AMQBindingURL(
+                    ExchangeDefaults.HEADERS_EXCHANGE_CLASS + "://" + ExchangeDefaults.HEADERS_EXCHANGE_NAME
+                    + "/test/queue1?" + BindingURL.OPTION_ROUTING_KEY + "='F0000=1'"));
+        FieldTable ft = new FieldTable();
+        ft.setString("F1000", "1");
+        MessageConsumer consumer =
+            consumerSession.createConsumer(queue, AMQSession.DEFAULT_PREFETCH_LOW_MARK,
+                AMQSession.DEFAULT_PREFETCH_HIGH_MARK, false, false, (String) null, ft);
+
+        // force synch to ensure the consumer has resulted in a bound queue
+        // ((AMQSession) consumerSession).declareExchangeSynch(ExchangeDefaults.HEADERS_EXCHANGE_NAME, ExchangeDefaults.HEADERS_EXCHANGE_CLASS);
+        // This is the default now
+
+        Connection con2 = (AMQConnection) getConnection("guest", "guest");
+
+        AMQSession producerSession = (AMQSession) con2.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+
+        // Need to start the "producer" connection in order to receive bounced messages
+        _logger.info("Starting producer connection");
+        con2.start();
+
+        MessageProducer mandatoryProducer = producerSession.createProducer(queue);
+
+        // Third test - should be routed
+        _logger.info("Sending isBound message");
+        StreamMessage msg = producerSession.createStreamMessage();
+
+        msg.setStringProperty("F1000", "1");
+
+        msg.writeByte((byte) 42);
+
+        mandatoryProducer.send(msg);
+
+        _logger.info("Starting consumer connection");
+        con.start();
+
+        StreamMessage msg2 = (StreamMessage) consumer.receive(2000);
+        assertNotNull(msg2);
+
+        msg2.readByte();
+        try
+        {
+            msg2.readByte();
+        }
+        catch (Exception e)
+        {
+            assertTrue("Expected MessageEOFException: " + e, e instanceof MessageEOFException);
+        }
+        con.close();
+        con2.close();
+    }
+
+    public void testModifyReceivedMessageExpandsBuffer() throws Exception
+    {
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+        AMQSession consumerSession = (AMQSession) con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        AMQQueue queue = new AMQQueue(con.getDefaultQueueExchangeName(), new AMQShortString("testQ"));
+        MessageConsumer consumer = consumerSession.createConsumer(queue);
+        consumer.setMessageListener(new MessageListener()
+            {
+
+                public void onMessage(Message message)
+                {
+                    StreamMessage sm = (StreamMessage) message;
+                    try
+                    {
+                        sm.clearBody();
+                        sm.writeString("dfgjshfslfjshflsjfdlsjfhdsljkfhdsljkfhsd");
+                    }
+                    catch (JMSException e)
+                    {
+                        _logger.error("Error when writing large string to received msg: " + e, e);
+                        fail("Error when writing large string to received msg" + e);
+                    }
+                }
+            });
+
+        Connection con2 = (AMQConnection) getConnection("guest", "guest");
+        AMQSession producerSession = (AMQSession) con2.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        MessageProducer mandatoryProducer = producerSession.createProducer(queue);
+        con.start();
+        StreamMessage sm = producerSession.createStreamMessage();
+        sm.writeInt(42);
+        mandatoryProducer.send(sm);
+        Thread.sleep(2000);
+        con.close();
+        con2.close();
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/topic/DurableSubscriptionTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/topic/DurableSubscriptionTest.java
new file mode 100644
index 0000000000..2d3a98977f
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/topic/DurableSubscriptionTest.java
@@ -0,0 +1,348 @@
+/*
+ *
+ * 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.topic;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.AMQTopic;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.InvalidDestinationException;
+import javax.jms.InvalidSelectorException;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+import javax.jms.TopicSubscriber;
+
+/**
+ * @todo Code to check that a consumer gets only one particular method could be factored into a re-usable method (as
+ *       a static on a base test helper class, e.g. TestUtils.
+ *
+ * @todo Code to create test end-points using session per connection, or all sessions on one connection, to be factored
+ *       out to make creating this test variation simpler. Want to make this variation available through LocalCircuit,
+ *       driven by the test model.
+ */
+public class DurableSubscriptionTest extends QpidTestCase
+{
+    private static final Logger _logger = LoggerFactory.getLogger(DurableSubscriptionTest.class);
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    public void testUnsubscribe() throws Exception
+    {
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+        AMQTopic topic = new AMQTopic(con, "MyDurableSubscriptionTestTopic");
+        _logger.info("Create Session 1");
+        Session session1 = con.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+        _logger.info("Create Consumer on Session 1");
+        MessageConsumer consumer1 = session1.createConsumer(topic);
+        _logger.info("Create Producer on Session 1");
+        MessageProducer producer = session1.createProducer(topic);
+
+        _logger.info("Create Session 2");
+        Session session2 = con.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+        _logger.info("Create Durable Subscriber on Session 2");
+        TopicSubscriber consumer2 = session2.createDurableSubscriber(topic, "MySubscription");
+
+        _logger.info("Starting connection");
+        con.start();
+
+        _logger.info("Producer sending message A");
+        producer.send(session1.createTextMessage("A"));
+
+        Message msg;
+        _logger.info("Receive message on consumer 1:expecting A");
+        msg = consumer1.receive();
+        assertEquals("A", ((TextMessage) msg).getText());
+        _logger.info("Receive message on consumer 1 :expecting null");
+        msg = consumer1.receive(1000);
+        assertEquals(null, msg);
+
+        _logger.info("Receive message on consumer 1:expecting A");
+        msg = consumer2.receive();
+        assertEquals("A", ((TextMessage) msg).getText());
+        msg = consumer2.receive(1000);
+        _logger.info("Receive message on consumer 1 :expecting null");
+        assertEquals(null, msg);
+
+        _logger.info("Unsubscribe session2/consumer2");
+        session2.unsubscribe("MySubscription");
+
+        _logger.info("Producer sending message B");
+        producer.send(session1.createTextMessage("B"));
+
+        _logger.info("Receive message on consumer 1 :expecting B");
+        msg = consumer1.receive();
+        assertEquals("B", ((TextMessage) msg).getText());
+        _logger.info("Receive message on consumer 1 :expecting null");
+        msg = consumer1.receive(1000);
+        assertEquals(null, msg);
+
+        _logger.info("Receive message on consumer 2 :expecting null");
+        msg = consumer2.receive(1000);
+        assertEquals(null, msg);
+
+        _logger.info("Close connection");
+        con.close();
+    }
+
+    public void testDurabilityAUTOACK() throws Exception
+    {
+        durabilityImpl(Session.AUTO_ACKNOWLEDGE);
+    }
+
+    public void testDurabilityNOACKSessionPerConnection() throws Exception
+    {
+        durabilityImplSessionPerConnection(AMQSession.NO_ACKNOWLEDGE);
+    }
+
+    public void testDurabilityAUTOACKSessionPerConnection() throws Exception
+    {
+        durabilityImplSessionPerConnection(Session.AUTO_ACKNOWLEDGE);
+    }
+
+    private void durabilityImpl(int ackMode) throws Exception
+    {
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+        AMQTopic topic = new AMQTopic(con, "MyTopic");
+        Session session1 = con.createSession(false, ackMode);
+        MessageConsumer consumer1 = session1.createConsumer(topic);
+
+        Session sessionProd = con.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+        MessageProducer producer = sessionProd.createProducer(topic);
+
+        Session session2 = con.createSession(false, AMQSession.NO_ACKNOWLEDGE);
+        TopicSubscriber consumer2 = session2.createDurableSubscriber(topic, "MySubscription");
+
+        con.start();
+
+        producer.send(session1.createTextMessage("A"));
+
+        Message msg;
+        msg = consumer1.receive();
+        assertEquals("A", ((TextMessage) msg).getText());
+        msg = consumer1.receive(1000);
+        assertEquals(null, msg);
+
+        msg = consumer2.receive();
+        assertEquals("A", ((TextMessage) msg).getText());
+        msg = consumer2.receive(1000);
+        assertEquals(null, msg);
+
+        consumer2.close();
+
+        producer.send(session1.createTextMessage("B"));
+
+        _logger.info("Receive message on consumer 1 :expecting B");
+        msg = consumer1.receive(500);
+        assertNotNull("Consumer 1 should get message 'B'.", msg);
+        assertEquals("Incorrect Message recevied on consumer1.", "B", ((TextMessage) msg).getText());
+        _logger.info("Receive message on consumer 1 :expecting null");
+        msg = consumer1.receive(500);
+        assertNull("There should be no more messages for consumption on consumer1.", msg);
+
+        Session session3 = con.createSession(false, ackMode);
+        MessageConsumer consumer3 = session3.createDurableSubscriber(topic, "MySubscription");
+
+        _logger.info("Receive message on consumer 3 :expecting B");
+        msg = consumer3.receive(500);
+        assertNotNull("Consumer 3 should get message 'B'.", msg);
+        assertEquals("Incorrect Message recevied on consumer4.", "B", ((TextMessage) msg).getText());
+        _logger.info("Receive message on consumer 3 :expecting null");
+        msg = consumer3.receive(500);
+        assertNull("There should be no more messages for consumption on consumer3.", msg);
+
+        consumer1.close();
+        consumer3.close();
+
+        con.close();
+    }
+
+    private void durabilityImplSessionPerConnection(int ackMode) throws Exception
+    {
+        Message msg;
+        // Create producer.
+        AMQConnection con0 = (AMQConnection) getConnection("guest", "guest");
+        con0.start();
+        Session session0 = con0.createSession(false, ackMode);
+
+        AMQTopic topic = new AMQTopic(con0, "MyTopic");
+
+        Session sessionProd = con0.createSession(false, ackMode);
+        MessageProducer producer = sessionProd.createProducer(topic);
+
+        // Create consumer 1.
+        AMQConnection con1 = (AMQConnection) getConnection("guest", "guest");
+        con1.start();
+        Session session1 = con1.createSession(false, ackMode);
+
+        MessageConsumer consumer1 = session0.createConsumer(topic);
+
+        // Create consumer 2.
+        AMQConnection con2 = (AMQConnection) getConnection("guest", "guest");
+        con2.start();
+        Session session2 = con2.createSession(false, ackMode);
+
+        TopicSubscriber consumer2 = session2.createDurableSubscriber(topic, "MySubscription");
+
+        // Send message and check that both consumers get it and only it.
+        producer.send(session0.createTextMessage("A"));
+
+        msg = consumer1.receive(500);
+        assertNotNull("Message should be available", msg);
+        assertEquals("Message Text doesn't match", "A", ((TextMessage) msg).getText());
+        msg = consumer1.receive(500);
+        assertNull("There should be no more messages for consumption on consumer1.", msg);
+
+        msg = consumer2.receive();
+        assertNotNull(msg);
+        assertEquals("Consumer 2 should also received the first msg.", "A", ((TextMessage) msg).getText());
+        msg = consumer2.receive(500);
+        assertNull("There should be no more messages for consumption on consumer2.", msg);
+
+        // Detach the durable subscriber.
+        consumer2.close();
+        session2.close();
+        con2.close();
+
+        // Send message and receive on open consumer.
+        producer.send(session0.createTextMessage("B"));
+
+        _logger.info("Receive message on consumer 1 :expecting B");
+        msg = consumer1.receive(1000);
+        assertEquals("B", ((TextMessage) msg).getText());
+        _logger.info("Receive message on consumer 1 :expecting null");
+        msg = consumer1.receive(1000);
+        assertEquals(null, msg);
+
+        // Re-attach a new consumer to the durable subscription, and check that it gets the message that it missed.
+        AMQConnection con3 = (AMQConnection) getConnection("guest", "guest");
+        con3.start();
+        Session session3 = con3.createSession(false, ackMode);
+
+        TopicSubscriber consumer3 = session3.createDurableSubscriber(topic, "MySubscription");
+
+        _logger.info("Receive message on consumer 3 :expecting B");
+        msg = consumer3.receive(500);
+        assertNotNull("Consumer 3 should get message 'B'.", msg);
+        assertEquals("Incorrect Message recevied on consumer4.", "B", ((TextMessage) msg).getText());
+        _logger.info("Receive message on consumer 3 :expecting null");
+        msg = consumer3.receive(500);
+        assertNull("There should be no more messages for consumption on consumer3.", msg);
+
+        consumer1.close();
+        consumer3.close();
+
+        con0.close();
+        con1.close();
+        con3.close();
+    }
+
+    /***
+     * This tests the fix for QPID-1085
+     * Creates a durable subscriber with an invalid selector, checks that the
+     * exception is thrown correctly and that the subscription is not created. 
+     * @throws Exception 
+     */
+    public void testDurableWithInvalidSelector() throws Exception
+    {
+    	Connection conn = getConnection();
+    	conn.start();
+    	Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
+    	AMQTopic topic = new AMQTopic((AMQConnection) conn, "MyTestDurableWithInvalidSelectorTopic");
+    	MessageProducer producer = session.createProducer(topic);
+    	producer.send(session.createTextMessage("testDurableWithInvalidSelector1"));
+    	try 
+    	{
+    		TopicSubscriber deadSubscriber = session.createDurableSubscriber(topic, "testDurableWithInvalidSelectorSub",
+																	 		 "=TEST 'test", true);
+    		assertNull("Subscriber should not have been created", deadSubscriber);
+    	} 
+    	catch (JMSException e)
+    	{
+    		assertTrue("Wrong type of exception thrown", e instanceof InvalidSelectorException);
+    	}
+    	
+    	TopicSubscriber liveSubscriber = session.createDurableSubscriber(topic, "testDurableWithInvalidSelectorSub");
+    	assertNotNull("Subscriber should have been created", liveSubscriber);
+
+    	producer.send(session.createTextMessage("testDurableWithInvalidSelector2"));
+    	
+    	Message msg = liveSubscriber.receive();
+    	assertNotNull ("Message should have been received", msg);
+    	assertEquals ("testDurableWithInvalidSelector2", ((TextMessage) msg).getText());
+    	assertNull("Should not receive subsequent message", liveSubscriber.receive(200));
+    }
+    
+    /***
+     * This tests the fix for QPID-1085
+     * Creates a durable subscriber with an invalid destination, checks that the
+     * exception is thrown correctly and that the subscription is not created. 
+     * @throws Exception 
+     */
+    public void testDurableWithInvalidDestination() throws Exception
+    {
+    	Connection conn = getConnection();
+    	conn.start();
+    	Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
+    	AMQTopic topic = new AMQTopic((AMQConnection) conn, "testDurableWithInvalidDestinationTopic");
+    	try 
+    	{
+    		TopicSubscriber deadSubscriber = session.createDurableSubscriber(null, "testDurableWithInvalidDestinationsub");
+    		assertNull("Subscriber should not have been created", deadSubscriber);
+    	} 
+    	catch (InvalidDestinationException e)
+    	{
+    		// This was expected
+    	}
+    	MessageProducer producer = session.createProducer(topic);    	
+    	producer.send(session.createTextMessage("testDurableWithInvalidSelector1"));
+    	
+    	TopicSubscriber liveSubscriber = session.createDurableSubscriber(topic, "testDurableWithInvalidDestinationsub");
+    	assertNotNull("Subscriber should have been created", liveSubscriber);
+    	
+    	producer.send(session.createTextMessage("testDurableWithInvalidSelector2"));
+    	Message msg = liveSubscriber.receive();
+    	assertNotNull ("Message should have been received", msg);
+    	assertEquals ("testDurableWithInvalidSelector2", ((TextMessage) msg).getText());
+    	assertNull("Should not receive subsequent message", liveSubscriber.receive(200));
+    }
+    
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(DurableSubscriptionTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/topic/TopicPublisherTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/topic/TopicPublisherTest.java
new file mode 100644
index 0000000000..6d115d1a2b
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/topic/TopicPublisherTest.java
@@ -0,0 +1,76 @@
+/*
+ *
+ * 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.topic;
+
+import javax.jms.MessageConsumer;
+import javax.jms.TextMessage;
+import javax.jms.TopicPublisher;
+import javax.jms.TopicSession;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.AMQTopic;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+/**
+ * @author Apache Software Foundation
+ */
+public class TopicPublisherTest extends QpidTestCase
+{
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+    public void testUnidentifiedProducer() throws Exception
+    {
+
+        AMQConnection con =  (AMQConnection) getConnection("guest", "guest");
+        AMQTopic topic = new AMQTopic(con,"MyTopic");
+        TopicSession session1 = con.createTopicSession(false, AMQSession.NO_ACKNOWLEDGE);
+        TopicPublisher publisher = session1.createPublisher(null);
+        MessageConsumer consumer1 = session1.createConsumer(topic);
+        con.start();
+        publisher.publish(topic, session1.createTextMessage("Hello"));
+        TextMessage m = (TextMessage) consumer1.receive(2000);
+        assertNotNull(m);
+        try
+        {
+            publisher.publish(session1.createTextMessage("Goodbye"));
+            fail("Did not throw UnsupportedOperationException");
+        }
+        catch (UnsupportedOperationException e)
+        {
+            // PASS
+        }
+        con.close();
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(TopicPublisherTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/topic/TopicSessionTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/topic/TopicSessionTest.java
new file mode 100644
index 0000000000..7a20b1058b
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/topic/TopicSessionTest.java
@@ -0,0 +1,417 @@
+/*
+ *
+ * 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.topic;
+
+import javax.jms.InvalidDestinationException;
+import javax.jms.JMSException;
+import javax.jms.MessageConsumer;
+import javax.jms.Session;
+import javax.jms.TemporaryTopic;
+import javax.jms.TextMessage;
+import javax.jms.TopicPublisher;
+import javax.jms.TopicSession;
+import javax.jms.TopicSubscriber;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.client.AMQTopic;
+import org.apache.qpid.client.AMQTopicSessionAdaptor;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+
+/** @author Apache Software Foundation */
+public class TopicSessionTest extends QpidTestCase
+{
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        super.tearDown();
+    }
+
+
+    public void testTopicSubscriptionUnsubscription() throws Exception
+    {
+
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+        AMQTopic topic = new AMQTopic(con.getDefaultTopicExchangeName(), "MyTopic");
+        TopicSession session1 = con.createTopicSession(false, AMQSession.NO_ACKNOWLEDGE);
+        TopicSubscriber sub = session1.createDurableSubscriber(topic, "subscription0");
+        TopicPublisher publisher = session1.createPublisher(topic);
+
+        con.start();
+
+        TextMessage tm = session1.createTextMessage("Hello");
+        publisher.publish(tm);
+
+        tm = (TextMessage) sub.receive(2000);
+        assertNotNull(tm);
+
+        session1.unsubscribe("subscription0");
+
+        try
+        {
+            session1.unsubscribe("not a subscription");
+            fail("expected InvalidDestinationException when unsubscribing from unknown subscription");
+        }
+        catch (InvalidDestinationException e)
+        {
+            ; // PASS
+        }
+        catch (Exception e)
+        {
+            fail("expected InvalidDestinationException when unsubscribing from unknown subscription, got: " + e);
+        }
+
+        con.close();
+    }
+
+    public void testSubscriptionNameReuseForDifferentTopicSingleConnection() throws Exception
+    {
+        subscriptionNameReuseForDifferentTopic(false);
+    }
+
+    public void testSubscriptionNameReuseForDifferentTopicTwoConnections() throws Exception
+    {
+        subscriptionNameReuseForDifferentTopic(true);
+    }
+
+    private void subscriptionNameReuseForDifferentTopic(boolean shutdown) throws Exception
+    {
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+        AMQTopic topic = new AMQTopic(con, "MyTopic1" + String.valueOf(shutdown));
+        AMQTopic topic2 = new AMQTopic(con, "MyOtherTopic1" + String.valueOf(shutdown));
+
+        TopicSession session1 = con.createTopicSession(false, AMQSession.AUTO_ACKNOWLEDGE);
+        TopicSubscriber sub = session1.createDurableSubscriber(topic, "subscription0");
+        TopicPublisher publisher = session1.createPublisher(null);
+
+        con.start();
+
+        publisher.publish(topic, session1.createTextMessage("hello"));
+        TextMessage m = (TextMessage) sub.receive(2000);
+        assertNotNull(m);
+
+        if (shutdown)
+        {
+            session1.close();
+            con.close();
+            con =  (AMQConnection) getConnection("guest", "guest");
+            con.start();
+            session1 = con.createTopicSession(false, AMQSession.NO_ACKNOWLEDGE);
+            publisher = session1.createPublisher(null);
+        }
+        TopicSubscriber sub2 = session1.createDurableSubscriber(topic2, "subscription0");
+        publisher.publish(topic, session1.createTextMessage("hello"));
+        if (!shutdown)
+        {
+            m = (TextMessage) sub.receive(2000);
+            assertNull(m);
+        }
+        publisher.publish(topic2, session1.createTextMessage("goodbye"));
+        m = (TextMessage) sub2.receive(2000);
+        assertNotNull(m);
+        assertEquals("goodbye", m.getText());
+        con.close();
+    }
+
+    public void testUnsubscriptionAfterConnectionClose() throws Exception
+    {
+        AMQConnection con1 = (AMQConnection) getConnection("guest", "guest", "clientid");
+        AMQTopic topic = new AMQTopic(con1, "MyTopic3");
+
+        TopicSession session1 = con1.createTopicSession(false, AMQSession.AUTO_ACKNOWLEDGE);
+        TopicPublisher publisher = session1.createPublisher(topic);
+
+        AMQConnection con2 = (AMQConnection) getConnection("guest", "guest", "clientid");
+        TopicSession session2 = con2.createTopicSession(false, AMQSession.AUTO_ACKNOWLEDGE);
+        TopicSubscriber sub = session2.createDurableSubscriber(topic, "subscription0");
+
+        con2.start();
+
+        publisher.publish(session1.createTextMessage("Hello"));
+        TextMessage tm = (TextMessage) sub.receive(2000);
+        assertNotNull(tm);
+        con2.close();
+        publisher.publish(session1.createTextMessage("Hello2"));
+        con2 =  (AMQConnection) getConnection("guest", "guest", "clientid");
+        session2 = con2.createTopicSession(false, AMQSession.NO_ACKNOWLEDGE);
+        sub = session2.createDurableSubscriber(topic, "subscription0");
+        con2.start();
+        tm = (TextMessage) sub.receive(2000);
+        assertNotNull(tm);
+        assertEquals("Hello2", tm.getText());
+        con1.close();
+        con2.close();
+    }
+
+    public void testTextMessageCreation() throws Exception
+    {
+
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+        AMQTopic topic = new AMQTopic(con, "MyTopic4");
+        TopicSession session1 = con.createTopicSession(false, AMQSession.NO_ACKNOWLEDGE);
+        TopicPublisher publisher = session1.createPublisher(topic);
+        MessageConsumer consumer1 = session1.createConsumer(topic);
+        con.start();
+        TextMessage tm = session1.createTextMessage("Hello");
+        publisher.publish(tm);
+        tm = (TextMessage) consumer1.receive(10000L);
+        assertNotNull(tm);
+        String msgText = tm.getText();
+        assertEquals("Hello", msgText);
+        tm = session1.createTextMessage();
+        msgText = tm.getText();
+        assertNull(msgText);
+        publisher.publish(tm);
+        tm = (TextMessage) consumer1.receive(10000L);
+        assertNotNull(tm);
+        msgText = tm.getText();
+        assertNull(msgText);
+        tm.clearBody();
+        tm.setText("Now we are not null");
+        publisher.publish(tm);
+        tm = (TextMessage) consumer1.receive(2000);
+        assertNotNull(tm);
+        msgText = tm.getText();
+        assertEquals("Now we are not null", msgText);
+
+        tm = session1.createTextMessage("");
+        msgText = tm.getText();
+        assertEquals("Empty string not returned", "", msgText);
+        publisher.publish(tm);
+        tm = (TextMessage) consumer1.receive(2000);
+        assertNotNull(tm);
+        assertEquals("Empty string not returned", "", msgText);
+        con.close();
+    }
+
+    public void testSendingSameMessage() throws Exception
+    {
+        AMQConnection conn = (AMQConnection) getConnection("guest", "guest");
+        TopicSession session = conn.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+        TemporaryTopic topic = session.createTemporaryTopic();
+        assertNotNull(topic);
+        TopicPublisher producer = session.createPublisher(topic);
+        MessageConsumer consumer = session.createConsumer(topic);
+        conn.start();
+        TextMessage sentMessage = session.createTextMessage("Test Message");
+        producer.send(sentMessage);
+        TextMessage receivedMessage = (TextMessage) consumer.receive(2000);
+        assertNotNull(receivedMessage);
+        assertEquals(sentMessage.getText(), receivedMessage.getText());
+        producer.send(sentMessage);
+        receivedMessage = (TextMessage) consumer.receive(2000);
+        assertNotNull(receivedMessage);
+        assertEquals(sentMessage.getText(), receivedMessage.getText());
+
+        conn.close();
+
+    }
+
+    public void testTemporaryTopic() throws Exception
+    {
+        AMQConnection conn = (AMQConnection) getConnection("guest", "guest");
+        TopicSession session = conn.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+        TemporaryTopic topic = session.createTemporaryTopic();
+        assertNotNull(topic);
+        TopicPublisher producer = session.createPublisher(topic);
+        MessageConsumer consumer = session.createConsumer(topic);
+        conn.start();
+        producer.send(session.createTextMessage("hello"));
+        TextMessage tm = (TextMessage) consumer.receive(2000);
+        assertNotNull(tm);
+        assertEquals("hello", tm.getText());
+
+        try
+        {
+            topic.delete();
+            fail("Expected JMSException : should not be able to delete while there are active consumers");
+        }
+        catch (JMSException je)
+        {
+            ; //pass
+        }
+
+        consumer.close();
+
+        try
+        {
+            topic.delete();
+        }
+        catch (JMSException je)
+        {
+            fail("Unexpected Exception: " + je.getMessage());
+        }
+
+        TopicSession session2 = conn.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+        try
+        {
+            session2.createConsumer(topic);
+            fail("Expected a JMSException when subscribing to a temporary topic created on adifferent session");
+        }
+        catch (JMSException je)
+        {
+            ; // pass
+        }
+
+
+        conn.close();
+    }
+
+
+    public void testNoLocal() throws Exception
+    {
+
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+
+        AMQTopic topic = new AMQTopic(con, "testNoLocal");
+
+        TopicSession session1 = con.createTopicSession(false, AMQSession.NO_ACKNOWLEDGE);
+        TopicSubscriber noLocal = session1.createSubscriber(topic,  "", true);
+        TopicSubscriber select = session1.createSubscriber(topic,  "Selector = 'select'", false);
+        TopicSubscriber normal = session1.createSubscriber(topic);
+
+        TopicPublisher publisher = session1.createPublisher(topic);
+
+        con.start();
+        TextMessage m;
+        TextMessage message;
+
+        //send message to all consumers
+        publisher.publish(session1.createTextMessage("hello-new2"));
+
+        //test normal subscriber gets message
+        m = (TextMessage) normal.receive(1000);
+        assertNotNull(m);
+
+        //test selector subscriber doesn't message
+        m = (TextMessage) select.receive(1000);
+        assertNull(m);
+
+        //test nolocal subscriber doesn't message
+        m = (TextMessage) noLocal.receive(1000);
+        if (m != null)
+        {
+            System.out.println("Message:" + m.getText());
+        }
+        assertNull(m);
+
+        //send message to all consumers
+        message = session1.createTextMessage("hello2");
+        message.setStringProperty("Selector", "select");
+
+        publisher.publish(message);
+
+        //test normal subscriber gets message
+        m = (TextMessage) normal.receive(1000);
+        assertNotNull(m);
+
+        //test selector subscriber does get message
+        m = (TextMessage) select.receive(1000);
+        assertNotNull(m);
+
+        //test nolocal subscriber doesn't message
+        m = (TextMessage) noLocal.receive(100);
+        assertNull(m);
+
+        AMQConnection con2 = (AMQConnection) getConnection("guest", "guest", "foo");
+        TopicSession session2 = con2.createTopicSession(false, AMQSession.NO_ACKNOWLEDGE);
+        TopicPublisher publisher2 = session2.createPublisher(topic);
+
+
+        message = session2.createTextMessage("hello2");
+        message.setStringProperty("Selector", "select");
+
+        publisher2.publish(message);
+
+        //test normal subscriber gets message
+        m = (TextMessage) normal.receive(1000);
+        assertNotNull(m);
+
+        //test selector subscriber does get message
+        m = (TextMessage) select.receive(1000);
+        assertNotNull(m);
+
+        //test nolocal subscriber does message
+        m = (TextMessage) noLocal.receive(100);
+        assertNotNull(m);
+
+
+        con.close();
+        con2.close();
+    }
+    
+    /**
+     * This tests QPID-1191, where messages which are sent to a topic but are not consumed by a subscriber
+     * due to a selector can be leaked.
+     * @throws Exception 
+     */
+    public void testNonMatchingMessagesDoNotFillQueue() throws Exception
+    {
+        AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+
+        // Setup Topic
+        AMQTopic topic = new AMQTopic(con, "testNoLocal");
+
+        TopicSession session = con.createTopicSession(false, AMQSession.NO_ACKNOWLEDGE);
+
+        // Setup subscriber with selector
+        TopicSubscriber selector = session.createSubscriber(topic,  "Selector = 'select'", false);
+        TopicPublisher publisher = session.createPublisher(topic);
+
+        con.start();
+        TextMessage m;
+        TextMessage message;
+
+        // Send non-matching message
+        message = session.createTextMessage("non-matching 1");
+        publisher.publish(message);
+        
+        // Send and consume matching message
+        message = session.createTextMessage("hello");
+        message.setStringProperty("Selector", "select");
+
+        publisher.publish(message);
+
+        m = (TextMessage) selector.receive(1000);
+        assertNotNull("should have received message", m);
+        assertEquals("Message contents were wrong", "hello", m.getText());
+        
+        // Send non-matching message
+        message = session.createTextMessage("non-matching 2");
+        publisher.publish(message);
+
+        // Assert queue count is 0
+        long depth = ((AMQTopicSessionAdaptor) session).getSession().getQueueDepth(topic);
+        assertEquals("Queue depth was wrong", 0, depth);
+        
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(TopicSessionTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/transacted/CommitRollbackTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/transacted/CommitRollbackTest.java
new file mode 100644
index 0000000000..9c755fcb41
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/transacted/CommitRollbackTest.java
@@ -0,0 +1,572 @@
+/*
+ *  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.transacted;
+
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.client.AMQConnection;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.*;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * This class tests a number of commits and roll back scenarios
+ *
+ * Assumptions; - Assumes empty Queue
+ */
+public class CommitRollbackTest extends QpidTestCase
+{
+    protected AMQConnection conn;
+    protected String queue = "direct://amq.direct//Qpid.Client.Transacted.CommitRollback.queue";
+    protected static int testMethod = 0;
+    protected String payload = "xyzzy";
+    private Session _session;
+    private MessageProducer _publisher;
+    private Session _pubSession;
+    private MessageConsumer _consumer;
+    Queue _jmsQueue;
+
+    private static final Logger _logger = LoggerFactory.getLogger(CommitRollbackTest.class);
+    private boolean _gotone = false;
+    private boolean _gottwo = false;
+    private boolean _gottwoRedelivered = false;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        testMethod++;
+        queue += testMethod;
+       newConnection();
+    }
+
+    private void newConnection() throws Exception
+    {
+        conn = (AMQConnection) getConnection("guest", "guest");
+
+        _session = conn.createSession(true, Session.CLIENT_ACKNOWLEDGE);
+
+        _jmsQueue = _session.createQueue(queue);
+        _consumer = _session.createConsumer(_jmsQueue);
+
+        _pubSession = conn.createSession(true, Session.CLIENT_ACKNOWLEDGE);
+
+        _publisher = _pubSession.createProducer(_pubSession.createQueue(queue));
+
+        conn.start();
+    }
+
+    protected void tearDown() throws Exception
+    {
+        conn.close();
+        super.tearDown();
+    }
+
+    /**
+     * PUT a text message, disconnect before commit, confirm it is gone.
+     *
+     * @throws Exception On error
+     */
+    public void testPutThenDisconnect() throws Exception
+    {
+        assertTrue("session is not transacted", _session.getTransacted());
+        assertTrue("session is not transacted", _pubSession.getTransacted());
+
+        _logger.info("sending test message");
+        String MESSAGE_TEXT = "testPutThenDisconnect";
+        _publisher.send(_pubSession.createTextMessage(MESSAGE_TEXT));
+
+        _logger.info("reconnecting without commit");
+        conn.close();
+
+        newConnection();
+
+        _logger.info("receiving result");
+        Message result = _consumer.receive(1000);
+
+        // commit to ensure message is removed from queue
+        _session.commit();
+
+        assertNull("test message was put and disconnected before commit, but is still present", result);
+    }
+
+    /**
+     * PUT a text message, disconnect before commit, confirm it is gone.
+     *
+     * @throws Exception On error
+     */
+    public void testPutThenCloseDisconnect() throws Exception
+    {
+        assertTrue("session is not transacted", _session.getTransacted());
+        assertTrue("session is not transacted", _pubSession.getTransacted());
+
+        _logger.info("sending test message");
+        String MESSAGE_TEXT = "testPutThenDisconnect";
+        _publisher.send(_pubSession.createTextMessage(MESSAGE_TEXT));
+
+        _logger.info("closing publisher without commit");
+        _publisher.close();
+
+        _logger.info("reconnecting without commit");
+        conn.close();
+
+        newConnection();
+
+        _logger.info("receiving result");
+        Message result = _consumer.receive(1000);
+
+        // commit to ensure message is removed from queue
+        _session.commit();
+
+        assertNull("test message was put and disconnected before commit, but is still present", result);
+    }
+
+    /**
+     * PUT a text message, rollback, confirm message is gone. The consumer is on the same connection but different
+     * session as producer
+     *
+     * @throws Exception On error
+     */
+    public void testPutThenRollback() throws Exception
+    {
+        assertTrue("session is not transacted", _session.getTransacted());
+        assertTrue("session is not transacted", _pubSession.getTransacted());
+
+        _logger.info("sending test message");
+        String MESSAGE_TEXT = "testPutThenRollback";
+        _publisher.send(_pubSession.createTextMessage(MESSAGE_TEXT));
+
+        _logger.info("rolling back");
+        _pubSession.rollback();
+
+        _logger.info("receiving result");
+        Message result = _consumer.receive(1000);
+
+        assertNull("test message was put and rolled back, but is still present", result);
+    }
+
+    /**
+     * GET a text message, disconnect before commit, confirm it is still there. The consumer is on a new connection
+     *
+     * @throws Exception On error
+     */
+    public void testGetThenDisconnect() throws Exception
+    {
+        assertTrue("session is not transacted", _session.getTransacted());
+        assertTrue("session is not transacted", _pubSession.getTransacted());
+
+        _logger.info("sending test message");
+        String MESSAGE_TEXT = "testGetThenDisconnect";
+        _publisher.send(_pubSession.createTextMessage(MESSAGE_TEXT));
+
+        _pubSession.commit();
+
+        _logger.info("getting test message");
+
+        Message msg = _consumer.receive(1000);
+        assertNotNull("retrieved message is null", msg);
+
+        _logger.info("closing connection");
+        conn.close();
+
+        newConnection();
+
+        _logger.info("receiving result");
+        Message result = _consumer.receive(1000);
+
+        _session.commit();
+
+        assertNotNull("test message was consumed and disconnected before commit, but is gone", result);
+        assertEquals("test message was correct message", MESSAGE_TEXT, ((TextMessage) result).getText());
+    }
+
+    /**
+     * GET a text message, close consumer, disconnect before commit, confirm it is still there. The consumer is on the
+     * same connection but different session as producer
+     *
+     * @throws Exception On error
+     */
+    public void testGetThenCloseDisconnect() throws Exception
+    {
+        assertTrue("session is not transacted", _session.getTransacted());
+        assertTrue("session is not transacted", _pubSession.getTransacted());
+
+        _logger.info("sending test message");
+        String MESSAGE_TEXT = "testGetThenCloseDisconnect";
+        _publisher.send(_pubSession.createTextMessage(MESSAGE_TEXT));
+
+        _pubSession.commit();
+
+        _logger.info("getting test message");
+
+        Message msg = _consumer.receive(1000);
+        assertNotNull("retrieved message is null", msg);
+        assertEquals("test message was correct message", MESSAGE_TEXT, ((TextMessage) msg).getText());
+
+        _logger.info("reconnecting without commit");
+        _consumer.close();
+        conn.close();
+
+        newConnection();
+
+        _logger.info("receiving result");
+        Message result = _consumer.receive(1000);
+
+        _session.commit();
+
+        assertNotNull("test message was consumed and disconnected before commit, but is gone", result);
+        assertEquals("test message was correct message", MESSAGE_TEXT, ((TextMessage) result).getText());
+    }
+
+    /**
+     * GET a text message, rollback, confirm it is still there. The consumer is on the same connection but differnt
+     * session to the producer
+     *
+     * @throws Exception On error
+     */
+    public void testGetThenRollback() throws Exception
+    {
+        assertTrue("session is not transacted", _session.getTransacted());
+        assertTrue("session is not transacted", _pubSession.getTransacted());
+
+        _logger.info("sending test message");
+        String MESSAGE_TEXT = "testGetThenRollback";
+        _publisher.send(_pubSession.createTextMessage(MESSAGE_TEXT));
+
+        _pubSession.commit();
+
+        _logger.info("getting test message");
+
+        Message msg = _consumer.receive(1000);
+
+        assertNotNull("retrieved message is null", msg);
+        assertEquals("test message was correct message", MESSAGE_TEXT, ((TextMessage) msg).getText());
+
+        _logger.info("rolling back");
+
+        _session.rollback();
+
+        _logger.info("receiving result");
+
+        Message result = _consumer.receive(1000);
+
+        _session.commit();
+        assertNotNull("test message was consumed and rolled back, but is gone", result);
+        assertEquals("test message was correct message", MESSAGE_TEXT, ((TextMessage) result).getText());
+        assertTrue("Message is not marked as redelivered", result.getJMSRedelivered());
+    }
+
+    /**
+     * GET a text message, close message producer, rollback, confirm it is still there. The consumer is on the same
+     * connection but different session as producer
+     *
+     * @throws Exception On error
+     */
+    public void testGetThenCloseRollback() throws Exception
+    {
+        assertTrue("session is not transacted", _session.getTransacted());
+        assertTrue("session is not transacted", _pubSession.getTransacted());
+
+        _logger.info("sending test message");
+        String MESSAGE_TEXT = "testGetThenCloseRollback";
+        _publisher.send(_pubSession.createTextMessage(MESSAGE_TEXT));
+
+        _pubSession.commit();
+
+        _logger.info("getting test message");
+
+        Message msg = _consumer.receive(1000);
+
+        assertNotNull("retrieved message is null", msg);
+        assertEquals("test message was correct message", MESSAGE_TEXT, ((TextMessage) msg).getText());
+
+        _logger.info("Closing consumer");
+        _consumer.close();
+
+        _logger.info("rolling back");
+        _session.rollback();
+
+        _logger.info("receiving result");
+
+        _consumer = _session.createConsumer(_jmsQueue);
+
+        Message result = _consumer.receive(1000);
+
+        _session.commit();
+        assertNotNull("test message was consumed and rolled back, but is gone", result);
+        assertEquals("test message was correct message", MESSAGE_TEXT, ((TextMessage) result).getText());
+        assertTrue("Message is not marked as redelivered", result.getJMSRedelivered());
+    }
+
+    /**
+     * Test that rolling back a session purges the dispatcher queue, and the messages arrive in the correct order
+     *
+     * @throws Exception On error
+     */
+    public void testSend2ThenRollback() throws Exception
+    {
+        int run = 0;
+        while (run < 10)
+        {
+            run++;
+            _logger.info("Run:" + run);
+            assertTrue("session is not transacted", _session.getTransacted());
+            assertTrue("session is not transacted", _pubSession.getTransacted());
+
+            _logger.info("sending two test messages");
+            _publisher.send(_pubSession.createTextMessage("1"));
+            _publisher.send(_pubSession.createTextMessage("2"));
+            _pubSession.commit();
+
+            _logger.info("getting test message");
+            assertEquals("1", ((TextMessage) _consumer.receive(1000)).getText());
+
+            _logger.info("rolling back");
+            _session.rollback();
+
+            _logger.info("receiving result");
+            Message result = _consumer.receive(1000);
+
+            assertNotNull("test message was consumed and rolled back, but is gone", result);
+
+            // Message Order is:
+
+            // Send 1 , 2
+            // Retrieve 1 and then rollback
+            // Receieve 1 (redelivered) , 2 (may or may not be redelivered??)
+
+            verifyMessages(result);
+
+            // Occassionally get message 2 first!
+//            assertEquals("Should get message one first", "1", ((TextMessage) result).getText());
+//            assertTrue("Message is not marked as redelivered", result.getJMSRedelivered());
+//
+//            result = _consumer.receive(1000);
+//            assertEquals("Second message should be message 2", "2", ((TextMessage) result).getText());
+//            assertTrue("Message is not marked as redelivered", result.getJMSRedelivered());
+//
+//            result = _consumer.receive(1000);
+//            assertNull("There should be no more messages", result);
+
+            _session.commit();
+        }
+    }
+
+    private void verifyMessages(Message result) throws JMSException
+    {
+
+        if (result == null)
+        {
+            assertTrue("Didn't receive redelivered message one", _gotone);
+            assertTrue("Didn't receive message two at all", _gottwo | _gottwoRedelivered);
+            _gotone = false;
+            _gottwo = false;
+            _gottwoRedelivered = false;
+            return;
+        }
+
+        if (((TextMessage) result).getText().equals("1"))
+        {
+            _logger.info("Got 1 redelivered");
+            assertTrue("Message is not marked as redelivered", result.getJMSRedelivered());
+            assertFalse("Already received message one", _gotone);
+            _gotone = true;
+
+        }
+        else
+        {
+            assertEquals("2", ((TextMessage) result).getText());
+
+            if (result.getJMSRedelivered())
+            {
+                _logger.info("Got 2 redelivered, message was prefetched");
+                assertFalse("Already received message redelivered two", _gottwoRedelivered);
+
+                _gottwoRedelivered = true;
+            }
+            else
+            {
+                _logger.warn("Got 2, message prefetched wasn't cleared or messages was in transit when rollback occured");
+                assertFalse("Already received message two", _gottwo);
+                assertFalse("Already received message redelivered two", _gottwoRedelivered);
+                _gottwo = true;
+            }
+        }
+
+        verifyMessages(_consumer.receive(1000));
+    }
+
+    /**
+     * This test sends two messages receives on of them but doesn't ack it.
+     * The consumer is then closed
+     * the first message should be returned as redelivered.
+     *  the second message should be delivered normally.
+     * @throws Exception
+     */
+    public void testSend2ThenCloseAfter1andTryAgain() throws Exception
+    {
+        assertTrue("session is not transacted", _session.getTransacted());
+        assertTrue("session is not transacted", _pubSession.getTransacted());
+
+        _logger.info("sending two test messages");
+        _publisher.send(_pubSession.createTextMessage("1"));
+        _publisher.send(_pubSession.createTextMessage("2"));
+        _pubSession.commit();
+
+        _logger.info("getting test message");
+        Message result = _consumer.receive(5000);
+
+        assertNotNull("Message received should not be null", result);
+        assertEquals("1", ((TextMessage) result).getText());
+        assertTrue("Messasge is marked as redelivered" + result, !result.getJMSRedelivered());
+
+        _logger.info("Closing Consumer");
+        
+        _consumer.close();
+
+        _logger.info("Creating New consumer");
+        _consumer = _session.createConsumer(_jmsQueue);
+
+        _logger.info("receiving result");
+
+
+        // Message 2 may be marked as redelivered if it was prefetched.
+        result = _consumer.receive(5000);
+        assertNotNull("Second message was not consumed, but is gone", result);
+
+        // The first message back will be 2, message 1 has been received but not committed
+        // Closing the consumer does not commit the session.
+
+        // if this is message 1 then it should be marked as redelivered
+        if("1".equals(((TextMessage) result).getText()))
+        {
+            fail("First message was recieved again");
+        }
+
+        result = _consumer.receive(1000);
+        assertNull("test message should be null:" + result, result);
+
+        _session.commit();
+    }
+
+    public void testPutThenRollbackThenGet() throws Exception
+    {
+        assertTrue("session is not transacted", _session.getTransacted());
+        assertTrue("session is not transacted", _pubSession.getTransacted());
+
+        _logger.info("sending test message");
+        String MESSAGE_TEXT = "testPutThenRollbackThenGet";
+
+        _publisher.send(_pubSession.createTextMessage(MESSAGE_TEXT));
+        _pubSession.commit();
+
+        assertNotNull(_consumer.receive(100));
+
+        _publisher.send(_pubSession.createTextMessage(MESSAGE_TEXT));
+
+        _logger.info("rolling back");
+        _pubSession.rollback();
+
+        _logger.info("receiving result");
+        Message result = _consumer.receive(1000);
+        assertNull("test message was put and rolled back, but is still present", result);
+
+        _publisher.send(_pubSession.createTextMessage(MESSAGE_TEXT));
+
+        _pubSession.commit();
+
+        assertNotNull(_consumer.receive(100));
+
+        _session.commit();
+    }
+
+    /**
+     * Qpid-1163
+     * Check that when commt is called inside onMessage then
+     * the last message is nor redelivered. 
+     *
+     * @throws Exception
+     */
+    public void testCommitWhithinOnMessage() throws Exception
+    {
+        Queue queue = (Queue) getInitialContext().lookup("queue");
+        // create a consumer
+             MessageConsumer cons = _session.createConsumer(queue);           
+        MessageProducer prod = _session.createProducer(queue);
+        Message message =  _session.createTextMessage("Message");
+        message.setJMSCorrelationID("m1");
+        prod.send(message);
+        _session.commit();
+        _logger.info("Sent message to queue");
+        CountDownLatch cd = new CountDownLatch(1);
+        cons.setMessageListener(new CommitWhithinOnMessageListener(cd));
+        conn.start();
+        cd.await(30, TimeUnit.SECONDS);
+        if( cd.getCount() > 0 )
+        {
+           fail("Did not received message");
+        }
+        // Check that the message has been dequeued
+        _session.close();
+        conn.close();
+        conn = (AMQConnection) getConnection("guest", "guest");
+        conn.start();
+        Session session = conn.createSession(false, Session.CLIENT_ACKNOWLEDGE);
+        cons = session.createConsumer(queue);        
+        message = cons.receiveNoWait();
+        if(message != null)
+        {
+            if(message.getJMSCorrelationID().equals("m1"))
+            {
+                fail("received message twice");
+            }
+            else
+            {
+                fail("queue should have been empty, received message: " + message);
+            }
+        }
+    }
+
+    private class CommitWhithinOnMessageListener implements MessageListener
+    {
+        private CountDownLatch _cd;
+        private CommitWhithinOnMessageListener(CountDownLatch cd)
+        {
+            _cd = cd;
+        }
+        public void onMessage(Message message)
+        {
+            try
+            {
+                _logger.info("received message " + message);
+                assertEquals("Wrong message received", message.getJMSCorrelationID(), "m1");
+                _logger.info("commit session");
+                _session.commit();
+                _cd.countDown();
+            }
+            catch (JMSException e)
+            {
+                e.printStackTrace();
+            }
+        }
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/transacted/TransactedTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/transacted/TransactedTest.java
new file mode 100644
index 0000000000..1eec6dd17c
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/transacted/TransactedTest.java
@@ -0,0 +1,348 @@
+/*
+ *
+ * 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.transacted;
+
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQQueue;
+import org.apache.qpid.client.AMQSession;
+import org.apache.qpid.framing.AMQShortString;
+import org.apache.qpid.jms.Session;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.TextMessage;
+
+public class TransactedTest extends QpidTestCase
+{
+    private AMQQueue queue1;
+
+    private AMQConnection con;
+    private Session session;
+    private MessageConsumer consumer1;
+    private MessageProducer producer2;
+
+    private AMQConnection prepCon;
+    private Session prepSession;
+    private MessageProducer prepProducer1;
+
+    private AMQConnection testCon;
+    private Session testSession;
+    private MessageConsumer testConsumer1;
+    private MessageConsumer testConsumer2;
+    private static final Logger _logger = LoggerFactory.getLogger(TransactedTest.class);
+
+    protected void setUp() throws Exception
+    {
+        try
+        {
+            super.setUp();
+            _logger.info("Create Connection");
+            con = (AMQConnection) getConnection("guest", "guest");
+            _logger.info("Create Session");
+            session = con.createSession(true, Session.SESSION_TRANSACTED);
+            _logger.info("Create Q1");
+            queue1 = new AMQQueue(session.getDefaultQueueExchangeName(), new AMQShortString("Q1"),
+                                  new AMQShortString("Q1"), false, true);
+            _logger.info("Create Q2");
+            AMQQueue queue2 = new AMQQueue(session.getDefaultQueueExchangeName(), new AMQShortString("Q2"), false);
+
+            _logger.info("Create Consumer of Q1");
+            consumer1 = session.createConsumer(queue1);
+            // Dummy just to create the queue.
+            _logger.info("Create Consumer of Q2");
+            MessageConsumer consumer2 = session.createConsumer(queue2);
+            _logger.info("Close Consumer of Q2");
+            consumer2.close();
+
+            _logger.info("Create producer to Q2");
+            producer2 = session.createProducer(queue2);
+
+            _logger.info("Start Connection");
+            con.start();
+
+            _logger.info("Create prep connection");
+            prepCon = (AMQConnection) getConnection("guest", "guest");
+
+            _logger.info("Create prep session");
+            prepSession = prepCon.createSession(false, AMQSession.AUTO_ACKNOWLEDGE);
+
+            _logger.info("Create prep producer to Q1");
+            prepProducer1 = prepSession.createProducer(queue1);
+
+            _logger.info("Create prep connection start");
+            prepCon.start();
+
+            _logger.info("Create test connection");
+            testCon = (AMQConnection) getConnection("guest", "guest");
+            _logger.info("Create test session");
+            testSession = testCon.createSession(false, AMQSession.AUTO_ACKNOWLEDGE);
+            _logger.info("Create test consumer of q2");
+            testConsumer2 = testSession.createConsumer(queue2);
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+            stopBroker();
+            throw e;
+        }
+    }
+
+    protected void tearDown() throws Exception
+    {
+        try
+        {
+            _logger.info("Close connection");
+            con.close();
+            _logger.info("Close test connection");
+            testCon.close();
+            _logger.info("Close prep connection");
+            prepCon.close();
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+        finally
+        {
+            super.tearDown();
+        }
+    }
+
+    public void testCommit() throws Exception
+    {
+        try
+        {
+// add some messages
+            _logger.info("Send prep A");
+            prepProducer1.send(prepSession.createTextMessage("A"));
+            _logger.info("Send prep B");
+            prepProducer1.send(prepSession.createTextMessage("B"));
+            _logger.info("Send prep C");
+            prepProducer1.send(prepSession.createTextMessage("C"));
+
+            // send and receive some messages
+            _logger.info("Send X to Q2");
+            producer2.send(session.createTextMessage("X"));
+            _logger.info("Send Y to Q2");
+            producer2.send(session.createTextMessage("Y"));
+            _logger.info("Send Z to Q2");
+            producer2.send(session.createTextMessage("Z"));
+
+            _logger.info("Read A from Q1");
+            expect("A", consumer1.receive(1000));
+            _logger.info("Read B from Q1");
+            expect("B", consumer1.receive(1000));
+            _logger.info("Read C from Q1");
+            expect("C", consumer1.receive(1000));
+
+            // commit
+            _logger.info("session commit");
+            session.commit();
+            _logger.info("Start test Connection");
+            testCon.start();
+
+            // ensure sent messages can be received and received messages are gone
+            _logger.info("Read X from Q2");
+            expect("X", testConsumer2.receive(1000));
+            _logger.info("Read Y from Q2");
+            expect("Y", testConsumer2.receive(1000));
+            _logger.info("Read Z from Q2");
+            expect("Z", testConsumer2.receive(1000));
+
+            _logger.info("create test session on Q1");
+            testConsumer1 = testSession.createConsumer(queue1);
+            _logger.info("Read null from Q1");
+            assertTrue(null == testConsumer1.receive(1000));
+            _logger.info("Read null from Q2");
+            assertTrue(null == testConsumer2.receive(1000));
+        }
+        catch (Throwable e)
+        {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    public void testRollback() throws Exception
+    {
+        try
+        {
+// add some messages
+            _logger.info("Send prep RB_A");
+            prepProducer1.send(prepSession.createTextMessage("RB_A"));
+            _logger.info("Send prep RB_B");
+            prepProducer1.send(prepSession.createTextMessage("RB_B"));
+            _logger.info("Send prep RB_C");
+            prepProducer1.send(prepSession.createTextMessage("RB_C"));
+
+            _logger.info("Sending RB_X RB_Y RB_Z");
+            producer2.send(session.createTextMessage("RB_X"));
+            producer2.send(session.createTextMessage("RB_Y"));
+            producer2.send(session.createTextMessage("RB_Z"));
+            _logger.info("Receiving RB_A RB_B");
+            expect("RB_A", consumer1.receive(1000));
+            expect("RB_B", consumer1.receive(1000));
+            // Don't consume 'RB_C' leave it in the prefetch cache to ensure rollback removes it.
+            // Quick sleep to ensure 'RB_C' gets pre-fetched
+            Thread.sleep(500);
+
+            // rollback
+            _logger.info("rollback");
+            session.rollback();
+
+            _logger.info("Receiving RB_A RB_B RB_C");
+            // ensure sent messages are not visible and received messages are requeued
+            expect("RB_A", consumer1.receive(1000), true);
+            expect("RB_B", consumer1.receive(1000), true);
+            expect("RB_C", consumer1.receive(1000), true);
+            _logger.info("Starting new connection");
+            testCon.start();
+            testConsumer1 = testSession.createConsumer(queue1);
+            _logger.info("Testing we have no messages left");
+            assertTrue(null == testConsumer1.receive(1000));
+            assertTrue(null == testConsumer2.receive(1000));
+
+            session.commit();
+
+            _logger.info("Testing we have no messages left after commit");
+            assertTrue(null == testConsumer1.receive(1000));
+            assertTrue(null == testConsumer2.receive(1000));
+        }
+        catch (Throwable e)
+        {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    public void testResendsMsgsAfterSessionClose() throws Exception
+    {
+        try
+        {
+            AMQConnection con = (AMQConnection) getConnection("guest", "guest");
+
+            Session consumerSession = con.createSession(true, Session.SESSION_TRANSACTED);
+            AMQQueue queue3 = new AMQQueue(consumerSession.getDefaultQueueExchangeName(), new AMQShortString("Q3"), false);
+            MessageConsumer consumer = consumerSession.createConsumer(queue3);
+
+            AMQConnection con2 = (AMQConnection) getConnection("guest", "guest");
+            Session producerSession = con2.createSession(true, Session.SESSION_TRANSACTED);
+            MessageProducer producer = producerSession.createProducer(queue3);
+
+            _logger.info("Sending four messages");
+            producer.send(producerSession.createTextMessage("msg1"));
+            producer.send(producerSession.createTextMessage("msg2"));
+            producer.send(producerSession.createTextMessage("msg3"));
+            producer.send(producerSession.createTextMessage("msg4"));
+
+            producerSession.commit();
+
+            _logger.info("Starting connection");
+            con.start();
+            TextMessage tm = (TextMessage) consumer.receive();
+            assertNotNull(tm);
+            assertEquals("msg1", tm.getText());
+
+            consumerSession.commit();
+
+            _logger.info("Received and committed first message");
+            tm = (TextMessage) consumer.receive(1000);
+            assertNotNull(tm);
+            assertEquals("msg2", tm.getText());
+
+            tm = (TextMessage) consumer.receive(1000);
+            assertNotNull(tm);
+            assertEquals("msg3", tm.getText());
+
+            tm = (TextMessage) consumer.receive(1000);
+            assertNotNull(tm);
+            assertEquals("msg4", tm.getText());
+
+            _logger.info("Received all four messages. Closing connection with three outstanding messages");
+
+            consumerSession.close();
+
+            consumerSession = con.createSession(true, Session.SESSION_TRANSACTED);
+
+            consumer = consumerSession.createConsumer(queue3);
+
+            // no ack for last three messages so when I call recover I expect to get three messages back
+            tm = (TextMessage) consumer.receive(3000);
+            assertNotNull(tm);
+            assertEquals("msg2", tm.getText());
+            assertTrue("Message is not redelivered", tm.getJMSRedelivered());
+
+            tm = (TextMessage) consumer.receive(3000);
+            assertNotNull(tm);
+            assertEquals("msg3", tm.getText());
+            assertTrue("Message is not redelivered", tm.getJMSRedelivered());
+
+            tm = (TextMessage) consumer.receive(3000);
+            assertNotNull(tm);
+            assertEquals("msg4", tm.getText());
+            assertTrue("Message is not redelivered", tm.getJMSRedelivered());
+
+            _logger.info("Received redelivery of three messages. Committing");
+
+            consumerSession.commit();
+
+            _logger.info("Called commit");
+
+            tm = (TextMessage) consumer.receive(1000);
+            assertNull(tm);
+
+            _logger.info("No messages redelivered as is expected");
+
+            con.close();
+            con2.close();
+        }
+        catch (Throwable e)
+        {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    private void expect(String text, Message msg) throws JMSException
+    {
+        expect(text, msg, false);
+    }
+
+    private void expect(String text, Message msg, boolean requeued) throws JMSException
+    {
+        assertNotNull("Message should not be null", msg);
+        assertTrue("Message should be a text message", msg instanceof TextMessage);
+        assertEquals("Message content does not match expected", text, ((TextMessage) msg).getText());
+        assertEquals("Message should " + (requeued ? "" : "not") + " be requeued", requeued, msg.getJMSRedelivered());
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(TransactedTest.class);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/xa/AbstractXATestCase.java b/java/systests/src/main/java/org/apache/qpid/test/unit/xa/AbstractXATestCase.java
new file mode 100644
index 0000000000..3906be2cc7
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/xa/AbstractXATestCase.java
@@ -0,0 +1,132 @@
+/* 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.xa;
+
+import org.apache.qpid.dtx.XidImpl;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import javax.transaction.xa.Xid;
+import javax.transaction.xa.XAResource;
+import javax.jms.*;
+import java.util.Random;
+
+/**
+ *
+ *
+ */
+public abstract  class AbstractXATestCase extends QpidTestCase
+{
+    protected static final String _sequenceNumberPropertyName = "seqNumber";
+
+      /**
+     * the xaResource associated with the standard session
+     */
+    protected static XAResource _xaResource = null;
+
+    /**
+     * producer registered with the standard session
+     */
+    protected static MessageProducer _producer = null;
+
+    /**
+     * consumer registered with the standard session
+     */
+    protected static MessageConsumer _consumer = null;
+
+    /**
+     * a standard message
+     */
+    protected static TextMessage _message = null;
+
+     /**
+     * xid counter
+     */
+    private static int _xidCounter = (new Random()).nextInt(1000000);
+
+
+     protected void setUp() throws Exception
+    {
+        super.setUp();
+        init();
+    }
+
+    public abstract  void init() throws Exception;
+
+
+    
+    /**
+         * construct a new Xid
+         *
+         * @return a new Xid
+         */
+        protected Xid getNewXid()
+        {
+            byte[] branchQualifier;
+            byte[] globalTransactionID;
+            int format = _xidCounter;
+            String branchQualifierSt = "branchQualifier" + _xidCounter;
+            String globalTransactionIDSt = "globalTransactionID" + _xidCounter;
+            branchQualifier = branchQualifierSt.getBytes();
+            globalTransactionID = globalTransactionIDSt.getBytes();
+            _xidCounter++;
+            return new XidImpl(branchQualifier, format, globalTransactionID);
+        }
+
+        public void init(XASession session, Destination destination)
+        {
+               // get the xaResource
+            try
+            {
+                _xaResource = session.getXAResource();
+            }
+            catch (Exception e)
+            {
+                fail("cannot access the xa resource: " + e.getMessage());
+            }
+            // create standard producer
+            try
+            {
+                _producer = session.createProducer(destination);
+                _producer.setDeliveryMode(DeliveryMode.PERSISTENT);
+            }
+            catch (JMSException e)
+            {
+                e.printStackTrace();
+                fail("cannot create message producer: " + e.getMessage());
+            }
+            // create standard consumer
+            try
+            {
+                _consumer = session.createConsumer(destination);
+            }
+            catch (JMSException e)
+            {
+                fail("cannot create message consumer: " + e.getMessage());
+            }
+            // create a standard message
+            try
+            {
+                _message = session.createTextMessage();
+                _message.setText("test XA");
+            }
+            catch (JMSException e)
+            {
+                fail("cannot create standard message: " + e.getMessage());
+            }
+        }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/xa/FaultTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/xa/FaultTest.java
new file mode 100644
index 0000000000..0adf39980b
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/xa/FaultTest.java
@@ -0,0 +1,364 @@
+package org.apache.qpid.test.unit.xa;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.*;
+import javax.transaction.xa.Xid;
+import javax.transaction.xa.XAResource;
+import javax.transaction.xa.XAException;
+
+import junit.framework.TestSuite;
+
+
+public class FaultTest extends AbstractXATestCase
+{
+    /* this clas logger */
+    private static final Logger _logger = LoggerFactory.getLogger(FaultTest.class);
+
+    /**
+     * the queue use by all the tests
+     */
+    private static Queue _queue = null;
+    /**
+     * the queue connection factory used by all tests
+     */
+    private static XAQueueConnectionFactory _queueFactory = null;
+
+    /**
+     * standard xa queue connection
+     */
+    private static XAQueueConnection _xaqueueConnection = null;
+
+    /**
+     * standard xa queue connection
+     */
+    private static QueueConnection _queueConnection = null;
+
+
+    /**
+     * standard queue session created from the standard connection
+     */
+    private static QueueSession _nonXASession = null;
+
+    /**
+     * the queue name
+     */
+    private static final String QUEUENAME = "xaQueue";
+
+    /** ----------------------------------------------------------------------------------- **/
+    /**
+     * ----------------------------- JUnit support  ----------------------------------------- *
+     */
+
+    /**
+     * Gets the test suite tests
+     *
+     * @return the test suite tests
+     */
+    public static TestSuite getSuite()
+    {
+        return new TestSuite(QueueTest.class);
+    }
+
+    /**
+     * Run the test suite.
+     *
+     * @param args Any command line arguments specified to this class.
+     */
+    public static void main(String args[])
+    {
+        junit.textui.TestRunner.run(getSuite());
+    }
+
+    public void tearDown() throws Exception
+    {
+        if (!isBroker08())
+        {
+            _xaqueueConnection.close();
+            _queueConnection.close();
+        }
+        super.tearDown();
+    }
+
+    /**
+     * Initialize standard actors
+     */
+    public void init() throws Exception
+    {
+        if (!isBroker08())
+        {
+            _queue = (Queue) getInitialContext().lookup(QUEUENAME);
+            _queueFactory = getConnectionFactory();
+            _xaqueueConnection = _queueFactory.createXAQueueConnection("guest", "guest");
+            XAQueueSession session = _xaqueueConnection.createXAQueueSession();
+            _queueConnection = _queueFactory.createQueueConnection();
+            _nonXASession = _queueConnection.createQueueSession(true, Session.AUTO_ACKNOWLEDGE);
+            init(session, _queue);
+        }
+    }
+
+    /** -------------------------------------------------------------------------------------- **/
+    /** ----------------------------- Test Suite  -------------------------------------------- **/
+    /** -------------------------------------------------------------------------------------- **/
+
+    /**
+     * Strategy:
+     * Invoke start twice with the same xid on an XA resource.
+     * Check that the second
+     * invocation is throwing the expected XA exception.
+     */
+    public void testSameXID() throws Exception
+    {
+        Xid xid = getNewXid();
+        _xaResource.start(xid, XAResource.TMNOFLAGS);
+        // we now exepct this operation to fail
+        try
+        {
+            _xaResource.start(xid, XAResource.TMNOFLAGS);
+            fail("We managed to start a transaction with the same xid");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_DUPID, e.errorCode);
+        }
+    }
+
+    /**
+     * Strategy:
+     * Invoke start on a XA resource with flag other than TMNOFLAGS, TMJOIN, or TMRESUME.
+     * Check that a XA Exception is thrown.
+     */
+    public void testWrongStartFlag()
+    {
+        Xid xid = getNewXid();
+        try
+        {
+            _xaResource.start(xid, XAResource.TMONEPHASE);
+            fail("We managed to start a transaction with a wrong flag");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_INVAL, e.errorCode);
+        }
+    }
+
+    /**
+     * Strategy:
+     * Check that a XA exception is thrown when:
+     * A non started xid is ended
+     */
+    public void testEnd()
+    {
+        Xid xid = getNewXid();
+        try
+        {
+            _xaResource.end(xid, XAResource.TMSUCCESS);
+            fail("We managed to end a transaction before it is started");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_PROTO, e.errorCode);
+        }
+    }
+
+
+    /**
+     * Strategy:
+     * Check that a XA exception is thrown when:
+     * Call forget on an unknown xid
+     * call forget on a started xid
+     * A non started xid is prepared
+     * A non ended xis is prepared
+     */
+    public void testForget()
+    {
+        Xid xid = getNewXid();
+        try
+        {
+            _xaResource.forget(xid);
+            fail("We managed to forget an unknown xid");
+        }
+        catch (XAException e)
+        {
+            // assertEquals("Wrong error code: ", XAException.XAER_NOTA, e.errorCode);
+        }
+        xid = getNewXid();
+        try
+        {
+            _xaResource.start(xid, XAResource.TMNOFLAGS);
+            _xaResource.forget(xid);
+            fail("We managed to forget a started xid");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_PROTO, e.errorCode);
+        }
+    }
+
+    /**
+     * Strategy:
+     * Check that a XA exception is thrown when:
+     * A non started xid is prepared
+     * A non ended xid is prepared
+     */
+    public void testPrepare()
+    {
+        Xid xid = getNewXid();
+        try
+        {
+            _xaResource.prepare(xid);
+            fail("We managed to prepare an unknown xid");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_NOTA, e.errorCode);
+        }
+        xid = getNewXid();
+        try
+        {
+            _xaResource.start(xid, XAResource.TMNOFLAGS);
+            _xaResource.prepare(xid);
+            fail("We managed to prepare a started xid");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_PROTO, e.errorCode);
+        }
+    }
+
+    /**
+     * Strategy:
+     * Check that the expected XA exception is thrown when:
+     * A non started xid is committed
+     * A non ended xid is committed
+     * A non prepared xid is committed with one phase set to false.
+     * A prepared xid is committed with one phase set to true.
+     */
+    public void testCommit() throws Exception
+    {
+        Xid xid = getNewXid();
+        try
+        {
+            _xaResource.commit(xid, true);
+            fail("We managed to commit an unknown xid");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_NOTA, e.errorCode);
+        }
+        xid = getNewXid();
+        try
+        {
+            _xaResource.start(xid, XAResource.TMNOFLAGS);
+            _xaResource.commit(xid, true);
+            fail("We managed to commit a not ended xid");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_PROTO, e.errorCode);
+        }
+        xid = getNewXid();
+        try
+        {
+            _xaResource.start(xid, XAResource.TMNOFLAGS);
+            _xaResource.end(xid, XAResource.TMSUCCESS);
+            _xaResource.commit(xid, false);
+            fail("We managed to commit a not prepared xid");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_PROTO, e.errorCode);
+        }
+        xid = getNewXid();
+        try
+        {
+            _xaResource.start(xid, XAResource.TMNOFLAGS);
+            _xaResource.end(xid, XAResource.TMSUCCESS);
+            _xaResource.prepare(xid);
+            _xaResource.commit(xid, true);
+            fail("We managed to commit a prepared xid");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_PROTO, e.errorCode);
+        }
+        finally
+        {
+            _xaResource.commit(xid, false);
+        }
+    }
+
+     /**
+     * Strategy:
+     * Check that the expected XA exception is thrown when:
+     * A non started xid is rolled back
+     * A non ended xid is rolled back
+     */
+    public void testRollback()
+    {
+        Xid xid = getNewXid();
+        try
+        {
+            _xaResource.rollback(xid);
+            fail("We managed to rollback an unknown xid");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_NOTA, e.errorCode);
+        }
+        xid = getNewXid();
+        try
+        {
+            _xaResource.start(xid, XAResource.TMNOFLAGS);
+            _xaResource.rollback(xid);
+            fail("We managed to rollback a not ended xid");
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XAER_PROTO, e.errorCode);
+        }
+    }
+
+    /**
+     * Strategy:
+     * Check that the timeout is set correctly
+     */
+    public void testTransactionTimeoutvalue() throws Exception
+    {
+        Xid xid = getNewXid();
+        _xaResource.start(xid, XAResource.TMNOFLAGS);
+        assertEquals("Wrong timeout", _xaResource.getTransactionTimeout(), 0);
+        _xaResource.setTransactionTimeout(1000);
+        assertEquals("Wrong timeout", _xaResource.getTransactionTimeout(), 1000);
+        _xaResource.end(xid, XAResource.TMSUCCESS);
+        xid = getNewXid();
+        _xaResource.start(xid, XAResource.TMNOFLAGS);
+        assertEquals("Wrong timeout", _xaResource.getTransactionTimeout(), 0);
+    }
+
+    /**
+     * Strategy:
+     * Check that a transaction timeout as expected
+     * - set timeout to 10ms
+     * - sleep 1000ms
+     * - call end and check that the expected exception is thrown
+     */
+    public void testTransactionTimeout() throws Exception
+    {
+        Xid xid = getNewXid();
+        try
+        {
+            _xaResource.start(xid, XAResource.TMNOFLAGS);
+            assertEquals("Wrong timeout", _xaResource.getTransactionTimeout(), 0);
+            _xaResource.setTransactionTimeout(10);
+            Thread.sleep(1000);
+            _xaResource.end(xid, XAResource.TMSUCCESS);
+        }
+        catch (XAException e)
+        {
+            assertEquals("Wrong error code: ", XAException.XA_RBTIMEOUT, e.errorCode);
+        }
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/xa/QueueTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/xa/QueueTest.java
new file mode 100644
index 0000000000..d2abc0eac1
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/xa/QueueTest.java
@@ -0,0 +1,657 @@
+/* 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.xa;
+
+import javax.jms.*;
+import javax.transaction.xa.XAResource;
+import javax.transaction.xa.Xid;
+import javax.transaction.xa.XAException;
+
+import junit.framework.TestSuite;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class QueueTest extends AbstractXATestCase
+{
+    /* this clas logger */
+    private static final Logger _logger = LoggerFactory.getLogger(QueueTest.class);
+
+    /**
+     * the queue use by all the tests
+     */
+    private static Queue _queue = null;
+    /**
+     * the queue connection factory used by all tests
+     */
+    private static XAQueueConnectionFactory _queueFactory = null;
+
+    /**
+     * standard xa queue connection
+     */
+    private static XAQueueConnection _xaqueueConnection= null;
+
+    /**
+     * standard xa queue connection
+     */
+    private static QueueConnection _queueConnection=null;
+
+
+    /**
+     * standard queue session created from the standard connection
+     */
+    private static QueueSession _nonXASession = null;
+
+    /**
+     * the queue name
+     */
+    private static final String QUEUENAME = "xaQueue";
+
+    /** ----------------------------------------------------------------------------------- **/
+    /**
+     * ----------------------------- JUnit support  ----------------------------------------- *
+     */
+
+    /**
+     * Gets the test suite tests
+     *
+     * @return the test suite tests
+     */
+    public static TestSuite getSuite()
+    {
+        return new TestSuite(QueueTest.class);
+    }
+
+    /**
+     * Run the test suite.
+     *
+     * @param args Any command line arguments specified to this class.
+     */
+    public static void main(String args[])
+    {
+        junit.textui.TestRunner.run(getSuite());
+    }
+
+    public void tearDown() throws Exception
+    {
+        if (!isBroker08())
+        {
+            try
+            {
+                _xaqueueConnection.close();
+                _queueConnection.close();
+            }
+            catch (Exception e)
+            {
+                fail("Exception thrown when cleaning standard connection: " + e.getStackTrace());
+            }
+        }
+        super.tearDown();
+    }
+
+    /**
+     * Initialize standard actors
+     */
+    public void init()
+    {
+        if (!isBroker08())
+        {
+            // lookup test queue
+            try
+            {
+                _queue = (Queue) getInitialContext().lookup(QUEUENAME);
+            }
+            catch (Exception e)
+            {
+                fail("cannot lookup test queue " + e.getMessage());
+            }
+
+            // lookup connection factory
+            try
+            {
+                _queueFactory = getConnectionFactory();
+            }
+            catch (Exception e)
+            {
+                fail("enable to lookup connection factory ");
+            }
+            // create standard connection
+            try
+            {
+                _xaqueueConnection= getNewQueueXAConnection();
+            }
+            catch (JMSException e)
+            {
+                fail("cannot create queue connection: " + e.getMessage());
+            }
+            // create xa session
+            XAQueueSession session = null;
+            try
+            {
+                session = _xaqueueConnection.createXAQueueSession();
+            }
+            catch (JMSException e)
+            {
+                fail("cannot create queue session: " + e.getMessage());
+            }
+            // create a standard session
+            try
+            {
+                _queueConnection = _queueFactory.createQueueConnection();
+                _nonXASession = _queueConnection.createQueueSession(true, Session.AUTO_ACKNOWLEDGE);
+            }
+            catch (JMSException e)
+            {
+                fail("cannot create queue session: " + e.getMessage());
+            }
+            init(session, _queue);
+        }
+    }
+
+    /** -------------------------------------------------------------------------------------- **/
+    /** ----------------------------- Test Suite  -------------------------------------------- **/
+    /** -------------------------------------------------------------------------------------- **/
+
+    /**
+     * Uses two transactions respectively with xid1 and xid2 that are used to send a message
+     * within xid1 and xid2.  xid2 is committed and xid1 is used to receive the message that was sent within xid2.
+     * Xid is then committed and a standard transaction is used to receive the message that was sent within xid1.
+     */
+    public void testProducer()
+    {
+        if (!isBroker08())
+        {
+            _logger.debug("running testProducer");
+            Xid xid1 = getNewXid();
+            Xid xid2 = getNewXid();
+            // start the xaResource for xid1
+            try
+            {
+                _xaResource.start(xid1, XAResource.TMNOFLAGS);
+            }
+            catch (XAException e)
+            {
+                e.printStackTrace();
+                fail("cannot start the transaction with xid1: " + e.getMessage());
+            }
+            try
+            {
+                // start the connection
+                _xaqueueConnection.start();
+                // produce a message with sequence number 1
+                _message.setLongProperty(_sequenceNumberPropertyName, 1);
+                _producer.send(_message);
+            }
+            catch (JMSException e)
+            {
+                fail(" cannot send persistent message: " + e.getMessage());
+            }
+            // suspend the transaction
+            try
+            {
+                _xaResource.end(xid1, XAResource.TMSUSPEND);
+            }
+            catch (XAException e)
+            {
+                fail("Cannot end the transaction with xid1: " + e.getMessage());
+            }
+            // start the xaResource for xid2
+            try
+            {
+                _xaResource.start(xid2, XAResource.TMNOFLAGS);
+            }
+            catch (XAException e)
+            {
+                fail("cannot start the transaction with xid2: " + e.getMessage());
+            }
+            try
+            {
+                // produce a message
+                _message.setLongProperty(_sequenceNumberPropertyName, 2);
+                _producer.send(_message);
+            }
+            catch (JMSException e)
+            {
+                fail(" cannot send second persistent message: " + e.getMessage());
+            }
+            // end xid2 and start xid1
+            try
+            {
+                _xaResource.end(xid2, XAResource.TMSUCCESS);
+                _xaResource.start(xid1, XAResource.TMRESUME);
+            }
+            catch (XAException e)
+            {
+                fail("Exception when ending and starting transactions: " + e.getMessage());
+            }
+            // two phases commit transaction with xid2
+            try
+            {
+                int resPrepare = _xaResource.prepare(xid2);
+                if (resPrepare != XAResource.XA_OK)
+                {
+                    fail("prepare returned: " + resPrepare);
+                }
+                _xaResource.commit(xid2, false);
+            }
+            catch (XAException e)
+            {
+                fail("Exception thrown when preparing transaction with xid2: " + e.getMessage());
+            }
+            // receive a message from queue test we expect it to be the second one
+            try
+            {
+                TextMessage message = (TextMessage) _consumer.receive(1000);
+                if (message == null)
+                {
+                    fail("did not receive second message as expected ");
+                }
+                else
+                {
+                    if (message.getLongProperty(_sequenceNumberPropertyName) != 2)
+                    {
+                        fail("receive wrong message its sequence number is: " + message
+                                .getLongProperty(_sequenceNumberPropertyName));
+                    }
+                }
+            }
+            catch (JMSException e)
+            {
+                fail("Exception when receiving second message: " + e.getMessage());
+            }
+            // end and one phase commit the first transaction
+            try
+            {
+                _xaResource.end(xid1, XAResource.TMSUCCESS);
+                _xaResource.commit(xid1, true);
+            }
+            catch (XAException e)
+            {
+                fail("Exception thrown when commiting transaction with xid1");
+            }
+            // We should now be able to receive the first message
+            try
+            {
+                _xaqueueConnection.close();
+                Session nonXASession = _nonXASession;
+                MessageConsumer nonXAConsumer = nonXASession.createConsumer(_queue);
+                _queueConnection.start();
+                TextMessage message1 = (TextMessage) nonXAConsumer.receive(1000);
+                if (message1 == null)
+                {
+                    fail("did not receive first message as expected ");
+                }
+                else
+                {
+                    if (message1.getLongProperty(_sequenceNumberPropertyName) != 1)
+                    {
+                        fail("receive wrong message its sequence number is: " + message1
+                                .getLongProperty(_sequenceNumberPropertyName));
+                    }
+                }
+                // commit that transacted session
+                nonXASession.commit();
+                // the queue should be now empty
+                message1 = (TextMessage) nonXAConsumer.receive(1000);
+                if (message1 != null)
+                {
+                    fail("receive an unexpected message ");
+                }
+            }
+            catch (JMSException e)
+            {
+                fail("Exception thrown when emptying the queue: " + e.getMessage());
+            }
+        }
+    }
+
+    /**
+     * strategy: Produce a message within Tx1 and prepare tx1. crash the server then commit tx1 and consume the message
+     */
+    public void testSendAndRecover()
+    {
+        if (!isBroker08())
+        {
+            _logger.debug("running testSendAndRecover");
+            Xid xid1 = getNewXid();
+            // start the xaResource for xid1
+            try
+            {
+                _xaResource.start(xid1, XAResource.TMNOFLAGS);
+            }
+            catch (XAException e)
+            {
+                fail("cannot start the transaction with xid1: " + e.getMessage());
+            }
+            try
+            {
+                // start the connection
+                _xaqueueConnection.start();
+                // produce a message with sequence number 1
+                _message.setLongProperty(_sequenceNumberPropertyName, 1);
+                _producer.send(_message);
+            }
+            catch (JMSException e)
+            {
+                fail(" cannot send persistent message: " + e.getMessage());
+            }
+            // suspend the transaction
+            try
+            {
+                _xaResource.end(xid1, XAResource.TMSUCCESS);
+            }
+            catch (XAException e)
+            {
+                fail("Cannot end the transaction with xid1: " + e.getMessage());
+            }
+            // prepare the transaction with xid1
+            try
+            {
+                _xaResource.prepare(xid1);
+            }
+            catch (XAException e)
+            {
+                fail("Exception when preparing xid1: " + e.getMessage());
+            }
+
+            /////// stop the server now !!
+            try
+            {
+                _logger.debug("stopping broker");
+                restartBroker();
+                init();
+            }
+            catch (Exception e)
+            {
+                fail("Exception when stopping and restarting the server");
+            }
+
+            // get the list of in doubt transactions
+            try
+            {
+                Xid[] inDoubt = _xaResource.recover(XAResource.TMSTARTRSCAN);
+                if (inDoubt == null)
+                {
+                    fail("the array of in doubt transactions should not be null ");
+                }
+                // At that point we expect only two indoubt transactions:
+                if (inDoubt.length != 1)
+                {
+                    fail("in doubt transaction size is diffenrent thatn 2, there are " + inDoubt.length + "in doubt transactions");
+                }
+
+                // commit them
+                for (Xid anInDoubt : inDoubt)
+                {
+                    if (anInDoubt.equals(xid1))
+                    {
+                        System.out.println("commit xid1 ");
+                        try
+                        {
+                            _xaResource.commit(anInDoubt, false);
+                        }
+                        catch (Exception e)
+                        {
+                            System.out.println("PB when aborted xid1");
+                        }
+                    }
+                    else
+                    {
+                        fail("did not receive right xid ");
+                    }
+                }
+            }
+            catch (XAException e)
+            {
+                e.printStackTrace();
+                fail("exception thrown when recovering transactions " + e.getMessage());
+            }
+            // the queue should contain the first message!
+            try
+            {
+                _xaqueueConnection.close();
+                Session nonXASession = _nonXASession;
+                MessageConsumer nonXAConsumer = nonXASession.createConsumer(_queue);
+                _queueConnection.start();
+                TextMessage message1 = (TextMessage) nonXAConsumer.receive(1000);
+
+                if (message1 == null)
+                {
+                    fail("queue does not contain any message!");
+                }
+                if (message1.getLongProperty(_sequenceNumberPropertyName) != 1)
+                {
+                    fail("Wrong message returned! Sequence number is " + message1
+                            .getLongProperty(_sequenceNumberPropertyName));
+                }
+                nonXASession.commit();
+            }
+            catch (JMSException e)
+            {
+                fail("Exception thrown when testin that queue test is not empty: " + e.getMessage());
+            }
+        }
+    }
+
+    /**
+     * strategy: Produce a message within Tx1 and prepare tx1. Produce a standard message and consume
+     * it within tx2 and prepare tx2. Shutdown the server and get the list of in doubt transactions:
+     * we expect tx1 and tx2! Then, Tx1 is aborted and tx2 is committed so we expect the test's queue to be empty!
+     */
+    public void testRecover()
+    {
+        if (!isBroker08())
+        {
+            _logger.debug("running testRecover");
+            Xid xid1 = getNewXid();
+            Xid xid2 = getNewXid();
+            // start the xaResource for xid1
+            try
+            {
+                _xaResource.start(xid1, XAResource.TMNOFLAGS);
+            }
+            catch (XAException e)
+            {
+                fail("cannot start the transaction with xid1: " + e.getMessage());
+            }
+            try
+            {
+                // start the connection
+                _xaqueueConnection.start();
+                // produce a message with sequence number 1
+                _message.setLongProperty(_sequenceNumberPropertyName, 1);
+                _producer.send(_message);
+            }
+            catch (JMSException e)
+            {
+                fail(" cannot send persistent message: " + e.getMessage());
+            }
+            // suspend the transaction
+            try
+            {
+                _xaResource.end(xid1, XAResource.TMSUCCESS);
+            }
+            catch (XAException e)
+            {
+                fail("Cannot end the transaction with xid1: " + e.getMessage());
+            }
+            // prepare the transaction with xid1
+            try
+            {
+                _xaResource.prepare(xid1);
+            }
+            catch (XAException e)
+            {
+                fail("Exception when preparing xid1: " + e.getMessage());
+            }
+
+            // send a message using the standard session
+            try
+            {
+                Session nonXASession = _nonXASession;
+                MessageProducer nonXAProducer = nonXASession.createProducer(_queue);
+                TextMessage message2 = nonXASession.createTextMessage();
+                message2.setText("non XA ");
+                message2.setLongProperty(_sequenceNumberPropertyName, 2);
+                nonXAProducer.setDeliveryMode(DeliveryMode.PERSISTENT);
+                nonXAProducer.send(message2);
+                // commit that transacted session
+                nonXASession.commit();
+            }
+            catch (Exception e)
+            {
+                fail("Exception thrown when emptying the queue: " + e.getMessage());
+            }
+            // start the xaResource for xid2
+            try
+            {
+                _xaResource.start(xid2, XAResource.TMNOFLAGS);
+            }
+            catch (XAException e)
+            {
+                fail("cannot start the transaction with xid1: " + e.getMessage());
+            }
+            // receive a message from queue test we expect it to be the second one
+            try
+            {
+                TextMessage message = (TextMessage) _consumer.receive(1000);
+                if (message == null || message.getLongProperty(_sequenceNumberPropertyName) != 2)
+                {
+                    fail("did not receive second message as expected ");
+                }
+            }
+            catch (JMSException e)
+            {
+                fail("Exception when receiving second message: " + e.getMessage());
+            }
+            // suspend the transaction
+            try
+            {
+                _xaResource.end(xid2, XAResource.TMSUCCESS);
+            }
+            catch (XAException e)
+            {
+                fail("Cannot end the transaction with xid2: " + e.getMessage());
+            }
+            // prepare the transaction with xid1
+            try
+            {
+                _xaResource.prepare(xid2);
+            }
+            catch (XAException e)
+            {
+                fail("Exception when preparing xid2: " + e.getMessage());
+            }
+
+            /////// stop the server now !!
+            try
+            {
+                _logger.debug("stopping broker");
+                restartBroker();
+                init();
+            }
+            catch (Exception e)
+            {
+                fail("Exception when stopping and restarting the server");
+            }
+
+            // get the list of in doubt transactions
+            try
+            {
+                Xid[] inDoubt = _xaResource.recover(XAResource.TMSTARTRSCAN);
+                if (inDoubt == null)
+                {
+                    fail("the array of in doubt transactions should not be null ");
+                }
+                // At that point we expect only two indoubt transactions:
+                if (inDoubt.length != 2)
+                {
+                    fail("in doubt transaction size is diffenrent thatn 2, there are " + inDoubt.length + "in doubt transactions");
+                }
+
+                // commit them
+                for (Xid anInDoubt : inDoubt)
+                {
+                    if (anInDoubt.equals(xid1))
+                    {
+                         _logger.debug("rollback xid1 ");
+                        try
+                        {
+                            _xaResource.rollback(anInDoubt);
+                        }
+                        catch (Exception e)
+                        {
+                            System.out.println("PB when aborted xid1");
+                        }
+                    }
+                    else if (anInDoubt.equals(xid2))
+                    {
+                        _logger.debug("commit xid2 ");
+                        try
+                        {
+                            _xaResource.commit(anInDoubt, false);
+                        }
+                        catch (Exception e)
+                        {
+                            System.out.println("PB when commiting xid2");
+                        }
+                    }
+                }
+            }
+            catch (XAException e)
+            {
+                e.printStackTrace();
+                fail("exception thrown when recovering transactions " + e.getMessage());
+            }
+            // the queue should be empty
+            try
+            {
+                _xaqueueConnection.close();
+                Session nonXASession = _nonXASession;
+                MessageConsumer nonXAConsumer = nonXASession.createConsumer(_queue);
+                _queueConnection.start();
+                TextMessage message1 = (TextMessage) nonXAConsumer.receive(1000);
+                if (message1 != null)
+                {
+                    fail("The queue is not empty! ");
+                }
+            }
+            catch (JMSException e)
+            {
+                fail("Exception thrown when testin that queue test is empty: " + e.getMessage());
+            }
+        }
+    }
+
+    /** -------------------------------------------------------------------------------------- **/
+    /** ----------------------------- Utility methods  --------------------------------------- **/
+    /** -------------------------------------------------------------------------------------- **/
+
+    /**
+     * get a new queue connection
+     *
+     * @return a new queue connection
+     * @throws JMSException If the JMS provider fails to create the queue connection
+     *                      due to some internal error or in case of authentication failure
+     */
+    private XAQueueConnection getNewQueueXAConnection() throws JMSException
+    {
+        return _queueFactory.createXAQueueConnection("guest", "guest");
+    }
+
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/unit/xa/TopicTest.java b/java/systests/src/main/java/org/apache/qpid/test/unit/xa/TopicTest.java
new file mode 100644
index 0000000000..99d0f0a075
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/unit/xa/TopicTest.java
@@ -0,0 +1,1711 @@
+/* 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.xa;
+
+import javax.jms.*;
+import javax.transaction.xa.XAResource;
+import javax.transaction.xa.Xid;
+import javax.transaction.xa.XAException;
+
+import junit.framework.TestSuite;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ *
+ *
+ */
+public class TopicTest extends AbstractXATestCase
+{
+    /* this clas logger */
+    private static final Logger _logger = LoggerFactory.getLogger(TopicTest.class);
+
+    /**
+     * the topic use by all the tests
+     */
+    private static Topic _topic = null;
+
+    /**
+     * the topic connection factory used by all tests
+     */
+    private static XATopicConnectionFactory _topicFactory = null;
+
+    /**
+     * standard topic connection
+     */
+    private static XATopicConnection _topicConnection = null;
+
+    /**
+     * standard topic session created from the standard connection
+     */
+    private static XATopicSession _session = null;
+
+    private static TopicSession _nonXASession = null;
+
+    /**
+     * the topic name
+     */
+    private static final String TOPICNAME = "xaTopic";
+
+    /**
+     * Indicate that a listenere has failed
+     */
+    private static boolean _failure = false;
+
+    /** -------------------------------------------------------------------------------------- **/
+    /** ----------------------------- JUnit support  ----------------------------------------- **/
+    /** -------------------------------------------------------------------------------------- **/
+
+    /**
+     * Gets the test suite tests
+     *
+     * @return the test suite tests
+     */
+    public static TestSuite getSuite()
+    {
+        return new TestSuite(TopicTest.class);
+    }
+
+    /**
+     * Run the test suite.
+     *
+     * @param args Any command line arguments specified to this class.
+     */
+    public static void main(String args[])
+    {
+        junit.textui.TestRunner.run(getSuite());
+    }
+
+    public void tearDown() throws Exception
+    {
+        if (!isBroker08())
+        {
+            try
+            {
+                _topicConnection.stop();
+                _topicConnection.close();
+            }
+            catch (Exception e)
+            {
+                fail("Exception thrown when cleaning standard connection: " + e.getStackTrace());
+            }
+        }
+        super.tearDown();
+    }
+
+    /**
+     * Initialize standard actors
+     */
+    public void init()
+    {
+        if (!isBroker08())
+        {
+            // lookup test queue
+            try
+            {
+                _topic = (Topic) getInitialContext().lookup(TOPICNAME);
+            }
+            catch (Exception e)
+            {
+                fail("cannot lookup test topic " + e.getMessage());
+            }
+            // lookup connection factory
+            try
+            {
+                _topicFactory = getConnectionFactory();
+            }
+            catch (Exception e)
+            {
+                fail("enable to lookup connection factory ");
+            }
+            // create standard connection
+            try
+            {
+                _topicConnection = getNewTopicXAConnection();
+            }
+            catch (JMSException e)
+            {
+                fail("cannot create queue connection: " + e.getMessage());
+            }
+            // create standard session
+            try
+            {
+                _session = _topicConnection.createXATopicSession();
+            }
+            catch (JMSException e)
+            {
+                fail("cannot create queue session: " + e.getMessage());
+            }
+            // create a standard session
+            try
+            {
+                _nonXASession = _topicConnection.createTopicSession(true, Session.AUTO_ACKNOWLEDGE);
+            }
+            catch (JMSException e)
+            {
+                e.printStackTrace();  //To change body of catch statement use Options | File Templates.
+            }
+            init(_session, _topic);
+        }
+    }
+
+    /** -------------------------------------------------------------------------------------- **/
+    /** ----------------------------- Test Suite  -------------------------------------------- **/
+    /** -------------------------------------------------------------------------------------- **/
+
+
+    /**
+     * Uses two transactions respectively with xid1 and xid2 that are use to send a message
+     * within xid1 and xid2. xid2 is committed and xid1 is used to receive the message that was sent within xid2.
+     * Xid is then committed and a standard transaction is used to receive the message that was sent within xid1.
+     */
+    public void testProducer()
+    {
+        if (!isBroker08())
+        {
+            _logger.debug("testProducer");
+            Xid xid1 = getNewXid();
+            Xid xid2 = getNewXid();
+            try
+            {
+                Session nonXASession = _nonXASession;
+                MessageConsumer nonXAConsumer = nonXASession.createConsumer(_topic);
+                _producer.setDeliveryMode(DeliveryMode.PERSISTENT);
+                // start the xaResource for xid1
+                try
+                {
+                    _logger.debug("starting tx branch xid1");
+                    _xaResource.start(xid1, XAResource.TMNOFLAGS);
+                }
+                catch (XAException e)
+                {
+                    e.printStackTrace();
+                    fail("cannot start the transaction with xid1: " + e.getMessage());
+                }
+                try
+                {
+                    // start the connection
+                    _topicConnection.start();
+                    _logger.debug("produce a message with sequence number 1");
+                    _message.setLongProperty(_sequenceNumberPropertyName, 1);
+                    _producer.send(_message);
+                }
+                catch (JMSException e)
+                {
+                    fail(" cannot send persistent message: " + e.getMessage());
+                }
+                _logger.debug("suspend the transaction branch xid1");
+                try
+                {
+                    _xaResource.end(xid1, XAResource.TMSUSPEND);
+                }
+                catch (XAException e)
+                {
+                    fail("Cannot end the transaction with xid1: " + e.getMessage());
+                }
+                _logger.debug("start the xaResource for xid2");
+                try
+                {
+                    _xaResource.start(xid2, XAResource.TMNOFLAGS);
+                }
+                catch (XAException e)
+                {
+                    fail("cannot start the transaction with xid2: " + e.getMessage());
+                }
+                try
+                {
+                    _logger.debug("produce a message");
+                    _message.setLongProperty(_sequenceNumberPropertyName, 2);
+                    _producer.send(_message);
+                }
+                catch (JMSException e)
+                {
+                    fail(" cannot send second persistent message: " + e.getMessage());
+                }
+                _logger.debug("end xid2 and start xid1");
+                try
+                {
+                    _xaResource.end(xid2, XAResource.TMSUCCESS);
+                    _xaResource.start(xid1, XAResource.TMRESUME);
+                }
+                catch (XAException e)
+                {
+                    fail("Exception when ending and starting transactions: " + e.getMessage());
+                }
+                _logger.debug("two phases commit transaction with xid2");
+                try
+                {
+                    int resPrepare = _xaResource.prepare(xid2);
+                    if (resPrepare != XAResource.XA_OK)
+                    {
+                        fail("prepare returned: " + resPrepare);
+                    }
+                    _xaResource.commit(xid2, false);
+                }
+                catch (XAException e)
+                {
+                    fail("Exception thrown when preparing transaction with xid2: " + e.getMessage());
+                }
+                _logger.debug("receiving a message from topic test we expect it to be the second one");
+                try
+                {
+                    TextMessage message = (TextMessage) _consumer.receive(1000);
+                    if (message == null)
+                    {
+                        fail("did not receive second message as expected ");
+                    }
+                    else
+                    {
+                        if (message.getLongProperty(_sequenceNumberPropertyName) != 2)
+                        {
+                            fail("receive wrong message its sequence number is: " + message
+                                    .getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                }
+                catch (JMSException e)
+                {
+                    fail("Exception when receiving second message: " + e.getMessage());
+                }
+                _logger.debug("end and one phase commit the first transaction");
+                try
+                {
+                    _xaResource.end(xid1, XAResource.TMSUCCESS);
+                    _xaResource.commit(xid1, true);
+                }
+                catch (XAException e)
+                {
+                    fail("Exception thrown when commiting transaction with xid1");
+                }
+                _logger.debug("We should now be able to receive the first and second message");
+                try
+                {
+                    TextMessage message1 = (TextMessage) nonXAConsumer.receive(1000);
+                    if (message1 == null)
+                    {
+                        fail("did not receive first message as expected ");
+                    }
+                    else
+                    {
+                        if (message1.getLongProperty(_sequenceNumberPropertyName) != 2)
+                        {
+                            fail("receive wrong message its sequence number is: " + message1
+                                    .getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    message1 = (TextMessage) nonXAConsumer.receive(1000);
+                    if (message1 == null)
+                    {
+                        fail("did not receive first message as expected ");
+                    }
+                    else
+                    {
+                        if (message1.getLongProperty(_sequenceNumberPropertyName) != 1)
+                        {
+                            fail("receive wrong message its sequence number is: " + message1
+                                    .getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _logger.debug("commit transacted session");
+                    nonXASession.commit();
+                    _logger.debug("Test that the topic is now empty");
+                    message1 = (TextMessage) nonXAConsumer.receive(1000);
+                    if (message1 != null)
+                    {
+                        fail("receive an unexpected message ");
+                    }
+                }
+                catch (JMSException e)
+                {
+                    fail("Exception thrown when emptying the queue: " + e.getMessage());
+                }
+            }
+            catch (JMSException e)
+            {
+                fail("cannot create standard consumer: " + e.getMessage());
+            }
+        }
+    }
+
+
+    /**
+     * strategy: Produce a message within Tx1 and commit tx1.  consume this message within tx2 and abort tx2.
+     * Consume the same message within tx3 and commit it. Check that no more message is available.
+     */
+    public void testDurSub()
+    {
+        if (!isBroker08())
+        {
+            Xid xid1 = getNewXid();
+            Xid xid2 = getNewXid();
+            Xid xid3 = getNewXid();
+            Xid xid4 = getNewXid();
+            String durSubName = "xaSubDurable";
+            try
+            {
+                TopicSubscriber xaDurSub = _session.createDurableSubscriber(_topic, durSubName);
+                try
+                {
+                    _topicConnection.start();
+                    _logger.debug("start xid1");
+                    _xaResource.start(xid1, XAResource.TMNOFLAGS);
+                    // start the connection
+                    _topicConnection.start();
+                    _logger.debug("produce a message with sequence number 1");
+                    _message.setLongProperty(_sequenceNumberPropertyName, 1);
+                    _producer.send(_message);
+                    _logger.debug("2 phases commit xid1");
+                    _xaResource.end(xid1, XAResource.TMSUCCESS);
+                    if (_xaResource.prepare(xid1) != XAResource.XA_OK)
+                    {
+                        fail("Problem when preparing tx1 ");
+                    }
+                    _xaResource.commit(xid1, false);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception when working with xid1: " + e.getMessage());
+                }
+                try
+                {
+                    _logger.debug("start xid2");
+                    _xaResource.start(xid2, XAResource.TMNOFLAGS);
+                    _logger.debug("receive the previously produced message");
+                    TextMessage message = (TextMessage) xaDurSub.receive(1000);
+                    if (message == null)
+                    {
+                        fail("no message received ");
+                    }
+                    else if (message.getLongProperty(_sequenceNumberPropertyName) != 1)
+                    {
+                        fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                    }
+                    _logger.debug("rollback xid2");
+                    boolean rollbackOnFailure = false;
+                    try
+                    {
+                        _xaResource.end(xid2, XAResource.TMFAIL);
+                    }
+                    catch (XAException e)
+                    {
+                        if (e.errorCode != XAException.XA_RBROLLBACK)
+                        {
+                            fail("Exception when working with xid2: " + e.getMessage());
+                        }
+                        rollbackOnFailure = true;
+                    }
+                    if (!rollbackOnFailure)
+                    {
+                        if (_xaResource.prepare(xid2) != XAResource.XA_OK)
+                        {
+                            fail("Problem when preparing tx2 ");
+                        }
+                        _xaResource.rollback(xid2);
+                    }
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception when working with xid2: " + e.getMessage());
+                }
+                try
+                {
+                    _logger.debug("start xid3");
+                    _xaResource.start(xid3, XAResource.TMNOFLAGS);
+                    _logger.debug(" receive the previously aborted consumed message");
+                    TextMessage message = (TextMessage) xaDurSub.receive(1000);
+                    if (message == null)
+                    {
+                        fail("no message received ");
+                    }
+                    else if (message.getLongProperty(_sequenceNumberPropertyName) != 1)
+                    {
+                        fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                    }
+                    _logger.debug("commit xid3");
+                    _xaResource.end(xid3, XAResource.TMSUCCESS);
+                    if (_xaResource.prepare(xid3) != XAResource.XA_OK)
+                    {
+                        fail("Problem when preparing tx3 ");
+                    }
+                    _xaResource.commit(xid3, false);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception when working with xid3: " + e.getMessage());
+                }
+                try
+                {
+                    _logger.debug("start xid4");
+                    _xaResource.start(xid4, XAResource.TMNOFLAGS);
+                    _logger.debug("check that topic is empty");
+                    TextMessage message = (TextMessage) xaDurSub.receive(1000);
+                    if (message != null)
+                    {
+                        fail("An unexpected message was received ");
+                    }
+                    _logger.debug("commit xid4");
+                    _xaResource.end(xid4, XAResource.TMSUCCESS);
+                    _xaResource.commit(xid4, true);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception when working with xid4: " + e.getMessage());
+                }
+            }
+            catch (Exception e)
+            {
+                e.printStackTrace();
+                fail("problem when creating dur sub: " + e.getMessage());
+            }
+            finally
+            {
+                try
+                {
+                    _session.unsubscribe(durSubName);
+                }
+                catch (JMSException e)
+                {
+                    e.printStackTrace();
+                    fail("problem when unsubscribing dur sub: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    /**
+     * strategy: create a XA durable subscriber dusSub, produce 7 messages with the standard session,
+     * consume 2 messages respectively with tx1, tx2 and tx3
+     * abort tx2, we now expect to receive messages 3 and 4 first! Receive 3 messages within tx1 i.e. 34 and 7!
+     * commit tx3
+     * abort tx1: we now expect that only messages 5 and 6 are definitly consumed!
+     * start tx4 and consume messages 1 - 4   and 7
+     * commit tx4
+     * Now the topic should be empty!
+     */
+    public void testMultiMessagesDurSub()
+    {
+        if (!isBroker08())
+        {
+            Xid xid1 = getNewXid();
+            Xid xid2 = getNewXid();
+            Xid xid3 = getNewXid();
+            Xid xid4 = getNewXid();
+            Xid xid6 = getNewXid();
+            String durSubName = "xaSubDurable";
+            TextMessage message;
+            try
+            {
+                TopicSubscriber xaDurSub = _session.createDurableSubscriber(_topic, durSubName);
+                try
+                {
+                    Session txSession = _nonXASession;
+                    MessageProducer txProducer = txSession.createProducer(_topic);
+                    _logger.debug("produce 10 persistent messages");
+                    txProducer.setDeliveryMode(DeliveryMode.PERSISTENT);
+                    _topicConnection.start();
+                    for (int i = 1; i <= 7; i++)
+                    {
+                        _message.setLongProperty(_sequenceNumberPropertyName, i);
+                        txProducer.send(_message);
+                    }
+                    // commit txSession
+                    txSession.commit();
+                }
+                catch (JMSException e)
+                {
+                    e.printStackTrace();
+                    fail("Exception thrown when producing messages: " + e.getMessage());
+                }
+
+                try
+                {
+                    _logger.debug(" consume 2 messages respectively with tx1, tx2 and tx3");
+                    //----- start xid1
+                    _xaResource.start(xid1, XAResource.TMNOFLAGS);
+                    // receive the 2 first messages
+                    for (int i = 1; i <= 2; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid1, XAResource.TMSUSPEND);
+                    //----- start xid2
+                    _xaResource.start(xid2, XAResource.TMNOFLAGS);
+                    // receive the 2 first messages
+                    for (int i = 3; i <= 4; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid2, XAResource.TMSUSPEND);
+                    //----- start xid3
+                    _xaResource.start(xid3, XAResource.TMNOFLAGS);
+                    // receive the 2 first messages
+                    for (int i = 5; i <= 6; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid3, XAResource.TMSUCCESS);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception thrown when consumming 6 first messages: " + e.getMessage());
+                }
+                try
+                {
+                    _logger.debug("abort tx2, we now expect to receive messages 3, 4 and 7");
+                    _xaResource.start(xid2, XAResource.TMRESUME);
+                    _xaResource.end(xid2, XAResource.TMSUCCESS);
+                    _xaResource.prepare(xid2);
+                    _xaResource.rollback(xid2);
+                    // receive 3 message within tx1: 3, 4 and 7
+                    _xaResource.start(xid1, XAResource.TMRESUME);
+                    _logger.debug(" 3, 4 and 7");
+                    for (int i = 1; i <= 3; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + 3);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) <= 2 || 5 == message
+                                .getLongProperty(_sequenceNumberPropertyName) || message
+                                .getLongProperty(_sequenceNumberPropertyName) == 6)
+                        {
+                            fail("wrong sequence number: " + message
+                                    .getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception thrown when consumming message: 3, 4 and 7:  " + e.getMessage());
+                }
+
+                try
+                {
+                    _xaResource.end(xid1, XAResource.TMSUCCESS);
+                    _logger.debug(" commit tx3");
+                    _xaResource.commit(xid3, true);
+                    _logger.debug("abort tx1");
+                    _xaResource.prepare(xid1);
+                    _xaResource.rollback(xid1);
+                }
+                catch (XAException e)
+                {
+                    e.printStackTrace();
+                    fail("XAException thrown when committing tx3 or aborting tx1: " + e.getMessage());
+                }
+
+                try
+                {
+                    // consume messages 1 - 4  + 7
+                    //----- start xid1
+                    _xaResource.start(xid4, XAResource.TMNOFLAGS);
+                    for (int i = 1; i <= 5; i++)
+                    {
+
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        _logger.debug(" received message: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) == 5 || message
+                                .getLongProperty(_sequenceNumberPropertyName) == 6)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid4, XAResource.TMSUCCESS);
+                    _xaResource.prepare(xid4);
+                    _xaResource.commit(xid4, false);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception thrown in last phase: " + e.getMessage());
+                }
+                // now the topic should be empty!!
+                try
+                {
+                    // start xid6
+                    _xaResource.start(xid6, XAResource.TMNOFLAGS);
+                    // should now be empty
+                    message = (TextMessage) xaDurSub.receive(1000);
+                    if (message != null)
+                    {
+                        fail("An unexpected message was received " + message
+                                .getLongProperty(_sequenceNumberPropertyName));
+                    }
+                    // commit xid6
+                    _xaResource.end(xid6, XAResource.TMSUCCESS);
+                    _xaResource.commit(xid6, true);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception when working with xid6: " + e.getMessage());
+                }
+            }
+            catch (Exception e)
+            {
+                e.printStackTrace();
+                fail("problem when creating dur sub: " + e.getMessage());
+            }
+            finally
+            {
+                try
+                {
+                    _session.unsubscribe(durSubName);
+                }
+                catch (JMSException e)
+                {
+                    e.printStackTrace();
+                    fail("problem when unsubscribing dur sub: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    /**
+     * strategy: create a XA durable subscriber dusSub, produce 10 messages with the standard session,
+     * consume 2 messages respectively with tx1, tx2 and tx3
+     * prepare xid2 and xid3
+     * crash the server
+     * Redo the job for xid1 that has been aborted by server crash
+     * abort tx2, we now expect to receive messages 3 and 4 first! Receive 3 messages within tx1 i.e. 34 and 7!
+     * commit tx3
+     * abort tx1: we now expect that only messages 5 and 6 are definitly consumed!
+     * start tx4 and consume messages 1 - 4
+     * start tx5 and consume messages 7 - 10
+     * abort tx4
+     * consume messages 1-4 with tx5
+     * commit tx5
+     * Now the topic should be empty!
+     */
+    public void testMultiMessagesDurSubCrash()
+    {
+        if (!isBroker08())
+        {
+            Xid xid1 = getNewXid();
+            Xid xid2 = getNewXid();
+            Xid xid3 = getNewXid();
+            Xid xid4 = getNewXid();
+            Xid xid5 = getNewXid();
+            Xid xid6 = getNewXid();
+            String durSubName = "xaSubDurable";
+            TextMessage message;
+            try
+            {
+                TopicSubscriber xaDurSub = _session.createDurableSubscriber(_topic, durSubName);
+                try
+                {
+                    Session txSession = _nonXASession;
+                    MessageProducer txProducer = txSession.createProducer(_topic);
+                    // produce 10 persistent messages
+                    txProducer.setDeliveryMode(DeliveryMode.PERSISTENT);
+                    _topicConnection.start();
+                    for (int i = 1; i <= 10; i++)
+                    {
+                        _message.setLongProperty(_sequenceNumberPropertyName, i);
+                        txProducer.send(_message);
+                    }
+                    // commit txSession
+                    txSession.commit();
+                }
+                catch (JMSException e)
+                {
+                    e.printStackTrace();
+                    fail("Exception thrown when producing messages: " + e.getMessage());
+                }
+                try
+                {
+                    // consume 2 messages respectively with tx1, tx2 and tx3
+                    //----- start xid1
+                    _xaResource.start(xid1, XAResource.TMNOFLAGS);
+                    // receive the 2 first messages
+                    for (int i = 1; i <= 2; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid1, XAResource.TMSUCCESS);
+                    //----- start xid2
+                    _xaResource.start(xid2, XAResource.TMNOFLAGS);
+                    // receive the 2 first messages
+                    for (int i = 3; i <= 4; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid2, XAResource.TMSUCCESS);
+                    //----- start xid3
+                    _xaResource.start(xid3, XAResource.TMNOFLAGS);
+                    // receive the 2 first messages
+                    for (int i = 5; i <= 6; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid3, XAResource.TMSUCCESS);
+                    // prepare tx2 and tx3
+
+                    _xaResource.prepare(xid2);
+                    _xaResource.prepare(xid3);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception thrown when consumming 6 first messages: " + e.getMessage());
+                }
+                /////// stop the broker now !!
+                try
+                {
+                    restartBroker();
+                    init();
+                }
+                catch (Exception e)
+                {
+                    fail("Exception when stopping and restarting the server");
+                }
+                // get the list of in doubt transactions
+                try
+                {
+                    _topicConnection.start();
+                    // reconnect to dursub!
+                    xaDurSub = _session.createDurableSubscriber(_topic, durSubName);
+                    Xid[] inDoubt = _xaResource.recover(XAResource.TMSTARTRSCAN);
+                    if (inDoubt == null)
+                    {
+                        fail("the array of in doubt transactions should not be null ");
+                    }
+                    // At that point we expect only two indoubt transactions:
+                    if (inDoubt.length != 2)
+                    {
+                        fail("in doubt transaction size is diffenrent than 2, there are " + inDoubt.length + "in doubt transactions");
+                    }
+                }
+                catch (XAException e)
+                {
+                    e.printStackTrace();
+                    fail("exception thrown when recovering transactions " + e.getMessage());
+                }
+                try
+                {
+                    // xid1 has been aborted redo the job!
+                    // consume 2 messages with tx1
+                    //----- start xid1
+                    _xaResource.start(xid1, XAResource.TMNOFLAGS);
+                    // receive the 2 first messages
+                    for (int i = 1; i <= 2; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid1, XAResource.TMSUSPEND);
+                    // abort tx2, we now expect to receive messages 3 and 4 first!
+                    _xaResource.rollback(xid2);
+
+                    // receive 3 message within tx1: 3, 4 and 7
+                    _xaResource.start(xid1, XAResource.TMRESUME);
+                    // receive messages 3, 4 and 7
+                    message = (TextMessage) xaDurSub.receive(1000);
+                    if (message == null)
+                    {
+                        fail("no message received! expected: " + 3);
+                    }
+                    else if (message.getLongProperty(_sequenceNumberPropertyName) != 3)
+                    {
+                        fail("wrong sequence number: " + message
+                                .getLongProperty(_sequenceNumberPropertyName) + " 3 was expected");
+                    }
+                    message = (TextMessage) xaDurSub.receive(1000);
+                    if (message == null)
+                    {
+                        fail("no message received! expected: " + 4);
+                    }
+                    else if (message.getLongProperty(_sequenceNumberPropertyName) != 4)
+                    {
+                        fail("wrong sequence number: " + message
+                                .getLongProperty(_sequenceNumberPropertyName) + " 4 was expected");
+                    }
+                    message = (TextMessage) xaDurSub.receive(1000);
+                    if (message == null)
+                    {
+                        fail("no message received! expected: " + 7);
+                    }
+                    else if (message.getLongProperty(_sequenceNumberPropertyName) != 7)
+                    {
+                        fail("wrong sequence number: " + message
+                                .getLongProperty(_sequenceNumberPropertyName) + " 7 was expected");
+                    }
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception thrown when consumming message: 3, 4 and 7:  " + e.getMessage());
+                }
+
+                try
+                {
+                    _xaResource.end(xid1, XAResource.TMSUSPEND);
+                    // commit tx3
+                    _xaResource.commit(xid3, false);
+                    // abort tx1
+                    _xaResource.prepare(xid1);
+                    _xaResource.rollback(xid1);
+                }
+                catch (XAException e)
+                {
+                    e.printStackTrace();
+                    fail("XAException thrown when committing tx3 or aborting tx1: " + e.getMessage());
+                }
+
+                try
+                {
+                    // consume messages 1 - 4
+                    //----- start xid1
+                    _xaResource.start(xid4, XAResource.TMNOFLAGS);
+                    for (int i = 1; i <= 4; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid4, XAResource.TMSUSPEND);
+                    // consume messages 8 - 10
+                    _xaResource.start(xid5, XAResource.TMNOFLAGS);
+                    for (int i = 7; i <= 10; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid5, XAResource.TMSUSPEND);
+                    // abort tx4
+                    _xaResource.prepare(xid4);
+                    _xaResource.rollback(xid4);
+                    // consume messages 1-4 with tx5
+                    _xaResource.start(xid5, XAResource.TMRESUME);
+                    for (int i = 1; i <= 4; i++)
+                    {
+                        message = (TextMessage) xaDurSub.receive(1000);
+                        if (message == null)
+                        {
+                            fail("no message received! expected: " + i);
+                        }
+                        else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                        {
+                            fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                        }
+                    }
+                    _xaResource.end(xid5, XAResource.TMSUSPEND);
+                    // commit tx5
+                    _xaResource.prepare(xid5);
+                    _xaResource.commit(xid5, false);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception thrown in last phase: " + e.getMessage());
+                }
+                // now the topic should be empty!!
+                try
+                {
+                    // start xid6
+                    _xaResource.start(xid6, XAResource.TMNOFLAGS);
+                    // should now be empty
+                    message = (TextMessage) xaDurSub.receive(1000);
+                    if (message != null)
+                    {
+                        fail("An unexpected message was received " + message
+                                .getLongProperty(_sequenceNumberPropertyName));
+                    }
+                    // commit xid6
+                    _xaResource.end(xid6, XAResource.TMSUSPEND);
+                    _xaResource.commit(xid6, true);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception when working with xid6: " + e.getMessage());
+                }
+            }
+            catch (Exception e)
+            {
+                e.printStackTrace();
+                fail("problem when creating dur sub: " + e.getMessage());
+            }
+            finally
+            {
+                try
+                {
+                    _session.unsubscribe(durSubName);
+                }
+                catch (JMSException e)
+                {
+                    e.printStackTrace();
+                    fail("problem when unsubscribing dur sub: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+
+    /**
+     * strategy: Produce a message within Tx1 and commit tx1.  a durable subscriber then receives that message within tx2
+     * that is then prepared.
+     * Shutdown the server and get the list of in doubt transactions:
+     * we expect tx2, Tx2 is aborted and the message consumed within tx3 that is committed we then check that the topic is empty.
+     */
+    public void testDurSubCrash()
+    {
+        if (!isBroker08())
+        {
+            Xid xid1 = getNewXid();
+            Xid xid2 = getNewXid();
+            Xid xid3 = getNewXid();
+            Xid xid4 = getNewXid();
+            String durSubName = "xaSubDurable";
+            try
+            {
+                TopicSubscriber xaDurSub = _session.createDurableSubscriber(_topic, durSubName);
+                try
+                {
+                    _topicConnection.start();
+                    //----- start xid1
+                    _xaResource.start(xid1, XAResource.TMNOFLAGS);
+                    // start the connection
+                    _topicConnection.start();
+                    // produce a message with sequence number 1
+                    _message.setLongProperty(_sequenceNumberPropertyName, 1);
+                    _producer.send(_message);
+                    // commit
+                    _xaResource.end(xid1, XAResource.TMSUCCESS);
+                    if (_xaResource.prepare(xid1) != XAResource.XA_OK)
+                    {
+                        fail("Problem when preparing tx1 ");
+                    }
+                    _xaResource.commit(xid1, false);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception when working with xid1: " + e.getMessage());
+                }
+                try
+                {
+                    // start xid2
+                    _xaResource.start(xid2, XAResource.TMNOFLAGS);
+                    // receive the previously produced message
+                    TextMessage message = (TextMessage) xaDurSub.receive(1000);
+                    if (message == null)
+                    {
+                        fail("no message received ");
+                    }
+                    else if (message.getLongProperty(_sequenceNumberPropertyName) != 1)
+                    {
+                        fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                    }
+                    // prepare xid2
+                    _xaResource.end(xid2, XAResource.TMSUCCESS);
+                    if (_xaResource.prepare(xid2) != XAResource.XA_OK)
+                    {
+                        fail("Problem when preparing tx2 ");
+                    }
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception when working with xid2: " + e.getMessage());
+                }
+
+                /////// stop the server now !!
+                try
+                {
+                    restartBroker();
+                    init();
+                }
+                catch (Exception e)
+                {
+                    fail("Exception when stopping and restarting the server");
+                }
+
+                // get the list of in doubt transactions
+                try
+                {
+                    _topicConnection.start();
+                    // reconnect to dursub!
+                    xaDurSub = _session.createDurableSubscriber(_topic, durSubName);
+                    Xid[] inDoubt = _xaResource.recover(XAResource.TMSTARTRSCAN);
+                    if (inDoubt == null)
+                    {
+                        fail("the array of in doubt transactions should not be null ");
+                    }
+                    // At that point we expect only two indoubt transactions:
+                    if (inDoubt.length != 1)
+                    {
+                        fail("in doubt transaction size is diffenrent than 2, there are " + inDoubt.length + "in doubt transactions");
+                    }
+
+                    // commit them
+                    for (Xid anInDoubt : inDoubt)
+                    {
+                        if (anInDoubt.equals(xid2))
+                        {
+                            System.out.println("aborting xid2 ");
+                            try
+                            {
+                                _xaResource.rollback(anInDoubt);
+                            }
+                            catch (Exception e)
+                            {
+                                e.printStackTrace();
+                                fail("exception when aborting xid2 ");
+                            }
+                        }
+                        else
+                        {
+                            System.out.println("XID2 is not in doubt ");
+                        }
+                    }
+                }
+                catch (XAException e)
+                {
+                    e.printStackTrace();
+                    fail("exception thrown when recovering transactions " + e.getMessage());
+                }
+
+                try
+                {
+                    // start xid3
+                    _xaResource.start(xid3, XAResource.TMNOFLAGS);
+                    // receive the previously produced message and aborted
+                    TextMessage message = (TextMessage) xaDurSub.receive(1000);
+                    if (message == null)
+                    {
+                        fail("no message received ");
+                    }
+                    else if (message.getLongProperty(_sequenceNumberPropertyName) != 1)
+                    {
+                        fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                    }
+                    // commit xid3
+                    _xaResource.end(xid3, XAResource.TMSUCCESS);
+                    if (_xaResource.prepare(xid3) != XAResource.XA_OK)
+                    {
+                        fail("Problem when preparing tx3 ");
+                    }
+                    _xaResource.commit(xid3, false);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception when working with xid3: " + e.getMessage());
+                }
+                try
+                {
+                    // start xid4
+                    _xaResource.start(xid4, XAResource.TMNOFLAGS);
+                    // should now be empty
+                    TextMessage message = (TextMessage) xaDurSub.receive(1000);
+                    if (message != null)
+                    {
+                        fail("An unexpected message was received " + message
+                                .getLongProperty(_sequenceNumberPropertyName));
+                    }
+                    // commit xid4
+                    _xaResource.end(xid4, XAResource.TMSUCCESS);
+                    _xaResource.commit(xid4, true);
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception when working with xid4: " + e.getMessage());
+                }
+            }
+            catch (Exception e)
+            {
+                e.printStackTrace();
+                fail("problem when creating dur sub: " + e.getMessage());
+            }
+            finally
+            {
+                try
+                {
+                    _session.unsubscribe(durSubName);
+                }
+                catch (JMSException e)
+                {
+                    e.printStackTrace();
+                    fail("problem when unsubscribing dur sub: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    /**
+     * strategy: Produce a message within Tx1 and prepare tx1.  Shutdown the server and get the list of indoubt transactions:
+     * we expect tx1, Tx1 is committed  so we expect the test topic not to be empty!
+     */
+    public void testRecover()
+    {
+        if (!isBroker08())
+        {
+            Xid xid1 = getNewXid();
+            String durSubName = "test1";
+            try
+            {
+                // create a dummy durable subscriber to be sure that messages are persisted!
+                _nonXASession.createDurableSubscriber(_topic, durSubName);
+                // start the xaResource for xid1
+                try
+                {
+                    _xaResource.start(xid1, XAResource.TMNOFLAGS);
+                }
+                catch (XAException e)
+                {
+                    fail("cannot start the transaction with xid1: " + e.getMessage());
+                }
+                try
+                {
+                    // start the connection
+                    _topicConnection.start();
+                    // produce a message with sequence number 1
+                    _message.setLongProperty(_sequenceNumberPropertyName, 1);
+                    _producer.send(_message);
+                }
+                catch (JMSException e)
+                {
+                    fail(" cannot send persistent message: " + e.getMessage());
+                }
+                // suspend the transaction
+                try
+                {
+                    _xaResource.end(xid1, XAResource.TMSUCCESS);
+                }
+                catch (XAException e)
+                {
+                    fail("Cannot end the transaction with xid1: " + e.getMessage());
+                }
+                // prepare the transaction with xid1
+                try
+                {
+                    _xaResource.prepare(xid1);
+                }
+                catch (XAException e)
+                {
+                    fail("Exception when preparing xid1: " + e.getMessage());
+                }
+
+                /////// stop the server now !!
+                try
+                {
+                    restartBroker();
+                    init();
+                }
+                catch (Exception e)
+                {
+                    fail("Exception when stopping and restarting the server");
+                }
+
+                try
+                {
+                    MessageConsumer nonXAConsumer =  _nonXASession.createDurableSubscriber(_topic, durSubName);
+                    _topicConnection.start();
+                    // get the list of in doubt transactions
+                    try
+                    {
+                        Xid[] inDoubt = _xaResource.recover(XAResource.TMSTARTRSCAN);
+                        if (inDoubt == null)
+                        {
+                            fail("the array of in doubt transactions should not be null ");
+                        }
+                        // At that point we expect only two indoubt transactions:
+                        if (inDoubt.length != 1)
+                        {
+                            fail("in doubt transaction size is diffenrent thatn 2, there are " + inDoubt.length + "in doubt transactions");
+                        }
+                        // commit them
+                        for (Xid anInDoubt : inDoubt)
+                        {
+                            if (anInDoubt.equals(xid1))
+                            {
+                                _logger.debug("committing xid1 ");
+                                try
+                                {
+                                    _xaResource.commit(anInDoubt, false);
+                                }
+                                catch (Exception e)
+                                {
+                                    _logger.debug("PB when aborted xid1");
+                                    e.printStackTrace();
+                                    fail("exception when committing xid1 ");
+                                }
+                            }
+                            else
+                            {
+                                _logger.debug("XID1 is not in doubt ");
+                            }
+                        }
+                    }
+                    catch (XAException e)
+                    {
+                        e.printStackTrace();
+                        fail("exception thrown when recovering transactions " + e.getMessage());
+                    }
+                    _logger.debug("the topic should not be empty");
+                    TextMessage message1 = (TextMessage) nonXAConsumer.receive(1000);
+                    if (message1 == null)
+                    {
+                        fail("The topic is empty! ");
+                    }
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                    fail("Exception thrown when testin that queue test is empty: " + e.getMessage());
+                }
+            }
+            catch (JMSException e)
+            {
+                e.printStackTrace();
+                fail("cannot create dummy durable subscriber: " + e.getMessage());
+            }
+            finally
+            {
+                try
+                {
+                    // unsubscribe the dummy durable subscriber
+                    TopicSession nonXASession = _nonXASession;
+                    nonXASession.unsubscribe(durSubName);
+                }
+                catch (JMSException e)
+                {
+                    fail("cannot unsubscribe durable subscriber: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    /**
+     * strategy:
+     * create a standard durable subscriber
+     * produce 3 messages
+     * consume the first message with that durable subscriber
+     * close the standard session that deactivates the durable subscriber
+     * migrate the durable subscriber to an xa one
+     * consume the second message with that xa durable subscriber
+     * close the xa session that deactivates the durable subscriber
+     * reconnect to the durable subscriber with a standard session
+     * consume the two remaining messages and check that the topic is empty!
+     */
+    public void testMigrateDurableSubscriber()
+    {
+        if (!isBroker08())
+        {
+            Xid xid1 = getNewXid();
+            Xid xid2 = getNewXid();
+            String durSubName = "DurableSubscriberMigrate";
+            try
+            {
+                Session stSession = _nonXASession;
+                MessageProducer producer = stSession.createProducer(_topic);
+                _logger.debug("Create a standard durable subscriber!");
+                TopicSubscriber durSub = stSession.createDurableSubscriber(_topic, durSubName);
+                TopicSubscriber durSub1 = stSession.createDurableSubscriber(_topic, durSubName + "_second");
+                TextMessage message;
+                producer.setDeliveryMode(DeliveryMode.PERSISTENT);
+                _topicConnection.start();
+                _logger.debug("produce 3 messages");
+                for (int i = 1; i <= 3; i++)
+                {
+                    _message.setLongProperty(_sequenceNumberPropertyName, i);
+                    //producer.send( _message );
+                    producer.send(_message, DeliveryMode.PERSISTENT, 9 - i, 0);
+                    stSession.commit();
+                }
+                _logger.debug("consume the first message with that durable subscriber");
+                message = (TextMessage) durSub.receive(1000);
+                if (message == null)
+                {
+                    fail("no message received ");
+                }
+                else if (message.getLongProperty(_sequenceNumberPropertyName) != 1)
+                {
+                    fail("wrong sequence number: " + message.getLongProperty(_sequenceNumberPropertyName));
+                }
+                // commit the standard session
+                stSession.commit();
+                _logger.debug("first message consumed ");
+                // close the session that deactivates the durable subscriber
+                stSession.close();
+                _logger.debug("migrate the durable subscriber to an xa one");
+                _xaResource.start(xid1, XAResource.TMNOFLAGS);
+                durSub = _session.createDurableSubscriber(_topic, durSubName);
+                _logger.debug(" consume the second message with that xa durable subscriber and abort it");
+                message = (TextMessage) durSub.receive(1000);
+                if (message == null)
+                {
+                    fail("no message received ");
+                }
+                else if (message.getLongProperty(_sequenceNumberPropertyName) != 2)
+                {
+                    System.out.println("wrong sequence number, 2 expected, received: " + message
+                            .getLongProperty(_sequenceNumberPropertyName));
+                }
+                _xaResource.end(xid1, XAResource.TMSUCCESS);
+                _xaResource.prepare(xid1);
+                _xaResource.rollback(xid1);
+                _logger.debug("close the session that deactivates the durable subscriber");
+                _session.close();
+                _logger.debug("create a new standard session");
+                stSession = _topicConnection.createTopicSession(true, 1);
+                _logger.debug("reconnect to the durable subscriber");
+                durSub = stSession.createDurableSubscriber(_topic, durSubName);
+                durSub1 = stSession.createDurableSubscriber(_topic, durSubName + "_second");
+                _logger.debug("Reconnected to durablse subscribers");
+                _logger.debug(" consume the 2 remaining messages");
+                message = (TextMessage) durSub.receive(1000);
+                if (message == null)
+                {
+                    fail("no message received ");
+                }
+                else if (message.getLongProperty(_sequenceNumberPropertyName) != 2)
+                {
+                    System.out.println("wrong sequence number, 2 expected, received: " + message
+                            .getLongProperty(_sequenceNumberPropertyName));
+                }
+                // consume the third message with that xa durable subscriber
+                message = (TextMessage) durSub.receive(1000);
+                if (message == null)
+                {
+                    fail("no message received ");
+                }
+                else if (message.getLongProperty(_sequenceNumberPropertyName) != 3)
+                {
+                     System.out.println("wrong sequence number, 3 expected, received: " + message
+                            .getLongProperty(_sequenceNumberPropertyName));
+                }
+                stSession.commit();
+                _logger.debug("the topic should be empty now");
+                message = (TextMessage) durSub.receive(1000);
+                if (message != null)
+                {
+                    fail("Received unexpected message ");
+                }
+                stSession.commit();
+                _logger.debug(" use dursub1 to receive all the 3 messages");
+                for (int i = 1; i <= 3; i++)
+                {
+                    message = (TextMessage) durSub1.receive(1000);
+                    if (message == null)
+                    {
+                        _logger.debug("no message received ");
+                    }
+                    else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                    {
+                        fail("wrong sequence number, " + i + " expected, received: " + message
+                                .getLongProperty(_sequenceNumberPropertyName));
+                    }
+                }
+                stSession.commit();
+                // send a non persistent message to check that all persistent messages are deleted
+                producer = stSession.createProducer(_topic);
+                producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
+                producer.send(_message);
+                stSession.commit();
+                message = (TextMessage) durSub.receive(1000);
+                if (message == null)
+                {
+                    fail("message not received ");
+                }
+                message = (TextMessage) durSub1.receive(1000);
+                if (message == null)
+                {
+                    fail("message not received ");
+                }
+                stSession.commit();
+                stSession.close();
+                _logger.debug(" now create a standard non transacted session and reconnect to the durable xubscriber");
+                TopicConnection stConnection =
+                        _topicConnection; //_topicFactory.createTopicConnection("guest", "guest");
+                TopicSession autoAclSession = stConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
+                TopicPublisher publisher = autoAclSession.createPublisher(_topic);
+                durSub = autoAclSession.createDurableSubscriber(_topic, durSubName);
+                stConnection.start();
+                // produce 3 persistent messages
+                for (int i = 1; i <= 3; i++)
+                {
+                    _message.setLongProperty(_sequenceNumberPropertyName, i);
+                    //producer.send( _message );
+                    publisher.send(_message, DeliveryMode.PERSISTENT, 9 - i, 0);
+                }
+                _logger.debug(" use dursub to receive all the 3 messages");
+                for (int i = 1; i <= 3; i++)
+                {
+                    message = (TextMessage) durSub.receive(1000);
+                    if (message == null)
+                    {
+                        System.out.println("no message received ");
+                    }
+                    else if (message.getLongProperty(_sequenceNumberPropertyName) != i)
+                    {
+                        System.out.println("wrong sequence number, " + i + " expected, received: " + message
+                                .getLongProperty(_sequenceNumberPropertyName));
+                    }
+                }
+
+                _logger.debug("now set a message listener");
+                AtomicBoolean lock = new AtomicBoolean(true);
+                reset();
+                stConnection.stop();
+                durSub.setMessageListener(new TopicListener(1, 3, lock));
+                _logger.debug(" produce 3 persistent messages");
+                for (int i = 1; i <= 3; i++)
+                {
+                    _message.setLongProperty(_sequenceNumberPropertyName, i);
+                    //producer.send( _message );
+                    publisher.send(_message, DeliveryMode.PERSISTENT, 9 - i, 0);
+                }
+                // start the connection
+                stConnection.start();
+                while (lock.get())
+                {
+                    synchronized (lock)
+                    {
+                        lock.wait();
+                    }
+                }
+                if (getFailureStatus())
+                {
+                    fail("problem with message listener");
+                }
+                stConnection.stop();
+                durSub.setMessageListener(null);
+                _logger.debug(" do the same with an xa session");
+                // produce 3 persistent messages
+                for (int i = 1; i <= 3; i++)
+                {
+                    _message.setLongProperty(_sequenceNumberPropertyName, i);
+                    //producer.send( _message );
+                    publisher.send(_message, DeliveryMode.PERSISTENT, 9 - i, 0);
+                }
+                //stConnection.close();
+                autoAclSession.close();
+                _logger.debug(" migrate the durable subscriber to an xa one");
+                _session = _topicConnection.createXATopicSession();
+                _xaResource = _session.getXAResource();
+                _xaResource.start(xid2, XAResource.TMNOFLAGS);
+                durSub = _session.createDurableSubscriber(_topic, durSubName);
+                lock = new AtomicBoolean();
+                reset();
+                _topicConnection.stop();
+                durSub.setMessageListener(new TopicListener(1, 3, lock));
+                // start the connection
+                _topicConnection.start();
+                while (lock.get())
+                {
+                    synchronized (lock)
+                    {
+                        lock.wait();
+                    }
+                }
+                if (getFailureStatus())
+                {
+                    fail("problem with XA message listener");
+                }
+                _xaResource.end(xid2, XAResource.TMSUCCESS);
+                _xaResource.commit(xid2, true);
+            }
+            catch (Exception e)
+            {
+                e.printStackTrace();
+                fail("Exception thrown: " + e.getMessage());
+            }
+            finally
+            {
+                try
+                {
+                    _topicConnection.createXASession().unsubscribe(durSubName);
+                    _topicConnection.createXASession().unsubscribe(durSubName + "_second");
+                }
+                catch (JMSException e)
+                {
+                    fail("Exception thrown when unsubscribing durable subscriber  " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    /** -------------------------------------------------------------------------------------- **/
+    /** ----------------------------- Utility methods  --------------------------------------- **/
+    /** -------------------------------------------------------------------------------------- **/
+
+    /**
+     * get a new queue connection
+     *
+     * @return a new queue connection
+     * @throws javax.jms.JMSException If the JMS provider fails to create the queue connection
+     *                                due to some internal error or in case of authentication failure
+     */
+    private XATopicConnection getNewTopicXAConnection() throws JMSException
+    {
+        return _topicFactory.createXATopicConnection("guest", "guest");
+    }
+
+    public static void failure()
+    {
+        _failure = true;
+    }
+
+    public static void reset()
+    {
+        _failure = false;
+    }
+
+    public static boolean getFailureStatus()
+    {
+        return _failure;
+    }
+
+    private class TopicListener implements MessageListener
+    {
+        private long _counter;
+        private long _end;
+        private final AtomicBoolean _lock;
+
+        public TopicListener(long init, long end, AtomicBoolean lock)
+        {
+            _counter = init;
+            _end = end;
+            _lock = lock;
+        }
+
+        public void onMessage(Message message)
+        {
+            long seq = 0;
+            try
+            {
+                seq = message.getLongProperty(TopicTest._sequenceNumberPropertyName);
+            }
+            catch (JMSException e)
+            {
+                e.printStackTrace();
+                TopicTest.failure();
+                _lock.set(false);
+                synchronized (_lock)
+                {
+                    _lock.notifyAll();
+                }
+            }
+            if (seq != _counter)
+            {
+                System.out.println("received message " + seq + " expected " + _counter);
+                TopicTest.failure();
+                _lock.set(false);
+                synchronized (_lock)
+                {
+                    _lock.notifyAll();
+                }
+            }
+            _counter++;
+            if (_counter > _end)
+            {
+                _lock.set(false);
+                synchronized (_lock)
+                {
+                    _lock.notifyAll();
+                }
+            }
+        }
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/util/ConversationFactory.java b/java/systests/src/main/java/org/apache/qpid/test/utils/ConversationFactory.java
index 00cb458c86..bc68320224 100644
--- a/java/systests/src/main/java/org/apache/qpid/util/ConversationFactory.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/utils/ConversationFactory.java
@@ -18,9 +18,10 @@
  * under the License.
  *
  */
-package org.apache.qpid.util;
+package org.apache.qpid.test.utils;
 
 import org.apache.log4j.Logger;
+import org.apache.qpid.test.utils.ReflectionUtils;
 
 import javax.jms.*;
 
diff --git a/java/systests/src/main/java/org/apache/qpid/test/FailoverBaseCase.java b/java/systests/src/main/java/org/apache/qpid/test/utils/FailoverBaseCase.java
index e939a06719..2fa6f4f417 100644
--- a/java/systests/src/main/java/org/apache/qpid/test/FailoverBaseCase.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/utils/FailoverBaseCase.java
@@ -18,25 +18,31 @@
  * under the License.
  *
  */
-package org.apache.qpid.test;
+package org.apache.qpid.test.utils;
 
 import org.apache.qpid.client.transport.TransportConnection;
 import org.apache.qpid.server.registry.ApplicationRegistry;
-import org.apache.qpid.testutil.QpidTestCase;
 
 import javax.jms.Connection;
 
 public class FailoverBaseCase extends QpidTestCase
 {
-    protected long RECEIVE_TIMEOUT = 1000l;
+    private boolean failedOver = true;
+    
 
     protected void setUp() throws java.lang.Exception
     {
         super.setUp();
-        if( _broker.equals(VM) )
+
+        try
+        {
+            TransportConnection.createVMBroker(2);
+        }
+        catch (Exception e)
         {
-            System.getProperties().setProperty("amqj.AutoCreateVMBroker", "true");
+            fail("Unable to create broker: " + e);
         }
+
     }
 
     /**
@@ -60,13 +66,24 @@ public class FailoverBaseCase extends QpidTestCase
         return conn;
     }
 
+    public void tearDown() throws Exception
+    {
+        if (!failedOver)
+        {
+            TransportConnection.killVMBroker(2);
+            ApplicationRegistry.remove(2);
+        }
+        super.tearDown();
+    }
+
+
     /**
      * Only used of VM borker.
-     * // TODO: update the failover mechanism once 0.10 provides support for failover. 
      */
     public void failBroker()
     {
-        TransportConnection.killVMBroker(1);
-        ApplicationRegistry.remove(1);
+        failedOver = true;
+        TransportConnection.killVMBroker(2);
+        ApplicationRegistry.remove(2);
     }
 }
diff --git a/java/systests/src/main/java/org/apache/qpid/test/utils/QpidClientConnection.java b/java/systests/src/main/java/org/apache/qpid/test/utils/QpidClientConnection.java
new file mode 100644
index 0000000000..35cab0fd33
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/utils/QpidClientConnection.java
@@ -0,0 +1,289 @@
+/*
+ *
+ * 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.utils;
+
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.JMSAMQException;
+import org.apache.qpid.test.utils.QpidTestCase;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.jms.Connection;
+import javax.jms.ExceptionListener;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageProducer;
+import javax.jms.Queue;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+
+public class QpidClientConnection extends QpidTestCase implements ExceptionListener
+{
+    private static final Logger _logger = LoggerFactory.getLogger(QpidClientConnection.class);
+
+    private boolean transacted = true;
+    private int ackMode = Session.CLIENT_ACKNOWLEDGE;
+    private Connection connection;
+
+    private String virtualHost;
+    private String brokerlist;
+    private int prefetch;
+    protected Session session;
+    protected boolean connected;
+
+    public QpidClientConnection(String broker)
+    {
+        super();
+        setVirtualHost("/test");
+        setBrokerList(broker);
+        setPrefetch(5000);
+    }
+
+
+    public Connection getConnection()
+    {
+        return connection;
+    }
+
+    public void connect() throws JMSException
+    {
+        if (!connected)
+        {
+            /*
+             * amqp://[user:pass@][clientid]/virtualhost?
+             * brokerlist='[transport://]host[:port][?option='value'[&option='value']];'
+             * [&failover='method[?option='value'[&option='value']]']
+             * [&option='value']"
+             */
+            String brokerUrl = "amqp://guest:guest@" + virtualHost + "?brokerlist='" + brokerlist + "'";
+            try
+            {
+                _logger.info("connecting to Qpid :" + brokerUrl);
+                connection = getConnection("guest", "guest") ;
+                // register exception listener
+                connection.setExceptionListener(this);
+
+                session = ((AMQConnection) connection).createSession(transacted, ackMode, prefetch);
+
+                _logger.info("starting connection");
+                connection.start();
+
+                connected = true;
+            }
+            catch (Exception e)
+            {
+                throw new JMSAMQException("URL syntax error in [" + brokerUrl + "]: " + e.getMessage(), e);
+            }
+        }
+    }
+
+    public void disconnect() throws Exception
+    {
+        if (connected)
+        {
+            session.commit();
+            session.close();
+            connection.close();
+            connected = false;
+            _logger.info("disconnected");
+        }
+    }
+
+    public void disconnectWithoutCommit() throws JMSException
+    {
+        if (connected)
+        {
+            session.close();
+            connection.close();
+            connected = false;
+            _logger.info("disconnected without commit");
+        }
+    }
+
+    public String getBrokerList()
+    {
+        return brokerlist;
+    }
+
+    public void setBrokerList(String brokerlist)
+    {
+        this.brokerlist = brokerlist;
+    }
+
+    public String getVirtualHost()
+    {
+        return virtualHost;
+    }
+
+    public void setVirtualHost(String virtualHost)
+    {
+        this.virtualHost = virtualHost;
+    }
+
+    public void setPrefetch(int prefetch)
+    {
+        this.prefetch = prefetch;
+    }
+
+    /** override as necessary */
+    public void onException(JMSException exception)
+    {
+        _logger.info("ExceptionListener event: error " + exception.getErrorCode() + ", message: " + exception.getMessage());
+    }
+
+    public boolean isConnected()
+    {
+        return connected;
+    }
+
+    public Session getSession()
+    {
+        return session;
+    }
+
+    /**
+     * Put a String as a text messages, repeat n times. A null payload will result in a null message.
+     *
+     * @param queueName The queue name to put to
+     * @param payload   the content of the payload
+     * @param copies    the number of messages to put
+     *
+     * @throws javax.jms.JMSException any exception that occurs
+     */
+    public void put(String queueName, String payload, int copies) throws JMSException
+    {
+        if (!connected)
+        {
+            connect();
+        }
+
+        _logger.info("putting to queue " + queueName);
+        Queue queue = session.createQueue(queueName);
+
+        final MessageProducer sender = session.createProducer(queue);
+
+        for (int i = 0; i < copies; i++)
+        {
+            Message m = session.createTextMessage(payload + i);
+            m.setIntProperty("index", i + 1);
+            sender.send(m);
+        }
+
+        session.commit();
+        sender.close();
+        _logger.info("put " + copies + " copies");
+    }
+
+    /**
+     * GET the top message on a queue. Consumes the message. Accepts timeout value.
+     *
+     * @param queueName   The quename to get from
+     * @param readTimeout The timeout to use
+     *
+     * @return the content of the text message if any
+     *
+     * @throws javax.jms.JMSException any exception that occured
+     */
+    public Message getNextMessage(String queueName, long readTimeout) throws JMSException
+    {
+        if (!connected)
+        {
+            connect();
+        }
+
+        Queue queue = session.createQueue(queueName);
+
+        final MessageConsumer consumer = session.createConsumer(queue);
+
+        Message message = consumer.receive(readTimeout);
+        session.commit();
+        consumer.close();
+
+        Message result;
+
+        // all messages we consume should be TextMessages
+        if (message instanceof TextMessage)
+        {
+            result = ((TextMessage) message);
+        }
+        else if (null == message)
+        {
+            result = null;
+        }
+        else
+        {
+            _logger.info("warning: received non-text message");
+            result = message;
+        }
+
+        return result;
+    }
+
+    /**
+     * GET the top message on a queue. Consumes the message.
+     *
+     * @param queueName The Queuename to get from
+     *
+     * @return The string content of the text message, if any received
+     *
+     * @throws javax.jms.JMSException any exception that occurs
+     */
+    public Message getNextMessage(String queueName) throws JMSException
+    {
+        return getNextMessage(queueName, 0);
+    }
+
+    /**
+     * Completely clears a queue. For readTimeout behaviour see Javadocs for javax.jms.MessageConsumer.
+     *
+     * @param queueName   The Queue name to consume from
+     * @param readTimeout The timeout for each consume
+     *
+     * @throws javax.jms.JMSException Any exception that occurs during the consume
+     * @throws InterruptedException   If the consume thread was interrupted during a consume.
+     */
+    public void consume(String queueName, int readTimeout) throws JMSException, InterruptedException
+    {
+        if (!connected)
+        {
+            connect();
+        }
+
+        _logger.info("consuming queue " + queueName);
+        Queue queue = session.createQueue(queueName);
+
+        final MessageConsumer consumer = session.createConsumer(queue);
+        int messagesReceived = 0;
+
+        _logger.info("consuming...");
+        while ((consumer.receive(readTimeout)) != null)
+        {
+            messagesReceived++;
+        }
+
+        session.commit();
+        consumer.close();
+        _logger.info("consumed: " + messagesReceived);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/testutil/QpidClientConnectionHelper.java b/java/systests/src/main/java/org/apache/qpid/test/utils/QpidClientConnectionHelper.java
index c43b65a805..72003ed7d7 100644
--- a/java/systests/src/main/java/org/apache/qpid/testutil/QpidClientConnectionHelper.java
+++ b/java/systests/src/main/java/org/apache/qpid/test/utils/QpidClientConnectionHelper.java
@@ -19,7 +19,7 @@
  *
  */
 
-package org.apache.qpid.testutil;
+package org.apache.qpid.test.utils;
 
 import org.apache.log4j.Logger;
 
@@ -30,7 +30,6 @@ import org.apache.qpid.client.JMSAMQException;
 import org.apache.qpid.url.URLSyntaxException;
 
 import javax.jms.Connection;
-import javax.jms.DeliveryMode;
 import javax.jms.ExceptionListener;
 import javax.jms.JMSException;
 import javax.jms.Message;
diff --git a/java/systests/src/main/java/org/apache/qpid/test/utils/QpidTestCase.java b/java/systests/src/main/java/org/apache/qpid/test/utils/QpidTestCase.java
new file mode 100644
index 0000000000..65939e1fb7
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/utils/QpidTestCase.java
@@ -0,0 +1,513 @@
+/* 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.utils;
+
+import junit.framework.TestCase;
+import junit.framework.TestResult;
+
+import javax.jms.Connection;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.qpid.client.transport.TransportConnection;
+import org.apache.qpid.client.AMQConnection;
+import org.apache.qpid.client.AMQConnectionFactory;
+import org.apache.qpid.server.registry.ApplicationRegistry;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ *
+ *
+ */
+public class QpidTestCase extends TestCase
+{
+
+    private static final Logger _logger = LoggerFactory.getLogger(QpidTestCase.class);
+
+    protected long RECEIVE_TIMEOUT = 1000l;
+
+    /**
+     * Some tests are excluded when the property test.excludes is set to true.
+     * An exclusion list is either a file (prop test.excludesfile) which contains one test name
+     * to be excluded per line or a String (prop test.excludeslist) where tests to be excluded are
+     * separated by " ". Excluded tests are specified following the format:
+     * className#testName where className is the class of the test to be
+     * excluded and testName is the name of the test to be excluded.
+     * className#* excludes all the tests of the specified class.
+     */
+    private static final String DEFAULT_INITIAL_CONTEXT = "org.apache.qpid.jndi.PropertiesFileInitialContextFactory";
+
+    static
+    {
+        if (Boolean.getBoolean("test.excludes"))
+        {
+            _logger.info("Some tests should be excluded, building the exclude list");
+            String exclusionListURI = System.getProperties().getProperty("test.excludesfile", "");
+            String exclusionListString = System.getProperties().getProperty("test.excludeslist", "");
+            File file = new File(exclusionListURI);
+            List<String> exclusionList = new ArrayList<String>();
+            if (file.exists())
+            {
+                _logger.info("Using exclude file: " + exclusionListURI);
+                try
+                {
+                    BufferedReader in = new BufferedReader(new FileReader(file));
+                    String excludedTest = in.readLine();
+                    do
+                    {
+                        exclusionList.add(excludedTest);
+                        excludedTest = in.readLine();
+                    }
+                    while (excludedTest != null);
+                }
+                catch (IOException e)
+                {
+                    _logger.warn("Exception when reading exclusion list", e);
+                }
+            }
+            else if (!exclusionListString.equals(""))
+            {
+                _logger.info("Using excludeslist: " + exclusionListString);
+                // the exclusion list may be specified as a string
+                StringTokenizer t = new StringTokenizer(exclusionListString, " ");
+                while (t.hasMoreTokens())
+                {
+                    exclusionList.add(t.nextToken());
+                }
+            }
+            else
+            {
+                throw new RuntimeException("Aborting test: Cannot find excludes file nor excludes list");
+            }
+            _exclusionList = exclusionList;
+        }
+
+        String initialContext = System.getProperty(InitialContext.INITIAL_CONTEXT_FACTORY);
+
+        if (initialContext == null || initialContext.length() == 0)
+        {
+            System.setProperty(InitialContext.INITIAL_CONTEXT_FACTORY, DEFAULT_INITIAL_CONTEXT);
+        }
+    }
+
+    private static List<String> _exclusionList;
+
+    // system properties
+    private static final String BROKER = "broker";
+    private static final String BROKER_CLEAN = "broker.clean";
+    private static final String BROKER_VERSION = "broker.version";
+    private static final String BROKER_READY = "broker.ready";
+    private static final String TEST_OUTPUT = "test.output";
+
+    // values
+    protected static final String VM = "vm";
+    private static final String EXTERNAL = "external";
+    private static final String VERSION_08 = "0-8";
+    private static final String VERSION_010 = "0-10";
+
+    private static final String QPID_HOME = "QPID_HOME";
+
+    protected String _broker = System.getProperty(BROKER, VM);
+    private String _brokerClean = System.getProperty(BROKER_CLEAN, null);
+    private String _brokerVersion = System.getProperty(BROKER_VERSION, VERSION_08);
+    private String _output = System.getProperty(TEST_OUTPUT);
+
+    private Process _brokerProcess;
+
+    private InitialContext _initialContext;
+    private AMQConnectionFactory _connectionFactory;
+    private boolean _brokerStarted;
+
+    // the connections created for a given test
+    protected List<Connection> _connections = new ArrayList<Connection>();
+
+    public QpidTestCase(String name)
+    {
+        super(name);
+    }
+
+    public QpidTestCase()
+    {
+        super("QpidTestCase");
+    }
+
+    public void runBare() throws Throwable
+    {
+        String name = getClass().getSimpleName() + "." + getName();
+        String qname = getClass().getName() + "." + getName();
+
+        PrintStream oldOut = System.out;
+        PrintStream oldErr = System.err;
+        PrintStream out = null;
+        PrintStream err = null;
+        boolean redirected = _output != null && _output.length() > 0;
+        if (redirected)
+        {
+            out = new PrintStream(String.format("%s/TEST-%s.out", _output, qname));
+            err = new PrintStream(String.format("%s/TEST-%s.err", _output, qname));
+            System.setOut(out);
+            System.setErr(err);
+        }
+
+        _logger.info("========== start " + name + " ==========");
+        startBroker();
+        try
+        {
+            super.runBare();
+        }
+        finally
+        {
+            try
+            {
+                stopBroker();
+            }
+            catch (Exception e)
+            {
+                _logger.error("exception stopping broker", e);
+            }
+            _logger.info("==========  stop " + name + " ==========");
+
+            if (redirected)
+            {
+                System.setErr(oldErr);
+                System.setOut(oldOut);
+                err.close();
+                out.close();
+            }
+        }
+    }
+
+    public void run(TestResult testResult)
+    {
+        if (_exclusionList != null && (_exclusionList.contains(getClass().getName() + "#*") ||
+                                       _exclusionList.contains(getClass().getName() + "#" + getName())))
+        {
+            _logger.info("Test: " + getName() + " is excluded");
+            testResult.endTest(this);
+        }
+        else
+        {
+            super.run(testResult);
+        }
+    }
+
+    private static final class Piper extends Thread
+    {
+
+        private LineNumberReader in;
+        private String ready;
+        private CountDownLatch latch;
+
+        public Piper(InputStream in, String ready)
+        {
+            this.in = new LineNumberReader(new InputStreamReader(in));
+            this.ready = ready;
+            if (this.ready != null && !this.ready.equals(""))
+            {
+                this.latch = new CountDownLatch(1);
+            }
+            else
+            {
+                this.latch = null;
+            }
+        }
+
+        public Piper(InputStream in)
+        {
+            this(in, null);
+        }
+
+        public boolean await(long timeout, TimeUnit unit) throws InterruptedException
+        {
+            if (latch == null)
+            {
+                return true;
+            }
+            else
+            {
+                return latch.await(timeout, unit);
+            }
+        }
+
+        public void run()
+        {
+            try
+            {
+                String line;
+                while ((line = in.readLine()) != null)
+                {
+                    System.out.println(line);
+                    if (latch != null && line.contains(ready))
+                    {
+                        latch.countDown();
+                    }
+                }
+            }
+            catch (IOException e)
+            {
+                // this seems to happen regularly even when
+                // exits are normal
+            }
+            finally
+            {
+                if (latch != null)
+                {
+                    latch.countDown();
+                }
+            }
+        }
+    }
+
+    public void startBroker() throws Exception
+    {
+        if (_broker.equals(VM))
+        {
+            // create an in_VM broker
+            TransportConnection.createVMBroker(1);
+        }
+        else if (!_broker.equals(EXTERNAL))
+        {
+            _logger.info("starting broker: " + _broker);
+            ProcessBuilder pb = new ProcessBuilder(_broker.split("\\s+"));
+            pb.redirectErrorStream(true);
+
+            Map<String, String> env = pb.environment();
+
+            String qpidHome = System.getProperty(QPID_HOME);
+            env.put(QPID_HOME, qpidHome);
+
+            //Augment Path with bin directory in QPID_HOME.
+            env.put("PATH", env.get("PATH").concat(File.pathSeparator + qpidHome + "/bin"));
+
+            _brokerProcess = pb.start();
+
+            Piper p = new Piper(_brokerProcess.getInputStream(),
+                                System.getProperty(BROKER_READY));
+
+            p.start();
+
+            if (!p.await(30, TimeUnit.SECONDS))
+            {
+                _logger.info("broker failed to become ready");
+                cleanBroker();
+                throw new RuntimeException("broker failed to become ready");
+            }
+
+            try
+            {
+                int exit = _brokerProcess.exitValue();
+                _logger.info("broker aborted: " + exit);
+                cleanBroker();
+                throw new RuntimeException("broker aborted: " + exit);
+            }
+            catch (IllegalThreadStateException e)
+            {
+                // this is expect if the broker started succesfully
+            }
+        }
+        _brokerStarted = true;
+    }
+
+    public void cleanBroker()
+    {
+        if (_brokerClean != null)
+        {
+            _logger.info("clean: " + _brokerClean);
+
+            try
+            {
+                ProcessBuilder pb = new ProcessBuilder(_brokerClean.split("\\s+"));
+                pb.redirectErrorStream(true);
+                Process clean = pb.start();
+                new Piper(clean.getInputStream()).start();
+
+                clean.waitFor();
+
+                _logger.info("clean exited: " + clean.exitValue());
+            }
+            catch (IOException e)
+            {
+                throw new RuntimeException(e);
+            }
+            catch (InterruptedException e)
+            {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    public void stopBroker() throws Exception
+    {
+        _logger.info("stopping broker: " + _broker);
+        if (_brokerProcess != null)
+        {
+            _brokerProcess.destroy();
+            _brokerProcess.waitFor();
+            _logger.info("broker exited: " + _brokerProcess.exitValue());
+            _brokerProcess = null;
+        }
+        else if (_broker.equals(VM))
+        {
+            TransportConnection.killAllVMBrokers();
+            ApplicationRegistry.removeAll();
+        }
+        _brokerStarted = false;
+    }
+
+    /**
+     * Check whether the broker is an 0.8
+     *
+     * @return true if the broker is an 0_8 version, false otherwise.
+     */
+    public boolean isBroker08()
+    {
+        return _brokerVersion.equals(VERSION_08);
+    }
+
+    public boolean isBroker010()
+    {
+        return _brokerVersion.equals(VERSION_010);
+    }
+
+    public void restartBroker() throws Exception
+    {
+        stopBroker();
+        startBroker();
+    }
+
+    /**
+     * we assume that the environment is correctly set
+     * i.e. -Djava.naming.provider.url="..//example010.properties"
+     * TODO should be a way of setting that through maven
+     *
+     * @return an initial context
+     *
+     * @throws NamingException if there is an error getting the context
+     */
+    public InitialContext getInitialContext() throws NamingException
+    {
+        _logger.info("get InitialContext");
+        if (_initialContext == null)
+        {
+            _initialContext = new InitialContext();
+        }
+        return _initialContext;
+    }
+
+    /**
+     * Get the default connection factory for the currently used broker
+     * Default factory is "local"
+     *
+     * @return A conection factory
+     *
+     * @throws Exception if there is an error getting the tactory
+     */
+    public AMQConnectionFactory getConnectionFactory() throws NamingException
+    {
+        _logger.info("get ConnectionFactory");
+        if (_connectionFactory == null)
+        {
+            if (_broker.equals(VM))
+            {
+                _connectionFactory = getConnectionFactory("vm");
+            }
+            else
+            {
+                _connectionFactory = getConnectionFactory("local");
+            }
+        }
+        return _connectionFactory;
+    }
+
+    /**
+     * Get a connection factory for the currently used broker
+     *
+     * @param factoryName The factory name
+     *
+     * @return A conection factory
+     *
+     * @throws Exception if there is an error getting the tactory
+     */
+    public AMQConnectionFactory getConnectionFactory(String factoryName) throws NamingException
+    {
+        return (AMQConnectionFactory) getInitialContext().lookup(factoryName);
+    }
+
+    public Connection getConnection() throws Exception
+    {
+        return getConnection("guest", "guest");
+    }
+
+    /**
+     * Get a connection (remote or in-VM)
+     *
+     * @param username The user name
+     * @param password The user password
+     *
+     * @return a newly created connection
+     *
+     * @throws Exception if there is an error getting the connection
+     */
+    public Connection getConnection(String username, String password) throws Exception
+    {
+        _logger.info("get Connection");
+        Connection con = getConnectionFactory().createConnection(username, password);
+        //add the connection in the lis of connections
+        _connections.add(con);
+        return con;
+    }
+
+    public Connection getConnection(String username, String password, String id) throws Exception
+    {
+        _logger.info("get Connection");
+        Connection con;
+        if (_broker.equals(VM))
+        {
+            con = new AMQConnection("vm://:1", username, password, id, "test");
+        }
+        else
+        {
+            con = getConnectionFactory().createConnection(username, password, id);
+        }
+        //add the connection in the lis of connections
+        _connections.add(con);
+        return con;
+    }
+
+    protected void tearDown() throws java.lang.Exception
+    {
+        // close all the connections used by this test.
+        if (_brokerStarted)
+        {
+            for (Connection c : _connections)
+            {
+                c.close();
+            }
+        }
+    }
+
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/utils/ReflectionUtils.java b/java/systests/src/main/java/org/apache/qpid/test/utils/ReflectionUtils.java
new file mode 100644
index 0000000000..7946c6a6d1
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/utils/ReflectionUtils.java
@@ -0,0 +1,228 @@
+/*
+ *
+ * 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.utils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * Provides helper methods for operating on classes and methods using reflection. Reflection methods tend to return
+ * a lot of checked exception so writing code to use them can be tedious and harder to read, especially when such errors
+ * are not expected to occur. This class always works with {@link ReflectionUtilsException}, which is a runtime exception,
+ * to wrap the checked exceptions raised by the standard Java reflection methods. Code using it does not normally
+ * expect these errors to occur, usually does not have a recovery mechanism for them when they do, but is cleaner,
+ * quicker to write and easier to read in the majority of cases.
+ *
+ * <p/><table id="crc"><caption>CRC Card</caption>
+ * <tr><th> Responsibilities <th> Collaborations
+ * <tr><td> Look up Classes by name.
+ * <tr><td> Instantiate Classes by no-arg constructor.
+ * </table>
+ */
+public class ReflectionUtils
+{
+    /**
+    * Gets the Class object for a named class.
+    *
+    * @param className The class to get the Class object for.
+    *
+    * @return The Class object for the named class.
+    */
+    public static Class<?> forName(String className)
+    {
+        try
+        {
+            return Class.forName(className);
+        }
+        catch (ClassNotFoundException e)
+        {
+            throw new ReflectionUtilsException("ClassNotFoundException whilst finding class.", e);
+        }
+    }
+
+    /**
+     * Creates an instance of a Class, instantiated through its no-args constructor.
+     *
+     * @param cls The Class to instantiate.
+     * @param <T> The Class type.
+     *
+     * @return An instance of the class.
+     */
+    public static <T> T newInstance(Class<? extends T> cls)
+    {
+        try
+        {
+            return cls.newInstance();
+        }
+        catch (InstantiationException e)
+        {
+            throw new ReflectionUtilsException("InstantiationException whilst instantiating class.", e);
+        }
+        catch (IllegalAccessException e)
+        {
+            throw new ReflectionUtilsException("IllegalAccessException whilst instantiating class.", e);
+        }
+    }
+
+    /**
+     * Calls a named method on an object with a specified set of parameters, any Java access modifier are overridden.
+     *
+     * @param o            The object to call.
+     * @param method       The method name to call.
+     * @param params       The parameters to pass.
+     * @param paramClasses The argument types.
+     *
+     * @return The return value from the method call.
+     */
+    public static Object callMethodOverridingIllegalAccess(Object o, String method, Object[] params, Class[] paramClasses)
+    {
+        // Get the objects class.
+        Class cls = o.getClass();
+
+        // Get the classes of the parameters.
+        /*Class[] paramClasses = new Class[params.length];
+
+        for (int i = 0; i < params.length; i++)
+        {
+            paramClasses[i] = params[i].getClass();
+        }*/
+
+        try
+        {
+            // Try to find the matching method on the class.
+            Method m = cls.getDeclaredMethod(method, paramClasses);
+
+            // Make it accessible.
+            m.setAccessible(true);
+
+            // Invoke it with the parameters.
+            return m.invoke(o, params);
+        }
+        catch (NoSuchMethodException e)
+        {
+            throw new ReflectionUtilsException("NoSuchMethodException.", e);
+        }
+        catch (IllegalAccessException e)
+        {
+            throw new ReflectionUtilsException("IllegalAccessException.", e);
+        }
+        catch (InvocationTargetException e)
+        {
+            throw new ReflectionUtilsException("InvocationTargetException", e);
+        }
+    }
+
+    /**
+     * Calls a named method on an object with a specified set of parameters.
+     *
+     * @param o      The object to call.
+     * @param method The method name to call.
+     * @param params The parameters to pass.
+     *
+     * @return The return value from the method call.
+     */
+    public static Object callMethod(Object o, String method, Object[] params)
+    {
+        // Get the objects class.
+        Class cls = o.getClass();
+
+        // Get the classes of the parameters.
+        Class[] paramClasses = new Class[params.length];
+
+        for (int i = 0; i < params.length; i++)
+        {
+            paramClasses[i] = params[i].getClass();
+        }
+
+        try
+        {
+            // Try to find the matching method on the class.
+            Method m = cls.getMethod(method, paramClasses);
+
+            // Invoke it with the parameters.
+            return m.invoke(o, params);
+        }
+        catch (NoSuchMethodException e)
+        {
+            throw new ReflectionUtilsException("NoSuchMethodException.", e);
+        }
+        catch (IllegalAccessException e)
+        {
+            throw new ReflectionUtilsException("IllegalAccessException", e);
+        }
+        catch (InvocationTargetException e)
+        {
+            throw new ReflectionUtilsException("InvocationTargetException", e);
+        }
+    }
+
+    /**
+     * Calls a constuctor witht the specified arguments.
+     *
+     * @param constructor The constructor.
+     * @param args        The arguments.
+     * @param <T>         The Class type.
+     *
+     * @return An instance of the class that the constructor is for.
+     */
+    public static <T> T newInstance(Constructor<T> constructor, Object[] args)
+    {
+        try
+        {
+            return constructor.newInstance(args);
+        }
+        catch (InstantiationException e)
+        {
+            throw new ReflectionUtilsException("InstantiationException", e);
+        }
+        catch (IllegalAccessException e)
+        {
+            throw new ReflectionUtilsException("IllegalAccessException", e);
+        }
+        catch (InvocationTargetException e)
+        {
+            throw new ReflectionUtilsException("InvocationTargetException", e);
+        }
+    }
+
+    /**
+     * Gets the constructor of a class that takes the specified set of arguments if any matches. If no matching
+     * constructor is found then a runtime exception is raised.
+     *
+     * @param cls  The class to get a constructor from.
+     * @param args The arguments to match.
+     * @param <T>  The class type.
+     *
+     * @return The constructor.
+     */
+    public static <T> Constructor<T> getConstructor(Class<T> cls, Class[] args)
+    {
+        try
+        {
+            return cls.getConstructor(args);
+        }
+        catch (NoSuchMethodException e)
+        {
+            throw new ReflectionUtilsException("NoSuchMethodException", e);
+        }
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/utils/ReflectionUtilsException.java b/java/systests/src/main/java/org/apache/qpid/test/utils/ReflectionUtilsException.java
new file mode 100644
index 0000000000..838828598b
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/utils/ReflectionUtilsException.java
@@ -0,0 +1,44 @@
+/*
+ *
+ * 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.utils;
+
+/**
+ * Wraps a checked exception that occurs when {@link ReflectionUtils} encounters checked exceptions using standard
+ * Java reflection methods.
+ *
+ * <p/><table id="crc"><caption>CRC Card</caption>
+ * <tr><th> Responsibilities <th> Collaborations
+ * <tr><td> Wrap a checked reflection exception.
+ * </table>
+ */
+public class ReflectionUtilsException extends RuntimeException
+{
+    /**
+     * Creates a runtime reflection exception, from a checked one.
+     *
+     * @param message The message.
+     * @param cause   The causing exception.
+     */
+    public ReflectionUtilsException(String message, Throwable cause)
+    {
+        super(message, cause);
+    }
+}
diff --git a/java/systests/src/main/java/org/apache/qpid/test/utils/protocol/TestIoSession.java b/java/systests/src/main/java/org/apache/qpid/test/utils/protocol/TestIoSession.java
new file mode 100644
index 0000000000..f1eb8159b6
--- /dev/null
+++ b/java/systests/src/main/java/org/apache/qpid/test/utils/protocol/TestIoSession.java
@@ -0,0 +1,104 @@
+/*
+ *
+ * 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.utils.protocol;
+
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+
+import org.apache.mina.common.IoFilterChain;
+import org.apache.mina.common.IoHandler;
+import org.apache.mina.common.IoService;
+import org.apache.mina.common.IoServiceConfig;
+import org.apache.mina.common.IoSessionConfig;
+import org.apache.mina.common.TransportType;
+import org.apache.mina.common.support.BaseIoSession;
+
+public class TestIoSession extends BaseIoSession {
+
+    private String _stringLocalAddress;
+    private int _localPort;
+
+    public SocketAddress getLocalAddress()
+    {
+        //create a new address for testing purposes using member variables
+        return new InetSocketAddress(_stringLocalAddress,_localPort);
+    }
+
+    protected void updateTrafficMask() {
+       //dummy
+    }
+
+    public IoService getService() {
+        return null;
+    }
+
+    public IoServiceConfig getServiceConfig() {
+        return null;
+    }
+
+    public IoHandler getHandler() {
+        return null;
+    }
+
+    public IoSessionConfig getConfig() {
+        return null;
+    }
+
+    public IoFilterChain getFilterChain() {
+        return null;
+    }
+
+    public TransportType getTransportType() {
+        return null;
+    }
+
+    public SocketAddress getRemoteAddress() {
+        return null;
+    }
+
+    public SocketAddress getServiceAddress() {
+        return null;
+    }
+
+    public int getScheduledWriteRequests() {
+        return 0;
+    }
+
+    public int getScheduledWriteBytes() {
+        return 0;
+    }
+
+    public String getStringLocalAddress() {
+        return _stringLocalAddress;
+    }
+
+    public void setStringLocalAddress(String _stringLocalAddress) {
+        this._stringLocalAddress = _stringLocalAddress;
+    }
+
+    public int getLocalPort() {
+        return _localPort;
+    }
+
+    public void setLocalPort(int _localPort) {
+        this._localPort = _localPort;
+    }
+}