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 public static int test_0_div_zero () {
1474 } catch (DivideByZeroException) {
1483 } catch (DivideByZeroException) {
1494 } catch (DivideByZeroException) {
1495 /* wrong exception */
1496 } catch (OverflowException) {
1507 } catch (DivideByZeroException) {
1508 /* wrong exception */
1509 } catch (OverflowException) {
1518 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1519 static void dummy () {
1522 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1523 static int div_zero_llvm_inner (int i) {
1525 // This call make use avoid the 'handler without invoke' restriction in the llvm backend
1528 } catch (Exception ex) {
1533 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1534 static long div_zero_llvm_inner_long (long l) {
1538 } catch (Exception ex) {
1543 public static int test_0_div_zero_llvm () {
1544 long r = div_zero_llvm_inner (0);
1547 r = div_zero_llvm_inner_long (0);
1553 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1554 static int div_overflow_llvm_inner (int i) {
1557 return Int32.MinValue / i;
1558 } catch (Exception ex) {
1563 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1564 static long div_overflow_llvm_inner_long (long l) {
1567 return Int64.MinValue / l;
1568 } catch (Exception ex) {
1573 public static int test_0_div_overflow_llvm () {
1574 long r = div_overflow_llvm_inner (-1);
1577 r = div_overflow_llvm_inner_long ((long)-1);
1583 public static int return_55 () {
1587 public static int test_0_cfold_div_zero () {
1588 // Test that constant folding doesn't cause division by zero exceptions
1589 if (return_55 () != return_55 ()) {
1608 public static int test_0_udiv_zero () {
1617 } catch (DivideByZeroException) {
1626 } catch (DivideByZeroException) {
1635 public static int test_0_long_div_zero () {
1644 } catch (DivideByZeroException) {
1653 } catch (DivideByZeroException) {
1664 } catch (DivideByZeroException) {
1665 /* wrong exception */
1666 } catch (ArithmeticException) {
1677 } catch (DivideByZeroException) {
1678 /* wrong exception */
1679 } catch (ArithmeticException) {
1688 public static int test_0_ulong_div_zero () {
1697 } catch (DivideByZeroException) {
1706 } catch (DivideByZeroException) {
1715 public static int test_0_float_div_zero () {
1724 } catch (DivideByZeroException) {
1733 } catch (DivideByZeroException) {
1742 public static int test_0_invalid_unbox () {
1745 object o = "Some string";
1749 // Illegal conversion; o contains a string not an int
1751 } catch (Exception e) {
1759 // Test that double[] can't be cast to double (bug #46027)
1760 public static int test_0_invalid_unbox_arrays () {
1761 double[] d1 = { 1.0 };
1762 double[][] d2 = { d1 };
1766 foreach (double d in a) {
1770 catch (InvalidCastException e) {
1775 /* bug# 42190, at least mcs generates a leave for the return that
1776 * jumps out of multiple exception clauses: we used to execute just
1777 * one enclosing finally block.
1779 public static int finally_level;
1780 static void do_something () {
1793 public static int test_2_multiple_finally_clauses () {
1796 if (finally_level == 1)
1801 public static int test_3_checked_cast_un () {
1802 ulong i = 0x8000000034000000;
1806 checked { j = (long)i; }
1807 } catch (OverflowException) {
1816 public static int test_4_checked_cast () {
1820 unchecked { i = (long)0x8000000034000000;};
1822 checked { j = (ulong)i; }
1823 } catch (OverflowException) {
1832 static readonly int[] mul_dim_results = new int[] {
1833 0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8,
1834 1, 0, 1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8,
1838 5, 0, 5, 1, 5, 2, 5, 3, 5, 4, 5, 5, 5, 6, 5, 7, 5, 8,
1839 6, 0, 6, 1, 6, 2, 6, 3, 6, 4, 6, 5, 6, 6, 6, 7, 6, 8,
1840 7, 0, 7, 1, 7, 2, 7, 3, 7, 4, 7, 5, 7, 6, 7, 7, 7, 8,
1843 public static int test_0_multi_dim_array_access () {
1844 int [,] a = System.Array.CreateInstance (typeof (int),
1845 new int [] {3,6}, new int [] {2,2 }) as int[,];
1848 for (x = 0; x < 8; ++x) {
1849 for (y = 0; y < 9; ++y) {
1850 bool got_ex = false;
1857 if (result_idx >= mul_dim_results.Length)
1859 if (mul_dim_results [result_idx] != x || mul_dim_results [result_idx + 1] != y) {
1860 return result_idx + 1;
1866 if (result_idx == mul_dim_results.Length)
1871 static void helper_out_obj (out object o) {
1872 o = (object)"buddy";
1875 static void helper_out_string (out string o) {
1879 public static int test_2_array_mismatch () {
1880 string[] a = { "hello", "world" };
1882 bool passed = false;
1885 helper_out_obj (out b [1]);
1886 } catch (ArrayTypeMismatchException) {
1891 helper_out_string (out a [1]);
1892 if (a [1] != "buddy")
1897 public static int test_0_ovf1 () {
1902 ulong a = UInt64.MaxValue - 1;
1911 public static int test_1_ovf2 () {
1916 ulong a = UInt64.MaxValue;
1925 public static int test_0_ovf3 () {
1928 long a = Int64.MaxValue - 1;
1939 public static int test_1_ovf4 () {
1942 long a = Int64.MaxValue;
1953 public static int test_0_ovf5 () {
1956 ulong a = UInt64.MaxValue - 1;
1967 public static int test_1_ovf6 () {
1970 ulong a = UInt64.MaxValue;
1981 public static int test_0_ovf7 () {
1984 long a = Int64.MinValue + 1;
1995 public static int test_1_ovf8 () {
1998 long a = Int64.MinValue;
2009 public static int test_0_ovf9 () {
2012 ulong a = UInt64.MinValue + 1;
2023 public static int test_1_ovf10 () {
2026 ulong a = UInt64.MinValue;
2037 public static int test_0_ovf11 () {
2040 int a = Int32.MinValue + 1;
2051 public static int test_1_ovf12 () {
2054 int a = Int32.MinValue;
2065 public static int test_0_ovf13 () {
2079 public static int test_1_ovf14 () {
2093 public static int test_0_ovf15 () {
2107 public static int test_1_ovf16 () {
2121 public static int test_0_ovf17 () {
2133 public static int test_0_ovf18 () {
2147 public static int test_1_ovf19 () {
2161 public static int test_0_ovf20 () {
2166 ulong a = 0xffffffffff;
2167 ulong t = a*0x0ffffff;
2175 public static int test_1_ovf21 () {
2178 ulong a = 0xffffffffff;
2181 ulong t = a*0x0fffffff;
2189 public static int test_1_ovf22 () {
2192 long a = Int64.MinValue;
2204 public static int test_1_ovf23 () {
2208 long b = Int64.MinValue;
2220 public static int i;
2223 throw new Exception ("Ugh!");
2226 public static int DoSomething () {
2231 public static int test_0_exception_in_cctor () {
2233 Broken.DoSomething ();
2235 catch (TypeInitializationException) {
2236 // This will only happen once even if --regression is used
2241 public static int test_5_regalloc () {
2245 for (i = 0; i < 10; ++i) {
2247 throw new Exception ();
2255 // Check that variables written in catch clauses are volatile
2258 throw new Exception ();
2269 throw new Exception ();
2283 public static void rethrow () {
2285 throw new ApplicationException();
2286 } catch (ApplicationException) {
2288 throw new OverflowException();
2289 } catch (Exception) {
2295 // Test that a rethrow rethrows the correct exception
2296 public static int test_0_rethrow_nested () {
2299 } catch (OverflowException) {
2301 } catch (Exception) {
2307 [MethodImplAttribute (MethodImplOptions.NoInlining)]
2308 public static void rethrow1 () {
2309 throw new Exception ();
2312 [MethodImplAttribute (MethodImplOptions.NoInlining)]
2313 public static void rethrow2 () {
2315 /* This disables tailcall opts */
2316 Console.WriteLine ();
2319 [Category ("!BITCODE")]
2320 public static int test_0_rethrow_stacktrace () {
2321 // Check that rethrowing an exception preserves the original stack trace
2326 catch (Exception ex) {
2327 // Check that each catch clause has its own exception variable
2328 // If not, the throw below will overwrite the exception used
2331 throw new DivideByZeroException ();
2333 catch (Exception foo) {
2339 catch (Exception ex) {
2340 if (ex.StackTrace.IndexOf ("rethrow2") != -1)
2348 class Face : IFace {}
2350 public static int test_1_array_mismatch_2 () {
2352 object [] o = new Face [1];
2355 } catch (ArrayTypeMismatchException) {
2360 public static int test_1_array_mismatch_3 () {
2362 object [] o = new IFace [1];
2365 } catch (ArrayTypeMismatchException) {
2370 public static int test_1_array_mismatch_4 () {
2372 object [][] o = new Face [5] [];
2373 o [0] = new object [5];
2376 } catch (ArrayTypeMismatchException) {
2381 public static int test_0_array_size () {
2386 int[,] mem2 = new int [Int32.MaxValue, Int32.MaxValue];
2388 catch (OutOfMemoryException e) {
2398 int i, j, k, l, m, n;
2401 static IntPtr[] addr;
2403 static unsafe void throw_func (int i, S s) {
2404 addr [i] = new IntPtr (&i);
2405 throw new Exception ();
2408 /* Test that arguments are correctly popped off the stack during unwinding */
2409 /* FIXME: Fails on x86 when llvm is enabled (#5432) */
2411 public static int test_0_stack_unwind () {
2412 addr = new IntPtr [1000];
2414 for (int j = 0; j < 1000; j++) {
2421 return (addr [0].ToInt64 () - addr [100].ToInt64 () < 100) ? 0 : 1;
2425 static unsafe void get_sp (int i) {
2426 addr [i] = new IntPtr (&i);
2429 /* Test that the arguments to the throw trampoline are correctly popped off the stack */
2430 public static int test_0_throw_unwind () {
2431 addr = new IntPtr [1000];
2433 for (int j = 0; j < 1000; j++) {
2436 throw new Exception ();
2441 return (addr [0].ToInt64 () - addr [100].ToInt64 () < 100) ? 0 : 1;
2444 public static int test_0_regress_73242 () {
2445 int [] arr = new int [10];
2446 for (int i = 0; i < 10; ++i)
2449 throw new Exception ();
2456 public static int test_0_nullref () {
2460 } catch (NullReferenceException e) {
2466 public int amethod () {
2470 public static int test_0_nonvirt_nullref_at_clause_start () {
2471 ExceptionTests t = null;
2474 } catch (NullReferenceException) {
2481 public static int throw_only () {
2482 throw new Exception ();
2485 [MethodImpl(MethodImplOptions.NoInlining)]
2486 public static int throw_only2 () {
2487 return throw_only ();
2490 public static int test_0_inline_throw_only () {
2492 return throw_only2 ();
2494 catch (Exception ex) {
2499 public static string GetText (string s) {
2503 public static int throw_only_gettext () {
2504 throw new Exception (GetText ("FOO"));
2507 public static int test_0_inline_throw_only_gettext () {
2510 o = throw_only_gettext ();
2512 catch (Exception ex) {
2516 return o != null ? 0 : 1;
2520 public static int test_0_throw_to_branch_opt_outer_clause () {
2525 string [] files = new string[1];
2527 string s = files[2];
2534 return (i == 1) ? 0 : 1;
2538 public static int test_0_try_inside_finally_cmov_opt () {
2539 bool Reconect = false;
2541 object o = new object ();
2545 catch (Exception ExCon) {
2551 catch (Exception Last) {
2555 if (Reconect == true) {
2558 catch (Exception ex) {
2566 public static int test_0_inline_throw () {
2575 // for llvm, the end bblock is unreachable
2576 public static int inline_throw1 (int i) {
2578 throw new Exception ();
2580 return inline_throw2 (i);
2583 public static int inline_throw2 (int i) {
2584 throw new Exception ();
2588 public static int test_0_lmf_filter () {
2590 // The invoke calls a runtime-invoke wrapper which has a filter clause
2592 typeof (ExceptionTests).GetMethod ("lmf_filter").Invoke (null, new object [] { });
2594 typeof (Tests).GetMethod ("lmf_filter").Invoke (null, new object [] { });
2596 } catch (TargetInvocationException) {
2601 public static void lmf_filter () {
2606 throw new NotImplementedException ();
2610 public static void Connect () {
2612 throw new Exception();
2615 public static void Stop () {
2623 private static void do_raise () {
2624 throw new System.Exception ();
2627 private static int int_func (int i) {
2632 public static int test_8_local_deadce_causes () {
2639 } catch (System.Exception) {
2645 public static int test_0_except_opt_two_clauses () {
2648 uint ui = (uint)size;
2651 uint v = ui * (uint)4;
2653 } catch (OverflowException e) {
2655 } catch (Exception) {
2664 public virtual long Method()
2666 throw new Exception();
2671 public static int test_100_long_vars_in_clauses_initlocals_opt () {
2672 Child c = new Child();
2682 public object AnObj;
2685 public static void DoSomething (ref object o) {
2688 public static int test_0_ldflda_null () {
2692 DoSomething (ref a.AnObj);
2693 } catch (NullReferenceException) {
2704 public static Foo* pFoo;
2707 /* MS.NET doesn't seem to throw in this case */
2708 public unsafe static int test_0_ldflda_null_pointer () {
2709 int* pi = &Foo.pFoo->i;
2714 static int test_0_try_clause_in_finally_clause_regalloc () {
2715 // Fill up registers with values
2716 object a = new object ();
2717 object[] arr1 = new object [1];
2718 object[] arr2 = new object [1];
2719 object[] arr3 = new object [1];
2720 object[] arr4 = new object [1];
2721 object[] arr5 = new object [1];
2723 for (int i = 0; i < 10; ++i)
2725 for (int i = 0; i < 10; ++i)
2727 for (int i = 0; i < 10; ++i)
2729 for (int i = 0; i < 10; ++i)
2731 for (int i = 0; i < 10; ++i)
2736 try_clause_in_finally_clause_regalloc_inner (out res);
2737 } catch (Exception) {
2742 public static object Throw () {
2743 for (int i = 0; i < 10; ++i)
2745 throw new Exception ();
2748 static void try_clause_in_finally_clause_regalloc_inner (out int res) {
2754 } catch (Exception) {
2755 /* Make sure this doesn't branch to the finally */
2756 throw new DivideByZeroException ();
2759 /* Make sure o is register allocated */
2772 } catch (DivideByZeroException) {
2777 public static bool t_1835_inner () {
2779 if (a) throw new Exception();
2783 [MethodImpl(MethodImplOptions.NoInlining)]
2784 public static bool t_1835_inner_2 () {
2785 bool b = t_1835_inner ();
2789 public static int test_0_inline_retval_throw_in_branch_1835 () {
2798 static bool finally_called = false;
2800 static void regress_30472 (int a, int b) {
2805 finally_called = true;
2810 public static int test_0_regress_30472 () {
2811 finally_called = false;
2813 regress_30472 (Int32.MaxValue - 1, 2);
2814 } catch (Exception ex) {
2816 return finally_called ? 0 : 1;
2819 static int array_len_1 = 1;
2821 public static int test_0_bounds_check_negative_constant () {
2823 byte[] arr = new byte [array_len_1];
2829 byte[] arr = new byte [array_len_1];
2837 public static int test_0_string_bounds_check_negative_constant () {
2847 public class MyException : Exception {
2848 public int marker = 0;
2849 public string res = "";
2851 public MyException (String res) {
2855 public bool FilterWithoutState () {
2856 return this.marker == 0x666;
2859 public bool FilterWithState () {
2860 bool ret = this.marker == 0x566;
2861 this.marker += 0x100;
2865 public bool FilterWithStringState () {
2866 bool ret = this.marker == 0x777;
2867 this.res = "fromFilter_" + this.res;
2872 [Category ("!BITCODE")]
2873 public static int test_1_basic_filter_catch () {
2875 MyException e = new MyException ("");
2878 } catch (MyException ex) when (ex.marker == 0x1337) {
2884 [Category ("!BITCODE")]
2885 public static int test_1234_complicated_filter_catch () {
2886 string res = "init";
2888 MyException e = new MyException (res);
2893 } catch (MyException ex) when (ex.FilterWithoutState ()) {
2894 res = "WRONG_" + res;
2897 res = "innerFinally_" + res;
2899 } catch (MyException ex) when (ex.FilterWithState ()) {
2900 res = "2ndcatch_" + res;
2902 // "2ndcatch_innerFinally_init"
2903 // Console.WriteLine ("res1: " + res);
2906 } catch (MyException ex) when (ex.FilterWithStringState ()) {
2907 res = "fwos_" + ex.res;
2909 res = "outerFinally_" + res;
2911 // Console.WriteLine ("res2: " + res);
2912 return "outerFinally_fwos_fromFilter_2ndcatch_innerFinally_init" == res ? 1234 : 0;
2915 public struct FooStruct
2917 public long Part1 { get; }
2918 public long Part2 { get; }
2920 public byte Part3 { get; }
2923 [MethodImpl( MethodImplOptions.NoInlining )]
2924 private static bool ExceptionFilter( byte x, FooStruct item ) => true;
2926 [Category ("!BITCODE")]
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