Work in progress of BytesMessage and StreamMessage work

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

5 files changed, 910 insertions, 57 deletions

diff --git a/java/client/src/main/java/org/apache/qpid/client/message/JMSBytesMessage.java b/java/client/src/main/java/org/apache/qpid/client/message/JMSBytesMessage.java
index 7da5b3eed9..6745052a5d 100644
--- a/java/client/src/main/java/org/apache/qpid/client/message/JMSBytesMessage.java
+++ b/java/client/src/main/java/org/apache/qpid/client/message/JMSBytesMessage.java
@@ -7,9 +7,9 @@
  * 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
@@ -20,19 +20,19 @@
  */
 package org.apache.qpid.client.message;
 
-import org.apache.qpid.framing.BasicContentHeaderProperties;
-import org.apache.qpid.framing.ContentHeaderBody;
-import org.apache.qpid.AMQException;
 import org.apache.mina.common.ByteBuffer;
+import org.apache.qpid.AMQException;
+import org.apache.qpid.framing.ContentHeaderBody;
 
-import javax.jms.*;
-import java.io.*;
-import java.nio.charset.Charset;
+import javax.jms.BytesMessage;
+import javax.jms.JMSException;
+import javax.jms.MessageFormatException;
 import java.nio.charset.CharacterCodingException;
+import java.nio.charset.Charset;
 
 public class JMSBytesMessage extends AbstractBytesMessage implements BytesMessage
 {
-    private static final String MIME_TYPE = "application/octet-stream";       
+    private static final String MIME_TYPE = "application/octet-stream";
 
     JMSBytesMessage()
     {
@@ -52,21 +52,21 @@ public class JMSBytesMessage extends AbstractBytesMessage implements BytesMessag
 
     JMSBytesMessage(long messageNbr, ContentHeaderBody contentHeader, ByteBuffer data)
             throws AMQException
-    {       
+    {
         super(messageNbr, contentHeader, data);
     }
 
     public String getMimeType()
     {
         return MIME_TYPE;
-    }                
+    }
 
     public long getBodyLength() throws JMSException
     {
         checkReadable();
         return _data.limit();
     }
-    
+
     public boolean readBoolean() throws JMSException
     {
         checkReadable();
@@ -257,6 +257,8 @@ public class JMSBytesMessage extends AbstractBytesMessage implements BytesMessag
         try
         {
             _data.putString(string, Charset.forName("UTF-8").newEncoder());
+            // we must add the null terminator manually
+            _data.put((byte)0);
         }
         catch (CharacterCodingException e)
         {
@@ -285,6 +287,51 @@ public class JMSBytesMessage extends AbstractBytesMessage implements BytesMessag
         {
             throw new NullPointerException("Argument must not be null");
         }
-        _data.putObject(object);
-    }    
+        Class clazz = object.getClass();
+        if (clazz == Byte.class)
+        {
+            writeByte((Byte) object);
+        }
+        else if (clazz == Boolean.class)
+        {
+            writeBoolean((Boolean) object);
+        }
+        else if (clazz == byte[].class)
+        {
+            writeBytes((byte[]) object);
+        }
+        else if (clazz == Short.class)
+        {
+            writeShort((Short) object);
+        }
+        else if (clazz == Character.class)
+        {
+            writeChar((Character) object);
+        }
+        else if (clazz == Integer.class)
+        {
+            writeInt((Integer) object);
+        }
+        else if (clazz == Long.class)
+        {
+            writeLong((Long) object);
+        }
+        else if (clazz == Float.class)
+        {
+            writeFloat((Float) object);
+        }
+        else if (clazz == Double.class)
+        {
+            writeDouble((Double) object);
+        }
+        else if (clazz == String.class)
+        {
+            writeUTF((String) object);
+        }
+        else
+        {
+            throw new MessageFormatException("Only primitives plus byte arrays and String are valid types");
+        }
+    }
+
 }
diff --git a/java/client/src/main/java/org/apache/qpid/client/message/JMSStreamMessage.java b/java/client/src/main/java/org/apache/qpid/client/message/JMSStreamMessage.java
index 061b010a03..882d54fd03 100644
--- a/java/client/src/main/java/org/apache/qpid/client/message/JMSStreamMessage.java
+++ b/java/client/src/main/java/org/apache/qpid/client/message/JMSStreamMessage.java
@@ -20,11 +20,12 @@
  */
 package org.apache.qpid.client.message;
 
-import javax.jms.StreamMessage;
 import javax.jms.JMSException;
+import javax.jms.MessageEOFException;
 import javax.jms.MessageFormatException;
-import java.nio.charset.Charset;
+import javax.jms.StreamMessage;
 import java.nio.charset.CharacterCodingException;
+import java.nio.charset.Charset;
 
 /**
  * @author Apache Software Foundation
@@ -33,53 +34,53 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
 {
     private static final String MIME_TYPE="jms/stream-message";
 
-    private static final String[] _typeNames = {
-            "boolean",
-            "byte",
-            "short",
-            "char",
-            "int",
-            "long",
-            "float",
-            "double",
-            "utf string"};
+    private static final String[] _typeNames = { "boolean",
+                                                 "byte",
+                                                 "byte array",
+                                                 "short",
+                                                 "char",
+                                                 "int",
+                                                 "long",
+                                                 "float",
+                                                 "double",
+                                                 "utf string" };
 
     private static final byte BOOLEAN_TYPE = (byte) 1;
 
     private static final byte BYTE_TYPE = (byte) 2;
 
-    private static final byte SHORT_TYPE = (byte) 3;
+    private static final byte BYTEARRAY_TYPE = (byte) 3;
+
+    private static final byte SHORT_TYPE = (byte) 4;
+
+    private static final byte CHAR_TYPE = (byte) 5;
 
-    private static final byte CHAR_TYPE = (byte) 4;
+    private static final byte INT_TYPE = (byte) 6;
 
-    private static final byte INT_TYPE = (byte) 5;
+    private static final byte LONG_TYPE = (byte) 7;
 
-    private static final byte LONG_TYPE = (byte) 6;
+    private static final byte FLOAT_TYPE = (byte) 8;
 
-    private static final byte FLOAT_TYPE = (byte) 7;
+    private static final byte DOUBLE_TYPE = (byte) 9;
 
-    private static final byte DOUBLE_TYPE = (byte) 8;
+    private static final byte STRING_TYPE = (byte) 10;
 
-    private static final byte STRING_TYPE = (byte) 9;
+    /**
+     * This is set when reading a byte array. The readBytes(byte[]) method supports multiple calls to read
+     * a byte array in multiple chunks, hence this is used to track how much is left to be read
+     */
+    private int _byteArrayRemaining = -1;
 
     public String getMimeType()
     {
         return MIME_TYPE;
     }
 
-    public boolean readBoolean() throws JMSException
-    {
-        checkReadable();
-        checkAvailable(2);
-        readAndCheckType(BOOLEAN_TYPE);
-        return _data.get() != 0;
-    }
-
     private void readAndCheckType(byte type) throws MessageFormatException
     {
         if (_data.get() != type)
         {
-            throw new MessageFormatException("Type " + _typeNames[type] + " not found next in stream");
+            throw new MessageFormatException("Type " + _typeNames[type - 1] + " not found next in stream");
         }
     }
 
@@ -88,11 +89,29 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
         _data.put(type);
     }
 
+    public boolean readBoolean() throws JMSException
+    {
+        checkReadable();
+        checkAvailable(2);
+        readAndCheckType(BOOLEAN_TYPE);
+        return readBooleanImpl();
+    }
+
+    private boolean readBooleanImpl()
+    {
+        return _data.get() != 0;
+    }
+
     public byte readByte() throws JMSException
     {
         checkReadable();
         checkAvailable(2);
         readAndCheckType(BYTE_TYPE);
+        return readByteImpl();
+    }
+
+    private byte readByteImpl()
+    {
         return _data.get();
     }
 
@@ -101,6 +120,11 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
         checkReadable();
         checkAvailable(3);
         readAndCheckType(SHORT_TYPE);
+        return readShortImpl();
+    }
+
+    private short readShortImpl()
+    {
         return _data.getShort();
     }
 
@@ -115,6 +139,11 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
         checkReadable();
         checkAvailable(3);
         readAndCheckType(CHAR_TYPE);
+        return readCharImpl();
+    }
+
+    private char readCharImpl()
+    {
         return _data.getChar();
     }
 
@@ -123,6 +152,11 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
         checkReadable();
         checkAvailable(5);
         readAndCheckType(INT_TYPE);
+        return readIntImpl();
+    }
+
+    private int readIntImpl()
+    {
         return _data.getInt();
     }
 
@@ -131,6 +165,11 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
         checkReadable();
         checkAvailable(9);
         readAndCheckType(LONG_TYPE);
+        return readLongImpl();
+    }
+
+    private long readLongImpl()
+    {
         return _data.getLong();
     }
 
@@ -139,6 +178,11 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
         checkReadable();
         checkAvailable(5);
         readAndCheckType(FLOAT_TYPE);
+        return readFloatImpl();
+    }
+
+    private float readFloatImpl()
+    {
         return _data.getFloat();
     }
 
@@ -147,8 +191,13 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
         checkReadable();
         checkAvailable(9);
         readAndCheckType(DOUBLE_TYPE);
+        return readDoubleImpl();
+    }
+
+    private double readDoubleImpl()
+    {
         return _data.getDouble();
-    }    
+    }
 
     public String readString() throws JMSException
     {
@@ -157,6 +206,11 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
         // single byte when using UTF-8 encoding
         checkAvailable(2);
         readAndCheckType(STRING_TYPE);
+        return readStringImpl();
+    }
+
+    private String readStringImpl() throws JMSException
+    {
         try
         {
             return _data.getString(Charset.forName("UTF-8").newDecoder());
@@ -176,10 +230,42 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
             throw new IllegalArgumentException("byte array must not be null");
         }
         checkReadable();
-        int count = (_data.remaining() >= bytes.length ? bytes.length : _data.remaining());
+        // first call
+        if (_byteArrayRemaining == -1)
+        {
+            // type discriminator plus array size
+            checkAvailable(5);
+            readAndCheckType(BYTEARRAY_TYPE);
+            int size = _data.getInt();
+            // size of -1 indicates null
+            if (size == -1)
+            {
+                return -1;
+            }
+            else
+            {
+                if (size > _data.remaining())
+                {
+                    throw new MessageEOFException("Byte array has stated size " + size + " but message only contains " +
+                                                  _data.remaining() + " bytes");
+                }
+                else
+                {
+                    _byteArrayRemaining = size;
+                }
+            }
+        }
+
+        return readBytesImpl(bytes);
+    }
+
+    private int readBytesImpl(byte[] bytes)
+    {
+        int count = (_byteArrayRemaining >= bytes.length ? bytes.length : _byteArrayRemaining);
+        _byteArrayRemaining -= count;
         if (count == 0)
         {
-            return -1;
+            return 0;
         }
         else
         {
@@ -190,7 +276,55 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
 
     public Object readObject() throws JMSException
     {
-        return null;
+        checkReadable();
+        checkAvailable(1);
+        byte type = _data.get();
+        Object result = null;
+        switch (type)
+        {
+            case BOOLEAN_TYPE:
+                result = readBooleanImpl();
+                break;
+            case BYTE_TYPE:
+                result = readByteImpl();
+                break;
+            case BYTEARRAY_TYPE:
+                checkAvailable(4);
+                int size = _data.getInt();
+                if (size == -1)
+                {
+                    result = null;
+                }
+                else
+                {
+                    _byteArrayRemaining = size;
+                    result = new byte[size];
+                    readBytesImpl(new byte[size]);
+                }
+                break;
+            case SHORT_TYPE:
+                result = readShortImpl();
+                break;
+            case CHAR_TYPE:
+                result = readCharImpl();
+                break;
+            case INT_TYPE:
+                result = readIntImpl();
+                break;
+            case LONG_TYPE:
+                result = readLongImpl();
+                break;
+            case FLOAT_TYPE:
+                result = readFloatImpl();
+                break;
+            case DOUBLE_TYPE:
+                result = readDoubleImpl();
+                break;
+            case STRING_TYPE:
+                result = readStringImpl();
+                break;
+        }
+        return result;
     }
 
     public void writeBoolean(boolean b) throws JMSException
@@ -256,6 +390,8 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
         try
         {
             _data.putString(string, Charset.forName("UTF-8").newEncoder());
+            // we must write the null terminator ourselves
+            _data.put((byte)0);
         }
         catch (CharacterCodingException e)
         {
@@ -268,13 +404,22 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
     public void writeBytes(byte[] bytes) throws JMSException
     {
         checkWritable();
-        _data.put(bytes);
+        writeBytes(bytes, 0, bytes == null?0:bytes.length);
     }
 
     public void writeBytes(byte[] bytes, int offset, int length) throws JMSException
     {
         checkWritable();
-        _data.put(bytes, offset, length);
+        writeTypeDiscriminator(BYTEARRAY_TYPE);
+        if (bytes == null)
+        {
+            _data.putInt(-1);
+        }
+        else
+        {
+            _data.putInt(length);
+            _data.put(bytes, offset, length);
+        }
     }
 
     public void writeObject(Object object) throws JMSException
@@ -284,6 +429,50 @@ public class JMSStreamMessage extends AbstractBytesMessage implements StreamMess
         {
             throw new NullPointerException("Argument must not be null");
         }
-        _data.putObject(object);
+        Class clazz = object.getClass();
+        if (clazz == Byte.class)
+        {
+            writeByte((Byte) object);
+        }
+        else if (clazz == Boolean.class)
+        {
+            writeBoolean((Boolean) object);
+        }
+        else if (clazz == byte[].class)
+        {
+            writeBytes((byte[]) object);
+        }
+        else if (clazz == Short.class)
+        {
+            writeShort((Short) object);
+        }
+        else if (clazz == Character.class)
+        {
+            writeChar((Character) object);
+        }
+        else if (clazz == Integer.class)
+        {
+            writeInt((Integer) object);
+        }
+        else if (clazz == Long.class)
+        {
+            writeLong((Long) object);
+        }
+        else if (clazz == Float.class)
+        {
+            writeFloat((Float) object);
+        }
+        else if (clazz == Double.class)
+        {
+            writeDouble((Double) object);
+        }
+        else if (clazz == String.class)
+        {
+            writeString((String) object);
+        }
+        else
+        {
+            throw new MessageFormatException("Only primitives plus byte arrays and String are valid types");
+        }
     }
 }
diff --git a/java/client/src/test/java/org/apache/qpid/client/message/TestMessageHelper.java b/java/client/src/test/java/org/apache/qpid/client/message/TestMessageHelper.java
index c34dbf14f1..02fe103c6a 100644
--- a/java/client/src/test/java/org/apache/qpid/client/message/TestMessageHelper.java
+++ b/java/client/src/test/java/org/apache/qpid/client/message/TestMessageHelper.java
@@ -7,9 +7,9 @@
  * 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
@@ -38,4 +38,9 @@ public class TestMessageHelper
     {
         return new JMSMapMessage();
     }
+
+    public static JMSStreamMessage newJMSStreamMessage() throws JMSException
+    {
+        return new JMSStreamMessage();
+    }
 }
diff --git a/java/client/src/test/java/org/apache/qpid/test/unit/client/message/BytesMessageTest.java b/java/client/src/test/java/org/apache/qpid/test/unit/client/message/BytesMessageTest.java
index 2a76c920b1..7ffb3ca469 100644
--- a/java/client/src/test/java/org/apache/qpid/test/unit/client/message/BytesMessageTest.java
+++ b/java/client/src/test/java/org/apache/qpid/test/unit/client/message/BytesMessageTest.java
@@ -7,9 +7,9 @@
  * 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
@@ -20,14 +20,15 @@
  */
 package org.apache.qpid.test.unit.client.message;
 
+import junit.framework.TestCase;
 import org.apache.qpid.client.message.JMSBytesMessage;
 import org.apache.qpid.client.message.TestMessageHelper;
 
+import javax.jms.MessageEOFException;
 import javax.jms.MessageNotReadableException;
 import javax.jms.MessageNotWriteableException;
-import javax.jms.MessageEOFException;
-
-import junit.framework.TestCase;
+import javax.jms.MessageFormatException;
+import java.util.HashMap;
 
 public class BytesMessageTest extends TestCase
 {
@@ -82,6 +83,18 @@ public class BytesMessageTest extends TestCase
         bm.writeInt(10);
     }
 
+    public void testWriteBoolean() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeBoolean(true);
+        bm.writeBoolean(false);
+        bm.reset();
+        boolean val = bm.readBoolean();
+        assertEquals(true, val);
+        val = bm.readBoolean();
+        assertEquals(false, val);
+    }
+
     public void testWriteInt() throws Exception
     {
         JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
@@ -102,6 +115,61 @@ public class BytesMessageTest extends TestCase
         assertEquals("Bananas", res);
     }
 
+    public void testWriteBytes() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        byte[] bytes = {1,2,3,4};
+        bm.writeBytes(bytes, 1, 2);
+        bm.reset();
+        bytes = new byte[2];
+        bm.readBytes(bytes);
+        assertEquals(2, bytes[0]);
+        assertEquals(3, bytes[1]);
+    }
+
+    public void testWriteObject() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeObject(new Boolean(true));
+        bm.writeObject(new Boolean(false));
+        bm.writeObject(new Byte((byte)2));
+        bm.writeObject(new byte[]{1,2,3,4});
+        bm.writeObject(new Character('g'));
+        bm.writeObject(new Short((short) 29));
+        bm.writeObject(new Integer(101));
+        bm.writeObject(new Long(50003222L));
+        bm.writeObject("Foobar");
+        bm.writeObject(new Float(1.7f));
+        bm.writeObject(new Double(8.7d));
+        bm.reset();
+        assertTrue(bm.readBoolean());
+        assertTrue(!bm.readBoolean());
+        assertEquals((byte)2, bm.readByte());
+        byte[] bytes = new byte[4];
+        bm.readBytes(bytes);
+        assertEquals('g', bm.readChar());
+        assertEquals((short) 29, bm.readShort());
+        assertEquals(101, bm.readInt());
+        assertEquals(50003222L, bm.readLong());
+        assertEquals("Foobar", bm.readUTF());
+        assertEquals(1.7f, bm.readFloat());
+        assertEquals(8.7d, bm.readDouble());
+    }
+
+    public void testWriteObjectRejectsNonPrimitives() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.writeObject(new HashMap());
+            fail("expected MessageFormatException was not thrown");
+        }
+        catch (MessageFormatException e)
+        {
+            // pass
+        }
+    }
+
     public void testWriteObjectThrowsNPE() throws Exception
     {
         try
@@ -126,7 +194,83 @@ public class BytesMessageTest extends TestCase
         bm.writeBoolean(true);
         bm.reset();
         boolean result = bm.readBoolean();
-        assertTrue(result);        
+        assertTrue(result);
+    }
+
+    public void testReadUnsignedByte() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeByte((byte) 9);
+        bm.reset();
+        int result = bm.readUnsignedByte();
+        assertEquals(9, result);
+    }
+
+    public void testReadUnsignedShort() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        bm.writeShort((byte) 9);
+        bm.reset();
+        int result = bm.readUnsignedShort();
+        assertEquals(9, result);
+    }
+
+    public void testReadBytesChecksNull() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.readBytes(null);
+        }
+        catch (IllegalArgumentException e)
+        {
+            // pass
+        }
+
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            bm.readBytes(null, 1);
+        }
+        catch (IllegalArgumentException e)
+        {
+            // pass
+        }
+    }
+
+    public void testReadBytesChecksMaxSize() throws Exception
+    {
+        try
+        {
+            JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+            byte[] bytes = new byte[100];
+            bm.readBytes(bytes, 120);
+        }
+        catch (IllegalArgumentException e)
+        {
+            // pass
+        }
+    }
+
+    public void testReadBytesReturnsCorrectLengths() throws Exception
+    {
+        JMSBytesMessage bm = TestMessageHelper.newJMSBytesMessage();
+        byte[] bytes = {2, 3};
+        bm.writeBytes(bytes);
+        bm.reset();
+        int len = bm.readBytes(bytes);
+        assertEquals(2, len);
+        len = bm.readBytes(bytes);
+        assertEquals(-1, len);
+        len = bm.readBytes(bytes, 2);
+        assertEquals(-1, len);
+        bm.reset();
+        len = bm.readBytes(bytes, 2);
+        assertEquals(2, len);
+        bm.reset();
+        len = bm.readBytes(bytes, 1);
+        assertEquals(1, len);
+
     }
 
     public void testEOFByte() throws Exception
diff --git a/java/client/src/test/java/org/apache/qpid/test/unit/client/message/StreamMessageTest.java b/java/client/src/test/java/org/apache/qpid/test/unit/client/message/StreamMessageTest.java
new file mode 100644
index 0000000000..83e555192c
--- /dev/null
+++ b/java/client/src/test/java/org/apache/qpid/test/unit/client/message/StreamMessageTest.java
@@ -0,0 +1,468 @@
+/*
+ *
+ * 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 junit.framework.TestCase;
+import org.apache.qpid.client.message.JMSStreamMessage;
+import org.apache.qpid.client.message.TestMessageHelper;
+
+import javax.jms.MessageNotReadableException;
+import javax.jms.MessageNotWriteableException;
+import javax.jms.MessageFormatException;
+import javax.jms.MessageEOFException;
+import java.util.HashMap;
+
+/**
+ * @author Apache Software Foundation
+ */
+public class StreamMessageTest extends TestCase
+{
+    /**
+     * Tests that on creation a call to getBodyLength() throws an exception
+     * if null was passed in during creation
+     */
+    public void testNotReadableOnCreationWithNull() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.readByte();
+            fail("expected exception did not occur");
+        }
+        catch (MessageNotReadableException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageNotReadableException, got " + e);
+        }
+    }
+
+    public void testResetMakesReadble() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeInt(10);
+            bm.reset();
+            bm.writeInt(12);
+            fail("expected exception did not occur");
+        }
+        catch (MessageNotWriteableException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageNotWriteableException, got " + e);
+        }
+    }
+
+    public void testClearBodyMakesWritable() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeInt(10);
+        bm.reset();
+        bm.clearBody();
+        bm.writeInt(10);
+    }
+
+    public void testWriteBoolean() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeBoolean(true);
+        bm.writeBoolean(false);
+        bm.reset();
+        boolean val = bm.readBoolean();
+        assertEquals(true, val);
+        val = bm.readBoolean();
+        assertEquals(false, val);
+    }
+
+    public void testWriteInt() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeInt(10);
+        bm.reset();
+        int val = bm.readInt();
+        assertTrue(val == 10);
+    }
+
+    public void testWriteString() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeString("Bananas");
+        bm.reset();
+        String res = bm.readString();
+        assertEquals("Bananas", res);
+    }
+
+    public void testWriteBytes() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        byte[] bytes = {1,2,3,4};
+        bm.writeBytes(bytes, 1, 2);
+        bm.reset();
+        bytes = new byte[2];
+        bm.readBytes(bytes);
+        assertEquals(2, bytes[0]);
+        assertEquals(3, bytes[1]);
+    }
+
+    public void testWriteObject() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeObject(new Boolean(true));
+        bm.writeObject(new Boolean(false));
+        bm.writeObject(new Byte((byte)2));
+        bm.writeObject(new byte[]{1,2,3,4});
+        bm.writeObject(new Character('g'));
+        bm.writeObject(new Short((short) 29));
+        bm.writeObject(new Integer(101));
+        bm.writeObject(new Long(50003222L));
+        bm.writeObject("Foobar");
+        bm.writeObject(new Float(1.7f));
+        bm.writeObject(new Double(8.7d));
+        bm.reset();
+        assertTrue(bm.readBoolean());
+        assertTrue(!bm.readBoolean());
+        assertEquals((byte)2, bm.readByte());
+        byte[] bytes = new byte[4];
+        bm.readBytes(bytes);
+        assertEquals('g', bm.readChar());
+        assertEquals((short) 29, bm.readShort());
+        assertEquals(101, bm.readInt());
+        assertEquals(50003222L, bm.readLong());
+        assertEquals("Foobar", bm.readString());
+        assertEquals(1.7f, bm.readFloat());
+        assertEquals(8.7d, bm.readDouble());
+    }
+
+    public void testWriteObjectRejectsNonPrimitives() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeObject(new HashMap());
+            fail("expected MessageFormatException was not thrown");
+        }
+        catch (MessageFormatException e)
+        {
+            // pass
+        }
+    }
+
+    public void testWriteObjectThrowsNPE() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeObject(null);
+            fail("expected exception did not occur");
+        }
+        catch (NullPointerException n)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected NullPointerException, got " + e);
+        }
+    }
+
+    public void testReadBoolean() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeBoolean(true);
+        bm.reset();
+        boolean result = bm.readBoolean();
+        assertTrue(result);
+    }
+
+    public void testReadBytesChecksNull() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.readBytes(null);
+        }
+        catch (IllegalArgumentException e)
+        {
+            // pass
+        }
+    }
+
+    public void testReadBytesReturnsCorrectLengths() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        byte[] bytes = {2, 3};
+        bm.writeBytes(bytes);        
+        bm.reset();
+        int len = bm.readBytes(bytes);
+        assertEquals(2, len);
+        len = bm.readBytes(bytes);
+        assertEquals(-1, len);
+    }
+
+    public void testEOFByte() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeByte((byte)1);
+            bm.reset();
+            bm.readByte();
+            // should throw
+            bm.readByte();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFBoolean() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeBoolean(true);
+            bm.reset();
+            bm.readBoolean();
+            // should throw
+            bm.readBoolean();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFChar() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeChar('A');
+            bm.reset();
+            bm.readChar();
+            // should throw
+            bm.readChar();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFDouble() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeDouble(1.3d);
+            bm.reset();
+            bm.readDouble();
+            // should throw
+            bm.readDouble();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFFloat() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeFloat(1.3f);
+            bm.reset();
+            bm.readFloat();
+            // should throw
+            bm.readFloat();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFInt() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeInt(99);
+            bm.reset();
+            bm.readInt();
+            // should throw
+            bm.readInt();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFLong() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeLong(4L);
+            bm.reset();
+            bm.readLong();
+            // should throw
+            bm.readLong();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    public void testEOFShort() throws Exception
+    {
+        try
+        {
+            JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+            bm.writeShort((short)4);
+            bm.reset();
+            bm.readShort();
+            // should throw
+            bm.readShort();
+            fail("expected exception did not occur");
+        }
+        catch (MessageEOFException m)
+        {
+            // ok
+        }
+        catch (Exception e)
+        {
+            fail("expected MessageEOFException, got " + e);
+        }
+    }
+
+    /**
+     * Tests that the readBytes() method populates the passed in array
+     * correctly
+     * @throws Exception
+     */
+    public void testReadBytes() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeByte((byte)3);
+        bm.writeByte((byte)4);
+        bm.reset();
+        byte[] result = new byte[2];
+        int count = bm.readBytes(result);
+        assertEquals((byte)3, result[0]);
+        assertEquals((byte)4, result[1]);
+        assertEquals(2, count);
+    }
+
+    public void testReadBytesEOF() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeByte((byte)3);
+        bm.writeByte((byte)4);
+        bm.reset();
+        byte[] result = new byte[2];
+        bm.readBytes(result);
+        int count = bm.readBytes(result);
+        assertEquals(-1, count);
+    }
+
+    public void testReadBytesWithLargerArray() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.writeByte((byte)3);
+        bm.writeByte((byte)4);
+        bm.reset();
+        byte[] result = new byte[3];
+        int count = bm.readBytes(result);
+        assertEquals(2, count);
+        assertEquals((byte)3, result[0]);
+        assertEquals((byte)4, result[1]);
+        assertEquals((byte)0, result[2]);
+    }
+
+    public void testToBodyString() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        final String testText = "This is a test";
+        bm.writeString(testText);
+        bm.reset();
+        String result = bm.toBodyString();
+        assertEquals(testText, result);
+    }
+
+    public void testToBodyStringWithNull() throws Exception
+    {
+        JMSStreamMessage bm = TestMessageHelper.newJMSStreamMessage();
+        bm.reset();
+        String result = bm.toBodyString();
+        assertNull(result);
+    }
+
+    public static junit.framework.Test suite()
+    {
+        return new junit.framework.TestSuite(StreamMessageTest.class);
+    }
+}