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                 static RuntimeTypeHandle handle;
  98
  99                 [Test]
 100                 [ExpectedException (typeof (ArgumentException))]
 101                 public void RunClassConstructor_Uninitialized ()
 102                 {
 103                         RuntimeHelpers.RunClassConstructor (handle);
 104                 }
 105
 106                 class Thrower {
 107                         static Thrower ()
 108                         {
 109                                 throw new NotFiniteNumberException ();
 110                         }
 111                 }
 112
 113                 [Test]
 114                 [ExpectedException (typeof (TypeInitializationException))]
 115                 public void RunClassConstructor_Throw ()
 116                 {
 117                         RuntimeHelpers.RunClassConstructor (typeof (Thrower).TypeHandle);
 118                 }
 119
 120                 class Fielder {
 121                         public byte [] array = new byte [1];
 122                 }
 123
 124                 static RuntimeFieldHandle rfh = typeof (Fielder).GetField ("array").FieldHandle;
 125                 static RuntimeFieldHandle static_rfh;
 126
 127                 [Test]
 128                 [ExpectedException (typeof (ArgumentNullException))]
 129                 public void InitializeArray_Null ()
 130                 {
 131                         RuntimeHelpers.InitializeArray (null, rfh);
 132                 }
 133
 134                 [Test]
 135                 [ExpectedException (typeof (ArgumentNullException))]
 136                 public void InitializeArray_Default ()
 137                 {
 138                         RuntimeFieldHandle h = new RuntimeFieldHandle ();
 139                         RuntimeHelpers.InitializeArray (new Fielder ().array, h);
 140                 }
 141
 142                 [Test]
 143                 [ExpectedException (typeof (ArgumentNullException))]
 144                 public void InitializeArray_Uninitialized ()
 145                 {
 146                         RuntimeHelpers.InitializeArray (new Fielder ().array, static_rfh);
 147                 }
 148
 149                 [Test]
 150                 [ExpectedException (typeof (ArgumentException))]
 151                 public void InitializeArray ()
 152                 {
 153                         RuntimeHelpers.InitializeArray (new Fielder ().array, rfh);
 154                 }
 155
 156                 public void TestGetHashCode ()
 157                 {
 158                         Assert.AreEqual (0, RuntimeHelpers.GetHashCode (null));
 159                         object o = new object ();
 160                         Assert.AreEqual (o.GetHashCode (), RuntimeHelpers.GetHashCode (o));
 161                         Assert.IsTrue (5 != RuntimeHelpers.GetHashCode (new FooClass ()));
 162                 }
 163
 164                 public void TestEquals ()
 165                 {
 166                         Assert.IsTrue (RuntimeHelpers.Equals (null, null));
 167                         Assert.IsTrue (!RuntimeHelpers.Equals (new object (), null));
 168                         Assert.IsTrue (!RuntimeHelpers.Equals (null, new object ()));
 169
 170                         FooStruct f1 = new FooStruct ();
 171                         f1.i = 5;
 172                         FooStruct f2 = new FooStruct ();
 173                         f2.i = 5;
 174                         object o1 = f1;
 175                         object o2 = o1;
 176                         object o3 = f2;
 177                         object o4 = "AAA";
 178                         Assert.IsTrue (RuntimeHelpers.Equals (o1, o2));
 179
 180                         // This should do a bit-by-bit comparison for valuetypes
 181                         Assert.IsTrue (RuntimeHelpers.Equals (o1, o3));
 182                         Assert.IsTrue (!RuntimeHelpers.Equals (o1, o4));
 183                 }
 184         }
 185 }