2 using System.Reflection;
3 using System.Runtime.CompilerServices;
6 * Regression tests for the mono JIT.
8 * Each test needs to be of the form:
10 * public static int test_<result>_<name> ();
12 * where <result> is an integer (the value that needs to be returned by
13 * the method to make it pass.
14 * <name> is a user-displayed name used to identify the test.
16 * The tests can be driven in two ways:
17 * *) running the program directly: Main() uses reflection to find and invoke
18 * the test methods (this is useful mostly to check that the tests are correct)
19 * *) with the --regression switch of the jit (this is the preferred way since
20 * all the tests will be run with optimizations on and off)
22 * The reflection logic could be moved to a .dll since we need at least another
23 * regression test file written in IL code to have better control on how
35 public static int Main (string[] args) {
36 return TestDriver.RunTests (typeof (Tests), args);
40 public static int test_0_catch () {
41 Exception x = new Exception ();
45 } catch (Exception e) {
52 public static int test_0_finally_without_exc () {
57 } catch (Exception e) {
66 public static int test_0_finally () {
70 throw new Exception ();
71 } catch (Exception e) {
79 public static int test_0_nested_finally () {
94 public static int test_0_byte_cast () {
107 } catch (OverflowException) {
121 } catch (OverflowException) {
136 } catch (OverflowException) {
150 } catch (OverflowException) {
164 } catch (OverflowException) {
178 } catch (OverflowException) {
192 } catch (OverflowException) {
206 } catch (OverflowException) {
220 } catch (OverflowException) {
234 } catch (OverflowException) {
248 } catch (OverflowException) {
262 } catch (OverflowException) {
277 catch (OverflowException) {
288 public static int test_0_sbyte_cast () {
300 } catch (OverflowException) {
314 } catch (OverflowException) {
328 } catch (OverflowException) {
342 } catch (OverflowException) {
356 } catch (OverflowException) {
370 } catch (OverflowException) {
384 } catch (OverflowException) {
398 } catch (OverflowException) {
412 } catch (OverflowException) {
426 } catch (OverflowException) {
440 } catch (OverflowException) {
454 } catch (OverflowException) {
468 } catch (OverflowException) {
482 } catch (OverflowException) {
496 } catch (OverflowException) {
510 } catch (OverflowException) {
524 } catch (OverflowException) {
538 } catch (OverflowException) {
552 } catch (OverflowException) {
566 } catch (OverflowException) {
581 catch (OverflowException) {
592 public static int test_0_ushort_cast () {
600 a = System.UInt16.MaxValue;
605 } catch (OverflowException) {
617 } catch (OverflowException) {
624 a = System.UInt16.MaxValue + 1;
629 } catch (OverflowException) {
641 } catch (OverflowException) {
653 } catch (OverflowException) {
660 double d = System.UInt16.MaxValue;
665 } catch (OverflowException) {
677 } catch (OverflowException) {
684 double d = System.UInt16.MaxValue + 1.0;
689 } catch (OverflowException) {
696 l = System.UInt16.MaxValue;
701 } catch (OverflowException) {
713 } catch (OverflowException) {
720 l = System.UInt16.MaxValue + 1;
725 } catch (OverflowException) {
737 } catch (OverflowException) {
749 } catch (OverflowException) {
758 public static int test_0_short_cast () {
765 a = System.UInt16.MaxValue;
770 } catch (OverflowException) {
782 } catch (OverflowException) {
789 a = System.Int16.MaxValue + 1;
794 } catch (OverflowException) {
801 a = System.Int16.MinValue - 1;
806 } catch (OverflowException) {
818 } catch (OverflowException) {
825 a = System.Int16.MinValue;
830 } catch (OverflowException) {
837 a = System.Int16.MaxValue;
842 } catch (OverflowException) {
849 a = System.Int16.MaxValue + 1;
854 } catch (OverflowException) {
861 double d = System.Int16.MaxValue;
866 } catch (OverflowException) {
873 double d = System.Int16.MinValue;
878 } catch (OverflowException) {
885 double d = System.Int16.MaxValue + 1.0;
890 } catch (OverflowException) {
897 double d = System.Int16.MinValue - 1.0;
902 } catch (OverflowException) {
909 l = System.Int16.MaxValue + 1;
914 } catch (OverflowException) {
921 l = System.Int16.MaxValue;
926 } catch (OverflowException) {
933 l = System.Int16.MinValue - 1;
938 } catch (OverflowException) {
946 l = System.Int16.MinValue;
951 } catch (OverflowException) {
958 l = 0x00000000ffffffff;
963 } catch (OverflowException) {
975 } catch (OverflowException) {
984 public static int test_0_int_cast () {
990 double d = System.Int32.MaxValue + 1.0;
995 } catch (OverflowException) {
1002 double d = System.Int32.MaxValue;
1007 } catch (OverflowException) {
1015 double d = System.Int32.MinValue;
1020 } catch (OverflowException) {
1028 double d = System.Int32.MinValue - 1.0;
1033 } catch (OverflowException) {
1040 l = System.Int32.MaxValue + (long)1;
1045 } catch (OverflowException) {
1052 l = System.Int32.MaxValue;
1057 } catch (OverflowException) {
1065 l = System.Int32.MinValue;
1070 } catch (OverflowException) {
1078 l = System.Int32.MinValue - (long)1;
1083 } catch (OverflowException) {
1090 uint ui = System.UInt32.MaxValue;
1096 catch (OverflowException) {
1103 ulong ul = (long)(System.Int32.MaxValue) + 1;
1109 catch (OverflowException) {
1116 ulong ul = UInt64.MaxValue;
1122 catch (OverflowException) {
1139 public static int test_0_uint_cast () {
1145 double d = System.UInt32.MaxValue;
1150 } catch (OverflowException) {
1157 double d = System.UInt32.MaxValue + 1.0;
1162 } catch (OverflowException) {
1169 double d = System.UInt32.MinValue;
1174 } catch (OverflowException) {
1181 double d = System.UInt32.MinValue - 1.0;
1186 } catch (OverflowException) {
1193 l = System.UInt32.MaxValue;
1198 } catch (OverflowException) {
1205 l = System.UInt32.MaxValue + (long)1;
1210 } catch (OverflowException) {
1217 l = System.UInt32.MinValue;
1222 } catch (OverflowException) {
1229 l = System.UInt32.MinValue - (long)1;
1234 } catch (OverflowException) {
1247 catch (OverflowException) {
1264 public static int test_0_long_cast () {
1267 * These tests depend on properties of x86 fp arithmetic so they won't work
1268 * on other platforms.
1275 double d = System.Int64.MaxValue - 512.0;
1280 } catch (OverflowException) {
1287 double d = System.Int64.MaxValue - 513.0;
1292 } catch (OverflowException) {
1299 double d = System.Int64.MinValue - 1024.0;
1304 } catch (OverflowException) {
1311 double d = System.Int64.MinValue - 1025.0;
1316 } catch (OverflowException) {
1334 public static int test_0_ulong_cast () {
1339 * These tests depend on properties of x86 fp arithmetic so they won't work
1340 * on other platforms.
1345 double d = System.UInt64.MaxValue - 1024.0;
1350 } catch (OverflowException) {
1357 double d = System.UInt64.MaxValue - 1025.0;
1362 } catch (OverflowException) {
1375 } catch (OverflowException) {
1387 } catch (OverflowException) {
1408 catch (OverflowException) {
1415 int i = Int32.MinValue;
1421 catch (OverflowException) {
1430 public static int test_0_simple_double_casts () {
1432 double d = 0xffffffff;
1434 if ((uint)d != 4294967295)
1438 * These tests depend on properties of x86 fp arithmetic so they won't work
1439 * on other platforms.
1442 d = 0xffffffffffffffff;
1456 if ((ushort)d != 0xffff)
1459 if ((byte)d != 0xff)
1465 [Category ("NaClDisable")]
1466 public static int test_0_div_zero () {
1475 } catch (DivideByZeroException) {
1484 } catch (DivideByZeroException) {
1495 } catch (DivideByZeroException) {
1496 /* wrong exception */
1497 } catch (OverflowException) {
1508 } catch (DivideByZeroException) {
1509 /* wrong exception */
1510 } catch (OverflowException) {
1519 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1520 static void dummy () {
1523 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1524 static int div_zero_llvm_inner (int i) {
1526 // This call make use avoid the 'handler without invoke' restriction in the llvm backend
1529 } catch (Exception ex) {
1534 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1535 static long div_zero_llvm_inner_long (long l) {
1539 } catch (Exception ex) {
1544 public static int test_0_div_zero_llvm () {
1545 long r = div_zero_llvm_inner (0);
1548 r = div_zero_llvm_inner_long (0);
1554 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1555 static int div_overflow_llvm_inner (int i) {
1558 return Int32.MinValue / i;
1559 } catch (Exception ex) {
1564 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1565 static long div_overflow_llvm_inner_long (long l) {
1568 return Int64.MinValue / l;
1569 } catch (Exception ex) {
1574 public static int test_0_div_overflow_llvm () {
1575 long r = div_overflow_llvm_inner (-1);
1578 r = div_overflow_llvm_inner_long ((long)-1);
1584 public static int return_55 () {
1588 public static int test_0_cfold_div_zero () {
1589 // Test that constant folding doesn't cause division by zero exceptions
1590 if (return_55 () != return_55 ()) {
1609 public static int test_0_udiv_zero () {
1618 } catch (DivideByZeroException) {
1627 } catch (DivideByZeroException) {
1636 [Category ("NaClDisable")]
1637 public static int test_0_long_div_zero () {
1646 } catch (DivideByZeroException) {
1655 } catch (DivideByZeroException) {
1666 } catch (DivideByZeroException) {
1667 /* wrong exception */
1668 } catch (ArithmeticException) {
1679 } catch (DivideByZeroException) {
1680 /* wrong exception */
1681 } catch (ArithmeticException) {
1690 public static int test_0_ulong_div_zero () {
1699 } catch (DivideByZeroException) {
1708 } catch (DivideByZeroException) {
1717 public static int test_0_float_div_zero () {
1726 } catch (DivideByZeroException) {
1735 } catch (DivideByZeroException) {
1744 public static int test_0_invalid_unbox () {
1747 object o = "Some string";
1751 // Illegal conversion; o contains a string not an int
1753 } catch (Exception e) {
1761 // Test that double[] can't be cast to double (bug #46027)
1762 public static int test_0_invalid_unbox_arrays () {
1763 double[] d1 = { 1.0 };
1764 double[][] d2 = { d1 };
1768 foreach (double d in a) {
1772 catch (InvalidCastException e) {
1777 /* bug# 42190, at least mcs generates a leave for the return that
1778 * jumps out of multiple exception clauses: we used to execute just
1779 * one enclosing finally block.
1781 public static int finally_level;
1782 static void do_something () {
1795 public static int test_2_multiple_finally_clauses () {
1798 if (finally_level == 1)
1803 public static int test_3_checked_cast_un () {
1804 ulong i = 0x8000000034000000;
1808 checked { j = (long)i; }
1809 } catch (OverflowException) {
1818 public static int test_4_checked_cast () {
1822 unchecked { i = (long)0x8000000034000000;};
1824 checked { j = (ulong)i; }
1825 } catch (OverflowException) {
1834 static readonly int[] mul_dim_results = new int[] {
1835 0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8,
1836 1, 0, 1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8,
1840 5, 0, 5, 1, 5, 2, 5, 3, 5, 4, 5, 5, 5, 6, 5, 7, 5, 8,
1841 6, 0, 6, 1, 6, 2, 6, 3, 6, 4, 6, 5, 6, 6, 6, 7, 6, 8,
1842 7, 0, 7, 1, 7, 2, 7, 3, 7, 4, 7, 5, 7, 6, 7, 7, 7, 8,
1845 public static int test_0_multi_dim_array_access () {
1846 int [,] a = System.Array.CreateInstance (typeof (int),
1847 new int [] {3,6}, new int [] {2,2 }) as int[,];
1850 for (x = 0; x < 8; ++x) {
1851 for (y = 0; y < 9; ++y) {
1852 bool got_ex = false;
1859 if (result_idx >= mul_dim_results.Length)
1861 if (mul_dim_results [result_idx] != x || mul_dim_results [result_idx + 1] != y) {
1862 return result_idx + 1;
1868 if (result_idx == mul_dim_results.Length)
1873 static void helper_out_obj (out object o) {
1874 o = (object)"buddy";
1877 static void helper_out_string (out string o) {
1881 public static int test_2_array_mismatch () {
1882 string[] a = { "hello", "world" };
1884 bool passed = false;
1887 helper_out_obj (out b [1]);
1888 } catch (ArrayTypeMismatchException) {
1893 helper_out_string (out a [1]);
1894 if (a [1] != "buddy")
1899 public static int test_0_ovf1 () {
1904 ulong a = UInt64.MaxValue - 1;
1913 public static int test_1_ovf2 () {
1918 ulong a = UInt64.MaxValue;
1927 public static int test_0_ovf3 () {
1930 long a = Int64.MaxValue - 1;
1941 public static int test_1_ovf4 () {
1944 long a = Int64.MaxValue;
1955 public static int test_0_ovf5 () {
1958 ulong a = UInt64.MaxValue - 1;
1969 public static int test_1_ovf6 () {
1972 ulong a = UInt64.MaxValue;
1983 public static int test_0_ovf7 () {
1986 long a = Int64.MinValue + 1;
1997 public static int test_1_ovf8 () {
2000 long a = Int64.MinValue;
2011 public static int test_0_ovf9 () {
2014 ulong a = UInt64.MinValue + 1;
2025 public static int test_1_ovf10 () {
2028 ulong a = UInt64.MinValue;
2039 public static int test_0_ovf11 () {
2042 int a = Int32.MinValue + 1;
2053 public static int test_1_ovf12 () {
2056 int a = Int32.MinValue;
2067 public static int test_0_ovf13 () {
2081 public static int test_1_ovf14 () {
2095 public static int test_0_ovf15 () {
2109 public static int test_1_ovf16 () {
2123 public static int test_0_ovf17 () {
2135 public static int test_0_ovf18 () {
2149 public static int test_1_ovf19 () {
2163 public static int test_0_ovf20 () {
2168 ulong a = 0xffffffffff;
2169 ulong t = a*0x0ffffff;
2177 public static int test_1_ovf21 () {
2180 ulong a = 0xffffffffff;
2183 ulong t = a*0x0fffffff;
2191 public static int test_1_ovf22 () {
2194 long a = Int64.MinValue;
2206 public static int test_1_ovf23 () {
2210 long b = Int64.MinValue;
2222 public static int i;
2225 throw new Exception ("Ugh!");
2228 public static int DoSomething () {
2233 public static int test_0_exception_in_cctor () {
2235 Broken.DoSomething ();
2237 catch (TypeInitializationException) {
2238 // This will only happen once even if --regression is used
2243 public static int test_5_regalloc () {
2247 for (i = 0; i < 10; ++i) {
2249 throw new Exception ();
2257 // Check that variables written in catch clauses are volatile
2260 throw new Exception ();
2271 throw new Exception ();
2285 public static void rethrow () {
2287 throw new ApplicationException();
2288 } catch (ApplicationException) {
2290 throw new OverflowException();
2291 } catch (Exception) {
2297 // Test that a rethrow rethrows the correct exception
2298 public static int test_0_rethrow_nested () {
2301 } catch (OverflowException) {
2303 } catch (Exception) {
2309 [MethodImplAttribute (MethodImplOptions.NoInlining)]
2310 public static void rethrow1 () {
2311 throw new Exception ();
2314 [MethodImplAttribute (MethodImplOptions.NoInlining)]
2315 public static void rethrow2 () {
2317 /* This disables tailcall opts */
2318 Console.WriteLine ();
2321 [Category ("!INTERPRETER")]
2322 [Category ("!BITCODE")]
2323 public static int test_0_rethrow_stacktrace () {
2324 // Check that rethrowing an exception preserves the original stack trace
2329 catch (Exception ex) {
2330 // Check that each catch clause has its own exception variable
2331 // If not, the throw below will overwrite the exception used
2334 throw new DivideByZeroException ();
2336 catch (Exception foo) {
2342 catch (Exception ex) {
2343 if (ex.StackTrace.IndexOf ("rethrow2") != -1)
2351 class Face : IFace {}
2353 public static int test_1_array_mismatch_2 () {
2355 object [] o = new Face [1];
2358 } catch (ArrayTypeMismatchException) {
2363 public static int test_1_array_mismatch_3 () {
2365 object [] o = new IFace [1];
2368 } catch (ArrayTypeMismatchException) {
2373 public static int test_1_array_mismatch_4 () {
2375 object [][] o = new Face [5] [];
2376 o [0] = new object [5];
2379 } catch (ArrayTypeMismatchException) {
2384 public static int test_0_array_size () {
2389 int[,] mem2 = new int [Int32.MaxValue, Int32.MaxValue];
2391 catch (OutOfMemoryException e) {
2401 int i, j, k, l, m, n;
2404 static IntPtr[] addr;
2406 static unsafe void throw_func (int i, S s) {
2407 addr [i] = new IntPtr (&i);
2408 throw new Exception ();
2411 /* Test that arguments are correctly popped off the stack during unwinding */
2412 /* FIXME: Fails on x86 when llvm is enabled (#5432) */
2414 public static int test_0_stack_unwind () {
2415 addr = new IntPtr [1000];
2417 for (int j = 0; j < 1000; j++) {
2424 return (addr [0].ToInt64 () - addr [100].ToInt64 () < 100) ? 0 : 1;
2428 static unsafe void get_sp (int i) {
2429 addr [i] = new IntPtr (&i);
2432 /* Test that the arguments to the throw trampoline are correctly popped off the stack */
2433 public static int test_0_throw_unwind () {
2434 addr = new IntPtr [1000];
2436 for (int j = 0; j < 1000; j++) {
2439 throw new Exception ();
2444 return (addr [0].ToInt64 () - addr [100].ToInt64 () < 100) ? 0 : 1;
2447 public static int test_0_regress_73242 () {
2448 int [] arr = new int [10];
2449 for (int i = 0; i < 10; ++i)
2452 throw new Exception ();
2459 public static int test_0_nullref () {
2463 } catch (NullReferenceException e) {
2469 public int amethod () {
2473 public static int test_0_nonvirt_nullref_at_clause_start () {
2474 ExceptionTests t = null;
2477 } catch (NullReferenceException) {
2484 public static int throw_only () {
2485 throw new Exception ();
2488 [MethodImpl(MethodImplOptions.NoInlining)]
2489 public static int throw_only2 () {
2490 return throw_only ();
2493 public static int test_0_inline_throw_only () {
2495 return throw_only2 ();
2497 catch (Exception ex) {
2502 public static string GetText (string s) {
2506 public static int throw_only_gettext () {
2507 throw new Exception (GetText ("FOO"));
2510 public static int test_0_inline_throw_only_gettext () {
2513 o = throw_only_gettext ();
2515 catch (Exception ex) {
2519 return o != null ? 0 : 1;
2523 public static int test_0_throw_to_branch_opt_outer_clause () {
2528 string [] files = new string[1];
2530 string s = files[2];
2537 return (i == 1) ? 0 : 1;
2541 public static int test_0_try_inside_finally_cmov_opt () {
2542 bool Reconect = false;
2544 object o = new object ();
2548 catch (Exception ExCon) {
2554 catch (Exception Last) {
2558 if (Reconect == true) {
2561 catch (Exception ex) {
2569 public static int test_0_inline_throw () {
2578 // for llvm, the end bblock is unreachable
2579 public static int inline_throw1 (int i) {
2581 throw new Exception ();
2583 return inline_throw2 (i);
2586 public static int inline_throw2 (int i) {
2587 throw new Exception ();
2591 public static int test_0_lmf_filter () {
2593 // The invoke calls a runtime-invoke wrapper which has a filter clause
2595 typeof (ExceptionTests).GetMethod ("lmf_filter").Invoke (null, new object [] { });
2597 typeof (Tests).GetMethod ("lmf_filter").Invoke (null, new object [] { });
2599 } catch (TargetInvocationException) {
2604 public static void lmf_filter () {
2609 throw new NotImplementedException ();
2613 public static void Connect () {
2615 throw new Exception();
2618 public static void Stop () {
2626 private static void do_raise () {
2627 throw new System.Exception ();
2630 private static int int_func (int i) {
2635 public static int test_8_local_deadce_causes () {
2642 } catch (System.Exception) {
2648 public static int test_0_except_opt_two_clauses () {
2651 uint ui = (uint)size;
2654 uint v = ui * (uint)4;
2656 } catch (OverflowException e) {
2658 } catch (Exception) {
2667 public virtual long Method()
2669 throw new Exception();
2674 public static int test_100_long_vars_in_clauses_initlocals_opt () {
2675 Child c = new Child();
2685 public object AnObj;
2688 public static void DoSomething (ref object o) {
2691 public static int test_0_ldflda_null () {
2695 DoSomething (ref a.AnObj);
2696 } catch (NullReferenceException) {
2707 public static Foo* pFoo;
2710 /* MS.NET doesn't seem to throw in this case */
2711 public unsafe static int test_0_ldflda_null_pointer () {
2712 int* pi = &Foo.pFoo->i;
2717 static int test_0_try_clause_in_finally_clause_regalloc () {
2718 // Fill up registers with values
2719 object a = new object ();
2720 object[] arr1 = new object [1];
2721 object[] arr2 = new object [1];
2722 object[] arr3 = new object [1];
2723 object[] arr4 = new object [1];
2724 object[] arr5 = new object [1];
2726 for (int i = 0; i < 10; ++i)
2728 for (int i = 0; i < 10; ++i)
2730 for (int i = 0; i < 10; ++i)
2732 for (int i = 0; i < 10; ++i)
2734 for (int i = 0; i < 10; ++i)
2739 try_clause_in_finally_clause_regalloc_inner (out res);
2740 } catch (Exception) {
2745 public static object Throw () {
2746 for (int i = 0; i < 10; ++i)
2748 throw new Exception ();
2751 static void try_clause_in_finally_clause_regalloc_inner (out int res) {
2757 } catch (Exception) {
2758 /* Make sure this doesn't branch to the finally */
2759 throw new DivideByZeroException ();
2762 /* Make sure o is register allocated */
2775 } catch (DivideByZeroException) {
2780 public static bool t_1835_inner () {
2782 if (a) throw new Exception();
2786 [MethodImpl(MethodImplOptions.NoInlining)]
2787 public static bool t_1835_inner_2 () {
2788 bool b = t_1835_inner ();
2792 public static int test_0_inline_retval_throw_in_branch_1835 () {
2801 static bool finally_called = false;
2803 static void regress_30472 (int a, int b) {
2808 finally_called = true;
2813 public static int test_0_regress_30472 () {
2814 finally_called = false;
2816 regress_30472 (Int32.MaxValue - 1, 2);
2817 } catch (Exception ex) {
2819 return finally_called ? 0 : 1;
2822 static int array_len_1 = 1;
2824 public static int test_0_bounds_check_negative_constant () {
2826 byte[] arr = new byte [array_len_1];
2832 byte[] arr = new byte [array_len_1];
2840 public static int test_0_string_bounds_check_negative_constant () {
2850 public class MyException : Exception {
2851 public int marker = 0;
2852 public string res = "";
2854 public MyException (String res) {
2858 public bool FilterWithoutState () {
2859 return this.marker == 0x666;
2862 public bool FilterWithState () {
2863 bool ret = this.marker == 0x566;
2864 this.marker += 0x100;
2868 public bool FilterWithStringState () {
2869 bool ret = this.marker == 0x777;
2870 this.res = "fromFilter_" + this.res;
2875 public static int test_1_basic_filter_catch () {
2877 MyException e = new MyException ("");
2880 } catch (MyException ex) when (ex.marker == 0x1337) {
2886 public static int test_1234_complicated_filter_catch () {
2887 string res = "init";
2889 MyException e = new MyException (res);
2894 } catch (MyException ex) when (ex.FilterWithoutState ()) {
2895 res = "WRONG_" + res;
2898 res = "innerFinally_" + res;
2900 } catch (MyException ex) when (ex.FilterWithState ()) {
2901 res = "2ndcatch_" + res;
2903 // "2ndcatch_innerFinally_init"
2904 // Console.WriteLine ("res1: " + res);
2907 } catch (MyException ex) when (ex.FilterWithStringState ()) {
2908 res = "fwos_" + ex.res;
2910 res = "outerFinally_" + res;
2912 // Console.WriteLine ("res2: " + res);
2913 return "outerFinally_fwos_fromFilter_2ndcatch_innerFinally_init" == res ? 1234 : 0;
2916 public struct FooStruct
2918 public long Part1 { get; }
2919 public long Part2 { get; }
2921 public byte Part3 { get; }
2924 [MethodImpl( MethodImplOptions.NoInlining )]
2925 private static bool ExceptionFilter( byte x, FooStruct item ) => true;
2927 public static int test_0_filter_caller_area () {
2929 throw new Exception();
2931 catch (Exception) when (ExceptionFilter (default(byte), default (FooStruct))) {
2938 class ExceptionTests : Tests