Exception Chaining missing method for suppressing context

Lib/test/test_raise.py

 # Copyright 2007 Google, Inc. All Rights Reserved.
 # Licensed to PSF under a Contributor Agreement.
 
 """Tests for the raise statement."""
 
-from test import support
+from test import support, script_helper
+import re
 import sys
 import types
 import unittest
 
 
+try:
+    from resource import setrlimit, RLIMIT_CORE, error as resource_error
+except ImportError:
+    prepare_subprocess = None
+else:
+    def prepare_subprocess():
+        # don't create core file
+        try:
+            setrlimit(RLIMIT_CORE, (0, 0))
+        except (ValueError, resource_error):
+            pass
+
+
+
 def get_tb():
     try:
         raise OSError()
     except:
         return sys.exc_info()[2]
 
 
 class Context:
     def __enter__(self):
         return self
@@ skipping 47 matching lines @@
 
     def test_nested_reraise(self):
         def nested_reraise():
             raise
         def reraise():
             try:
                 raise TypeError("foo")
             except:
                 nested_reraise()
         self.assertRaises(TypeError, reraise)
+
+    def test_raise_from_None(self):
+        try:
+            try:
+                raise TypeError("foo")
+            except:
+                raise ValueError() from None
+        except ValueError as e:
+            self.assertTrue(isinstance(e.__context__, TypeError))
+            self.assertIsNone(e.__cause__)
 
     def test_with_reraise1(self):
         def reraise():
             try:
                 raise TypeError("foo")
             except:
                 with Context():
                     pass
                 raise
         self.assertRaises(TypeError, reraise)
@@ skipping 43 matching lines @@
 
     def test_assert_with_tuple_arg(self):
         try:
             assert False, (3,)
         except AssertionError as e:
             self.assertEqual(str(e), "(3,)")
 
 
 
 class TestCause(unittest.TestCase):
+
+    def testCauseSyntax(self):
+        try:
+            try:
+                try:
+                    raise TypeError
+                except Exception:
+                    raise ValueError from None
+            except ValueError as exc:
+                self.assertIsNone(exc.__cause__)
+                raise exc from Ellipsis
+        except ValueError as exc:
+            e = exc
+            
+        self.assertIs(e.__cause__, Ellipsis)
+        self.assertIsInstance(e.__context__, TypeError)
+
     def test_invalid_cause(self):
         try:
             raise IndexError from 5
         except TypeError as e:
             self.assertIn("exception cause", str(e))
         else:
             self.fail("No exception raised")
 
     def test_class_cause(self):
         try:
@@ skipping 19 matching lines @@
 
         try:
             raise IndexError from MyException
         except RuntimeError:
             pass
         else:
             self.fail("No exception raised")
 
 
 class TestTraceback(unittest.TestCase):
+
+    def get_output(self, code, filename=None):
+        """
+        Run the specified code in Python (in a new child process) and read the
+        output from the standard error or from a file (if filename is set).
+        Return the output lines as a list.
+        """
+        options = {}
+        if prepare_subprocess:
+            options['preexec_fn'] = prepare_subprocess
+        process = script_helper.spawn_python('-c', code, **options)
+        stdout, stderr = process.communicate()
+        exitcode = process.wait()
+        output = support.strip_python_stderr(stdout)
+        output = output.decode('ascii', 'backslashreplace')
+        if filename:
+            self.assertEqual(output, '')
+            with open(filename, "rb") as fp:
+                output = fp.read()
+            output = output.decode('ascii', 'backslashreplace')
+        output = re.sub('Current thread 0x[0-9a-f]+',
+                        'Current thread XXX',
+                        output)
+        return output.splitlines(), exitcode
+
+    def test_traceback_verbiage(self):
+        code = """
+try:
+    raise ValueError
+except:
+    raise NameError from None
+"""
+        text, exitcode = self.get_output(code)
+        self.assertEqual(len(text), 3)
+        self.assertTrue(text[0].startswith('Traceback'))
+        self.assertTrue(text[1].startswith('  File '))
+        self.assertTrue(text[2].startswith('NameError'))
+
     def test_sets_traceback(self):
         try:
             raise IndexError()
         except IndexError as e:
             self.assertIsInstance(e.__traceback__, types.TracebackType)
         else:
             self.fail("No exception raised")
 
     def test_accepts_traceback(self):
         tb = get_tb()
@@ skipping 190 matching lines @@
             pass
         else:
             self.fail("No exception raised")
 
 
 def test_main():
     support.run_unittest(__name__)
 
 if __name__ == "__main__":
     unittest.main()