/*
 * 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.
 */

using NUnit.Framework;
using System;
using System.Text;
using System.Collections;
using Apache.NMS.Stomp.Commands;
using Apache.NMS.Stomp.Protocol;
using Apache.NMS.Util;

namespace Apache.NMS.Stomp.Test.Commands
{
    [TestFixture]
    public class MessageTest
    {
        private string nmsMessageID;
        private string nmsCorrelationID;
        private Topic nmsDestination;
        private TempTopic nmsReplyTo;
        private MsgDeliveryMode nmsDeliveryMode;
        private bool nmsRedelivered;
        private string nmsType;
        private MsgPriority nmsPriority;
        private DateTime nmsTimestamp;
        private long[] consumerIDs;

        [SetUp]
        public virtual void SetUp()
        {
            this.nmsMessageID = "testid";
            this.nmsCorrelationID = "testcorrelationid";
            this.nmsDestination = new Topic("test.topic");
            this.nmsReplyTo = new TempTopic("test.replyto.topic:001");
            this.nmsDeliveryMode = MsgDeliveryMode.NonPersistent;
            this.nmsRedelivered = true;
            this.nmsType = "test type";
            this.nmsPriority = MsgPriority.High;
            this.nmsTimestamp = DateTime.Now;
            this.consumerIDs = new long[3];

            for(int i = 0; i < this.consumerIDs.Length; i++)
            {
                this.consumerIDs[i] = i;
            }
        }

        [Test]
        public void TestSetReadOnly()
        {
            Message msg = new Message();
            msg.ReadOnlyProperties =  true;
            bool test = false;

            try
            {
                msg.Properties.SetInt("test", 1);
            }
            catch(MessageNotWriteableException)
            {
                test = true;
            }
            catch(NMSException)
            {
                test = false;
            }

            Assert.IsTrue(test);
        }

        [Test]
        public void TestSetToForeignNMSID()
        {
            Message msg = new Message();
            msg.NMSMessageId = "ID:EMS-SERVER.8B443C380083:429";
        }

        [Test]
        public void TestEqualsObject()
        {
            Message msg1 = new Message();
            Message msg2 = new Message();
            msg1.NMSMessageId = this.nmsMessageID;
            Assert.IsTrue(!msg1.Equals(msg2));
            msg2.NMSMessageId = this.nmsMessageID;
            Assert.IsTrue(msg1.Equals(msg2));
        }

        [Test]
        public void TestShallowCopy()
        {
            Message msg1 = new Message();
            msg1.NMSMessageId = nmsMessageID;
            Message msg2 = (Message) msg1.Clone();
            Assert.IsTrue(msg1 != msg2 && msg1.Equals(msg2));
        }

        [Test]
        public void TestCopy()
        {
            this.nmsMessageID = "ID:1141:45278:429";
            this.nmsCorrelationID = "testcorrelationid";
            this.nmsDestination = new Topic("test.topic");
            this.nmsReplyTo = new TempTopic("test.replyto.topic:001");
            this.nmsDeliveryMode = MsgDeliveryMode.NonPersistent;
            this.nmsType = "test type";
            this.nmsPriority = MsgPriority.High;
            this.nmsTimestamp = DateTime.Now;

            Message msg1 = new Message();
            msg1.NMSMessageId = this.nmsMessageID;
            msg1.NMSCorrelationID = this.nmsCorrelationID;
            msg1.FromDestination = this.nmsDestination;
            msg1.NMSReplyTo = this.nmsReplyTo;
            msg1.NMSDeliveryMode = this.nmsDeliveryMode;
            msg1.NMSType = this.nmsType;
            msg1.NMSPriority = this.nmsPriority;
            msg1.NMSTimestamp = this.nmsTimestamp;
            msg1.ReadOnlyProperties = true;

            Message msg2 = msg1.Clone() as Message;

            Assert.IsTrue(msg1.NMSMessageId.Equals(msg2.NMSMessageId));
            Assert.IsTrue(msg1.NMSCorrelationID.Equals(msg2.NMSCorrelationID));
            Assert.IsTrue(msg1.NMSDestination.Equals(msg2.NMSDestination));
            Assert.IsTrue(msg1.NMSReplyTo.Equals(msg2.NMSReplyTo));
            Assert.IsTrue(msg1.NMSDeliveryMode == msg2.NMSDeliveryMode);
            Assert.IsTrue(msg1.NMSRedelivered == msg2.NMSRedelivered);
            Assert.IsTrue(msg1.NMSType.Equals(msg2.NMSType));
            Assert.IsTrue(msg1.NMSPriority == msg2.NMSPriority);
            Assert.IsTrue(msg1.NMSTimestamp == msg2.NMSTimestamp);
        }

        [Test]
        public void TestGetAndSetNMSCorrelationID()
        {
            Message msg = new Message();
            msg.NMSCorrelationID = this.nmsCorrelationID;
            Assert.IsTrue(msg.NMSCorrelationID.Equals(this.nmsCorrelationID));
        }

        [Test]
        public void TestGetAndSetNMSReplyTo()
        {
            Message msg = new Message();
            msg.NMSReplyTo = this.nmsReplyTo;
            Assert.AreEqual(msg.NMSReplyTo, this.nmsReplyTo);
        }

        [Test]
        public void TestGetAndSetNMSDestination()
        {
            Message msg = new Message();
            msg.FromDestination = this.nmsDestination;
            Assert.AreEqual(msg.NMSDestination, this.nmsDestination);
        }

        [Test]
        public void TestGetAndSetNMSDeliveryMode()
        {
            Message msg = new Message();
            msg.NMSDeliveryMode = this.nmsDeliveryMode;
            Assert.IsTrue(msg.NMSDeliveryMode == this.nmsDeliveryMode);
        }

        [Test]
        public void TestGetAndSetMSRedelivered()
        {
            Message msg = new Message();
            msg.RedeliveryCounter = 2;
            Assert.IsTrue(msg.NMSRedelivered == this.nmsRedelivered);
        }

        [Test]
        public void TestGetAndSetNMSType()
        {
            Message msg = new Message();
            msg.NMSType = this.nmsType;
            Assert.AreEqual(msg.NMSType, this.nmsType);
        }

        [Test]
        public void TestGetAndSetNMSPriority()
        {
            Message msg = new Message();
            msg.NMSPriority = this.nmsPriority;
            Assert.IsTrue(msg.NMSPriority == this.nmsPriority);
        }

        public void TestClearProperties()
        {
            Message msg = new Message();
            msg.Properties.SetString("test", "test");
            msg.Content = new byte[1];
            msg.NMSMessageId = this.nmsMessageID;
            msg.ClearProperties();
            Assert.IsNull(msg.Properties.GetString("test"));
            Assert.IsNotNull(msg.NMSMessageId);
            Assert.IsNotNull(msg.Content);
        }

        [Test]
        public void TestPropertyExists()
        {
            Message msg = new Message();
            msg.Properties.SetString("test", "test");
            Assert.IsTrue(msg.Properties.Contains("test"));
        }

        [Test]
        public void TestGetBooleanProperty()
        {
            Message msg = new Message();
            string name = "booleanProperty";
            msg.Properties.SetBool(name, true);
            Assert.IsTrue(msg.Properties.GetBool(name));
        }

        [Test]
        public void TestGetByteProperty()
        {
            Message msg = new Message();
            string name = "byteProperty";
            msg.Properties.SetByte(name, (byte)1);
            Assert.IsTrue(msg.Properties.GetByte(name) == 1);
        }

        [Test]
        public void TestGetShortProperty()
        {
            Message msg = new Message();
            string name = "shortProperty";
            msg.Properties.SetShort(name, (short)1);
            Assert.IsTrue(msg.Properties.GetShort(name) == 1);
        }

        [Test]
        public void TestGetIntProperty()
        {
            Message msg = new Message();
            string name = "intProperty";
            msg.Properties.SetInt(name, 1);
            Assert.IsTrue(msg.Properties.GetInt(name) == 1);
        }

        [Test]
        public void TestGetLongProperty()
        {
            Message msg = new Message();
            string name = "longProperty";
            msg.Properties.SetLong(name, 1);
            Assert.IsTrue(msg.Properties.GetLong(name) == 1);
        }

        [Test]
        public void TestGetFloatProperty()
        {
            Message msg = new Message();
            string name = "floatProperty";
            msg.Properties.SetFloat(name, 1.3f);
            Assert.IsTrue(msg.Properties.GetFloat(name) == 1.3f);
        }

        [Test]
        public void TestGetDoubleProperty()
        {
            Message msg = new Message();
            string name = "doubleProperty";
            msg.Properties.SetDouble(name, 1.3d);
            Assert.IsTrue(msg.Properties.GetDouble(name) == 1.3);
        }

        [Test]
        public void TestGetStringProperty()
        {
            Message msg = new Message();
            string name = "stringProperty";
            msg.Properties.SetString(name, name);
            Assert.IsTrue(msg.Properties.GetString(name).Equals(name));
        }

        [Test]
        public void TestGetObjectProperty()
        {
            Message msg = new Message();
            string name = "floatProperty";
            msg.Properties.SetFloat(name, 1.3f);
            Assert.IsTrue(msg.Properties[name] is float);
            Assert.IsTrue((float)msg.Properties[name] == 1.3f);
        }

        [Test]
        public void TestGetPropertyNames()
        {
            Message msg = new Message();
            string name = "floatProperty";
            msg.Properties.SetFloat(name, 1.3f);

            foreach(string key in msg.Properties.Keys)
            {
                Assert.IsTrue(key.Equals(name));
            }
        }

        [Test]
        public void TestSetObjectProperty()
        {
            Message msg = new Message();
            string name = "property";

            try
            {
                msg.Properties[name] = "string";
                msg.Properties[name] = (Byte) 1;
                msg.Properties[name] = (Int16) 1;
                msg.Properties[name] = (Int32) 1;
                msg.Properties[name] = (Int64) 1;
                msg.Properties[name] = (Single) 1.1f;
                msg.Properties[name] = (Double) 1.1;
                msg.Properties[name] = (Boolean) true;
                msg.Properties[name] = null;
            }
            catch(MessageFormatException)
            {
                Assert.Fail("should accept object primitives and String");
            }

            try
            {
                msg.Properties[name] = new Object();
                Assert.Fail("should accept only object primitives and String");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties[name] = new StringBuilder();
                Assert.Fail("should accept only object primitives and String");
            }
            catch(MessageFormatException)
            {
            }
        }

        [Test]
        public void TestConvertProperties()
        {
            Message msg = new Message();

            msg.Properties["stringProperty"] = "string";
            msg.Properties["byteProperty"] = (Byte) 1;
            msg.Properties["shortProperty"] = (Int16) 1;
            msg.Properties["intProperty"] = (Int32) 1;
            msg.Properties["longProperty"] = (Int64) 1;
            msg.Properties["floatProperty"] = (Single) 1.1f;
            msg.Properties["doubleProperty"] = (Double) 1.1;
            msg.Properties["booleanProperty"] = (Boolean) true;
            msg.Properties["nullProperty"] = null;

            msg.BeforeMarshall(new StompWireFormat());

            IPrimitiveMap properties = msg.Properties;
            Assert.AreEqual(properties["stringProperty"], "string");
            Assert.AreEqual((byte)properties["byteProperty"], (byte) 1);
            Assert.AreEqual((short)properties["shortProperty"], (short) 1);
            Assert.AreEqual((int)properties["intProperty"], (int) 1);
            Assert.AreEqual((long)properties["longProperty"], (long) 1);
            Assert.AreEqual((float)properties["floatProperty"], 1.1f, 0);
            Assert.AreEqual((double)properties["doubleProperty"], 1.1, 0);
            Assert.AreEqual((bool)properties["booleanProperty"], true);
            Assert.IsNull(properties["nullProperty"]);

        }

        [Test]
        public void TestSetNullProperty()
        {
            Message msg = new Message();
            string name = "cheese";
            msg.Properties.SetString(name, "Cheddar");
            Assert.AreEqual("Cheddar", msg.Properties.GetString(name));

            msg.Properties.SetString(name, null);
            Assert.AreEqual(null, msg.Properties.GetString(name));
        }

        [Test]
        public void TestSetNullPropertyName()
        {
            Message msg = new Message();

            try
            {
                msg.Properties.SetString(null, "Cheese");
                Assert.Fail("Should have thrown exception");
            }
            catch(Exception)
            {
            }
        }

        [Test]
        public void TestSetEmptyPropertyName()
        {
            Message msg = new Message();

            try
            {
                msg.Properties.SetString("", "Cheese");
                Assert.Fail("Should have thrown exception");
            }
            catch(Exception)
            {
            }
        }

        [Test]
        public void TestGetAndSetNMSXDeliveryCount()
        {
            Message msg = new Message();
            msg.Properties.SetInt("NMSXDeliveryCount", 1);
            int count = msg.Properties.GetInt("NMSXDeliveryCount");
            Assert.IsTrue(count == 1, "expected delivery count = 1 - got: " + count);
        }

        [Test]
        public void TestClearBody()
        {
            BytesMessage message = new BytesMessage();
            message.ClearBody();
            Assert.IsFalse(message.ReadOnlyBody);
        }

        [Test]
        public void TestBooleanPropertyConversion()
        {
            Message msg = new Message();
            String propertyName = "property";
            msg.Properties.SetBool(propertyName, true);

            Assert.AreEqual((bool)msg.Properties[propertyName], true);
            Assert.IsTrue(msg.Properties.GetBool(propertyName));
            Assert.AreEqual(msg.Properties.GetString(propertyName), "True");
            try
            {
                msg.Properties.GetByte(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetShort(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetInt(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetLong(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetFloat(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetDouble(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }
        }

        [Test]
        public void TestBytePropertyConversion()
        {
            Message msg = new Message();
            String propertyName = "property";
            msg.Properties.SetByte(propertyName, (byte)1);

            Assert.AreEqual((byte)msg.Properties[propertyName], 1);
            Assert.AreEqual(msg.Properties.GetByte(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetShort(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetInt(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetLong(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetString(propertyName), "1");

            try
            {
                msg.Properties.GetBool(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetFloat(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try {
                msg.Properties.GetDouble(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }
        }

        [Test]
        public void TestShortPropertyConversion()
        {
            Message msg = new Message();
            String propertyName = "property";
            msg.Properties.SetShort(propertyName, (short)1);

            Assert.AreEqual((short)msg.Properties[propertyName], 1);
            Assert.AreEqual(msg.Properties.GetShort(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetInt(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetLong(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetString(propertyName), "1");

            try
            {
                msg.Properties.GetBool(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetByte(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetFloat(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetDouble(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }
        }

        [Test]
        public void TestIntPropertyConversion()
        {
            Message msg = new Message();
            String propertyName = "property";
            msg.Properties.SetInt(propertyName, (int)1);

            Assert.AreEqual((int)msg.Properties[propertyName], 1);
            Assert.AreEqual(msg.Properties.GetInt(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetLong(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetString(propertyName), "1");

            try
            {
                msg.Properties.GetBool(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetByte(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetShort(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetFloat(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetDouble(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }
        }

        [Test]
        public void TestLongPropertyConversion()
        {
            Message msg = new Message();
            String propertyName = "property";
            msg.Properties.SetLong(propertyName, 1);

            Assert.AreEqual((long)msg.Properties[propertyName], 1);
            Assert.AreEqual(msg.Properties.GetLong(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetString(propertyName), "1");

            try
            {
                msg.Properties.GetBool(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetByte(propertyName);
                Assert.Fail("Should have thrown exception");
            } catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetShort(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetInt(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetFloat(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetDouble(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }
        }

        [Test]
        public void TestFloatPropertyConversion()
        {
            Message msg = new Message();
            String propertyName = "property";
            float floatValue = (float)1.5;
            msg.Properties.SetFloat(propertyName, floatValue);
            Assert.AreEqual((float)msg.Properties[propertyName], floatValue, 0);
            Assert.AreEqual(msg.Properties.GetFloat(propertyName), floatValue, 0);
            Assert.AreEqual(msg.Properties.GetDouble(propertyName), floatValue, 0);
            Assert.AreEqual(msg.Properties.GetString(propertyName), floatValue.ToString());

            try
            {
                msg.Properties.GetBool(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetByte(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetShort(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetInt(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetLong(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }
        }

        [Test]
        public void TestDoublePropertyConversion()
        {
            Message msg = new Message();
            String propertyName = "property";
            Double doubleValue = 1.5;
            msg.Properties.SetDouble(propertyName, doubleValue);
            Assert.AreEqual((double)msg.Properties[propertyName], doubleValue, 0);
            Assert.AreEqual(msg.Properties.GetDouble(propertyName), doubleValue, 0);
            Assert.AreEqual(msg.Properties.GetString(propertyName), doubleValue.ToString());

            try
            {
                msg.Properties.GetBool(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetByte(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetShort(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetInt(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetLong(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetFloat(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }
        }

        [Test]
        public void TestStringPropertyConversion()
        {
            Message msg = new Message();
            String propertyName = "property";
            String stringValue = "True";
            msg.Properties.SetString(propertyName, stringValue);
            Assert.AreEqual(msg.Properties.GetString(propertyName), stringValue);
            Assert.AreEqual((string)msg.Properties[propertyName], stringValue);
            Assert.AreEqual(msg.Properties.GetBool(propertyName), true);

            stringValue = "1";
            msg.Properties.SetString(propertyName, stringValue);
            Assert.AreEqual(msg.Properties.GetByte(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetShort(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetInt(propertyName), 1);
            Assert.AreEqual(msg.Properties.GetLong(propertyName), 1);

            Double doubleValue = 1.5;
            stringValue = doubleValue.ToString();
            msg.Properties.SetString(propertyName, stringValue);
            Assert.AreEqual(msg.Properties.GetFloat(propertyName), 1.5, 0);
            Assert.AreEqual(msg.Properties.GetDouble(propertyName), 1.5, 0);

            stringValue = "bad";
            msg.Properties.SetString(propertyName, stringValue);

            try
            {
                msg.Properties.GetByte(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetShort(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetInt(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetLong(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetFloat(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            try
            {
                msg.Properties.GetDouble(propertyName);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageFormatException)
            {
            }

            Assert.IsFalse(msg.Properties.GetBool(propertyName));
        }

        [Test]
        public void TestReadOnlyProperties()
        {
            Message msg = new Message();
            String propertyName = "property";
            msg.ReadOnlyProperties = true;

            try
            {
                msg.Properties[propertyName] = new Object();
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageNotWriteableException)
            {
            }

            try
            {
                msg.Properties.SetString(propertyName, "test");
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageNotWriteableException)
            {
            }

            try
            {
                msg.Properties.SetBool(propertyName, true);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageNotWriteableException)
            {
            }

            try
            {
                msg.Properties.SetByte(propertyName, (byte)1);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageNotWriteableException) {
            }

            try
            {
                msg.Properties.SetShort(propertyName, (short)1);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageNotWriteableException)
            {
            }

            try
            {
                msg.Properties.SetInt(propertyName, 1);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageNotWriteableException)
            {
            }

            try
            {
                msg.Properties.SetLong(propertyName, 1);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageNotWriteableException)
            {
            }

            try
            {
                msg.Properties.SetFloat(propertyName, (float)1.5);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageNotWriteableException)
            {
            }

            try
            {
                msg.Properties.SetDouble(propertyName, 1.5);
                Assert.Fail("Should have thrown exception");
            }
            catch(MessageNotWriteableException)
            {
            }
        }
    }
}