using System;
using System.Reflection;
+using System.Runtime.CompilerServices;
/*
* Regression tests for the mono JIT.
*
* Each test needs to be of the form:
*
- * static int test_<result>_<name> ();
+ * public static int test_<result>_<name> ();
*
* where <result> is an integer (the value that needs to be returned by
* the method to make it pass.
class Tests {
- static int Main () {
+ public static int Main () {
return TestDriver.RunTests (typeof (Tests));
}
- static int test_0_catch () {
+ public static int test_0_catch () {
Exception x = new Exception ();
try {
return 1;
}
- static int test_0_finally_without_exc () {
+ public static int test_0_finally_without_exc () {
int x;
try {
return x;
}
- static int test_0_finally () {
+ public static int test_0_finally () {
int x = 1;
try {
return x;
}
- static int test_0_nested_finally () {
+ public static int test_0_nested_finally () {
int a;
try {
return a;
}
- static int test_0_byte_cast () {
+ public static int test_0_byte_cast () {
int a;
long l;
+ ulong ul;
byte b = 0;
bool failed;
if (b != 0)
return -2;
+
try {
a = 256;
failed = true;
return 12;
if (b != 0)
return -12;
-
+
+ try {
+ ul = 256;
+ failed = true;
+ checked {
+ b = (byte)ul;
+ }
+ }
+ catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 13;
+ if (b != 0)
+ return -13;
+
return 0;
}
- static int test_0_sbyte_cast () {
+ public static int test_0_sbyte_cast () {
int a;
long l;
sbyte b = 0;
if (failed)
return 20;
if (b != 127)
- return -19;
+ return -20;
+
+ try {
+ ulong ul = 128;
+ failed = true;
+ checked {
+ b = (sbyte)ul;
+ }
+ }
+ catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 21;
+ if (b != 127)
+ return -21;
return 0;
}
- static int test_0_ushort_cast () {
+ public static int test_0_ushort_cast () {
int a;
long l;
+ ulong ul;
ushort b;
bool failed;
if (failed)
return 12;
+ try {
+ ul = 0xfffff;
+ failed = true;
+ checked {
+ b = (ushort)ul;
+ }
+ } catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 13;
+
return 0;
}
- static int test_0_short_cast () {
+ public static int test_0_short_cast () {
int a;
long l;
short b;
if (failed)
return 16;
+ try {
+ l = 0x00000000ffffffff;
+ failed = true;
+ checked {
+ b = (short)l;
+ }
+ } catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 17;
+
+ try {
+ ulong ul = 32768;
+ failed = true;
+ checked {
+ b = (short)ul;
+ }
+ } catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 18;
+
return 0;
}
- static int test_0_int_cast () {
+ public static int test_0_int_cast () {
int a;
long l;
bool failed;
if (failed)
return 8;
+ try {
+ uint ui = System.UInt32.MaxValue;
+ failed = true;
+ checked {
+ a = (int)ui;
+ }
+ }
+ catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 9;
+
+ try {
+ ulong ul = (long)(System.Int32.MaxValue) + 1;
+ failed = true;
+ checked {
+ a = (int)ul;
+ }
+ }
+ catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 10;
+
+ try {
+ ulong ul = UInt64.MaxValue;
+ failed = true;
+ checked {
+ a = (int)ul;
+ }
+ }
+ catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 11;
+
{
int i;
float f = 1.1f;
return 0;
}
- static int test_0_uint_cast () {
+ public static int test_0_uint_cast () {
uint a;
long l;
bool failed;
if (failed)
return 8;
+ try {
+ int i = -1;
+ failed = true;
+ checked {
+ a = (uint)i;
+ }
+ }
+ catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 9;
+
{
uint i;
float f = 1.1f;
return 0;
}
- static int test_0_long_cast () {
+ public static int test_0_long_cast () {
+
+ /*
+ * These tests depend on properties of x86 fp arithmetic so they won't work
+ * on other platforms.
+ */
+ /*
long a;
bool failed;
if (failed)
return 2;
-
try {
double d = System.Int64.MinValue - 1024.0;
failed = false;
}
if (failed)
return 4;
+ */
{
long i;
return 0;
}
- static int test_0_ulong_cast () {
+ public static int test_0_ulong_cast () {
ulong a;
bool failed;
+ /*
+ * These tests depend on properties of x86 fp arithmetic so they won't work
+ * on other platforms.
+ */
+
+ /*
try {
double d = System.UInt64.MaxValue - 1024.0;
failed = true;
}
if (failed)
return 2;
-
+ */
try {
double d = 0;
}
}
+ try {
+ int i = -1;
+ failed = true;
+ checked {
+ a = (ulong)i;
+ }
+ }
+ catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 5;
+
+ try {
+ int i = Int32.MinValue;
+ failed = true;
+ checked {
+ a = (ulong)i;
+ }
+ }
+ catch (OverflowException) {
+ failed = false;
+ }
+ if (failed)
+ return 6;
+
return 0;
}
- static int test_0_simple_double_casts () {
+ public static int test_0_simple_double_casts () {
double d = 0xffffffff;
if ((uint)d != 4294967295)
return 1;
+ /*
+ * These tests depend on properties of x86 fp arithmetic so they won't work
+ * on other platforms.
+ */
+ /*
d = 0xffffffffffffffff;
if ((ulong)d != 0)
if ((byte)d != 0)
return 4;
+ */
d = 0xffff;
return 0;
}
- static int test_0_div_zero () {
+ public static int test_0_div_zero () {
int d = 1;
int q = 0;
int val;
return 0;
}
- static int return_55 () {
+ public static int return_55 () {
return 55;
}
- static int test_0_cfold_div_zero () {
+ public static int test_0_cfold_div_zero () {
// Test that constant folding doesn't cause division by zero exceptions
if (return_55 () != return_55 ()) {
int d = 1;
return 0;
}
- static int test_0_udiv_zero () {
+ public static int test_0_udiv_zero () {
uint d = 1;
uint q = 0;
uint val;
return 0;
}
- static int test_0_long_div_zero () {
+ public static int test_0_long_div_zero () {
long d = 1;
long q = 0;
long val;
return 0;
}
- static int test_0_ulong_div_zero () {
+ public static int test_0_ulong_div_zero () {
ulong d = 1;
ulong q = 0;
ulong val;
return 0;
}
- static int test_0_float_div_zero () {
+ public static int test_0_float_div_zero () {
double d = 1;
double q = 0;
double val;
return 0;
}
- static int test_0_invalid_unbox () {
+ public static int test_0_invalid_unbox () {
int i = 123;
object o = "Some string";
}
// Test that double[] can't be cast to double (bug #46027)
- static int test_0_invalid_unbox_arrays () {
+ public static int test_0_invalid_unbox_arrays () {
double[] d1 = { 1.0 };
double[][] d2 = { d1 };
Array a = d2;
* jumps out of multiple exception clauses: we used to execute just
* one enclosing finally block.
*/
- static int finally_level;
+ public static int finally_level;
static void do_something () {
int a = 0;
try {
}
}
- static int test_2_multiple_finally_clauses () {
+ public static int test_2_multiple_finally_clauses () {
finally_level = 0;
do_something ();
if (finally_level == 1)
return 0;
}
- static int test_3_checked_cast_un () {
+ public static int test_3_checked_cast_un () {
ulong i = 0x8000000034000000;
long j;
return 3;
}
- static int test_4_checked_cast () {
+ public static int test_4_checked_cast () {
long i;
ulong j;
7, 0, 7, 1, 7, 2, 7, 3, 7, 4, 7, 5, 7, 6, 7, 7, 7, 8,
};
- static int test_0_multi_dim_array_access () {
+ public static int test_0_multi_dim_array_access () {
int [,] a = System.Array.CreateInstance (typeof (int),
new int [] {3,6}, new int [] {2,2 }) as int[,];
int x, y;
o = "buddy";
}
- static int test_2_array_mismatch () {
+ public static int test_2_array_mismatch () {
string[] a = { "hello", "world" };
object[] b = a;
bool passed = false;
return 2;
}
- static int test_0_ovf () {
- int ocount = 0;
+ public static int test_0_ovf1 () {
+ int exception = 0;
checked {
-
- ocount = 0;
try {
ulong a = UInt64.MaxValue - 1;
ulong t = a++;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 1;
+ }
+ return exception;
+ }
+
+ public static int test_1_ovf2 () {
+ int exception = 0;
- ocount = 0;
+ checked {
try {
ulong a = UInt64.MaxValue;
ulong t = a++;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 1)
- return 2;
+ }
+ return exception;
+ }
+
+ public static int test_0_ovf3 () {
+ int exception = 0;
- ocount = 0;
+ long a = Int64.MaxValue - 1;
+ checked {
try {
- long a = Int64.MaxValue - 1;
long t = a++;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 3;
+ }
+ return exception;
+ }
+ public static int test_1_ovf4 () {
+ int exception = 0;
+
+ long a = Int64.MaxValue;
+ checked {
try {
- long a = Int64.MaxValue;
long t = a++;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 1)
- return 4;
+ }
+ return exception;
+ }
- ocount = 0;
+ public static int test_0_ovf5 () {
+ int exception = 0;
+
+ ulong a = UInt64.MaxValue - 1;
+ checked {
try {
- ulong a = UInt64.MaxValue - 1;
ulong t = a++;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 5;
+ }
+ return exception;
+ }
+
+ public static int test_1_ovf6 () {
+ int exception = 0;
+ ulong a = UInt64.MaxValue;
+ checked {
try {
- ulong a = UInt64.MaxValue;
ulong t = a++;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 1)
- return 6;
+ }
+ return exception;
+ }
+
+ public static int test_0_ovf7 () {
+ int exception = 0;
- ocount = 0;
+ long a = Int64.MinValue + 1;
+ checked {
try {
- long a = Int64.MinValue + 1;
long t = a--;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 7;
+ }
+ return 0;
+ }
- ocount = 0;
+ public static int test_1_ovf8 () {
+ int exception = 0;
+
+ long a = Int64.MinValue;
+ checked {
try {
- long a = Int64.MinValue;
long t = a--;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 1)
- return 8;
+ }
+ return exception;
+ }
+
+ public static int test_0_ovf9 () {
+ int exception = 0;
- ocount = 0;
+ ulong a = UInt64.MinValue + 1;
+ checked {
try {
- ulong a = UInt64.MinValue + 1;
ulong t = a--;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 9;
+ }
+ return exception;
+ }
+
+ public static int test_1_ovf10 () {
+ int exception = 0;
- ocount = 0;
+ ulong a = UInt64.MinValue;
+ checked {
try {
- ulong a = UInt64.MinValue;
ulong t = a--;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 1)
- return 10;
+ }
+ return exception;
+ }
+
+ public static int test_0_ovf11 () {
+ int exception = 0;
- ocount = 0;
+ int a = Int32.MinValue + 1;
+ checked {
try {
- int a = Int32.MinValue + 1;
int t = a--;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 11;
+ }
+ return exception;
+ }
- ocount = 0;
+ public static int test_1_ovf12 () {
+ int exception = 0;
+
+ int a = Int32.MinValue;
+ checked {
try {
- int a = Int32.MinValue;
int t = a--;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 1)
- return 12;
+ }
+ return exception;
+ }
+
+ public static int test_0_ovf13 () {
+ int exception = 0;
- ocount = 0;
+ uint a = 1;
+ checked {
try {
- uint a = 1;
uint t = a--;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 13;
+ }
+ return exception;
+ }
- ocount = 0;
+ public static int test_1_ovf14 () {
+ int exception = 0;
+
+ uint a = 0;
+ checked {
try {
- uint a = 0;
uint t = a--;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 1)
- return 14;
+ }
+ return exception;
+ }
+
+ public static int test_0_ovf15 () {
+ int exception = 0;
- ocount = 0;
+ sbyte a = 126;
+ checked {
try {
- sbyte a = 126;
sbyte t = a++;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 15;
+ }
+ return exception;
+ }
- ocount = 0;
+ public static int test_1_ovf16 () {
+ int exception = 0;
+
+ sbyte a = 127;
+ checked {
try {
- sbyte a = 127;
sbyte t = a++;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 1)
- return 16;
+ }
+ return exception;
+ }
+
+ public static int test_0_ovf17 () {
+ int exception = 0;
- ocount = 0;
+ checked {
try {
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 17;
+ }
+ return exception;
+ }
+
+ public static int test_0_ovf18 () {
+ int exception = 0;
- ocount = 0;
+ int a = 1 << 29;
+ checked {
try {
- int a = 1 << 29;
int t = a*2;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 18;
+ }
+ return exception;
+ }
+
+ public static int test_1_ovf19 () {
+ int exception = 0;
- ocount = 0;
+ int a = 1 << 30;
+ checked {
try {
- int a = 1 << 30;
int t = a*2;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 1)
- return 19;
+ }
+ return exception;
+ }
- ocount = 0;
+ public static int test_0_ovf20 () {
+ int exception = 0;
+
+ checked {
try {
ulong a = 0xffffffffff;
ulong t = a*0x0ffffff;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 0)
- return 20;
+ }
+ return exception;
+ }
- ocount = 0;
+ public static int test_1_ovf21 () {
+ int exception = 0;
+
+ ulong a = 0xffffffffff;
+ checked {
try {
- ulong a = 0xffffffffff;
ulong t = a*0x0fffffff;
} catch {
- ocount++;
+ exception = 1;
}
- if (ocount != 1)
- return 21;
+ }
+ return exception;
+ }
+
+ public static int test_1_ovf22 () {
+ int exception = 0;
- ocount = 0;
+ long a = Int64.MinValue;
+ long b = 10;
+ checked {
try {
- long a = Int64.MinValue;
- long b = 10;
long v = a * b;
} catch {
- ocount ++;
+ exception = 1;
}
- if (ocount != 1)
- return 22;
+ }
+ return exception;
+ }
- ocount = 0;
+ public static int test_1_ovf23 () {
+ int exception = 0;
+
+ long a = 10;
+ long b = Int64.MinValue;
+ checked {
try {
- long a = 10;
- long b = Int64.MinValue;
long v = a * b;
} catch {
- ocount ++;
+ exception = 1;
}
- if (ocount != 1)
- return 23;
}
-
- return 0;
+ return exception;
}
class Broken {
- static int i;
+ public static int i;
static Broken () {
throw new Exception ("Ugh!");
}
}
- static int test_0_exception_in_cctor () {
+ public static int test_0_exception_in_cctor () {
try {
Broken.DoSomething ();
}
return 0;
}
- static int test_5_regalloc () {
+ public static int test_5_regalloc () {
int i = 0;
try {
return i;
}
+ public static void rethrow () {
+ try {
+ throw new ApplicationException();
+ } catch (ApplicationException) {
+ try {
+ throw new OverflowException();
+ } catch (Exception) {
+ throw;
+ }
+ }
+ }
+
+ // Test that a rethrow rethrows the correct exception
+ public static int test_0_rethrow_nested () {
+ try {
+ rethrow ();
+ } catch (OverflowException) {
+ return 0;
+ } catch (Exception) {
+ return 1;
+ }
+ return 2;
+ }
+
/* MarshalByRefObject prevents the methods from being inlined */
class ThrowClass : MarshalByRefObject {
public static void rethrow1 () {
}
}
- static int test_0_rethrow_stacktrace () {
+ public static int test_0_rethrow_stacktrace () {
// Check that rethrowing an exception preserves the original stack trace
try {
try {
ThrowClass.rethrow2 ();
}
catch (Exception ex) {
+ // Check that each catch clause has its own exception variable
+ // If not, the throw below will overwrite the exception used
+ // by the rethrow
+ try {
+ throw new DivideByZeroException ();
+ }
+ catch (Exception foo) {
+ }
+
throw;
}
}
}
return 1;
- }
+ }
+
+ interface IFace {}
+ class Face : IFace {}
+
+ public static int test_1_array_mismatch_2 () {
+ try {
+ object [] o = new Face [1];
+ o [0] = 1;
+ return 0;
+ } catch (ArrayTypeMismatchException) {
+ return 1;
+ }
+ }
+
+ public static int test_1_array_mismatch_3 () {
+ try {
+ object [] o = new IFace [1];
+ o [0] = 1;
+ return 0;
+ } catch (ArrayTypeMismatchException) {
+ return 1;
+ }
+ }
+
+ public static int test_1_array_mismatch_4 () {
+ try {
+ object [][] o = new Face [5] [];
+ o [0] = new object [5];
+
+ return 0;
+ } catch (ArrayTypeMismatchException) {
+ return 1;
+ }
+ }
+
+ public static int test_0_array_size () {
+ bool failed;
+
+ try {
+ failed = true;
+ int[] mem1 = new int [Int32.MaxValue];
+ }
+ catch (OutOfMemoryException e) {
+ failed = false;
+ }
+ if (failed)
+ return 1;
+
+ try {
+ failed = true;
+ int[,] mem2 = new int [Int32.MaxValue, Int32.MaxValue];
+ }
+ catch (OutOfMemoryException e) {
+ failed = false;
+ }
+ if (failed)
+ return 2;
+
+ return 0;
+ }
+
+ struct S {
+ int i, j, k, l, m, n;
+ }
+
+ static IntPtr[] addr;
+
+ static unsafe void throw_func (int i, S s) {
+ addr [i] = new IntPtr (&i);
+ throw new Exception ();
+ }
+
+ /* Test that arguments are correctly popped off the stack during unwinding */
+ public static int test_0_stack_unwind () {
+ addr = new IntPtr [1000];
+ S s = new S ();
+ for (int j = 0; j < 1000; j++) {
+ try {
+ throw_func (j, s);
+ }
+ catch (Exception) {
+ }
+ }
+ return (addr [0].ToInt64 () - addr [100].ToInt64 () < 100) ? 0 : 1;
+ }
+
+ public static int test_0_regress_73242 () {
+ int [] arr = new int [10];
+ for (int i = 0; i < 10; ++i)
+ arr [i] = 0;
+ try {
+ throw new Exception ();
+ }
+ catch {
+ }
+ return 0;
+ }
+
+ public static int test_0_nullref () {
+ try {
+ Array foo = null;
+ foo.Clone();
+ } catch (NullReferenceException e) {
+ return 0;
+ }
+ return 1;
+ }
+
+ public int amethod () {
+ return 1;
+ }
+
+ public static int test_0_nonvirt_nullref_at_clause_start () {
+ Tests t = null;
+ try {
+ t.amethod ();
+ } catch (NullReferenceException) {
+ return 0;
+ }
+
+ return 1;
+ }
+
+ public static int throw_only () {
+ throw new Exception ();
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static int throw_only2 () {
+ return throw_only ();
+ }
+
+ public static int test_0_inline_throw_only () {
+ try {
+ return throw_only2 ();
+ }
+ catch (Exception ex) {
+ return 0;
+ }
+ }
+
+ public static string GetText (string s) {
+ return s;
+ }
+
+ public static int throw_only_gettext () {
+ throw new Exception (GetText ("FOO"));
+ }
+
+ public static int test_0_inline_throw_only_gettext () {
+ object o = null;
+ try {
+ o = throw_only_gettext ();
+ }
+ catch (Exception ex) {
+ return 0;
+ }
+
+ return o != null ? 0 : 1;
+ }
+
+ // bug #78633
+ public static int test_0_throw_to_branch_opt_outer_clause () {
+ int i = 0;
+
+ try {
+ try {
+ string [] files = new string[1];
+
+ string s = files[2];
+ } finally {
+ i ++;
+ }
+ } catch {
+ }
+
+ return (i == 1) ? 0 : 1;
+ }
+
+ // bug #485721
+ public static int test_0_try_inside_finally_cmov_opt () {
+ bool Reconect = false;
+
+ object o = new object ();
+
+ try {
+ }
+ catch (Exception ExCon) {
+ if (o != null)
+ Reconect = true;
+
+ try {
+ }
+ catch (Exception Last) {
+ }
+ }
+ finally {
+ if (Reconect == true) {
+ try {
+ }
+ catch (Exception ex) {
+ }
+ }
+ }
+
+ return 0;
+ }
+
+ public static int test_0_inline_throw () {
+ try {
+ inline_throw1 (5);
+ return 1;
+ } catch {
+ return 0;
+ }
+ }
+
+ // for llvm, the end bblock is unreachable
+ public static int inline_throw1 (int i) {
+ if (i == 0)
+ throw new Exception ();
+ else
+ return inline_throw2 (i);
+ }
+
+ public static int inline_throw2 (int i) {
+ throw new Exception ();
+ }
+
+ // bug #539550
+ public static int test_0_lmf_filter () {
+ try {
+ // The invoke calls a runtime-invoke wrapper which has a filter clause
+ typeof (Tests).GetMethod ("lmf_filter").Invoke (null, new object [] { });
+ } catch (TargetInvocationException) {
+ }
+ return 0;
+ }
+
+ public static void lmf_filter () {
+ try {
+ Connect ();
+ }
+ catch {
+ throw new NotImplementedException ();
+ }
+ }
+
+ public static void Connect () {
+ Stop ();
+ throw new Exception();
+ }
+
+ public static void Stop () {
+ try {
+ lock (null) {}
+ }
+ catch {
+ }
+ }
+
+ private static void do_raise () {
+ throw new System.Exception ();
+ }
+
+ private static int int_func (int i) {
+ return i;
+ }
+
+ // #559876
+ public static int test_8_local_deadce_causes () {
+ int myb = 4;
+
+ try {
+ myb = int_func (8);
+ do_raise();
+ myb = int_func (2);
+ } catch (System.Exception) {
+ return myb;
+ }
+ return 0;
+ }
+
+ public static int test_0_except_opt_two_clauses () {
+ int size;
+ size = -1;
+ uint ui = (uint)size;
+ try {
+ checked {
+ uint v = ui * (uint)4;
+ }
+ } catch (OverflowException e) {
+ return 0;
+ } catch (Exception) {
+ return 1;
+ }
+
+ return 2;
+ }
+
+ class Child
+ {
+ public virtual long Method()
+ {
+ throw new Exception();
+ }
+ }
+
+ /* #612206 */
+ public static int test_100_long_vars_in_clauses_initlocals_opt () {
+ Child c = new Child();
+ long value = 100;
+ try {
+ value = c.Method();
+ }
+ catch {}
+ return (int)value;
+ }
+
+ class A {
+ public object AnObj;
+ }
+
+ public static void DoSomething (ref object o) {
+ }
+
+ public static int test_0_ldflda_null () {
+ A a = null;
+
+ try {
+ DoSomething (ref a.AnObj);
+ } catch (NullReferenceException) {
+ return 0;
+ }
+
+ return 1;
+ }
+
+ unsafe struct Foo
+ {
+ public int i;
+
+ public static Foo* pFoo;
+ }
+
+ /* MS.NET doesn't seem to throw in this case */
+ public unsafe static int test_0_ldflda_null_pointer () {
+ int* pi = &Foo.pFoo->i;
+
+ return 0;
+ }
}
projects / mono.git / blobdiff