activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject [04/13] activemq-nms-xms git commit: Initial check-in of new Apache.NMS.XMS provider implementation. Big thanks to Stéphane Ramet for the implementation! Fixes [AMQNET-185]. (See https://issues.apache.org/jira/browse/AMQNET-185)
Date Wed, 08 Mar 2017 13:45:10 GMT
http://git-wip-us.apache.org/repos/asf/activemq-nms-xms/blob/653d676d/src/test/csharp/EndianBinaryWriterTest.cs
----------------------------------------------------------------------
diff --git a/src/test/csharp/EndianBinaryWriterTest.cs b/src/test/csharp/EndianBinaryWriterTest.cs
new file mode 100644
index 0000000..635b449
--- /dev/null
+++ b/src/test/csharp/EndianBinaryWriterTest.cs
@@ -0,0 +1,202 @@
+/*
+ * 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 System;
+using System.IO;
+using Apache.NMS.Util;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	[TestFixture]
+	public class EndianBinaryWriterTest
+	{
+		void writeString16TestHelper(char[] input, byte[] expect)
+		{
+			MemoryStream stream = new MemoryStream();
+			EndianBinaryWriter writer = new EndianBinaryWriter(stream);
+
+			String str = new String(input);
+
+			writer.WriteString16(str);
+
+			byte[] result = stream.GetBuffer();
+
+			Assert.AreEqual(result[0], 0x00);
+			Assert.AreEqual(result[1], expect.Length);
+
+			for(int i = 4; i < expect.Length; ++i)
+			{
+				Assert.AreEqual(result[i], expect[i - 2]);
+			}
+		}
+
+		[Test]
+		public void testWriteString16_1byteUTF8encoding()
+		{
+			// Test data with 1-byte UTF8 encoding.
+			char[] input = { '\u0000', '\u000B', '\u0048', '\u0065', '\u006C', '\u006C', '\u006F', '\u0020', '\u0057', '\u006F', '\u0072', '\u006C', '\u0064' };
+			byte[] expect = { 0xC0, 0x80, 0x0B, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64 };
+
+			writeString16TestHelper(input, expect);
+		}
+
+		[Test]
+		public void testWriteString16_2byteUTF8encoding()
+		{
+			// Test data with 2-byte UT8 encoding.
+			char[] input = { '\u0000', '\u00C2', '\u00A9', '\u00C3', '\u00A6' };
+			byte[] expect = { 0xC0, 0x80, 0xC3, 0x82, 0xC2, 0xA9, 0xC3, 0x83, 0xC2, 0xA6 };
+
+			writeString16TestHelper(input, expect);
+		}
+
+		[Test]
+		public void testWriteString16_1byteAnd2byteEmbeddedNULLs()
+		{
+			// Test data with 1-byte and 2-byte encoding with embedded NULL's.
+			char[] input = { '\u0000', '\u0004', '\u00C2', '\u00A9', '\u00C3', '\u0000', '\u00A6' };
+			byte[] expect = { 0xC0, 0x80, 0x04, 0xC3, 0x82, 0xC2, 0xA9, 0xC3, 0x83, 0xC0, 0x80, 0xC2, 0xA6 };
+
+			writeString16TestHelper(input, expect);
+		}
+
+		[Test]
+		public void testWriteString16_nullstring()
+		{
+			// test that a null string writes no output.
+			MemoryStream stream = new MemoryStream();
+			EndianBinaryWriter writer = new EndianBinaryWriter(stream);
+			writer.WriteString16(null);
+			Assert.AreEqual(0, stream.Length);
+		}
+
+		[Test]
+		public void testWriteString16_emptystring()
+		{
+			// test that a null string writes no output.
+			MemoryStream stream = new MemoryStream();
+			EndianBinaryWriter writer = new EndianBinaryWriter(stream);
+			writer.WriteString16("");
+
+			stream.Seek(0, SeekOrigin.Begin);
+			EndianBinaryReader reader = new EndianBinaryReader(stream);
+			Assert.AreEqual(0, reader.ReadInt16());
+		}
+
+		[Test]
+		[ExpectedException(typeof(IOException))]
+		public void testWriteString16_stringTooLong()
+		{
+			// String of length 65536 of Null Characters.
+			MemoryStream stream = new MemoryStream();
+			EndianBinaryWriter writer = new EndianBinaryWriter(stream);
+			String testStr = new String('a', 65536);
+			writer.Write(testStr);
+		}
+
+		[Test]
+		public void testWriteString16_maxStringLength()
+		{
+			// String of length 65535 of non Null Characters since Null encodes as UTF-8.
+			MemoryStream stream = new MemoryStream();
+			EndianBinaryWriter writer = new EndianBinaryWriter(stream);
+			String testStr = new String('a', 65535);
+			writer.Write(testStr);
+		}
+
+		[Test]
+		[ExpectedException(typeof(IOException))]
+		public void testWriteString16_invalidEncodingHeader()
+		{
+			// Set one of the 65535 bytes to a value that will result in a 2 byte UTF8 encoded sequence.
+			// This will cause the string of length 65535 to have a utf length of 65536.
+			MemoryStream stream = new MemoryStream();
+			EndianBinaryWriter writer = new EndianBinaryWriter(stream);
+			String testStr = new String('a', 65535);
+			char[] array = testStr.ToCharArray();
+			array[0] = '\u0000';
+			testStr = new String(array);
+			writer.Write(testStr);
+		}
+
+		void writeString32TestHelper(char[] input, byte[] expect)
+		{
+			MemoryStream stream = new MemoryStream();
+			EndianBinaryWriter writer = new EndianBinaryWriter(stream);
+
+			String str = new String(input);
+
+			writer.WriteString32(str);
+
+			byte[] result = stream.GetBuffer();
+
+			Assert.AreEqual(result[0], 0x00);
+			Assert.AreEqual(result[1], 0x00);
+			Assert.AreEqual(result[2], 0x00);
+			Assert.AreEqual(result[3], expect.Length);
+
+			for(int i = 4; i < expect.Length; ++i)
+			{
+				Assert.AreEqual(result[i], expect[i - 4]);
+			}
+		}
+
+		[Test]
+		public void testWriteString32_1byteUTF8encoding()
+		{
+			// Test data with 1-byte UTF8 encoding.
+			char[] input = { '\u0000', '\u000B', '\u0048', '\u0065', '\u006C', '\u006C', '\u006F', '\u0020', '\u0057', '\u006F', '\u0072', '\u006C', '\u0064' };
+			byte[] expect = { 0xC0, 0x80, 0x0B, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64 };
+
+			writeString32TestHelper(input, expect);
+		}
+
+		[Test]
+		public void testWriteString32_2byteUTF8encoding()
+		{
+			// Test data with 2-byte UT8 encoding.
+			char[] input = { '\u0000', '\u00C2', '\u00A9', '\u00C3', '\u00A6' };
+			byte[] expect = { 0xC0, 0x80, 0xC3, 0x82, 0xC2, 0xA9, 0xC3, 0x83, 0xC2, 0xA6 };
+
+			writeString32TestHelper(input, expect);
+		}
+
+		[Test]
+		public void testWriteString32_1byteAnd2byteEmbeddedNULLs()
+		{
+			// Test data with 1-byte and 2-byte encoding with embedded NULL's.
+			char[] input = { '\u0000', '\u0004', '\u00C2', '\u00A9', '\u00C3', '\u0000', '\u00A6' };
+			byte[] expect = { 0xC0, 0x80, 0x04, 0xC3, 0x82, 0xC2, 0xA9, 0xC3, 0x83, 0xC0, 0x80, 0xC2, 0xA6 };
+
+			writeString32TestHelper(input, expect);
+		}
+
+		[Test]
+		public void testWriteString32_nullstring()
+		{
+			// test that a null strings writes a -1
+			MemoryStream stream = new MemoryStream();
+			EndianBinaryWriter writer = new EndianBinaryWriter(stream);
+			writer.WriteString32(null);
+
+			stream.Seek(0, SeekOrigin.Begin);
+			EndianBinaryReader reader = new EndianBinaryReader(stream);
+			Assert.AreEqual(-1, reader.ReadInt32());
+		}
+	}
+}

http://git-wip-us.apache.org/repos/asf/activemq-nms-xms/blob/653d676d/src/test/csharp/EndianTest.cs
----------------------------------------------------------------------
diff --git a/src/test/csharp/EndianTest.cs b/src/test/csharp/EndianTest.cs
new file mode 100644
index 0000000..773eaf1
--- /dev/null
+++ b/src/test/csharp/EndianTest.cs
@@ -0,0 +1,131 @@
+/*
+ * 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 System.IO;
+using Apache.NMS.Util;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	[TestFixture]
+	public class EndianTest
+	{
+		[Test]
+		public void TestLongEndian()
+		{
+			long value = 0x0102030405060708L;
+			long newValue = EndianSupport.SwitchEndian(value);
+			Assert.AreEqual(0x0807060504030201L, newValue);
+			long actual = EndianSupport.SwitchEndian(newValue);
+			Assert.AreEqual(value, actual);
+		}
+
+		[Test]
+		public void TestIntEndian()
+		{
+			int value = 0x12345678;
+			int newValue = EndianSupport.SwitchEndian(value);
+			Assert.AreEqual(0x78563412, newValue);
+			int actual = EndianSupport.SwitchEndian(newValue);
+			Assert.AreEqual(value, actual);
+		}
+
+		[Test]
+		public void TestCharEndian()
+		{
+			char value = 'J';
+			char newValue = EndianSupport.SwitchEndian(value);
+			char actual = EndianSupport.SwitchEndian(newValue);
+			Assert.AreEqual(value, actual);
+		}
+
+		[Test]
+		public void TestShortEndian()
+		{
+			short value = 0x1234;
+			short newValue = EndianSupport.SwitchEndian(value);
+			Assert.AreEqual(0x3412, newValue);
+			short actual = EndianSupport.SwitchEndian(newValue);
+			Assert.AreEqual(value, actual);
+		}
+
+		[Test]
+		public void TestNegativeLongEndian()
+		{
+			long value = -0x0102030405060708L;
+			long newValue = EndianSupport.SwitchEndian(value);
+			long actual = EndianSupport.SwitchEndian(newValue);
+			Assert.AreEqual(value, actual);
+		}
+
+		[Test]
+		public void TestNegativeIntEndian()
+		{
+			int value = -0x12345678;
+			int newValue = EndianSupport.SwitchEndian(value);
+			int actual = EndianSupport.SwitchEndian(newValue);
+			Assert.AreEqual(value, actual);
+		}
+
+		[Test]
+		public void TestNegativeShortEndian()
+		{
+			short value = -0x1234;
+			short newValue = EndianSupport.SwitchEndian(value);
+			short actual = EndianSupport.SwitchEndian(newValue);
+			Assert.AreEqual(value, actual);
+		}
+
+		[Test]
+		public void TestFloatDontNeedEndianSwitch()
+		{
+			float value = -1.223F;
+
+			// Convert to int so we can compare to Java version.
+			MemoryStream ms = new MemoryStream(4);
+			BinaryWriter bw = new BinaryWriter(ms);
+			bw.Write(value);
+			bw.Close();
+			ms = new MemoryStream(ms.ToArray());
+			BinaryReader br = new BinaryReader(ms);
+
+			// System.out.println(Integer.toString(Float.floatToIntBits(-1.223F), 16));
+			Assert.AreEqual(-0x406374bc, br.ReadInt32());
+		}
+
+		[Test]
+		public void TestDoublDontNeedEndianSwitch()
+		{
+			double value = -1.223D;
+
+			// Convert to int so we can compare to Java version.
+			MemoryStream ms = new MemoryStream(4);
+			BinaryWriter bw = new BinaryWriter(ms);
+			bw.Write(value);
+			bw.Close();
+			ms = new MemoryStream(ms.ToArray());
+			BinaryReader br = new BinaryReader(ms);
+			long longVersion = br.ReadInt64();
+
+			// System.out.println(Long.toString(Double.doubleToLongBits(-1.223D), 16));
+			Assert.AreEqual(-0x400c6e978d4fdf3b, longVersion);
+		}
+	}
+}
+
+
+

http://git-wip-us.apache.org/repos/asf/activemq-nms-xms/blob/653d676d/src/test/csharp/ForeignMessageTransformationTest.cs
----------------------------------------------------------------------
diff --git a/src/test/csharp/ForeignMessageTransformationTest.cs b/src/test/csharp/ForeignMessageTransformationTest.cs
new file mode 100644
index 0000000..e5870b8
--- /dev/null
+++ b/src/test/csharp/ForeignMessageTransformationTest.cs
@@ -0,0 +1,305 @@
+/*
+ * 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 System;
+using Apache.NMS.Util;
+using Apache.NMS.Commands;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+    //[TestFixture]
+    public class ForeignMessageTransformationTest : NMSTest
+    {
+        private string propertyName = "Test-Property";
+        private string propertyValue = "Test-Property-Value";
+        private string mapElementName = "Test-Map-Property";
+        private string mapElementValue = "Test-Map-Property-Value";
+        private string textBody = "This is a TextMessage from a Foreign Provider";
+        private byte[] bytesContent = {1, 2, 3, 4, 5, 6, 7, 8};
+
+        private bool a = true;
+        private byte b = 123;
+        private char c = 'c';
+        private short d = 0x1234;
+        private int e = 0x12345678;
+        private long f = 0x1234567812345678;
+        private string g = "Hello World!";
+        private bool h = false;
+        private byte i = 0xFF;
+        private short j = -0x1234;
+        private int k = -0x12345678;
+        private long l = -0x1234567812345678;
+        private float m = 2.1F;
+        private double n = 2.3;
+
+		protected ForeignMessageTransformationTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+        //[Test]
+        public virtual void TestSendReceiveForeignMessage(
+            //[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+            MsgDeliveryMode deliveryMode, string testTopicRef)
+        {
+            using(IConnection connection = CreateConnection())
+            {
+                connection.Start();
+                using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+                {
+					IDestination destination = GetClearDestination(session, DestinationType.Topic, testTopicRef);
+                    using(IMessageConsumer consumer = session.CreateConsumer(destination))
+                    using(IMessageProducer producer = session.CreateProducer(destination))
+                    {
+                        try
+                        {
+                            producer.DeliveryMode = deliveryMode;
+                            Message request = new Message();
+                            request.Properties[propertyName] = propertyValue;
+
+                            producer.Send(request);
+
+                            IMessage message = consumer.Receive(receiveTimeout);
+                            Assert.IsNotNull(message, "No message returned!");
+                            Assert.AreEqual(request.Properties.Count, message.Properties.Count, "Invalid number of properties.");
+                            Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+
+                            // use generic API to access entries
+                            Assert.AreEqual(propertyValue, message.Properties[propertyName], "generic map entry: " + propertyName);
+
+                            // use type safe APIs
+                            Assert.AreEqual(propertyValue, message.Properties.GetString(propertyName),   "map entry: " + propertyName);
+                        }
+                        catch(NotSupportedException)
+                        {
+                        }
+                    }
+                }
+            }
+        }
+
+        //[Test]
+        public virtual void TestSendReceiveForeignTextMessage(
+            //[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+            MsgDeliveryMode deliveryMode, string testTopicRef)
+        {
+            using(IConnection connection = CreateConnection())
+            {
+                connection.Start();
+                using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+                {
+					IDestination destination = GetClearDestination(session, DestinationType.Topic, testTopicRef);
+                    using(IMessageConsumer consumer = session.CreateConsumer(destination))
+                    using(IMessageProducer producer = session.CreateProducer(destination))
+                    {
+                        try
+                        {
+                            producer.DeliveryMode = deliveryMode;
+                            TextMessage request = new TextMessage();
+                            request.Properties[propertyName] = propertyValue;
+                            request.Text = textBody;
+
+                            producer.Send(request);
+
+                            ITextMessage message = consumer.Receive(receiveTimeout) as ITextMessage;
+                            Assert.IsNotNull(message, "No message returned!");
+                            Assert.AreEqual(request.Properties.Count, message.Properties.Count, "Invalid number of properties.");
+                            Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+
+                            // Check the body
+                            Assert.AreEqual(textBody, message.Text, "TextMessage body was wrong.");
+
+                            // use generic API to access entries
+                            Assert.AreEqual(propertyValue, message.Properties[propertyName], "generic map entry: " + propertyName);
+
+                            // use type safe APIs
+                            Assert.AreEqual(propertyValue, message.Properties.GetString(propertyName),   "map entry: " + propertyName);
+                        }
+                        catch(NotSupportedException)
+                        {
+                        }
+                    }
+                }
+            }
+        }
+
+		//[Test]
+		public virtual void TestSendReceiveForeignBytesMessage(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testTopicRef)
+		{
+			using(IConnection connection = CreateConnection())
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Topic, testTopicRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						try
+						{
+							producer.DeliveryMode = deliveryMode;
+							BytesMessage request = new BytesMessage();
+							request.Properties[propertyName] = propertyValue;
+							request.WriteBytes(bytesContent);
+
+							producer.Send(request);
+
+							IBytesMessage message = consumer.Receive(receiveTimeout) as IBytesMessage;
+							Assert.IsNotNull(message, "No message returned!");
+							Assert.AreEqual(request.Properties.Count, message.Properties.Count, "Invalid number of properties.");
+							Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+
+							// Check the body
+							byte[] content = new byte[bytesContent.Length];
+							Assert.AreEqual(bytesContent.Length, message.ReadBytes(content));
+							Assert.AreEqual(bytesContent, content, "BytesMessage body was wrong.");
+
+							// use generic API to access entries
+							Assert.AreEqual(propertyValue, message.Properties[propertyName], "generic map entry: " + propertyName);
+
+							// use type safe APIs
+							Assert.AreEqual(propertyValue, message.Properties.GetString(propertyName),   "map entry: " + propertyName);
+						}
+						catch(NotSupportedException)
+						{
+						}
+					}
+				}
+			}
+		}
+
+		//[Test]
+		public virtual void TestSendReceiveForeignMapMessage(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testTopicRef)
+		{
+			using(IConnection connection = CreateConnection())
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Topic, testTopicRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						try
+						{
+							producer.DeliveryMode = deliveryMode;
+							MapMessage request = new MapMessage();
+							request.Properties[propertyName] = propertyValue;
+							request.Body[mapElementName] = mapElementValue;
+
+							producer.Send(request);
+
+							IMapMessage message = consumer.Receive(receiveTimeout) as IMapMessage;
+							Assert.IsNotNull(message, "No message returned!");
+							Assert.AreEqual(request.Properties.Count, message.Properties.Count, "Invalid number of properties.");
+							Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+
+							// Check the body
+							Assert.AreEqual(request.Body.Count, message.Body.Count);
+							Assert.AreEqual(mapElementValue, message.Body[mapElementName], "MapMessage body was wrong.");
+
+							// use generic API to access entries
+							Assert.AreEqual(propertyValue, message.Properties[propertyName], "generic map entry: " + propertyName);
+
+							// use type safe APIs
+							Assert.AreEqual(propertyValue, message.Properties.GetString(propertyName),   "map entry: " + propertyName);
+						}
+						catch(NotSupportedException)
+						{
+						}
+					}
+				}
+			}
+		}
+
+		//[Test]
+		public virtual void TestSendReceiveForeignStreamMessage(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testTopicRef)
+		{
+			using(IConnection connection = CreateConnection())
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Topic, testTopicRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						try
+						{
+							producer.DeliveryMode = deliveryMode;
+							StreamMessage request = new StreamMessage();
+							request.Properties[propertyName] = propertyValue;
+
+							request.WriteBoolean(a);
+							request.WriteByte(b);
+							request.WriteChar(c);
+							request.WriteInt16(d);
+							request.WriteInt32(e);
+							request.WriteInt64(f);
+							request.WriteString(g);
+							request.WriteBoolean(h);
+							request.WriteByte(i);
+							request.WriteInt16(j);
+							request.WriteInt32(k);
+							request.WriteInt64(l);
+							request.WriteSingle(m);
+							request.WriteDouble(n);
+
+							producer.Send(request);
+
+							IStreamMessage message = consumer.Receive(receiveTimeout) as IStreamMessage;
+							Assert.IsNotNull(message, "No message returned!");
+							Assert.AreEqual(request.Properties.Count, message.Properties.Count, "Invalid number of properties.");
+							Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+
+							// Check the body
+							Assert.AreEqual(a, message.ReadBoolean(), "Stream Boolean Value: a");
+							Assert.AreEqual(b, message.ReadByte(), "Stream Byte Value: b");
+							Assert.AreEqual(c, message.ReadChar(), "Stream Char Value: c");
+							Assert.AreEqual(d, message.ReadInt16(), "Stream Int16 Value: d");
+							Assert.AreEqual(e, message.ReadInt32(), "Stream Int32 Value: e");
+							Assert.AreEqual(f, message.ReadInt64(), "Stream Int64 Value: f");
+							Assert.AreEqual(g, message.ReadString(), "Stream String Value: g");
+							Assert.AreEqual(h, message.ReadBoolean(), "Stream Boolean Value: h");
+							Assert.AreEqual(i, message.ReadByte(), "Stream Byte Value: i");
+							Assert.AreEqual(j, message.ReadInt16(), "Stream Int16 Value: j");
+							Assert.AreEqual(k, message.ReadInt32(), "Stream Int32 Value: k");
+							Assert.AreEqual(l, message.ReadInt64(), "Stream Int64 Value: l");
+							Assert.AreEqual(m, message.ReadSingle(), "Stream Single Value: m");
+							Assert.AreEqual(n, message.ReadDouble(), "Stream Double Value: n");
+
+							// use generic API to access entries
+							Assert.AreEqual(propertyValue, message.Properties[propertyName], "generic map entry: " + propertyName);
+
+							// use type safe APIs
+							Assert.AreEqual(propertyValue, message.Properties.GetString(propertyName),   "map entry: " + propertyName);
+						}
+						catch(NotSupportedException)
+						{
+						}
+					}
+				}
+			}
+		}
+	}
+}

http://git-wip-us.apache.org/repos/asf/activemq-nms-xms/blob/653d676d/src/test/csharp/MapMessageTest.cs
----------------------------------------------------------------------
diff --git a/src/test/csharp/MapMessageTest.cs b/src/test/csharp/MapMessageTest.cs
new file mode 100644
index 0000000..6b7385d
--- /dev/null
+++ b/src/test/csharp/MapMessageTest.cs
@@ -0,0 +1,208 @@
+/*
+ * 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 System;
+using System.Collections;
+using Apache.NMS.Util;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	//[TestFixture]
+	public class MapMessageTest : NMSTest
+	{
+		protected bool a = true;
+		protected byte b = 123;
+		protected char c = 'c';
+		protected short d = 0x1234;
+		protected int e = 0x12345678;
+		protected long f = 0x1234567812345678;
+		protected string g = "Hello World!";
+		protected bool h = false;
+		protected byte i = 0xFF;
+		protected short j = -0x1234;
+		protected int k = -0x12345678;
+		protected long l = -0x1234567812345678;
+		protected float m = 2.1F;
+		protected double n = 2.3;
+		protected byte[] o = {1, 2, 3, 4, 5};
+
+		protected MapMessageTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+		//[Test]
+		public virtual void TestSendReceiveMapMessage(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.DeliveryMode = deliveryMode;
+						IMapMessage request = session.CreateMapMessage();
+						request.Body["a"] = a;
+						request.Body["b"] = b;
+						request.Body["c"] = c;
+						request.Body["d"] = d;
+						request.Body["e"] = e;
+						request.Body["f"] = f;
+						request.Body["g"] = g;
+						request.Body["h"] = h;
+						request.Body["i"] = i;
+						request.Body["j"] = j;
+						request.Body["k"] = k;
+						request.Body["l"] = l;
+						request.Body["m"] = m;
+						request.Body["n"] = n;
+						request.Body["o"] = o;
+						producer.Send(request);
+
+						IMapMessage message = consumer.Receive(receiveTimeout) as IMapMessage;
+						Assert.IsNotNull(message, "No message returned!");
+						Assert.AreEqual(request.Body.Count, message.Body.Count, "Invalid number of message maps.");
+						Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+						Assert.AreEqual(ToHex(f), ToHex(message.Body.GetLong("f")), "map entry: f as hex");
+
+						// use generic API to access entries
+						Assert.AreEqual(a, message.Body["a"], "generic map entry: a");
+						Assert.AreEqual(b, message.Body["b"], "generic map entry: b");
+						Assert.AreEqual(c, message.Body["c"], "generic map entry: c");
+						Assert.AreEqual(d, message.Body["d"], "generic map entry: d");
+						Assert.AreEqual(e, message.Body["e"], "generic map entry: e");
+						Assert.AreEqual(f, message.Body["f"], "generic map entry: f");
+						Assert.AreEqual(g, message.Body["g"], "generic map entry: g");
+						Assert.AreEqual(h, message.Body["h"], "generic map entry: h");
+						Assert.AreEqual(i, message.Body["i"], "generic map entry: i");
+						Assert.AreEqual(j, message.Body["j"], "generic map entry: j");
+						Assert.AreEqual(k, message.Body["k"], "generic map entry: k");
+						Assert.AreEqual(l, message.Body["l"], "generic map entry: l");
+						Assert.AreEqual(m, message.Body["m"], "generic map entry: m");
+						Assert.AreEqual(n, message.Body["n"], "generic map entry: n");
+						Assert.AreEqual(o, message.Body["o"], "generic map entry: o");
+
+						// use type safe APIs
+						Assert.AreEqual(a, message.Body.GetBool("a"), "map entry: a");
+						Assert.AreEqual(b, message.Body.GetByte("b"), "map entry: b");
+						Assert.AreEqual(c, message.Body.GetChar("c"), "map entry: c");
+						Assert.AreEqual(d, message.Body.GetShort("d"), "map entry: d");
+						Assert.AreEqual(e, message.Body.GetInt("e"), "map entry: e");
+						Assert.AreEqual(f, message.Body.GetLong("f"), "map entry: f");
+						Assert.AreEqual(g, message.Body.GetString("g"), "map entry: g");
+						Assert.AreEqual(h, message.Body.GetBool("h"), "map entry: h");
+						Assert.AreEqual(i, message.Body.GetByte("i"), "map entry: i");
+						Assert.AreEqual(j, message.Body.GetShort("j"), "map entry: j");
+						Assert.AreEqual(k, message.Body.GetInt("k"), "map entry: k");
+						Assert.AreEqual(l, message.Body.GetLong("l"), "map entry: l");
+						Assert.AreEqual(m, message.Body.GetFloat("m"), "map entry: m");
+						Assert.AreEqual(n, message.Body.GetDouble("n"), "map entry: n");
+						Assert.AreEqual(o, message.Body.GetBytes("o"), "map entry: o");
+					}
+				}
+			}
+		}
+
+		//[Test]
+		public virtual void TestSendReceiveNestedMapMessage(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						try
+						{
+							producer.DeliveryMode = deliveryMode;
+							IMapMessage request = session.CreateMapMessage();
+							const string textFieldValue = "Nested Map Messages Rule!";
+
+							request.Body.SetString("textField", textFieldValue);
+
+							IDictionary grandChildMap = new Hashtable();
+							grandChildMap["x"] = "abc";
+							grandChildMap["y"] = new ArrayList(new object[] { "a", "b", "c" });
+
+							IDictionary nestedMap = new Hashtable();
+							nestedMap["a"] = "foo";
+							nestedMap["b"] = (int) 23;
+							nestedMap["c"] = (long) 45;
+							nestedMap["d"] = grandChildMap;
+
+							request.Body.SetDictionary("mapField", nestedMap);
+							request.Body.SetList("listField", new ArrayList(new Object[] { "a", "b", "c" }));
+
+							producer.Send(request);
+
+							IMapMessage message = consumer.Receive(receiveTimeout) as IMapMessage;
+							Assert.IsNotNull(message, "No message returned!");
+							Assert.AreEqual(request.Body.Count, message.Body.Count, "Invalid number of message maps.");
+							Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+
+							string textFieldResponse = message.Body.GetString("textField");
+							Assert.AreEqual(textFieldValue, textFieldResponse, "textField does not match.");
+
+							IDictionary nestedMapResponse = message.Body.GetDictionary("mapField");
+							Assert.IsNotNull(nestedMapResponse, "Nested map not returned.");
+							Assert.AreEqual(nestedMap.Count, nestedMapResponse.Count, "nestedMap: Wrong number of elements");
+							Assert.AreEqual("foo", nestedMapResponse["a"], "nestedMap: a");
+							Assert.AreEqual(23, nestedMapResponse["b"], "nestedMap: b");
+							Assert.AreEqual(45, nestedMapResponse["c"], "nestedMap: c");
+
+							IDictionary grandChildMapResponse = nestedMapResponse["d"] as IDictionary;
+							Assert.IsNotNull(grandChildMapResponse, "Grand child map not returned.");
+							Assert.AreEqual(grandChildMap.Count, grandChildMapResponse.Count, "grandChildMap: Wrong number of elements");
+							Assert.AreEqual(grandChildMapResponse["x"], "abc", "grandChildMap: x");
+
+							IList grandChildList = grandChildMapResponse["y"] as IList;
+							Assert.IsNotNull(grandChildList, "Grand child list not returned.");
+							Assert.AreEqual(3, grandChildList.Count, "grandChildList: Wrong number of list elements.");
+							Assert.AreEqual("a", grandChildList[0], "grandChildList: a");
+							Assert.AreEqual("b", grandChildList[1], "grandChildList: b");
+							Assert.AreEqual("c", grandChildList[2], "grandChildList: c");
+
+							IList listFieldResponse = message.Body.GetList("listField");
+							Assert.IsNotNull(listFieldResponse, "Nested list not returned.");
+							Assert.AreEqual(3, listFieldResponse.Count, "listFieldResponse: Wrong number of list elements.");
+							Assert.AreEqual("a", listFieldResponse[0], "listFieldResponse: a");
+							Assert.AreEqual("b", listFieldResponse[1], "listFieldResponse: b");
+							Assert.AreEqual("c", listFieldResponse[2], "listFieldResponse: c");
+						}
+						catch(NotSupportedException)
+						{
+						}
+						catch(NMSException e)
+						{
+							Assert.IsTrue(e.InnerException.GetType() == typeof(NotSupportedException));
+						}
+					}
+				}
+			}
+		}
+	}
+}

http://git-wip-us.apache.org/repos/asf/activemq-nms-xms/blob/653d676d/src/test/csharp/MessageSelectorTest.cs
----------------------------------------------------------------------
diff --git a/src/test/csharp/MessageSelectorTest.cs b/src/test/csharp/MessageSelectorTest.cs
new file mode 100644
index 0000000..03f0a4e
--- /dev/null
+++ b/src/test/csharp/MessageSelectorTest.cs
@@ -0,0 +1,184 @@
+/*
+ * 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 System;
+using System.Threading;
+using Apache.NMS.Util;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	//[TestFixture]
+	//[Category("LongRunning")]
+	public class MessageSelectorTest : NMSTest
+	{
+		private int receivedNonIgnoredMsgCount = 0;
+		private int receivedIgnoredMsgCount = 0;
+		private bool simulateSlowConsumer = false;
+
+		protected MessageSelectorTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+		//[Test]
+		public virtual void TestFilterIgnoredMessages(
+			//[Values(SELECTOR_TEST_QUEUE_URI, SELECTOR_TEST_TOPIC_URI)]
+			string testDestinationURI)
+		{
+			simulateSlowConsumer = false;
+			RunFilterIgnoredMessagesTest(testDestinationURI);
+		}
+
+		/// <summary>
+		/// A slow consumer will trigger the producer flow control on the broker when the destination is
+		/// a queue.  It will also trigger the consumer flow control by slowing down the feed to all of the
+		/// consumers on the queue to only send messages as fast as the slowest consumer can run.
+		/// When sending to a topic, the producer will not be slowed down, and consumers will be allowed
+		/// to run as fast as they can go.
+		/// Since this test can take a long time to run, it is marked as explicit.
+		/// </summary>
+		/// <param name="testDestinationURI"></param>
+		//[Test]
+		public virtual void TestFilterIgnoredMessagesSlowConsumer(
+			//[Values(SELECTOR_TEST_QUEUE_URI, SELECTOR_TEST_TOPIC_URI)]
+			string testDestinationURI)
+		{
+			simulateSlowConsumer = true;
+			RunFilterIgnoredMessagesTest(testDestinationURI);
+		}
+
+		public void RunFilterIgnoredMessagesTest(string testDestinationURI)
+		{
+			TimeSpan ttl = TimeSpan.FromMinutes(30);
+			const int MaxNumRequests = 100000;
+
+			using(IConnection connection1 = CreateConnection(GetTestClientId()))
+			using(IConnection connection2 = CreateConnection(GetTestClientId()))
+			using(IConnection connection3 = CreateConnection(GetTestClientId()))
+			{
+				connection1.Start();
+				connection2.Start();
+				connection3.Start();
+				using(ISession session1 = connection1.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				using(ISession session2 = connection2.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				using(ISession session3 = connection3.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination1 = GetClearDestination(session1, testDestinationURI);
+					IDestination destination2 = GetClearDestination(session2, testDestinationURI);
+					IDestination destination3 = GetClearDestination(session3, testDestinationURI);
+
+					using(IMessageProducer producer = session1.CreateProducer(destination1))
+					using(IMessageConsumer consumer1 = session2.CreateConsumer(destination2, "JMSType NOT LIKE '%IGNORE'"))
+					{
+						int numNonIgnoredMsgsSent = 0;
+						int numIgnoredMsgsSent = 0;
+
+						producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
+
+						receivedNonIgnoredMsgCount = 0;
+						receivedIgnoredMsgCount = 0;
+						consumer1.Listener += new MessageListener(OnNonIgnoredMessage);
+						IMessageConsumer consumer2 = null;
+
+						for(int index = 1; index <= MaxNumRequests; index++)
+						{
+							IMessage request = session1.CreateTextMessage(String.Format("Hello World! [{0} of {1}]", index, MaxNumRequests));
+
+							request.NMSTimeToLive = ttl;
+							if(0 == (index % 2))
+							{
+								request.NMSType = "ACTIVE";
+								numNonIgnoredMsgsSent++;
+							}
+							else
+							{
+								request.NMSType = "ACTIVE.IGNORE";
+								numIgnoredMsgsSent++;
+							}
+
+							producer.Send(request);
+
+							if(2000 == index)
+							{
+								// Start the second consumer
+								if(destination3.IsTopic)
+								{
+									// Reset the ignored message sent count, since all previous messages
+									// will not have been consumed on a topic.
+									numIgnoredMsgsSent = 0;
+								}
+
+								consumer2 = session3.CreateConsumer(destination3, "JMSType LIKE '%IGNORE'");
+								consumer2.Listener += new MessageListener(OnIgnoredMessage);
+							}
+						}
+
+						// Create a waiting loop that will coordinate the end of the test.  It checks
+						// to see that all intended messages were received.  It will continue to wait as
+						// long as new messages are being received.  If it stops receiving messages before
+						// it receives everything it expects, it will eventually timeout and the test will fail.
+						int waitCount = 0;
+						int lastReceivedINongnoredMsgCount = receivedNonIgnoredMsgCount;
+						int lastReceivedIgnoredMsgCount = receivedIgnoredMsgCount;
+
+						while(receivedNonIgnoredMsgCount < numNonIgnoredMsgsSent
+								|| receivedIgnoredMsgCount < numIgnoredMsgsSent)
+						{
+							if(lastReceivedINongnoredMsgCount != receivedNonIgnoredMsgCount
+								|| lastReceivedIgnoredMsgCount != receivedIgnoredMsgCount)
+							{
+								// Reset the wait count.
+								waitCount = 0;
+							}
+							else
+							{
+								waitCount++;
+							}
+
+							lastReceivedINongnoredMsgCount = receivedNonIgnoredMsgCount;
+							lastReceivedIgnoredMsgCount = receivedIgnoredMsgCount;
+
+							Assert.IsTrue(waitCount <= 30, String.Format("Timeout waiting for all messages to be delivered. Only {0} of {1} non-ignored messages delivered.  Only {2} of {3} ignored messages delivered.",
+								receivedNonIgnoredMsgCount, numNonIgnoredMsgsSent, receivedIgnoredMsgCount, numIgnoredMsgsSent));
+							Thread.Sleep(1000);
+						}
+
+						consumer2.Dispose();
+					}
+				}
+			}
+		}
+
+		protected void OnNonIgnoredMessage(IMessage message)
+		{
+			receivedNonIgnoredMsgCount++;
+			Assert.AreEqual(message.NMSType, "ACTIVE");
+		}
+
+		protected void OnIgnoredMessage(IMessage message)
+		{
+			receivedIgnoredMsgCount++;
+			Assert.AreEqual(message.NMSType, "ACTIVE.IGNORE");
+			if(simulateSlowConsumer)
+			{
+				// Simulate a slow consumer  It doesn't have to be too slow in a high speed environment
+				// in order to trigger producer flow control.
+				Thread.Sleep(10);
+			}
+		}
+	}
+}

http://git-wip-us.apache.org/repos/asf/activemq-nms-xms/blob/653d676d/src/test/csharp/MessageTest.cs
----------------------------------------------------------------------
diff --git a/src/test/csharp/MessageTest.cs b/src/test/csharp/MessageTest.cs
new file mode 100644
index 0000000..228ed98
--- /dev/null
+++ b/src/test/csharp/MessageTest.cs
@@ -0,0 +1,147 @@
+/*
+ * 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 System;
+using Apache.NMS.Util;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	//[TestFixture]
+	public class MessageTest : NMSTest
+	{
+		protected bool		a = true;
+		protected byte		b = 123;
+		protected char		c = 'c';
+		protected short		d = 0x1234;
+		protected int		e = 0x12345678;
+		protected long		f = 0x1234567812345678;
+		protected string	g = "Hello World!";
+		protected bool		h = false;
+		protected byte		i = 0xFF;
+		protected short		j = -0x1234;
+		protected int		k = -0x12345678;
+		protected long		l = -0x1234567812345678;
+		protected float		m = 2.1F;
+		protected double	n = 2.3;
+		protected byte[]    o = {1, 2, 3, 4, 5};
+
+		protected MessageTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+		//[Test]
+		public virtual void TestSendReceiveMessageProperties(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.DeliveryMode = deliveryMode;
+						IMessage request = session.CreateMessage();
+						request.Properties["a"] = a;
+						request.Properties["b"] = b;
+						request.Properties["c"] = c;
+						request.Properties["d"] = d;
+						request.Properties["e"] = e;
+						request.Properties["f"] = f;
+						request.Properties["g"] = g;
+						request.Properties["h"] = h;
+						request.Properties["i"] = i;
+						request.Properties["j"] = j;
+						request.Properties["k"] = k;
+						request.Properties["l"] = l;
+						request.Properties["m"] = m;
+						request.Properties["n"] = n;
+						
+						try
+						{
+							request.Properties["o"] = o;
+							Assert.Fail("Should not be able to add a Byte[] to the Properties of a Message.");
+						}
+						catch
+						{
+							// Expected
+						}
+						
+						try
+						{
+							request.Properties.SetBytes("o", o);
+							Assert.Fail("Should not be able to add a Byte[] to the Properties of a Message.");
+						}
+						catch
+						{
+							// Expected
+						}						
+						
+						producer.Send(request);
+
+						IMessage message = consumer.Receive(receiveTimeout);
+						Assert.IsNotNull(message, "No message returned!");
+						Assert.AreEqual(request.Properties.Count, message.Properties.Count, "Invalid number of properties.");
+						Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+						Assert.AreEqual(ToHex(f), ToHex(message.Properties.GetLong("f")), "map entry: f as hex");
+
+						// use generic API to access entries
+						// Perform a string only comparison here since some NMS providers are type limited and
+						// may return only a string instance from the generic [] accessor.  Each provider should
+						// further test this functionality to determine that the correct type is returned if
+						// it is capable of doing so.
+						Assert.AreEqual(a.ToString(), message.Properties["a"].ToString(), "generic map entry: a");
+						Assert.AreEqual(b.ToString(), message.Properties["b"].ToString(), "generic map entry: b");
+						Assert.AreEqual(c.ToString(), message.Properties["c"].ToString(), "generic map entry: c");
+						Assert.AreEqual(d.ToString(), message.Properties["d"].ToString(), "generic map entry: d");
+						Assert.AreEqual(e.ToString(), message.Properties["e"].ToString(), "generic map entry: e");
+						Assert.AreEqual(f.ToString(), message.Properties["f"].ToString(), "generic map entry: f");
+						Assert.AreEqual(g.ToString(), message.Properties["g"].ToString(), "generic map entry: g");
+						Assert.AreEqual(h.ToString(), message.Properties["h"].ToString(), "generic map entry: h");
+						Assert.AreEqual(i.ToString(), message.Properties["i"].ToString(), "generic map entry: i");
+						Assert.AreEqual(j.ToString(), message.Properties["j"].ToString(), "generic map entry: j");
+						Assert.AreEqual(k.ToString(), message.Properties["k"].ToString(), "generic map entry: k");
+						Assert.AreEqual(l.ToString(), message.Properties["l"].ToString(), "generic map entry: l");
+						Assert.AreEqual(m.ToString(), message.Properties["m"].ToString(), "generic map entry: m");
+						Assert.AreEqual(n.ToString(), message.Properties["n"].ToString(), "generic map entry: n");
+
+						// use type safe APIs
+						Assert.AreEqual(a, message.Properties.GetBool("a"),   "map entry: a");
+						Assert.AreEqual(b, message.Properties.GetByte("b"),   "map entry: b");
+						Assert.AreEqual(c, message.Properties.GetChar("c"),   "map entry: c");
+						Assert.AreEqual(d, message.Properties.GetShort("d"),  "map entry: d");
+						Assert.AreEqual(e, message.Properties.GetInt("e"),    "map entry: e");
+						Assert.AreEqual(f, message.Properties.GetLong("f"),   "map entry: f");
+						Assert.AreEqual(g, message.Properties.GetString("g"), "map entry: g");
+						Assert.AreEqual(h, message.Properties.GetBool("h"),   "map entry: h");
+						Assert.AreEqual(i, message.Properties.GetByte("i"),   "map entry: i");
+						Assert.AreEqual(j, message.Properties.GetShort("j"),  "map entry: j");
+						Assert.AreEqual(k, message.Properties.GetInt("k"),    "map entry: k");
+						Assert.AreEqual(l, message.Properties.GetLong("l"),   "map entry: l");
+						Assert.AreEqual(m, message.Properties.GetFloat("m"),  "map entry: m");
+						Assert.AreEqual(n, message.Properties.GetDouble("n"), "map entry: n");
+					}
+				}
+			}
+		}
+	}
+}
+

http://git-wip-us.apache.org/repos/asf/activemq-nms-xms/blob/653d676d/src/test/csharp/MessageTransformerTest.cs
----------------------------------------------------------------------
diff --git a/src/test/csharp/MessageTransformerTest.cs b/src/test/csharp/MessageTransformerTest.cs
new file mode 100644
index 0000000..f2d5b12
--- /dev/null
+++ b/src/test/csharp/MessageTransformerTest.cs
@@ -0,0 +1,124 @@
+/*
+ * 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 System;
+using Apache.NMS.Util;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	//[TestFixture]
+	public class MessageTransformerTest : NMSTest
+	{
+		private string propertyName = "ADDITIONAL-PROPERTY";
+		private string propertyValue = "ADDITIONAL-PROPERTY-VALUE";
+
+		protected MessageTransformerTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+		//[Test]
+		public virtual void TestProducerTransformer(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode)
+		{
+			using(IConnection connection = CreateConnection())
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination = session.CreateTemporaryTopic();
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.DeliveryMode = deliveryMode;
+						producer.ProducerTransformer = DoProducerTransform;
+
+                        IMessage message = session.CreateMessage();
+
+                        message.Properties["Test"] = "Value";
+
+                        producer.Send(message);
+
+                        message = consumer.Receive(TimeSpan.FromMilliseconds(5000));
+
+                        Assert.IsNotNull(message);
+                        Assert.IsTrue(message.Properties.Count == 2);
+
+                        Assert.AreEqual("Value", message.Properties["Test"]);
+                        Assert.AreEqual(propertyValue, message.Properties[propertyName]);
+					}
+				}
+			}
+		}
+		
+		//[Test]
+		public virtual void TestConsumerTransformer(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode)
+		{
+			using(IConnection connection = CreateConnection())
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination = session.CreateTemporaryTopic();
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.DeliveryMode = deliveryMode;
+
+						consumer.ConsumerTransformer = DoConsumerTransform;
+
+                        IMessage message = session.CreateMessage();
+
+                        message.Properties["Test"] = "Value";
+
+                        producer.Send(message);
+
+                        message = consumer.Receive(TimeSpan.FromMilliseconds(5000));
+
+                        Assert.IsNotNull(message);
+                        Assert.IsTrue(message.Properties.Count == 2, "Property Count should be 2");
+
+                        Assert.AreEqual("Value", message.Properties["Test"], "Property 'Value' was incorrect");
+                        Assert.AreEqual(propertyValue, message.Properties[propertyName], "Property not inserted");
+                    }
+				}
+			}
+		}
+		
+		private IMessage DoProducerTransform(ISession session, IMessageProducer producer, IMessage message)
+		{
+			message.Properties[propertyName] = propertyValue;
+			
+			return message;
+		}
+
+		private IMessage DoConsumerTransform(ISession session, IMessageConsumer consumer, IMessage message)
+		{
+            IMessage newMessage = session.CreateMessage();
+
+            MessageTransformation.CopyNMSMessageProperties(message, newMessage);
+
+			newMessage.Properties[propertyName] = propertyValue;
+
+			return newMessage;
+		}
+	}
+}
+

http://git-wip-us.apache.org/repos/asf/activemq-nms-xms/blob/653d676d/src/test/csharp/NMSPropertyTest.cs
----------------------------------------------------------------------
diff --git a/src/test/csharp/NMSPropertyTest.cs b/src/test/csharp/NMSPropertyTest.cs
new file mode 100644
index 0000000..82b1021
--- /dev/null
+++ b/src/test/csharp/NMSPropertyTest.cs
@@ -0,0 +1,82 @@
+/*
+ * 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 System;
+using Apache.NMS.Util;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	//[TestFixture]
+	public class NMSPropertyTest : NMSTest
+	{
+		// standard NMS properties
+		protected string expectedText = "Hey this works!";
+		protected string correlationID = "FooBar";
+		protected MsgPriority priority = MsgPriority.Normal;
+		protected String type = "FooType";
+		protected String groupID = "BarGroup";
+		protected int groupSeq = 1;
+
+		protected NMSPropertyTest(NMSTestSupport testSupport)
+			: base (testSupport)
+		{
+		}
+
+		//[Test]
+		public void TestSendReceiveNMSProperties(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.Priority = priority;
+						producer.DeliveryMode = deliveryMode;
+						ITextMessage request = session.CreateTextMessage(expectedText);
+
+						// Set the headers
+						request.NMSCorrelationID = correlationID;
+						request.NMSType = type;
+						request.Properties["NMSXGroupID"] = groupID;
+						request.Properties["NMSXGroupSeq"] = groupSeq;
+
+						producer.Send(request);
+
+						ITextMessage message = consumer.Receive(receiveTimeout) as ITextMessage;
+
+						Assert.IsNotNull(message, "Did not receive an ITextMessage!");
+						Assert.AreEqual(expectedText, message.Text, "Message text does not match.");
+
+						// compare standard NMS headers
+						Assert.AreEqual(correlationID, message.NMSCorrelationID, "NMSCorrelationID does not match");
+						Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+						Assert.AreEqual(priority, message.NMSPriority, "NMSPriority does not match");
+						Assert.AreEqual(type, message.NMSType, "NMSType does not match");
+						Assert.AreEqual(groupID, message.Properties["NMSXGroupID"], "NMSXGroupID does not match");
+						Assert.AreEqual(groupSeq, message.Properties["NMSXGroupSeq"], "NMSXGroupSeq does not match");
+					}
+				}
+			}
+		}
+	}
+}

http://git-wip-us.apache.org/repos/asf/activemq-nms-xms/blob/653d676d/src/test/csharp/NMSTest.cs
----------------------------------------------------------------------
diff --git a/src/test/csharp/NMSTest.cs b/src/test/csharp/NMSTest.cs
new file mode 100644
index 0000000..1069586
--- /dev/null
+++ b/src/test/csharp/NMSTest.cs
@@ -0,0 +1,508 @@
+/*
+ * 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 System;
+using System.Xml;
+using Apache.NMS.Util;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	/// <summary>
+	/// Base class for test cases
+	/// </summary>
+	public abstract class NMSTest
+	{
+		protected TimeSpan receiveTimeout = TimeSpan.FromMilliseconds(15000);
+
+		public static string ToHex(long value)
+		{
+			return String.Format("{0:x}", value);
+		}
+
+		#region Constructors and test support
+
+		private NMSTestSupport testSupport;
+
+		static NMSTest()
+		{
+			Apache.NMS.Tracer.Trace = new NMSTracer();
+		}
+
+		protected NMSTest(NMSTestSupport testSupport)
+		{
+			this.testSupport = testSupport;
+			this.testSupport.TestClassType = this.GetType();
+		}
+
+		#endregion
+
+		#region Set up and tear down
+
+		[SetUp]
+		public virtual void SetUp()
+		{
+			this.testSupport.SetUp();
+		}
+
+		[TearDown]
+		public virtual void TearDown()
+		{
+			this.testSupport.TearDown();
+		}
+
+		#endregion
+
+		#region Configuration file
+
+		/// <summary>
+		/// The configuration document.
+		/// </summary>
+		public XmlDocument ConfigurationDocument
+		{
+			get { return this.testSupport.ConfigurationDocument; }
+		}
+
+		/// <summary>
+		/// Loads the configuration file.
+		/// </summary>
+		/// <returns>XmlDocument of the configuration file</returns>
+		protected virtual XmlDocument LoadConfigFile()
+		{
+			return this.testSupport.LoadConfigFile();
+		}
+
+		/// <summary>
+		/// Loads the configuration file.
+		/// </summary>
+		/// <param name="configFilePath">Configuration file path</param>
+		/// <returns>XmlDocument of the configuration file</returns>
+		protected virtual XmlDocument LoadConfigFile(string configFilePath)
+		{
+			return this.testSupport.LoadConfigFile(configFilePath);
+		}
+
+		/// <summary>
+		/// Gets the path of the configuration filename.
+		/// </summary>
+		/// <returns>Path of the configuration filename</returns>
+		protected virtual string GetConfigFilePath()
+		{
+			return this.testSupport.GetConfigFilePath();
+		}
+
+		/// <summary>
+		/// Gets the environment variable name for the configuration file path.
+		/// </summary>
+		/// <returns>Environment variable name</returns>
+		protected virtual string GetConfigEnvVarName()
+		{
+			return this.testSupport.GetConfigEnvVarName();
+		}
+
+		/// <summary>
+		/// Gets the default name for the configuration filename.
+		/// </summary>
+		/// <returns>Default name of the configuration filename</returns>
+		protected virtual string GetDefaultConfigFileName()
+		{
+			return this.testSupport.GetDefaultConfigFileName();
+		}
+
+		/// <summary>
+		/// Gets the value of the "value" attribute of the specified node.
+		/// </summary>
+		/// <param name="parentNode">Parent node</param>
+		/// <param name="nodeName">Node name</param>
+		/// <param name="defaultVaue">Default value</param>
+		/// <returns></returns>
+		protected virtual string GetNodeValueAttribute(XmlElement parentNode,
+			string nodeName, string defaultVaue)
+		{
+			return this.testSupport.GetNodeValueAttribute(parentNode,
+				nodeName, defaultVaue);
+		}
+
+		#endregion
+
+		#region URI node
+
+		/// <summary>
+		/// Gets the URI node for the default configuration.
+		/// </summary>
+		/// <returns>URI node for the default configuration name</returns>
+		public virtual XmlElement GetURINode()
+		{
+			return this.testSupport.GetURINode();
+		}
+
+		/// <summary>
+		/// Gets the URI node for the default configuration.
+		/// </summary>
+		/// <param name="nameTestURI">Name of the default configuration node
+		/// </param>
+		/// <returns>URI node for the default configuration name</returns>
+		public virtual XmlElement GetURINode(string nameTestURI)
+		{
+			return this.testSupport.GetURINode(nameTestURI);
+		}
+
+		/// <summary>
+		/// Gets the name of the default connection configuration to be loaded.
+		/// </summary>
+		/// <returns>Default configuration name</returns>
+		protected virtual string GetNameTestURI()
+		{
+			return this.testSupport.GetNameTestURI();
+		}
+
+		#endregion
+
+		#region Factory
+
+		private NMSConnectionFactory nmsFactory;
+		/// <summary>
+		/// The connection factory interface property.
+		/// </summary>
+		public IConnectionFactory Factory
+		{
+			get { return this.testSupport.Factory; }
+		}
+
+		/// <summary>
+		/// Create the NMS Factory that can create NMS Connections.
+		/// </summary>
+		/// <returns>Connection factory</returns>
+		protected NMSConnectionFactory CreateNMSFactory()
+		{
+			return this.testSupport.CreateNMSFactory();
+		}
+
+		/// <summary>
+		/// Create the NMS Factory that can create NMS Connections. This
+		/// function loads the connection settings from the configuration file.
+		/// </summary>
+		/// <param name="nameTestURI">The named connection configuration.
+		/// </param>
+		/// <returns>Connection factory</returns>
+		protected NMSConnectionFactory CreateNMSFactory(string nameTestURI)
+		{
+			return this.testSupport.CreateNMSFactory(nameTestURI);
+		}
+
+		/// <summary>
+		/// Get the parameters for the ConnectionFactory from the configuration
+		/// file.
+		/// </summary>
+		/// <param name="uriNode">Parent node of the factoryParams node.</param>
+		/// <returns>Object array of parameter objects to be passsed to provider
+		/// factory object.  Null if no parameters are specified in
+		/// configuration file.</returns>
+		protected object[] GetFactoryParams(XmlElement uriNode)
+		{
+			return this.testSupport.GetFactoryParams(uriNode);
+		}
+
+		#endregion
+
+		#region Client id and connection
+
+		/// <summary>
+		/// Client id.
+		/// </summary>
+		public string ClientId
+		{
+			get { return this.testSupport.ClientId; }
+		}
+
+		/// <summary>
+		/// Gets a new client id.
+		/// </summary>
+		/// <returns>Client id</returns>
+		public virtual string GetTestClientId()
+		{
+			return this.testSupport.GetTestClientId();
+		}
+
+		/// <summary>
+		/// Create a new connection to the broker.
+		/// </summary>
+		/// <returns>New connection</returns>
+		public virtual IConnection CreateConnection()
+		{
+			return this.testSupport.CreateConnection();
+		}
+
+		/// <summary>
+		/// Create a new connection to the broker.
+		/// </summary>
+		/// <param name="newClientId">Client ID of the new connection.</param>
+		/// <returns>New connection</returns>
+		public virtual IConnection CreateConnection(string newClientId)
+		{
+			return this.testSupport.CreateConnection(newClientId);
+		}
+
+		/// <summary>
+		/// Create a new connection to the broker, and start it.
+		/// </summary>
+		/// <returns>Started connection</returns>
+		public virtual IConnection CreateConnectionAndStart()
+		{
+			return this.testSupport.CreateConnectionAndStart();
+		}
+
+		/// <summary>
+		/// Create a new connection to the broker, and start it.
+		/// </summary>
+		/// <param name="newClientId">Client ID of the new connection.</param>
+		/// <returns>Started connection</returns>
+		public virtual IConnection CreateConnectionAndStart(string newClientId)
+		{
+			return this.testSupport.CreateConnectionAndStart(newClientId);
+		}
+
+		#endregion
+
+		#region Destination
+
+		/// <summary>
+		/// Gets a clear destination.
+		/// </summary>
+		/// <param name="session">Session</param>
+		/// <param name="type">Destination type</param>
+		/// <param name="destinationRef">Configuration node name for the
+		/// destination URI</param>
+		/// <returns>Destination</returns>
+		public virtual IDestination GetClearDestination(ISession session,
+			DestinationType type, string destinationRef)
+		{
+			return this.testSupport.GetClearDestination(session, type, destinationRef);
+		}
+
+		/// <summary>
+		/// Gets a clear destination. This will try to delete an existing
+		/// destination and re-create it.
+		/// </summary>
+		/// <param name="session">Session</param>
+		/// <param name="destinationURI">Destination URI</param>
+		/// <returns>Clear destination</returns>
+		public virtual IDestination GetClearDestination(ISession session,
+			string destinationURI)
+		{
+			return this.testSupport.GetClearDestination(session, destinationURI);
+		}
+
+		/// <summary>
+		/// Gets an existing destination. Don't clear its contents.
+		/// </summary>
+		/// <param name="session">Session</param>
+		/// <param name="type">Destination type</param>
+		/// <param name="destinationRef">Configuration node name for the
+		/// destination URI</param>
+		/// <returns>Destination</returns>
+		public virtual IDestination GetDestination(ISession session,
+			DestinationType type, string destinationRef)
+		{
+			return this.testSupport.GetDestination(session, type, destinationRef);
+		}
+
+		/// <summary>
+		/// Gets a destination URI.
+		/// </summary>
+		/// <param name="type">Destination type</param>
+		/// <param name="destinationRef">Configuration node name for the
+		/// destination URI</param>
+		/// <returns>Destination URI</returns>
+		public virtual string GetDestinationURI(DestinationType type, string destinationRef)
+		{
+			return this.testSupport.GetDestinationURI(type, destinationRef);
+		}
+
+		#endregion
+
+		#region Durable consumer
+
+		/// <summary>
+		/// Register a durable consumer
+		/// </summary>
+		/// <param name="connectionID">Connection ID of the consumer.</param>
+		/// <param name="destination">Destination name to register.  Supports
+		/// embedded prefix names.</param>
+		/// <param name="consumerID">Name of the durable consumer.</param>
+		/// <param name="selector">Selector parameters for consumer.</param>
+		/// <param name="noLocal"></param>
+		protected void RegisterDurableConsumer(string connectionID,
+			string destination, string consumerID, string selector, bool noLocal)
+		{
+			using(IConnection connection = CreateConnection(connectionID))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(
+					AcknowledgementMode.DupsOkAcknowledge))
+				{
+					ITopic destinationTopic = (ITopic)SessionUtil.GetDestination(session, destination);
+					Assert.IsNotNull(destinationTopic, "Could not get destination topic.");
+
+					using(IMessageConsumer consumer = session.CreateDurableConsumer(destinationTopic, consumerID, selector, noLocal))
+					{
+						Assert.IsNotNull(consumer, "Could not create durable consumer.");
+					}
+				}
+			}
+		}
+
+		/// <summary>
+		/// Unregister a durable consumer for the given connection ID.
+		/// </summary>
+		/// <param name="connectionID">Connection ID of the consumer.</param>
+		/// <param name="consumerID">Name of the durable consumer.</param>
+		protected void UnregisterDurableConsumer(string connectionID, string consumerID)
+		{
+			using(IConnection connection = CreateConnection(connectionID))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.DupsOkAcknowledge))
+				{
+					session.DeleteDurableConsumer(consumerID);
+				}
+			}
+		}
+
+		#endregion
+
+		#region Send messages
+
+		/// <summary>
+		/// Sends a specified number of text messages to the designated
+		/// destination.
+		/// </summary>
+		/// <param name="destination">Destination.</param>
+		/// <param name="deliveryMode">Delivery mode.</param>
+		/// <param name="count">Number of messages to be sent.</param>
+		public void SendMessages(IDestination destination,
+			MsgDeliveryMode deliveryMode, int count)
+		{
+			IConnection connection = CreateConnection();
+			connection.Start();
+			SendMessages(connection, destination, deliveryMode, count);
+			connection.Close();
+		}
+
+		/// <summary>
+		/// Sends a specified number of text messages to the designated
+		/// destination.
+		/// </summary>
+		/// <param name="connection">Connection.</param>
+		/// <param name="destination">Destination.</param>
+		/// <param name="deliveryMode">Delivery mode.</param>
+		/// <param name="count">Number of messages to be sent.</param>
+		public void SendMessages(IConnection connection,
+			IDestination destination, MsgDeliveryMode deliveryMode, int count)
+		{
+			ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
+			SendMessages(session, destination, deliveryMode, count);
+			session.Close();
+		}
+
+		/// <summary>
+		/// Sends a specified number of text messages to the designated
+		/// destination.
+		/// </summary>
+		/// <param name="session">Session.</param>
+		/// <param name="destination">Destination.</param>
+		/// <param name="deliveryMode">Delivery mode.</param>
+		/// <param name="count">Number of messages to be sent.</param>
+		public void SendMessages(ISession session, IDestination destination,
+			MsgDeliveryMode deliveryMode, int count)
+		{
+			IMessageProducer producer = session.CreateProducer(destination);
+			producer.DeliveryMode = deliveryMode;
+			for(int i = 0; i < count; i++)
+			{
+				producer.Send(session.CreateTextMessage("" + i));
+			}
+			producer.Close();
+		}
+
+		#endregion
+
+		#region Check messages
+
+		protected void AssertTextMessagesEqual(IMessage[] firstSet, IMessage[] secondSet)
+		{
+			AssertTextMessagesEqual(firstSet, secondSet, "");
+		}
+
+		protected void AssertTextMessagesEqual(IMessage[] firstSet, IMessage[] secondSet, string messsage)
+		{
+			Assert.AreEqual(firstSet.Length, secondSet.Length, "Message count does not match: " + messsage);
+
+			for(int i = 0; i < secondSet.Length; i++)
+			{
+				ITextMessage m1 = firstSet[i] as ITextMessage;
+				ITextMessage m2 = secondSet[i] as ITextMessage;
+
+				AssertTextMessageEqual(m1, m2, "Message " + (i + 1) + " did not match : ");
+			}
+		}
+
+		protected void AssertEquals(ITextMessage m1, ITextMessage m2)
+		{
+			AssertEquals(m1, m2, "");
+		}
+
+		protected void AssertTextMessageEqual(ITextMessage m1, ITextMessage m2, string message)
+		{
+			Assert.IsFalse(m1 == null ^ m2 == null, message + ": expected {" + m1 + "}, but was {" + m2 + "}");
+
+			if(m1 == null)
+			{
+				return;
+			}
+
+			Assert.AreEqual(m1.Text, m2.Text, message);
+		}
+
+		protected void AssertEquals(IMessage m1, IMessage m2)
+		{
+			AssertEquals(m1, m2, "");
+		}
+
+		protected void AssertEquals(IMessage m1, IMessage m2, string message)
+		{
+			Assert.IsFalse(m1 == null ^ m2 == null, message + ": expected {" + m1 + "}, but was {" + m2 + "}");
+
+			if(m1 == null)
+			{
+				return;
+			}
+
+			Assert.IsTrue(m1.GetType() == m2.GetType(), message + ": expected {" + m1 + "}, but was {" + m2 + "}");
+
+			if(m1 is ITextMessage)
+			{
+				AssertTextMessageEqual((ITextMessage) m1, (ITextMessage) m2, message);
+			}
+			else
+			{
+				Assert.AreEqual(m1, m2, message);
+			}
+		}
+
+		#endregion
+	}
+}


Mime
View raw message