You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@activemq.apache.org by ta...@apache.org on 2010/01/14 00:09:40 UTC
svn commit: r898992 - in /activemq/activemq-dotnet/Apache.NMS.Stomp/trunk:
src/test/csharp/Commands/MapMessageTest.cs vs2008-stomp-test.csproj
Author: tabish
Date: Wed Jan 13 23:09:39 2010
New Revision: 898992
URL: http://svn.apache.org/viewvc?rev=898992&view=rev
Log:
Add basic tests for the MapMessage class.
Added:
activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/src/test/csharp/Commands/MapMessageTest.cs (with props)
Modified:
activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/vs2008-stomp-test.csproj
Added: activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/src/test/csharp/Commands/MapMessageTest.cs
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/src/test/csharp/Commands/MapMessageTest.cs?rev=898992&view=auto
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/src/test/csharp/Commands/MapMessageTest.cs (added)
+++ activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/src/test/csharp/Commands/MapMessageTest.cs Wed Jan 13 23:09:39 2010
@@ -0,0 +1,548 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using NUnit.Framework;
+using System;
+using System.Text;
+using System.Collections;
+using Apache.NMS.Stomp.Commands;
+using System.Globalization;
+
+namespace Apache.NMS.Stomp.Test.Commands
+{
+ [TestFixture]
+ public class MapMessageTest
+ {
+
+ private string name = "testName";
+
+ [Test]
+ public void TestBytesConversion()
+ {
+ MapMessage msg = new MapMessage();
+ msg.Body.SetBool("boolean", true);
+ msg.Body.SetByte("byte", (byte)1);
+ msg.Body["bytes"] = new byte[1];
+ msg.Body.SetChar("char", 'a');
+ msg.Body.SetDouble("double", 1.5);
+ msg.Body.SetFloat("float", 1.5f);
+ msg.Body.SetInt("int", 1);
+ msg.Body.SetLong("long", 1);
+ msg.Body["object"] = "stringObj";
+ msg.Body.SetShort("short", (short)1);
+ msg.Body.SetString("string", "string");
+
+ // Test with a 1Meg String
+ StringBuilder bigSB = new StringBuilder(1024 * 1024);
+ for(int i = 0; i < 1024 * 1024; i++)
+ {
+ bigSB.Append((char)'a' + i % 26);
+ }
+ String bigString = bigSB.ToString();
+
+ msg.Body.SetString("bigString", bigString);
+
+ msg = (MapMessage)msg.Clone();
+
+ Assert.AreEqual(msg.Body.GetBool("boolean"), true);
+ Assert.AreEqual(msg.Body.GetByte("byte"), (byte)1);
+ Assert.AreEqual((msg.Body["bytes"] as byte[]).Length, 1);
+ Assert.AreEqual(msg.Body.GetChar("char"), 'a');
+ Assert.AreEqual(msg.Body.GetDouble("double"), 1.5, 0);
+ Assert.AreEqual(msg.Body.GetFloat("float"), 1.5f, 0);
+ Assert.AreEqual(msg.Body.GetInt("int"), 1);
+ Assert.AreEqual(msg.Body.GetLong("long"), 1);
+ Assert.AreEqual(msg.Body["object"], "stringObj");
+ Assert.AreEqual(msg.Body.GetShort("short"), (short)1);
+ Assert.AreEqual(msg.Body.GetString("string"), "string");
+ Assert.AreEqual(msg.Body.GetString("bigString"), bigString);
+ }
+
+ [Test]
+ public void TestGetBoolean()
+ {
+ MapMessage msg = new MapMessage();
+ msg.Body.SetBool(name, true);
+ msg.ReadOnlyBody = true;
+ Assert.IsTrue(msg.Body.GetBool(name));
+ msg.ClearBody();
+ msg.Body.SetString(name, "True");
+
+ msg = (MapMessage)msg.Clone();
+
+ Assert.IsTrue(msg.Body.GetBool(name));
+ }
+
+ [Test]
+ public void TestGetByte()
+ {
+ MapMessage msg = new MapMessage();
+ msg.Body.SetByte(this.name, (byte)1);
+ msg = (MapMessage)msg.Clone();
+ Assert.IsTrue(msg.Body.GetByte(this.name) == (byte)1);
+ }
+
+ [Test]
+ public void TestGetShort()
+ {
+ MapMessage msg = new MapMessage();
+ try
+ {
+ msg.Body.SetShort(this.name, (short)1);
+ msg = (MapMessage)msg.Clone();
+ Assert.IsTrue(msg.Body.GetShort(this.name) == (short)1);
+ }
+ catch(NMSException)
+ {
+ Assert.IsTrue(false);
+ }
+ }
+
+ [Test]
+ public void TestGetChar()
+ {
+ MapMessage msg = new MapMessage();
+ try
+ {
+ msg.Body.SetChar(this.name, 'a');
+ msg = (MapMessage)msg.Clone();
+ Assert.IsTrue(msg.Body.GetChar(this.name) == 'a');
+ }
+ catch(NMSException)
+ {
+ Assert.IsTrue(false);
+ }
+ }
+
+ [Test]
+ public void TestGetInt()
+ {
+ MapMessage msg = new MapMessage();
+ try
+ {
+ msg.Body.SetInt(this.name, 1);
+ msg = (MapMessage)msg.Clone();
+ Assert.IsTrue(msg.Body.GetInt(this.name) == 1);
+ }
+ catch(NMSException)
+ {
+ Assert.IsTrue(false);
+ }
+ }
+
+ [Test]
+ public void TestGetLong()
+ {
+ MapMessage msg = new MapMessage();
+ try
+ {
+ msg.Body.SetLong(this.name, 1);
+ msg = (MapMessage)msg.Clone();
+ Assert.IsTrue(msg.Body.GetLong(this.name) == 1);
+ }
+ catch(NMSException)
+ {
+ Assert.IsTrue(false);
+ }
+ }
+
+ [Test]
+ public void TestGetFloat()
+ {
+ MapMessage msg = new MapMessage();
+ try
+ {
+ msg.Body.SetFloat(this.name, 1.5f);
+ msg = (MapMessage)msg.Clone();
+ Assert.IsTrue(msg.Body.GetFloat(this.name) == 1.5f);
+ }
+ catch(NMSException)
+ {
+ Assert.IsTrue(false);
+ }
+ }
+
+ [Test]
+ public void TestGetDouble()
+ {
+ MapMessage msg = new MapMessage();
+ try
+ {
+ msg.Body.SetDouble(this.name, 1.5);
+ msg = (MapMessage)msg.Clone();
+ Assert.IsTrue(msg.Body.GetDouble(this.name) == 1.5);
+ }
+ catch(NMSException)
+ {
+ Assert.IsTrue(false);
+ }
+ }
+
+ [Test]
+ public void TestGetString()
+ {
+ MapMessage msg = new MapMessage();
+ try
+ {
+ String str = "test";
+ msg.Body.SetString(this.name, str);
+ msg = (MapMessage)msg.Clone();
+ Assert.AreEqual(msg.Body.GetString(this.name), str);
+ }
+ catch(NMSException)
+ {
+ Assert.IsTrue(false);
+ }
+ }
+
+ [Test]
+ public void TestGetBytes()
+ {
+ MapMessage msg = new MapMessage();
+ try
+ {
+ byte[] bytes1 = new byte[3];
+ byte[] bytes2 = new byte[2];
+ System.Array.Copy(bytes1, 0, bytes2, 0, 2);
+ msg.Body[this.name] = bytes1;
+ msg.Body[this.name + "2"] = bytes2;
+ msg = (MapMessage)msg.Clone();
+ Assert.IsTrue(System.Array.Equals(msg.Body[this.name], bytes1));
+ Assert.AreEqual(((byte[]) msg.Body[this.name + "2"]).Length, bytes2.Length);
+ }
+ catch(NMSException)
+ {
+ Assert.IsTrue(false);
+ }
+ }
+
+ [Test]
+ public void TestGetObject()
+ {
+ MapMessage msg = new MapMessage();
+ Boolean booleanValue = true;
+ Byte byteValue = Byte.Parse("1");
+ byte[] bytesValue = new byte[3];
+ Char charValue = (Char) 'a';
+ Double doubleValue = Double.Parse("1.5", CultureInfo.InvariantCulture);
+ Single floatValue = Single.Parse("1.5", CultureInfo.InvariantCulture);
+ Int32 intValue = Int32.Parse("1");
+ Int64 longValue = Int64.Parse("1");
+ Int16 shortValue = Int16.Parse("1");
+ String stringValue = "string";
+
+ try
+ {
+ msg.Body["boolean"] = booleanValue;
+ msg.Body["byte"] = byteValue;
+ msg.Body["bytes"] = bytesValue;
+ msg.Body["char"] = charValue;
+ msg.Body["double"] = doubleValue;
+ msg.Body["float"] = floatValue;
+ msg.Body["int"] = intValue;
+ msg.Body["long"] = longValue;
+ msg.Body["short"] = shortValue;
+ msg.Body["string"] = stringValue;
+ }
+ catch(MessageFormatException)
+ {
+ Assert.Fail("object formats should be correct");
+ }
+
+ msg = (MapMessage)msg.Clone();
+
+ Assert.IsTrue(msg.Body["boolean"] is Boolean);
+ Assert.AreEqual(msg.Body["boolean"], booleanValue);
+ Assert.AreEqual(msg.Body.GetBool("boolean"), booleanValue);
+ Assert.IsTrue(msg.Body["byte"] is Byte);
+ Assert.AreEqual(msg.Body["byte"], byteValue);
+ Assert.AreEqual(msg.Body.GetByte("byte"), byteValue);
+ Assert.IsTrue(msg.Body["bytes"] is byte[]);
+ Assert.AreEqual(((byte[])msg.Body["bytes"]).Length, bytesValue.Length);
+ Assert.AreEqual((msg.Body["bytes"] as byte[]).Length, bytesValue.Length);
+ Assert.IsTrue(msg.Body["char"] is Char);
+ Assert.AreEqual(msg.Body["char"], charValue);
+ Assert.AreEqual(msg.Body.GetChar("char"), charValue);
+ Assert.IsTrue(msg.Body["double"] is Double);
+ Assert.AreEqual(msg.Body["double"], doubleValue);
+ Assert.AreEqual(msg.Body.GetDouble("double"), doubleValue, 0);
+ Assert.IsTrue(msg.Body["float"] is Single);
+ Assert.AreEqual(msg.Body["float"], floatValue);
+ Assert.AreEqual(msg.Body.GetFloat("float"), floatValue, 0);
+ Assert.IsTrue(msg.Body["int"] is Int32);
+ Assert.AreEqual(msg.Body["int"], intValue);
+ Assert.AreEqual(msg.Body.GetInt("int"), intValue);
+ Assert.IsTrue(msg.Body["long"] is Int64);
+ Assert.AreEqual(msg.Body["long"], longValue);
+ Assert.AreEqual(msg.Body.GetLong("long"), longValue);
+ Assert.IsTrue(msg.Body["short"] is Int16);
+ Assert.AreEqual(msg.Body["short"], shortValue);
+ Assert.AreEqual(msg.Body.GetShort("short"), shortValue);
+ Assert.IsTrue(msg.Body["string"] is String);
+ Assert.AreEqual(msg.Body["string"], stringValue);
+ Assert.AreEqual(msg.Body.GetString("string"), stringValue);
+
+ msg.ClearBody();
+ try
+ {
+ msg.Body["object"] = new Object();
+ Assert.Fail("should have thrown exception");
+ }
+ catch(MessageFormatException)
+ {
+ }
+
+ }
+
+ [Test]
+ public void TestGetMapNames()
+ {
+ MapMessage msg = new MapMessage();
+ msg.Body.SetBool("boolean", true);
+ msg.Body.SetByte("byte", (byte)1);
+ msg.Body["bytes1"] = new byte[1];
+ msg.Body.SetChar("char", 'a');
+ msg.Body.SetDouble("double", 1.5);
+ msg.Body.SetFloat("float", 1.5f);
+ msg.Body.SetInt("int", 1);
+ msg.Body.SetLong("long", 1);
+ msg.Body["object"] = "stringObj";
+ msg.Body.SetShort("short", (short)1);
+ msg.Body.SetString("string", "string");
+
+ msg = (MapMessage)msg.Clone();
+
+ ICollection mapNames = msg.Body.Keys;
+ System.Collections.ArrayList mapNamesList = new System.Collections.ArrayList(mapNames);
+
+ Assert.AreEqual(mapNamesList.Count, 11);
+ Assert.IsTrue(mapNamesList.Contains("boolean"));
+ Assert.IsTrue(mapNamesList.Contains("byte"));
+ Assert.IsTrue(mapNamesList.Contains("bytes1"));
+ Assert.IsTrue(mapNamesList.Contains("char"));
+ Assert.IsTrue(mapNamesList.Contains("double"));
+ Assert.IsTrue(mapNamesList.Contains("float"));
+ Assert.IsTrue(mapNamesList.Contains("int"));
+ Assert.IsTrue(mapNamesList.Contains("long"));
+ Assert.IsTrue(mapNamesList.Contains("object"));
+ Assert.IsTrue(mapNamesList.Contains("short"));
+ Assert.IsTrue(mapNamesList.Contains("string"));
+ }
+
+ [Test]
+ public void TestItemExists()
+ {
+ MapMessage mapMessage = new MapMessage();
+
+ mapMessage.Body.SetString("exists", "test");
+
+ mapMessage = (MapMessage)mapMessage.Clone();
+
+ Assert.IsTrue(mapMessage.Body.Contains("exists"));
+ Assert.IsFalse(mapMessage.Body.Contains("doesntExist"));
+ }
+
+ [Test]
+ public void TestClearBody()
+ {
+ MapMessage mapMessage = new MapMessage();
+ mapMessage.Body.SetString("String", "String");
+ mapMessage.ClearBody();
+ Assert.IsFalse(mapMessage.ReadOnlyBody);
+
+ mapMessage.OnSend();
+ mapMessage.Content = mapMessage.Content;
+ Assert.IsNull(mapMessage.Body.GetString("String"));
+ mapMessage.ClearBody();
+ mapMessage.Body.SetString("String", "String");
+
+ mapMessage = (MapMessage)mapMessage.Clone();
+
+ mapMessage.Body.GetString("String");
+ }
+
+ [Test]
+ public void TestReadOnlyBody()
+ {
+ MapMessage msg = new MapMessage();
+ msg.Body.SetBool("boolean", true);
+ msg.Body.SetByte("byte", (byte)1);
+ msg.Body["bytes"] = new byte[1];
+ msg.Body.SetChar("char", 'a');
+ msg.Body.SetDouble("double", 1.5);
+ msg.Body.SetFloat("float", 1.5f);
+ msg.Body.SetInt("int", 1);
+ msg.Body.SetLong("long", 1);
+ msg.Body["object"] = "stringObj";
+ msg.Body.SetShort("short", (short)1);
+ msg.Body.SetString("string", "string");
+
+ msg.ReadOnlyBody = true;
+
+ try
+ {
+ msg.Body.GetBool("boolean");
+ msg.Body.GetByte("byte");
+ Assert.IsNotNull(msg.Body["bytes"]);
+ msg.Body.GetChar("char");
+ msg.Body.GetDouble("double");
+ msg.Body.GetFloat("float");
+ msg.Body.GetInt("int");
+ msg.Body.GetLong("long");
+ Assert.IsNotNull(msg.Body["object"]);
+ msg.Body.GetShort("short");
+ msg.Body.GetString("string");
+ }
+ catch(MessageNotReadableException)
+ {
+ Assert.Fail("should be readable");
+ }
+
+ try
+ {
+ msg.Body.SetBool("boolean", true);
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+
+ try
+ {
+ msg.Body.SetByte("byte", (byte)1);
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+
+ try
+ {
+ msg.Body["bytes"] = new byte[1];
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+
+ try
+ {
+ msg.Body.SetChar("char", 'a');
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+
+ try
+ {
+ msg.Body.SetDouble("double", 1.5);
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+
+ try {
+ msg.Body.SetFloat("float", 1.5f);
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+
+ try
+ {
+ msg.Body.SetInt("int", 1);
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+
+ try
+ {
+ msg.Body.SetLong("long", 1);
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+
+ try
+ {
+ msg.Body["object"] = "stringObj";
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+
+ try
+ {
+ msg.Body.SetShort("short", (short)1);
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+
+ try
+ {
+ msg.Body.SetString("string", "string");
+ Assert.Fail("should throw exception");
+ }
+ catch(MessageNotWriteableException)
+ {
+ }
+ }
+
+ [Test]
+ public void TestWriteOnlyBody()
+ {
+ MapMessage msg = new MapMessage();
+ msg.ReadOnlyBody = false;
+
+ msg.Body.SetBool("boolean", true);
+ msg.Body.SetByte("byte", (byte)1);
+ msg.Body["bytes"] = new byte[1];
+ msg.Body.SetChar("char", 'a');
+ msg.Body.SetDouble("double", 1.5);
+ msg.Body.SetFloat("float", 1.5f);
+ msg.Body.SetInt("int", 1);
+ msg.Body.SetLong("long", 1);
+ msg.Body["object"] = "stringObj";
+ msg.Body.SetShort("short", (short)1);
+ msg.Body.SetString("string", "string");
+
+ msg.ReadOnlyBody = true;
+
+ msg.Body.GetBool("boolean");
+ msg.Body.GetByte("byte");
+ Assert.IsNotNull(msg.Body["bytes"]);
+ msg.Body.GetChar("char");
+ msg.Body.GetDouble("double");
+ msg.Body.GetFloat("float");
+ msg.Body.GetInt("int");
+ msg.Body.GetLong("long");
+ Assert.IsNotNull(msg.Body["object"]);
+ msg.Body.GetShort("short");
+ msg.Body.GetString("string");
+ }
+
+ }
+}
Propchange: activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/src/test/csharp/Commands/MapMessageTest.cs
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/src/test/csharp/Commands/MapMessageTest.cs
------------------------------------------------------------------------------
svn:executable = *
Modified: activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/vs2008-stomp-test.csproj
URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/vs2008-stomp-test.csproj?rev=898992&r1=898991&r2=898992&view=diff
==============================================================================
--- activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/vs2008-stomp-test.csproj (original)
+++ activemq/activemq-dotnet/Apache.NMS.Stomp/trunk/vs2008-stomp-test.csproj Wed Jan 13 23:09:39 2010
@@ -100,5 +100,6 @@
<Compile Include="src\test\csharp\Commands\TextMessageTest.cs" />
<Compile Include="src\test\csharp\NMSConnectionFactoryTest.cs" />
<Compile Include="src\test\csharp\Threads\DedicatedTaskRunnerTest.cs" />
+ <Compile Include="src\test\csharp\Commands\MapMessageTest.cs" />
</ItemGroup>
</Project>
\ No newline at end of file