(Path submitted by Tomas Restrepo) Qpid-336 Field table updated to match Java client.

git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk@507096 13f79535-47bb-0310-9956-ffa450edef68

3 files changed, 279 insertions, 1 deletions

diff --git a/qpid/dotnet/Qpid.Common.Tests/Qpid.Common.Tests.csproj b/qpid/dotnet/Qpid.Common.Tests/Qpid.Common.Tests.csproj
index fb9aec55cf..8c5142e690 100644
--- a/qpid/dotnet/Qpid.Common.Tests/Qpid.Common.Tests.csproj
+++ b/qpid/dotnet/Qpid.Common.Tests/Qpid.Common.Tests.csproj
@@ -18,6 +18,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>

     <ErrorReport>prompt</ErrorReport>

     <WarningLevel>4</WarningLevel>

+    <UseVSHostingProcess>true</UseVSHostingProcess>

   </PropertyGroup>

   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

     <DebugType>pdbonly</DebugType>

@@ -39,8 +40,13 @@
   <ItemGroup>

     <Compile Include="Properties\AssemblyInfo.cs" />

     <Compile Include="Qpid\Collections\TestLinkedHashtable.cs" />

+    <Compile Include="Qpid\Framing\TestAMQType.cs" />

   </ItemGroup>

   <ItemGroup>

+    <ProjectReference Include="..\Qpid.Buffer\Qpid.Buffer.csproj">

+      <Project>{44384DF2-B0A4-4580-BDBC-EE4BAA87D995}</Project>

+      <Name>Qpid.Buffer</Name>

+    </ProjectReference>

     <ProjectReference Include="..\Qpid.Common\Qpid.Common.csproj">

       <Project>{77064C42-24D2-4CEB-9EA2-0EF481A43205}</Project>

       <Name>Qpid.Common</Name>

diff --git a/qpid/dotnet/Qpid.Common.Tests/Qpid.Common.Tests.mdp b/qpid/dotnet/Qpid.Common.Tests/Qpid.Common.Tests.mdp
index 2ef60cbca2..e7b74c9756 100644
--- a/qpid/dotnet/Qpid.Common.Tests/Qpid.Common.Tests.mdp
+++ b/qpid/dotnet/Qpid.Common.Tests/Qpid.Common.Tests.mdp
@@ -17,10 +17,12 @@
   <Contents>
     <File name="./Properties/AssemblyInfo.cs" subtype="Code" buildaction="Compile" />
     <File name="./Qpid/Collections/TestLinkedHashtable.cs" subtype="Code" buildaction="Compile" />
+    <File name="./Qpid/Framing/TestAMQType.cs" subtype="Code" buildaction="Compile" />
   </Contents>
   <References>
     <ProjectReference type="Gac" localcopy="True" refto="System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
     <ProjectReference type="Assembly" localcopy="True" refto="../Qpid.Client.Tests/lib/nunit/nunit.framework.dll" />
+    <ProjectReference type="Project" localcopy="True" refto="Qpid.Buffer" />
     <ProjectReference type="Project" localcopy="True" refto="Qpid.Common" />
   </References>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/qpid/dotnet/Qpid.Common.Tests/Qpid/Framing/TestAMQType.cs b/qpid/dotnet/Qpid.Common.Tests/Qpid/Framing/TestAMQType.cs
new file mode 100644
index 0000000000..805d728db6
--- /dev/null
+++ b/qpid/dotnet/Qpid.Common.Tests/Qpid/Framing/TestAMQType.cs
@@ -0,0 +1,270 @@
+/*

+ *

+ * 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 Qpid.Buffer;

+using Qpid.Framing;

+

+namespace Qpid.Framing.Tests

+{

+    [TestFixture]

+    public class TestAMQType

+    {

+

+       #region LONG_STRING tests

+       [Test]

+       public void LONG_STRING_ReadWrite()

+       {

+          AMQType type = AMQType.LONG_STRING;

+          ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+          const string VALUE = "simple string 1";

+

+          type.WriteToBuffer(VALUE, buffer);

+          buffer.flip();

+          buffer.position(0);

+          AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+          Assert.AreEqual(VALUE, value.Value);

+       }

+       #endregion // LONG_STRING tests

+

+       #region UINT32 tests

+       [Test]

+       public void UINT32_CanGetEncodingSize()

+       {

+          AMQType type = AMQType.UINT32;

+          Assert.AreEqual(4, type.GetEncodingSize(1234443));

+       }

+

+       [Test]

+       public void UINT32_ToNativeValue()

+       {

+          AMQType type = AMQType.UINT32;

+          Assert.AreEqual(1, type.ToNativeValue(1));

+          Assert.AreEqual(1, type.ToNativeValue((short)1));

+          Assert.AreEqual(1, type.ToNativeValue((byte)1));

+          Assert.AreEqual(1, type.ToNativeValue("1"));

+

+          try

+          {

+             Assert.AreEqual(1, type.ToNativeValue("adasdads"));

+             Assert.Fail("Invalid format allowed");

+          } catch ( FormatException )

+          {

+          }

+       }

+

+       [Test]

+       public void UINT32_ReadWrite()

+       {

+          AMQType type = AMQType.UINT32;

+          ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+          const uint VALUE = 0xFFEEDDCC;

+

+          type.WriteToBuffer(VALUE, buffer);

+          buffer.flip();

+          buffer.position(0);

+          AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+          Assert.AreEqual(VALUE, value.Value);

+       }

+       #endregion // UINT32 Tests

+

+       #region VOID Tests

+       [Test]

+       public void VOID_CanGetEncodingSize()

+       {

+          AMQType type = AMQType.VOID;

+          Assert.AreEqual(0, type.GetEncodingSize(null));

+       }

+

+       [Test]

+       public void VOID_ToNativeValue()

+       {

+          AMQType type = AMQType.VOID;

+          Assert.IsNull(type.ToNativeValue(null));

+

+          try

+          {

+             type.ToNativeValue("asdasd");

+             Assert.Fail("converted invalid value");

+          } catch (FormatException)

+          {

+          }

+       }

+

+       [Test]

+       public void VOID_ReadWrite()

+       {

+          AMQType type = AMQType.VOID;

+          ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+

+          type.WriteToBuffer(null, buffer);

+          buffer.flip();

+          buffer.position(0);

+          AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+          Assert.AreEqual(null, value.Value);

+       }

+

+       #endregion // VOID Tests

+

+       #region BOOLEAN Tests

+       [Test]

+       public void BOOLEAN_CanGetEncodingSize()

+       {

+          AMQType type = AMQType.BOOLEAN;

+          Assert.AreEqual(1, type.GetEncodingSize(true));

+       }

+

+       [Test]

+       public void BOOLEAN_ToNativeValue()

+       {

+          AMQType type = AMQType.BOOLEAN;

+          Assert.AreEqual(true, type.ToNativeValue(true));

+          Assert.AreEqual(false, type.ToNativeValue("false"));

+

+          try

+          {

+             type.ToNativeValue("asdasd");

+             Assert.Fail("converted invalid value");

+          } catch ( FormatException )

+          {

+          }

+       }

+

+       [Test]

+       public void BOOLEAN_ReadWrite()

+       {

+          AMQType type = AMQType.BOOLEAN;

+          ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+

+          type.WriteToBuffer(true, buffer);

+          buffer.flip();

+          buffer.position(0);

+          AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+          Assert.AreEqual(true, value.Value);

+       }

+       #endregion // BOOLEAN Tests

+

+       #region INT16 tests

+       [Test]

+       public void INT16_ReadWrite()

+       {

+          AMQType type = AMQType.INT16;

+          ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+          const short VALUE = -32765;

+

+          type.WriteToBuffer(VALUE, buffer);

+          buffer.flip();

+          buffer.position(0);

+          AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+          Assert.AreEqual(VALUE, value.Value);

+       }

+       //public void UINT16_ReadWrite()

+       //{

+       //   AMQType type = AMQType.UINT16;

+       //   ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+       //   const ushort VALUE = 64321;

+

+       //   type.WriteToBuffer(VALUE, buffer);

+       //   buffer.flip();

+       //   buffer.position(0);

+       //   AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+       //   Assert.AreEqual(VALUE, value.Value);

+       //}

+       #endregion // INT16 Tests

+

+       #region INT32 tests

+       [Test]

+       public void INT32_ReadWrite()

+       {

+          AMQType type = AMQType.INT32;

+          ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+          const int VALUE = -39273563;

+

+          type.WriteToBuffer(VALUE, buffer);

+          buffer.flip();

+          buffer.position(0);

+          AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+          Assert.AreEqual(VALUE, value.Value);

+       }

+       #endregion // INT32 Tests

+

+       #region INT64 tests

+       [Test]

+       public void INT64_ReadWrite()

+       {

+          AMQType type = AMQType.INT64;

+          ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+          const long VALUE = -(2^43+1233123);

+

+          type.WriteToBuffer(VALUE, buffer);

+          buffer.flip();

+          buffer.position(0);

+          AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+          Assert.AreEqual(VALUE, value.Value);

+       }

+       [Test]

+       public void UINT64_ReadWrite()

+       {

+          AMQType type = AMQType.UINT64;

+          ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+          const ulong VALUE = (2 ^ 61 + 1233123);

+

+          type.WriteToBuffer(VALUE, buffer);

+          buffer.flip();

+          buffer.position(0);

+          AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+          Assert.AreEqual(VALUE, value.Value);

+       }

+       #endregion // INT64 Tests

+

+       #region FLOAT tests

+       [Test]

+       public void FLOAT_ReadWrite()

+       {

+          AMQType type = AMQType.FLOAT;

+          ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+          const float VALUE = 1.2345000E-035f;

+

+          type.WriteToBuffer(VALUE, buffer);

+          buffer.flip();

+          buffer.position(0);

+          AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+          Assert.AreEqual(VALUE, value.Value);

+       }

+       #endregion // FLOAT Tests

+

+       #region DOUBLE tests

+       [Test]

+       public void DOUBLE_ReadWrite()

+       {

+          AMQType type = AMQType.DOUBLE;

+          ByteBuffer buffer = (new SimpleByteBufferAllocator()).Allocate(0x1000, false);

+          const double VALUE = 1.2345000E-045;

+

+          type.WriteToBuffer(VALUE, buffer);

+          buffer.flip();

+          buffer.position(0);

+          AMQTypedValue value = AMQTypedValue.ReadFromBuffer(buffer);

+          Assert.AreEqual(VALUE, value.Value);

+       }

+       #endregion // FLOAT Tests

+    }

+}