From 539d795c25ceb36b775371b2517615d12cfaab12 Mon Sep 17 00:00:00 2001 From: Craig Citro Date: Mon, 1 Feb 2010 12:28:45 -0800 Subject: [PATCH] Add a bunch of new tests for closures. --- tests/run/closure_tests_1.pyx | 401 ++++++++++++++++ tests/run/closure_tests_2.pyx | 498 ++++++++++++++++++++ tests/run/closure_tests_3.pyx | 698 ++++++++++++++++++++++++++++ tests/run/closure_tests_4.pyx | 829 ++++++++++++++++++++++++++++++++++ tests/run/lambda_tests.pyx | 577 +++++++++++++++++++++++ 5 files changed, 3003 insertions(+) create mode 100644 tests/run/closure_tests_1.pyx create mode 100644 tests/run/closure_tests_2.pyx create mode 100644 tests/run/closure_tests_3.pyx create mode 100644 tests/run/closure_tests_4.pyx create mode 100644 tests/run/lambda_tests.pyx diff --git a/tests/run/closure_tests_1.pyx b/tests/run/closure_tests_1.pyx new file mode 100644 index 00000000..82d412e8 --- /dev/null +++ b/tests/run/closure_tests_1.pyx @@ -0,0 +1,401 @@ +# +# closure_tests_1.pyx +# +# Battery of tests for closures in Cython. Based on the collection of +# compiler tests from P423/B629 at Indiana University, Spring 1999 and +# Fall 2000. Special thanks to R. Kent Dybvig, Dan Friedman, Kevin +# Millikin, and everyone else who helped to generate the original +# tests. Converted into a collection of Python/Cython tests by Craig +# Citro. +# +# Note: This set of tests is split (somewhat randomly) into several +# files, simply because putting all the tests in a single file causes +# gcc and g++ to buckle under the load. +# + +def g1425(): + """ + >>> g1425() + 142 + """ + if (True): + def g1424(): + if (True): + return 122 + return (20)+(g1424()) + else: + return 10000 + + +def g1432(): + """ + >>> g1432() + [0, []] + """ + def g1431(): + return [0,[]] + x_1056 = g1431() + if (x_1056): + def g1430(): + def g1429(): + return (x_1056[0]) + def g1428(): + return (x_1056[0]) + return (g1429())+(g1428()) + x_1056[0] = g1430() + return x_1056 + + +def g1435(): + """ + >>> g1435() + 4000 + """ + def g1434(): + def g1433(y_1057): + return y_1057 + return g1433 + return g1434()(4000) + + +def g1438(): + """ + >>> g1438() + 1 + """ + def g1437(): + def g1436(x_1058): + return x_1058 + return g1436 + f_1059 = g1437() + return (f_1059(0)+1) + + +def g1441(): + """ + >>> g1441() + 4 + """ + def g1440(): + def g1439(y_1060): + return y_1060 + return g1439 + f_1061 = g1440() + return f_1061(f_1061(4)) + + +def g1446(): + """ + >>> g1446() + 4 + """ + def g1445(): + def g1444(f_1063): + return f_1063(f_1063(4)) + return g1444 + def g1443(): + def g1442(y_1062): + return y_1062 + return g1442 + return g1445()(g1443()) + + +def g1449(): + """ + >>> g1449() + 9000 + """ + def g1448(): + a_1064 = 4000 + def g1447(b_1065): + return (a_1064)+(b_1065) + return g1447 + return g1448()(5000) + + +def g1454(): + """ + >>> g1454() + 9000 + """ + def g1453(): + def g1452(): + def g1450(a_1066): + def g1451(b_1067): + return (a_1066)+(b_1067) + return g1451 + return g1450 + return g1452()(4000) + return g1453()(5000) + + +def g1459(): + """ + >>> g1459() + 2 + """ + def g1458(): + def g1457(f_1069): + return f_1069(f_1069(0)) + return g1457 + def g1456(): + def g1455(x_1068): + return (x_1068+1) + return g1455 + return g1458()(g1456()) + + +def g1462(): + """ + >>> g1462() + 0 + """ + x_1072 = 0 + def g1461(): + def g1460(x_1070): + return x_1070 + return g1460 + f_1071 = g1461() + a_1075 = f_1071(x_1072) + b_1074 = f_1071(x_1072) + c_1073 = f_1071(x_1072) + return ((a_1075)+(b_1074))+(c_1073) + + +def g1465(): + """ + >>> g1465() + 3 + """ + x_1080 = 0 + y_1079 = 1 + z_1078 = 2 + def g1464(): + def g1463(x_1076): + return x_1076 + return g1463 + f_1077 = g1464() + a_1083 = f_1077(x_1080) + b_1082 = f_1077(y_1079) + c_1081 = f_1077(z_1078) + return ((a_1083)+(b_1082))+(c_1081) + + +def g1468(): + """ + >>> g1468() + 0 + """ + def g1467(): + def g1466(x_1085, y_1084): + return x_1085 + return g1466 + f_1086 = g1467() + a_1087 = f_1086(0, 1) + return f_1086(a_1087, a_1087) + + +def g1471(): + """ + >>> g1471() + 0 + """ + x_1094 = 0 + y_1093 = 1 + z_1092 = 2 + def g1470(): + def g1469(x_1090, y_1089, z_1088): + return x_1090 + return g1469 + f_1091 = g1470() + a_1097 = f_1091(x_1094, y_1093, z_1092) + b_1096 = y_1093 + c_1095 = z_1092 + return f_1091(a_1097, b_1096, c_1095) + + +def g1474(): + """ + >>> g1474() + 3 + """ + def g1473(): + def g1472(a_1101, b_1100, c_1099, d_1098): + return (a_1101)+(d_1098) + return g1472 + f_1102 = g1473() + return f_1102(0, 1, 2, 3) + + +def g1478(): + """ + >>> g1478() + 3 + """ + def g1477(): + def g1476(x_1103): + return x_1103 + return g1476 + f_1104 = g1477() + def g1475(): + a_1107 = 0 + b_1106 = 1 + c_1105 = 2 + return (f_1104(a_1107))+((f_1104(b_1106))+(f_1104(c_1105))) + return (f_1104(0))+(g1475()) + + +def g1483(): + """ + >>> g1483() + """ + a_1108 = 0 + def g1482(): + def g1481(): + return 0 + return g1481 + a_1110 = g1482() + def g1480(): + def g1479(): + return 11 + return g1479 + b_1109 = g1480() + a_1110 = 11 + + +def g1486(): + """ + >>> g1486() + """ + a_1111 = 0 + def g1485(): + def g1484(): + a_1113 = 0 + return g1484 + a_1113 = g1485() + b_1112 = 11 + return a_1113() + + +def g1491(): + """ + >>> g1491() + 0 + """ + def g1490(): + def g1489(): + return 0 + return g1489 + a_1115 = g1490() + def g1488(): + def g1487(): + return 11 + return g1487 + b_1114 = g1488() + return a_1115() + + +def g1494(): + """ + >>> g1494() + 2 + """ + def g1493(): + x_1116 = 1 + def g1492(y_1117): + return (x_1116)+(y_1117) + return g1492 + f_1118 = g1493() + x_1119 = 0 + return f_1118(f_1118(x_1119)) + + +def g1501(): + """ + >>> g1501() + 3050 + """ + def g1500(): + def g1499(): + def g1498(x_1121): + return (x_1121)+(50) + return g1498 + t_1122 = g1499() + def g1497(f_1123): + return t_1122(f_1123(1000)) + return g1497 + def g1496(): + def g1495(y_1120): + return (y_1120)+(2000) + return g1495 + return g1500()(g1496()) + + +def g1508(): + """ + >>> g1508() + 60 + """ + def g1507(): + def g1506(): + def g1505(): + def g1502(a_1124): + def g1503(b_1125): + def g1504(c_1126): + return (a_1124)+((b_1125)+(c_1126)) + return g1504 + return g1503 + return g1502 + return g1505()(10) + return g1506()(20) + return g1507()(30) + + +def g1513(): + """ + >>> g1513() + 5 + """ + def g1512(): + def g1509(b_1127): + def g1511(): + def g1510(a_1128): + return (b_1127)+(a_1128) + return g1510 + return g1511()(2) + return g1509 + return g1512()(3) + + +def g1518(): + """ + >>> g1518() + 5 + """ + def g1517(): + def g1516(f_1130): + return f_1130(f_1130(5)) + return g1516 + def g1515(): + def g1514(x_1129): + return x_1129 + return g1514 + return g1517()(g1515()) + + +def g1523(): + """ + >>> g1523() + 8000 + """ + def g1522(): + def g1521(): + def g1520(x_1131): + return (x_1131)+(3000) + return g1520 + f_1132 = g1521() + def g1519(y_1133): + return f_1132(f_1132(y_1133)) + return g1519 + return g1522()(2000) + diff --git a/tests/run/closure_tests_2.pyx b/tests/run/closure_tests_2.pyx new file mode 100644 index 00000000..1b86ffb8 --- /dev/null +++ b/tests/run/closure_tests_2.pyx @@ -0,0 +1,498 @@ +# +# closure_tests_2.pyx +# +# Battery of tests for closures in Cython. Based on the collection of +# compiler tests from P423/B629 at Indiana University, Spring 1999 and +# Fall 2000. Special thanks to R. Kent Dybvig, Dan Friedman, Kevin +# Millikin, and everyone else who helped to generate the original +# tests. Converted into a collection of Python/Cython tests by Craig +# Citro. +# +# Note: This set of tests is split (somewhat randomly) into several +# files, simply because putting all the tests in a single file causes +# gcc and g++ to buckle under the load. +# + + +def g1526(): + """ + >>> g1526() + 2 + """ + x_1134 = 0 + def g1525(): + x_1136 = 1 + z_1135 = x_1134 + def g1524(y_1137): + return (x_1136)+((z_1135)+(y_1137)) + return g1524 + f_1138 = g1525() + return f_1138(f_1138(x_1134)) + + +def g1535(): + """ + >>> g1535() + 3050 + """ + def g1534(): + def g1533(): + def g1531(t_1141): + def g1532(f_1142): + return t_1141(f_1142(1000)) + return g1532 + return g1531 + def g1530(): + def g1529(x_1140): + return (x_1140)+(50) + return g1529 + return g1533()(g1530()) + def g1528(): + def g1527(y_1139): + return (y_1139)+(2000) + return g1527 + return g1534()(g1528()) + + +def g1540(): + """ + >>> g1540() + 2050 + """ + def g1539(): + t_1143 = 50 + def g1538(f_1144): + return (t_1143)+(f_1144()) + return g1538 + def g1537(): + def g1536(): + return 2000 + return g1536 + return g1539()(g1537()) + + +def g1547(): + """ + >>> g1547() + 2050 + """ + def g1546(): + def g1545(): + def g1543(t_1145): + def g1544(f_1146): + return (t_1145)+(f_1146()) + return g1544 + return g1543 + return g1545()(50) + def g1542(): + def g1541(): + return 2000 + return g1541 + return g1546()(g1542()) + + +def g1550(): + """ + >>> g1550() + 700 + """ + def g1549(): + x_1147 = 300 + def g1548(y_1148): + return (x_1147)+(y_1148) + return g1548 + return g1549()(400) + + +def g1553(): + """ + >>> g1553() + 0 + """ + x_1152 = 3 + def g1552(): + def g1551(x_1150, y_1149): + return x_1150 + return g1551 + f_1151 = g1552() + if (f_1151(0, 0)): + return f_1151(f_1151(0, 0), x_1152) + else: + return 0 + + +def g1562(): + """ + >>> g1562() + False + """ + def g1561(): + def g1556(x_1153): + def g1560(): + def g1559(): + return isinstance(x_1153, list) + if (g1559()): + def g1558(): + def g1557(): + return (x_1153[0]) + return (g1557() == 0) + return (not g1558()) + else: + return False + if (g1560()): + return x_1153 + else: + return False + return g1556 + f_1154 = g1561() + def g1555(): + def g1554(): + return [0,[]] + return [0,g1554()] + return f_1154(g1555()) + + +def g1570(): + """ + >>> g1570() + False + """ + def g1569(): + def g1563(x_1155): + def g1568(): + if (x_1155): + def g1567(): + def g1566(): + return isinstance(x_1155, list) + if (g1566()): + def g1565(): + def g1564(): + return (x_1155[0]) + return (g1564() == 0) + return (not g1565()) + else: + return False + return (not g1567()) + else: + return False + if (g1568()): + return x_1155 + else: + return False + return g1563 + f_1156 = g1569() + return f_1156(0) + + +def g1575(): + """ + >>> g1575() + [] + """ + def g1574(): + def g1571(x_1157): + def g1573(): + def g1572(): + return isinstance(x_1157, list) + if (g1572()): + return True + else: + return (x_1157 == []) + if (g1573()): + return x_1157 + else: + return [] + return g1571 + f_1158 = g1574() + return f_1158(0) + + +def g1578(): + """ + >>> g1578() + 4 + """ + y_1159 = 4 + def g1577(): + def g1576(y_1160): + return y_1160 + return g1576 + f_1161 = g1577() + return f_1161(f_1161(y_1159)) + + +def g1581(): + """ + >>> g1581() + 0 + """ + y_1162 = 4 + def g1580(): + def g1579(x_1164, y_1163): + return 0 + return g1579 + f_1165 = g1580() + return f_1165(f_1165(y_1162, y_1162), f_1165(y_1162, y_1162)) + + +def g1584(): + """ + >>> g1584() + 0 + """ + y_1166 = 4 + def g1583(): + def g1582(x_1168, y_1167): + return 0 + return g1582 + f_1169 = g1583() + return f_1169(f_1169(y_1166, y_1166), f_1169(y_1166, f_1169(y_1166, y_1166))) + + +def g1587(): + """ + >>> g1587() + 0 + """ + y_1170 = 4 + def g1586(): + def g1585(x_1172, y_1171): + return 0 + return g1585 + f_1173 = g1586() + return f_1173(f_1173(y_1170, f_1173(y_1170, y_1170)), f_1173(y_1170, f_1173(y_1170, y_1170))) + + +def g1594(): + """ + >>> g1594() + 4 + """ + def g1593(): + def g1588(y_1174): + def g1592(): + def g1591(f_1176): + return f_1176(f_1176(y_1174)) + return g1591 + def g1590(): + def g1589(y_1175): + return y_1175 + return g1589 + return g1592()(g1590()) + return g1588 + return g1593()(4) + + +def g1598(): + """ + >>> g1598() + 23 + """ + def g1597(): + def g1596(x_1177): + return x_1177 + return g1596 + f_1178 = g1597() + def g1595(): + if (False): + return 1 + else: + return f_1178(22) + return (g1595()+1) + + +def g1603(): + """ + >>> g1603() + 22 + """ + def g1602(): + def g1601(x_1179): + return x_1179 + return g1601 + f_1180 = g1602() + def g1600(): + def g1599(): + return 23 == 0 + return f_1180(g1599()) + if (g1600()): + return 1 + else: + return 22 + + +def g1611(): + """ + >>> g1611() + 5061 + """ + def g1610(): + def g1609(x_1182): + if (x_1182): + return (not x_1182) + else: + return x_1182 + return g1609 + f_1185 = g1610() + def g1608(): + def g1607(x_1181): + return (10)*(x_1181) + return g1607 + f2_1184 = g1608() + x_1183 = 23 + def g1606(): + def g1605(): + def g1604(): + return x_1183 == 0 + return f_1185(g1604()) + if (g1605()): + return 1 + else: + return (x_1183)*(f2_1184((x_1183-1))) + return (g1606()+1) + + +def g1614(): + """ + >>> g1614() + 1 + """ + def g1613(): + def g1612(): + return 0 + return g1612 + f_1186 = g1613() + x_1187 = f_1186() + return 1 + + +def g1617(): + """ + >>> g1617() + 1 + """ + def g1616(): + def g1615(): + return 0 + return g1615 + f_1188 = g1616() + f_1188() + return 1 + + +def g1620(): + """ + >>> g1620() + 4 + """ + def g1619(): + def g1618(x_1189): + return x_1189 + return g1618 + f_1190 = g1619() + if (True): + f_1190(3) + return 4 + else: + return 5 + + +def g1623(): + """ + >>> g1623() + 6 + """ + def g1622(): + def g1621(x_1191): + return x_1191 + return g1621 + f_1192 = g1622() + (f_1192(4)) if (True) else (5) + return 6 + + +def g1627(): + """ + >>> g1627() + 120 + """ + def g1626(): + def g1624(fact_1195, n_1194, acc_1193): + def g1625(): + return n_1194 == 0 + if (g1625()): + return acc_1193 + else: + return fact_1195(fact_1195, (n_1194-1), (n_1194)*(acc_1193)) + return g1624 + fact_1196 = g1626() + return fact_1196(fact_1196, 5, 1) + + +def g1632(): + """ + >>> g1632() + 144 + """ + def g1631(): + def g1628(b_1199, c_1198, a_1197): + b_1203 = (b_1199)+(a_1197) + def g1630(): + def g1629(): + a_1201 = (b_1199)+(b_1199) + c_1200 = (c_1198)+(c_1198) + return (a_1201)+(a_1201) + return (a_1197)+(g1629()) + a_1202 = g1630() + return (a_1202)*(a_1202) + return g1628 + return g1631()(2, 3, 4) + + +def g1639(): + """ + >>> g1639() + 3 + """ + def g1638(): + def g1636(x_1204): + def g1637(): + return x_1204() + return g1637 + return g1636 + f_1205 = g1638() + def g1635(): + def g1634(): + def g1633(): + return 3 + return g1633 + return f_1205(g1634()) + return g1635()() + + +def g1646(): + """ + >>> g1646() + 3628800 + """ + def g1645(): + def g1643(x_1207): + def g1644(): + return x_1207 == 0 + if (g1644()): + return 1 + else: + return (x_1207)*(f_1206((x_1207)-(1))) + return g1643 + f_1206 = g1645() + q_1208 = 17 + def g1642(): + def g1640(a_1209): + q_1208 = 10 + def g1641(): + return a_1209(q_1208) + return g1641 + return g1640 + g_1210 = g1642() + return g_1210(f_1206)() + diff --git a/tests/run/closure_tests_3.pyx b/tests/run/closure_tests_3.pyx new file mode 100644 index 00000000..0279691d --- /dev/null +++ b/tests/run/closure_tests_3.pyx @@ -0,0 +1,698 @@ +# +# closure_tests_3.pyx +# +# Battery of tests for closures in Cython. Based on the collection of +# compiler tests from P423/B629 at Indiana University, Spring 1999 and +# Fall 2000. Special thanks to R. Kent Dybvig, Dan Friedman, Kevin +# Millikin, and everyone else who helped to generate the original +# tests. Converted into a collection of Python/Cython tests by Craig +# Citro. +# +# Note: This set of tests is split (somewhat randomly) into several +# files, simply because putting all the tests in a single file causes +# gcc and g++ to buckle under the load. +# + + +def g1649(): + """ + >>> g1649() + 6 + """ + def g1648(): + def g1647(x_1211): + return x_1211 + return g1647 + f_1212 = g1648() + if (f_1212(True)): + f_1212(3) + f_1212(4) + else: + f_1212(5) + return f_1212(6) + + +def g1653(): + """ + >>> g1653() + 5 + """ + def g1652(): + def g1651(x_1213): + return (x_1213+1) + return g1651 + f_1214 = g1652() + def g1650(): + f_1215 = 3 + return (f_1215)+(1) + return f_1214(g1650()) + + +def g1662(): + """ + >>> g1662() + 51 + """ + x_1223 = 15 + def g1661(): + def g1660(h_1219, v_1218): + return (h_1219)*(v_1218) + return g1660 + f_1222 = g1661() + def g1659(): + def g1658(x_1217): + return (x_1217)+(5) + return g1658 + k_1221 = g1659() + def g1657(): + def g1656(x_1216): + return (x_1216+1) + return g1656 + g_1220 = g1657() + def g1655(): + def g1654(): + g_1224 = 3 + return f_1222(g_1224, x_1223) + return g_1220(g1654()) + return k_1221(g1655()) + + +def g1665(): + """ + >>> g1665() + 5 + """ + x_1225 = 4 + def g1664(): + def g1663(): + return x_1225 + return g1663 + f_1226 = g1664() + x_1225 = 5 + return f_1226() + + +def g1670(): + """ + >>> g1670() + 5 + """ + def g1669(): + def g1668(): + def g1667(): + def g1666(): + return 4 + return g1666 + y_1227 = g1667() + return y_1227() + return (g1668()+1) + x_1228 = g1669() + return x_1228 + + +def g1674(): + """ + >>> g1674() + 1 + """ + def g1673(): + def g1671(n_1230): + def g1672(): + return n_1230 == 0 + if (g1672()): + return 1 + else: + return one_1229((n_1230-1)) + return g1671 + one_1229 = g1673() + return one_1229(13) + + +def g1681(): + """ + >>> g1681() + True + """ + def g1680(): + def g1678(x_1234): + def g1679(): + return x_1234 == 0 + if (g1679()): + return True + else: + return odd_1231((x_1234-1)) + return g1678 + even_1232 = g1680() + def g1677(): + def g1675(x_1233): + def g1676(): + return x_1233 == 0 + if (g1676()): + return False + else: + return even_1232((x_1233-1)) + return g1675 + odd_1231 = g1677() + return odd_1231(13) + + +def g1688(): + """ + >>> g1688() + True + """ + t_1236 = True + f_1235 = False + def g1687(): + def g1685(x_1240): + def g1686(): + return x_1240 == 0 + if (g1686()): + return t_1236 + else: + return odd_1237((x_1240-1)) + return g1685 + even_1238 = g1687() + def g1684(): + def g1682(x_1239): + def g1683(): + return x_1239 == 0 + if (g1683()): + return f_1235 + else: + return even_1238((x_1239-1)) + return g1682 + odd_1237 = g1684() + return odd_1237(13) + + +def g1698(): + """ + >>> g1698() + True + """ + def g1697(): + def g1696(x_1241): + return x_1241 + return g1696 + even_1242 = g1697() + def g1695(): + def g1694(): + def g1692(x_1246): + def g1693(): + return x_1246 == 0 + if (g1693()): + return True + else: + return odd_1243((x_1246-1)) + return g1692 + even_1244 = g1694() + def g1691(): + def g1689(x_1245): + def g1690(): + return x_1245 == 0 + if (g1690()): + return False + else: + return even_1244((x_1245-1)) + return g1689 + odd_1243 = g1691() + return odd_1243(13) + return even_1242(g1695()) + + +def g1702(): + """ + >>> g1702() + 120 + """ + def g1701(): + def g1699(n_1248): + def g1700(): + return n_1248 == 0 + if (g1700()): + return 1 + else: + return (n_1248)*(fact_1247((n_1248-1))) + return g1699 + fact_1247 = g1701() + return fact_1247(5) + + +def g1716(): + """ + >>> g1716() + 10 + """ + x_1249 = 5 + def g1715(): + def g1713(u_1263, v_1262, w_1261): + def g1714(): + return u_1263 == 0 + if (g1714()): + return b_1251(v_1262, w_1261) + else: + return a_1252((u_1263)-(1), v_1262, w_1261) + return g1713 + a_1252 = g1715() + def g1712(): + def g1705(q_1255, r_1254): + p_1256 = (q_1255)*(r_1254) + def g1711(): + def g1709(n_1260): + def g1710(): + return n_1260 == 0 + if (g1710()): + return c_1250(p_1256) + else: + return o_1257((n_1260)-(1)) + return g1709 + e_1258 = g1711() + def g1708(): + def g1706(n_1259): + def g1707(): + return n_1259 == 0 + if (g1707()): + return c_1250(x_1249) + else: + return e_1258((n_1259)-(1)) + return g1706 + o_1257 = g1708() + return e_1258((q_1255)*(r_1254)) + return g1705 + b_1251 = g1712() + def g1704(): + def g1703(x_1253): + return (5)*(x_1253) + return g1703 + c_1250 = g1704() + return a_1252(3, 2, 1) + + +def g1729(): + """ + >>> g1729() + 537516 + """ + def g1728(): + def g1727(x_1269): + return (x_1269+1) + return g1727 + f_1276 = g1728() + def g1726(): + def g1725(x_1268): + return (x_1268-1) + return g1725 + g_1275 = g1726() + def g1724(): + def g1723(x_1267): + return (x_1267+1) + return g1723 + t_1274 = g1724() + def g1722(): + def g1721(x_1266): + return (x_1266+1) + return g1721 + j_1273 = g1722() + def g1720(): + def g1719(x_1265): + return (x_1265+1) + return g1719 + i_1272 = g1720() + def g1718(): + def g1717(x_1264): + return (x_1264+1) + return g1717 + h_1271 = g1718() + x_1270 = 80 + a_1279 = f_1276(x_1270) + b_1278 = g_1275(x_1270) + c_1277 = h_1271(i_1272(j_1273(t_1274(x_1270)))) + return (a_1279)*((b_1278)*((c_1277)+(0))) + + +def g1733(): + """ + >>> g1733() + 120 + """ + def g1732(): + def g1730(fact_1281, n_1280): + def g1731(): + return n_1280 == 0 + if (g1731()): + return 1 + else: + return (fact_1281(fact_1281, (n_1280-1)))*(n_1280) + return g1730 + fact_1282 = g1732() + return fact_1282(fact_1282, 5) + + +def g1737(): + """ + >>> g1737() + 10000 + """ + def g1736(): + def g1735(x_1283): + return (x_1283)+(1000) + return g1735 + f_1284 = g1736() + def g1734(): + return f_1284(-2) == 0 + if (g1734()): + return f_1284(6000) + else: + return f_1284(f_1284(8000)) + + +def g1741(): + """ + >>> g1741() + 10000 + """ + def g1740(): + def g1739(x_1285): + return (x_1285)+(1000) + return g1739 + f_1286 = g1740() + def g1738(): + return f_1286(-1) == 0 + if (g1738()): + return f_1286(6000) + else: + return f_1286(f_1286(8000)) + + +def g1747(): + """ + >>> g1747() + 8000 + """ + def g1746(): + def g1745(x_1288, y_1287): + return (x_1288)+(1000) + return g1745 + f_1289 = g1746() + def g1744(): + def g1743(): + def g1742(): + return 0 + return f_1289(3000, g1742()) + if (g1743()): + return f_1289(f_1289(4000, 0), 0) + else: + return 8000 + return (g1744())+(2000) + + +def g1754(): + """ + >>> g1754() + 24 + """ + def g1753(): + def g1752(): + def g1751(): + def g1748(x_1290): + def g1749(y_1291): + def g1750(z_1292): + return (x_1290)+((y_1291)+((z_1292)+(y_1291))) + return g1750 + return g1749 + return g1748 + return g1751()(5) + return g1752()(6) + return g1753()(7) + + +def g1765(): + """ + >>> g1765() + 35 + """ + def g1764(): + def g1763(): + def g1762(): + def g1761(): + def g1760(): + def g1755(x_1293): + def g1756(y_1294): + def g1757(z_1295): + def g1758(w_1296): + def g1759(u_1297): + return (x_1293)+((y_1294)+((z_1295)+((w_1296)+(u_1297)))) + return g1759 + return g1758 + return g1757 + return g1756 + return g1755 + return g1760()(5) + return g1761()(6) + return g1762()(7) + return g1763()(8) + return g1764()(9) + + +def g1769(): + """ + >>> g1769() + True + """ + def g1768(): + def g1767(x_1298): + return x_1298 + return g1767 + f_1299 = g1768() + def g1766(): + return callable(f_1299) + if (g1766()): + return True + else: + return False + + +def g1779(): + """ + >>> g1779() + 6 + """ + def g1778(): + def g1773(sum_1301, ls_1300): + def g1777(): + return (ls_1300 == []) + if (g1777()): + return 0 + else: + def g1776(): + return (ls_1300[0]) + def g1775(): + def g1774(): + return (ls_1300[1]) + return sum_1301(sum_1301, g1774()) + return (g1776())+(g1775()) + return g1773 + sum_1302 = g1778() + def g1772(): + def g1771(): + def g1770(): + return [3,[]] + return [2,g1770()] + return [1,g1771()] + return sum_1302(sum_1302, g1772()) + + +def g1785(): + """ + >>> g1785() + 1500 + """ + def g1784(): + def g1783(): + def g1780(a_1303): + def g1781(): + def g1782(): + if (True): + return 200 + (a_1303)+(g1782()) + return 1500 + return g1781 + return g1780 + return g1783()(1000) + return g1784()() + + +def g1791(): + """ + >>> g1791() + 102 + """ + def g1790(): + def g1789(): + def g1786(b_1304): + def g1787(a_1305): + def g1788(): + if (1): + return 2 + a_1305 = g1788() + return (a_1305)+(b_1304) + return g1787 + return g1786 + return g1789()(100) + return g1790()(200) + + +def g1800(): + """ + >>> g1800() + 2600 + """ + def g1799(): + def g1798(): + def g1797(): + def g1792(a_1306): + def g1793(b_1307): + def g1794(): + if (b_1307): + return 200 + a_1306 = g1794() + def g1795(c_1308): + def g1796(): + if (300): + return 400 + c_1308 = g1796() + return (a_1306)+((b_1307)+(c_1308)) + return g1795 + return g1793 + return g1792 + return g1797()(1000) + return g1798()(2000) + return g1799()(3000) + + +def g1807(): + """ + >>> g1807() + 3628800 + """ + def g1806(): + def g1804(x_1310): + def g1805(): + return x_1310 == 0 + if (g1805()): + return 1 + else: + return (x_1310)*(f_1309((x_1310)-(1))) + return g1804 + f_1309 = g1806() + def g1803(): + def g1801(a_1311): + def g1802(b_1312): + return a_1311(b_1312) + return g1802 + return g1801 + g_1313 = g1803() + return g_1313(f_1309)(10) + + +def g1828(): + """ + >>> g1828() + [52, [44, [17, [44, [52, 17]]]]] + """ + def g1827(): + def g1826(): + return (a_1316)+(b_1315) + return g1826 + f_1318 = g1827() + def g1825(): + def g1822(y_1320): + def g1824(): + def g1823(y_1321): + return y_1321 + return g1823 + g_1317 = g1824() + return (y_1320)+(y_1320) + return g1822 + g_1317 = g1825() + a_1316 = 17 + b_1315 = 35 + def g1821(): + def g1820(): + def g1819(): + return a_1316 + return g1819 + def g1818(): + def g1817(v_1319): + a_1316 = v_1319 + return g1817 + return [g1820(),g1818()] + h_1314 = g1821() + x1_1324 = f_1318() + x2_1323 = g_1317(22) + def g1816(): + def g1815(): + return (h_1314[0]) + return g1815()() + x3_1322 = g1816() + x4_1325 = g_1317(22) + def g1814(): + return (h_1314[1]) + g1814()(3) + x5_1327 = f_1318() + def g1813(): + def g1812(): + return (h_1314[0]) + return g1812()() + x6_1326 = g1813() + def g1811(): + def g1810(): + def g1809(): + def g1808(): + return [x5_1327,x6_1326] + return [x4_1325,g1808()] + return [x3_1322,g1809()] + return [x2_1323,g1810()] + return [x1_1324,g1811()] + + +def g1843(): + """ + >>> g1843() + [52, [17, [35, [17, 35]]]] + """ + def g1842(): + def g1841(): + return (a_1330)+(b_1329) + return g1841 + f_1331 = g1842() + a_1330 = 17 + b_1329 = 35 + def g1840(): + def g1839(): + def g1838(): + return a_1330 + return g1838 + def g1837(): + def g1836(): + return b_1329 + return g1836 + return [g1839(),g1837()] + h_1328 = g1840() + def g1835(): + def g1834(): + def g1833(): + def g1832(): + def g1831(): + return (h_1328[0]) + return g1831()() + def g1830(): + def g1829(): + return (h_1328[1]) + return g1829()() + return [g1832(),g1830()] + return [b_1329,g1833()] + return [a_1330,g1834()] + return [f_1331(),g1835()] + diff --git a/tests/run/closure_tests_4.pyx b/tests/run/closure_tests_4.pyx new file mode 100644 index 00000000..81e16450 --- /dev/null +++ b/tests/run/closure_tests_4.pyx @@ -0,0 +1,829 @@ +# +# closure_tests_4.pyx +# +# Battery of tests for closures in Cython. Based on the collection of +# compiler tests from P423/B629 at Indiana University, Spring 1999 and +# Fall 2000. Special thanks to R. Kent Dybvig, Dan Friedman, Kevin +# Millikin, and everyone else who helped to generate the original +# tests. Converted into a collection of Python/Cython tests by Craig +# Citro. +# +# Note: This set of tests is split (somewhat randomly) into several +# files, simply because putting all the tests in a single file causes +# gcc and g++ to buckle under the load. +# + + +def g1852(): + """ + >>> g1852() + [3, 42] + """ + def g1851(): + def g1850(x_1333): + x_1334 = 3 + return 3 + return g1850 + f_1332 = g1851() + def g1848(): + def g1847(x_1336): + y_1337 = 14 + y_1337 = 7 + return y_1337 + return g1847 + g_1335 = g1848() + def g1849(): + return [g_1335,3] + g_1335 = g1849() + def g1846(): + def g1845(x_1340): + return x_1340 + return g1845 + h_1339 = g1846() + z_1338 = 42 + def g1844(): + return (g_1335[1]) + return [g1844(),h_1339(z_1338)] + + +def g1864(): + """ + >>> g1864() + True + """ + t_1342 = True + f_1341 = False + def g1863(): + return [t_1342,f_1341] + bools_1345 = g1863() + def g1862(): + def g1861(x_1343): + if ((not x_1343)): + return f_1341 + else: + return t_1342 + return g1861 + id_1344 = g1862() + def g1860(): + def g1857(x_1349): + def g1859(): + return x_1349 == 0 + if (g1859()): + def g1858(): + return (bools_1345[0]) + return id_1344(g1858()) + else: + return odd_1346((x_1349)-(1)) + return g1857 + even_1347 = g1860() + def g1856(): + def g1853(y_1348): + def g1855(): + return y_1348 == 0 + if (g1855()): + def g1854(): + return (bools_1345[1]) + return id_1344(g1854()) + else: + return even_1347((y_1348)-(1)) + return g1853 + odd_1346 = g1856() + return odd_1346(5) + + +def g1872(): + """ + >>> g1872() + 35 + """ + a_1350 = 5 + def g1871(): + return [a_1350,6] + b_1351 = g1871() + def g1870(): + def g1869(x_1352): + return (x_1352)*(a_1350) + return g1869 + f_1353 = g1870() + def g1867(): + def g1866(): + return (b_1351[0]) + return (f_1353(a_1350))-(g1866()) + if (g1867()): + def g1868(): + if ((not a_1350)): + return (2)*(a_1350) + else: + return (2)+(a_1350) + b_1351[0] = g1868() + f_1353(a_1350) + else: + if ((not (not (f_1353(a_1350) < b_1351)))): (f_1353(a_1350)) + def g1865(): + return (b_1351[0]) + return f_1353(g1865()) + + +def g1885(): + """ + >>> g1885() + 9 + """ + def g1884(): + def g1883(x_1368, y_1367): + if ((not x_1368)): + return g_1355((x_1368+1), (y_1367+1)) + else: + return h_1354((x_1368)+(y_1367)) + return g1883 + f_1356 = g1884() + def g1882(): + def g1875(u_1359, v_1358): + a_1361 = (u_1359)+(v_1358) + b_1360 = (u_1359)*(v_1358) + def g1881(): + def g1876(d_1363): + def g1880(): + return [a_1361,b_1360] + p_1365 = g1880() + def g1879(): + def g1877(m_1366): + if ((m_1366 < u_1359)): + return f_1356(m_1366, d_1363) + else: + def g1878(): + return (p_1365[0]) + return h_1354(g1878()) + return g1877 + q_1364 = g1879() + return q_1364(f_1356(a_1361, b_1360)) + return g1876 + e_1362 = g1881() + return e_1362(u_1359) + return g1875 + g_1355 = g1882() + def g1874(): + def g1873(w_1357): + return w_1357 + return g1873 + h_1354 = g1874() + return f_1356(4, 5) + + +def g1897(): + """ + >>> g1897() + 22 + """ + def g1896(): + def g1890(x_1373): + def g1895(): + def g1894(): + def g1893(): + def g1891(y_1374): + def g1892(z_1375): + return (y_1374)+(z_1375) + return g1892 + return g1891 + return g1893()(6) + return g1894()(7) + return (x_1373)+(g1895()) + return g1890 + f_1370 = g1896() + def g1889(): + def g1888(): + def g1887(): + def g1886(w_1372, u_1371): + return (w_1372)+(u_1371) + return g1886 + return g1887()(8, 9) + return (5)+(g1888()) + g_1369 = g1889() + return g_1369 + + +def g1923(): + """ + >>> g1923() + True + """ + y_1377 = [] + z_1376 = 10 + def g1911(): + return [5,y_1377] + test_ls_1378 = g1911() + def g1922(): + def g1913(f_1379): + def g1921(): + def g1918(g_1382): + def g1920(): + def g1919(x_1383): + return g_1382(g_1382)(x_1383) + return g1919 + return f_1379(g1920()) + return g1918 + def g1917(): + def g1914(g_1380): + def g1916(): + def g1915(x_1381): + return g_1380(g_1380)(x_1381) + return g1915 + return f_1379(g1916()) + return g1914 + return g1921()(g1917()) + return g1913 + y_1377 = g1922() + def g1912(): + return [z_1376,test_ls_1378] + test_ls_1378 = g1912() + def g1910(): + def g1906(ls_1385): + def g1909(): + return (ls_1385 == []) + if (g1909()): + return 0 + else: + def g1908(): + def g1907(): + return (ls_1385[1]) + return length_1384(g1907()) + return (1)+(g1908()) + return g1906 + length_1384 = g1910() + len_1386 = length_1384(test_ls_1378) + def g1905(): + def g1904(): + def g1903(): + def g1898(len_1387): + def g1899(ls_1388): + def g1902(): + return (ls_1388 == []) + if (g1902()): + return 0 + else: + def g1901(): + def g1900(): + return (ls_1388[1]) + return len_1387(g1900()) + return (1)+(g1901()) + return g1899 + return g1898 + return y_1377(g1903()) + length_1384 = g1904() + return length_1384(test_ls_1378) + return (g1905() == len_1386) + + +def g1927(): + """ + >>> g1927() + 0 + """ + def g1926(): + def g1924(): + def g1925(): + return loop_1389() + return g1925 + return g1924 + loop_1389 = g1926() + loop_1389() + return 0 + + +def g1935(): + """ + >>> g1935() + 668 + """ + def g1934(): + def g1928(): + def g1933(): + def g1931(link_1392): + def g1932(): + return link_1392() + return g1932 + return g1931 + loop_1391 = g1933() + def g1930(): + def g1929(): + return 668 + return g1929 + return loop_1391(g1930()) + return g1928 + f_1390 = g1934() + return f_1390()() + + +def g1946(): + """ + >>> g1946() + 14629 + """ + def g1945(): + def g1944(): + return 1 + return g1944 + if (g1945()): + a_1393 = 2 + def g1943(): + def g1942(): + def g1941(): + def g1938(x_1394): + def g1940(): + def g1939(): + a_1393 = 1 + a_1393 = g1939() + x_1395 = g1940() + return x_1395 + return g1938 + return g1941()(1) + if (g1942()): + def g1937(): + def g1936(): + return None + return (a_1393 == g1936()) + if (g1937()): + return True + else: + return False + else: + return False + if (g1943()): + return 778477 + else: + return 14629 + + +def g1949(): + """ + >>> g1949() + 2 + """ + def g1948(): + def g1947(x_1396): + return x_1396 + return g1947 + f_1397 = g1948() + a_1398 = 1 + return ((f_1397(a_1398))+(a_1398))*(a_1398) + + +def g1952(): + """ + >>> g1952() + 17 + """ + def g1951(): + def g1950(x_1400, y_1399): + return x_1400 + return g1950 + k_1401 = g1951() + b_1402 = 17 + return k_1401(k_1401(k_1401, 37), 37)(b_1402, (b_1402)*(b_1402)) + + +def g1956(): + """ + >>> g1956() + False + """ + def g1955(): + def g1953(): + n_1403 = 256 + def g1954(): + return ([0]*n_1403) + v_1404 = g1954() + v_1404[32] = n_1403 + return v_1404[32] + return g1953 + f_1405 = g1955() + return isinstance(f_1405(), list) + + +def g1959(): + """ + >>> g1959() + 60 + """ + w_1409 = 4 + x_1408 = 8 + y_1407 = 16 + z_1406 = 32 + def g1958(): + def g1957(): + return (w_1409)+((x_1408)+((y_1407)+(z_1406))) + return g1957 + f_1410 = g1958() + return f_1410() + + +def g1965(): + """ + >>> g1965() + 37 + """ + def g1964(): + def g1962(g_1412, u_1411): + def g1963(): + if (u_1411): + return g_1412(37) + else: + return u_1411 + return g_1412(g1963()) + return g1962 + f_1413 = g1964() + def g1961(): + def g1960(x_1414): + return x_1414 + return g1960 + return f_1413(g1961(), 75) + + +def g1971(): + """ + >>> g1971() + 4687 + """ + def g1970(): + def g1968(h_1416, u_1415): + def g1969(): + if (u_1415): + return h_1416((u_1415)+(37)) + else: + return u_1415 + return h_1416(g1969()) + return g1968 + f_1418 = g1970() + w_1417 = 62 + def g1967(): + def g1966(x_1419): + return (w_1417)-(x_1419) + return g1966 + return f_1418(g1967(), (75)*(w_1417)) + + +def g1983(): + """ + >>> g1983() + True + """ + t_1421 = True + f_1420 = False + def g1982(): + return [t_1421,f_1420] + bools_1424 = g1982() + def g1981(): + def g1980(x_1422): + if ((not x_1422)): + return f_1420 + else: + return t_1421 + return g1980 + id_1423 = g1981() + def g1979(): + def g1976(x_1428): + def g1978(): + def g1977(): + return x_1428 == 0 + return id_1423(g1977()) + if (g1978()): + return (bools_1424[0]) + else: + return odd_1425((x_1428)-(1)) + return g1976 + even_1426 = g1979() + def g1975(): + def g1972(y_1427): + def g1974(): + return y_1427 == 0 + if (g1974()): + def g1973(): + return (bools_1424[1]) + return id_1423(g1973()) + else: + return even_1426((y_1427)-(1)) + return g1972 + odd_1425 = g1975() + return odd_1425(5) + + +def g1990(): + """ + >>> g1990() + 48 + """ + def g1989(): + def g1984(x_1431, y_1430, z_1429): + def g1988(): + def g1987(u_1435, v_1434): + x_1431 = u_1435 + return (x_1431)+(v_1434) + return g1987 + f_1437 = g1988() + def g1986(): + def g1985(r_1433, s_1432): + y_1430 = (z_1429)+(s_1432) + return y_1430 + return g1985 + g_1436 = g1986() + return (f_1437(1, 2))*(g_1436(3, 4)) + return g1984 + return g1989()(10, 11, 12) + + +def g1997(): + """ + >>> g1997() + 176 + """ + def g1996(): + def g1991(x_1440, y_1439, z_1438): + f_1444 = False + def g1995(): + def g1994(r_1442, s_1441): + y_1439 = (z_1438)+(s_1441) + return y_1439 + return g1994 + g_1443 = g1995() + def g1993(): + def g1992(u_1446, v_1445): + v_1445 = u_1446 + return (x_1440)+(v_1445) + return g1992 + f_1444 = g1993() + return (f_1444(1, 2))*(g_1443(3, 4)) + return g1991 + return g1996()(10, 11, 12) + + +def g2002(): + """ + >>> g2002() + 5 + """ + def g2001(): + def g2000(x_1450): + return (x_1450)+(1) + return g2000 + f_1448 = g2001() + def g1999(): + def g1998(y_1449): + return f_1448(f_1448(y_1449)) + return g1998 + g_1447 = g1999() + return (f_1448(1))+(g_1447(1)) + + +def g2010(): + """ + >>> g2010() + 1521 + """ + y_1451 = 3 + def g2009(): + def g2007(x_1457): + def g2008(): + return x_1457 == 0 + if (g2008()): + return g_1453((x_1457)+(1)) + else: + return f_1454((x_1457)-(y_1451)) + return g2007 + f_1454 = g2009() + def g2006(): + def g2005(x_1456): + return h_1452((x_1456)*(x_1456)) + return g2005 + g_1453 = g2006() + def g2004(): + def g2003(x_1455): + return x_1455 + return g2003 + h_1452 = g2004() + return g_1453(39) + + +def g2017(): + """ + >>> g2017() + -1 + """ + def g2014(): + def g2013(x_1461): + return (x_1461)+(1) + return g2013 + f_1459 = g2014() + def g2012(): + def g2011(y_1460): + return f_1459(f_1459(y_1460)) + return g2011 + g_1458 = g2012() + def g2016(): + def g2015(x_1462): + return (x_1462)-(1) + return g2015 + f_1459 = g2016() + return (f_1459(1))+(g_1458(1)) + + +def g2032(): + """ + >>> g2032() + [52, [17, [35, [17, 35]]]] + """ + def g2031(): + def g2030(): + return (a_1465)+(b_1464) + return g2030 + f_1466 = g2031() + a_1465 = 17 + b_1464 = 35 + def g2029(): + def g2028(): + def g2027(): + return a_1465 + return g2027 + def g2026(): + def g2025(): + return b_1464 + return g2025 + return [g2028(),g2026()] + h_1463 = g2029() + def g2024(): + def g2023(): + def g2022(): + def g2021(): + def g2020(): + return (h_1463[0]) + return g2020()() + def g2019(): + def g2018(): + return (h_1463[1]) + return g2018()() + return [g2021(),g2019()] + return [b_1464,g2022()] + return [a_1465,g2023()] + return [f_1466(),g2024()] + + +def g2038(): + """ + >>> g2038() + 120 + """ + x_1469 = 5 + def g2037(): + a_1467 = 1 + def g2036(): + return a_1467 + return g2036 + th_1468 = g2037() + def g2035(): + def g2033(n_1472, th_1471): + def g2034(): + return n_1472 == 0 + if (g2034()): + return th_1471() + else: + return (n_1472)*(fact_1470((n_1472)-(1), th_1471)) + return g2033 + fact_1470 = g2035() + return fact_1470(x_1469, th_1468) + + +def g2046(): + """ + >>> g2046() + [120, -120] + """ + def g2045(): + def g2044(n_1473): + return (n_1473 < 0) + return g2044 + negative_1474 = g2045() + def g2043(): + def g2041(n_1478): + def g2042(): + return n_1478 == 0 + if (g2042()): + return 1 + else: + return (n_1478)*(fact_1476((n_1478)-(1))) + return g2041 + fact_1476 = g2043() + def g2040(): + def g2039(n_1477): + if ((not negative_1474(n_1477))): + return fact_1476(n_1477) + else: + return (0)-(fact_1476((0)-(n_1477))) + return g2039 + call_fact_1475 = g2040() + return [call_fact_1475(5),call_fact_1475(-5)] + + +def g2050(): + """ + >>> g2050() + [0, 1, 2, 3] + """ + def g2049(): + def g2048(v_1482, i_1481, n_1480): + if ((not (i_1481 == n_1480))): + v_1482[i_1481] = i_1481 + return iota_fill_1479(v_1482, (i_1481)+(1), n_1480) + return g2048 + iota_fill_1479 = g2049() + n_1483 = 4 + def g2047(): + return ([0]*n_1483) + v_1484 = g2047() + iota_fill_1479(v_1484, 0, n_1483) + return v_1484 + + +def g2061(): + """ + >>> g2061() + [[33, 55], [77, 99]] + """ + def g2060(): + def g2059(): + def g2058(): + def g2057(): + def g2051(a_1485): + def g2052(b_1486): + def g2053(c_1487): + def g2054(d_1488): + def g2056(): + return [a_1485,b_1486] + def g2055(): + return [c_1487,d_1488] + return [g2056(),g2055()] + return g2054 + return g2053 + return g2052 + return g2051 + return g2057()(33) + return g2058()(55) + return g2059()(77) + return g2060()(99) + + +def g2075(): + """ + >>> g2075() + [[[3, [21, [18, []]]], [4, [28, [24, []]]]], [[[0, [0, [0, []]]], [1, [7, [6, []]]]], [[408, 408], []]]] + """ + a_1489 = 17 + def g2074(): + def g2064(x_1490): + x1_1492 = (x_1490)+(1) + x2_1491 = (x_1490)+(2) + y1_1494 = (x1_1492)*(7) + y2_1493 = (x2_1491)*(7) + z1_1496 = (y1_1494)-(x1_1492) + z2_1495 = (y2_1493)-(x2_1491) + w1_1498 = (z1_1496)*(a_1489) + w2_1497 = (z2_1495)*(a_1489) + def g2073(): + def g2068(b_1500): + if ((b_1500 == a_1489)): + def g2072(): + def g2071(): + return [z1_1496,[]] + return [y1_1494,g2071()] + return [x1_1492,g2072()] + else: + def g2070(): + def g2069(): + return [z2_1495,[]] + return [y2_1493,g2069()] + return [x2_1491,g2070()] + return g2068 + g_1502 = g2073() + def g2067(): + def g2066(c_1499): + if ((c_1499 == x_1490)): + return w1_1498 + else: + return w2_1497 + return g2066 + h_1501 = g2067() + def g2065(): + if (((x_1490)*(x_1490) == (x_1490)+(x_1490))): + return True + else: + return (x_1490 < 0) + if (g2065()): + return [g_1502(17),g_1502(16)] + else: + return [h_1501(x_1490),h_1501((x_1490)-(0))] + return g2064 + f_1503 = g2074() + def g2063(): + def g2062(): + return [f_1503(3),[]] + return [f_1503(-1),g2062()] + return [f_1503(2),g2063()] + diff --git a/tests/run/lambda_tests.pyx b/tests/run/lambda_tests.pyx new file mode 100644 index 00000000..e5abff35 --- /dev/null +++ b/tests/run/lambda_tests.pyx @@ -0,0 +1,577 @@ +# +# lambda_tests.pyx +# +# Battery of tests for closures in Cython. Based on the collection of +# compiler tests from P423/B629 at Indiana University, Spring 1999 and +# Fall 2000. Special thanks to R. Kent Dybvig, Dan Friedman, Kevin +# Millikin, and everyone else who helped to generate the original +# tests. Converted into a collection of Python/Cython tests by Craig +# Citro. +# +# Note: This set of tests is split (somewhat randomly) into several +# files, simply because putting all the tests in a single file causes +# gcc and g++ to buckle under the load. +# + + +def g0(): + """ + >>> g0() + 4000 + """ + return (lambda y_1: y_1)(4000) + + +def g1(): + """ + >>> g1() + 1 + """ + f_3 = (lambda x_2: x_2) + return (f_3(0)+1) + + +def g2(): + """ + >>> g2() + 4 + """ + f_5 = (lambda y_4: y_4) + return f_5(f_5(4)) + + +def g3(): + """ + >>> g3() + 4 + """ + return (lambda f_7: f_7(f_7(4)))((lambda y_6: y_6)) + + +def g5(): + """ + >>> g5() + 9000 + """ + def g4(): + a_8 = 4000 + return lambda b_9: ((a_8)+(b_9)) + return g4()(5000) + + +def g6(): + """ + >>> g6() + 9000 + """ + return (lambda a_10: (lambda b_11: (a_10)+(b_11)))(4000)(5000) + + +def g7(): + """ + >>> g7() + 2 + """ + return (lambda f_13: f_13(f_13(0)))((lambda x_12: (x_12+1))) + + +def g8(): + """ + >>> g8() + 0 + """ + f_16 = (lambda x_15, y_14: x_15) + a_17 = f_16(0, 1) + return f_16(a_17, a_17) + + +def g10(): + """ + >>> g10() + 3 + """ + f_19 = (lambda x_18: x_18) + def g9(): + a_22 = 0 + b_21 = 1 + c_20 = 2 + return (f_19(a_22))+((f_19(b_21))+(f_19(c_20))) + return (f_19(0))+(g9()) + + +def g12(): + """ + >>> g12() + 2 + """ + def g11(): + x_23 = 1 + return lambda y_24: ((x_23)+(y_24)) + f_25 = g11() + x_26 = 0 + return f_25(f_25(x_26)) + + +def g14(): + """ + >>> g14() + 3050 + """ + def g13(): + t_29 = (lambda x_28: (x_28)+(50)) + return lambda f_30: (t_29(f_30(1000))) + return g13()((lambda y_27: (y_27)+(2000))) + + +def g15(): + """ + >>> g15() + 3050 + """ + return (lambda t_33: (lambda f_34: t_33(f_34(1000))))((lambda x_32: (x_32)+(50)))((lambda y_31: (y_31)+(2000))) + + +def g17(): + """ + >>> g17() + 2050 + """ + def g16(): + t_35 = 50 + return lambda f_36: ((t_35)+(f_36())) + return g16()((lambda : 2000)) + + +def g18(): + """ + >>> g18() + 2050 + """ + return (lambda t_37: (lambda f_38: (t_37)+(f_38())))(50)((lambda : 2000)) + + +def g20(): + """ + >>> g20() + 700 + """ + def g19(): + x_39 = 300 + return lambda y_40: ((x_39)+(y_40)) + return g19()(400) + + +def g21(): + """ + >>> g21() + 0 + """ + x_44 = 3 + f_43 = (lambda x_42, y_41: x_42) + if (f_43(0, 0)): + return f_43(f_43(0, 0), x_44) + else: + return 0 + + +def g22(): + """ + >>> g22() + False + """ + f_46 = (lambda x_45: (x_45) if (((not ((x_45[0]) == 0))) if (isinstance(x_45, list)) else (False)) else (False)) + return f_46([0,[0,[]]]) + + +def g23(): + """ + >>> g23() + False + """ + f_48 = (lambda x_47: (x_47) if (((not ((not ((x_47[0]) == 0))) if (isinstance(x_47, list)) else (False))) if (x_47) else (False)) else (False)) + return f_48(0) + + +def g24(): + """ + >>> g24() + [] + """ + f_50 = (lambda x_49: (x_49) if ((True) if (isinstance(x_49, list)) else ((x_49 == []))) else ([])) + return f_50(0) + + +def g25(): + """ + >>> g25() + 0 + """ + y_51 = 4 + f_54 = (lambda x_53, y_52: 0) + return f_54(f_54(y_51, y_51), f_54(y_51, y_51)) + + +def g26(): + """ + >>> g26() + 0 + """ + y_55 = 4 + f_58 = (lambda x_57, y_56: 0) + return f_58(f_58(y_55, f_58(y_55, y_55)), f_58(y_55, f_58(y_55, y_55))) + + +def g27(): + """ + >>> g27() + 4 + """ + return (lambda y_59: (lambda f_61: f_61(f_61(y_59)))((lambda y_60: y_60)))(4) + + +def g28(): + """ + >>> g28() + 23 + """ + f_63 = (lambda x_62: x_62) + return ((1) if (False) else (f_63(22))+1) + + +def g29(): + """ + >>> g29() + 5061 + """ + f_68 = (lambda x_65: ((not x_65)) if (x_65) else (x_65)) + f2_67 = (lambda x_64: (10)*(x_64)) + x_66 = 23 + return ((1) if (f_68(x_66 == 0)) else ((x_66)*(f2_67((x_66-1))))+1) + + +def g30(): + """ + >>> g30() + 1 + """ + one_69 = (lambda n_70: (1) if (n_70 == 0) else (one_69((n_70-1)))) + return one_69(13) + + +def g31(): + """ + >>> g31() + True + """ + even_72 = (lambda x_74: (True) if (x_74 == 0) else (odd_71((x_74-1)))) + odd_71 = (lambda x_73: (False) if (x_73 == 0) else (even_72((x_73-1)))) + return odd_71(13) + + +def g32(): + """ + >>> g32() + False + """ + even_76 = (lambda x_78: (True) if (x_78 == 0) else (odd_75((x_78-1)))) + odd_75 = (lambda x_77: (False) if (x_77 == 0) else (even_76((x_77-1)))) + return even_76(13) + + +def g34(): + """ + >>> g34() + True + """ + even_80 = (lambda x_79: x_79) + def g33(): + even_82 = (lambda x_84: (True) if (x_84 == 0) else (odd_81((x_84-1)))) + odd_81 = (lambda x_83: (False) if (x_83 == 0) else (even_82((x_83-1)))) + return odd_81(13) + return even_80(g33()) + + +def g35(): + """ + >>> g35() + 120 + """ + fact_85 = (lambda n_86: (1) if (n_86 == 0) else ((n_86)*(fact_85((n_86-1))))) + return fact_85(5) + + +def g38(): + """ + >>> g38() + 10 + """ + x_87 = 5 + a_90 = (lambda u_101, v_100, w_99: (b_89(v_100, w_99)) if (u_101 == 0) else (a_90((u_101)-(1), v_100, w_99))) + def g37(): + def g36(q_93, r_92): + p_94 = (q_93)*(r_92) + e_96 = (lambda n_98: (c_88(p_94)) if (n_98 == 0) else (o_95((n_98)-(1)))) + o_95 = (lambda n_97: (c_88(x_87)) if (n_97 == 0) else (e_96((n_97)-(1)))) + return e_96((q_93)*(r_92)) + return g36 + b_89 = g37() + c_88 = (lambda x_91: (5)*(x_91)) + return a_90(3, 2, 1) + + +def g39(): + """ + >>> g39() + 120 + """ + fact_104 = (lambda fact_103, n_102: (1) if (n_102 == 0) else ((fact_103(fact_103, (n_102-1)))*(n_102))) + return fact_104(fact_104, 5) + + +def g40(): + """ + >>> g40() + 35 + """ + return (lambda x_105: (lambda y_106: (lambda z_107: (lambda w_108: (lambda u_109: (x_105)+((y_106)+((z_107)+((w_108)+(u_109)))))))))(5)(6)(7)(8)(9) + + +def g41(): + """ + >>> g41() + 6 + """ + sum_112 = (lambda sum_111, ls_110: (0) if ((ls_110 == [])) else (((ls_110[0]))+(sum_111(sum_111, (ls_110[1]))))) + return sum_112(sum_112, [1,[2,[3,[]]]]) + + +def g46(): + """ + >>> g46() + 1500 + """ + def g45(): + def g44(): + def g42(a_113): + def g43(): + (a_113)+(200 if True else None) + return 1500 + return g43 + return g42 + return g44()(1000) + return g45()() + + +def g53(): + """ + >>> g53() + 2600 + """ + def g52(): + def g51(): + def g50(): + def g47(a_114): + def g48(b_115): + a_114 = 200 if b_115 else None + def g49(c_116): + c_116 = 400 if 300 else None + return (a_114)+((b_115)+(c_116)) + return g49 + return g48 + return g47 + return g50()(1000) + return g51()(2000) + return g52()(3000) + + +def g54(): + """ + >>> g54() + 5 + """ + return (lambda f_118: f_118(f_118(5)))((lambda x_117: x_117)) + + +def g56(): + """ + >>> g56() + 8000 + """ + def g55(): + f_120 = (lambda x_119: (x_119)+(3000)) + return lambda y_121: (f_120(f_120(y_121))) + return g55()(2000) + + +def g57(): + """ + >>> g57() + 120 + """ + fact_125 = (lambda fact_124, n_123, acc_122: (acc_122) if (n_123 == 0) else (fact_124(fact_124, (n_123-1), (n_123)*(acc_122)))) + return fact_125(fact_125, 5, 1) + + +def g58(): + """ + >>> g58() + 3 + """ + f_127 = (lambda x_126: (lambda : x_126())) + return f_127((lambda : 3))() + + +def g59(): + """ + >>> g59() + 22 + """ + f_129 = (lambda x_132: (x_132)+((lambda y_133: (lambda z_134: (y_133)+(z_134)))(6)(7))) + g_128 = (5)+((lambda w_131, u_130: (w_131)+(u_130))(8, 9)) + return g_128 + + +def g60(): + """ + >>> g60() + 0 + """ + loop_135 = (lambda : (lambda : loop_135())) + loop_135() + return 0 + + +def g63(): + """ + >>> g63() + 668 + """ + def g62(): + def g61(): + loop_137 = (lambda link_138: (lambda : link_138())) + return loop_137((lambda : 668)) + return g61 + f_136 = g62() + return f_136()() + + +def g64(): + """ + >>> g64() + 17 + """ + k_141 = (lambda x_140, y_139: x_140) + b_142 = 17 + return k_141(k_141(k_141, 37), 37)(b_142, (b_142)*(b_142)) + + +def g65(): + """ + >>> g65() + 37 + """ + f_145 = (lambda g_144, u_143: g_144((g_144(37)) if (u_143) else (u_143))) + return f_145((lambda x_146: x_146), 75) + + +def g66(): + """ + >>> g66() + 4687 + """ + f_150 = (lambda h_148, u_147: h_148((h_148((u_147)+(37))) if (u_147) else (u_147))) + w_149 = 62 + return f_150((lambda x_151: (w_149)-(x_151)), (75)*(w_149)) + + +def g67(): + """ + >>> g67() + True + """ + t_153 = True + f_152 = False + bools_156 = [t_153,f_152] + id_155 = (lambda x_154: (f_152) if ((not x_154)) else (t_153)) + even_158 = (lambda x_160: ((bools_156[0])) if (id_155(x_160 == 0)) else (odd_157((x_160)-(1)))) + odd_157 = (lambda y_159: (id_155((bools_156[1]))) if (y_159 == 0) else (even_158((y_159)-(1)))) + return odd_157(5) + + +def g68(): + """ + >>> g68() + 5 + """ + f_162 = (lambda x_164: (x_164)+(1)) + g_161 = (lambda y_163: f_162(f_162(y_163))) + return (f_162(1))+(g_161(1)) + + +def g69(): + """ + >>> g69() + 1521 + """ + y_165 = 3 + f_168 = (lambda x_171: (g_167((x_171)+(1))) if (x_171 == 0) else (f_168((x_171)-(y_165)))) + g_167 = (lambda x_170: h_166((x_170)*(x_170))) + h_166 = (lambda x_169: x_169) + return g_167(39) + + +def g70(): + """ + >>> g70() + -1 + """ + f_173 = (lambda x_175: (x_175)+(1)) + g_172 = (lambda y_174: f_173(f_173(y_174))) + f_173 = (lambda x_176: (x_176)-(1)) + return (f_173(1))+(g_172(1)) + + +def g71(): + """ + >>> g71() + [52, [17, [35, [17, 35]]]] + """ + f_180 = (lambda : (a_179)+(b_178)) + a_179 = 17 + b_178 = 35 + h_177 = [(lambda : a_179),(lambda : b_178)] + return [f_180(),[a_179,[b_178,[(h_177[0])(),(h_177[1])()]]]] + + +def g73(): + """ + >>> g73() + 120 + """ + x_183 = 5 + def g72(): + a_181 = 1 + return lambda : (a_181) + th_182 = g72() + fact_184 = (lambda n_186, th_185: (th_185()) if (n_186 == 0) else ((n_186)*(fact_184((n_186)-(1), th_185)))) + return fact_184(x_183, th_182) + + +def g74(): + """ + >>> g74() + [120, -120] + """ + negative_188 = (lambda n_187: (n_187 < 0)) + fact_190 = (lambda n_192: (1) if (n_192 == 0) else ((n_192)*(fact_190((n_192)-(1))))) + call_fact_189 = (lambda n_191: (fact_190(n_191)) if ((not negative_188(n_191))) else ((0)-(fact_190((0)-(n_191))))) + return [call_fact_189(5),call_fact_189(-5)] + + +def g75(): + """ + >>> g75() + [[33, 55], [77, 99]] + """ + return (lambda a_193: (lambda b_194: (lambda c_195: (lambda d_196: [[a_193,b_194],[c_195,d_196]]))))(33)(55)(77)(99) + -- 2.26.2