Merge pull request #2274 from esdrubal/udpclientreceive

[mono.git] / mcs / class / corlib / Test / System / BufferTest.cs

diff --git a/mcs/class/corlib/Test/System/BufferTest.cs b/mcs/class/corlib/Test/System/BufferTest.cs
index 441b9f4d4c6877b6c4342f9382b0535f4d3788e3..fa979412d0774785ec3e223a88fec262e4ce15c8 100644 (file)
--- a/mcs/class/corlib/Test/System/BufferTest.cs
+++ b/mcs/class/corlib/Test/System/BufferTest.cs
@@ -15,11 +15,10 @@ using System;
 namespace MonoTests.System {
 
        [TestFixture]
-       public class BufferTest : Assertion {
+       public class BufferTest  {
 
                const int SIZE = 10;
                byte [] byteArray  = new byte [SIZE];   // 8-bits unsigned integer array
-               float [] floatArray = new float [SIZE];
                
                [Test]
                public void BlockCopy ()
@@ -31,7 +30,7 @@ namespace MonoTests.System {
                        Buffer.BlockCopy (myArray1, 0, myArray2, 0, SizeOfInt32  * myArray1.Length);
                
                        for (int i = 0; i < myArray1.Length; i++) 
-                               AssertEquals ("TestBlockCopy Error at i=" + i, i + 1, myArray2 [i]);            
+                               Assert.AreEqual (i + 1, myArray2 [i], "TestBlockCopy Error at i=" + i);
                }
 
                [Test]
@@ -150,43 +149,43 @@ namespace MonoTests.System {
                        float [,,,] floatArray4 = new float [10,0,10,10];
                        float [,,,] floatArray5 = new float [0,0,0,0];
                        float [] floatArray6 = new float [0];
-                       TestCase [] someArray = new TestCase [3];
+                       BufferTest [] someArray = new BufferTest [3];
                
                        try {
                                Buffer.ByteLength (null);       
-                               Fail ("TestByteLength: ArgumentNullException not thrown");
+                               Assert.Fail ("TestByteLength: ArgumentNullException not thrown");
                        } catch (ArgumentNullException) {
                                // do nothing, this is expected
                        } catch (Exception e) {
-                               Fail ("Unexpected exception on Buffer.ByteLength (null):" + e);
+                               Assert.Fail ("Unexpected exception on Buffer.ByteLength (null):" + e);
                        }
                
                        try {
                                Buffer.ByteLength (someArray);  
-                               Fail ("TestByteLength: ArgumentException not thrown");
+                               Assert.Fail ("TestByteLength: ArgumentException not thrown");
                        } catch (ArgumentException) {
                                // do nothing, this is expected
                        } catch (Exception e) {
-                               Fail ("Unexpected exception on Buffer.ByteLength (non primitive array):" + e);
+                               Assert.Fail ("Unexpected exception on Buffer.ByteLength (non primitive array):" + e);
                        }
                
                        numBytes = Buffer.ByteLength (floatArray);
-                       AssertEquals ("TestByteLength: wrong byteLength for floatArray", 40, numBytes);
+                       Assert.AreEqual (40, numBytes, "TestByteLength: wrong byteLength for floatArray");
 
                        numBytes = Buffer.ByteLength (floatArray2);
-                       AssertEquals ("TestByteLength: wrong byteLength for floatArray2", 400, numBytes);
+                       Assert.AreEqual (400, numBytes, "TestByteLength: wrong byteLength for floatArray2");
 
                        numBytes = Buffer.ByteLength (floatArray3);
-                       AssertEquals ("TestByteLength: wrong byteLength for floatArray3", 4000, numBytes);
+                       Assert.AreEqual (4000, numBytes, "TestByteLength: wrong byteLength for floatArray3");
 
                        numBytes = Buffer.ByteLength (floatArray4);
-                       AssertEquals ("TestByteLength: wrong byteLength for floatArray4", 0, numBytes);
+                       Assert.AreEqual (0, numBytes, "TestByteLength: wrong byteLength for floatArray4");
 
                        numBytes = Buffer.ByteLength (floatArray5);
-                       AssertEquals ("TestByteLength: wrong byteLength for floatArray5", 0, numBytes);
+                       Assert.AreEqual (0, numBytes, "TestByteLength: wrong byteLength for floatArray5");
 
                        numBytes = Buffer.ByteLength (floatArray6);
-                       AssertEquals ("TestByteLength: wrong byteLength for floatArray6", 0, numBytes);
+                       Assert.AreEqual (0, numBytes, "TestByteLength: wrong byteLength for floatArray6");
                }
                
                [Test]
@@ -196,15 +195,14 @@ namespace MonoTests.System {
                        bool errorThrown = false;
                        byteArray = new byte [10];
                        byteArray [5] = 8;
-                       TestCase [] someArray = new TestCase [3];
+                       BufferTest [] someArray = new BufferTest [3];
                
                        try {
                                Buffer.GetByte (null, 5);
                        } catch (ArgumentNullException) {
                                errorThrown = true;
                        }
-                       Assert ("TestGetByte: ArgumentNullException not thrown",
-                               errorThrown);
+                       Assert.IsTrue (errorThrown, "TestGetByte: ArgumentNullException not thrown");
                
                        errorThrown = false;
                
@@ -213,8 +211,7 @@ namespace MonoTests.System {
                        } catch (ArgumentOutOfRangeException) {
                                errorThrown = true;
                        }
-                       Assert ("TestGetByte: ArgumentOutOfRangeException (negative index) not implemented",
-                               errorThrown);
+                       Assert.IsTrue (errorThrown, "TestGetByte: ArgumentOutOfRangeException (negative index) not implemented");
                
                        errorThrown = false;
                
@@ -223,34 +220,34 @@ namespace MonoTests.System {
                        } catch (ArgumentOutOfRangeException) {
                                errorThrown = true;
                        }
-                       Assert ("TestGetByte: ArgumentOutOfRangeException (index bigger/equal than array's size not thrown", errorThrown);
+                       Assert.IsTrue (errorThrown, "TestGetByte: ArgumentOutOfRangeException (index bigger/equal than array's size not thrown");
                
                        errorThrown = false;
                
                        try {
                                Buffer.GetByte (someArray, 0);  
-                               Fail ("TestGetByte: ArgumentException not thrown");
+                               Assert.Fail ("TestGetByte: ArgumentException not thrown");
                        } catch (ArgumentException) {
                                // do nothing, this is expected
                        } catch (Exception e) {
-                               Fail ("Unexpected exception on Buffer.GetByte (non primitive array):" + e);
+                               Assert.Fail ("Unexpected exception on Buffer.GetByte (non primitive array):" + e);
                        }
                
-                       AssertEquals ("TestGetByte Error", (Byte)8, Buffer.GetByte (byteArray, 5));
+                       Assert.AreEqual ((Byte)8, Buffer.GetByte (byteArray, 5), "TestGetByte Error");
                }
        
                [Test]
                public void SetByte ()
                {
                        bool errorThrown = false;
-                       TestCase [] someArray = new TestCase [3];
+                       BufferTest [] someArray = new BufferTest [3];
                
                        try {
                                Buffer.SetByte (null, 5, 12);
                        } catch (ArgumentNullException) {
                                errorThrown = true;
                        }
-                       Assert ("TestSetByte: ArgumentNullException not thrown", errorThrown);
+                       Assert.IsTrue (errorThrown, "TestSetByte: ArgumentNullException not thrown");
                        errorThrown = false;
                
                        try {
@@ -258,8 +255,7 @@ namespace MonoTests.System {
                        } catch (ArgumentOutOfRangeException) {
                                errorThrown = true;
                        }
-                       Assert ("TestSetByte: ArgumentOutOfRangeException (case: negative index) not thrown",
-                               errorThrown);
+                       Assert.IsTrue (errorThrown, "TestSetByte: ArgumentOutOfRangeException (case: negative index) not thrown");
                        errorThrown = false;
                
                        try {
@@ -267,21 +263,33 @@ namespace MonoTests.System {
                        } catch (ArgumentOutOfRangeException) {
                                errorThrown = true;
                        }
-                       Assert ("TestSetByte: ArgumentOutOfRangeException (case: index bigger/equal than array'size",
-                               errorThrown);
+                       Assert.IsTrue (errorThrown, "TestSetByte: ArgumentOutOfRangeException (case: index bigger/equal than array'size");
                        errorThrown = false;
                
                        try {
                                Buffer.SetByte (someArray, 0, 42);      
-                               Fail ("TestSetByte: ArgumentException not thrown");
+                               Assert.Fail ("TestSetByte: ArgumentException not thrown");
                        } catch (ArgumentException) {
                                // do nothing, this is expected
                        } catch (Exception e) {
-                               Fail ("Unexpected exception on Buffer.SetByte (non primitive array):" + e);
+                               Assert.Fail ("Unexpected exception on Buffer.SetByte (non primitive array):" + e);
                        }
                
                        Buffer.SetByte (byteArray, 3, (byte) 10);
-                       AssertEquals ("TestSetByte", (Byte)10, Buffer.GetByte (byteArray, 3));
+                       Assert.AreEqual ((Byte)10, Buffer.GetByte (byteArray, 3), "TestSetByte");
+               }
+
+               [Test]
+               public void MemoryCopy_Simple ()
+               {
+                       int a = 0xBC614E;
+                       int b = 1;
+                       unsafe {
+                               Buffer.MemoryCopy (&a, &b, 4, 2);                               
+                       }
+
+                       Assert.AreEqual (0xBC614E, a, "#1");
+                       Assert.AreEqual (0x614E, b, "#2");
                }
        }
 }