NaCl runtime fixes

[mono.git] / mono / mini / arrays.cs

diff --git a/mono/mini/arrays.cs b/mono/mini/arrays.cs
index 0bd8bb300fa2bb58492559bc80f776a3ef87f7c5..e65e30a203f73d038a0ead499237957e72e07157 100644 (file)
--- a/mono/mini/arrays.cs
+++ b/mono/mini/arrays.cs
@@ -25,8 +25,8 @@ using System.Reflection;
 
 class Tests {
 
-       static int Main () {
-               return TestDriver.RunTests (typeof (Tests));
+       public static int Main (string[] args) {
+               return TestDriver.RunTests (typeof (Tests), args);
        }
        
        public static int test_10_create () {
@@ -434,9 +434,31 @@ class Tests {
                if (sum != 1800)
                        return 12;
 
+               /* Null check */
+               object[,] a13 = null;
+               try {
+                       a13 [0, 0] = new Object ();
+                       return 13;
+               } catch (NullReferenceException) {
+               }
+
                return 0;
        }
 
+       public static int test_100_3_dimensional_arrays () {
+        int[,,] test = new int[10, 10, 10];
+
+               test [1, 1, 1] = 100;
+               return test [1, 1, 1];
+       }
+
+       public static int test_100_4_dimensional_arrays () {
+        int[,,,] test = new int[10, 10, 10, 10];
+
+               test [1, 1, 1, 1] = 100;
+               return test [1, 1, 1, 1];
+       }
+
        public static int test_0_bug_71454 () {
                int[,] a = new int[4,4];
                int[,] b = new int[4,4];
@@ -610,7 +632,109 @@ class Tests {
                return 0;
        }
 
-       public static int long_indices () {
+       public enum IntEnum {
+               A,B,C
+       }
+
+       public enum UintEnum : uint {
+               A,B,C
+       }
+
+       static bool TryCast<T> (object o) {
+               return o is T[];
+       }
+
+       public static int test_0_primitive_array_cast () {
+               object a = new int[1];
+               object b = new uint[1];
+               object c = new IntEnum[1];
+               object d = new UintEnum[1];
+
+               object[] arr = new object[] { a, b, c, d };
+               int err = 1;
+
+               foreach (var v in arr) {
+                       if (!TryCast<int> (v))
+                               return err;
+                       if (!TryCast<uint> (v))
+                               return err + 1;
+                       if (!TryCast<IntEnum> (v))
+                               return err + 2;
+                       if (!TryCast<UintEnum> (v))
+                               return err + 3;
+                       err += 4;
+               }
+
+               foreach (var v in arr) {
+                       if (!(v is int[]))
+                               return err;
+                       if (!(v is uint[]))
+                               return err;
+                       if (!(v is IntEnum[]))
+                               return err;
+                       if (!(v is UintEnum[]))
+                               return err;
+                       err += 4;
+               }
+               return 0;
+       }
+
+       public static int test_0_intptr_array_cast () {
+               object[] a = new object[] { new int[1], new uint[1] };
+               object[] b = new object[] { new long[1], new ulong[1] };
+               object[] c = new object[] { new IntPtr[1], new UIntPtr[1] };
+
+               int err = 1;
+               if (IntPtr.Size == 4) {
+                       foreach (var v in a) {
+                               if (!(v is IntPtr[]))
+                                       return err;
+                               if (!(v is IntPtr[]))
+                                       return err;
+                               err += 2;
+                       }
+                       foreach (var v in b) {
+                               if (v is IntPtr[])
+                                       return err;
+                               if (v is IntPtr[])
+                                       return err;
+                               err += 2;
+                       }
+
+                       foreach (var v in c) {
+                               if (!(v is int[]))
+                                       return err;
+                               if (!(v is uint[]))
+                                       return err;
+                               err += 2;
+                       }
+               } else {
+                       foreach (var v in a) {
+                               if (v is IntPtr[])
+                                       return err;
+                               if (v is IntPtr[])
+                                       return err;
+                               err += 2;
+                       }
+                       foreach (var v in b) {
+                               if (!(v is IntPtr[]))
+                                       return err;
+                               if (!(v is IntPtr[]))
+                                       return err;
+                               err += 2;
+                       }
+                       foreach (var v in c) {
+                               if (!(v is long[]))
+                                       return err;
+                               if (!(v is ulong[]))
+                                       return err;
+                               err += 2;
+                       }
+               }
+               return 0;
+       }
+
+       public static int test_0_long_indices () {
                int[] arr = new int [10];
                int[,] arr2 = new int [10, 10];
                long index = 1;
@@ -622,6 +746,16 @@ class Tests {
                        return 2;
                return 0;
        }
+
+       // #7438
+       public static int test_0_ldelema_2_64bit () {
+        bool[,] test = new bool[201,201];
+        int x,y;
+        for(x=-100;x<100;x++) for(y=-100;y<100;y++){
+            test[x+100,y+100] = true;
+        }
+               return 0;
+       }               
 }