+ struct LargeStruct {
+ public int a, b, c, d;
+ }
+
+ [MethodImplAttribute (MethodImplOptions.NoInlining)]
+ public static bool GetHasValue<T>(T? value) where T : struct
+ {
+ return value.HasValue;
+ }
+
+ [Category ("DYNCALL")]
+ [Category ("!FULLAOT-AMD64")]
+ public static int test_0_large_nullable_invoke () {
+ var s = new LargeStruct () { a = 1, b = 2, c = 3, d = 4 };
+
+ GetHasValue<LargeStruct> (s);
+
+#if __MOBILE__
+ var m = typeof(AotTests).GetMethod("GetHasValue", BindingFlags.Static | BindingFlags.Public);
+#else
+ var m = typeof(Tests).GetMethod("GetHasValue", BindingFlags.Static | BindingFlags.Public);
+#endif
+
+ Type type = typeof (LargeStruct?).GetGenericArguments () [0];
+ bool b1 = (bool)m.MakeGenericMethod (new Type[] {type}).Invoke (null, new object[] { s });
+ if (!b1)
+ return 1;
+ bool b2 = (bool)m.MakeGenericMethod (new Type[] {type}).Invoke (null, new object[] { null });
+ if (b2)
+ return 2;
+ return 0;
+ }
+
+ struct FpStruct {
+ public float a, b, c;
+ }
+
+ struct LargeStruct2 {
+ public FpStruct x;
+ public int a, b, c, d, e, f, g, h;
+ }
+
+ [MethodImplAttribute (MethodImplOptions.NoInlining)]
+ static int pass_hfa_on_stack (FpStruct s1, FpStruct s2, FpStruct s3) {
+ return (int)s3.c;
+ }
+
+ public static int test_10_arm64_hfa_on_stack_llvm () {
+ var arr = new LargeStruct2 [10, 10];
+ for (int i = 0; i < 10; ++i)
+ for (int j = 0; j < 10; ++j)
+ arr [i, j].x = new FpStruct ();
+
+ var s1 = new FpStruct () { a = 1, b = 1, c = 10 };
+ return pass_hfa_on_stack (s1, s1, s1);
+ }
+
+ public static int test_0_get_current_method () {
+ var m = MethodBase.GetCurrentMethod ();
+#if __MOBILE__
+ var m2 = typeof (AotTests).GetMethod ("test_0_get_current_method");
+#else
+ var m2 = typeof (Tests).GetMethod ("test_0_get_current_method");
+#endif
+ return m == m2 ? 0 : 1;
+ }
+
+ class GetCurrentMethodClass<T> {
+ [MethodImplAttribute (MethodImplOptions.NoInlining)]
+ public MethodBase get_current () {
+ return MethodBase.GetCurrentMethod ();
+ }
+ }
+
+ public static int test_0_get_current_method_generic () {
+ var c = new GetCurrentMethodClass<string> ();
+ var m = c.get_current ();
+ var m2 = typeof (GetCurrentMethodClass<>).GetMethod ("get_current");
+ return m == m2 ? 0 : 1;
+ }
+
+ public static int test_0_array_wrappers_runtime_invoke () {
+ string[][] arr = new string [10][];
+ IEnumerable<string[]> iface = arr;
+ var m = typeof(IEnumerable<string[]>).GetMethod ("GetEnumerator");
+ m.Invoke (arr, null);
+ return 0;
+ }
+
+ public static int test_0_fault_clauses () {
+ object [] data = { 1, 2, 3 };
+ int [] expected = { 1, 2, 3 };
+
+ try {
+ Action d = delegate () { data.Cast<IEnumerable> ().GetEnumerator ().MoveNext (); };
+ d ();
+ } catch (Exception ex) {
+ }
+ return 0;
+ }