mcs/class/corlib/Test/System.Runtime.CompilerServices/RuntimeHelpersTest.cs

   1 //
   2 // RuntimeHelpersTest.cs - NUnit Test Cases for the System.Runtime.CompilerServices.RuntimeHelpers class
   3 //
   4 // Zoltan Varga (vargaz@freemail.hu)
   5 //
   6 // (C) Ximian, Inc.  http://www.ximian.com
   7
   8 using System;
   9 using System.Runtime.CompilerServices;
  10
  11 using NUnit.Framework;
  12
  13 namespace MonoTests.System.Runtime.CompilerServices {
  14
  15         [TestFixture]
  16         public class RuntimeHelpersTest {
  17             struct FooStruct {
  18                         public int i;
  19                         public string j;
  20
  21                         public override int GetHashCode () {
  22                                 return 5;
  23                         }
  24
  25                         public override bool Equals (object o) {
  26                                 Assert.Fail ();
  27                                 return false;
  28                         }
  29                 }
  30
  31                 class FooClass {
  32                         public static int counter = 0;
  33
  34                         static FooClass () {
  35                                 counter = counter + 1;
  36                         }
  37
  38                         public override int GetHashCode () {
  39                                 return 5;
  40                         }
  41
  42                         public override bool Equals (object o) {
  43                                 Assert.Fail ();
  44                                 return true;
  45                         }
  46                 }
  47
  48                 public void TestOffsetToStringData ()
  49                 {
  50                         Assert.AreEqual (
  51                                                   RuntimeHelpers.OffsetToStringData,
  52                                                   RuntimeHelpers.OffsetToStringData, "OffsetToStringData is not constant");
  53                 }
  54
  55                 public void TestGetObjectValue ()
  56                 {
  57                         FooStruct s1;
  58                         FooStruct s2;
  59
  60                         // Test null
  61                         Assert.AreEqual (RuntimeHelpers.GetObjectValue (null),
  62                                                   null);
  63
  64                         // Test non-valuetype
  65                         Assert.AreEqual (RuntimeHelpers.GetObjectValue (this),
  66                                                   this);
  67
  68                         // Test valuetype
  69                         s1.i = 42;
  70                         s1.j = "FOO";
  71                         s2 = (FooStruct)RuntimeHelpers.GetObjectValue(s1);
  72                         s1.i = 43;
  73                         s1.j = "BAR";
  74                         Assert.AreEqual (s2.i, 42);
  75                         Assert.AreEqual (s2.j, "FOO");
  76                 }
  77
  78                 public void TestRunClassConstructor ()
  79                 {
  80                         RuntimeHelpers.RunClassConstructor (typeof(FooClass).TypeHandle);
  81                         Assert.AreEqual (FooClass.counter, 1);
  82
  83                         // Each static constructor should only be run once
  84                         RuntimeHelpers.RunClassConstructor (typeof(FooClass).TypeHandle);
  85                         Assert.AreEqual (FooClass.counter, 1);
  86                 }
  87
  88                 [Test]
  89                 [ExpectedException (typeof (ArgumentException))]
  90                 public void RunClassConstructor_Default ()
  91                 {
  92                         RuntimeTypeHandle rth = new RuntimeTypeHandle ();
  93                         Assert.AreEqual (IntPtr.Zero, rth.Value, "Value");
  94                         RuntimeHelpers.RunClassConstructor (rth);
  95                 }
  96
  97                 // Expected the handle here is that way, because we are going to test for an ArgumentException being thrown
  98 #pragma warning disable 649
  99                 static RuntimeTypeHandle handle;
 100 #pragma warning restore 649
 101                 [Test]
 102                 [ExpectedException (typeof (ArgumentException))]
 103                 public void RunClassConstructor_Uninitialized ()
 104                 {
 105                         RuntimeHelpers.RunClassConstructor (handle);
 106                 }
 107
 108                 class Thrower {
 109                         static Thrower ()
 110                         {
 111                                 throw new NotFiniteNumberException ();
 112                         }
 113                 }
 114
 115                 [Test]
 116                 [ExpectedException (typeof (TypeInitializationException))]
 117                 public void RunClassConstructor_Throw ()
 118                 {
 119                         RuntimeHelpers.RunClassConstructor (typeof (Thrower).TypeHandle);
 120                 }
 121
 122                 class Fielder {
 123                         public byte [] array = new byte [1];
 124                 }
 125
 126                 static RuntimeFieldHandle rfh = typeof (Fielder).GetField ("array").FieldHandle;
 127
 128                 // Disable expected warning: the point of the test is to validate that an exception is thrown for something with a null (the default value in this case)
 129                 #pragma warning disable  649
 130                 static RuntimeFieldHandle static_rfh;
 131                 #pragma warning restore 649
 132
 133                 [Test]
 134                 [ExpectedException (typeof (ArgumentNullException))]
 135                 public void InitializeArray_Null ()
 136                 {
 137                         RuntimeHelpers.InitializeArray (null, rfh);
 138                 }
 139
 140                 [Test]
 141                 [ExpectedException (typeof (ArgumentNullException))]
 142                 public void InitializeArray_Default ()
 143                 {
 144                         RuntimeFieldHandle h = new RuntimeFieldHandle ();
 145                         RuntimeHelpers.InitializeArray (new Fielder ().array, h);
 146                 }
 147
 148                 [Test]
 149                 [ExpectedException (typeof (ArgumentNullException))]
 150                 public void InitializeArray_Uninitialized ()
 151                 {
 152                         RuntimeHelpers.InitializeArray (new Fielder ().array, static_rfh);
 153                 }
 154
 155                 [Test]
 156                 [ExpectedException (typeof (ArgumentException))]
 157                 public void InitializeArray ()
 158                 {
 159                         RuntimeHelpers.InitializeArray (new Fielder ().array, rfh);
 160                 }
 161
 162                 public void TestGetHashCode ()
 163                 {
 164                         Assert.AreEqual (0, RuntimeHelpers.GetHashCode (null));
 165                         object o = new object ();
 166                         Assert.AreEqual (o.GetHashCode (), RuntimeHelpers.GetHashCode (o));
 167                         Assert.IsTrue (5 != RuntimeHelpers.GetHashCode (new FooClass ()));
 168                 }
 169
 170                 public void TestEquals ()
 171                 {
 172                         Assert.IsTrue (RuntimeHelpers.Equals (null, null));
 173                         Assert.IsTrue (!RuntimeHelpers.Equals (new object (), null));
 174                         Assert.IsTrue (!RuntimeHelpers.Equals (null, new object ()));
 175
 176                         FooStruct f1 = new FooStruct ();
 177                         f1.i = 5;
 178                         FooStruct f2 = new FooStruct ();
 179                         f2.i = 5;
 180                         object o1 = f1;
 181                         object o2 = o1;
 182                         object o3 = f2;
 183                         object o4 = "AAA";
 184                         Assert.IsTrue (RuntimeHelpers.Equals (o1, o2));
 185
 186                         // This should do a bit-by-bit comparison for valuetypes
 187                         Assert.IsTrue (RuntimeHelpers.Equals (o1, o3));
 188                         Assert.IsTrue (!RuntimeHelpers.Equals (o1, o4));
 189                 }
 190         }
 191 }