Unblock some tests

Author: slozier

Src/IronPythonTest/Cases/CPythonCasesManifest.ini

@@ -1173,9 +1173,6 @@ Ignore=true # blocking
 [CPython.test_base64]
 Ignore=true # https://github.com/IronLanguages/ironpython3/issues/1135
 
-[CPython.test_baseexception]
-Ignore=true # ModuleNotFoundError
-
 [CPython.test_bytes]
 Ignore=true # 5 failures
 
@@ -1219,10 +1216,10 @@ Ignore=true # AssertionError: 5 != 4
 Ignore=true # blocked by https://github.com/IronLanguages/ironpython3/issues/98
 
 [CPython.test_hashlib]
-Ignore=true # NameError: name 'ModuleNotFoundError' is not defined
+Ignore=true # AttributeError: 'module' object has no attribute 'shake_128'
 
 [CPython.test_int]
-Ignore=true # blocked by test_grammar
+Ignore=true # blocked by https://github.com/IronLanguages/ironpython3/issues/105
 
 [CPython.test_linecache]
 Ignore=true # two failures
@@ -1284,9 +1281,6 @@ Ignore=true # AssertionError: DeprecationWarning not triggered
 [CPython.test_support]
 Ignore=true # lots of failures
 
-[CPython.test_tokenize]
-Ignore=true # blocked by test_grammar
-
 [CPython.test_unpack]
 Ignore=true # 4 failures
 
@@ -1300,7 +1294,7 @@ Ignore=true # blocking
 Ignore=true # LookupError: unknown encoding: oem
 
 [CPython.test_winreg]
-Ignore=true # NameError: name 'REG_QWORD' is not defined
+Ignore=true # 3 failures
 
 [CPython.test_winsound]
 Ignore=true # test_keyword_args

Src/IronPythonTest/Cases/IronPythonCasesManifest.ini

@@ -179,17 +179,14 @@ Ignore=true # test_doc
 [IronPython.test_builtin_stdlib]
 Ignore=true # NameError: name 'ModuleNotFoundError' is not defined / multiple other things
 
-[IronPython.test_bz2_stdlib]
-Ignore=true # TypeError: integer argument expected, got 'WindowsPath'
-
 [IronPython.test_codecs_stdlib]
 Ignore=true # multiple failures
 
 [IronPython.test_codeccallbacks_stdlib]
 Ignore=true # multiple failures
 
 [IronPython.test_complex_stdlib]
-Ignore=true # blocked by test_grammar
+Ignore=true # 1 failure https://github.com/IronLanguages/ironpython3/issues/105
 
 [IronPython.test_datetime_stdlib]
 Ignore=true # multiple failures
@@ -198,7 +195,7 @@ Ignore=true # multiple failures
 Ignore=true # blocking
 
 [IronPython.test_float_stdlib]
-Ignore=true # blocked by test_grammar
+Ignore=true # 2 failures https://github.com/IronLanguages/ironpython3/issues/105
 
 [IronPython.test_functools_stdlib]
 Ignore=true # StackOverflowException

Src/StdLib/Lib/test/ann_module.py

@@ -5,6 +5,8 @@
 Empty lines above are for good reason (testing for correct line numbers)
 """
 
+__annotations__ = {} # https://github.com/IronLanguages/ironpython3/issues/106
+
 from typing import Optional
 
 __annotations__[1] = 2

Src/StdLib/Lib/test/test_grammar.py

@@ -1415,76 +1415,77 @@ def __imatmul__(self, o):
         m @= 42
         self.assertEqual(m.other, 42)
 
-    def test_async_await(self):
-        async def test():
-            def sum():
-                pass
-            if 1:
-                await someobj()
-
-        self.assertEqual(test.__name__, 'test')
-        self.assertTrue(bool(test.__code__.co_flags & inspect.CO_COROUTINE))
-
-        def decorator(func):
-            setattr(func, '_marked', True)
-            return func
-
-        @decorator
-        async def test2():
-            return 22
-        self.assertTrue(test2._marked)
-        self.assertEqual(test2.__name__, 'test2')
-        self.assertTrue(bool(test2.__code__.co_flags & inspect.CO_COROUTINE))
-
-    def test_async_for(self):
-        class Done(Exception): pass
-
-        class AIter:
-            def __aiter__(self):
-                return self
-            async def __anext__(self):
-                raise StopAsyncIteration
-
-        async def foo():
-            async for i in AIter():
-                pass
-            async for i, j in AIter():
-                pass
-            async for i in AIter():
-                pass
-            else:
-                pass
-            raise Done
-
-        with self.assertRaises(Done):
-            foo().send(None)
-
-    def test_async_with(self):
-        class Done(Exception): pass
-
-        class manager:
-            async def __aenter__(self):
-                return (1, 2)
-            async def __aexit__(self, *exc):
-                return False
-
-        async def foo():
-            async with manager():
-                pass
-            async with manager() as x:
-                pass
-            async with manager() as (x, y):
-                pass
-            async with manager(), manager():
-                pass
-            async with manager() as x, manager() as y:
-                pass
-            async with manager() as x, manager():
-                pass
-            raise Done
-
-        with self.assertRaises(Done):
-            foo().send(None)
+# https://github.com/IronLanguages/ironpython3/issues/1428
+#    def test_async_await(self):
+#        async def test():
+#            def sum():
+#                pass
+#            if 1:
+#                await someobj()
+#
+#        self.assertEqual(test.__name__, 'test')
+#        self.assertTrue(bool(test.__code__.co_flags & inspect.CO_COROUTINE))
+#
+#        def decorator(func):
+#            setattr(func, '_marked', True)
+#            return func
+#
+#        @decorator
+#        async def test2():
+#            return 22
+#        self.assertTrue(test2._marked)
+#        self.assertEqual(test2.__name__, 'test2')
+#        self.assertTrue(bool(test2.__code__.co_flags & inspect.CO_COROUTINE))
+#
+#    def test_async_for(self):
+#        class Done(Exception): pass
+#
+#        class AIter:
+#            def __aiter__(self):
+#                return self
+#            async def __anext__(self):
+#                raise StopAsyncIteration
+#
+#        async def foo():
+#            async for i in AIter():
+#                pass
+#            async for i, j in AIter():
+#                pass
+#            async for i in AIter():
+#                pass
+#            else:
+#                pass
+#            raise Done
+#
+#        with self.assertRaises(Done):
+#            foo().send(None)
+#
+#    def test_async_with(self):
+#        class Done(Exception): pass
+#
+#        class manager:
+#            async def __aenter__(self):
+#                return (1, 2)
+#            async def __aexit__(self, *exc):
+#                return False
+#
+#        async def foo():
+#            async with manager():
+#                pass
+#            async with manager() as x:
+#                pass
+#            async with manager() as (x, y):
+#                pass
+#            async with manager(), manager():
+#                pass
+#            async with manager() as x, manager() as y:
+#                pass
+#            async with manager() as x, manager():
+#                pass
+#            raise Done
+#
+#        with self.assertRaises(Done):
+#            foo().send(None)
 
 
 if __name__ == '__main__':

Src/StdLib/Lib/typing.py

@@ -1975,30 +1975,30 @@ class AsyncContextManager(Generic[T_co],
         __slots__ = ()
 
     __all__.append('AsyncContextManager')
-elif sys.version_info[:2] >= (3, 5):
-    exec("""
-class AsyncContextManager(Generic[T_co]):
-    __slots__ = ()
-
-    async def __aenter__(self):
-        return self
-
-    @abc.abstractmethod
-    async def __aexit__(self, exc_type, exc_value, traceback):
-        return None
-
-    @classmethod
-    def __subclasshook__(cls, C):
-        if cls is AsyncContextManager:
-            if sys.version_info[:2] >= (3, 6):
-                return _collections_abc._check_methods(C, "__aenter__", "__aexit__")
-            if (any("__aenter__" in B.__dict__ for B in C.__mro__) and
-                    any("__aexit__" in B.__dict__ for B in C.__mro__)):
-                return True
-        return NotImplemented
-
-__all__.append('AsyncContextManager')
-""")
+#elif sys.version_info[:2] >= (3, 5):
+#    exec("""
+#class AsyncContextManager(Generic[T_co]):
+#    __slots__ = ()
+#
+#    async def __aenter__(self):
+#        return self
+#
+#    @abc.abstractmethod
+#    async def __aexit__(self, exc_type, exc_value, traceback):
+#        return None
+#
+#    @classmethod
+#    def __subclasshook__(cls, C):
+#        if cls is AsyncContextManager:
+#            if sys.version_info[:2] >= (3, 6):
+#                return _collections_abc._check_methods(C, "__aenter__", "__aexit__")
+#            if (any("__aenter__" in B.__dict__ for B in C.__mro__) and
+#                    any("__aexit__" in B.__dict__ for B in C.__mro__)):
+#                return True
+#        return NotImplemented
+#
+#__all__.append('AsyncContextManager')
+#""")
 
 
 class Dict(dict, MutableMapping[KT, VT], extra=dict):