Fix some test on python 3.9 (nightly).

Mostly

1) Pgen parser does not raise MemorryError anymore.
2) Function signature now understand "Optinal" correctly

IPython/core/tests/test_async_helpers.py

@@ -1,313 +1,316 b''
 """
 Test for async helpers. 
 
 Should only trigger on python 3.5+ or will have syntax errors.
 """
 from itertools import chain, repeat
 import nose.tools as nt
 from textwrap import dedent, indent
 from unittest import TestCase
 from IPython.testing.decorators import skip_without
-
+import sys
 
 iprc = lambda x: ip.run_cell(dedent(x)).raise_error()
 iprc_nr = lambda x: ip.run_cell(dedent(x))
 
 from IPython.core.async_helpers import _should_be_async
 
 class AsyncTest(TestCase):
     def test_should_be_async(self):
         nt.assert_false(_should_be_async("False"))
         nt.assert_true(_should_be_async("await bar()"))
         nt.assert_true(_should_be_async("x = await bar()"))
         nt.assert_false(
             _should_be_async(
                 dedent(
                     """
             async def awaitable():
                 pass
         """
                 )
             )
         )
 
     def _get_top_level_cases(self):
         # These are test cases that should be valid in a function
         # but invalid outside of a function.
         test_cases = []
         test_cases.append(('basic', "{val}"))
 
         # Note, in all conditional cases, I use True instead of
         # False so that the peephole optimizer won't optimize away
         # the return, so CPython will see this as a syntax error:
         #
         # while True:
         #    break
         #    return
         #
         # But not this:
         #
         # while False:
         #    return
         #
         # See https://bugs.python.org/issue1875
 
         test_cases.append(('if', dedent("""
         if True:
             {val}
         """)))
 
         test_cases.append(('while', dedent("""
         while True:
             {val}
             break
         """)))
 
         test_cases.append(('try', dedent("""
         try:
             {val}
         except:
             pass
         """)))
 
         test_cases.append(('except', dedent("""
         try:
             pass
         except:
             {val}
         """)))
 
         test_cases.append(('finally', dedent("""
         try:
             pass
         except:
             pass
         finally:
             {val}
         """)))
 
         test_cases.append(('for', dedent("""
         for _ in range(4):
             {val}
         """)))
 
 
         test_cases.append(('nested', dedent("""
         if True:
             while True:
                 {val}
                 break
         """)))
 
         test_cases.append(('deep-nested', dedent("""
         if True:
             while True:
                 break
                 for x in range(3):
                     if True:
                         while True:
                             for x in range(3):
                                 {val}
         """)))
 
         return test_cases
 
     def _get_ry_syntax_errors(self):
         # This is a mix of tests that should be a syntax error if
         # return or yield whether or not they are in a function
 
         test_cases = []
 
         test_cases.append(('class', dedent("""
         class V:
             {val}
         """)))
 
         test_cases.append(('nested-class', dedent("""
         class V:
             class C:
                 {val}
         """)))
 
         return test_cases
 
 
     def test_top_level_return_error(self):
         tl_err_test_cases = self._get_top_level_cases()
         tl_err_test_cases.extend(self._get_ry_syntax_errors())
 
         vals = ('return', 'yield', 'yield from (_ for _ in range(3))',
                 dedent('''
                     def f():
                         pass
                     return
                     '''),
                 )
 
         for test_name, test_case in tl_err_test_cases:
             # This example should work if 'pass' is used as the value
             with self.subTest((test_name, 'pass')):
                 iprc(test_case.format(val='pass'))
 
             # It should fail with all the values
             for val in vals:
                 with self.subTest((test_name, val)):
                     msg = "Syntax error not raised for %s, %s" % (test_name, val)
                     with self.assertRaises(SyntaxError, msg=msg):
                         iprc(test_case.format(val=val))
 
     def test_in_func_no_error(self):
         # Test that the implementation of top-level return/yield
         # detection isn't *too* aggressive, and works inside a function
         func_contexts = []
 
         func_contexts.append(('func', False, dedent("""
         def f():""")))
 
         func_contexts.append(('method', False, dedent("""
         class MyClass:
             def __init__(self):
         """)))
 
         func_contexts.append(('async-func', True,  dedent("""
         async def f():""")))
 
         func_contexts.append(('async-method', True,  dedent("""
         class MyClass:
             async def f(self):""")))
 
         func_contexts.append(('closure', False, dedent("""
         def f():
             def g():
         """)))
 
         def nest_case(context, case):
             # Detect indentation
             lines = context.strip().splitlines()
             prefix_len = 0
             for c in lines[-1]:
                 if c != ' ':
                     break
                 prefix_len += 1
 
             indented_case = indent(case, ' ' * (prefix_len + 4))
             return context + '\n' + indented_case
 
         # Gather and run the tests
 
         # yield is allowed in async functions, starting in Python 3.6,
         # and yield from is not allowed in any version
         vals = ('return', 'yield', 'yield from (_ for _ in range(3))')
         async_safe = (True,
                         True,
                         False)
         vals = tuple(zip(vals, async_safe))
 
         success_tests = zip(self._get_top_level_cases(), repeat(False))
         failure_tests = zip(self._get_ry_syntax_errors(), repeat(True))
 
         tests = chain(success_tests, failure_tests)
 
         for context_name, async_func, context in func_contexts:
             for (test_name, test_case), should_fail in tests:
                 nested_case = nest_case(context, test_case)
 
                 for val, async_safe in vals:
                     val_should_fail = (should_fail or
                                         (async_func and not async_safe))
 
                     test_id = (context_name, test_name, val)
                     cell = nested_case.format(val=val)
 
                     with self.subTest(test_id):
                         if val_should_fail:
                             msg = ("SyntaxError not raised for %s" %
                                     str(test_id))
                             with self.assertRaises(SyntaxError, msg=msg):
                                 iprc(cell)
 
                                 print(cell)
                         else:
                             iprc(cell)
 
     def test_nonlocal(self):
         # fails if outer scope is not a function scope or if var not defined
         with self.assertRaises(SyntaxError):
             iprc("nonlocal x")
             iprc("""
             x = 1
             def f():
                 nonlocal x
                 x = 10000
                 yield x
             """)
             iprc("""
             def f():
                 def g():
                     nonlocal x
                     x = 10000
                     yield x
             """)
 
         # works if outer scope is a function scope and var exists
         iprc("""
         def f():
             x = 20
             def g():
                 nonlocal x
                 x = 10000
                 yield x
         """)
 
 
     def test_execute(self):
         iprc("""
         import asyncio
         await asyncio.sleep(0.001)
         """
         )
 
     def test_autoawait(self):
         iprc("%autoawait False")
         iprc("%autoawait True")
         iprc("""
         from asyncio import sleep
         await sleep(0.1)
         """
         )
-
-    def test_memory_error(self):
-        with self.assertRaises(MemoryError):
-            iprc("(" * 200 + ")" * 200)
+    
+    if sys.version_info < (3,9):
+        # new pgen parser in 3.9 does not raise MemoryError on too many nested
+        # parens anymore
+        def test_memory_error(self):
+            with self.assertRaises(MemoryError):
+                iprc("(" * 200 + ")" * 200)
 
     @skip_without('curio')
     def test_autoawait_curio(self):
         iprc("%autoawait curio")
 
     @skip_without('trio')
     def test_autoawait_trio(self):
         iprc("%autoawait trio")
 
     @skip_without('trio')
     def test_autoawait_trio_wrong_sleep(self):
         iprc("%autoawait trio")
         res = iprc_nr("""
         import asyncio
         await asyncio.sleep(0)
         """)
         with nt.assert_raises(TypeError):
             res.raise_error()
 
     @skip_without('trio')
     def test_autoawait_asyncio_wrong_sleep(self):
         iprc("%autoawait asyncio")
         res = iprc_nr("""
         import trio
         await trio.sleep(0)
         """)
         with nt.assert_raises(RuntimeError):
             res.raise_error()
 
 
     def tearDown(self):
         ip.loop_runner = "asyncio"

IPython/core/tests/test_oinspect.py

@@ -1,439 +1,447 b''
 """Tests for the object inspection functionality.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 from inspect import signature, Signature, Parameter
 import os
 import re
 
 import nose.tools as nt
 
 from .. import oinspect
 
 from decorator import decorator
 
 from IPython.testing.tools import AssertPrints, AssertNotPrints
 from IPython.utils.path import compress_user
 
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 inspector = None
 
 def setup_module():
     global inspector
     inspector = oinspect.Inspector()
 
 
 #-----------------------------------------------------------------------------
 # Local utilities
 #-----------------------------------------------------------------------------
 
 # WARNING: since this test checks the line number where a function is
 # defined, if any code is inserted above, the following line will need to be
 # updated.  Do NOT insert any whitespace between the next line and the function
 # definition below.
 THIS_LINE_NUMBER = 41  # Put here the actual number of this line
 
 from unittest import TestCase
 
 class Test(TestCase):
 
     def test_find_source_lines(self):
         self.assertEqual(oinspect.find_source_lines(Test.test_find_source_lines),
                     THIS_LINE_NUMBER+6)
 
 
 # A couple of utilities to ensure these tests work the same from a source or a
 # binary install
 def pyfile(fname):
     return os.path.normcase(re.sub('.py[co]$', '.py', fname))
 
 
 def match_pyfiles(f1, f2):
     nt.assert_equal(pyfile(f1), pyfile(f2))
 
 
 def test_find_file():
     match_pyfiles(oinspect.find_file(test_find_file), os.path.abspath(__file__))
 
 
 def test_find_file_decorated1():
 
     @decorator
     def noop1(f):
         def wrapper(*a, **kw):
             return f(*a, **kw)
         return wrapper
 
     @noop1
     def f(x):
         "My docstring"
     
     match_pyfiles(oinspect.find_file(f), os.path.abspath(__file__))
     nt.assert_equal(f.__doc__, "My docstring")
 
 
 def test_find_file_decorated2():
 
     @decorator
     def noop2(f, *a, **kw):
         return f(*a, **kw)
 
     @noop2
     @noop2
     @noop2
     def f(x):
         "My docstring 2"
     
     match_pyfiles(oinspect.find_file(f), os.path.abspath(__file__))
     nt.assert_equal(f.__doc__, "My docstring 2")
     
 
 def test_find_file_magic():
     run = ip.find_line_magic('run')
     nt.assert_not_equal(oinspect.find_file(run), None)
 
 
 # A few generic objects we can then inspect in the tests below
 
 class Call(object):
     """This is the class docstring."""
 
     def __init__(self, x, y=1):
         """This is the constructor docstring."""
 
     def __call__(self, *a, **kw):
         """This is the call docstring."""
 
     def method(self, x, z=2):
         """Some method's docstring"""
 
 class HasSignature(object):
     """This is the class docstring."""
     __signature__ = Signature([Parameter('test', Parameter.POSITIONAL_OR_KEYWORD)])
 
     def __init__(self, *args):
         """This is the init docstring"""
 
 
 class SimpleClass(object):
     def method(self, x, z=2):
         """Some method's docstring"""
 
 
 class Awkward(object):
     def __getattr__(self, name):
         raise Exception(name)
 
 class NoBoolCall:
     """
     callable with `__bool__` raising should still be inspect-able.
     """
 
     def __call__(self):
         """does nothing"""
         pass
 
     def __bool__(self):
         """just raise NotImplemented"""
         raise NotImplementedError('Must be implemented')
 
 
 class SerialLiar(object):
     """Attribute accesses always get another copy of the same class.
 
     unittest.mock.call does something similar, but it's not ideal for testing
     as the failure mode is to eat all your RAM. This gives up after 10k levels.
     """
     def __init__(self, max_fibbing_twig, lies_told=0):
         if lies_told > 10000:
             raise RuntimeError('Nose too long, honesty is the best policy')
         self.max_fibbing_twig = max_fibbing_twig
         self.lies_told = lies_told
         max_fibbing_twig[0] = max(max_fibbing_twig[0], lies_told)
 
     def __getattr__(self, item):
         return SerialLiar(self.max_fibbing_twig, self.lies_told + 1)
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 def test_info():
     "Check that Inspector.info fills out various fields as expected."
     i = inspector.info(Call, oname='Call')
     nt.assert_equal(i['type_name'], 'type')
     expted_class = str(type(type))  # <class 'type'> (Python 3) or <type 'type'>
     nt.assert_equal(i['base_class'], expted_class)
     nt.assert_regex(i['string_form'], "<class 'IPython.core.tests.test_oinspect.Call'( at 0x[0-9a-f]{1,9})?>")
     fname = __file__
     if fname.endswith(".pyc"):
         fname = fname[:-1]
     # case-insensitive comparison needed on some filesystems
     # e.g. Windows:
     nt.assert_equal(i['file'].lower(), compress_user(fname).lower())
     nt.assert_equal(i['definition'], None)
     nt.assert_equal(i['docstring'], Call.__doc__)
     nt.assert_equal(i['source'], None)
     nt.assert_true(i['isclass'])
     nt.assert_equal(i['init_definition'], "Call(x, y=1)")
     nt.assert_equal(i['init_docstring'], Call.__init__.__doc__)
 
     i = inspector.info(Call, detail_level=1)
     nt.assert_not_equal(i['source'], None)
     nt.assert_equal(i['docstring'], None)
 
     c = Call(1)
     c.__doc__ = "Modified instance docstring"
     i = inspector.info(c)
     nt.assert_equal(i['type_name'], 'Call')
     nt.assert_equal(i['docstring'], "Modified instance docstring")
     nt.assert_equal(i['class_docstring'], Call.__doc__)
     nt.assert_equal(i['init_docstring'], Call.__init__.__doc__)
     nt.assert_equal(i['call_docstring'], Call.__call__.__doc__)
 
 def test_class_signature():
     info = inspector.info(HasSignature, 'HasSignature')
     nt.assert_equal(info['init_definition'], "HasSignature(test)")
     nt.assert_equal(info['init_docstring'], HasSignature.__init__.__doc__)
 
 def test_info_awkward():
     # Just test that this doesn't throw an error.
     inspector.info(Awkward())
 
 def test_bool_raise():
     inspector.info(NoBoolCall())
 
 def test_info_serialliar():
     fib_tracker = [0]
     inspector.info(SerialLiar(fib_tracker))
 
     # Nested attribute access should be cut off at 100 levels deep to avoid
     # infinite loops: https://github.com/ipython/ipython/issues/9122
     nt.assert_less(fib_tracker[0], 9000)
 
 def support_function_one(x, y=2, *a, **kw):
     """A simple function."""
 
 def test_calldef_none():
     # We should ignore __call__ for all of these.
     for obj in [support_function_one, SimpleClass().method, any, str.upper]:
         i = inspector.info(obj)
         nt.assert_is(i['call_def'], None)
 
 def f_kwarg(pos, *, kwonly):
     pass
 
 def test_definition_kwonlyargs():
     i = inspector.info(f_kwarg, oname='f_kwarg')  # analysis:ignore
     nt.assert_equal(i['definition'], "f_kwarg(pos, *, kwonly)")
 
 def test_getdoc():
     class A(object):
         """standard docstring"""
         pass
 
     class B(object):
         """standard docstring"""
         def getdoc(self):
             return "custom docstring"
     
     class C(object):
         """standard docstring"""
         def getdoc(self):
             return None
     
     a = A()
     b = B()
     c = C()
     
     nt.assert_equal(oinspect.getdoc(a), "standard docstring")
     nt.assert_equal(oinspect.getdoc(b), "custom docstring")
     nt.assert_equal(oinspect.getdoc(c), "standard docstring")
 
 
 def test_empty_property_has_no_source():
     i = inspector.info(property(), detail_level=1)
     nt.assert_is(i['source'], None)
 
 
 def test_property_sources():
     import posixpath 
     # A simple adder whose source and signature stays
     # the same across Python distributions
     def simple_add(a, b):
         "Adds two numbers"
         return a + b
     
     class A(object):
         @property
         def foo(self):
             return 'bar'
 
         foo = foo.setter(lambda self, v: setattr(self, 'bar', v))
 
         dname = property(posixpath.dirname)
         adder = property(simple_add) 
 
     i = inspector.info(A.foo, detail_level=1)
     nt.assert_in('def foo(self):', i['source'])
     nt.assert_in('lambda self, v:', i['source'])
 
     i = inspector.info(A.dname, detail_level=1)
     nt.assert_in('def dirname(p)', i['source'])
     
     i = inspector.info(A.adder, detail_level=1)
     nt.assert_in('def simple_add(a, b)', i['source'])
 
 
 def test_property_docstring_is_in_info_for_detail_level_0():
     class A(object):
         @property
         def foobar(self):
             """This is `foobar` property."""
             pass
 
     ip.user_ns['a_obj'] = A()
     nt.assert_equal(
         'This is `foobar` property.',
         ip.object_inspect('a_obj.foobar', detail_level=0)['docstring'])
 
     ip.user_ns['a_cls'] = A
     nt.assert_equal(
         'This is `foobar` property.',
         ip.object_inspect('a_cls.foobar', detail_level=0)['docstring'])
 
 
 def test_pdef():
     # See gh-1914
     def foo(): pass
     inspector.pdef(foo, 'foo')
 
 
 def test_pinfo_nonascii():
     # See gh-1177
     from . import nonascii2
     ip.user_ns['nonascii2'] = nonascii2
     ip._inspect('pinfo', 'nonascii2', detail_level=1)
 
 def test_pinfo_type():
     """
     type can fail in various edge case, for example `type.__subclass__()`
     """
     ip._inspect('pinfo', 'type')
 
 
 def test_pinfo_docstring_no_source():
     """Docstring should be included with detail_level=1 if there is no source"""
     with AssertPrints('Docstring:'):
         ip._inspect('pinfo', 'str.format', detail_level=0)
     with AssertPrints('Docstring:'):
         ip._inspect('pinfo', 'str.format', detail_level=1)
 
 
 def test_pinfo_no_docstring_if_source():
     """Docstring should not be included with detail_level=1 if source is found"""
     def foo():
         """foo has a docstring"""
 
     ip.user_ns['foo'] = foo
 
     with AssertPrints('Docstring:'):
         ip._inspect('pinfo', 'foo', detail_level=0)
     with AssertPrints('Source:'):
         ip._inspect('pinfo', 'foo', detail_level=1)
     with AssertNotPrints('Docstring:'):
         ip._inspect('pinfo', 'foo', detail_level=1)
 
 
 def test_pinfo_docstring_if_detail_and_no_source():
     """ Docstring should be displayed if source info not available """
     obj_def = '''class Foo(object):
                   """ This is a docstring for Foo """
                   def bar(self):
                       """ This is a docstring for Foo.bar """
                       pass
               ''' 
     
     ip.run_cell(obj_def)
     ip.run_cell('foo = Foo()')
     
     with AssertNotPrints("Source:"):
         with AssertPrints('Docstring:'):
             ip._inspect('pinfo', 'foo', detail_level=0)
         with AssertPrints('Docstring:'):
             ip._inspect('pinfo', 'foo', detail_level=1)
         with AssertPrints('Docstring:'):
             ip._inspect('pinfo', 'foo.bar', detail_level=0)
 
     with AssertNotPrints('Docstring:'):
         with AssertPrints('Source:'):
             ip._inspect('pinfo', 'foo.bar', detail_level=1)
 
 
 def test_pinfo_magic():
     with AssertPrints('Docstring:'):
         ip._inspect('pinfo', 'lsmagic', detail_level=0)
 
     with AssertPrints('Source:'):
         ip._inspect('pinfo', 'lsmagic', detail_level=1)
 
 
 def test_init_colors():
     # ensure colors are not present in signature info
     info = inspector.info(HasSignature)
     init_def = info['init_definition']
     nt.assert_not_in('[0m', init_def)
 
 
 def test_builtin_init():
     info = inspector.info(list)
     init_def = info['init_definition']
     nt.assert_is_not_none(init_def)
 
 
 def test_render_signature_short():
     def short_fun(a=1): pass
     sig = oinspect._render_signature(
         signature(short_fun),
         short_fun.__name__,
     )
     nt.assert_equal(sig, 'short_fun(a=1)')
 
 
 def test_render_signature_long():
     from typing import Optional
 
     def long_function(
         a_really_long_parameter: int,
         and_another_long_one: bool = False,
         let_us_make_sure_this_is_looong: Optional[str] = None,
     ) -> bool: pass
 
     sig = oinspect._render_signature(
         signature(long_function),
         long_function.__name__,
     )
     nt.assert_in(sig, [
+        # Python >=3.9
+        '''\
+long_function(
+    a_really_long_parameter: int,
+    and_another_long_one: bool = False,
+    let_us_make_sure_this_is_looong: Optional[str] = None,
+) -> bool\
+''',
         # Python >=3.7
         '''\
 long_function(
     a_really_long_parameter: int,
     and_another_long_one: bool = False,
     let_us_make_sure_this_is_looong: Union[str, NoneType] = None,
 ) -> bool\
 ''',  # Python <=3.6
         '''\
 long_function(
     a_really_long_parameter:int,
     and_another_long_one:bool=False,
     let_us_make_sure_this_is_looong:Union[str, NoneType]=None,
 ) -> bool\
 ''',
     ])

IPython/core/tests/test_ultratb.py

@@ -1,408 +1,412 b''
 # encoding: utf-8
 """Tests for IPython.core.ultratb
 """
 import io
 import logging
 import re
 import sys
 import os.path
 from textwrap import dedent
 import traceback
 import unittest
 
 from IPython.core.ultratb import ColorTB, VerboseTB
 
 
 from IPython.testing import tools as tt
 from IPython.testing.decorators import onlyif_unicode_paths
 from IPython.utils.syspathcontext import prepended_to_syspath
 from IPython.utils.tempdir import TemporaryDirectory
 
 file_1 = """1
 2
 3
 def f():
   1/0
 """
 
 file_2 = """def f():
   1/0
 """
 
 
 def recursionlimit(frames):
     """
     decorator to set the recursion limit temporarily
     """
 
     def inner(test_function):
         def wrapper(*args, **kwargs):
             rl = sys.getrecursionlimit()
             sys.setrecursionlimit(frames)
             try:
                 return test_function(*args, **kwargs)
             finally:
                 sys.setrecursionlimit(rl)
 
         return wrapper
 
     return inner
 
 
 class ChangedPyFileTest(unittest.TestCase):
     def test_changing_py_file(self):
         """Traceback produced if the line where the error occurred is missing?
         
         https://github.com/ipython/ipython/issues/1456
         """
         with TemporaryDirectory() as td:
             fname = os.path.join(td, "foo.py")
             with open(fname, "w") as f:
                 f.write(file_1)
             
             with prepended_to_syspath(td):
                 ip.run_cell("import foo")
             
             with tt.AssertPrints("ZeroDivisionError"):
                 ip.run_cell("foo.f()")
             
             # Make the file shorter, so the line of the error is missing.
             with open(fname, "w") as f:
                 f.write(file_2)
             
             # For some reason, this was failing on the *second* call after
             # changing the file, so we call f() twice.
             with tt.AssertNotPrints("Internal Python error", channel='stderr'):
                 with tt.AssertPrints("ZeroDivisionError"):
                     ip.run_cell("foo.f()")
                 with tt.AssertPrints("ZeroDivisionError"):
                     ip.run_cell("foo.f()")
 
 iso_8859_5_file = u'''# coding: iso-8859-5
 
 def fail():
     """дбИЖ"""
     1/0     # дбИЖ
 '''
 
 class NonAsciiTest(unittest.TestCase):
     @onlyif_unicode_paths
     def test_nonascii_path(self):
         # Non-ascii directory name as well.
         with TemporaryDirectory(suffix=u'é') as td:
             fname = os.path.join(td, u"fooé.py")
             with open(fname, "w") as f:
                 f.write(file_1)
             
             with prepended_to_syspath(td):
                 ip.run_cell("import foo")
             
             with tt.AssertPrints("ZeroDivisionError"):
                 ip.run_cell("foo.f()")
     
     def test_iso8859_5(self):
         with TemporaryDirectory() as td:
             fname = os.path.join(td, 'dfghjkl.py')
 
             with io.open(fname, 'w', encoding='iso-8859-5') as f:
                 f.write(iso_8859_5_file)
             
             with prepended_to_syspath(td):
                 ip.run_cell("from dfghjkl import fail")
             
             with tt.AssertPrints("ZeroDivisionError"):
                 with tt.AssertPrints(u'дбИЖ', suppress=False):
                     ip.run_cell('fail()')
     
     def test_nonascii_msg(self):
         cell = u"raise Exception('é')"
         expected = u"Exception('é')"
         ip.run_cell("%xmode plain")
         with tt.AssertPrints(expected):
             ip.run_cell(cell)
 
         ip.run_cell("%xmode verbose")
         with tt.AssertPrints(expected):
             ip.run_cell(cell)
 
         ip.run_cell("%xmode context")
         with tt.AssertPrints(expected):
             ip.run_cell(cell)
 
         ip.run_cell("%xmode minimal")
         with tt.AssertPrints(u"Exception: é"):
             ip.run_cell(cell)
 
         # Put this back into Context mode for later tests.
         ip.run_cell("%xmode context")
 
 class NestedGenExprTestCase(unittest.TestCase):
     """
     Regression test for the following issues:
     https://github.com/ipython/ipython/issues/8293
     https://github.com/ipython/ipython/issues/8205
     """
     def test_nested_genexpr(self):
         code = dedent(
             """\
             class SpecificException(Exception):
                 pass
 
             def foo(x):
                 raise SpecificException("Success!")
 
             sum(sum(foo(x) for _ in [0]) for x in [0])
             """
         )
         with tt.AssertPrints('SpecificException: Success!', suppress=False):
             ip.run_cell(code)
 
 
 indentationerror_file = """if True:
 zoon()
 """
 
 class IndentationErrorTest(unittest.TestCase):
     def test_indentationerror_shows_line(self):
         # See issue gh-2398
         with tt.AssertPrints("IndentationError"):
             with tt.AssertPrints("zoon()", suppress=False):
                 ip.run_cell(indentationerror_file)
         
         with TemporaryDirectory() as td:
             fname = os.path.join(td, "foo.py")
             with open(fname, "w") as f:
                 f.write(indentationerror_file)
             
             with tt.AssertPrints("IndentationError"):
                 with tt.AssertPrints("zoon()", suppress=False):
                     ip.magic('run %s' % fname)
 
 se_file_1 = """1
 2
 7/
 """
 
 se_file_2 = """7/
 """
 
 class SyntaxErrorTest(unittest.TestCase):
     def test_syntaxerror_without_lineno(self):
         with tt.AssertNotPrints("TypeError"):
             with tt.AssertPrints("line unknown"):
                 ip.run_cell("raise SyntaxError()")
 
     def test_syntaxerror_no_stacktrace_at_compile_time(self):
         syntax_error_at_compile_time = """
 def foo():
     ..
 """
         with tt.AssertPrints("SyntaxError"):
             ip.run_cell(syntax_error_at_compile_time)
 
         with tt.AssertNotPrints("foo()"):
             ip.run_cell(syntax_error_at_compile_time)
 
     def test_syntaxerror_stacktrace_when_running_compiled_code(self):
         syntax_error_at_runtime = """
 def foo():
     eval("..")
 
 def bar():
     foo()
 
 bar()
 """
         with tt.AssertPrints("SyntaxError"):
             ip.run_cell(syntax_error_at_runtime)
         # Assert syntax error during runtime generate stacktrace
         with tt.AssertPrints(["foo()", "bar()"]):
             ip.run_cell(syntax_error_at_runtime)
         del ip.user_ns['bar']
         del ip.user_ns['foo']
 
     def test_changing_py_file(self):
         with TemporaryDirectory() as td:
             fname = os.path.join(td, "foo.py")
             with open(fname, 'w') as f:
                 f.write(se_file_1)
 
             with tt.AssertPrints(["7/", "SyntaxError"]):
                 ip.magic("run " + fname)
 
             # Modify the file
             with open(fname, 'w') as f:
                 f.write(se_file_2)
 
             # The SyntaxError should point to the correct line
             with tt.AssertPrints(["7/", "SyntaxError"]):
                 ip.magic("run " + fname)
 
     def test_non_syntaxerror(self):
         # SyntaxTB may be called with an error other than a SyntaxError
         # See e.g. gh-4361
         try:
             raise ValueError('QWERTY')
         except ValueError:
             with tt.AssertPrints('QWERTY'):
                 ip.showsyntaxerror()
 
-
-class MemoryErrorTest(unittest.TestCase):
-    def test_memoryerror(self):
-        memoryerror_code = "(" * 200 + ")" * 200
-        with tt.AssertPrints("MemoryError"):
-            ip.run_cell(memoryerror_code)
+import sys
+if sys.version_info < (3,9):
+    """
+    New 3.9 Pgen Parser does not raise Memory error, except on failed malloc.
+    """
+    class MemoryErrorTest(unittest.TestCase):
+        def test_memoryerror(self):
+            memoryerror_code = "(" * 200 + ")" * 200
+            with tt.AssertPrints("MemoryError"):
+                ip.run_cell(memoryerror_code)
 
 
 class Python3ChainedExceptionsTest(unittest.TestCase):
     DIRECT_CAUSE_ERROR_CODE = """
 try:
     x = 1 + 2
     print(not_defined_here)
 except Exception as e:
     x += 55
     x - 1
     y = {}
     raise KeyError('uh') from e
     """
 
     EXCEPTION_DURING_HANDLING_CODE = """
 try:
     x = 1 + 2
     print(not_defined_here)
 except Exception as e:
     x += 55
     x - 1
     y = {}
     raise KeyError('uh')
     """
 
     SUPPRESS_CHAINING_CODE = """
 try:
     1/0
 except Exception:
     raise ValueError("Yikes") from None
     """
 
     def test_direct_cause_error(self):
         with tt.AssertPrints(["KeyError", "NameError", "direct cause"]):
             ip.run_cell(self.DIRECT_CAUSE_ERROR_CODE)
 
     def test_exception_during_handling_error(self):
         with tt.AssertPrints(["KeyError", "NameError", "During handling"]):
             ip.run_cell(self.EXCEPTION_DURING_HANDLING_CODE)
 
     def test_suppress_exception_chaining(self):
         with tt.AssertNotPrints("ZeroDivisionError"), \
              tt.AssertPrints("ValueError", suppress=False):
             ip.run_cell(self.SUPPRESS_CHAINING_CODE)
 
     def test_plain_direct_cause_error(self):
         with tt.AssertPrints(["KeyError", "NameError", "direct cause"]):
             ip.run_cell("%xmode Plain")
             ip.run_cell(self.DIRECT_CAUSE_ERROR_CODE)
             ip.run_cell("%xmode Verbose")
 
     def test_plain_exception_during_handling_error(self):
         with tt.AssertPrints(["KeyError", "NameError", "During handling"]):
             ip.run_cell("%xmode Plain")
             ip.run_cell(self.EXCEPTION_DURING_HANDLING_CODE)
             ip.run_cell("%xmode Verbose")
 
     def test_plain_suppress_exception_chaining(self):
         with tt.AssertNotPrints("ZeroDivisionError"), \
              tt.AssertPrints("ValueError", suppress=False):
             ip.run_cell("%xmode Plain")
             ip.run_cell(self.SUPPRESS_CHAINING_CODE)
             ip.run_cell("%xmode Verbose")
 
 
 class RecursionTest(unittest.TestCase):
     DEFINITIONS = """
 def non_recurs():
     1/0
 
 def r1():
     r1()
 
 def r3a():
     r3b()
 
 def r3b():
     r3c()
 
 def r3c():
     r3a()
 
 def r3o1():
     r3a()
 
 def r3o2():
     r3o1()
 """
     def setUp(self):
         ip.run_cell(self.DEFINITIONS)
 
     def test_no_recursion(self):
         with tt.AssertNotPrints("skipping similar frames"):
             ip.run_cell("non_recurs()")
 
     @recursionlimit(200)
     def test_recursion_one_frame(self):
         with tt.AssertPrints(re.compile(
             r"\[\.\.\. skipping similar frames: r1 at line 5 \(\d{2,3} times\)\]")
         ):
             ip.run_cell("r1()")
 
     @recursionlimit(200)
     def test_recursion_three_frames(self):
         with tt.AssertPrints("[... skipping similar frames: "), \
                 tt.AssertPrints(re.compile(r"r3a at line 8 \(\d{2} times\)"), suppress=False), \
                 tt.AssertPrints(re.compile(r"r3b at line 11 \(\d{2} times\)"), suppress=False), \
                 tt.AssertPrints(re.compile(r"r3c at line 14 \(\d{2} times\)"), suppress=False):
             ip.run_cell("r3o2()")
 
 
 #----------------------------------------------------------------------------
 
 # module testing (minimal)
 def test_handlers():
     def spam(c, d_e):
         (d, e) = d_e
         x = c + d
         y = c * d
         foo(x, y)
 
     def foo(a, b, bar=1):
         eggs(a, b + bar)
 
     def eggs(f, g, z=globals()):
         h = f + g
         i = f - g
         return h / i
 
     buff = io.StringIO()
 
     buff.write('')
     buff.write('*** Before ***')
     try:
         buff.write(spam(1, (2, 3)))
     except:
         traceback.print_exc(file=buff)
 
     handler = ColorTB(ostream=buff)
     buff.write('*** ColorTB ***')
     try:
         buff.write(spam(1, (2, 3)))
     except:
         handler(*sys.exc_info())
     buff.write('')
 
     handler = VerboseTB(ostream=buff)
     buff.write('*** VerboseTB ***')
     try:
         buff.write(spam(1, (2, 3)))
     except:
         handler(*sys.exc_info())
     buff.write('')