diff --git a/Lib/test/randv2_32.pck b/Lib/test/randv2_32.pck
new file mode 100644
index 000000000..587ab2410
--- /dev/null
+++ b/Lib/test/randv2_32.pck
@@ -0,0 +1,633 @@
+crandom
+Random
+p0
+(tRp1
+(I2
+(I-2147483648
+I-845974985
+I-1294090086
+I1193659239
+I-1849481736
+I-946579732
+I-34406770
+I1749049471
+I1997774682
+I1432026457
+I1288127073
+I-943175655
+I-1718073964
+I339993548
+I-1045260575
+I582505037
+I-1555108250
+I-1114765620
+I1578648750
+I-350384412
+I-20845848
+I-288255314
+I738790953
+I1901249641
+I1999324672
+I-277361068
+I-1515885839
+I2061761596
+I-809068089
+I1287981136
+I258129492
+I-6303745
+I-765148337
+I1090344911
+I1653434703
+I-1242923628
+I1639171313
+I-1870042660
+I-1655014050
+I345609048
+I2093410138
+I1963263374
+I-2122098342
+I1336859961
+I-810942729
+I945857753
+I2103049942
+I623922684
+I1418349549
+I690877342
+I754973107
+I-1605111847
+I1607137813
+I-1704917131
+I1317536428
+I1714882872
+I-1665385120
+I1823694397
+I-1790836866
+I-1696724812
+I-603979847
+I-498599394
+I-341265291
+I927388804
+I1778562135
+I1716895781
+I1023198122
+I1726145967
+I941955525
+I1240148950
+I-1929634545
+I-1288147083
+I-519318335
+I754559777
+I-707571958
+I374604022
+I420424061
+I-1095443486
+I1621934944
+I-1220502522
+I-140049608
+I-918917122
+I304341024
+I-1637446057
+I-353934485
+I1973436235
+I433380241
+I-686759465
+I-2111563154
+I-573422032
+I804304541
+I1513063483
+I1417381689
+I-804778729
+I211756408
+I544537322
+I890881641
+I150378374
+I1765739392
+I1011604116
+I584889095
+I1400520554
+I413747808
+I-1741992587
+I-1882421574
+I-1373001903
+I-1885348538
+I903819480
+I1083220038
+I-1318105424
+I1740421404
+I1693089625
+I775965557
+I1319608037
+I-2127475785
+I-367562895
+I-1416273451
+I1693000327
+I-1217438421
+I834405522
+I-128287275
+I864057548
+I-973917356
+I7304111
+I1712253182
+I1353897741
+I672982288
+I1778575559
+I-403058377
+I-38540378
+I-1393713496
+I13193171
+I1127196200
+I205176472
+I-2104790506
+I299985416
+I1403541685
+I-1018270667
+I-1980677490
+I-1182625797
+I1637015181
+I-1795357414
+I1514413405
+I-924516237
+I-1841873650
+I-1014591269
+I1576616065
+I-1319103135
+I-120847840
+I2062259778
+I-9285070
+I1160890300
+I-575137313
+I-1509108275
+I46701926
+I-287560914
+I-256824960
+I577558250
+I900598310
+I944607867
+I2121154920
+I-1170505192
+I-1347170575
+I77247778
+I-1899015765
+I1234103327
+I1027053658
+I1934632322
+I-792031234
+I1147322536
+I1290655117
+I1002059715
+I1325898538
+I896029793
+I-790940694
+I-980470721
+I-1922648255
+I-951672814
+I291543943
+I1158740218
+I-1959023736
+I-1977185236
+I1527900076
+I514104195
+I-814154113
+I-593157883
+I-1023704660
+I1285688377
+I-2117525386
+I768954360
+I-38676846
+I-799848659
+I-1305517259
+I-1938213641
+I-462146758
+I-1663302892
+I1899591069
+I-22935388
+I-275856976
+I-443736893
+I-739441156
+I93862068
+I-838105669
+I1735629845
+I-817484206
+I280814555
+I1753547179
+I1811123479
+I1974543632
+I-48447465
+I-642694345
+I-531149613
+I518698953
+I-221642627
+I-686519187
+I776644303
+I257774400
+I-1499134857
+I-1055273455
+I-237023943
+I1981752330
+I-917671662
+I-372905983
+I1588058420
+I1171936660
+I-1730977121
+I1360028989
+I1769469287
+I1910709542
+I-852692959
+I1396944667
+I-1723999155
+I-310975435
+I-1965453954
+I-1636858570
+I2005650794
+I680293715
+I1355629386
+I844514684
+I-1909152807
+I-808646074
+I1936510018
+I1134413810
+I-143411047
+I-1478436304
+I1394969244
+I-1170110660
+I1963112086
+I-1518351049
+I-1506287443
+I-455023090
+I-855366028
+I-1746785568
+I933990882
+I-703625141
+I-285036872
+I188277905
+I1471578620
+I-981382835
+I-586974220
+I945619758
+I1608778444
+I-1708548066
+I-1897629320
+I-42617810
+I-836840790
+I539154487
+I-235706962
+I332074418
+I-575700589
+I1534608003
+I632116560
+I-1819760653
+I642052958
+I-722391771
+I-1104719475
+I-1196847084
+I582413973
+I1563394876
+I642007944
+I108989456
+I361625014
+I677308625
+I-1806529496
+I-959050708
+I-1858251070
+I-216069832
+I701624579
+I501238033
+I12287030
+I1895107107
+I2089098638
+I-874806230
+I1236279203
+I563718890
+I-544352489
+I-1879707498
+I1767583393
+I-1776604656
+I-693294301
+I-88882831
+I169303357
+I1299196152
+I-1122791089
+I-379157172
+I1934671851
+I1575736961
+I-19573174
+I-1401511009
+I9305167
+I-1115174467
+I1670735537
+I1226436501
+I-2004524535
+I1767463878
+I-1722855079
+I-559413926
+I1529810851
+I1201272087
+I-1297130971
+I-1188149982
+I1396557188
+I-370358342
+I-1006619702
+I1600942463
+I906087130
+I-76991909
+I2069580179
+I-1674195181
+I-2098404729
+I-940972459
+I-573399187
+I-1930386277
+I-721311199
+I-647834744
+I1452181671
+I688681916
+I1812793731
+I1704380620
+I-1389615179
+I866287837
+I-1435265007
+I388400782
+I-147986600
+I-1613598851
+I-1040347408
+I782063323
+I-239282031
+I-575966722
+I-1865208174
+I-481365146
+I579572803
+I-1239481494
+I335361280
+I-429722947
+I1881772789
+I1908103808
+I1653690013
+I-1668588344
+I1933787953
+I-2033480609
+I22162797
+I-1516527040
+I-461232482
+I-16201372
+I-2043092030
+I114990337
+I-1524090084
+I1456374020
+I458606440
+I-1928083218
+I227773125
+I-1129028159
+I1678689
+I1575896907
+I-1792935220
+I-151387575
+I64084088
+I-95737215
+I1337335688
+I-1963466345
+I1243315130
+I-1798518411
+I-546013212
+I-607065396
+I1219824160
+I1715218469
+I-1368163783
+I1701552913
+I-381114888
+I1068821717
+I266062971
+I-2066513172
+I1767407229
+I-780936414
+I-705413443
+I-1256268847
+I1646874149
+I1107690353
+I839133072
+I67001749
+I860763503
+I884880613
+I91977084
+I755371933
+I420745153
+I-578480690
+I-1520193551
+I1011369331
+I-99754575
+I-733141064
+I-500598588
+I1081124271
+I-1341266575
+I921002612
+I-848852487
+I-1904467341
+I-1294256973
+I-94074714
+I-1778758498
+I-1401188547
+I2101830578
+I2058864877
+I-272875991
+I-1375854779
+I-1332937870
+I619425525
+I-1034529639
+I-36454393
+I-2030499985
+I-1637127500
+I-1408110287
+I-2108625749
+I-961007436
+I1475654951
+I-791946251
+I1667792115
+I1818978830
+I1897980514
+I1959546477
+I-74478911
+I-508643347
+I461594399
+I538802715
+I-2094970071
+I-2076660253
+I1091358944
+I1944029246
+I-343957436
+I-1915845022
+I1237620188
+I1144125174
+I1522190520
+I-670252952
+I-19469226
+I675626510
+I758750096
+I909724354
+I-1846259652
+I544669343
+I445182495
+I-821519930
+I-1124279685
+I-1668995122
+I1653284793
+I-678555151
+I-687513207
+I1558259445
+I-1978866839
+I1558835601
+I1732138472
+I-1904793363
+I620020296
+I1562597874
+I1942617227
+I-549632552
+I721603795
+I417978456
+I-1355281522
+I-538065208
+I-1079523196
+I187375699
+I449064972
+I1018083947
+I1632388882
+I-493269866
+I92769041
+I1477146750
+I1782708404
+I444873376
+I1085851104
+I-6823272
+I-1302251853
+I1602050688
+I-1042187824
+I287161745
+I-1972094479
+I103271491
+I2131619773
+I-2064115870
+I766815498
+I990861458
+I-1664407378
+I1083746756
+I-1018331904
+I-677315687
+I-951670647
+I-952356874
+I451460609
+I-818615564
+I851439508
+I656362634
+I-1351240485
+I823378078
+I1985597385
+I597757740
+I-1512303057
+I1590872798
+I1108424213
+I818850898
+I-1368594306
+I-201107761
+I1793370378
+I1247597611
+I-1594326264
+I-601653890
+I427642759
+I248322113
+I-292545338
+I1708985870
+I1917042771
+I429354503
+I-478470329
+I793960014
+I369939133
+I1728189157
+I-518963626
+I-278523974
+I-1877289696
+I-2088617658
+I-1367940049
+I-62295925
+I197975119
+I-252900777
+I803430539
+I485759441
+I-528283480
+I-1287443963
+I-478617444
+I-861906946
+I-649095555
+I-893184337
+I2050571322
+I803433133
+I1629574571
+I1649720417
+I-2050225209
+I1208598977
+I720314344
+I-615166251
+I-835077127
+I-1405372429
+I995698064
+I148123240
+I-943016676
+I-594609622
+I-1381596711
+I1017195301
+I-1268893013
+I-1815985179
+I-1393570351
+I-870027364
+I-476064472
+I185582645
+I569863326
+I1098584267
+I-1599147006
+I-485054391
+I-852098365
+I1477320135
+I222316762
+I-1515583064
+I-935051367
+I393383063
+I819617226
+I722921837
+I-1241806499
+I-1358566385
+I1666813591
+I1333875114
+I-1663688317
+I-47254623
+I-885800726
+I307388991
+I-1219459496
+I1374870300
+I2132047877
+I-1385624198
+I-245139206
+I1015139214
+I-926198559
+I1969798868
+I-1950480619
+I-559193432
+I-1256446518
+I-1983476981
+I790179655
+I1004289659
+I1541827617
+I1555805575
+I501127333
+I-1123446797
+I-453230915
+I2035104883
+I1296122398
+I-1843698604
+I-715464588
+I337143971
+I-1972119192
+I606777909
+I726977302
+I-1149501872
+I-1963733522
+I-1797504644
+I624
+tp2
+Ntp3
+b.
\ No newline at end of file
diff --git a/Lib/test/randv2_64.pck b/Lib/test/randv2_64.pck
new file mode 100644
index 000000000..090dd6fd1
--- /dev/null
+++ b/Lib/test/randv2_64.pck
@@ -0,0 +1,633 @@
+crandom
+Random
+p0
+(tRp1
+(I2
+(I2147483648
+I1812115682
+I2741755497
+I1028055730
+I809166036
+I2773628650
+I62321950
+I535290043
+I349877800
+I976167039
+I2490696940
+I3631326955
+I2107991114
+I2941205793
+I3199611605
+I1871971556
+I1456108540
+I2984591044
+I140836801
+I4203227310
+I3652722980
+I4031971234
+I555769760
+I697301296
+I2347638880
+I3302335858
+I320255162
+I2553586608
+I1570224361
+I2838780912
+I2315834918
+I2351348158
+I3545433015
+I2292018579
+I1177569331
+I758497559
+I2913311175
+I1014948880
+I1793619243
+I3982451053
+I3850988342
+I2393984324
+I1583100093
+I3144742543
+I3655047493
+I3507532385
+I3094515442
+I350042434
+I2455294844
+I1038739312
+I313809152
+I189433072
+I1653165452
+I4186650593
+I19281455
+I2589680619
+I4145931590
+I4283266118
+I636283172
+I943618337
+I3170184633
+I2308766231
+I634615159
+I538152647
+I2079576891
+I1029442616
+I3410689412
+I1370292761
+I1071718978
+I2139496322
+I1876699543
+I3485866187
+I3157490130
+I1633105386
+I1453253160
+I3841322080
+I3789608924
+I4110770792
+I95083673
+I931354627
+I2065389591
+I3448339827
+I3348204577
+I3263528560
+I2411324590
+I4003055026
+I1869670093
+I2737231843
+I4150701155
+I2689667621
+I2993263224
+I3239890140
+I1191430483
+I1214399779
+I3623428533
+I1817058866
+I3052274451
+I326030082
+I1505129312
+I2306812262
+I1349150363
+I1099127895
+I2543465574
+I2396380193
+I503926466
+I1607109730
+I3451716817
+I58037114
+I4290081119
+I947517597
+I3083440186
+I520522630
+I2948962496
+I4184319574
+I2957636335
+I668374201
+I2325446473
+I472785314
+I3791932366
+I573017189
+I2185725379
+I1262251492
+I3525089379
+I2951262653
+I1305347305
+I940958122
+I3343754566
+I359371744
+I3874044973
+I396897232
+I147188248
+I716683703
+I4013880315
+I1133359586
+I1794612249
+I3480815192
+I3988787804
+I1729355809
+I573408542
+I1419310934
+I1770030447
+I3552845567
+I1693976502
+I1271189893
+I2298236738
+I2049219027
+I3464198070
+I1233574082
+I1007451781
+I1838253750
+I687096593
+I1131375603
+I1223013895
+I1490478435
+I339265439
+I4232792659
+I491538536
+I2816256769
+I1044097522
+I2566227049
+I748762793
+I1511830494
+I3593259822
+I4121279213
+I3735541309
+I3609794797
+I1939942331
+I377570434
+I1437957554
+I1831285696
+I55062811
+I2046783110
+I1303902283
+I1838349877
+I420993556
+I1256392560
+I2795216506
+I2783687924
+I3322303169
+I512794749
+I308405826
+I517164429
+I3320436022
+I1328403632
+I2269184746
+I3729522810
+I3304314450
+I2238756124
+I1690581361
+I3813277532
+I4119706879
+I2659447875
+I388818978
+I2064580814
+I1586227676
+I2627522685
+I2017792269
+I547928109
+I859107450
+I1062238929
+I858886237
+I3795783146
+I4173914756
+I3835915965
+I3329504821
+I3494579904
+I838863205
+I3399734724
+I4247387481
+I3618414834
+I2984433798
+I2165205561
+I4260685684
+I3045904244
+I3450093836
+I3597307595
+I3215851166
+I3162801328
+I2558283799
+I950068105
+I1829664117
+I3108542987
+I2378860527
+I790023460
+I280087750
+I1171478018
+I2333653728
+I3976932140
+I896746152
+I1802494195
+I1232873794
+I2749440836
+I2032037296
+I2012091682
+I1296131034
+I3892133385
+I908161334
+I2296791795
+I548169794
+I696265
+I893156828
+I426904709
+I3565374535
+I2655906825
+I2792178515
+I2406814632
+I4038847579
+I3123934642
+I2197503004
+I3535032597
+I2266216689
+I2117613462
+I1787448518
+I1875089416
+I2037165384
+I1140676321
+I3606296464
+I3229138231
+I2458267132
+I1874651171
+I3331900867
+I1000557654
+I1432861701
+I473636323
+I2691783927
+I1871437447
+I1328016401
+I4118690062
+I449467602
+I681789035
+I864889442
+I1200888928
+I75769445
+I4008690037
+I2464577667
+I4167795823
+I3070097648
+I2579174882
+I1216886568
+I3810116343
+I2249507485
+I3266903480
+I3671233480
+I100191658
+I3087121334
+I365063087
+I3821275176
+I2165052848
+I1282465245
+I3601570637
+I3132413236
+I2780570459
+I3222142917
+I3129794692
+I2611590811
+I947031677
+I2991908938
+I750997949
+I3632575131
+I1632014461
+I2846484755
+I2347261779
+I2903959448
+I1397316686
+I1904578392
+I774649578
+I3164598558
+I2429587609
+I738244516
+I1563304975
+I1399317414
+I1021316297
+I3187933234
+I2126780757
+I4011907847
+I4095169219
+I3358010054
+I2729978247
+I3736811646
+I3009656410
+I2893043637
+I4027447385
+I1239610110
+I1488806900
+I2674866844
+I442876374
+I2853687260
+I2785921005
+I3151378528
+I1180567
+I2803146964
+I982221759
+I2192919417
+I3087026181
+I2480838002
+I738452921
+I687986185
+I3049371676
+I3636492954
+I3468311299
+I2379621102
+I788988633
+I1643210601
+I2983998168
+I2492730801
+I2586048705
+I604073029
+I4121082815
+I1496476928
+I2972357110
+I2663116968
+I2642628592
+I2116052039
+I487186279
+I2577680328
+I3974766614
+I730776636
+I3842528855
+I1929093695
+I44626622
+I3989908833
+I1695426222
+I3675479382
+I3051784964
+I1514876613
+I1254036595
+I2420450649
+I3034377361
+I2332990590
+I1535175126
+I185834384
+I1107372900
+I1707278185
+I1286285295
+I3332574225
+I2785672437
+I883170645
+I2005666473
+I3403131327
+I4122021352
+I1464032858
+I3702576112
+I260554598
+I1837731650
+I2594435345
+I75771049
+I2012484289
+I3058649775
+I29979703
+I3861335335
+I2506495152
+I3786448704
+I442947790
+I2582724774
+I4291336243
+I2568189843
+I1923072690
+I1121589611
+I837696302
+I3284631720
+I3865021324
+I3576453165
+I2559531629
+I1459231762
+I3506550036
+I3754420159
+I2622000757
+I124228596
+I1084328605
+I1692830753
+I547273558
+I674282621
+I655259103
+I3188629610
+I490502174
+I2081001293
+I3191330704
+I4109943593
+I1859948504
+I3163806460
+I508833168
+I1256371033
+I2709253790
+I2068956572
+I3092842814
+I3913926529
+I2039638759
+I981982529
+I536094190
+I368855295
+I51993975
+I1597480732
+I4058175522
+I2155896702
+I3196251991
+I1081913893
+I3952353788
+I3545548108
+I2370669647
+I2206572308
+I2576392991
+I1732303374
+I1153136290
+I537641955
+I1738691747
+I3232854186
+I2539632206
+I2829760278
+I3058187853
+I1202425792
+I3762361970
+I2863949342
+I2640635867
+I376638744
+I1857679757
+I330798087
+I1457400505
+I1135610046
+I606400715
+I1859536026
+I509811335
+I529772308
+I2579273244
+I1890382004
+I3959908876
+I2612335971
+I2834052227
+I1434475986
+I3684202717
+I4015011345
+I582567852
+I3689969571
+I3934753460
+I3034960691
+I208573292
+I4004113742
+I3992904842
+I2587153719
+I3529179079
+I1565424987
+I779130678
+I1048582935
+I3213591622
+I3607793434
+I3951254937
+I2047811901
+I7508850
+I248544605
+I4210090324
+I2331490884
+I70057213
+I776474945
+I1345528889
+I3290403612
+I1664955269
+I1533143116
+I545003424
+I4141564478
+I1257326139
+I868843601
+I2337603029
+I1918131449
+I1843439523
+I1125519035
+I673340118
+I421408852
+I1520454906
+I1804722630
+I3621254196
+I2329968000
+I39464672
+I430583134
+I294026512
+I53978525
+I2892276105
+I1418863764
+I3419054451
+I1391595797
+I3544981798
+I4191780858
+I825672357
+I2972000844
+I1571305069
+I4231982845
+I3611916419
+I3045163168
+I2982349733
+I278572141
+I4215338078
+I839860504
+I1819151779
+I1412347479
+I1386770353
+I3914589491
+I3783104977
+I4124296733
+I830546258
+I89825624
+I4110601328
+I2545483429
+I300600527
+I516641158
+I3693021034
+I2852912854
+I3240039868
+I4167407959
+I1479557946
+I3621188804
+I1391590944
+I3578441128
+I1227055556
+I406898396
+I3064054983
+I25835338
+I402664165
+I4097682779
+I2106728012
+I203613622
+I3045467686
+I1381726438
+I3798670110
+I1342314961
+I3552497361
+I535913619
+I2625787583
+I1606574307
+I1101269630
+I1950513752
+I1121355862
+I3586816903
+I438529984
+I2473182121
+I1229997203
+I405445940
+I1695535315
+I427014336
+I3916768430
+I392298359
+I1884642868
+I1244730821
+I741058080
+I567479957
+I3527621168
+I3191971011
+I3267069104
+I4108668146
+I1520795587
+I166581006
+I473794477
+I1562126550
+I929843010
+I889533294
+I1266556608
+I874518650
+I3520162092
+I3013765049
+I4220231414
+I547246449
+I3998093769
+I3737193746
+I3872944207
+I793651876
+I2606384318
+I875991012
+I1394836334
+I4102011644
+I854380426
+I2618666767
+I2568302000
+I1995512132
+I229491093
+I2673500286
+I3364550739
+I3836923416
+I243656987
+I3944388983
+I4064949677
+I1416956378
+I1703244487
+I3990798829
+I2023425781
+I3926702214
+I1229015501
+I3174247824
+I624
+tp2
+Ntp3
+b.
\ No newline at end of file
diff --git a/Lib/test/randv3.pck b/Lib/test/randv3.pck
new file mode 100644
index 000000000..09fc38b1a
--- /dev/null
+++ b/Lib/test/randv3.pck
@@ -0,0 +1,633 @@
+crandom
+Random
+p0
+(tRp1
+(I3
+(L2147483648L
+L994081831L
+L2806287265L
+L2228999830L
+L3396498069L
+L2956805457L
+L3273927761L
+L920726507L
+L1862624492L
+L2921292485L
+L1779526843L
+L2469105503L
+L251696293L
+L1254390717L
+L779197080L
+L3165356830L
+L2007365218L
+L1870028812L
+L2896519363L
+L1855578438L
+L979518416L
+L3481710246L
+L3191861507L
+L3993006593L
+L2967971479L
+L3353342753L
+L3576782572L
+L339685558L
+L2367675732L
+L116208555L
+L1220054437L
+L486597056L
+L1912115141L
+L1037044792L
+L4096904723L
+L3409146175L
+L3701651227L
+L315824610L
+L4138604583L
+L1385764892L
+L191878900L
+L2320582219L
+L3420677494L
+L2776503169L
+L1148247403L
+L829555069L
+L902064012L
+L2934642741L
+L2477108577L
+L2583928217L
+L1658612579L
+L2865447913L
+L129147346L
+L3691171887L
+L1569328110L
+L1372860143L
+L1054139183L
+L1617707080L
+L69020592L
+L3810271603L
+L1853953416L
+L3499803073L
+L1027545027L
+L3229043605L
+L250848720L
+L3324932626L
+L3537002962L
+L2494323345L
+L3238103962L
+L4147541579L
+L3636348186L
+L3025455083L
+L2678771977L
+L584700256L
+L3461826909L
+L854511420L
+L943463552L
+L3609239025L
+L3977577989L
+L253070090L
+L777394544L
+L2144086567L
+L1092947992L
+L854327284L
+L2222750082L
+L360183510L
+L1312466483L
+L3227531091L
+L2235022500L
+L3013060530L
+L2541091298L
+L3480126342L
+L1839762775L
+L2632608190L
+L1108889403L
+L3045050923L
+L731513126L
+L3505436788L
+L3062762017L
+L1667392680L
+L1354126500L
+L1143573930L
+L2816645702L
+L2100356873L
+L2817679106L
+L1210746010L
+L2409915248L
+L2910119964L
+L2309001420L
+L220351824L
+L3667352871L
+L3993148590L
+L2886160232L
+L4239393701L
+L1189270581L
+L3067985541L
+L147374573L
+L2355164869L
+L3696013550L
+L4227037846L
+L1905112743L
+L3312843689L
+L2930678266L
+L1828795355L
+L76933594L
+L3987100796L
+L1288361435L
+L3464529151L
+L965498079L
+L1444623093L
+L1372893415L
+L1536235597L
+L1341994850L
+L963594758L
+L2115295754L
+L982098685L
+L1053433904L
+L2078469844L
+L3059765792L
+L1753606181L
+L2130171254L
+L567588194L
+L529629426L
+L3621523534L
+L3027576564L
+L1176438083L
+L4096287858L
+L1168574683L
+L1425058962L
+L1429631655L
+L2902106759L
+L761900641L
+L1329183956L
+L1947050932L
+L447490289L
+L3282516276L
+L200037389L
+L921868197L
+L3331403999L
+L4088760249L
+L2188326318L
+L288401961L
+L1360802675L
+L314302808L
+L3314639210L
+L3749821203L
+L2286081570L
+L2768939062L
+L3200541016L
+L2133495482L
+L385029880L
+L4217232202L
+L3171617231L
+L1660846653L
+L2459987621L
+L2691776124L
+L4225030408L
+L3595396773L
+L1103680661L
+L539064057L
+L1492841101L
+L166195394L
+L757973658L
+L533893054L
+L2784879594L
+L1021821883L
+L2350548162L
+L176852116L
+L3503166025L
+L148079914L
+L1633466236L
+L2773090165L
+L1162846701L
+L3575737795L
+L1624178239L
+L2454894710L
+L3014691938L
+L526355679L
+L1870824081L
+L3362425857L
+L3907566665L
+L3462563184L
+L2229112004L
+L4203735748L
+L1557442481L
+L924133999L
+L1906634214L
+L880459727L
+L4065895870L
+L141426254L
+L1258450159L
+L3243115027L
+L1574958840L
+L313939294L
+L3055664260L
+L3459714255L
+L531778790L
+L509505506L
+L1620227491L
+L2675554942L
+L2516509560L
+L3797299887L
+L237135890L
+L3203142213L
+L1087745310L
+L1897151854L
+L3936590041L
+L132765167L
+L2385908063L
+L1360600289L
+L3574567769L
+L2752788114L
+L2644228966L
+L2377705183L
+L601277909L
+L4046480498L
+L324401408L
+L3279931760L
+L2227059377L
+L1538827493L
+L4220532064L
+L478044564L
+L2917117761L
+L635492832L
+L2319763261L
+L795944206L
+L1820473234L
+L1673151409L
+L1404095402L
+L1661067505L
+L3217106938L
+L2406310683L
+L1931309248L
+L2458622868L
+L3323670524L
+L3266852755L
+L240083943L
+L3168387397L
+L607722198L
+L1256837690L
+L3608124913L
+L4244969357L
+L1289959293L
+L519750328L
+L3229482463L
+L1105196988L
+L1832684479L
+L3761037224L
+L2363631822L
+L3297957711L
+L572766355L
+L1195822137L
+L2239207981L
+L2034241203L
+L163540514L
+L288160255L
+L716403680L
+L4019439143L
+L1536281935L
+L2345100458L
+L2786059178L
+L2822232109L
+L987025395L
+L3061166559L
+L490422513L
+L2551030115L
+L2638707620L
+L1344728502L
+L714108911L
+L2831719700L
+L2188615369L
+L373509061L
+L1351077504L
+L3136217056L
+L783521095L
+L2554949468L
+L2662499550L
+L1203826951L
+L1379632388L
+L1918858985L
+L607465976L
+L1980450237L
+L3540079211L
+L3397813410L
+L2913309266L
+L2289572621L
+L4133935327L
+L4166227663L
+L3371801704L
+L3065474909L
+L3580562343L
+L3832172378L
+L2556130719L
+L310473705L
+L3734014346L
+L2490413810L
+L347233056L
+L526668037L
+L1158393656L
+L544329703L
+L2150085419L
+L3914038146L
+L1060237586L
+L4159394837L
+L113205121L
+L309966775L
+L4098784465L
+L3635222960L
+L2417516569L
+L2089579233L
+L1725807541L
+L2728122526L
+L2365836523L
+L2504078522L
+L1443946869L
+L2384171411L
+L997046534L
+L3249131657L
+L1699875986L
+L3618097146L
+L1716038224L
+L2629818607L
+L2929217876L
+L1367250314L
+L1726434951L
+L1388496325L
+L2107602181L
+L2822366842L
+L3052979190L
+L3796798633L
+L1543813381L
+L959000121L
+L1363845999L
+L2952528150L
+L874184932L
+L1888387194L
+L2328695295L
+L3442959855L
+L841805947L
+L1087739275L
+L3230005434L
+L3045399265L
+L1161817318L
+L2898673139L
+L860011094L
+L940539782L
+L1297818080L
+L4243941623L
+L1577613033L
+L4204131887L
+L3819057225L
+L1969439558L
+L3297963932L
+L241874069L
+L3517033453L
+L2295345664L
+L1098911422L
+L886955008L
+L1477397621L
+L4279347332L
+L3616558791L
+L2384411957L
+L742537731L
+L764221540L
+L2871698900L
+L3530636393L
+L691256644L
+L758730966L
+L1717773090L
+L2751856377L
+L3188484000L
+L3767469670L
+L1623863053L
+L3533236793L
+L4099284176L
+L723921107L
+L310594036L
+L223978745L
+L2266565776L
+L201843303L
+L2969968546L
+L3351170888L
+L3465113624L
+L2712246712L
+L1521383057L
+L2384461798L
+L216357551L
+L2167301975L
+L3144653194L
+L2781220155L
+L3620747666L
+L95971265L
+L4255400243L
+L59999757L
+L4174273472L
+L3974511524L
+L1007123950L
+L3112477628L
+L806461512L
+L3148074008L
+L528352882L
+L2545979588L
+L2562281969L
+L3010249477L
+L1886331611L
+L3210656433L
+L1034099976L
+L2906893579L
+L1197048779L
+L1870004401L
+L3898300490L
+L2686856402L
+L3975723478L
+L613043532L
+L2565674353L
+L3760045310L
+L3468984376L
+L4126258L
+L303855424L
+L3988963552L
+L276256796L
+L544071807L
+L1023872062L
+L1747461519L
+L1975571260L
+L4033766958L
+L2946555557L
+L1492957796L
+L958271685L
+L46480515L
+L907760635L
+L1306626357L
+L819652378L
+L1172300279L
+L1116851319L
+L495601075L
+L1157715330L
+L534220108L
+L377320028L
+L1672286106L
+L2066219284L
+L1842386355L
+L2546059464L
+L1839457336L
+L3476194446L
+L3050550028L
+L594705582L
+L1905813535L
+L1813033412L
+L2700858157L
+L169067972L
+L4252889045L
+L1921944555L
+L497671474L
+L210143935L
+L2688398489L
+L325158375L
+L3450846447L
+L891760597L
+L712802536L
+L1132557436L
+L1417044075L
+L1639889660L
+L1746379970L
+L1478741647L
+L2817563486L
+L2573612532L
+L4266444457L
+L2911601615L
+L804745411L
+L2207254652L
+L1189140646L
+L3829725111L
+L3637367348L
+L1944731747L
+L2193440343L
+L1430195413L
+L1173515229L
+L1582618217L
+L2070767037L
+L247908936L
+L1460675439L
+L556001596L
+L327629335L
+L1036133876L
+L4228129605L
+L999174048L
+L3635804039L
+L1416550481L
+L1270540269L
+L4280743815L
+L39607659L
+L1552540623L
+L2762294062L
+L504137289L
+L4117044239L
+L1417130225L
+L1342970056L
+L1755716449L
+L1169447322L
+L2731401356L
+L2319976745L
+L2869221479L
+L23972655L
+L2251495389L
+L1429860878L
+L3728135992L
+L4241432973L
+L3698275076L
+L216416432L
+L4040046960L
+L246077176L
+L894675685L
+L3932282259L
+L3097205100L
+L2128818650L
+L1319010656L
+L1601974009L
+L2552960957L
+L3554016055L
+L4209395641L
+L2013340102L
+L3370447801L
+L2307272002L
+L1795091354L
+L202109401L
+L988345070L
+L2514870758L
+L1132726850L
+L582746224L
+L3112305421L
+L1843020683L
+L3600189223L
+L1101349165L
+L4211905855L
+L2866677581L
+L2881621130L
+L4165324109L
+L4238773191L
+L3635649550L
+L2670481044L
+L2996248219L
+L1676992480L
+L3473067050L
+L4205793699L
+L4019490897L
+L1579990481L
+L1899617990L
+L1136347713L
+L1802842268L
+L3591752960L
+L1197308739L
+L433629786L
+L4032142790L
+L3148041979L
+L3312138845L
+L3896860449L
+L3298182567L
+L907605170L
+L1658664067L
+L2682980313L
+L2523523173L
+L1208722103L
+L3808530363L
+L1079003946L
+L4282402864L
+L2041010073L
+L2667555071L
+L688018180L
+L1405121012L
+L4167994076L
+L3504695336L
+L1923944749L
+L1143598790L
+L3936268898L
+L3606243846L
+L1017420080L
+L4026211169L
+L596529763L
+L1844259624L
+L2840216282L
+L2673807759L
+L3407202575L
+L2737971083L
+L4075423068L
+L3684057432L
+L3146627241L
+L599650513L
+L69773114L
+L1257035919L
+L807485291L
+L2376230687L
+L3036593147L
+L2642411658L
+L106080044L
+L2199622729L
+L291834511L
+L2697611361L
+L11689733L
+L625123952L
+L3226023062L
+L3229663265L
+L753059444L
+L2843610189L
+L624L
+tp2
+Ntp3
+b.
\ No newline at end of file
diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py
index 57feec603..cec6b83b6 100644
--- a/Lib/test/seq_tests.py
+++ b/Lib/test/seq_tests.py
@@ -416,7 +416,8 @@ class CommonTest(unittest.TestCase):
             self.assertEqual(lst2, lst)
             self.assertNotEqual(id(lst2), id(lst))
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'test.support' has no attribute 'check_free_after_iterating'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, self.type2test)
         support.check_free_after_iterating(self, reversed, self.type2test)
diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py
index 9615d3ae4..3c028a054 100644
--- a/Lib/test/test_array.py
+++ b/Lib/test/test_array.py
@@ -471,7 +471,6 @@ class BaseTest:
                 nb_warnings += 1
         self.assertEqual(len(r), nb_warnings)
 
-    @unittest.skip("TODO: RUSTPYTHON, OverflowError: Python int too large to convert to Rust i8")
     def test_tofrombytes(self):
         a = array.array(self.typecode, 2*self.example)
         b = array.array(self.typecode)
@@ -1131,7 +1130,6 @@ class StringTest(BaseTest):
         a = array.array(self.typecode, self.example)
         self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2])
 
-@unittest.skip("TODO: RUSTPYTHON, ValueError: bad typecode")
 class UnicodeTest(StringTest, unittest.TestCase):
     typecode = 'u'
     example = '\x01\u263a\x00\ufeff'
@@ -1140,6 +1138,173 @@ class UnicodeTest(StringTest, unittest.TestCase):
     outside = str('\x33')
     minitemsize = 2
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_add(self):
+        super().test_add()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_buffer(self):
+        super().test_buffer()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_buffer_info(self):
+        super().test_buffer_info()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_byteswap(self):
+        super().test_byteswap()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_cmp(self):
+        super().test_cmp()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_constructor(self):
+        super().test_constructor()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_constructor_with_iterable_argument(self):
+        super().test_constructor_with_iterable_argument()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_copy(self):
+        super().test_copy()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_count(self):
+        super().test_count()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_coveritertraverse(self):
+        super().test_coveritertraverse()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_deepcopy(self):
+        super().test_deepcopy()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_delitem(self):
+        super().test_delitem()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_exhausted_iterator(self):
+        super().test_exhausted_iterator()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_extend(self):
+        super().test_extend()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_extended_getslice(self):
+        super().test_extended_getslice()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_extended_set_del_slice(self):
+        super().test_extended_set_del_slice()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_fromarray(self):
+        super().test_fromarray()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_getitem(self):
+        super().test_getitem()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_getslice(self):
+        super().test_getslice()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_iadd(self):
+        super().test_iadd()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_imul(self):
+        super().test_imul()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_index(self):
+        super().test_index()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_insert(self):
+        super().test_insert()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_len(self):
+        super().test_len()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_mul(self):
+        super().test_mul()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_pop(self):
+        super().test_pop()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_remove(self):
+        super().test_remove()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_repr(self):
+        super().test_repr()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_reverse(self):
+        super().test_reverse()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_setslice(self):
+        super().test_setslice()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_str(self):
+        super().test_str()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofromlist(self):
+        super().test_tofromlist()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_unicode(self):
         self.assertRaises(TypeError, array.array, 'b', 'foo')
 
@@ -1160,6 +1325,8 @@ class UnicodeTest(StringTest, unittest.TestCase):
 
         self.assertRaises(TypeError, a.fromunicode)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_issue17223(self):
         # this used to crash
         if sizeof_wchar == 4:
@@ -1345,6 +1512,11 @@ class ByteTest(SignedNumberTest, unittest.TestCase):
     typecode = 'b'
     minitemsize = 1
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
 class UnsignedByteTest(UnsignedNumberTest, unittest.TestCase):
     typecode = 'B'
     minitemsize = 1
@@ -1353,34 +1525,74 @@ class ShortTest(SignedNumberTest, unittest.TestCase):
     typecode = 'h'
     minitemsize = 2
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
 class UnsignedShortTest(UnsignedNumberTest, unittest.TestCase):
     typecode = 'H'
     minitemsize = 2
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
 class IntTest(SignedNumberTest, unittest.TestCase):
     typecode = 'i'
     minitemsize = 2
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
 class UnsignedIntTest(UnsignedNumberTest, unittest.TestCase):
     typecode = 'I'
     minitemsize = 2
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
 class LongTest(SignedNumberTest, unittest.TestCase):
     typecode = 'l'
     minitemsize = 4
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
 class UnsignedLongTest(UnsignedNumberTest, unittest.TestCase):
     typecode = 'L'
     minitemsize = 4
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
 class LongLongTest(SignedNumberTest, unittest.TestCase):
     typecode = 'q'
     minitemsize = 8
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
 class UnsignedLongLongTest(UnsignedNumberTest, unittest.TestCase):
     typecode = 'Q'
     minitemsize = 8
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
 class FPTest(NumberTest):
     example = [-42.0, 0, 42, 1e5, -1e10]
     smallerexample = [-42.0, 0, 42, 1e5, -2e10]
@@ -1420,10 +1632,20 @@ class FloatTest(FPTest, unittest.TestCase):
     typecode = 'f'
     minitemsize = 4
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
 class DoubleTest(FPTest, unittest.TestCase):
     typecode = 'd'
     minitemsize = 8
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tofrombytes(self):
+        super().test_tofrombytes()
+
     @unittest.skip("TODO: RUSTPYTHON, thread 'main' panicked at 'capacity overflow'")
     def test_alloc_overflow(self):
         from sys import maxsize
diff --git a/Lib/test/test_importlib/extension/test_loader.py b/Lib/test/test_importlib/extension/test_loader.py
index d711ea99c..e2c2c71bf 100644
--- a/Lib/test/test_importlib/extension/test_loader.py
+++ b/Lib/test/test_importlib/extension/test_loader.py
@@ -22,7 +22,8 @@ class LoaderTests(abc.LoaderTests):
     def load_module(self, fullname):
         return self.loader.load_module(fullname)
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: 'NoneType' object has no attribute 'rpartition'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_load_module_API(self):
         # Test the default argument for load_module().
         self.loader.load_module()
@@ -59,7 +60,8 @@ class LoaderTests(abc.LoaderTests):
     # No extension module in a package available for testing.
     test_lacking_parent = None
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: 'NoneType' object has no attribute 'rpartition'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_module_reuse(self):
         with util.uncache(util.EXTENSIONS.name):
             module1 = self.load_module(util.EXTENSIONS.name)
@@ -75,7 +77,8 @@ class LoaderTests(abc.LoaderTests):
             self.load_module(name)
         self.assertEqual(cm.exception.name, name)
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: 'NoneType' object has no attribute 'rpartition'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_package(self):
         self.assertFalse(self.loader.is_package(util.EXTENSIONS.name))
         for suffix in self.machinery.EXTENSION_SUFFIXES:
diff --git a/Lib/test/test_importlib/frozen/test_loader.py b/Lib/test/test_importlib/frozen/test_loader.py
index 7e61c2af0..5c92f8cba 100644
--- a/Lib/test/test_importlib/frozen/test_loader.py
+++ b/Lib/test/test_importlib/frozen/test_loader.py
@@ -34,7 +34,8 @@ class ExecModuleTests(abc.LoaderTests):
         self.assertEqual(output, 'Hello world!\n')
         self.assertTrue(hasattr(module, '__spec__'))
 
-    @unittest.skip("TODO: RUSTPYTHON, ImportError: '__phello__' is not a frozen module")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_package(self):
         name = '__phello__'
         module, output = self.exec_module(name)
@@ -47,7 +48,8 @@ class ExecModuleTests(abc.LoaderTests):
                                  expected=value))
         self.assertEqual(output, 'Hello world!\n')
 
-    @unittest.skip("TODO: RUSTPYTHON, ImportError: '__phello__.spam' is not a frozen module")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_lacking_parent(self):
         name = '__phello__.spam'
         with util.uncache('__phello__'):
@@ -107,7 +109,8 @@ class LoaderTests(abc.LoaderTests):
             self.assertEqual(stdout.getvalue(), 'Hello world!\n')
             self.assertFalse(hasattr(module, '__file__'))
 
-    @unittest.skip("TODO: RUSTPYTHON, ImportError: '__phello__' is not a frozen module")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_package(self):
         with util.uncache('__phello__'),  captured_stdout() as stdout:
             with warnings.catch_warnings():
@@ -126,7 +129,8 @@ class LoaderTests(abc.LoaderTests):
             self.assertEqual(stdout.getvalue(), 'Hello world!\n')
             self.assertFalse(hasattr(module, '__file__'))
 
-    @unittest.skip("TODO: RUSTPYTHON, ImportError: '__phello__.spam' is not a frozen module")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_lacking_parent(self):
         with util.uncache('__phello__', '__phello__.spam'), \
              captured_stdout() as stdout:
@@ -204,7 +208,8 @@ class InspectLoaderTests:
         result = self.machinery.FrozenImporter.get_source('__hello__')
         self.assertIsNone(result)
 
-    @unittest.skip("TODO: RUSTPYTHON, ImportError: '__phello__' is not a frozen module")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_package(self):
         # Should be able to tell what is a package.
         test_for = (('__hello__', False), ('__phello__', True),
diff --git a/Lib/test/test_importlib/import_/test_caching.py b/Lib/test/test_importlib/import_/test_caching.py
index e1afe262d..21bdecc6a 100644
--- a/Lib/test/test_importlib/import_/test_caching.py
+++ b/Lib/test/test_importlib/import_/test_caching.py
@@ -61,7 +61,8 @@ class ImportlibUseCache(UseCache, unittest.TestCase):
 
     # __import__ inconsistent between loaders and built-in import when it comes
     #   to when to use the module in sys.modules and when not to.
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: unexpected payload for __call__")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_using_cache_after_loader(self):
         # [from cache on return]
         with self.create_mock('module') as mock:
@@ -70,7 +71,8 @@ class ImportlibUseCache(UseCache, unittest.TestCase):
                 self.assertEqual(id(module), id(sys.modules['module']))
 
     # See test_using_cache_after_loader() for reasoning.
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: unexpected payload for __call__")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_using_cache_for_assigning_to_attribute(self):
         # [from cache to attribute]
         with self.create_mock('pkg.__init__', 'pkg.module') as importer:
@@ -81,7 +83,8 @@ class ImportlibUseCache(UseCache, unittest.TestCase):
                                  id(sys.modules['pkg.module']))
 
     # See test_using_cache_after_loader() for reasoning.
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: unexpected payload for __call__")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_using_cache_for_fromlist(self):
         # [from cache for fromlist]
         with self.create_mock('pkg.__init__', 'pkg.module') as importer:
diff --git a/Lib/test/test_importlib/import_/test_meta_path.py b/Lib/test/test_importlib/import_/test_meta_path.py
index 31910797c..ad7d2588a 100644
--- a/Lib/test/test_importlib/import_/test_meta_path.py
+++ b/Lib/test/test_importlib/import_/test_meta_path.py
@@ -67,7 +67,8 @@ class CallSignature:
             return fxn(*args, **kwargs)
         return log, wrapper
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: unexpected payload for __call__")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_no_path(self):
         # [no path]
         mod_name = 'top_level'
@@ -83,7 +84,8 @@ class CallSignature:
                 self.assertEqual(args[0], mod_name)
                 self.assertIsNone(args[1])
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: unexpected payload for __call__")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_with_path(self):
         # [path set]
         pkg_name = 'pkg'
diff --git a/Lib/test/test_importlib/source/test_file_loader.py b/Lib/test/test_importlib/source/test_file_loader.py
index 43aa6f9f7..c16c66dfa 100644
--- a/Lib/test/test_importlib/source/test_file_loader.py
+++ b/Lib/test/test_importlib/source/test_file_loader.py
@@ -238,7 +238,8 @@ class SimpleTest(abc.LoaderTests):
                 warnings.simplefilter('ignore', DeprecationWarning)
                 loader.load_module('bad name')
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: object of type 'NoneType' has no len()")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     @util.writes_bytecode_files
     def test_checked_hash_based_pyc(self):
         with util.create_modules('_temp') as mapping:
@@ -270,7 +271,8 @@ class SimpleTest(abc.LoaderTests):
                 data[8:16],
             )
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unittest' has no attribute 'mock'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     @util.writes_bytecode_files
     def test_overridden_checked_hash_based_pyc(self):
         with util.create_modules('_temp') as mapping, \
@@ -296,7 +298,8 @@ class SimpleTest(abc.LoaderTests):
             loader.exec_module(mod)
             self.assertEqual(mod.state, 'old')
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: object of type 'NoneType' has no len()")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     @util.writes_bytecode_files
     def test_unchecked_hash_based_pyc(self):
         with util.create_modules('_temp') as mapping:
@@ -327,7 +330,8 @@ class SimpleTest(abc.LoaderTests):
                 data[8:16],
             )
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unittest' has no attribute 'mock'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     @util.writes_bytecode_files
     def test_overiden_unchecked_hash_based_pyc(self):
         with util.create_modules('_temp') as mapping, \
diff --git a/Lib/test/test_importlib/source/test_finder.py b/Lib/test/test_importlib/source/test_finder.py
index 364a3be8d..03993da62 100644
--- a/Lib/test/test_importlib/source/test_finder.py
+++ b/Lib/test/test_importlib/source/test_finder.py
@@ -178,7 +178,8 @@ class FinderTests(abc.FinderTests):
         found = self._find(finder, 'doesnotexist')
         self.assertEqual(found, self.NOT_FOUND)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: Not a directory (os error 20)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_ignore_file(self):
         # If a directory got changed to a file from underneath us, then don't
         # worry about looking for submodules.
diff --git a/Lib/test/test_importlib/source/test_source_encoding.py b/Lib/test/test_importlib/source/test_source_encoding.py
index d7991abc6..17f87e2f7 100644
--- a/Lib/test/test_importlib/source/test_source_encoding.py
+++ b/Lib/test/test_importlib/source/test_source_encoding.py
@@ -74,12 +74,14 @@ class EncodingTest:
         source = b"#/usr/bin/python\n" + self.create_source('Latin-1')
         self.run_test(source)
 
-    @unittest.skip("TODO: RUSTPYTHON, SyntaxError: Got unexpected token  at line 1 column 2")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     # [BOM]
     def test_bom(self):
         self.run_test(codecs.BOM_UTF8 + self.source_line.encode('utf-8'))
 
-    @unittest.skip("TODO: RUSTPYTHON, SyntaxError: Got unexpected token  at line 1 column 2")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     # [BOM and utf-8]
     def test_bom_and_utf_8(self):
         source = codecs.BOM_UTF8 + self.create_source('utf-8')
diff --git a/Lib/test/test_importlib/test_abc.py b/Lib/test/test_importlib/test_abc.py
index 4e6c26cd5..ffcd94d18 100644
--- a/Lib/test/test_importlib/test_abc.py
+++ b/Lib/test/test_importlib/test_abc.py
@@ -789,7 +789,8 @@ class SourceOnlyLoaderTests(SourceLoaderTestHarness):
 
     """
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'tokenize' has no attribute 'detect_encoding'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_get_source(self):
         # Verify the source code is returned as a string.
         # If an OSError is raised by get_data then raise ImportError.
@@ -844,7 +845,8 @@ class SourceOnlyLoaderTests(SourceLoaderTestHarness):
             self.verify_module(module)
             self.assertFalse(hasattr(module, '__path__'))
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'tokenize' has no attribute 'detect_encoding'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_get_source_encoding(self):
         # Source is considered encoded in UTF-8 by default unless otherwise
         # specified by an encoding line.
@@ -964,7 +966,8 @@ class SourceLoaderGetSourceTests:
 
     """Tests for importlib.abc.SourceLoader.get_source()."""
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'tokenize' has no attribute 'detect_encoding'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_default_encoding(self):
         # Should have no problems with UTF-8 text.
         name = 'mod'
@@ -974,7 +977,8 @@ class SourceLoaderGetSourceTests:
         returned_source = mock.get_source(name)
         self.assertEqual(returned_source, source)
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'tokenize' has no attribute 'detect_encoding'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_decoded_source(self):
         # Decoding should work.
         name = 'mod'
@@ -985,7 +989,8 @@ class SourceLoaderGetSourceTests:
         returned_source = mock.get_source(name)
         self.assertEqual(returned_source, source)
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'io' has no attribute 'IncrementalNewlineDecoder'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_universal_newlines(self):
         # PEP 302 says universal newlines should be used.
         name = 'mod'
diff --git a/Lib/test/test_importlib/test_lazy.py b/Lib/test/test_importlib/test_lazy.py
index 96a812ccf..14e0186f9 100644
--- a/Lib/test/test_importlib/test_lazy.py
+++ b/Lib/test/test_importlib/test_lazy.py
@@ -75,7 +75,8 @@ class LazyLoaderTests(unittest.TestCase):
         self.assertIsNone(loader.loaded)
         return module
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: __class__ assignment only supported for types without a payload")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_e2e(self):
         # End-to-end test to verify the load is in fact lazy.
         importer = TestingImporter()
@@ -89,21 +90,24 @@ class LazyLoaderTests(unittest.TestCase):
         self.assertIsNotNone(importer.loaded)
         self.assertEqual(module, importer.loaded)
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: __class__ assignment only supported for types without a payload")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_attr_unchanged(self):
         # An attribute only mutated as a side-effect of import should not be
         # changed needlessly.
         module = self.new_module()
         self.assertEqual(TestingImporter.mutated_name, module.__name__)
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: __class__ assignment only supported for types without a payload")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_new_attr(self):
         # A new attribute should persist.
         module = self.new_module()
         module.new_attr = 42
         self.assertEqual(42, module.new_attr)
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: __class__ assignment only supported for types without a payload")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_mutated_preexisting_attr(self):
         # Changing an attribute that already existed on the module --
         # e.g. __name__ -- should persist.
@@ -111,7 +115,8 @@ class LazyLoaderTests(unittest.TestCase):
         module.__name__ = 'bogus'
         self.assertEqual('bogus', module.__name__)
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: __class__ assignment only supported for types without a payload")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_mutated_attr(self):
         # Changing an attribute that comes into existence after an import
         # should persist.
@@ -119,20 +124,23 @@ class LazyLoaderTests(unittest.TestCase):
         module.attr = 6
         self.assertEqual(6, module.attr)
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: __class__ assignment only supported for types without a payload")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_delete_eventual_attr(self):
         # Deleting an attribute should stay deleted.
         module = self.new_module()
         del module.attr
         self.assertFalse(hasattr(module, 'attr'))
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: __class__ assignment only supported for types without a payload")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_delete_preexisting_attr(self):
         module = self.new_module()
         del module.__name__
         self.assertFalse(hasattr(module, '__name__'))
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: __class__ assignment only supported for types without a payload")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_module_substitution_error(self):
         with test_util.uncache(TestingImporter.module_name):
             fresh_module = types.ModuleType(TestingImporter.module_name)
@@ -141,7 +149,8 @@ class LazyLoaderTests(unittest.TestCase):
             with self.assertRaisesRegex(ValueError, "substituted"):
                 module.__name__
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: __class__ assignment only supported for types without a payload")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_module_already_in_sys(self):
         with test_util.uncache(TestingImporter.module_name):
             module = self.new_module()
diff --git a/Lib/test/test_importlib/test_open.py b/Lib/test/test_importlib/test_open.py
index d108e9993..ac676341f 100644
--- a/Lib/test/test_importlib/test_open.py
+++ b/Lib/test/test_importlib/test_open.py
@@ -28,14 +28,16 @@ class OpenTests:
             result = fp.read()
             self.assertEqual(result, 'Hello, UTF-8 world!\n')
 
-    @unittest.skip("TODO: RUSTPYTHON, UnicodeDecodeError: cannot decode byte at index: 0")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_open_text_given_encoding(self):
         with resources.open_text(
                 self.data, 'utf-16.file', 'utf-16', 'strict') as fp:
             result = fp.read()
         self.assertEqual(result, 'Hello, UTF-16 world!\n')
 
-    @unittest.skip("TODO: RUSTPYTHON, UnicodeDecodeError: cannot decode byte at index: 0")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_open_text_with_errors(self):
         # Raises UnicodeError without the 'errors' argument.
         with resources.open_text(
diff --git a/Lib/test/test_importlib/test_read.py b/Lib/test/test_importlib/test_read.py
index d7e155bf0..8f26361a7 100644
--- a/Lib/test/test_importlib/test_read.py
+++ b/Lib/test/test_importlib/test_read.py
@@ -24,13 +24,15 @@ class ReadTests:
         result = resources.read_text(self.data, 'utf-8.file')
         self.assertEqual(result, 'Hello, UTF-8 world!\n')
 
-    @unittest.skip("TODO: RUSTPYTHON, UnicodeDecodeError: cannot decode byte at index: 0")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_read_text_given_encoding(self):
         result = resources.read_text(
             self.data, 'utf-16.file', encoding='utf-16')
         self.assertEqual(result, 'Hello, UTF-16 world!\n')
 
-    @unittest.skip("TODO: RUSTPYTHON, UnicodeDecodeError: cannot decode byte at index: 0")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_read_text_with_errors(self):
         # Raises UnicodeError without the 'errors' argument.
         self.assertRaises(
diff --git a/Lib/test/test_importlib/test_util.py b/Lib/test/test_importlib/test_util.py
index 7f1fbe4ef..19122c2ee 100644
--- a/Lib/test/test_importlib/test_util.py
+++ b/Lib/test/test_importlib/test_util.py
@@ -21,19 +21,22 @@ class DecodeSourceBytesTests:
 
     source = "string ='ü'"
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'tokenize' has no attribute 'detect_encoding'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_ut8_default(self):
         source_bytes = self.source.encode('utf-8')
         self.assertEqual(self.util.decode_source(source_bytes), self.source)
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'tokenize' has no attribute 'detect_encoding'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_specified_encoding(self):
         source = '# coding=latin-1\n' + self.source
         source_bytes = source.encode('latin-1')
         assert source_bytes != source.encode('utf-8')
         self.assertEqual(self.util.decode_source(source_bytes), source)
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'tokenize' has no attribute 'detect_encoding'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_universal_newlines(self):
         source = '\r\n'.join([self.source, self.source])
         source_bytes = source.encode('utf-8')
@@ -546,7 +549,6 @@ class MagicNumberTests:
         # Should be 4 bytes.
         self.assertEqual(len(self.util.MAGIC_NUMBER), 4)
 
-    @unittest.skip("TODO: RUSTPYTHON, Source_MagicNumberTests passes while Frozen_MagicNumberTests fails")
     def test_incorporates_rn(self):
         # The magic number uses \r\n to come out wrong when splitting on lines.
         self.assertTrue(self.util.MAGIC_NUMBER.endswith(b'\r\n'))
@@ -556,6 +558,13 @@ class MagicNumberTests:
  Source_MagicNumberTests
  ) = util.test_both(MagicNumberTests, util=importlib_util)
 
+# TODO: RUSTPYTHON
+@unittest.expectedFailure
+def test_incorporates_rn_MONKEYPATCH(self):
+    self.assertTrue(self.util.MAGIC_NUMBER.endswith(b'\r\n'))
+
+# TODO: RUSTPYTHON
+Frozen_MagicNumberTests.test_incorporates_rn = test_incorporates_rn_MONKEYPATCH
 
 class PEP3147Tests:
 
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index e143ac0f1..8733d0f9f 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -626,8 +626,6 @@ class IOTest(unittest.TestCase):
             else:
                 self.fail("1/0 didn't raise an exception")
 
-    # TODO: RUSTPYTHON
-    # @unittest.expectedFailure
     # issue 5008
     def test_append_mode_tell(self):
         with self.open(support.TESTFN, "wb") as f:
@@ -2600,8 +2598,8 @@ class TextIOWrapperTest(unittest.TestCase):
     def tearDown(self):
         support.unlink(support.TESTFN)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest fails while CTextIOWrapperTest errors: "
-        "AttributeError: 'TextIOWrapper' object has no attribute 'line_buffering'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_constructor(self):
         r = self.BytesIO(b"\xc3\xa9\n\n")
         b = self.BufferedReader(r, 1000)
@@ -2616,7 +2614,6 @@ class TextIOWrapperTest(unittest.TestCase):
         self.assertRaises(TypeError, t.__init__, b, newline=42)
         self.assertRaises(ValueError, t.__init__, b, newline='xyzzy')
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_uninitialized(self):
         t = self.TextIOWrapper.__new__(self.TextIOWrapper)
         del t
@@ -2628,7 +2625,6 @@ class TextIOWrapperTest(unittest.TestCase):
         t.__init__(self.MockRawIO())
         self.assertEqual(t.read(0), '')
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_non_text_encoding_codecs_are_rejected(self):
         # Ensure the constructor complains if passed a codec that isn't
         # marked as a text encoding
@@ -2638,9 +2634,8 @@ class TextIOWrapperTest(unittest.TestCase):
         with self.assertRaisesRegex(LookupError, "is not a text encoding"):
             self.TextIOWrapper(b, encoding="hex")
 
-    @unittest.skip("TODO: RUSTPYTHON, "
-        "AttributeError: 'TextIOWrapper' object has no attribute 'detach'; "
-        "BufferError: Existing exports of data: object cannot be re-sized")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_detach(self):
         r = self.BytesIO()
         b = self.BufferedWriter(r)
@@ -2661,7 +2656,6 @@ class TextIOWrapperTest(unittest.TestCase):
         self.assertFalse(t.line_buffering)
         self.assertFalse(t.write_through)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_repr(self):
         raw = self.BytesIO("hello".encode("utf-8"))
         b = self.BufferedReader(raw)
@@ -2692,9 +2686,8 @@ class TextIOWrapperTest(unittest.TestCase):
             except RuntimeError:
                 pass
 
-    @unittest.skip("TODO: RUSTPYTHON, "
-        "TypeError: Unexpected keyword argument line_buffering; "
-        "BufferError: Existing exports of data: object cannot be re-sized")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_line_buffering(self):
         r = self.BytesIO()
         b = self.BufferedWriter(r, 1000)
@@ -2706,9 +2699,8 @@ class TextIOWrapperTest(unittest.TestCase):
         t.write("A\rB")
         self.assertEqual(r.getvalue(), b"XY\nZA\rB")
 
-    @unittest.skip("TODO: RUSTPYTHON, "
-        "TypeError: Unexpected keyword argument line_buffering; "
-        "BufferError: Existing exports of data: object cannot be re-sized")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_reconfigure_line_buffering(self):
         r = self.BytesIO()
         b = self.BufferedWriter(r, 1000)
@@ -2775,8 +2767,6 @@ class TextIOWrapperTest(unittest.TestCase):
         self.assertIsNotNone(t.encoding)
         codecs.lookup(t.encoding)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest errors: "
-        "UnicodeDecodeError: cannot decode byte at index: 4")
     def test_encoding_errors_reading(self):
         # (1) default
         b = self.BytesIO(b"abc\n\xff\n")
@@ -2795,7 +2785,6 @@ class TextIOWrapperTest(unittest.TestCase):
         t = self.TextIOWrapper(b, encoding="ascii", errors="replace")
         self.assertEqual(t.read(), "abc\n\ufffd\n")
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_encoding_errors_writing(self):
         # (1) default
         b = self.BytesIO()
@@ -2820,7 +2809,6 @@ class TextIOWrapperTest(unittest.TestCase):
         t.flush()
         self.assertEqual(b.getvalue(), b"abc?def\n")
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_newlines(self):
         input_lines = [ "unix\n", "windows\r\n", "os9\r", "last\n", "nonl" ]
 
@@ -2863,7 +2851,6 @@ class TextIOWrapperTest(unittest.TestCase):
                             self.assertEqual(got_line, exp_line)
                         self.assertEqual(len(got_lines), len(exp_lines))
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_newlines_input(self):
         testdata = b"AAA\nBB\x00B\nCCC\rDDD\rEEE\r\nFFF\r\nGGG"
         normalized = testdata.replace(b"\r\n", b"\n").replace(b"\r", b"\n")
@@ -2880,7 +2867,6 @@ class TextIOWrapperTest(unittest.TestCase):
             txt.seek(0)
             self.assertEqual(txt.read(), "".join(expected))
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_newlines_output(self):
         testdict = {
             "": b"AAA\nBBB\nCCC\nX\rY\r\nZ",
@@ -2913,7 +2899,6 @@ class TextIOWrapperTest(unittest.TestCase):
         support.gc_collect()
         self.assertEqual([b"abc"], l)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_override_destructor(self):
         record = []
         class MyTextIO(self.TextIOWrapper):
@@ -2954,9 +2939,8 @@ class TextIOWrapperTest(unittest.TestCase):
 
     # Systematic tests of the text I/O API
 
-    @unittest.skip("TODO: RUSTPYTHON, "
-        "io.UnsupportedOperation: TextIOWrapper.truncate() not supported; "
-        "OSError: can't reconstruct logical file position")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_basic_io(self):
         for chunksize in (1, 2, 3, 4, 5, 15, 16, 17, 31, 32, 33, 63, 64, 65):
             for enc in "ascii", "latin-1", "utf-8" :# , "utf-16-be", "utf-16-le":
@@ -3030,7 +3014,8 @@ class TextIOWrapperTest(unittest.TestCase):
         self.assertEqual(f.tell(), p2)
         f.close()
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: 'TextIOWrapper' object has no attribute '_CHUNK_SIZE'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_seeking(self):
         chunk_size = _default_chunk_size()
         prefix_size = chunk_size - 2
@@ -3048,9 +3033,8 @@ class TextIOWrapperTest(unittest.TestCase):
             self.assertEqual(f.tell(), prefix_size)
             self.assertEqual(f.readline(), u_suffix)
 
-    @unittest.skip("TODO: RUSTPYTHON, "
-        "AttributeError: 'TextIOWrapper' object has no attribute '_CHUNK_SIZE'; "
-        "OSError: can't reconstruct logical file position")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_seeking_too(self):
         # Regression test for a specific bug
         data = b'\xe0\xbf\xbf\n'
@@ -3109,8 +3093,6 @@ class TextIOWrapperTest(unittest.TestCase):
         finally:
             StatefulIncrementalDecoder.codecEnabled = 0
 
-    @unittest.skip("TODO: RUSTPYTHON, CTextIOWrapperTest passes while PyTextIOWrapperTest errors: "
-        "LookupError: unknown encoding: euc_jp")
     def test_multibyte_seek_and_tell(self):
         f = self.open(support.TESTFN, "w", encoding="euc_jp")
         f.write("AB\n\u3046\u3048\n")
@@ -3126,8 +3108,6 @@ class TextIOWrapperTest(unittest.TestCase):
         self.assertEqual(f.tell(), p1)
         f.close()
 
-    @unittest.skip("TODO: RUSTPYTHON, CTextIOWrapperTest passes while PyTextIOWrapperTest errors: "
-        "LookupError: unknown encoding: euc_jis_2004")
     def test_seek_with_encoder_state(self):
         f = self.open(support.TESTFN, "w", encoding="euc_jis_2004")
         f.write("\u00e6\u0300")
@@ -3141,8 +3121,8 @@ class TextIOWrapperTest(unittest.TestCase):
         self.assertEqual(f.readline(), "\u00e6\u0300\u0300")
         f.close()
 
-    @unittest.skip("TODO: RUSTPYTHON, CTextIOWrapperTest fails while PyTextIOWrapperTest errors: "
-        "AttributeError: module 'codecs' has no attribute 'utf_32_encode'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_encoded_writes(self):
         data = "1234567890"
         tests = ("utf-16",
@@ -3170,7 +3150,6 @@ class TextIOWrapperTest(unittest.TestCase):
         txt = self.TextIOWrapper(UnReadable())
         self.assertRaises(OSError, txt.read)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_read_one_by_one(self):
         txt = self.TextIOWrapper(self.BytesIO(b"AA\r\nBB"))
         reads = ""
@@ -3189,7 +3168,6 @@ class TextIOWrapperTest(unittest.TestCase):
         txt.seek(0)
         self.assertEqual(txt.readlines(5), ["AA\n", "BB\n"])
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     # read in amounts equal to TextIOWrapper._CHUNK_SIZE which is 128.
     def test_read_by_chunk(self):
         # make sure "\r\n" straddles 128 char boundary.
@@ -3224,7 +3202,6 @@ class TextIOWrapperTest(unittest.TestCase):
         self.assertRaises(TypeError, txt.writelines, None)
         self.assertRaises(TypeError, txt.writelines, b'abc')
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_issue1395_1(self):
         txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
 
@@ -3237,7 +3214,6 @@ class TextIOWrapperTest(unittest.TestCase):
             reads += c
         self.assertEqual(reads, self.normalized)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_issue1395_2(self):
         txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
         txt._CHUNK_SIZE = 4
@@ -3250,7 +3226,6 @@ class TextIOWrapperTest(unittest.TestCase):
             reads += c
         self.assertEqual(reads, self.normalized)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_issue1395_3(self):
         txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
         txt._CHUNK_SIZE = 4
@@ -3262,7 +3237,6 @@ class TextIOWrapperTest(unittest.TestCase):
         reads += txt.readline()
         self.assertEqual(reads, self.normalized)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_issue1395_4(self):
         txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
         txt._CHUNK_SIZE = 4
@@ -3271,7 +3245,6 @@ class TextIOWrapperTest(unittest.TestCase):
         reads += txt.read()
         self.assertEqual(reads, self.normalized)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_issue1395_5(self):
         txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
         txt._CHUNK_SIZE = 4
@@ -3282,15 +3255,14 @@ class TextIOWrapperTest(unittest.TestCase):
         txt.seek(pos)
         self.assertEqual(txt.read(4), "BBB\n")
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_issue2282(self):
         buffer = self.BytesIO(self.testdata)
         txt = self.TextIOWrapper(buffer, encoding="ascii")
 
         self.assertEqual(buffer.seekable(), txt.seekable())
 
-    @unittest.skip("TODO: RUSTPYTHON, CTextIOWrapperTest fails while PyTextIOWrapperTest errors:"
-        "AttributeError: module 'codecs' has no attribute 'utf_32_encode'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_append_bom(self):
         # The BOM is not written again when appending to a non-empty file
         filename = support.TESTFN
@@ -3306,8 +3278,8 @@ class TextIOWrapperTest(unittest.TestCase):
             with self.open(filename, 'rb') as f:
                 self.assertEqual(f.read(), 'aaaxxx'.encode(charset))
 
-    @unittest.skip("TODO: RUSTPYTHON, CTextIOWrapperTest fails while PyTextIOWrapperTest errors:"
-        "AttributeError: module 'codecs' has no attribute 'utf_32_encode'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_seek_bom(self):
         # Same test, but when seeking manually
         filename = support.TESTFN
@@ -3323,8 +3295,8 @@ class TextIOWrapperTest(unittest.TestCase):
             with self.open(filename, 'rb') as f:
                 self.assertEqual(f.read(), 'bbbzzz'.encode(charset))
 
-    @unittest.skip("TODO: RUSTPYTHON, CTextIOWrapperTest fails while PyTextIOWrapperTest errors:"
-        "AttributeError: module 'codecs' has no attribute 'utf_32_encode'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_seek_append_bom(self):
         # Same test, but first seek to the start and then to the end
         filename = support.TESTFN
@@ -3362,7 +3334,6 @@ class TextIOWrapperTest(unittest.TestCase):
             for n in range(20):
                 self.assertEqual(content.count("Thread%03d\n" % n), 1)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_flush_error_on_close(self):
         # Test that text file is closed despite failed flush
         # and that flush() is called before file closed.
@@ -3380,7 +3351,6 @@ class TextIOWrapperTest(unittest.TestCase):
         self.assertFalse(closed[1])
         txt.flush = lambda: None  # break reference loop
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_close_error_on_close(self):
         buffer = self.BytesIO(self.testdata)
         def bad_flush():
@@ -3401,7 +3371,6 @@ class TextIOWrapperTest(unittest.TestCase):
         buffer.close = lambda: None
         txt.flush = lambda: None
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_nonnormalized_close_error_on_close(self):
         # Issue #21677
         buffer = self.BytesIO(self.testdata)
@@ -3441,7 +3410,6 @@ class TextIOWrapperTest(unittest.TestCase):
         with self.assertRaises(AttributeError):
             txt.buffer = buf
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_rawio(self):
         # Issue #12591: TextIOWrapper must work with raw I/O objects, so
         # that subprocess.Popen() can have the required unbuffered
@@ -3453,8 +3421,6 @@ class TextIOWrapperTest(unittest.TestCase):
         self.assertEqual(txt.readline(), 'efghi\n')
         self.assertEqual(list(txt), ['jkl\n', 'opq\n'])
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest errors: "
-        "TypeError: Unexpected keyword argument write_through")
     def test_rawio_write_through(self):
         # Issue #12591: with write_through=True, writes don't need a flush
         raw = self.MockRawIO([b'abc', b'def', b'ghi\njkl\nopq\n'])
@@ -3465,9 +3431,8 @@ class TextIOWrapperTest(unittest.TestCase):
         txt.write('5')
         self.assertEqual(b''.join(raw._write_stack), b'123\n45')
 
-    @unittest.skip("TODO: RUSTPYTHON, "
-        "TypeError: Unexpected keyword argument write_through; "
-        "BufferError: Existing exports of data: object cannot be re-sized")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_bufio_write_through(self):
         # Issue #21396: write_through=True doesn't force a flush()
         # on the underlying binary buffered object.
@@ -3500,8 +3465,6 @@ class TextIOWrapperTest(unittest.TestCase):
         self.assertTrue(write_called)
         self.assertEqual(rawio.getvalue(), data * 11) # all flushed
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest errors: "
-        "AttributeError: 'TextIOWrapper' object has no attribute 'reconfigure'")
     def test_reconfigure_write_through(self):
         raw = self.MockRawIO([])
         t = self.TextIOWrapper(raw, encoding='ascii', newline='\n')
@@ -3545,7 +3508,6 @@ class TextIOWrapperTest(unittest.TestCase):
             t = io.TextIOWrapper(io.BytesIO(b'foo'), encoding="rot13")
         self.assertRaises(TypeError, t.write, 'bar')
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest fails")
     def test_illegal_decoder(self):
         # Issue #17106
         # Bypass the early encoding check added in issue 20404
@@ -3654,8 +3616,8 @@ class TextIOWrapperTest(unittest.TestCase):
         F.tell = lambda x: 0
         t = self.TextIOWrapper(F(), encoding='utf-8')
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest fails while CTextIOWrapperTest errors: "
-        "UnicodeDecodeError: cannot decode byte at index: 3")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_reconfigure_encoding_read(self):
         # latin1 -> utf8
         # (latin1 can decode utf-8 encoded string)
@@ -3668,8 +3630,6 @@ class TextIOWrapperTest(unittest.TestCase):
         with self.assertRaises(self.UnsupportedOperation):
             txt.reconfigure(newline=None)
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest errors: "
-        "AttributeError: 'TextIOWrapper' object has no attribute 'reconfigure'")
     def test_reconfigure_write_fromascii(self):
         # ascii has a specific encodefunc in the C implementation,
         # but utf-8-sig has not. Make sure that we get rid of the
@@ -3682,8 +3642,6 @@ class TextIOWrapperTest(unittest.TestCase):
         txt.flush()
         self.assertEqual(raw.getvalue(), b'foo\n\xc3\xa9\n')
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest errors: "
-        "AttributeError: 'TextIOWrapper' object has no attribute 'reconfigure'")
     def test_reconfigure_write(self):
         # latin -> utf8
         raw = self.BytesIO()
@@ -3705,8 +3663,6 @@ class TextIOWrapperTest(unittest.TestCase):
         txt.flush()
         self.assertEqual(raw.getvalue(), b'abc\nd\xc3\xa9f\n')
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest errors: "
-        "AttributeError: 'TextIOWrapper' object has no attribute 'reconfigure'")
     def test_reconfigure_write_non_seekable(self):
         raw = self.BytesIO()
         raw.seekable = lambda: False
@@ -3720,8 +3676,6 @@ class TextIOWrapperTest(unittest.TestCase):
         # If the raw stream is not seekable, there'll be a BOM
         self.assertEqual(raw.getvalue(),  b'abc\n\xef\xbb\xbfd\xc3\xa9f\n')
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest errors: "
-        "AttributeError: 'TextIOWrapper' object has no attribute 'reconfigure'")
     def test_reconfigure_defaults(self):
         txt = self.TextIOWrapper(self.BytesIO(), 'ascii', 'replace', '\n')
         txt.reconfigure(encoding=None)
@@ -3745,8 +3699,6 @@ class TextIOWrapperTest(unittest.TestCase):
 
         self.assertEqual(txt.detach().getvalue(), b'LF\nCRLF\r\n')
 
-    @unittest.skip("TODO: RUSTPYTHON, PyTextIOWrapperTest passes while CTextIOWrapperTest errors: "
-        "AttributeError: 'TextIOWrapper' object has no attribute 'reconfigure'")
     def test_reconfigure_newline(self):
         raw = self.BytesIO(b'CR\rEOF')
         txt = self.TextIOWrapper(raw, 'ascii', newline='\n')
@@ -3818,6 +3770,151 @@ class CTextIOWrapperTest(TextIOWrapperTest):
     io = io
     shutdown_error = "RuntimeError: could not find io module state"
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_uninitialized(self):
+        super().test_uninitialized()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_non_text_encoding_codecs_are_rejected(self):
+        super().test_non_text_encoding_codecs_are_rejected()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_repr(self):
+        super().test_repr()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_encoding_errors_reading(self):
+        super().test_encoding_errors_reading()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_encoding_errors_writing(self):
+        super().test_encoding_errors_writing()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_newlines(self):
+        super().test_newlines()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_newlines_input(self):
+        super().test_newlines_input()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_newlines_output(self):
+        super().test_newlines_output()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_override_destructor(self):
+        super().test_override_destructor()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_read_one_by_one(self):
+        super().test_read_one_by_one()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_read_by_chunk(self):
+        super().test_read_by_chunk()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_issue1395_1(self):
+        super().test_issue1395_1()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_issue1395_2(self):
+        super().test_issue1395_2()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_issue1395_3(self):
+        super().test_issue1395_3()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_issue1395_4(self):
+        super().test_issue1395_4()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_issue1395_5(self):
+        super().test_issue1395_5()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_issue2282(self):
+        super().test_issue2282()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_flush_error_on_close(self):
+        super().test_flush_error_on_close()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_close_error_on_close(self):
+        super().test_close_error_on_close()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_nonnormalized_close_error_on_close(self):
+        super().test_nonnormalized_close_error_on_close()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_rawio(self):
+        super().test_rawio()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_rawio_write_through(self):
+        super().test_rawio_write_through()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_reconfigure_write_through(self):
+        super().test_reconfigure_write_through()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_illegal_decoder(self):
+        super().test_illegal_decoder()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_reconfigure_write_fromascii(self):
+        super().test_reconfigure_write_fromascii()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_reconfigure_write(self):
+        super().test_reconfigure_write()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_reconfigure_write_non_seekable(self):
+        super().test_reconfigure_write_non_seekable()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_reconfigure_defaults(self):
+        super().test_reconfigure_defaults()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_reconfigure_newline(self):
+        super().test_reconfigure_newline()
+
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_initialization(self):
@@ -3863,7 +3960,8 @@ class CTextIOWrapperTest(TextIOWrapperTest):
             t2.buddy = t1
         support.gc_collect()
 
-    @unittest.skip("TODO: RUSTPYTHON, KeyError: '_CHUNK_SIZE'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_del__CHUNK_SIZE_SystemError(self):
         t = self.TextIOWrapper(self.BytesIO(), encoding='ascii')
         with self.assertRaises(AttributeError):
@@ -3874,6 +3972,21 @@ class PyTextIOWrapperTest(TextIOWrapperTest):
     io = pyio
     shutdown_error = "LookupError: unknown encoding: ascii"
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_newlines(self):
+        super().test_newlines()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_seek_with_encoder_state(self):
+        super().test_seek_with_encoder_state()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_multibyte_seek_and_tell(self):
+        super().test_multibyte_seek_and_tell()
+
 
 @unittest.skip("TODO: RUSTPYTHON, incremental decoder")
 class IncrementalNewlineDecoderTest(unittest.TestCase):
@@ -4214,11 +4327,13 @@ class MiscIOTest(unittest.TestCase):
                 with self.open(support.TESTFN, **kwargs) as f:
                     self.assertRaises(TypeError, pickle.dumps, f, protocol)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: Bad file descriptor (os error 9)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_nonblock_pipe_write_bigbuf(self):
         self._test_nonblock_pipe_write(16*1024)
 
-    @unittest.skip("TODO: RUSTPYTHON, BlockingIOError: Resource temporarily unavailable (os error 11)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_nonblock_pipe_write_smallbuf(self):
         self._test_nonblock_pipe_write(1024)
 
@@ -4427,7 +4542,6 @@ class SignalsTest(unittest.TestCase):
     def test_interrupted_write_buffered(self):
         self.check_interrupted_write(b"xy", b"xy", mode="wb")
 
-    @unittest.skip("TODO: RUSTPYTHON, CSignalsTest passes while PySignalsTest hangs")
     def test_interrupted_write_text(self):
         self.check_interrupted_write("xy", b"xy", mode="w", encoding="ascii")
 
@@ -4489,12 +4603,14 @@ class SignalsTest(unittest.TestCase):
             os.close(w)
             os.close(r)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: Broken pipe (os error 32)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_interrupted_read_retry_buffered(self):
         self.check_interrupted_read_retry(lambda x: x.decode('latin1'),
                                           mode="rb")
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: Broken pipe (os error 32)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_interrupted_read_retry_text(self):
         self.check_interrupted_read_retry(lambda x: x,
                                           mode="r")
@@ -4587,6 +4703,10 @@ class PySignalsTest(SignalsTest):
     test_reentrant_write_buffered = None
     test_reentrant_write_text = None
 
+    @unittest.skip("TODO: RUSTPYTHON, hangs?")
+    def test_interrupted_write_text(self):
+        super().test_interrupted_write_text()
+
 
 def load_tests(*args):
     tests = (CIOTest, PyIOTest, APIMismatchTest,
diff --git a/Lib/test/test_iter.py b/Lib/test/test_iter.py
index d55da8fac..015e8ae19 100644
--- a/Lib/test/test_iter.py
+++ b/Lib/test/test_iter.py
@@ -1029,7 +1029,8 @@ class TestCase(unittest.TestCase):
         self.assertEqual(next(it), 0)
         self.assertEqual(next(it), 1)
 
-    @unittest.skip("TODO: RUSTPYTHON, NameError: name 'check_free_after_iterating' is not defined")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_free_after_iterating(self):
         check_free_after_iterating(self, iter, SequenceClass, (0,))
 
diff --git a/Lib/test/test_json/test_fail.py b/Lib/test/test_json/test_fail.py
index 881e8391a..dcadc1c51 100644
--- a/Lib/test/test_json/test_fail.py
+++ b/Lib/test/test_json/test_fail.py
@@ -79,7 +79,6 @@ SKIPS = {
 }
 
 class TestFail:
-    @unittest.skip("TODO: RUSTPYTHON, TestPyFail passes while TestCFail fails")
     def test_failures(self):
         for idx, doc in enumerate(JSONDOCS):
             idx = idx + 1
@@ -219,3 +218,9 @@ class TestFail:
 
 class TestPyFail(TestFail, PyTest): pass
 class TestCFail(TestFail, CTest): pass
+# TODO: RUSTPYTHON
+class TestCFail(TestFail, CTest):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_failures(self):
+        super().test_failures()
diff --git a/Lib/test/test_json/test_scanstring.py b/Lib/test/test_json/test_scanstring.py
index d19b86e34..140a7c12a 100644
--- a/Lib/test/test_json/test_scanstring.py
+++ b/Lib/test/test_json/test_scanstring.py
@@ -86,9 +86,8 @@ class TestScanstring:
             scanstring('["Bad value", truth]', 2, True),
             ('Bad value', 12))
 
-    @unittest.skip("TODO: RUSTPYTHON, "
-        "json.decoder.JSONDecodeError: unpaired surrogate: line 1 column 3 (char 2); "
-        "ValueError: chr() arg not in range(0x110000)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_surrogates(self):
         scanstring = self.json.decoder.scanstring
         def assertScan(given, expect):
@@ -105,8 +104,6 @@ class TestScanstring:
         assertScan('"z\ud834\\udd20x"', 'z\ud834\udd20x')
         assertScan('"z\ud834x"', 'z\ud834x')
 
-    @unittest.skip("TODO: RUSTPYTHON, TestCScanstring passes while TestPyScanstring errors: "
-        "ValueError: chr() arg not in range(0x110000)")
     def test_bad_escapes(self):
         scanstring = self.json.decoder.scanstring
         bad_escapes = [
@@ -138,13 +135,18 @@ class TestScanstring:
             with self.assertRaises(self.JSONDecodeError, msg=s):
                 scanstring(s, 1, True)
 
-    @unittest.skip("TODO: RUSTPYTHON, "
-        "TypeError: Expected type 'str', not 'bytes'; "
-        "TypeError: expected string")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_overflow(self):
         with self.assertRaises(OverflowError):
             self.json.decoder.scanstring(b"xxx", sys.maxsize+1)
 
 
 class TestPyScanstring(TestScanstring, PyTest): pass
+# TODO: RUSTPYTHON
+class TestPyScanstring(TestScanstring, PyTest):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_bad_escapes(self):
+        super().test_bad_escapes()
 class TestCScanstring(TestScanstring, CTest): pass
diff --git a/Lib/test/test_json/test_unicode.py b/Lib/test/test_json/test_unicode.py
index e9ec511c3..e5882a1ef 100644
--- a/Lib/test/test_json/test_unicode.py
+++ b/Lib/test/test_json/test_unicode.py
@@ -53,7 +53,8 @@ class TestUnicode:
         self.assertRaises(TypeError, self.dumps, b"hi")
         self.assertRaises(TypeError, self.dumps, [b"hi"])
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'codecs' has no attribute 'utf_32_be_encode'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_bytes_decode(self):
         for encoding, bom in [
                 ('utf-8', codecs.BOM_UTF8),
diff --git a/Lib/test/test_memoryview.py b/Lib/test/test_memoryview.py
index 3972899bd..3fe85c503 100644
--- a/Lib/test/test_memoryview.py
+++ b/Lib/test/test_memoryview.py
@@ -220,7 +220,6 @@ class AbstractMemoryTests:
             m = None
             self.assertEqual(sys.getrefcount(b), oldrefcount)
 
-    @unittest.skip("TODO: RUSTPYTHON, NameError: name 'gc' is not defined")
     def test_gc(self):
         for tp in self._types:
             if not isinstance(tp, type):
@@ -473,6 +472,11 @@ class BaseMemorySliceSliceTests:
 class BytesMemoryviewTest(unittest.TestCase,
     BaseMemoryviewTests, BaseBytesMemoryTests):
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gc(self):
+        super().test_gc()
+
     def test_constructor(self):
         for tp in self._types:
             ob = tp(self._source)
@@ -497,6 +501,10 @@ class ArrayMemoryviewTest(unittest.TestCase,
 
 class BytesMemorySliceTest(unittest.TestCase,
     BaseMemorySliceTests, BaseBytesMemoryTests):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gc(self):
+        super().test_gc()
     pass
 
 class ArrayMemorySliceTest(unittest.TestCase,
@@ -505,6 +513,10 @@ class ArrayMemorySliceTest(unittest.TestCase,
 
 class BytesMemorySliceSliceTest(unittest.TestCase,
     BaseMemorySliceSliceTests, BaseBytesMemoryTests):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gc(self):
+        super().test_gc()
     pass
 
 class ArrayMemorySliceSliceTest(unittest.TestCase,
diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py
index 31b964709..e260433c7 100644
--- a/Lib/test/test_operator.py
+++ b/Lib/test/test_operator.py
@@ -474,7 +474,6 @@ class OperatorTestCase:
         self.assertEqual(operator.ixor     (c, 5), "ixor")
         self.assertEqual(operator.iconcat  (c, c), "iadd")
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: 'NotImplementedType' object cannot be interpreted as an integer")
     def test_length_hint(self):
         operator = self.module
         class X(object):
@@ -517,6 +516,11 @@ class PyOperatorTestCase(OperatorTestCase, unittest.TestCase):
 class COperatorTestCase(OperatorTestCase, unittest.TestCase):
     module = c_operator
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_length_hint(self):
+        super().test_length_hint()
+
 
 class OperatorPickleTestCase:
     def copy(self, obj, proto):
diff --git a/Lib/test/test_pathlib.py b/Lib/test/test_pathlib.py
index 556a70d96..14e1ac9a9 100644
--- a/Lib/test/test_pathlib.py
+++ b/Lib/test/test_pathlib.py
@@ -619,7 +619,6 @@ class _BasePurePathTest(object):
         self.assertRaises(ValueError, p.relative_to, '')
         self.assertRaises(ValueError, p.relative_to, P('a'))
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: Missing 1 required positional arguments: self")
     def test_pickling_common(self):
         P = self.cls
         p = P('/a/b')
@@ -1332,7 +1331,8 @@ class _BasePathTest(object):
         p = P(P('').absolute().anchor) / '~'
         self.assertEqual(p.expanduser(), p)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: data provided contains a nul byte")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_exists(self):
         P = self.cls
         p = P(BASE)
@@ -1410,7 +1410,8 @@ class _BasePathTest(object):
         self.assertIn(cm.exception.errno, (errno.ENOTDIR,
                                            errno.ENOENT, errno.EINVAL))
 
-    @unittest.skip("TODO: RUSTPYTHON, FileNotFoundError: No such file or directory (os error 2)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_glob_common(self):
         def _check(glob, expected):
             self.assertEqual(set(glob), { P(BASE, q) for q in expected })
@@ -1435,7 +1436,8 @@ class _BasePathTest(object):
         else:
             _check(p.glob("*/fileB"), ['dirB/fileB', 'linkB/fileB'])
 
-    @unittest.skip("TODO: RUSTPYTHON, FileNotFoundError: No such file or directory (os error 2)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_rglob_common(self):
         def _check(glob, expected):
             self.assertEqual(set(glob), { P(BASE, q) for q in expected })
@@ -1698,7 +1700,6 @@ class _BasePathTest(object):
         self.assertEqual(os.stat(r).st_size, size)
         self.assertFileNotFound(q.stat)
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: utime: 'times' must be either a tuple of two ints or None")
     def test_touch_common(self):
         P = self.cls(BASE)
         p = P / 'newfileA'
@@ -1890,7 +1891,8 @@ class _BasePathTest(object):
         self.assertTrue(link.is_dir())
         self.assertTrue(list(link.iterdir()))
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: data provided contains a nul byte")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_dir(self):
         P = self.cls(BASE)
         self.assertTrue((P / 'dirA').is_dir())
@@ -1904,7 +1906,8 @@ class _BasePathTest(object):
         self.assertIs((P / 'dirA\udfff').is_dir(), False)
         self.assertIs((P / 'dirA\x00').is_dir(), False)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: data provided contains a nul byte")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_file(self):
         P = self.cls(BASE)
         self.assertTrue((P / 'fileA').is_file())
@@ -1919,7 +1922,8 @@ class _BasePathTest(object):
         self.assertIs((P / 'fileA\x00').is_file(), False)
 
     @only_posix
-    @unittest.skip("TODO: RUSTPYTHON, OSError: data provided contains a nul byte")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_mount(self):
         P = self.cls(BASE)
         R = self.cls('/')  # TODO: Work out Windows.
@@ -1933,7 +1937,8 @@ class _BasePathTest(object):
         self.assertIs(self.cls('/\udfff').is_mount(), False)
         self.assertIs(self.cls('/\x00').is_mount(), False)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: data provided contains a nul byte")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_symlink(self):
         P = self.cls(BASE)
         self.assertFalse((P / 'fileA').is_symlink())
@@ -1950,7 +1955,8 @@ class _BasePathTest(object):
             self.assertIs((P / 'linkA\udfff').is_file(), False)
             self.assertIs((P / 'linkA\x00').is_file(), False)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: data provided contains a nul byte")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_fifo_false(self):
         P = self.cls(BASE)
         self.assertFalse((P / 'fileA').is_fifo())
@@ -1961,7 +1967,8 @@ class _BasePathTest(object):
         self.assertIs((P / 'fileA\x00').is_fifo(), False)
 
     @unittest.skipUnless(hasattr(os, "mkfifo"), "os.mkfifo() required")
-    @unittest.skip("TODO: RUSTPYTHON, unimplemented")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_fifo_true(self):
         P = self.cls(BASE, 'myfifo')
         try:
@@ -1974,7 +1981,8 @@ class _BasePathTest(object):
         self.assertIs(self.cls(BASE, 'myfifo\udfff').is_fifo(), False)
         self.assertIs(self.cls(BASE, 'myfifo\x00').is_fifo(), False)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: data provided contains a nul byte")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_socket_false(self):
         P = self.cls(BASE)
         self.assertFalse((P / 'fileA').is_socket())
@@ -1985,7 +1993,8 @@ class _BasePathTest(object):
         self.assertIs((P / 'fileA\x00').is_socket(), False)
 
     @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
-    @unittest.skip("TODO: RUSTPYTHON, unimplemented")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_socket_true(self):
         P = self.cls(BASE, 'mysock')
         sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
@@ -2002,7 +2011,8 @@ class _BasePathTest(object):
         self.assertIs(self.cls(BASE, 'mysock\udfff').is_socket(), False)
         self.assertIs(self.cls(BASE, 'mysock\x00').is_socket(), False)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: data provided contains a nul byte")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_block_device_false(self):
         P = self.cls(BASE)
         self.assertFalse((P / 'fileA').is_block_device())
@@ -2012,7 +2022,8 @@ class _BasePathTest(object):
         self.assertIs((P / 'fileA\udfff').is_block_device(), False)
         self.assertIs((P / 'fileA\x00').is_block_device(), False)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: data provided contains a nul byte")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_char_device_false(self):
         P = self.cls(BASE)
         self.assertFalse((P / 'fileA').is_char_device())
@@ -2022,7 +2033,8 @@ class _BasePathTest(object):
         self.assertIs((P / 'fileA\udfff').is_char_device(), False)
         self.assertIs((P / 'fileA\x00').is_char_device(), False)
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: data provided contains a nul byte")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_is_char_device_true(self):
         # Under Unix, /dev/null should generally be a char device.
         P = self.cls('/dev/null')
@@ -2034,7 +2046,6 @@ class _BasePathTest(object):
         self.assertIs(self.cls('/dev/null\udfff').is_char_device(), False)
         self.assertIs(self.cls('/dev/null\x00').is_char_device(), False)
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: Missing 1 required positional arguments: self")
     def test_pickling_common(self):
         p = self.cls(BASE, 'fileA')
         for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
@@ -2251,7 +2262,8 @@ class PosixPathTest(_BasePathTest, unittest.TestCase):
 
     @unittest.skipIf(sys.platform != "darwin",
                      "Bad file descriptor in /dev/fd affects only macOS")
-    @unittest.skip("TODO: RUSTPYTHON, OSError: (20, 'Not a directory (os error 20)')")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_handling_bad_descriptor(self):
         try:
             file_descriptors = list(pathlib.Path('/dev/fd').rglob("*"))[3:]
diff --git a/Lib/test/test_platform.py b/Lib/test/test_platform.py
index 15f229660..96676aab5 100644
--- a/Lib/test/test_platform.py
+++ b/Lib/test/test_platform.py
@@ -220,7 +220,6 @@ class PlatformTest(unittest.TestCase):
     def test_win32_ver(self):
         res = platform.win32_ver()
 
-    @unittest.skip("TODO: RUSTPYTHON, NameError: name 'ParserCreate' is not defined")
     def test_mac_ver(self):
         res = platform.mac_ver()
 
@@ -254,7 +253,12 @@ class PlatformTest(unittest.TestCase):
                 self.assertEqual(res[2], 'PowerPC')
 
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'os' has no attribute 'fork'")
+    # TODO: RUSTPYTHON
+    if sys.platform == "darwin":
+        test_mac_ver = unittest.expectedFailure(test_mac_ver)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     @unittest.skipUnless(sys.platform == 'darwin', "OSX only test")
     def test_mac_ver_with_fork(self):
         # Issue7895: platform.mac_ver() crashes when using fork without exec
diff --git a/Lib/test/test_py_compile.py b/Lib/test/test_py_compile.py
index 0f214986c..aca293d1b 100644
--- a/Lib/test/test_py_compile.py
+++ b/Lib/test/test_py_compile.py
@@ -107,13 +107,16 @@ class PyCompileTestsBase:
         self.assertTrue(os.path.exists(self.pyc_path))
         self.assertFalse(os.path.exists(self.cache_path))
 
-    @unittest.skip("TODO: RUSTPYTHON, macOS FileNotFoundError: (2, 'No such file or directory (os error 2)')")
     def test_relative_path(self):
         py_compile.compile(os.path.relpath(self.source_path),
                            os.path.relpath(self.pyc_path))
         self.assertTrue(os.path.exists(self.pyc_path))
         self.assertFalse(os.path.exists(self.cache_path))
 
+    # TODO: RUSTPYTHON
+    if sys.platform == "darwin":
+        test_relative_path = unittest.expectedFailure(test_relative_path)
+
     @unittest.skipIf(hasattr(os, 'geteuid') and os.geteuid() == 0,
                      'non-root user required')
     @unittest.skipIf(os.name == 'nt',
@@ -130,7 +133,8 @@ class PyCompileTestsBase:
         finally:
             os.chmod(self.directory, mode.st_mode)
 
-    @unittest.skip("TODO: RUSTPYTHON, FileNotFoundError: No such file or directory (os error 2)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_bad_coding(self):
         bad_coding = os.path.join(os.path.dirname(__file__), 'bad_coding2.py')
         with support.captured_stderr():
@@ -176,7 +180,8 @@ class PyCompileTestsBase:
         # Specifying optimized bytecode should lead to a path reflecting that.
         self.assertIn('opt-2', py_compile.compile(self.source_path, optimize=2))
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: object of type 'NoneType' has no len()")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_invalidation_mode(self):
         py_compile.compile(
             self.source_path,
@@ -196,11 +201,44 @@ class PyCompileTestsBase:
         self.assertEqual(flags, 0b1)
 
 
-@unittest.skip("TODO: RUSTPYTHON, TypeError: object of type 'NoneType' has no len()")
 class PyCompileTestsWithSourceEpoch(PyCompileTestsBase,
                                     unittest.TestCase,
                                     metaclass=SourceDateEpochTestMeta,
                                     source_date_epoch=True):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_absolute_path(self):
+        super().test_absolute_path()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_cache_path(self):
+        super().test_cache_path()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_cwd(self):
+        super().test_cwd()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_double_dot_no_clobber(self):
+        super().test_double_dot_no_clobber()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_optimization_path(self):
+        super().test_optimization_path()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_relative_path(self):
+        super().test_relative_path()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_source_date_epoch(self):
+        super().test_source_date_epoch()
     pass
 
 
diff --git a/Lib/test/test_random.py b/Lib/test/test_random.py
index 39cdb836b..c9f463d09 100644
--- a/Lib/test/test_random.py
+++ b/Lib/test/test_random.py
@@ -20,8 +20,6 @@ class TestBasicOps:
         """Helper function to make a list of random numbers"""
         return [self.gen.random() for i in range(n)]
 
-    @unittest.skip("TODO: RUSTPYTHON, MersenneTwister_TestBasicOps errors: "
-        "AttributeError: 'super' object has no attribute 'getstate'")
     def test_autoseed(self):
         self.gen.seed()
         state1 = self.gen.getstate()
@@ -40,8 +38,6 @@ class TestBasicOps:
         self.gen.setstate(state)    # should regenerate the same sequence
         self.assertEqual(randseq, self.randomlist(N))
 
-    @unittest.skip("TODO: RUSTPYTHON, MersenneTwister_TestBasicOps errors: "
-        "TypeError: Expected type 'int', not 'float'")
     def test_seedargs(self):
         # Seed value with a negative hash.
         class MySeed(object):
@@ -106,7 +102,6 @@ class TestBasicOps:
         shuffle(seq, mock_random)
         mock_random.assert_called_with()
 
-    @unittest.skip("TODO: RUSTPYTHON, MersenneTwister_TestBasicOps hangs?")
     def test_choice(self):
         choice = self.gen.choice
         with self.assertRaises(IndexError):
@@ -259,8 +254,6 @@ class TestBasicOps:
             self.assertEqual(x1, x2)
             self.assertEqual(y1, y2)
 
-    @unittest.skip("TODO: RUSTPYTHON, MersenneTwister_TestBasicOps errors: "
-        "TypeError: Missing 1 required positional arguments: self")
     def test_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             state = pickle.dumps(self.gen, proto)
@@ -269,7 +262,8 @@ class TestBasicOps:
             restoredseq = [newgen.random() for i in range(10)]
             self.assertEqual(origseq, restoredseq)
 
-    @unittest.skip("TODO: RUSTPYTHON, FileNotFoundError: No such file or directory (os error 2)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_bug_1727780(self):
         # verify that version-2-pickles can be loaded
         # fine, whether they are created on 32-bit or 64-bit
@@ -282,7 +276,6 @@ class TestBasicOps:
                 r = pickle.load(f)
             self.assertEqual(int(r.random()*1000), value)
 
-    @unittest.skip("TODO: RUSTPYTHON, MersenneTwister_TestBasicOps fails")
     def test_bug_9025(self):
         # Had problem with an uneven distribution in int(n*random())
         # Verify the fix by checking that distributions fall within expectations.
@@ -319,7 +312,6 @@ class SystemRandom_TestBasicOps(TestBasicOps, unittest.TestCase):
         self.gen.seed(100)
         self.assertEqual(self.gen.gauss_next, None)
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: Missing 1 required positional arguments: self")
     def test_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             self.assertRaises(NotImplementedError, pickle.dumps, self.gen, proto)
@@ -420,6 +412,35 @@ class SystemRandom_TestBasicOps(TestBasicOps, unittest.TestCase):
 class MersenneTwister_TestBasicOps(TestBasicOps, unittest.TestCase):
     gen = random.Random()
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_autoseed(self):
+        super().test_autoseed()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_seedargs(self):
+        super().test_seedargs()
+
+    @unittest.skip("TODO: RUSTPYTHON, hangs?")
+    def test_choice(self):
+        super().test_choice()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_pickling(self):
+        super().test_pickling()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_bug_9025(self):
+        super().test_bug_9025()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_seed_when_randomness_source_not_found(self):
+        super().test_seed_when_randomness_source_not_found()
+
     def test_guaranteed_stable(self):
         # These sequences are guaranteed to stay the same across versions of python
         self.gen.seed(3456147, version=1)
@@ -490,7 +511,8 @@ class MersenneTwister_TestBasicOps(TestBasicOps, unittest.TestCase):
     def test_setstate_first_arg(self):
         self.assertRaises(ValueError, self.gen.setstate, (1, None, None))
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: 'super' object has no attribute 'getstate'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_setstate_middle_arg(self):
         start_state = self.gen.getstate()
         # Wrong type, s/b tuple
@@ -676,7 +698,8 @@ class MersenneTwister_TestBasicOps(TestBasicOps, unittest.TestCase):
             self.assertEqual(k, numbits)        # note the stronger assertion
             self.assertTrue(2**k > n > 2**(k-1))   # note the stronger assertion
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: 'Random' object has no attribute '_randbelow_without_getrandbits'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_randbelow_without_getrandbits(self):
         # Random._randbelow() can only use random() when the built-in one
         # has been overridden but no new getrandbits() method was supplied.
@@ -775,7 +798,8 @@ def gamma(z, sqrt2pi=(2.0*pi)**0.5):
     ])
 
 class TestDistributions(unittest.TestCase):
-    @unittest.skip("TODO: RUSTPYTHON, ValueError: math domain error")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_zeroinputs(self):
         # Verify that distributions can handle a series of zero inputs'
         g = random.Random()
@@ -901,7 +925,8 @@ class TestDistributions(unittest.TestCase):
         returned_value = random.gammavariate(1.0, 3.14)
         self.assertAlmostEqual(returned_value, 1.877208182372648)
 
-    @unittest.skip("TODO: RUSTPYTHON, StopIteration")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     @unittest.mock.patch('random.Random.random')
     def test_gammavariate_alpha_equal_one_equals_expovariate(self, random_mock):
 
@@ -992,7 +1017,8 @@ class TestDistributions(unittest.TestCase):
 
 
 class TestRandomSubclassing(unittest.TestCase):
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: Unexpected keyword argument newarg")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_random_subclass_with_kwargs(self):
         # SF bug #1486663 -- this used to erroneously raise a TypeError
         class Subclass(random.Random):
diff --git a/Lib/test/test_set.py b/Lib/test/test_set.py
index ea7098bbe..a399d1caf 100644
--- a/Lib/test/test_set.py
+++ b/Lib/test/test_set.py
@@ -63,7 +63,6 @@ class TestJointOps:
     def test_len(self):
         self.assertEqual(len(self.s), len(self.d))
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: unhashable type")
     def test_contains(self):
         for c in self.letters:
             self.assertEqual(c in self.s, c in self.d)
@@ -227,9 +226,6 @@ class TestJointOps:
         self.assertFalse(set('a').issubset('cbs'))
         self.assertFalse(set('cbs').issuperset('a'))
 
-    @unittest.skip("TODO: RUSTPYTHON, "
-        "RuntimeError: Unexpected payload 'frozenset' for type 'SetSubclass'; "
-        "RuntimeError: Unexpected payload 'set' for type 'SetSubclass'")
     def test_pickling(self):
         for i in range(pickle.HIGHEST_PROTOCOL + 1):
             p = pickle.dumps(self.s, i)
@@ -241,7 +237,8 @@ class TestJointOps:
                 dup = pickle.loads(p)
                 self.assertEqual(self.s.x, dup.x)
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module '__main__' has no attribute 'set_iterator'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_iterator_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             itorg = iter(self.s)
@@ -316,7 +313,6 @@ class TestJointOps:
             self.assertRaises(RuntimeError, s.discard, BadCmp())
             self.assertRaises(RuntimeError, s.remove, BadCmp())
 
-    @unittest.skip("TODO: RUSTPYTHON, TestSetSubclass fails")
     def test_cyclical_repr(self):
         w = ReprWrapper()
         s = self.thetype([w])
@@ -362,7 +358,8 @@ class TestJointOps:
         self.assertEqual(sum(elem.hash_count for elem in d), n)
         self.assertEqual(d3, dict.fromkeys(d, 123))
 
-    @unittest.skip("TODO: RUSTPYTHON, NameError: name 'gc' is not defined")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_container_iterator(self):
         # Bug #3680: tp_traverse was not implemented for set iterator object
         class C(object):
@@ -375,7 +372,8 @@ class TestJointOps:
         gc.collect()
         self.assertTrue(ref() is None, "Cycle was not collected")
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'test.support' has no attribute 'check_free_after_iterating'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, self.thetype)
 
@@ -383,6 +381,11 @@ class TestSet(TestJointOps, unittest.TestCase):
     thetype = set
     basetype = set
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_contains(self):
+        super().test_contains()
+
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_init(self):
@@ -682,6 +685,16 @@ class TestSetSubclass(TestSet):
     thetype = SetSubclass
     basetype = set
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_pickling(self):
+        super().test_pickling()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_cyclical_repr(self):
+        super().test_cyclical_repr()
+
 class SetSubclassWithKeywordArgs(set):
     def __init__(self, iterable=[], newarg=None):
         set.__init__(self, iterable)
@@ -788,6 +801,11 @@ class TestFrozenSetSubclass(TestFrozenSet):
     thetype = FrozenSetSubclass
     basetype = frozenset
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_pickling(self):
+        super().test_pickling()
+
     def test_constructor_identity(self):
         s = self.thetype(range(3))
         t = self.thetype(s)
@@ -1566,7 +1584,6 @@ class TestCopying:
         for i in range(len(dup_list)):
             self.assertTrue(dup_list[i] is set_list[i])
 
-    @unittest.skip("TODO: RUSTPYTHON, TestCopyingNested, TestCopyingSingleton, TestCopyingTriple, and TestCopyingTuple fail")
     def test_deep_copy(self):
         dup = copy.deepcopy(self.set)
         ##print type(dup), repr(dup)
@@ -1588,24 +1605,44 @@ class TestCopyingSingleton(TestCopying, unittest.TestCase):
     def setUp(self):
         self.set = set(["hello"])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_deep_copy(self):
+        super().test_deep_copy()
+
 #------------------------------------------------------------------------------
 
 class TestCopyingTriple(TestCopying, unittest.TestCase):
     def setUp(self):
         self.set = set(["zero", 0, None])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_deep_copy(self):
+        super().test_deep_copy()
+
 #------------------------------------------------------------------------------
 
 class TestCopyingTuple(TestCopying, unittest.TestCase):
     def setUp(self):
         self.set = set([(1, 2)])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_deep_copy(self):
+        super().test_deep_copy()
+
 #------------------------------------------------------------------------------
 
 class TestCopyingNested(TestCopying, unittest.TestCase):
     def setUp(self):
         self.set = set([((1, 2), (3, 4))])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_deep_copy(self):
+        super().test_deep_copy()
+
 #==============================================================================
 
 class TestIdentities(unittest.TestCase):
diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py
index a3b0fd6c7..5a9116365 100644
--- a/Lib/test/test_slice.py
+++ b/Lib/test/test_slice.py
@@ -236,7 +236,8 @@ class SliceTest(unittest.TestCase):
         x[1:2] = 42
         self.assertEqual(tmp, [(slice(1, 2), 42)])
 
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: unexpected payload for __eq__")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_pickle(self):
         s = slice(10, 20, 3)
         for protocol in (0,1,2):
diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py
index 0e51925a2..9e1e7e99a 100644
--- a/Lib/test/test_unicode.py
+++ b/Lib/test/test_unicode.py
@@ -1341,7 +1341,8 @@ class UnicodeTest(string_tests.CommonTest,
         with self.assertRaises(ValueError):
             result = format(2.34, format_string)
 
-    @unittest.skip("TODO: RUSTPYTHON, IndexError: tuple index out of range")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_format_huge_item_number(self):
         format_string = "{{{}:.6f}}".format(sys.maxsize + 1)
         with self.assertRaises(ValueError):
diff --git a/Lib/test/test_unicode_file.py b/Lib/test/test_unicode_file.py
index c8576058d..dc72c723c 100644
--- a/Lib/test/test_unicode_file.py
+++ b/Lib/test/test_unicode_file.py
@@ -117,7 +117,8 @@ class TestUnicodeFiles(unittest.TestCase):
 
     # The 'test' functions are unittest entry points, and simply call our
     # _test functions with each of the filename combinations we wish to test
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: utime: 'times' must be either a tuple of two ints or None")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_single_files(self):
         self._test_single(TESTFN_UNICODE)
         if TESTFN_UNENCODABLE is not None:
diff --git a/Lib/test/test_unicode_file_functions.py b/Lib/test/test_unicode_file_functions.py
index 4a7784735..a9986469c 100644
--- a/Lib/test/test_unicode_file_functions.py
+++ b/Lib/test/test_unicode_file_functions.py
@@ -92,7 +92,8 @@ class UnicodeFileTests(unittest.TestCase):
                              "with bad filename in the exception: %a" %
                              (fn.__name__, filename, exc_filename))
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: 'FileNotFoundError' object has no attribute 'filename'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_failures(self):
         # Pass non-existing Unicode filenames all over the place.
         for name in self.files:
@@ -110,7 +111,8 @@ class UnicodeFileTests(unittest.TestCase):
     else:
         _listdir_failure = NotADirectoryError
 
-    @unittest.skip("TODO: RUSTPYTHON, OSError: Not a directory (os error 20)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_open(self):
         for name in self.files:
             f = open(name, 'wb')
@@ -123,7 +125,8 @@ class UnicodeFileTests(unittest.TestCase):
     # NFD (a variant of Unicode NFD form). Normalize the filename to NFC, NFKC,
     # NFKD in Python is useless, because darwin will normalize it later and so
     # open(), os.stat(), etc. don't raise any exception.
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: 'FileNotFoundError' object has no attribute 'filename'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     @unittest.skipIf(sys.platform == 'darwin', 'irrelevant test on Mac OS X')
     def test_normalize(self):
         files = set(self.files)
diff --git a/Lib/test/test_unicode_identifiers.py b/Lib/test/test_unicode_identifiers.py
index dbd5cff5c..7bd5e5da5 100644
--- a/Lib/test/test_unicode_identifiers.py
+++ b/Lib/test/test_unicode_identifiers.py
@@ -2,7 +2,8 @@ import unittest
 
 class PEP3131Test(unittest.TestCase):
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: type object 'T' has no attribute 'μ'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_valid(self):
         class T:
             ä = 1
@@ -20,7 +21,8 @@ class PEP3131Test(unittest.TestCase):
         𝔘𝔫𝔦𝔠𝔬𝔡𝔢 = 1
         self.assertIn("Unicode", dir())
 
-    @unittest.skip("TODO: RUSTPYTHON, ImportError: cannot import name 'badsyntax_3131'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_invalid(self):
         try:
             from test import badsyntax_3131
diff --git a/Lib/test/test_unicodedata.py b/Lib/test/test_unicodedata.py
index f526daced..e6cf0c367 100644
--- a/Lib/test/test_unicodedata.py
+++ b/Lib/test/test_unicodedata.py
@@ -22,7 +22,8 @@ class UnicodeMethodsTest(unittest.TestCase):
     # update this, if the database changes
     expectedchecksum = '9129d6f2bdf008a81c2476e5b5127014a62130c1'
 
-    @unittest.skip("TODO: RUSTPYTHON, ValueError: chr() arg not in range(0x110000)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_method_checksum(self):
         h = hashlib.sha1()
         for i in range(0x10000):
@@ -82,7 +83,8 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
     # Update this if the database changes. Make sure to do a full rebuild
     # (e.g. 'make distclean && make') to get the correct checksum.
     expectedchecksum = 'c44a49ca7c5cb6441640fe174ede604b45028652'
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'digit'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_function_checksum(self):
         data = []
         h = hashlib.sha1()
@@ -104,7 +106,8 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
         result = h.hexdigest()
         self.assertEqual(result, self.expectedchecksum)
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'digit'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_digit(self):
         self.assertEqual(self.db.digit('A', None), None)
         self.assertEqual(self.db.digit('9'), 9)
@@ -117,7 +120,8 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
         self.assertRaises(TypeError, self.db.digit, 'xx')
         self.assertRaises(ValueError, self.db.digit, 'x')
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'numeric'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_numeric(self):
         self.assertEqual(self.db.numeric('A',None), None)
         self.assertEqual(self.db.numeric('9'), 9)
@@ -131,7 +135,8 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
         self.assertRaises(TypeError, self.db.numeric, 'xx')
         self.assertRaises(ValueError, self.db.numeric, 'x')
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'decimal'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_decimal(self):
         self.assertEqual(self.db.decimal('A',None), None)
         self.assertEqual(self.db.decimal('9'), 9)
@@ -165,7 +170,8 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
         self.assertRaises(TypeError, self.db.bidirectional)
         self.assertRaises(TypeError, self.db.bidirectional, 'xx')
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'decomposition'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_decomposition(self):
         self.assertEqual(self.db.decomposition('\uFFFE'),'')
         self.assertEqual(self.db.decomposition('\u00bc'), '<fraction> 0031 2044 0034')
@@ -173,7 +179,8 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
         self.assertRaises(TypeError, self.db.decomposition)
         self.assertRaises(TypeError, self.db.decomposition, 'xx')
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'mirrored'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_mirrored(self):
         self.assertEqual(self.db.mirrored('\uFFFE'), 0)
         self.assertEqual(self.db.mirrored('a'), 0)
@@ -183,7 +190,8 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
         self.assertRaises(TypeError, self.db.mirrored)
         self.assertRaises(TypeError, self.db.mirrored, 'xx')
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'combining'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_combining(self):
         self.assertEqual(self.db.combining('\uFFFE'), 0)
         self.assertEqual(self.db.combining('a'), 0)
@@ -235,7 +243,8 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
     # For tests of unicodedata.is_normalized / self.db.is_normalized ,
     # see test_normalization.py .
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'east_asian_width'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_east_asian_width(self):
         eaw = self.db.east_asian_width
         self.assertRaises(TypeError, eaw, b'a')
@@ -250,7 +259,8 @@ class UnicodeFunctionsTest(UnicodeDatabaseTest):
         self.assertEqual(eaw('\u2010'), 'A')
         self.assertEqual(eaw('\U00020000'), 'W')
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: 'UCD' object has no attribute 'east_asian_width'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_east_asian_width_9_0_changes(self):
         self.assertEqual(self.db.ucd_3_2_0.east_asian_width('\u231a'), 'N')
         self.assertEqual(self.db.east_asian_width('\u231a'), 'W')
@@ -275,7 +285,8 @@ class UnicodeMiscTest(UnicodeDatabaseTest):
             "(can't load unicodedata module)"
         self.assertIn(error, result.err.decode("ascii"))
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'decimal'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_decimal_numeric_consistent(self):
         # Test that decimal and numeric are consistent,
         # i.e. if a character has a decimal value,
@@ -289,7 +300,8 @@ class UnicodeMiscTest(UnicodeDatabaseTest):
                 count += 1
         self.assertTrue(count >= 10) # should have tested at least the ASCII digits
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'digit'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_digit_numeric_consistent(self):
         # Test that digit and numeric are consistent,
         # i.e. if a character has a digit value,
@@ -306,7 +318,8 @@ class UnicodeMiscTest(UnicodeDatabaseTest):
     def test_bug_1704793(self):
         self.assertEqual(self.db.lookup("GOTHIC LETTER FAIHU"), '\U00010346')
 
-    @unittest.skip("TODO: RUSTPYTHON, AttributeError: module 'unicodedata' has no attribute 'mirrored'")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_ucd_510(self):
         import unicodedata
         # In UCD 5.1.0, a mirrored property changed wrt. UCD 3.2.0
@@ -318,7 +331,8 @@ class UnicodeMiscTest(UnicodeDatabaseTest):
         self.assertTrue("\u1d79".upper()=='\ua77d')
         self.assertTrue(".".upper()=='.')
 
-    @unittest.skip("TODO: RUSTPYTHON, ValueError: chr() arg not in range(0x110000)")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_bug_5828(self):
         self.assertEqual("\u1d79".lower(), "\u1d79")
         # Only U+0000 should have U+0000 as its upper/lower/titlecase variant