Apache.NMS.ActiveMQ.Commands.ActiveMQStreamMessage.ReadChar C# (CSharp) Method

        public char ReadChar()
        {
            InitializeReading();

            try
            {
                long startingPos = this.byteBuffer.Position;
                try
                {
                    int type = this.dataIn.ReadByte();

                    switch (type)
                    {
                        case PrimitiveMap.CHAR_TYPE:
                            return this.dataIn.ReadChar();
                        case PrimitiveMap.NULL:
                            this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                            throw new NMSException("Cannot convert Null type to a char");
                        default:
                            this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                            throw new MessageFormatException("Value is not a Char type.");
                    }
                }
                catch(FormatException e)
                {
                    this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                    throw NMSExceptionSupport.CreateMessageFormatException(e);
                }
            }
            catch(EndOfStreamException e)
            {
                throw NMSExceptionSupport.CreateMessageEOFException(e);
            }
            catch(IOException e)
            {
                throw NMSExceptionSupport.CreateMessageFormatException(e);
            }
        }

 public void TestReadOnlyBody()
 {
     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.WriteSingle((float)1.5);
         message.WriteInt32(1);
         message.WriteInt64(1);
         message.WriteObject("stringobj");
         message.WriteInt16((short)1);
         message.WriteString("string");
     }
     catch(MessageNotWriteableException)
     {
         Assert.Fail("Should be writeable");
     }
     message.Reset();
     try
     {
         message.ReadBoolean();
         message.ReadByte();
         Assert.AreEqual(1, message.ReadBytes(new byte[10]));
         Assert.AreEqual(-1, message.ReadBytes(new byte[10]));
         Assert.AreEqual(2, message.ReadBytes(new byte[10]));
         Assert.AreEqual(-1, message.ReadBytes(new byte[10]));
         message.ReadChar();
         message.ReadDouble();
         message.ReadSingle();
         message.ReadInt32();
         message.ReadInt64();
         message.ReadString();
         message.ReadInt16();
         message.ReadString();
     }
     catch(MessageNotReadableException)
     {
         Assert.Fail("Should be readable");
     }
     try
     {
         message.WriteBoolean(true);
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try
     {
         message.WriteByte((byte)1);
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try
     {
         message.WriteBytes(new byte[1]);
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try
     {
         message.WriteBytes(new byte[3], 0, 2);
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try {
         message.WriteChar('a');
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try
     {
         message.WriteDouble(1.5);
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try
     {
         message.WriteSingle((float)1.5);
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try
     {
         message.WriteInt32(1);
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try
     {
         message.WriteInt64(1);
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try
     {
         message.WriteObject("stringobj");
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try
     {
         message.WriteSingle((short)1);
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
     try
     {
         message.WriteString("string");
         Assert.Fail("Should have thrown exception");
     }
     catch(MessageNotWriteableException)
     {
     }
 }