From 7359705232d49c2c2035f8edbf823b8023e2f7ef Mon Sep 17 00:00:00 2001 From: Guilherme Leobas Date: Tue, 20 May 2025 15:43:36 -0300 Subject: [PATCH] Add CPython tests for unittest (#150788) Tests: * test_assertions.py Pull Request resolved: https://github.com/pytorch/pytorch/pull/150788 Approved by: https://github.com/williamwen42 --- .../3_13/test_unittest/test_assertions.diff | 89 ++++ .../3_13/test_unittest/test_assertions.py | 469 ++++++++++++++++++ ...assertions-TestLongMessage.testAlmostEqual | 0 ...rtions-TestLongMessage.testAssertDictEqual | 0 ...assertions-TestLongMessage.testAssertFalse | 0 ...sertions-TestLongMessage.testAssertGreater | 0 ...ons-TestLongMessage.testAssertGreaterEqual | 0 ...st_assertions-TestLongMessage.testAssertIn | 0 ...st_assertions-TestLongMessage.testAssertIs | 0 ...ssertions-TestLongMessage.testAssertIsNone | 0 ...assertions-TestLongMessage.testAssertIsNot | 0 ...rtions-TestLongMessage.testAssertIsNotNone | 0 ..._assertions-TestLongMessage.testAssertLess | 0 ...rtions-TestLongMessage.testAssertLessEqual | 0 ...s-TestLongMessage.testAssertMultiLineEqual | 0 ...assertions-TestLongMessage.testAssertNotIn | 0 ...ertions-TestLongMessage.testAssertNotRegex | 0 ...ssertions-TestLongMessage.testAssertRaises | 0 ...ions-TestLongMessage.testAssertRaisesRegex | 0 ...assertions-TestLongMessage.testAssertRegex | 0 ...ns-TestLongMessage.testAssertSequenceEqual | 0 ...ertions-TestLongMessage.testAssertSetEqual | 0 ..._assertions-TestLongMessage.testAssertTrue | 0 ...assertions-TestLongMessage.testAssertWarns | 0 ...tions-TestLongMessage.testAssertWarnsRegex | 0 ...ertions-TestLongMessage.testNotAlmostEqual | 0 ...st_assertions-TestLongMessage.testNotEqual | 0 ...rtions-TestLongMessage.test_assertNotWarns | 0 ...tions-TestLongMessage.test_baseAssertEqual | 0 ..._assertions-TestLongMessage.test_formatMsg | 0 ...ertions-Test_Assertions.testAssertNotRegex | 0 ...s-Test_Assertions.test_AmostEqualWithDelta | 0 ...sertions.test_assertRaises_frames_survival | 0 33 files changed, 558 insertions(+) create mode 100644 test/dynamo/cpython/3_13/test_unittest/test_assertions.diff create mode 100644 test/dynamo/cpython/3_13/test_unittest/test_assertions.py create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAlmostEqual create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertDictEqual create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertFalse create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertGreater create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertGreaterEqual create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIn create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIs create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIsNone create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIsNot create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIsNotNone create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertLess create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertLessEqual create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertMultiLineEqual create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertNotIn create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertNotRegex create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertRaises create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertRaisesRegex create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertRegex create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertSequenceEqual create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertSetEqual create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertTrue create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertWarns create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertWarnsRegex create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testNotAlmostEqual create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testNotEqual create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.test_assertNotWarns create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.test_baseAssertEqual create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.test_formatMsg create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-Test_Assertions.testAssertNotRegex create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-Test_Assertions.test_AmostEqualWithDelta create mode 100644 test/dynamo_expected_failures/CPython313-test_assertions-Test_Assertions.test_assertRaises_frames_survival diff --git a/test/dynamo/cpython/3_13/test_unittest/test_assertions.diff b/test/dynamo/cpython/3_13/test_unittest/test_assertions.diff new file mode 100644 index 000000000000..9f2d27da51d2 --- /dev/null +++ b/test/dynamo/cpython/3_13/test_unittest/test_assertions.diff @@ -0,0 +1,89 @@ +diff --git a/test/dynamo/cpython/3_13/test_unittest/test_assertions.py b/test/dynamo/cpython/3_13/test_unittest/test_assertions.py +index 1dec947ea76..5a8c2a9d3af 100644 +--- a/test/dynamo/cpython/3_13/test_unittest/test_assertions.py ++++ b/test/dynamo/cpython/3_13/test_unittest/test_assertions.py +@@ -1,3 +1,54 @@ ++# ======= BEGIN Dynamo patch ======= ++# Owner(s): ["module: dynamo"] ++ ++# ruff: noqa ++# flake8: noqa ++ ++import sys ++import torch ++import torch._dynamo.test_case ++import unittest ++from torch.testing._internal.common_utils import run_tests ++ ++ ++__TestCase = torch._dynamo.test_case.CPythonTestCase ++ ++ ++# redirect import statements ++import sys ++import importlib.abc ++ ++redirect_imports = ( ++ "test.mapping_tests", ++ "test.typinganndata", ++ "test.test_grammar", ++ "test.test_math", ++ "test.test_iter", ++ "test.typinganndata.ann_module", ++) ++ ++class RedirectImportFinder(importlib.abc.MetaPathFinder): ++ def find_spec(self, fullname, path, target=None): ++ # Check if the import is the problematic one ++ if fullname in redirect_imports: ++ try: ++ # Attempt to import the standalone module ++ name = fullname.removeprefix("test.") ++ r = importlib.import_module(name) ++ # Redirect the module in sys.modules ++ sys.modules[fullname] = r ++ # Return a module spec from the found module ++ return importlib.util.find_spec(name) ++ except ImportError: ++ return None ++ return None ++ ++# Add the custom finder to sys.meta_path ++sys.meta_path.insert(0, RedirectImportFinder()) ++ ++ ++# ======= END DYNAMO PATCH ======= ++ + import datetime + import warnings + import weakref +@@ -6,7 +57,7 @@ from test.support import gc_collect + from itertools import product + + +-class Test_Assertions(unittest.TestCase): ++class Test_Assertions(__TestCase): + def test_AlmostEqual(self): + self.assertAlmostEqual(1.00000001, 1.0) + self.assertNotAlmostEqual(1.0000001, 1.0) +@@ -141,12 +192,13 @@ class Test_Assertions(unittest.TestCase): + self.fail('assertNotRegex should have failed.') + + +-class TestLongMessage(unittest.TestCase): ++class TestLongMessage(__TestCase): + """Test that the individual asserts honour longMessage. + This actually tests all the message behaviour for + asserts that use longMessage.""" + + def setUp(self): ++ super().setUp() + class TestableTestFalse(unittest.TestCase): + longMessage = False + failureException = self.failureException +@@ -414,4 +466,4 @@ class TestLongMessage(unittest.TestCase): + + + if __name__ == "__main__": +- unittest.main() ++ run_tests() diff --git a/test/dynamo/cpython/3_13/test_unittest/test_assertions.py b/test/dynamo/cpython/3_13/test_unittest/test_assertions.py new file mode 100644 index 000000000000..5a8c2a9d3af9 --- /dev/null +++ b/test/dynamo/cpython/3_13/test_unittest/test_assertions.py @@ -0,0 +1,469 @@ +# ======= BEGIN Dynamo patch ======= +# Owner(s): ["module: dynamo"] + +# ruff: noqa +# flake8: noqa + +import sys +import torch +import torch._dynamo.test_case +import unittest +from torch.testing._internal.common_utils import run_tests + + +__TestCase = torch._dynamo.test_case.CPythonTestCase + + +# redirect import statements +import sys +import importlib.abc + +redirect_imports = ( + "test.mapping_tests", + "test.typinganndata", + "test.test_grammar", + "test.test_math", + "test.test_iter", + "test.typinganndata.ann_module", +) + +class RedirectImportFinder(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path, target=None): + # Check if the import is the problematic one + if fullname in redirect_imports: + try: + # Attempt to import the standalone module + name = fullname.removeprefix("test.") + r = importlib.import_module(name) + # Redirect the module in sys.modules + sys.modules[fullname] = r + # Return a module spec from the found module + return importlib.util.find_spec(name) + except ImportError: + return None + return None + +# Add the custom finder to sys.meta_path +sys.meta_path.insert(0, RedirectImportFinder()) + + +# ======= END DYNAMO PATCH ======= + +import datetime +import warnings +import weakref +import unittest +from test.support import gc_collect +from itertools import product + + +class Test_Assertions(__TestCase): + def test_AlmostEqual(self): + self.assertAlmostEqual(1.00000001, 1.0) + self.assertNotAlmostEqual(1.0000001, 1.0) + self.assertRaises(self.failureException, + self.assertAlmostEqual, 1.0000001, 1.0) + self.assertRaises(self.failureException, + self.assertNotAlmostEqual, 1.00000001, 1.0) + + self.assertAlmostEqual(1.1, 1.0, places=0) + self.assertRaises(self.failureException, + self.assertAlmostEqual, 1.1, 1.0, places=1) + + self.assertAlmostEqual(0, .1+.1j, places=0) + self.assertNotAlmostEqual(0, .1+.1j, places=1) + self.assertRaises(self.failureException, + self.assertAlmostEqual, 0, .1+.1j, places=1) + self.assertRaises(self.failureException, + self.assertNotAlmostEqual, 0, .1+.1j, places=0) + + self.assertAlmostEqual(float('inf'), float('inf')) + self.assertRaises(self.failureException, self.assertNotAlmostEqual, + float('inf'), float('inf')) + + def test_AmostEqualWithDelta(self): + self.assertAlmostEqual(1.1, 1.0, delta=0.5) + self.assertAlmostEqual(1.0, 1.1, delta=0.5) + self.assertNotAlmostEqual(1.1, 1.0, delta=0.05) + self.assertNotAlmostEqual(1.0, 1.1, delta=0.05) + + self.assertAlmostEqual(1.0, 1.0, delta=0.5) + self.assertRaises(self.failureException, self.assertNotAlmostEqual, + 1.0, 1.0, delta=0.5) + + self.assertRaises(self.failureException, self.assertAlmostEqual, + 1.1, 1.0, delta=0.05) + self.assertRaises(self.failureException, self.assertNotAlmostEqual, + 1.1, 1.0, delta=0.5) + + self.assertRaises(TypeError, self.assertAlmostEqual, + 1.1, 1.0, places=2, delta=2) + self.assertRaises(TypeError, self.assertNotAlmostEqual, + 1.1, 1.0, places=2, delta=2) + + first = datetime.datetime.now() + second = first + datetime.timedelta(seconds=10) + self.assertAlmostEqual(first, second, + delta=datetime.timedelta(seconds=20)) + self.assertNotAlmostEqual(first, second, + delta=datetime.timedelta(seconds=5)) + + def test_assertRaises(self): + def _raise(e): + raise e + self.assertRaises(KeyError, _raise, KeyError) + self.assertRaises(KeyError, _raise, KeyError("key")) + try: + self.assertRaises(KeyError, lambda: None) + except self.failureException as e: + self.assertIn("KeyError not raised", str(e)) + else: + self.fail("assertRaises() didn't fail") + try: + self.assertRaises(KeyError, _raise, ValueError) + except ValueError: + pass + else: + self.fail("assertRaises() didn't let exception pass through") + with self.assertRaises(KeyError) as cm: + try: + raise KeyError + except Exception as e: + exc = e + raise + self.assertIs(cm.exception, exc) + + with self.assertRaises(KeyError): + raise KeyError("key") + try: + with self.assertRaises(KeyError): + pass + except self.failureException as e: + self.assertIn("KeyError not raised", str(e)) + else: + self.fail("assertRaises() didn't fail") + try: + with self.assertRaises(KeyError): + raise ValueError + except ValueError: + pass + else: + self.fail("assertRaises() didn't let exception pass through") + + def test_assertRaises_frames_survival(self): + # Issue #9815: assertRaises should avoid keeping local variables + # in a traceback alive. + class A: + pass + wr = None + + class Foo(unittest.TestCase): + + def foo(self): + nonlocal wr + a = A() + wr = weakref.ref(a) + try: + raise OSError + except OSError: + raise ValueError + + def test_functional(self): + self.assertRaises(ValueError, self.foo) + + def test_with(self): + with self.assertRaises(ValueError): + self.foo() + + Foo("test_functional").run() + gc_collect() # For PyPy or other GCs. + self.assertIsNone(wr()) + Foo("test_with").run() + gc_collect() # For PyPy or other GCs. + self.assertIsNone(wr()) + + def testAssertNotRegex(self): + self.assertNotRegex('Ala ma kota', r'r+') + try: + self.assertNotRegex('Ala ma kota', r'k.t', 'Message') + except self.failureException as e: + self.assertIn('Message', e.args[0]) + else: + self.fail('assertNotRegex should have failed.') + + +class TestLongMessage(__TestCase): + """Test that the individual asserts honour longMessage. + This actually tests all the message behaviour for + asserts that use longMessage.""" + + def setUp(self): + super().setUp() + class TestableTestFalse(unittest.TestCase): + longMessage = False + failureException = self.failureException + + def testTest(self): + pass + + class TestableTestTrue(unittest.TestCase): + longMessage = True + failureException = self.failureException + + def testTest(self): + pass + + self.testableTrue = TestableTestTrue('testTest') + self.testableFalse = TestableTestFalse('testTest') + + def testDefault(self): + self.assertTrue(unittest.TestCase.longMessage) + + def test_formatMsg(self): + self.assertEqual(self.testableFalse._formatMessage(None, "foo"), "foo") + self.assertEqual(self.testableFalse._formatMessage("foo", "bar"), "foo") + + self.assertEqual(self.testableTrue._formatMessage(None, "foo"), "foo") + self.assertEqual(self.testableTrue._formatMessage("foo", "bar"), "bar : foo") + + # This blows up if _formatMessage uses string concatenation + self.testableTrue._formatMessage(object(), 'foo') + + def test_formatMessage_unicode_error(self): + one = ''.join(chr(i) for i in range(255)) + # this used to cause a UnicodeDecodeError constructing msg + self.testableTrue._formatMessage(one, '\uFFFD') + + def assertMessages(self, methodName, args, errors): + """ + Check that methodName(*args) raises the correct error messages. + errors should be a list of 4 regex that match the error when: + 1) longMessage = False and no msg passed; + 2) longMessage = False and msg passed; + 3) longMessage = True and no msg passed; + 4) longMessage = True and msg passed; + """ + def getMethod(i): + useTestableFalse = i < 2 + if useTestableFalse: + test = self.testableFalse + else: + test = self.testableTrue + return getattr(test, methodName) + + for i, expected_regex in enumerate(errors): + testMethod = getMethod(i) + kwargs = {} + withMsg = i % 2 + if withMsg: + kwargs = {"msg": "oops"} + + with self.assertRaisesRegex(self.failureException, + expected_regex=expected_regex): + testMethod(*args, **kwargs) + + def testAssertTrue(self): + self.assertMessages('assertTrue', (False,), + ["^False is not true$", "^oops$", "^False is not true$", + "^False is not true : oops$"]) + + def testAssertFalse(self): + self.assertMessages('assertFalse', (True,), + ["^True is not false$", "^oops$", "^True is not false$", + "^True is not false : oops$"]) + + def testNotEqual(self): + self.assertMessages('assertNotEqual', (1, 1), + ["^1 == 1$", "^oops$", "^1 == 1$", + "^1 == 1 : oops$"]) + + def testAlmostEqual(self): + self.assertMessages( + 'assertAlmostEqual', (1, 2), + [r"^1 != 2 within 7 places \(1 difference\)$", "^oops$", + r"^1 != 2 within 7 places \(1 difference\)$", + r"^1 != 2 within 7 places \(1 difference\) : oops$"]) + + def testNotAlmostEqual(self): + self.assertMessages('assertNotAlmostEqual', (1, 1), + ["^1 == 1 within 7 places$", "^oops$", + "^1 == 1 within 7 places$", "^1 == 1 within 7 places : oops$"]) + + def test_baseAssertEqual(self): + self.assertMessages('_baseAssertEqual', (1, 2), + ["^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"]) + + def testAssertSequenceEqual(self): + # Error messages are multiline so not testing on full message + # assertTupleEqual and assertListEqual delegate to this method + self.assertMessages('assertSequenceEqual', ([], [None]), + [r"\+ \[None\]$", "^oops$", r"\+ \[None\]$", + r"\+ \[None\] : oops$"]) + + def testAssertSetEqual(self): + self.assertMessages('assertSetEqual', (set(), set([None])), + ["None$", "^oops$", "None$", + "None : oops$"]) + + def testAssertIn(self): + self.assertMessages('assertIn', (None, []), + [r'^None not found in \[\]$', "^oops$", + r'^None not found in \[\]$', + r'^None not found in \[\] : oops$']) + + def testAssertNotIn(self): + self.assertMessages('assertNotIn', (None, [None]), + [r'^None unexpectedly found in \[None\]$', "^oops$", + r'^None unexpectedly found in \[None\]$', + r'^None unexpectedly found in \[None\] : oops$']) + + def testAssertDictEqual(self): + self.assertMessages('assertDictEqual', ({}, {'key': 'value'}), + [r"\+ \{'key': 'value'\}$", "^oops$", + r"\+ \{'key': 'value'\}$", + r"\+ \{'key': 'value'\} : oops$"]) + + def testAssertMultiLineEqual(self): + self.assertMessages('assertMultiLineEqual', ("", "foo"), + [r"\+ foo\n$", "^oops$", + r"\+ foo\n$", + r"\+ foo\n : oops$"]) + + def testAssertLess(self): + self.assertMessages('assertLess', (2, 1), + ["^2 not less than 1$", "^oops$", + "^2 not less than 1$", "^2 not less than 1 : oops$"]) + + def testAssertLessEqual(self): + self.assertMessages('assertLessEqual', (2, 1), + ["^2 not less than or equal to 1$", "^oops$", + "^2 not less than or equal to 1$", + "^2 not less than or equal to 1 : oops$"]) + + def testAssertGreater(self): + self.assertMessages('assertGreater', (1, 2), + ["^1 not greater than 2$", "^oops$", + "^1 not greater than 2$", + "^1 not greater than 2 : oops$"]) + + def testAssertGreaterEqual(self): + self.assertMessages('assertGreaterEqual', (1, 2), + ["^1 not greater than or equal to 2$", "^oops$", + "^1 not greater than or equal to 2$", + "^1 not greater than or equal to 2 : oops$"]) + + def testAssertIsNone(self): + self.assertMessages('assertIsNone', ('not None',), + ["^'not None' is not None$", "^oops$", + "^'not None' is not None$", + "^'not None' is not None : oops$"]) + + def testAssertIsNotNone(self): + self.assertMessages('assertIsNotNone', (None,), + ["^unexpectedly None$", "^oops$", + "^unexpectedly None$", + "^unexpectedly None : oops$"]) + + def testAssertIs(self): + self.assertMessages('assertIs', (None, 'foo'), + ["^None is not 'foo'$", "^oops$", + "^None is not 'foo'$", + "^None is not 'foo' : oops$"]) + + def testAssertIsNot(self): + self.assertMessages('assertIsNot', (None, None), + ["^unexpectedly identical: None$", "^oops$", + "^unexpectedly identical: None$", + "^unexpectedly identical: None : oops$"]) + + def testAssertRegex(self): + self.assertMessages('assertRegex', ('foo', 'bar'), + ["^Regex didn't match:", + "^oops$", + "^Regex didn't match:", + "^Regex didn't match: (.*) : oops$"]) + + def testAssertNotRegex(self): + self.assertMessages('assertNotRegex', ('foo', 'foo'), + ["^Regex matched:", + "^oops$", + "^Regex matched:", + "^Regex matched: (.*) : oops$"]) + + + def assertMessagesCM(self, methodName, args, func, errors): + """ + Check that the correct error messages are raised while executing: + with method(*args): + func() + *errors* should be a list of 4 regex that match the error when: + 1) longMessage = False and no msg passed; + 2) longMessage = False and msg passed; + 3) longMessage = True and no msg passed; + 4) longMessage = True and msg passed; + """ + p = product((self.testableFalse, self.testableTrue), + ({}, {"msg": "oops"})) + for (cls, kwargs), err in zip(p, errors): + method = getattr(cls, methodName) + with self.assertRaisesRegex(cls.failureException, err): + with method(*args, **kwargs) as cm: + func() + + def testAssertRaises(self): + self.assertMessagesCM('assertRaises', (TypeError,), lambda: None, + ['^TypeError not raised$', '^oops$', + '^TypeError not raised$', + '^TypeError not raised : oops$']) + + def testAssertRaisesRegex(self): + # test error not raised + self.assertMessagesCM('assertRaisesRegex', (TypeError, 'unused regex'), + lambda: None, + ['^TypeError not raised$', '^oops$', + '^TypeError not raised$', + '^TypeError not raised : oops$']) + # test error raised but with wrong message + def raise_wrong_message(): + raise TypeError('foo') + self.assertMessagesCM('assertRaisesRegex', (TypeError, 'regex'), + raise_wrong_message, + ['^"regex" does not match "foo"$', '^oops$', + '^"regex" does not match "foo"$', + '^"regex" does not match "foo" : oops$']) + + def testAssertWarns(self): + self.assertMessagesCM('assertWarns', (UserWarning,), lambda: None, + ['^UserWarning not triggered$', '^oops$', + '^UserWarning not triggered$', + '^UserWarning not triggered : oops$']) + + def test_assertNotWarns(self): + def warn_future(): + warnings.warn('xyz', FutureWarning, stacklevel=2) + self.assertMessagesCM('_assertNotWarns', (FutureWarning,), + warn_future, + ['^FutureWarning triggered$', + '^oops$', + '^FutureWarning triggered$', + '^FutureWarning triggered : oops$']) + + def testAssertWarnsRegex(self): + # test error not raised + self.assertMessagesCM('assertWarnsRegex', (UserWarning, 'unused regex'), + lambda: None, + ['^UserWarning not triggered$', '^oops$', + '^UserWarning not triggered$', + '^UserWarning not triggered : oops$']) + # test warning raised but with wrong message + def raise_wrong_message(): + warnings.warn('foo') + self.assertMessagesCM('assertWarnsRegex', (UserWarning, 'regex'), + raise_wrong_message, + ['^"regex" does not match "foo"$', '^oops$', + '^"regex" does not match "foo"$', + '^"regex" does not match "foo" : oops$']) + + +if __name__ == "__main__": + run_tests() diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAlmostEqual b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAlmostEqual new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertDictEqual b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertDictEqual new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertFalse b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertFalse new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertGreater b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertGreater new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertGreaterEqual b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertGreaterEqual new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIn b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIn new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIs b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIs new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIsNone b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIsNone new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIsNot b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIsNot new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIsNotNone b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertIsNotNone new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertLess b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertLess new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertLessEqual b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertLessEqual new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertMultiLineEqual b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertMultiLineEqual new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertNotIn b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertNotIn new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertNotRegex b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertNotRegex new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertRaises b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertRaises new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertRaisesRegex b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertRaisesRegex new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertRegex b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertRegex new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertSequenceEqual b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertSequenceEqual new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertSetEqual b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertSetEqual new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertTrue b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertTrue new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertWarns b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertWarns new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertWarnsRegex b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testAssertWarnsRegex new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testNotAlmostEqual b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testNotAlmostEqual new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testNotEqual b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.testNotEqual new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.test_assertNotWarns b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.test_assertNotWarns new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.test_baseAssertEqual b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.test_baseAssertEqual new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.test_formatMsg b/test/dynamo_expected_failures/CPython313-test_assertions-TestLongMessage.test_formatMsg new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-Test_Assertions.testAssertNotRegex b/test/dynamo_expected_failures/CPython313-test_assertions-Test_Assertions.testAssertNotRegex new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-Test_Assertions.test_AmostEqualWithDelta b/test/dynamo_expected_failures/CPython313-test_assertions-Test_Assertions.test_AmostEqualWithDelta new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/dynamo_expected_failures/CPython313-test_assertions-Test_Assertions.test_assertRaises_frames_survival b/test/dynamo_expected_failures/CPython313-test_assertions-Test_Assertions.test_assertRaises_frames_survival new file mode 100644 index 000000000000..e69de29bb2d1