content: /*
   * 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.activemq.command;
  
  import javax.jms.JMSException;
  import javax.jms.MessageFormatException;
  import javax.jms.MessageNotReadableException;
  import javax.jms.MessageNotWriteableException;
  
  import junit.framework.TestCase;
  
  public class ActiveMQStreamMessageTest extends TestCase {
  
     public ActiveMQStreamMessageTest(String name) {
        super(name);
     }
  
     public static void main(String[] args) {
        junit.textui.TestRunner.run(ActiveMQStreamMessageTest.class);
     }
  
     @Override
     protected void setUp() throws Exception {
        super.setUp();
     }
  
     @Override
     protected void tearDown() throws Exception {
        super.tearDown();
     }
  
     public void testGetDataStructureType() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        assertEquals(msg.getDataStructureType(), CommandTypes.ACTIVEMQ_STREAM_MESSAGE);
     }
  
     public void testReadBoolean() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           msg.writeBoolean(true);
           msg.reset();
           assertTrue(msg.readBoolean());
           msg.reset();
           assertTrue(msg.readString().equals("true"));
           msg.reset();
           try {
              msg.readByte();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readShort();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readInt();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readLong();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readFloat();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readDouble();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readChar();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readBytes(new byte[1]);
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testreadByte() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           byte test = (byte) 4;
           msg.writeByte(test);
           msg.reset();
           assertTrue(msg.readByte() == test);
           msg.reset();
           assertTrue(msg.readShort() == test);
           msg.reset();
           assertTrue(msg.readInt() == test);
           msg.reset();
           assertTrue(msg.readLong() == test);
           msg.reset();
           assertTrue(msg.readString().equals(Byte.valueOf(test).toString()));
           msg.reset();
           try {
              msg.readBoolean();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readFloat();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readDouble();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readChar();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readBytes(new byte[1]);
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testReadShort() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           short test = (short) 4;
           msg.writeShort(test);
           msg.reset();
           assertTrue(msg.readShort() == test);
           msg.reset();
           assertTrue(msg.readInt() == test);
           msg.reset();
           assertTrue(msg.readLong() == test);
           msg.reset();
           assertTrue(msg.readString().equals(Short.valueOf(test).toString()));
           msg.reset();
           try {
              msg.readBoolean();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readByte();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readFloat();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readDouble();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readChar();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readBytes(new byte[1]);
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testReadChar() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           char test = 'z';
           msg.writeChar(test);
           msg.reset();
           assertTrue(msg.readChar() == test);
           msg.reset();
           assertTrue(msg.readString().equals(Character.valueOf(test).toString()));
           msg.reset();
           try {
              msg.readBoolean();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readByte();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readShort();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readInt();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readLong();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readFloat();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readDouble();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readBytes(new byte[1]);
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testReadInt() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           int test = 4;
           msg.writeInt(test);
           msg.reset();
           assertTrue(msg.readInt() == test);
           msg.reset();
           assertTrue(msg.readLong() == test);
           msg.reset();
           assertTrue(msg.readString().equals(Integer.valueOf(test).toString()));
           msg.reset();
           try {
              msg.readBoolean();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readByte();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readShort();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readFloat();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readDouble();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readChar();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readBytes(new byte[1]);
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testReadLong() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           long test = 4L;
           msg.writeLong(test);
           msg.reset();
           assertTrue(msg.readLong() == test);
           msg.reset();
           assertTrue(msg.readString().equals(Long.valueOf(test).toString()));
           msg.reset();
           try {
              msg.readBoolean();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readByte();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readShort();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readInt();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readFloat();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readDouble();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readChar();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readBytes(new byte[1]);
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg = new ActiveMQStreamMessage();
           msg.writeObject(Long.valueOf("1"));
           // reset so it's readable now
           msg.reset();
           assertEquals(Long.valueOf("1"), msg.readObject());
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testReadFloat() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           float test = 4.4f;
           msg.writeFloat(test);
           msg.reset();
           assertTrue(msg.readFloat() == test);
           msg.reset();
           assertTrue(msg.readDouble() == test);
           msg.reset();
           assertTrue(msg.readString().equals(Float.valueOf(test).toString()));
           msg.reset();
           try {
              msg.readBoolean();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readByte();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readShort();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readInt();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readLong();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readChar();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readBytes(new byte[1]);
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testReadDouble() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           double test = 4.4d;
           msg.writeDouble(test);
           msg.reset();
           assertTrue(msg.readDouble() == test);
           msg.reset();
           assertTrue(msg.readString().equals(Double.valueOf(test).toString()));
           msg.reset();
           try {
              msg.readBoolean();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readByte();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readShort();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readInt();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readLong();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readFloat();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readChar();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readBytes(new byte[1]);
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
  
     }
  
     public void testReadString() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           byte testByte = (byte) 2;
           msg.writeString(Byte.valueOf(testByte).toString());
           msg.reset();
           assertTrue(msg.readByte() == testByte);
           msg.clearBody();
           short testShort = 3;
           msg.writeString(Short.valueOf(testShort).toString());
           msg.reset();
           assertTrue(msg.readShort() == testShort);
           msg.clearBody();
           int testInt = 4;
           msg.writeString(Integer.valueOf(testInt).toString());
           msg.reset();
           assertTrue(msg.readInt() == testInt);
           msg.clearBody();
           long testLong = 6L;
           msg.writeString(Long.valueOf(testLong).toString());
           msg.reset();
           assertTrue(msg.readLong() == testLong);
           msg.clearBody();
           float testFloat = 6.6f;
           msg.writeString(Float.valueOf(testFloat).toString());
           msg.reset();
           assertTrue(msg.readFloat() == testFloat);
           msg.clearBody();
           double testDouble = 7.7d;
           msg.writeString(Double.valueOf(testDouble).toString());
           msg.reset();
           assertTrue(msg.readDouble() == testDouble);
           msg.clearBody();
           msg.writeString("true");
           msg.reset();
           assertTrue(msg.readBoolean());
           msg.clearBody();
           msg.writeString("a");
           msg.reset();
           try {
              msg.readChar();
              fail("Should have thrown exception");
           } catch (MessageFormatException e) {
           }
           msg.clearBody();
           msg.writeString("777");
           msg.reset();
           try {
              msg.readBytes(new byte[3]);
              fail("Should have thrown exception");
           } catch (MessageFormatException e) {
           }
  
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testReadBigString() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           // Test with a 1Meg String
           StringBuilder bigSB = new StringBuilder(1024 * 1024);
           for (int i = 0; i < 1024 * 1024; i++) {
              bigSB.append('a' + i % 26);
           }
           String bigString = bigSB.toString();
  
           msg.writeString(bigString);
           msg.reset();
           assertEquals(bigString, msg.readString());
  
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testReadBytes() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           byte[] test = new byte[50];
           for (int i = 0; i < test.length; i++) {
              test[i] = (byte) i;
           }
           msg.writeBytes(test);
           msg.reset();
           byte[] valid = new byte[test.length];
           msg.readBytes(valid);
           for (int i = 0; i < valid.length; i++) {
              assertTrue(valid[i] == test[i]);
           }
           msg.reset();
           try {
              msg.readByte();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readShort();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readInt();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readLong();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readFloat();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readChar();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
           msg.reset();
           try {
              msg.readString();
              fail("Should have thrown exception");
           } catch (MessageFormatException mfe) {
           }
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testReadObject() {
        ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
        try {
           byte testByte = (byte) 2;
           msg.writeByte(testByte);
           msg.reset();
           assertTrue(((Byte) msg.readObject()).byteValue() == testByte);
           msg.clearBody();
  
           short testShort = 3;
           msg.writeShort(testShort);
           msg.reset();
           assertTrue(((Short) msg.readObject()).shortValue() == testShort);
           msg.clearBody();
  
           int testInt = 4;
           msg.writeInt(testInt);
           msg.reset();
           assertTrue(((Integer) msg.readObject()).intValue() == testInt);
           msg.clearBody();
  
           long testLong = 6L;
           msg.writeLong(testLong);
           msg.reset();
           assertTrue(((Long) msg.readObject()).longValue() == testLong);
           msg.clearBody();
  
           float testFloat = 6.6f;
           msg.writeFloat(testFloat);
           msg.reset();
           assertTrue(((Float) msg.readObject()).floatValue() == testFloat);
           msg.clearBody();
  
           double testDouble = 7.7d;
           msg.writeDouble(testDouble);
           msg.reset();
           assertTrue(((Double) msg.readObject()).doubleValue() == testDouble);
           msg.clearBody();
  
           char testChar = 'z';
           msg.writeChar(testChar);
           msg.reset();
           assertTrue(((Character) msg.readObject()).charValue() == testChar);
           msg.clearBody();
  
           byte[] data = new byte[50];
           for (int i = 0; i < data.length; i++) {
              data[i] = (byte) i;
           }
           msg.writeBytes(data);
           msg.reset();
           byte[] valid = (byte[]) msg.readObject();
           assertTrue(valid.length == data.length);
           for (int i = 0; i < valid.length; i++) {
              assertTrue(valid[i] == data[i]);
           }
           msg.clearBody();
           msg.writeBoolean(true);
           msg.reset();
           assertTrue(((Boolean) msg.readObject()).booleanValue());
  
        } catch (JMSException jmsEx) {
           jmsEx.printStackTrace();
           assertTrue(false);
        }
     }
  
     public void testClearBody() throws JMSException {
        ActiveMQStreamMessage streamMessage = new ActiveMQStreamMessage();
        try {
           streamMessage.writeObject(Long.valueOf(2));
           streamMessage.clearBody();
           assertFalse(streamMessage.isReadOnlyBody());
           streamMessage.writeObject(Long.valueOf(2));
           streamMessage.readObject();
           fail("should throw exception");
        } catch (MessageNotReadableException mnwe) {
        } catch (MessageNotWriteableException mnwe) {
           fail("should be writeable");
        }
     }
  
     public void testReset() throws JMSException {
        ActiveMQStreamMessage streamMessage = new ActiveMQStreamMessage();
        try {
           streamMessage.writeDouble(24.5);
           streamMessage.writeLong(311);
        } catch (MessageNotWriteableException mnwe) {
           fail("should be writeable");
        }
        streamMessage.reset();
        try {
           assertTrue(streamMessage.isReadOnlyBody());
           assertEquals(streamMessage.readDouble(), 24.5, 0);
           assertEquals(streamMessage.readLong(), 311);
        } catch (MessageNotReadableException mnre) {
           fail("should be readable");
        }
        try {
           streamMessage.writeInt(33);
           fail("should throw exception");
        } catch (MessageNotWriteableException mnwe) {
        }
     }
  
     public void testReadOnlyBody() throws JMSException {
        ActiveMQStreamMessage message = new ActiveMQStreamMessage();
        try {
           message.writeBoolean(true);
           message.writeByte((byte) 1);
           message.writeBytes(new byte[1]);
           message.writeBytes(new byte[3], 0, 2);
           message.writeChar('a');
           message.writeDouble(1.5);
           message.writeFloat((float) 1.5);
           message.writeInt(1);
           message.writeLong(1);
           message.writeObject("stringobj");
           message.writeShort((short) 1);
           message.writeString("string");
        } catch (MessageNotWriteableException mnwe) {
           fail("Should be writeable");
        }
        message.reset();
        try {
           message.readBoolean();
           message.readByte();
           assertEquals(1, message.readBytes(new byte[10]));
           assertEquals(-1, message.readBytes(new byte[10]));
           assertEquals(2, message.readBytes(new byte[10]));
           assertEquals(-1, message.readBytes(new byte[10]));
           message.readChar();
           message.readDouble();
           message.readFloat();
           message.readInt();
           message.readLong();
           message.readString();
           message.readShort();
           message.readString();
        } catch (MessageNotReadableException mnwe) {
           fail("Should be readable");
        }
        try {
           message.writeBoolean(true);
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeByte((byte) 1);
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeBytes(new byte[1]);
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeBytes(new byte[3], 0, 2);
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeChar('a');
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeDouble(1.5);
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeFloat((float) 1.5);
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeInt(1);
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeLong(1);
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeObject("stringobj");
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeShort((short) 1);
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
        try {
           message.writeString("string");
           fail("Should have thrown exception");
        } catch (MessageNotWriteableException mnwe) {
        }
     }
  
     public void testWriteOnlyBody() throws JMSException {
        ActiveMQStreamMessage message = new ActiveMQStreamMessage();
        message.clearBody();
        try {
           message.writeBoolean(true);
           message.writeByte((byte) 1);
           message.writeBytes(new byte[1]);
           message.writeBytes(new byte[3], 0, 2);
           message.writeChar('a');
           message.writeDouble(1.5);
           message.writeFloat((float) 1.5);
           message.writeInt(1);
           message.writeLong(1);
           message.writeObject("stringobj");
           message.writeShort((short) 1);
           message.writeString("string");
        } catch (MessageNotWriteableException mnwe) {
           fail("Should be writeable");
        }
        try {
           message.readBoolean();
           fail("Should have thrown exception");
        } catch (MessageNotReadableException mnwe) {
        }
        try {
           message.readByte();
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
        try {
           message.readBytes(new byte[1]);
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
        try {
           message.readBytes(new byte[2]);
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
        try {
           message.readChar();
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
        try {
           message.readDouble();
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
        try {
           message.readFloat();
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
        try {
           message.readInt();
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
        try {
           message.readLong();
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
        try {
           message.readString();
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
        try {
           message.readShort();
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
        try {
           message.readString();
           fail("Should have thrown exception");
        } catch (MessageNotReadableException e) {
        }
     }
  
     public void testWriteObject() {
        try {
           ActiveMQStreamMessage message = new ActiveMQStreamMessage();
           message.clearBody();
           message.writeObject("test");
           message.writeObject(Character.valueOf('a'));
           message.writeObject(Boolean.valueOf(false));
           message.writeObject(Byte.valueOf((byte) 2));
           message.writeObject(Short.valueOf((short) 2));
           message.writeObject(Integer.valueOf(2));
           message.writeObject(Long.valueOf(2L));
           message.writeObject(Float.valueOf(2.0f));
           message.writeObject(Double.valueOf(2.0d));
        } catch (Exception e) {
           fail(e.getMessage());
        }
        try {
           ActiveMQStreamMessage message = new ActiveMQStreamMessage();
           message.clearBody();
           message.writeObject(new Object());
           fail("should throw an exception");
        } catch (MessageFormatException e) {
  
        } catch (Exception e) {
           fail(e.getMessage());
        }
     }
  
  }
  