| blob | cf7dc613c0461c90f077bdb19ef223bc06f4bb57 |
5 /*
6 * Regression tests for the mono JIT.
7 *
8 * Each test needs to be of the form:
9 *
10 * public static int test_<result>_<name> ();
11 *
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.
15 *
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)
21 *
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
24 * the IL code looks.
25 */
31 }
41 }
43 }
54 }
57 }
68 }
70 }
82 }
83 }
85 }
99 }
102 }
113 }
116 }
128 }
131 }
142 }
145 }
156 }
159 }
170 }
173 }
184 }
187 }
198 }
201 }
212 }
215 }
226 }
229 }
240 }
243 }
254 }
257 }
268 }
269 }
272 }
279 }
292 }
295 }
306 }
309 }
320 }
323 }
334 }
337 }
348 }
351 }
362 }
365 }
376 }
379 }
390 }
393 }
404 }
407 }
418 }
421 }
432 }
435 }
446 }
449 }
460 }
463 }
474 }
477 }
488 }
491 }
502 }
505 }
516 }
519 }
530 }
533 }
544 }
547 }
558 }
561 }
572 }
573 }
576 }
583 }
597 }
600 }
609 }
612 }
621 }
624 }
633 }
636 }
645 }
648 }
657 }
660 }
669 }
672 }
681 }
684 }
693 }
696 }
705 }
708 }
717 }
720 }
729 }
732 }
741 }
744 }
749 }
762 }
765 }
774 }
777 }
786 }
789 }
798 }
801 }
810 }
813 }
822 }
825 }
834 }
837 }
846 }
849 }
858 }
861 }
870 }
873 }
882 }
885 }
894 }
897 }
906 }
909 }
918 }
921 }
930 }
933 }
943 }
946 }
955 }
958 }
967 }
970 }
975 }
987 }
990 }
999 }
1002 }
1012 }
1015 }
1025 }
1028 }
1037 }
1040 }
1049 }
1052 }
1062 }
1065 }
1075 }
1078 }
1087 }
1088 }
1091 }
1100 }
1101 }
1104 }
1113 }
1114 }
1117 }
1121 {
1126 }
1127 }
1130 }
1142 }
1145 }
1154 }
1157 }
1166 }
1169 }
1178 }
1181 }
1190 }
1193 }
1202 }
1205 }
1214 }
1217 }
1226 }
1229 }
1238 }
1239 }
1242 }
1246 {
1251 }
1252 }
1255 }
1259 /*
1260 * These tests depend on properties of x86 fp arithmetic so they won't work
1261 * on other platforms.
1262 */
1263 /*
1264 long a;
1265 bool failed;
1267 try {
1268 double d = System.Int64.MaxValue - 512.0;
1269 failed = true;
1270 checked {
1271 a = (long)d;
1272 }
1273 } catch (OverflowException) {
1274 failed = false;
1275 }
1276 if (failed)
1277 return 1;
1279 try {
1280 double d = System.Int64.MaxValue - 513.0;
1281 failed = false;
1282 checked {
1283 a = (long)d;
1284 }
1285 } catch (OverflowException) {
1286 failed = true;
1287 }
1288 if (failed)
1289 return 2;
1291 try {
1292 double d = System.Int64.MinValue - 1024.0;
1293 failed = false;
1294 checked {
1295 a = (long)d;
1296 }
1297 } catch (OverflowException) {
1298 failed = true;
1299 }
1300 if (failed)
1301 return 3;
1303 try {
1304 double d = System.Int64.MinValue - 1025.0;
1305 failed = true;
1306 checked {
1307 a = (long)d;
1308 }
1309 } catch (OverflowException) {
1310 failed = false;
1311 }
1312 if (failed)
1313 return 4;
1314 */
1316 {
1321 }
1322 }
1325 }
1331 /*
1332 * These tests depend on properties of x86 fp arithmetic so they won't work
1333 * on other platforms.
1334 */
1336 /*
1337 try {
1338 double d = System.UInt64.MaxValue - 1024.0;
1339 failed = true;
1340 checked {
1341 a = (ulong)d;
1342 }
1343 } catch (OverflowException) {
1344 failed = false;
1345 }
1346 if (failed)
1347 return 1;
1349 try {
1350 double d = System.UInt64.MaxValue - 1025.0;
1351 failed = false;
1352 checked {
1353 a = (ulong)d;
1354 }
1355 } catch (OverflowException) {
1356 failed = true;
1357 }
1358 if (failed)
1359 return 2;
1360 */
1367 }
1370 }
1379 }
1382 }
1386 {
1391 }
1392 }
1399 }
1400 }
1403 }
1412 }
1413 }
1416 }
1421 }
1430 /*
1431 * These tests depend on properties of x86 fp arithmetic so they won't work
1432 * on other platforms.
1433 */
1434 /*
1435 d = 0xffffffffffffffff;
1437 if ((ulong)d != 0)
1438 return 2;
1440 if ((ushort)d != 0)
1441 return 3;
1443 if ((byte)d != 0)
1444 return 4;
1445 */
1456 }
1469 }
1478 }
1488 /* wrong exception */
1491 }
1501 /* wrong exception */
1504 }
1509 }
1513 }
1516 // Test that constant folding doesn't cause division by zero exceptions
1531 }
1534 }
1547 }
1556 }
1561 }
1574 }
1583 }
1593 /* wrong exception */
1596 }
1606 /* wrong exception */
1609 }
1614 }
1627 }
1636 }
1641 }
1654 }
1663 }
1668 }
1677 // Illegal conversion; o contains a string not an int
1682 }
1685 }
1687 // Test that double[] can't be cast to double (bug #46027)
1695 }
1697 }
1700 }
1701 }
1703 /* bug# 42190, at least mcs generates a leave for the return that
1704 * jumps out of multiple exception clauses: we used to execute just
1705 * one enclosing finally block.
1706 */
1715 }
1717 finally_level++;
1718 }
1719 }
1727 }
1734 checked { j = (long)i; }
1737 }
1742 }
1750 checked { j = (ulong)i; }
1753 }
1758 }
1769 };
1783 }
1789 }
1791 }
1792 }
1793 }
1797 }
1801 }
1805 }
1816 }
1823 }
1834 }
1835 }
1837 }
1848 }
1849 }
1851 }
1862 }
1863 }
1865 }
1876 }
1877 }
1879 }
1890 }
1891 }
1893 }
1904 }
1905 }
1907 }
1918 }
1919 }
1921 }
1932 }
1933 }
1935 }
1946 }
1947 }
1949 }
1960 }
1961 }
1963 }
1974 }
1975 }
1977 }
1988 }
1989 }
1991 }
2002 }
2003 }
2005 }
2016 }
2017 }
2019 }
2030 }
2031 }
2033 }
2044 }
2045 }
2047 }
2056 }
2057 }
2059 }
2070 }
2071 }
2073 }
2084 }
2085 }
2087 }
2098 }
2099 }
2101 }
2112 }
2113 }
2115 }
2127 }
2128 }
2130 }
2142 }
2143 }
2145 }
2152 }
2156 }
2157 }
2162 }
2164 // This will only happen once even if --regression is used
2165 }
2167 }
2176 }
2177 }
2181 }
2183 // Check that variables written in catch clauses are volatile
2187 }
2190 }
2198 }
2201 }
2202 }
2204 }
2209 }
2219 }
2220 }
2221 }
2223 // Test that a rethrow rethrows the correct exception
2231 }
2233 }
2235 /* MarshalByRefObject prevents the methods from being inlined */
2239 }
2243 }
2244 }
2247 // Check that rethrowing an exception preserves the original stack trace
2251 }
2253 // Check that each catch clause has its own exception variable
2254 // If not, the throw below will overwrite the exception used
2255 // by the rethrow
2258 }
2260 }
2263 }
2264 }
2268 }
2271 }
2283 }
2284 }
2293 }
2294 }
2304 }
2305 }
2313 }
2316 }
2323 }
2326 }
2331 }
2335 }
2342 }
2344 /* Test that arguments are correctly popped off the stack during unwinding */
2351 }
2353 }
2354 }
2356 }
2364 }
2366 }
2368 }
2376 }
2378 }
2382 }
2390 }
2393 }
2397 }
2402 }
2407 }
2410 }
2411 }
2415 }
2419 }
2425 }
2428 }
2431 }
2433 // bug #78633
2443 i ++;
2444 }
2446 }
2449 }
2451 // bug #485721
2458 }
2464 }
2466 }
2467 }
2471 }
2473 }
2474 }
2475 }
2478 }
2486 }
2487 }
2489 // for llvm, the end bblock is unreachable
2493 else
2495 }
2499 }
2501 // bug #539550
2504 // The invoke calls a runtime-invoke wrapper which has a filter clause
2507 }
2509 }
2514 }
2517 }
2518 }
2523 }
2528 }
2530 }
2531 }
2535 }
2539 }
2541 // #559876
2551 }
2553 }
2562 }
2567 }
2570 }
2571 }