Merged revisions 662818 via svnmerge from

https://svn.apache.org/repos/asf/incubator/qpid/branches/M2.x

........
  r662818 | ritchiem | 2008-06-03 16:07:07 +0100 (Tue, 03 Jun 2008) | 1 line
  
  QPID-1117 : Added tests for all other message types. Refactored the common parts out of the objectTest.
........


git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/branches/M2.1.x@662820 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 153 insertions, 4 deletions

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
index b3a9ee69b8..06c3f8829f 100644
--- 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
@@ -26,12 +26,19 @@ 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 VMTestCase
@@ -40,6 +47,7 @@ public class MessageToStringTest extends VMTestCase
     private Session _session;
     private Queue _queue;
     MessageConsumer _consumer;
+    private static final String BYTE_TEST = "MapByteTest";
 
     public void setUp() throws Exception
     {
@@ -67,6 +75,35 @@ public class MessageToStringTest extends VMTestCase
         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);
@@ -76,26 +113,138 @@ public class MessageToStringTest extends VMTestCase
 
         Message testMessage = _session.createObjectMessage(test);
 
-        producer.send(testMessage);
+        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());
 
-        UUID result = null;
+        byte[] byteResults;
+        UUID result;
 
         try
         {
-            result = (UUID) ((ObjectMessage) receivedMessage).getObject();
+            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());
         }
 
-        assertEquals("UUIDs were not equal", test, result);
+    }
+
+    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();
     }
 
 }