activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jgo...@apache.org
Subject svn commit: r1723221 [10/11] - in /activemq/activemq-dotnet/Apache.NMS.XMS/trunk: ./ keyfile/ src/ src/main/ src/main/csharp/ src/main/csharp/Util/ src/main/ndoc/ src/main/sandcastle/ src/test/ src/test/csharp/ src/test/csharp/Commands/
Date Wed, 06 Jan 2016 02:19:57 GMT
Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/NMSTestSupport.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/NMSTestSupport.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/NMSTestSupport.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/NMSTestSupport.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,651 @@
+/*
+ * 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 System.IO;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using System.Xml;
+using Apache.NMS.Util;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	/// <summary>
+	/// Useful class for test cases support.
+	/// </summary>
+	public class NMSTestSupport
+	{
+		protected TimeSpan receiveTimeout = TimeSpan.FromMilliseconds(15000);
+		protected int testRun;
+		protected int idCounter;
+
+        protected Type testClassType;
+		public Type TestClassType
+		{
+			get { return this.testClassType; }
+			set { this.testClassType = value; }
+		}
+
+		#region Constructors
+
+		public NMSTestSupport()
+		{
+		}
+
+		#endregion
+
+		#region Set up and tear down
+
+		public virtual void SetUp()
+		{
+			this.testRun++;
+		}
+
+		public virtual void TearDown()
+		{
+		}
+
+		#endregion
+
+		#region Configuration file
+
+		private XmlDocument configurationDocument = null;
+		/// <summary>
+		/// The configuration document.
+		/// </summary>
+		public XmlDocument ConfigurationDocument
+		{
+			get
+			{
+				if(this.configurationDocument == null)
+				{
+					this.configurationDocument = LoadConfigFile();
+					Assert.IsTrue(this.configurationDocument != null,
+						"Error loading configuration.");
+				}
+
+				return this.configurationDocument;
+			}
+		}
+
+		/// <summary>
+		/// Loads the configuration file.
+		/// </summary>
+		/// <returns>XmlDocument of the configuration file</returns>
+		public virtual XmlDocument LoadConfigFile()
+		{
+			return LoadConfigFile(GetConfigFilePath());
+		}
+
+		/// <summary>
+		/// Loads the configuration file.
+		/// </summary>
+		/// <param name="configFilePath">Configuration file path</param>
+		/// <returns>XmlDocument of the configuration file</returns>
+		public virtual XmlDocument LoadConfigFile(string configFilePath)
+		{
+			XmlDocument configDoc = new XmlDocument();
+
+			configDoc.Load(configFilePath);
+
+			return configDoc;
+		}
+
+		/// <summary>
+		/// Gets the path of the configuration filename.
+		/// </summary>
+		/// <returns>Path of the configuration filename</returns>
+		public virtual string GetConfigFilePath()
+		{
+			// The full path may be specified by an environment variable
+			string configFilePath = GetEnvVar(GetConfigEnvVarName(), "");
+			bool configFound = (!string.IsNullOrEmpty(configFilePath)
+				&& File.Exists(configFilePath));
+
+			// Else it may be found in well known locations
+			if(!configFound)
+			{
+				string[] paths = GetConfigSearchPaths();
+				string configFileName = GetDefaultConfigFileName();
+
+				foreach(string path in paths)
+				{
+					string fullpath = Path.Combine(path, configFileName);
+					Tracer.Debug("\tScanning folder: " + path);
+
+					if(File.Exists(fullpath))
+					{
+						Tracer.Debug("\tAssembly found!");
+						configFilePath = fullpath;
+						configFound = true;
+						break;
+					}
+				}
+			}
+
+			Tracer.Debug("\tConfig file: " + configFilePath);
+			Assert.IsTrue(configFound, "Connection configuration file does not exist.");
+			return configFilePath;
+		}
+
+		/// <summary>
+		/// Gets the environment variable name for the configuration file path.
+		/// </summary>
+		/// <returns>Environment variable name</returns>
+		public virtual string GetConfigEnvVarName()
+		{
+			return "NMSTESTCONFIGPATH";
+		}
+
+		/// <summary>
+		/// Gets the default name for the configuration filename.
+		/// </summary>
+		/// <returns>Default name of the configuration filename</returns>
+		public virtual string GetDefaultConfigFileName()
+		{
+			return "nmsprovider-test.config";
+		}
+
+		/// <summary>
+		/// Gets an array of paths where the configuration file sould be found.
+		/// </summary>
+		/// <returns>Array of paths</returns>
+		private static string[] GetConfigSearchPaths()
+		{
+			ArrayList pathList = new ArrayList();
+
+			// Check the current folder first.
+			pathList.Add("");
+#if !NETCF
+			AppDomain currentDomain = AppDomain.CurrentDomain;
+
+			// Check the folder the assembly is located in.
+			pathList.Add(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
+			if(null != currentDomain.BaseDirectory)
+			{
+				pathList.Add(currentDomain.BaseDirectory);
+			}
+
+			if(null != currentDomain.RelativeSearchPath)
+			{
+				pathList.Add(currentDomain.RelativeSearchPath);
+			}
+#endif
+
+			return (string[]) pathList.ToArray(typeof(string));
+		}
+
+		/// <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>
+		public string GetNodeValueAttribute(XmlElement parentNode,
+			string nodeName, string defaultVaue)
+		{
+			XmlElement node = (XmlElement)parentNode.SelectSingleNode(nodeName);
+
+			return (node == null ? defaultVaue : node.GetAttribute("value"));
+		}
+
+		#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 GetURINode(GetNameTestURI());
+		}
+
+		/// <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 (XmlElement)ConfigurationDocument.SelectSingleNode(
+				String.Format("/configuration/{0}", nameTestURI));
+		}
+
+		/// <summary>
+		/// Gets the name of the default connection configuration to be loaded.
+		/// </summary>
+		/// <returns>Default configuration name</returns>
+		public virtual string GetNameTestURI()
+		{
+			return "testURI";
+		}
+
+		#endregion
+
+		#region Factory
+
+		private NMSConnectionFactory nmsFactory;
+		/// <summary>
+		/// The connection factory interface property.
+		/// </summary>
+		public IConnectionFactory Factory
+		{
+			get
+			{
+				if(this.nmsFactory == null)
+				{
+					this.nmsFactory = CreateNMSFactory();
+
+					Assert.IsNotNull(this.nmsFactory, "Error creating factory.");
+				}
+
+				return this.nmsFactory.ConnectionFactory;
+			}
+		}
+
+		/// <summary>
+		/// Create the NMS Factory that can create NMS Connections.
+		/// </summary>
+		/// <returns>Connection factory</returns>
+		public NMSConnectionFactory CreateNMSFactory()
+		{
+			return CreateNMSFactory(GetNameTestURI());
+		}
+
+		/// <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>
+		public NMSConnectionFactory CreateNMSFactory(string nameTestURI)
+		{
+			XmlElement uriNode = GetURINode(nameTestURI);
+
+			Uri brokerUri = null;
+			object[] factoryParams = null;
+			if(uriNode != null)
+			{
+				// Replace any environment variables embedded inside the string.
+				brokerUri = new Uri(uriNode.GetAttribute("value"));
+				factoryParams = GetFactoryParams(uriNode);
+				clientId = GetNodeValueAttribute(uriNode, "clientId", "NMSTestClientId");
+				userName = GetNodeValueAttribute(uriNode, "userName", null);
+				passWord = GetNodeValueAttribute(uriNode, "passWord", null);
+			}
+
+			if(factoryParams == null)
+			{
+				this.nmsFactory = new Apache.NMS.NMSConnectionFactory(brokerUri);
+			}
+			else
+			{
+				this.nmsFactory = new Apache.NMS.NMSConnectionFactory(brokerUri, factoryParams);
+			}
+
+			return this.nmsFactory;
+		}
+
+		/// <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>
+		public object[] GetFactoryParams(XmlElement uriNode)
+		{
+			ArrayList factoryParams = new ArrayList();
+			XmlElement factoryParamsNode = (XmlElement)uriNode.SelectSingleNode("factoryParams");
+
+			if(factoryParamsNode != null)
+			{
+				XmlNodeList nodeList = factoryParamsNode.SelectNodes("param");
+
+				if(nodeList != null)
+				{
+					foreach(XmlElement paramNode in nodeList)
+					{
+						string paramType = paramNode.GetAttribute("type");
+						string paramValue = paramNode.GetAttribute("value");
+
+						switch(paramType)
+						{
+							case "string":
+								factoryParams.Add(paramValue);
+								break;
+
+							case "int":
+								factoryParams.Add(int.Parse(paramValue));
+								break;
+
+							// TODO: Add more parameter types
+						}
+					}
+				}
+			}
+
+			if(factoryParams.Count > 0)
+			{
+				return factoryParams.ToArray();
+			}
+
+			return null;
+		}
+
+		#endregion
+
+		#region Environment variables
+
+		/// <summary>
+		/// Get environment variable value.
+		/// </summary>
+		/// <param name="varName"></param>
+		/// <param name="defaultValue"></param>
+		/// <returns></returns>
+		public static string GetEnvVar(string varName, string defaultValue)
+		{
+#if (PocketPC||NETCF||NETCF_2_0)
+            string varValue = null;
+#else
+			string varValue = Environment.GetEnvironmentVariable(varName);
+#endif
+			if(null == varValue)
+			{
+				varValue = defaultValue;
+			}
+
+			return varValue;
+		}
+
+		#endregion
+
+		#region Client id and connection
+
+		protected string clientId;
+		/// <summary>
+		/// Client id.
+		/// </summary>
+		public string ClientId
+		{
+			get { return this.clientId; }
+		}
+
+		/// <summary>
+		/// Gets a new client id.
+		/// </summary>
+		/// <returns>Client id</returns>
+		public virtual string GetTestClientId()
+		{
+			System.Text.StringBuilder id = new System.Text.StringBuilder();
+
+			id.Append("ID:");
+			id.Append(this.GetType().Name);
+			id.Append(":");
+			id.Append(this.testRun);
+			id.Append(":");
+			id.Append(++idCounter);
+
+			return id.ToString();
+		}
+
+		protected string userName;
+		/// <summary>
+		/// User name.
+		/// </summary>
+		public string UserName
+		{
+			get { return this.userName; }
+		}
+
+		protected string passWord;
+		/// <summary>
+		/// User pass word.
+		/// </summary>
+		public string PassWord
+		{
+			get { return this.passWord; }
+		}
+
+		/// <summary>
+		/// Create a new connection to the broker.
+		/// </summary>
+		/// <returns>New connection</returns>
+		public virtual IConnection CreateConnection()
+		{
+			return CreateConnection(null);
+		}
+
+		/// <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)
+		{
+			IConnection newConnection;
+
+			if(this.userName == null)
+			{
+				newConnection = Factory.CreateConnection();
+			}
+			else
+			{
+				newConnection = Factory.CreateConnection(userName, passWord);
+			}
+
+			Assert.IsNotNull(newConnection, "Connection not created");
+
+			if(newClientId != null)
+			{
+				newConnection.ClientId = newClientId;
+			}
+
+			return newConnection;
+		}
+
+		/// <summary>
+		/// Create a new connection to the broker, and start it.
+		/// </summary>
+		/// <returns>Started connection</returns>
+		public virtual IConnection CreateConnectionAndStart()
+		{
+			return CreateConnectionAndStart(null);
+		}
+
+		/// <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)
+		{
+			IConnection newConnection = CreateConnection(newClientId);
+			newConnection.Start();
+			return newConnection;
+		}
+
+		#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)
+		{
+			string uri = GetDestinationURI(type, destinationRef);
+
+			return GetClearDestination(session, uri);
+		}
+
+		/// <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)
+		{
+			IDestination destination;
+
+			try
+			{
+				DeleteDestination(session, destinationURI);
+				destination = CreateDestination(session, destinationURI);
+			}
+			catch(Exception)
+			{
+				// Can't delete it, so lets try and purge it.
+				destination = SessionUtil.GetDestination(session, destinationURI);
+
+				using(IMessageConsumer consumer = session.CreateConsumer(destination))
+				{
+					while(consumer.Receive(TimeSpan.FromMilliseconds(750)) != null)
+					{
+					}
+				}
+			}
+
+			return destination;
+		}
+
+		/// <summary>
+		/// Deletes a destination.
+		/// </summary>
+		/// <param name="session">Session</param>
+		/// <param name="destinationURI">Destination URI</param>
+		protected virtual void DeleteDestination(ISession session,
+			string destinationURI)
+		{
+			// Only delete the destination if it can be recreated
+			// SessionUtil.DeleteDestination(session, destinationURI, DestinationType.Queue)
+			throw new NotSupportedException();
+		}
+
+		/// <summary>
+		/// Creates a destination.
+		/// </summary>
+		/// <param name="session">Session</param>
+		/// <param name="destinationURI">Destination URI</param>
+		protected virtual IDestination CreateDestination(ISession session,
+			string destinationURI)
+		{
+			throw new NotSupportedException();
+		}
+
+		/// <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)
+		{
+			string uri = GetDestinationURI(type, destinationRef);
+
+			IDestination destination = SessionUtil.GetDestination(session, uri);
+
+			return destination;
+		}
+
+		/// <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)
+		{
+			string uri = null;
+
+			if(!string.IsNullOrEmpty(destinationRef))
+			{
+				XmlElement uriNode = GetURINode();
+
+				if(uriNode != null)
+				{
+					uri = GetNodeValueAttribute(uriNode, destinationRef, null);
+				}
+			}
+
+			if(string.IsNullOrEmpty(uri))
+			{
+				uri = NewDestinationURI(type);
+			}
+
+			return uri;
+		}
+
+		/// <summary>
+		/// Gets a new destination URI.
+		/// </summary>
+		/// <param name="type">Destination type</param>
+		/// <returns>Destination URI</returns>
+		public virtual string NewDestinationURI(DestinationType type)
+		{
+			string name = "TEST." + this.TestClassType.Name
+						+ "." + Guid.NewGuid().ToString();
+			string scheme;
+			switch(type)
+			{
+				case DestinationType.Queue:
+					scheme = "queue://";
+					break;
+
+				case DestinationType.Topic:
+					scheme = "topic://";
+					break;
+
+				case DestinationType.TemporaryQueue:
+					scheme = "temp-queue://";
+					break;
+
+				case DestinationType.TemporaryTopic:
+					scheme = "temp-topic://";
+					break;
+
+				default:
+					throw new ArgumentException("type: " + type);
+			}
+
+			return scheme + name;
+		}
+
+		#endregion
+	}
+}

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/NMSTracer.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/NMSTracer.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/NMSTracer.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/NMSTracer.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,87 @@
+/*
+ * 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.
+ */
+
+#define TRACE	// Force tracing to be enabled for this class
+
+namespace Apache.NMS.Test
+{
+	public class NMSTracer : Apache.NMS.ITrace
+	{
+		#region ITrace Members
+		public void Debug(string message)
+		{
+#if !NETCF
+			System.Diagnostics.Trace.WriteLine(string.Format("DEBUG: {0}", message));
+#endif
+		}
+
+		public void Error(string message)
+		{
+#if !NETCF
+			System.Diagnostics.Trace.WriteLine(string.Format("ERROR: {0}", message));
+#endif
+		}
+
+		public void Fatal(string message)
+		{
+#if !NETCF
+			System.Diagnostics.Trace.WriteLine(string.Format("FATAL: {0}", message));
+#endif
+		}
+
+		public void Info(string message)
+		{
+#if !NETCF
+			System.Diagnostics.Trace.WriteLine(string.Format("INFO: {0}", message));
+#endif
+		}
+
+		public void Warn(string message)
+		{
+#if !NETCF
+			System.Diagnostics.Trace.WriteLine(string.Format("WARN: {0}", message));
+#endif
+		}
+
+		public bool IsDebugEnabled
+		{
+			get { return true; }
+		}
+
+		public bool IsErrorEnabled
+		{
+			get { return true; }
+		}
+
+		public bool IsFatalEnabled
+		{
+			get { return true; }
+		}
+
+		public bool IsInfoEnabled
+		{
+			get { return true; }
+		}
+
+		public bool IsWarnEnabled
+		{
+			get { return true; }
+		}
+
+		#endregion
+	}
+}

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/PrimitiveMapTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/PrimitiveMapTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/PrimitiveMapTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/PrimitiveMapTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,170 @@
+/*
+ * 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 PrimitiveMapTest
+	{
+
+		bool a = true;
+		byte b = 123;
+		char c = 'c';
+		short d = 0x1234;
+		int e = 0x12345678;
+		long f = 0x1234567812345678;
+		string g = "Hello World!";
+		bool h = false;
+		byte i = 0xFF;
+		short j = -0x1234;
+		int k = -0x12345678;
+		long l = -0x1234567812345678;
+		IList m = CreateList();
+		IDictionary n = CreateDictionary();
+
+		[Test]
+		public void TestNotMarshalled()
+		{
+			PrimitiveMap map = CreatePrimitiveMap();
+			AssertPrimitiveMap(map);
+		}
+
+		[Test]
+		public void TestMarshalled()
+		{
+			PrimitiveMap map = CreatePrimitiveMap();
+			byte[] data = map.Marshal();
+			map = PrimitiveMap.Unmarshal(data);
+			AssertPrimitiveMap(map);
+		}
+
+		[Test]
+		public void TestMarshalledWithBigString()
+		{
+			PrimitiveMap map = CreatePrimitiveMap();
+			String test = new String('a', 65538);
+			map.SetString("BIG_STRING", test);
+			byte[] data = map.Marshal();
+			map = PrimitiveMap.Unmarshal(data);
+			AssertPrimitiveMap(map);
+			Assert.AreEqual(test, map.GetString("BIG_STRING"));
+		}
+
+		protected PrimitiveMap CreatePrimitiveMap()
+		{
+			PrimitiveMap map = new PrimitiveMap();
+
+			map["a"] = a;
+			map["b"] = b;
+			map["c"] = c;
+			map["d"] = d;
+			map["e"] = e;
+			map["f"] = f;
+			map["g"] = g;
+			map["h"] = h;
+			map["i"] = i;
+			map["j"] = j;
+			map["k"] = k;
+			map["l"] = l;
+			map["m"] = m;
+			map["n"] = n;
+
+			return map;
+		}
+
+		protected void AssertPrimitiveMap(PrimitiveMap map)
+		{
+			// use generic API to access entries
+			Assert.AreEqual(a, map["a"], "generic map entry: a");
+			Assert.AreEqual(b, map["b"], "generic map entry: b");
+			Assert.AreEqual(c, map["c"], "generic map entry: c");
+			Assert.AreEqual(d, map["d"], "generic map entry: d");
+			Assert.AreEqual(e, map["e"], "generic map entry: e");
+			Assert.AreEqual(f, map["f"], "generic map entry: f");
+			Assert.AreEqual(g, map["g"], "generic map entry: g");
+			Assert.AreEqual(h, map["h"], "generic map entry: h");
+			Assert.AreEqual(i, map["i"], "generic map entry: i");
+			Assert.AreEqual(j, map["j"], "generic map entry: j");
+			Assert.AreEqual(k, map["k"], "generic map entry: k");
+			Assert.AreEqual(l, map["l"], "generic map entry: l");
+			//Assert.AreEqual(m, map["m"], "generic map entry: m");
+			//Assert.AreEqual(n, map["n"], "generic map entry: n");
+
+			// use type safe APIs
+			Assert.AreEqual(a, map.GetBool("a"), "map entry: a");
+			Assert.AreEqual(b, map.GetByte("b"), "map entry: b");
+			Assert.AreEqual(c, map.GetChar("c"), "map entry: c");
+			Assert.AreEqual(d, map.GetShort("d"), "map entry: d");
+			Assert.AreEqual(e, map.GetInt("e"), "map entry: e");
+			Assert.AreEqual(f, map.GetLong("f"), "map entry: f");
+			Assert.AreEqual(g, map.GetString("g"), "map entry: g");
+			Assert.AreEqual(h, map.GetBool("h"), "map entry: h");
+			Assert.AreEqual(i, map.GetByte("i"), "map entry: i");
+			Assert.AreEqual(j, map.GetShort("j"), "map entry: j");
+			Assert.AreEqual(k, map.GetInt("k"), "map entry: k");
+			Assert.AreEqual(l, map.GetLong("l"), "map entry: l");
+			//Assert.AreEqual(m, map.GetList("m"), "map entry: m");
+			//Assert.AreEqual(n, map.GetDictionary("n"), "map entry: n");
+
+			IList list = map.GetList("m");
+			Assert.AreEqual(2, list.Count, "list size");
+			Assert.IsTrue(list.Contains("Item1"));
+			Assert.IsTrue(list.Contains("Item2"));
+
+			IDictionary dictionary = map.GetDictionary("n");
+			Assert.AreEqual(5, dictionary.Count, "dictionary size");
+
+			IDictionary childMap = (IDictionary) dictionary["childMap"];
+			Assert.IsNotNull(childMap);
+			Assert.AreEqual("childMap", childMap["name"], "childMap[name]");
+
+			IList childList = (IList) dictionary["childList"];
+			Assert.IsNotNull(childList);
+			Assert.IsTrue(childList.Contains("childListElement1"));
+		}
+
+		protected static IList CreateList()
+		{
+			ArrayList answer = new ArrayList();
+			answer.Add("Item1");
+			answer.Add("Item2");
+			return answer;
+		}
+
+		protected static IDictionary CreateDictionary()
+		{
+			Hashtable answer = new Hashtable();
+			answer.Add("Name", "James");
+			answer.Add("Location", "London");
+			answer.Add("Company", "LogicBlaze");
+
+			Hashtable childMap = new Hashtable();
+			childMap.Add("name", "childMap");
+			answer.Add("childMap", childMap);
+
+			ArrayList childList = new ArrayList();
+			childList.Add("childListElement1");
+			answer.Add("childList", childList);
+			return answer;
+		}
+	}
+}

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/ProducerTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/ProducerTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/ProducerTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/ProducerTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,113 @@
+/*
+ * 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 NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	//[TestFixture]
+	public class ProducerTest : NMSTest
+	{
+		protected ProducerTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+        //[Test]
+        public virtual void TestProducerSendToNullDestinationWithoutDefault()
+        {
+            using(IConnection connection = CreateConnection(GetTestClientId()))
+            {
+                connection.Start();
+                using(ISession session = connection.CreateSession())
+                {
+                    IMessageProducer producer = session.CreateProducer(null);
+
+                    try
+                    {
+                        producer.Send(null, session.CreateTextMessage("Message"));
+                        Assert.Fail("Producer should have thrown an NotSupportedException");
+                    }
+                    catch(NotSupportedException)
+                    {
+                    }
+                    catch(Exception ex)
+                    {
+                        Assert.Fail("Wrong Exception Type Thrown: " + ex.GetType().Name);
+                    }
+                }
+            }
+        }
+
+        //[Test]
+        public virtual void TestProducerSendToNullDestinationWithDefault()
+        {
+            using(IConnection connection = CreateConnection(GetTestClientId()))
+            {
+                connection.Start();
+                using(ISession session = connection.CreateSession())
+                {
+                    IDestination unusedDest = session.CreateTemporaryQueue();
+
+                    IMessageProducer producer = session.CreateProducer(unusedDest);
+
+                    try
+                    {
+                        producer.Send(null, session.CreateTextMessage("Message"));
+                        Assert.Fail("Producer should have thrown an InvalidDestinationException");
+                    }
+                    catch(InvalidDestinationException)
+                    {
+                    }
+                    catch(Exception ex)
+                    {
+                        Assert.Fail("Wrong Exception Type Thrown: " + ex.GetType().Name);
+                    }
+                }
+            }
+        }
+
+		//[Test]
+		public virtual void TestProducerSendToNonDefaultDestination()
+		{
+            using(IConnection connection = CreateConnection(GetTestClientId()))
+            {
+                connection.Start();
+                using(ISession session = connection.CreateSession())
+                {
+					IDestination unusedDest = session.CreateTemporaryQueue();
+					IDestination usedDest = session.CreateTemporaryQueue();
+
+					IMessageProducer producer = session.CreateProducer(unusedDest);
+
+                    try
+                    {
+					    producer.Send(usedDest, session.CreateTextMessage("Message"));
+                        Assert.Fail("Producer should have thrown an NotSupportedException");
+                    }
+                    catch(NotSupportedException)
+                    {
+                    }
+                    catch(Exception ex)
+                    {
+                        Assert.Fail("Wrong Exception Type Thrown: " + ex.GetType().Name);
+                    }
+				}
+			}
+        }
+	}
+}

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/RedeliveryPolicyTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/RedeliveryPolicyTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/RedeliveryPolicyTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/RedeliveryPolicyTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,135 @@
+/*
+ * 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 Apache.NMS.Policies;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+    [TestFixture]
+    public class RedeliveryPolicyTest
+    {
+        [Test]
+        public void Executes_redelivery_policy_with_backoff_enabled_correctly()
+        {
+            RedeliveryPolicy policy = new RedeliveryPolicy();
+
+            policy.BackOffMultiplier = 2;
+            policy.InitialRedeliveryDelay = 5;
+            policy.UseExponentialBackOff = true;
+
+            // simulate a retry of 10 times
+            Assert.IsTrue(policy.RedeliveryDelay(0) == 0, "redelivery delay not 5 is " + policy.RedeliveryDelay(0));
+            Assert.IsTrue(policy.RedeliveryDelay(1) == 5, "redelivery delay not 10 is " + policy.RedeliveryDelay(1));
+            Assert.IsTrue(policy.RedeliveryDelay(2) == 10, "redelivery delay not 20 is " + policy.RedeliveryDelay(2));
+            Assert.IsTrue(policy.RedeliveryDelay(3) == 20, "redelivery delay not 40 is " + policy.RedeliveryDelay(3));
+            Assert.IsTrue(policy.RedeliveryDelay(4) == 40, "redelivery delay not 80 is " + policy.RedeliveryDelay(4));
+            Assert.IsTrue(policy.RedeliveryDelay(5) == 80, "redelivery delay not 160 is " + policy.RedeliveryDelay(5));
+            Assert.IsTrue(policy.RedeliveryDelay(6) == 160, "redelivery delay not 320 is " + policy.RedeliveryDelay(6));
+            Assert.IsTrue(policy.RedeliveryDelay(7) == 320, "redelivery delay not 640 is " + policy.RedeliveryDelay(7));
+            Assert.IsTrue(policy.RedeliveryDelay(8) == 640, "redelivery delay not 1280 is " + policy.RedeliveryDelay(8));
+            Assert.IsTrue(policy.RedeliveryDelay(9) == 1280, "redelivery delay not 2560 is " + policy.RedeliveryDelay(9));
+        }
+
+        [Test]
+        public void Executes_redelivery_policy_with_backoff_of_3_enabled_correctly()
+        {
+            RedeliveryPolicy policy = new RedeliveryPolicy();
+
+            policy.BackOffMultiplier = 3;
+            policy.InitialRedeliveryDelay = 3;
+            policy.UseExponentialBackOff = true;
+
+            // simulate a retry of 10 times
+            Assert.IsTrue(policy.RedeliveryDelay(0) == 0, "redelivery delay not 5 is " + policy.RedeliveryDelay(0));
+            Assert.IsTrue(policy.RedeliveryDelay(1) == 3, "redelivery delay not 10 is " + policy.RedeliveryDelay(1));
+            Assert.IsTrue(policy.RedeliveryDelay(2) == 9, "redelivery delay not 20 is " + policy.RedeliveryDelay(2));
+            Assert.IsTrue(policy.RedeliveryDelay(3) == 27, "redelivery delay not 40 is " + policy.RedeliveryDelay(3));
+            Assert.IsTrue(policy.RedeliveryDelay(4) == 81, "redelivery delay not 80 is " + policy.RedeliveryDelay(4));
+            Assert.IsTrue(policy.RedeliveryDelay(5) == 243, "redelivery delay not 160 is " + policy.RedeliveryDelay(5));
+            Assert.IsTrue(policy.RedeliveryDelay(6) == 729, "redelivery delay not 320 is " + policy.RedeliveryDelay(6));
+            Assert.IsTrue(policy.RedeliveryDelay(7) == 2187, "redelivery delay not 640 is " + policy.RedeliveryDelay(7));
+            Assert.IsTrue(policy.RedeliveryDelay(8) == 6561, "redelivery delay not 1280 is " + policy.RedeliveryDelay(8));
+            Assert.IsTrue(policy.RedeliveryDelay(9) == 19683, "redelivery delay not 2560 is " + policy.RedeliveryDelay(9));
+        }
+
+        [Test]
+        public void Executes_redelivery_policy_without_backoff_enabled_correctly()
+        {
+            RedeliveryPolicy policy = new RedeliveryPolicy();
+
+            policy.InitialRedeliveryDelay = 5;
+
+            // simulate a retry of 10 times
+            Assert.IsTrue(policy.RedeliveryDelay(0) == 0, "redelivery delay not 0 is " + policy.RedeliveryDelay(0));
+            Assert.IsTrue(policy.RedeliveryDelay(1) == 5, "redelivery delay not 5 is " + policy.RedeliveryDelay(1));
+            Assert.IsTrue(policy.RedeliveryDelay(2) == 5, "redelivery delay not 5 is " + policy.RedeliveryDelay(2));
+            Assert.IsTrue(policy.RedeliveryDelay(3) == 5, "redelivery delay not 5 is " + policy.RedeliveryDelay(3));
+            Assert.IsTrue(policy.RedeliveryDelay(4) == 5, "redelivery delay not 5 is " + policy.RedeliveryDelay(4));
+            Assert.IsTrue(policy.RedeliveryDelay(5) == 5, "redelivery delay not 5 is " + policy.RedeliveryDelay(5));
+            Assert.IsTrue(policy.RedeliveryDelay(6) == 5, "redelivery delay not 5 is " + policy.RedeliveryDelay(6));
+            Assert.IsTrue(policy.RedeliveryDelay(7) == 5, "redelivery delay not 5 is " + policy.RedeliveryDelay(7));
+            Assert.IsTrue(policy.RedeliveryDelay(8) == 5, "redelivery delay not 5 is " + policy.RedeliveryDelay(8));
+            Assert.IsTrue(policy.RedeliveryDelay(9) == 5, "redelivery delay not 5 is " + policy.RedeliveryDelay(9));
+        }
+
+        [Test]
+        public void Should_get_collision_percent_correctly()
+        {
+            RedeliveryPolicy policy = new RedeliveryPolicy();
+
+            policy.CollisionAvoidancePercent = 45;
+
+            Assert.IsTrue(policy.CollisionAvoidancePercent == 45);
+        }
+
+        [Test]
+        public void Executes_redelivery_policy_with_collision_enabled_correctly()
+        {
+            RedeliveryPolicy policy = new RedeliveryPolicy();
+
+            policy.BackOffMultiplier = 2;
+            policy.InitialRedeliveryDelay = 5;
+            policy.UseExponentialBackOff = true;
+            policy.UseCollisionAvoidance = true;
+            policy.CollisionAvoidancePercent = 10;
+
+            // simulate a retry of 10 times
+            int delay = policy.RedeliveryDelay(0);
+            Assert.IsTrue(delay == 0, "not zero is " + policy.RedeliveryDelay(0));
+            delay = policy.RedeliveryDelay(1);
+            Assert.IsTrue(delay >= 4.5 && delay <= 5.5, "not delay >= 4.5 && delay <= 5.5 is " + policy.RedeliveryDelay(1));
+            delay = policy.RedeliveryDelay(2);
+            Assert.IsTrue(delay >= 9 && delay <= 11, "not delay >= 9 && delay <= 11 is " + policy.RedeliveryDelay(2));
+            delay = policy.RedeliveryDelay(3);
+            Assert.IsTrue(delay >= 18 && delay <= 22, "not delay >= 18 && delay <= 22 is " + policy.RedeliveryDelay(3));
+            delay = policy.RedeliveryDelay(4);
+            Assert.IsTrue(delay >= 36 && delay <= 44, "not delay >= 36 && delay <= 44 is " + policy.RedeliveryDelay(4));
+            delay = policy.RedeliveryDelay(5);
+            Assert.IsTrue(delay >= 72 && delay <= 88, "not delay >= 72 && delay <= 88 is " + policy.RedeliveryDelay(5));
+            delay = policy.RedeliveryDelay(6);
+            Assert.IsTrue(delay >= 144 && delay <= 176, "not delay >= 144 && delay <= 176 is " + policy.RedeliveryDelay(6));
+            delay = policy.RedeliveryDelay(7);
+            Assert.IsTrue(delay >= 288 && delay <= 352, "not delay >= 288 && delay <= 352 is " + policy.RedeliveryDelay(7));
+            delay = policy.RedeliveryDelay(8);
+            Assert.IsTrue(delay >= 576 && delay <= 704, "not delay >= 576 && delay <= 704 is " + policy.RedeliveryDelay(8));
+            delay = policy.RedeliveryDelay(9);
+            Assert.IsTrue(delay >= 1152 && delay <= 1408, "not delay >= 1152 && delay <= 1408 is " + policy.RedeliveryDelay(9));
+            delay = policy.RedeliveryDelay(10);
+            Assert.IsTrue(delay >= 2304 && delay <= 2816, "not delay >= 2304 && delay <= 2816 is " + policy.RedeliveryDelay(10));
+        }
+    }
+}

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/RequestResponseTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/RequestResponseTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/RequestResponseTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/RequestResponseTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,74 @@
+/*
+ * 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 RequestResponseTest : NMSTest
+	{
+		protected RequestResponseTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+		//[Test]
+		//[Category("RequestResponse")]		
+		public virtual void TestRequestResponseMessaging(string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection())
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					ITemporaryQueue replyTo = session.CreateTemporaryQueue();
+
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						IMessage request = session.CreateMessage();
+						
+						request.NMSReplyTo = replyTo;
+						
+						producer.Send(request);
+						
+						request = consumer.Receive(TimeSpan.FromMilliseconds(3000));
+						Assert.IsNotNull(request);
+						Assert.IsNotNull(request.NMSReplyTo);
+						
+						using(IMessageProducer responder = session.CreateProducer(request.NMSReplyTo))
+						{
+							IMessage response = session.CreateTextMessage("RESPONSE");							
+							responder.Send(response);
+						}						
+					}
+					
+					using(IMessageConsumer consumer = session.CreateConsumer(replyTo))
+					{
+						ITextMessage response = consumer.Receive(TimeSpan.FromMilliseconds(3000)) as ITextMessage;
+						Assert.IsNotNull(response);
+						Assert.AreEqual("RESPONSE", response.Text);
+					}
+				}
+			}
+		}
+	}
+}
+

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/StreamMessageTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/StreamMessageTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/StreamMessageTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/StreamMessageTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,111 @@
+/*
+ * 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 Apache.NMS.Util;
+using NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+	//[TestFixture]
+	public class StreamMessageTest : 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 StreamMessageTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+		//[Test]
+		public virtual void TestSendReceiveStreamMessage(
+			//[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;
+						IStreamMessage request;
+
+						try
+						{
+							request = session.CreateStreamMessage();
+						}
+						catch(System.NotSupportedException)
+						{
+							return;
+						}
+
+						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(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+
+						// use generic API to access entries
+						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");
+					}
+				}
+			}
+		}
+	}
+}

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TempDestinationDeletionTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TempDestinationDeletionTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TempDestinationDeletionTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TempDestinationDeletionTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,80 @@
+/*
+ * 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 TempDestinationDeletionTest : NMSTest
+	{
+		protected TempDestinationDeletionTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+		//[Test]
+		public virtual void TestTempDestinationDeletion(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode,
+			//[Values(QUEUE_DESTINATION_NAME, TOPIC_DESTINATION_NAME, TEMP_QUEUE_DESTINATION_NAME, TEMP_TOPIC_DESTINATION_NAME)]
+			string testDestinationURI)
+		{
+			using(IConnection connection1 = CreateConnection(GetTestClientId()))
+			{
+				connection1.Start();
+				using(ISession session = connection1.CreateSession(AcknowledgementMode.AutoAcknowledge))
+				{
+					const int MaxNumDestinations = 100;
+
+					for(int index = 1; index <= MaxNumDestinations; index++)
+					{
+						IDestination destination = GetClearDestination(session, testDestinationURI);
+
+						using(IMessageProducer producer = session.CreateProducer(destination))
+						using(IMessageConsumer consumer = session.CreateConsumer(destination))
+						{
+							producer.DeliveryMode = deliveryMode;
+
+							IMessage request = session.CreateTextMessage("Hello World, Just Passing Through!");
+
+							request.NMSType = "TEMP_MSG";
+							producer.Send(request);
+							IMessage receivedMsg = consumer.Receive(TimeSpan.FromMilliseconds(5000));
+							Assert.IsNotNull(receivedMsg);
+							Assert.AreEqual(receivedMsg.NMSType, "TEMP_MSG");
+							
+							// Ensures that Consumer closes out its subscription
+							consumer.Close();
+						}
+
+						try
+						{
+							session.DeleteDestination(destination);
+						}
+						catch(NotSupportedException)
+						{
+							// Might as well not try this again.
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+}

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TempDestinationTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TempDestinationTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TempDestinationTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TempDestinationTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,175 @@
+/*
+ * 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 NUnit.Framework;
+
+namespace Apache.NMS.Test
+{
+    //[TestFixture]
+    public class TempDestinationTest : NMSTest
+    {
+        private IConnection connection;
+        private IList connections = ArrayList.Synchronized(new ArrayList());
+
+		protected TempDestinationTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+        //[SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+
+            this.connection = CreateConnection();
+            this.connections.Add(connection);
+        }
+
+        //[TearDown]
+        public override void TearDown()
+        {
+            foreach(IConnection conn in this.connections)
+            {
+                try
+                {
+                    conn.Close();
+                }
+                catch
+                {
+                }
+            }
+
+            connections.Clear();
+
+            base.TearDown();
+        }
+
+        //[Test]
+        public virtual void TestTempDestOnlyConsumedByLocalConn()
+        {
+            connection.Start();
+
+            ISession tempSession = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
+            ITemporaryQueue queue = tempSession.CreateTemporaryQueue();
+            IMessageProducer producer = tempSession.CreateProducer(queue);
+            producer.DeliveryMode = (MsgDeliveryMode.NonPersistent);
+            ITextMessage message = tempSession.CreateTextMessage("First");
+            producer.Send(message);
+
+            // temp destination should not be consume when using another connection
+            IConnection otherConnection = CreateConnection();
+            connections.Add(otherConnection);
+            ISession otherSession = otherConnection.CreateSession(AcknowledgementMode.AutoAcknowledge);
+            ITemporaryQueue otherQueue = otherSession.CreateTemporaryQueue();
+            IMessageConsumer consumer = otherSession.CreateConsumer(otherQueue);
+            IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(3000));
+            Assert.IsNull(msg);
+
+            // should be able to consume temp destination from the same connection
+            consumer = tempSession.CreateConsumer(queue);
+            msg = consumer.Receive(TimeSpan.FromMilliseconds(3000));
+            Assert.IsNotNull(msg);
+        }
+
+        //[Test]
+        public virtual void TestTempQueueHoldsMessagesWithConsumers()
+        {
+            ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
+            ITemporaryQueue queue = session.CreateTemporaryQueue();
+            IMessageConsumer consumer = session.CreateConsumer(queue);
+            connection.Start();
+
+            IMessageProducer producer = session.CreateProducer(queue);
+            producer.DeliveryMode = (MsgDeliveryMode.NonPersistent);
+            ITextMessage message = session.CreateTextMessage("Hello");
+            producer.Send(message);
+
+            IMessage message2 = consumer.Receive(TimeSpan.FromMilliseconds(1000));
+            Assert.IsNotNull(message2);
+            Assert.IsTrue(message2 is ITextMessage, "Expected message to be a ITextMessage");
+            Assert.IsTrue(((ITextMessage)message2).Text == message.Text, "Expected message to be a '" + message.Text + "'");
+        }
+
+        //[Test]
+        public virtual void TestTempQueueHoldsMessagesWithoutConsumers()
+        {
+            ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
+            ITemporaryQueue queue = session.CreateTemporaryQueue();
+            IMessageProducer producer = session.CreateProducer(queue);
+            producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
+            ITextMessage message = session.CreateTextMessage("Hello");
+            producer.Send(message);
+
+            connection.Start();
+            IMessageConsumer consumer = session.CreateConsumer(queue);
+            IMessage message2 = consumer.Receive(TimeSpan.FromMilliseconds(3000));
+            Assert.IsNotNull(message2);
+            Assert.IsTrue(message2 is ITextMessage, "Expected message to be a ITextMessage");
+            Assert.IsTrue(((ITextMessage)message2).Text == message.Text, "Expected message to be a '" + message.Text + "'");
+        }
+
+        //[Test]
+        public virtual void TestTmpQueueWorksUnderLoad()
+        {
+            int count = 500;
+            int dataSize = 1024;
+
+            ArrayList list = new ArrayList(count);
+            ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
+            ITemporaryQueue queue = session.CreateTemporaryQueue();
+            IBytesMessage message;
+            IBytesMessage message2;
+            IMessageProducer producer = session.CreateProducer(queue);
+            producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
+
+            byte[] srcdata = new byte[dataSize];
+            srcdata[0] = (byte) 'B';
+            srcdata[1] = (byte) 'A';
+            srcdata[2] = (byte) 'D';
+            srcdata[3] = (byte) 'W';
+            srcdata[4] = (byte) 'O';
+            srcdata[5] = (byte) 'L';
+            srcdata[6] = (byte) 'F';
+            for(int i = 0; i < count; i++)
+            {
+                message = session.CreateBytesMessage();
+                message.WriteBytes(srcdata);
+                message.Properties.SetInt("c", i);
+                producer.Send(message);
+                list.Add(message);
+            }
+
+            connection.Start();
+            byte[] data = new byte[dataSize];
+            byte[] data2 = new byte[dataSize];
+            IMessageConsumer consumer = session.CreateConsumer(queue);
+            for(int i = 0; i < count; i++)
+            {
+                message2 = consumer.Receive(TimeSpan.FromMilliseconds(2000)) as IBytesMessage;
+                Assert.IsNotNull(message2);
+                Assert.AreEqual(i, message2.Properties.GetInt("c"));
+                message = list[i] as IBytesMessage;
+                Assert.IsNotNull(message);
+				message.Reset();
+                message.ReadBytes(data);
+                message2.ReadBytes(data2);
+                Assert.AreEqual(data, data2);
+            }
+        }
+    }
+}

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TextMessageTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TextMessageTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TextMessageTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TextMessageTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,71 @@
+/*
+ * 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 TextMessageTest : NMSTest
+	{
+		protected TextMessageTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+		//[Test]
+		public virtual void TestSendReceiveTextMessage(
+			//[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.CreateTextMessage("Hello World!");
+						producer.Send(request);
+
+						IMessage message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(request, message);
+						Assert.AreEqual(deliveryMode, message.NMSDeliveryMode, "NMSDeliveryMode does not match");
+					}
+				}
+			}
+		}
+
+		/// <summary>
+		/// Assert that two messages are ITextMessages and their text bodies are equal.
+		/// </summary>
+		/// <param name="expected"></param>
+		/// <param name="actual"></param>
+		protected void AssertTextMessageEqual(IMessage expected, IMessage actual)
+		{
+			ITextMessage expectedTextMsg = expected as ITextMessage;
+			Assert.IsNotNull(expectedTextMsg, "'expected' message not a text message");
+			ITextMessage actualTextMsg = actual as ITextMessage;
+			Assert.IsNotNull(actualTextMsg, "'actual' message not a text message");
+			Assert.AreEqual(expectedTextMsg.Text, actualTextMsg.Text, "Text message does not match.");
+		}
+	}
+}

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TransactionTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TransactionTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TransactionTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/TransactionTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,439 @@
+/*
+ * 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 TransactionTest : NMSTest
+	{
+		protected TransactionTest(NMSTestSupport testSupport)
+			: base(testSupport)
+		{
+		}
+
+		//[Test]
+		public virtual void TestSendRollback(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.DeliveryMode = deliveryMode;
+						ITextMessage firstMsgSend = session.CreateTextMessage("First Message");
+						producer.Send(firstMsgSend);
+						session.Commit();
+
+						ITextMessage rollbackMsg = session.CreateTextMessage("I'm going to get rolled back.");
+						producer.Send(rollbackMsg);
+						session.Rollback();
+
+						ITextMessage secondMsgSend = session.CreateTextMessage("Second Message");
+						producer.Send(secondMsgSend);
+						session.Commit();
+
+						// Receive the messages
+
+						IMessage message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(firstMsgSend, message, "First message does not match.");
+
+						message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(secondMsgSend, message, "Second message does not match.");
+
+						// validates that the rollback was not consumed
+						session.Commit();
+					}
+				}
+			}
+		}
+
+		//[Test]
+		public virtual void TestSendSessionClose(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			ITextMessage firstMsgSend;
+			ITextMessage secondMsgSend;
+
+			using(IConnection connection1 = CreateConnection(GetTestClientId()))
+			{
+				connection1.Start();
+				using(ISession session1 = connection1.CreateSession(AcknowledgementMode.Transactional))
+				{
+					IDestination destination1 = GetClearDestination(session1, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session1.CreateConsumer(destination1))
+					{
+						// First connection session that sends one message, and the
+						// second message is implicitly rolled back as the session is
+						// disposed before Commit() can be called.
+						using(IConnection connection2 = CreateConnection(GetTestClientId()))
+						{
+							connection2.Start();
+							using(ISession session2 = connection2.CreateSession(AcknowledgementMode.Transactional))
+							{
+								IDestination destination2 = GetClearDestination(session2, DestinationType.Queue, testQueueRef);
+								using(IMessageProducer producer = session2.CreateProducer(destination2))
+								{
+									producer.DeliveryMode = deliveryMode;
+									firstMsgSend = session2.CreateTextMessage("First Message");
+									producer.Send(firstMsgSend);
+									session2.Commit();
+
+									ITextMessage rollbackMsg = session2.CreateTextMessage("I'm going to get rolled back.");
+									producer.Send(rollbackMsg);
+								}
+							}
+						}
+
+						// Second connection session that will send one message.
+						using(IConnection connection2 = CreateConnection(GetTestClientId()))
+						{
+							connection2.Start();
+							using(ISession session2 = connection2.CreateSession(AcknowledgementMode.Transactional))
+							{
+								IDestination destination2 = GetClearDestination(session2, DestinationType.Queue, testQueueRef);
+								using(IMessageProducer producer = session2.CreateProducer(destination2))
+								{
+									producer.DeliveryMode = deliveryMode;
+									secondMsgSend = session2.CreateTextMessage("Second Message");
+									producer.Send(secondMsgSend);
+									session2.Commit();
+								}
+							}
+						}
+
+						// Check the consumer to verify which messages were actually received.
+						IMessage message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(firstMsgSend, message, "First message does not match.");
+
+						message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(secondMsgSend, message, "Second message does not match.");
+
+						// validates that the rollback was not consumed
+						session1.Commit();
+					}
+				}
+			}
+		}
+
+		//[Test]
+		public virtual void TestReceiveRollback(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.DeliveryMode = deliveryMode;
+						// Send both messages
+						ITextMessage firstMsgSend = session.CreateTextMessage("First Message");
+						producer.Send(firstMsgSend);
+						ITextMessage secondMsgSend = session.CreateTextMessage("Second Message");
+						producer.Send(secondMsgSend);
+						session.Commit();
+
+						// Receive the messages
+
+						IMessage message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(firstMsgSend, message, "First message does not match.");
+						session.Commit();
+
+						message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(secondMsgSend, message, "Second message does not match.");
+
+						// Rollback so we can get that last message again.
+						session.Rollback();
+						IMessage rollbackMsg = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(secondMsgSend, rollbackMsg, "Rollback message does not match.");
+						session.Commit();
+					}
+				}
+			}
+		}
+
+
+		//[Test]
+		public virtual void TestReceiveTwoThenRollback(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.DeliveryMode = deliveryMode;
+						// Send both messages
+						ITextMessage firstMsgSend = session.CreateTextMessage("First Message");
+						producer.Send(firstMsgSend);
+						ITextMessage secondMsgSend = session.CreateTextMessage("Second Message");
+						producer.Send(secondMsgSend);
+						session.Commit();
+
+						// Receive the messages
+
+						IMessage message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(firstMsgSend, message, "First message does not match.");
+						message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(secondMsgSend, message, "Second message does not match.");
+
+						// Rollback so we can get that last two messages again.
+						session.Rollback();
+						IMessage rollbackMsg = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(firstMsgSend, rollbackMsg, "First rollback message does not match.");
+						rollbackMsg = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(secondMsgSend, rollbackMsg, "Second rollback message does not match.");
+
+						Assert.IsNull(consumer.ReceiveNoWait());
+						session.Commit();
+					}
+				}
+			}
+		}
+
+		//[Test]
+		public virtual void TestSendCommitNonTransaction(
+			//[Values(AcknowledgementMode.AutoAcknowledge, AcknowledgementMode.ClientAcknowledge)]
+			AcknowledgementMode ackMode,
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(ackMode))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.DeliveryMode = deliveryMode;
+						ITextMessage firstMsgSend = session.CreateTextMessage("SendCommitNonTransaction Message");
+						producer.Send(firstMsgSend);
+						try
+						{
+							session.Commit();
+							Assert.Fail("Should have thrown an InvalidOperationException.");
+						}
+						catch(InvalidOperationException)
+						{
+						}
+					}
+				}
+			}
+		}
+
+		//[Test]
+		public virtual void TestReceiveCommitNonTransaction(
+			//[Values(AcknowledgementMode.AutoAcknowledge, AcknowledgementMode.ClientAcknowledge)]
+			AcknowledgementMode ackMode,
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(ackMode))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.DeliveryMode = deliveryMode;
+						ITextMessage firstMsgSend = session.CreateTextMessage("ReceiveCommitNonTransaction Message");
+						producer.Send(firstMsgSend);
+
+						// Receive the messages
+
+						IMessage message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(firstMsgSend, message, "First message does not match.");
+						if(AcknowledgementMode.ClientAcknowledge == ackMode)
+						{
+							message.Acknowledge();
+						}
+
+						try
+						{
+							session.Commit();
+							Assert.Fail("Should have thrown an InvalidOperationException.");
+						}
+						catch(InvalidOperationException)
+						{
+						}
+					}
+				}
+			}
+		}
+
+		//[Test]
+		public virtual void TestReceiveRollbackNonTransaction(
+			//[Values(AcknowledgementMode.AutoAcknowledge, AcknowledgementMode.ClientAcknowledge)]
+			AcknowledgementMode ackMode,
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				using(ISession session = connection.CreateSession(ackMode))
+				{
+					IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+					using(IMessageConsumer consumer = session.CreateConsumer(destination))
+					using(IMessageProducer producer = session.CreateProducer(destination))
+					{
+						producer.DeliveryMode = deliveryMode;
+						ITextMessage firstMsgSend = session.CreateTextMessage("ReceiveCommitNonTransaction Message");
+						producer.Send(firstMsgSend);
+
+						// Receive the messages
+
+						IMessage message = consumer.Receive(receiveTimeout);
+						AssertTextMessageEqual(firstMsgSend, message, "First message does not match.");
+						if(AcknowledgementMode.ClientAcknowledge == ackMode)
+						{
+							message.Acknowledge();
+						}
+
+						try
+						{
+							session.Rollback();
+							Assert.Fail("Should have thrown an InvalidOperationException.");
+						}
+						catch(InvalidOperationException)
+						{
+						}
+					}
+				}
+			}
+		}
+
+		/// <summary>
+		/// Assert that two messages are ITextMessages and their text bodies are equal.
+		/// </summary>
+		/// <param name="expected"></param>
+		/// <param name="actual"></param>
+		/// <param name="message"></param>
+		protected void AssertTextMessageEqual(IMessage expected, IMessage actual, String message)
+		{
+			ITextMessage expectedTextMsg = expected as ITextMessage;
+			Assert.IsNotNull(expectedTextMsg, "'expected' message not a text message");
+			ITextMessage actualTextMsg = actual as ITextMessage;
+			Assert.IsNotNull(actualTextMsg, "'actual' message not a text message");
+			Assert.AreEqual(expectedTextMsg.Text, actualTextMsg.Text, message);
+		}
+
+		//[Test]
+		public virtual void TestRedispatchOfRolledbackTx(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				ISession session = connection.CreateSession(AcknowledgementMode.Transactional);
+				IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+
+				SendMessages(connection, destination, deliveryMode, 2);
+
+				IMessageConsumer consumer = session.CreateConsumer(destination);
+				Assert.IsNotNull(consumer.Receive(TimeSpan.FromMilliseconds(1500)));
+				Assert.IsNotNull(consumer.Receive(TimeSpan.FromMilliseconds(1500)));
+
+				// install another consumer while message dispatch is unacked/uncommitted
+				ISession redispatchSession = connection.CreateSession(AcknowledgementMode.Transactional);
+				IMessageConsumer redispatchConsumer = redispatchSession.CreateConsumer(destination);
+
+				session.Rollback();
+				session.Close();
+
+				IMessage msg = redispatchConsumer.Receive(TimeSpan.FromMilliseconds(1500));
+				Assert.IsNotNull(msg);
+				Assert.IsTrue(msg.NMSRedelivered);
+				Assert.AreEqual(2, msg.Properties.GetLong("NMSXDeliveryCount"));
+				msg = redispatchConsumer.Receive(TimeSpan.FromMilliseconds(1500));
+				Assert.IsNotNull(msg);
+				Assert.IsTrue(msg.NMSRedelivered);
+				Assert.AreEqual(2, msg.Properties.GetLong("NMSXDeliveryCount"));
+				redispatchSession.Commit();
+
+				Assert.IsNull(redispatchConsumer.Receive(TimeSpan.FromMilliseconds(500)));
+				redispatchSession.Close();
+			}
+		}
+
+		//[Test]
+		public virtual void TestRedispatchOfUncommittedTx(
+			//[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode, string testQueueRef)
+		{
+			using(IConnection connection = CreateConnection(GetTestClientId()))
+			{
+				connection.Start();
+				ISession session = connection.CreateSession(AcknowledgementMode.Transactional);
+				IDestination destination = GetClearDestination(session, DestinationType.Queue, testQueueRef);
+
+				SendMessages(connection, destination, deliveryMode, 2);
+
+				IMessageConsumer consumer = session.CreateConsumer(destination);
+				Assert.IsNotNull(consumer.Receive(TimeSpan.FromMilliseconds(2000)));
+				Assert.IsNotNull(consumer.Receive(TimeSpan.FromMilliseconds(2000)));
+
+				// install another consumer while message dispatch is unacked/uncommitted
+				ISession redispatchSession = connection.CreateSession(AcknowledgementMode.Transactional);
+				IMessageConsumer redispatchConsumer = redispatchSession.CreateConsumer(destination);
+
+				// no commit so will auto rollback and get re-dispatched to redisptachConsumer
+				session.Close();
+
+				IMessage msg = redispatchConsumer.Receive(TimeSpan.FromMilliseconds(2000));
+				Assert.IsNotNull(msg);
+				Assert.IsTrue(msg.NMSRedelivered);
+				Assert.AreEqual(2, msg.Properties.GetLong("NMSXDeliveryCount"));
+
+				msg = redispatchConsumer.Receive(TimeSpan.FromMilliseconds(2000));
+				Assert.IsNotNull(msg);
+				Assert.IsTrue(msg.NMSRedelivered);
+				Assert.AreEqual(2, msg.Properties.GetLong("NMSXDeliveryCount"));
+				redispatchSession.Commit();
+
+				Assert.IsNull(redispatchConsumer.Receive(TimeSpan.FromMilliseconds(500)));
+				redispatchSession.Close();
+			}
+		}
+	}
+}
+
+

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/XMSAsyncConsumeTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/XMSAsyncConsumeTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/XMSAsyncConsumeTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/XMSAsyncConsumeTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,106 @@
+/*
+ * 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.Threading;
+using Apache.NMS.Test;
+using NUnit.Framework;
+
+namespace Apache.NMS.XMS.Test
+{
+	[TestFixture]
+	public class XMSAsyncConsumeTest : AsyncConsumeTest
+	{
+		protected static string DEFAULT_TEST_QUEUE = "defaultTestQueue";
+
+		public XMSAsyncConsumeTest() :
+			base(new XMSTestSupport())
+		{
+		}
+
+		[SetUp]
+		public override void SetUp()
+		{
+			base.SetUp();
+		}
+
+		[TearDown]
+		public override void TearDown()
+		{
+			base.TearDown();
+		}
+
+		[Test]
+		public void TestAsynchronousConsume(
+			[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode)
+		{
+			base.TestAsynchronousConsume(deliveryMode, DEFAULT_TEST_QUEUE);
+		}
+
+		[Test]
+		public void TestCreateConsumerAfterSend(
+			[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode)
+		{
+			base.TestCreateConsumerAfterSend(deliveryMode, DEFAULT_TEST_QUEUE);
+		}
+
+		[Test]
+		public void TestCreateConsumerBeforeSendAddListenerAfterSend(
+			[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode)
+		{
+			base.TestCreateConsumerBeforeSendAddListenerAfterSend(deliveryMode, DEFAULT_TEST_QUEUE);
+		}
+
+		[Test]
+		public void TestAsynchronousTextMessageConsume(
+			[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode)
+		{
+			base.TestAsynchronousTextMessageConsume(deliveryMode, DEFAULT_TEST_QUEUE);
+		}
+
+		[Test]
+		public void TestTemporaryQueueAsynchronousConsume(
+			[Values(MsgDeliveryMode.Persistent, MsgDeliveryMode.NonPersistent)]
+			MsgDeliveryMode deliveryMode)
+		{
+			using(IConnection connection = CreateConnectionAndStart(GetTestClientId()))
+			using(ISession syncSession = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+			using(ISession asyncSession = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
+			using(IDestination destination = GetClearDestination(syncSession, DestinationType.Queue, DEFAULT_TEST_QUEUE))
+			using(ITemporaryQueue tempReplyDestination = syncSession.CreateTemporaryQueue())
+			using(IMessageConsumer consumer = asyncSession.CreateConsumer(destination))
+			using(IMessageConsumer tempConsumer = asyncSession.CreateConsumer(tempReplyDestination))
+			using(IMessageProducer producer = syncSession.CreateProducer(destination))
+			{
+				producer.DeliveryMode = deliveryMode;
+				tempConsumer.Listener += new MessageListener(OnMessage);
+				consumer.Listener += new MessageListener(OnQueueMessage);
+
+				IMessage request = syncSession.CreateMessage();
+				request.NMSCorrelationID = "TemqQueueAsyncConsume";
+				request.NMSType = "Test";
+				request.NMSReplyTo = tempReplyDestination;
+				producer.Send(request);
+
+				WaitForMessageToArrive();
+				Assert.AreEqual("TempQueueAsyncResponse", receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
+			}
+		}
+	}
+}

Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/XMSBadConsumeTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/XMSBadConsumeTest.cs?rev=1723221&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/XMSBadConsumeTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/XMSBadConsumeTest.cs Wed Jan  6 02:19:56 2016
@@ -0,0 +1,50 @@
+/*
+ * 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 NUnit.Framework;
+using Apache.NMS.Test;
+
+namespace Apache.NMS.XMS.Test
+{
+	[TestFixture]
+	public class XMSBadConsumeTest : BadConsumeTest
+	{
+		public XMSBadConsumeTest()
+			: base(new NMSTestSupport())
+		{
+		}
+
+		[SetUp]
+		public override void SetUp()
+		{
+			base.SetUp();
+		}
+
+		[TearDown]
+		public override void TearDown()
+		{
+			base.TearDown();
+		}
+
+		[Test]
+		[ExpectedException(Handler="ExceptionValidationCheck")]
+		public override void TestBadConsumerException()
+		{
+			base.TestBadConsumerException();
+		}
+	}
+}



Mime
View raw message