Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 1 | from contextlib import contextmanager |
Christian Heimes | 5fb7c2a | 2007-12-24 08:52:31 +0000 | [diff] [blame] | 2 | import linecache |
Raymond Hettinger | dc9dcf1 | 2003-07-13 06:15:11 +0000 | [diff] [blame] | 3 | import os |
Christian Heimes | 5fb7c2a | 2007-12-24 08:52:31 +0000 | [diff] [blame] | 4 | from io import StringIO |
Guido van Rossum | 61e21b5 | 2007-08-20 19:06:03 +0000 | [diff] [blame] | 5 | import sys |
Raymond Hettinger | d6f6e50 | 2003-07-13 08:37:40 +0000 | [diff] [blame] | 6 | import unittest |
Philip Jenvey | 0805ca3 | 2010-04-07 04:04:10 +0000 | [diff] [blame] | 7 | import subprocess |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 8 | from test import support |
Antoine Pitrou | cf9f980 | 2010-11-10 13:55:25 +0000 | [diff] [blame] | 9 | from test.script_helper import assert_python_ok |
Jeremy Hylton | 8501466 | 2003-07-11 15:37:59 +0000 | [diff] [blame] | 10 | |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 11 | from test import warning_tests |
Jeremy Hylton | 8501466 | 2003-07-11 15:37:59 +0000 | [diff] [blame] | 12 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 13 | import warnings as original_warnings |
Jeremy Hylton | 8501466 | 2003-07-11 15:37:59 +0000 | [diff] [blame] | 14 | |
Nick Coghlan | 4738470 | 2009-04-22 16:13:36 +0000 | [diff] [blame] | 15 | py_warnings = support.import_fresh_module('warnings', blocked=['_warnings']) |
| 16 | c_warnings = support.import_fresh_module('warnings', fresh=['_warnings']) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 17 | |
| 18 | @contextmanager |
| 19 | def warnings_state(module): |
| 20 | """Use a specific warnings implementation in warning_tests.""" |
| 21 | global __warningregistry__ |
| 22 | for to_clear in (sys, warning_tests): |
| 23 | try: |
| 24 | to_clear.__warningregistry__.clear() |
| 25 | except AttributeError: |
| 26 | pass |
| 27 | try: |
| 28 | __warningregistry__.clear() |
| 29 | except NameError: |
| 30 | pass |
| 31 | original_warnings = warning_tests.warnings |
Florent Xicluna | fd1b093 | 2010-03-28 00:25:02 +0000 | [diff] [blame] | 32 | original_filters = module.filters |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 33 | try: |
Florent Xicluna | fd1b093 | 2010-03-28 00:25:02 +0000 | [diff] [blame] | 34 | module.filters = original_filters[:] |
| 35 | module.simplefilter("once") |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 36 | warning_tests.warnings = module |
| 37 | yield |
| 38 | finally: |
| 39 | warning_tests.warnings = original_warnings |
Florent Xicluna | fd1b093 | 2010-03-28 00:25:02 +0000 | [diff] [blame] | 40 | module.filters = original_filters |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 41 | |
| 42 | |
| 43 | class BaseTest(unittest.TestCase): |
| 44 | |
| 45 | """Basic bookkeeping required for testing.""" |
| 46 | |
| 47 | def setUp(self): |
| 48 | # The __warningregistry__ needs to be in a pristine state for tests |
| 49 | # to work properly. |
| 50 | if '__warningregistry__' in globals(): |
| 51 | del globals()['__warningregistry__'] |
| 52 | if hasattr(warning_tests, '__warningregistry__'): |
| 53 | del warning_tests.__warningregistry__ |
| 54 | if hasattr(sys, '__warningregistry__'): |
| 55 | del sys.__warningregistry__ |
| 56 | # The 'warnings' module must be explicitly set so that the proper |
| 57 | # interaction between _warnings and 'warnings' can be controlled. |
| 58 | sys.modules['warnings'] = self.module |
| 59 | super(BaseTest, self).setUp() |
| 60 | |
| 61 | def tearDown(self): |
| 62 | sys.modules['warnings'] = original_warnings |
| 63 | super(BaseTest, self).tearDown() |
| 64 | |
| 65 | |
| 66 | class FilterTests(object): |
| 67 | |
| 68 | """Testing the filtering functionality.""" |
| 69 | |
| 70 | def test_error(self): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 71 | with original_warnings.catch_warnings(module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 72 | self.module.resetwarnings() |
| 73 | self.module.filterwarnings("error", category=UserWarning) |
| 74 | self.assertRaises(UserWarning, self.module.warn, |
| 75 | "FilterTests.test_error") |
| 76 | |
| 77 | def test_ignore(self): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 78 | with original_warnings.catch_warnings(record=True, |
| 79 | module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 80 | self.module.resetwarnings() |
| 81 | self.module.filterwarnings("ignore", category=UserWarning) |
| 82 | self.module.warn("FilterTests.test_ignore", UserWarning) |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 83 | self.assertEquals(len(w), 0) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 84 | |
| 85 | def test_always(self): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 86 | with original_warnings.catch_warnings(record=True, |
| 87 | module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 88 | self.module.resetwarnings() |
| 89 | self.module.filterwarnings("always", category=UserWarning) |
| 90 | message = "FilterTests.test_always" |
| 91 | self.module.warn(message, UserWarning) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 92 | self.assertTrue(message, w[-1].message) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 93 | self.module.warn(message, UserWarning) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 94 | self.assertTrue(w[-1].message, message) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 95 | |
| 96 | def test_default(self): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 97 | with original_warnings.catch_warnings(record=True, |
| 98 | module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 99 | self.module.resetwarnings() |
| 100 | self.module.filterwarnings("default", category=UserWarning) |
| 101 | message = UserWarning("FilterTests.test_default") |
| 102 | for x in range(2): |
| 103 | self.module.warn(message, UserWarning) |
| 104 | if x == 0: |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 105 | self.assertEquals(w[-1].message, message) |
| 106 | del w[:] |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 107 | elif x == 1: |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 108 | self.assertEquals(len(w), 0) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 109 | else: |
| 110 | raise ValueError("loop variant unhandled") |
| 111 | |
| 112 | def test_module(self): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 113 | with original_warnings.catch_warnings(record=True, |
| 114 | module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 115 | self.module.resetwarnings() |
| 116 | self.module.filterwarnings("module", category=UserWarning) |
| 117 | message = UserWarning("FilterTests.test_module") |
| 118 | self.module.warn(message, UserWarning) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 119 | self.assertEquals(w[-1].message, message) |
| 120 | del w[:] |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 121 | self.module.warn(message, UserWarning) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 122 | self.assertEquals(len(w), 0) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 123 | |
| 124 | def test_once(self): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 125 | with original_warnings.catch_warnings(record=True, |
| 126 | module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 127 | self.module.resetwarnings() |
| 128 | self.module.filterwarnings("once", category=UserWarning) |
| 129 | message = UserWarning("FilterTests.test_once") |
| 130 | self.module.warn_explicit(message, UserWarning, "test_warnings.py", |
| 131 | 42) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 132 | self.assertEquals(w[-1].message, message) |
| 133 | del w[:] |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 134 | self.module.warn_explicit(message, UserWarning, "test_warnings.py", |
| 135 | 13) |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 136 | self.assertEquals(len(w), 0) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 137 | self.module.warn_explicit(message, UserWarning, "test_warnings2.py", |
| 138 | 42) |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 139 | self.assertEquals(len(w), 0) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 140 | |
| 141 | def test_inheritance(self): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 142 | with original_warnings.catch_warnings(module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 143 | self.module.resetwarnings() |
| 144 | self.module.filterwarnings("error", category=Warning) |
| 145 | self.assertRaises(UserWarning, self.module.warn, |
| 146 | "FilterTests.test_inheritance", UserWarning) |
| 147 | |
| 148 | def test_ordering(self): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 149 | with original_warnings.catch_warnings(record=True, |
| 150 | module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 151 | self.module.resetwarnings() |
| 152 | self.module.filterwarnings("ignore", category=UserWarning) |
| 153 | self.module.filterwarnings("error", category=UserWarning, |
| 154 | append=True) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 155 | del w[:] |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 156 | try: |
| 157 | self.module.warn("FilterTests.test_ordering", UserWarning) |
| 158 | except UserWarning: |
| 159 | self.fail("order handling for actions failed") |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 160 | self.assertEquals(len(w), 0) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 161 | |
| 162 | def test_filterwarnings(self): |
| 163 | # Test filterwarnings(). |
| 164 | # Implicitly also tests resetwarnings(). |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 165 | with original_warnings.catch_warnings(record=True, |
| 166 | module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 167 | self.module.filterwarnings("error", "", Warning, "", 0) |
| 168 | self.assertRaises(UserWarning, self.module.warn, 'convert to error') |
| 169 | |
| 170 | self.module.resetwarnings() |
| 171 | text = 'handle normally' |
| 172 | self.module.warn(text) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 173 | self.assertEqual(str(w[-1].message), text) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 174 | self.assertTrue(w[-1].category is UserWarning) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 175 | |
| 176 | self.module.filterwarnings("ignore", "", Warning, "", 0) |
| 177 | text = 'filtered out' |
| 178 | self.module.warn(text) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 179 | self.assertNotEqual(str(w[-1].message), text) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 180 | |
| 181 | self.module.resetwarnings() |
| 182 | self.module.filterwarnings("error", "hex*", Warning, "", 0) |
| 183 | self.assertRaises(UserWarning, self.module.warn, 'hex/oct') |
| 184 | text = 'nonmatching text' |
| 185 | self.module.warn(text) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 186 | self.assertEqual(str(w[-1].message), text) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 187 | self.assertTrue(w[-1].category is UserWarning) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 188 | |
| 189 | class CFilterTests(BaseTest, FilterTests): |
| 190 | module = c_warnings |
| 191 | |
| 192 | class PyFilterTests(BaseTest, FilterTests): |
| 193 | module = py_warnings |
| 194 | |
| 195 | |
| 196 | class WarnTests(unittest.TestCase): |
| 197 | |
| 198 | """Test warnings.warn() and warnings.warn_explicit().""" |
| 199 | |
| 200 | def test_message(self): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 201 | with original_warnings.catch_warnings(record=True, |
| 202 | module=self.module) as w: |
Florent Xicluna | fd1b093 | 2010-03-28 00:25:02 +0000 | [diff] [blame] | 203 | self.module.simplefilter("once") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 204 | for i in range(4): |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 205 | text = 'multi %d' %i # Different text on each call. |
| 206 | self.module.warn(text) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 207 | self.assertEqual(str(w[-1].message), text) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 208 | self.assertTrue(w[-1].category is UserWarning) |
Raymond Hettinger | d6f6e50 | 2003-07-13 08:37:40 +0000 | [diff] [blame] | 209 | |
Brett Cannon | 54bd41d | 2008-09-02 04:01:42 +0000 | [diff] [blame] | 210 | # Issue 3639 |
| 211 | def test_warn_nonstandard_types(self): |
| 212 | # warn() should handle non-standard types without issue. |
| 213 | for ob in (Warning, None, 42): |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 214 | with original_warnings.catch_warnings(record=True, |
| 215 | module=self.module) as w: |
Florent Xicluna | fd1b093 | 2010-03-28 00:25:02 +0000 | [diff] [blame] | 216 | self.module.simplefilter("once") |
Brett Cannon | 54bd41d | 2008-09-02 04:01:42 +0000 | [diff] [blame] | 217 | self.module.warn(ob) |
| 218 | # Don't directly compare objects since |
| 219 | # ``Warning() != Warning()``. |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 220 | self.assertEquals(str(w[-1].message), str(UserWarning(ob))) |
Brett Cannon | 54bd41d | 2008-09-02 04:01:42 +0000 | [diff] [blame] | 221 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 222 | def test_filename(self): |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 223 | with warnings_state(self.module): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 224 | with original_warnings.catch_warnings(record=True, |
| 225 | module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 226 | warning_tests.inner("spam1") |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 227 | self.assertEqual(os.path.basename(w[-1].filename), |
| 228 | "warning_tests.py") |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 229 | warning_tests.outer("spam2") |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 230 | self.assertEqual(os.path.basename(w[-1].filename), |
| 231 | "warning_tests.py") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 232 | |
| 233 | def test_stacklevel(self): |
| 234 | # Test stacklevel argument |
| 235 | # make sure all messages are different, so the warning won't be skipped |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 236 | with warnings_state(self.module): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 237 | with original_warnings.catch_warnings(record=True, |
| 238 | module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 239 | warning_tests.inner("spam3", stacklevel=1) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 240 | self.assertEqual(os.path.basename(w[-1].filename), |
| 241 | "warning_tests.py") |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 242 | warning_tests.outer("spam4", stacklevel=1) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 243 | self.assertEqual(os.path.basename(w[-1].filename), |
| 244 | "warning_tests.py") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 245 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 246 | warning_tests.inner("spam5", stacklevel=2) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 247 | self.assertEqual(os.path.basename(w[-1].filename), |
| 248 | "test_warnings.py") |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 249 | warning_tests.outer("spam6", stacklevel=2) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 250 | self.assertEqual(os.path.basename(w[-1].filename), |
| 251 | "warning_tests.py") |
Christian Heimes | 5d8da20 | 2008-05-06 13:58:24 +0000 | [diff] [blame] | 252 | warning_tests.outer("spam6.5", stacklevel=3) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 253 | self.assertEqual(os.path.basename(w[-1].filename), |
| 254 | "test_warnings.py") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 255 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 256 | warning_tests.inner("spam7", stacklevel=9999) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 257 | self.assertEqual(os.path.basename(w[-1].filename), |
| 258 | "sys") |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 259 | |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 260 | def test_missing_filename_not_main(self): |
| 261 | # If __file__ is not specified and __main__ is not the module name, |
| 262 | # then __file__ should be set to the module name. |
| 263 | filename = warning_tests.__file__ |
| 264 | try: |
| 265 | del warning_tests.__file__ |
| 266 | with warnings_state(self.module): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 267 | with original_warnings.catch_warnings(record=True, |
| 268 | module=self.module) as w: |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 269 | warning_tests.inner("spam8", stacklevel=1) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 270 | self.assertEqual(w[-1].filename, warning_tests.__name__) |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 271 | finally: |
| 272 | warning_tests.__file__ = filename |
| 273 | |
| 274 | def test_missing_filename_main_with_argv(self): |
| 275 | # If __file__ is not specified and the caller is __main__ and sys.argv |
| 276 | # exists, then use sys.argv[0] as the file. |
| 277 | if not hasattr(sys, 'argv'): |
| 278 | return |
| 279 | filename = warning_tests.__file__ |
| 280 | module_name = warning_tests.__name__ |
| 281 | try: |
| 282 | del warning_tests.__file__ |
| 283 | warning_tests.__name__ = '__main__' |
| 284 | with warnings_state(self.module): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 285 | with original_warnings.catch_warnings(record=True, |
| 286 | module=self.module) as w: |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 287 | warning_tests.inner('spam9', stacklevel=1) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 288 | self.assertEqual(w[-1].filename, sys.argv[0]) |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 289 | finally: |
| 290 | warning_tests.__file__ = filename |
| 291 | warning_tests.__name__ = module_name |
| 292 | |
| 293 | def test_missing_filename_main_without_argv(self): |
| 294 | # If __file__ is not specified, the caller is __main__, and sys.argv |
| 295 | # is not set, then '__main__' is the file name. |
| 296 | filename = warning_tests.__file__ |
| 297 | module_name = warning_tests.__name__ |
| 298 | argv = sys.argv |
| 299 | try: |
| 300 | del warning_tests.__file__ |
| 301 | warning_tests.__name__ = '__main__' |
| 302 | del sys.argv |
| 303 | with warnings_state(self.module): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 304 | with original_warnings.catch_warnings(record=True, |
| 305 | module=self.module) as w: |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 306 | warning_tests.inner('spam10', stacklevel=1) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 307 | self.assertEqual(w[-1].filename, '__main__') |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 308 | finally: |
| 309 | warning_tests.__file__ = filename |
| 310 | warning_tests.__name__ = module_name |
| 311 | sys.argv = argv |
| 312 | |
Christian Heimes | daaf8ee | 2008-05-04 23:58:41 +0000 | [diff] [blame] | 313 | def test_missing_filename_main_with_argv_empty_string(self): |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 314 | # If __file__ is not specified, the caller is __main__, and sys.argv[0] |
| 315 | # is the empty string, then '__main__ is the file name. |
| 316 | # Tests issue 2743. |
| 317 | file_name = warning_tests.__file__ |
| 318 | module_name = warning_tests.__name__ |
| 319 | argv = sys.argv |
| 320 | try: |
| 321 | del warning_tests.__file__ |
| 322 | warning_tests.__name__ = '__main__' |
| 323 | sys.argv = [''] |
| 324 | with warnings_state(self.module): |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 325 | with original_warnings.catch_warnings(record=True, |
| 326 | module=self.module) as w: |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 327 | warning_tests.inner('spam11', stacklevel=1) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 328 | self.assertEqual(w[-1].filename, '__main__') |
Christian Heimes | 81ee3ef | 2008-05-04 22:42:01 +0000 | [diff] [blame] | 329 | finally: |
| 330 | warning_tests.__file__ = file_name |
| 331 | warning_tests.__name__ = module_name |
| 332 | sys.argv = argv |
| 333 | |
Brett Cannon | db73491 | 2008-06-27 00:52:15 +0000 | [diff] [blame] | 334 | def test_warn_explicit_type_errors(self): |
| 335 | # warn_explicit() shoud error out gracefully if it is given objects |
| 336 | # of the wrong types. |
| 337 | # lineno is expected to be an integer. |
| 338 | self.assertRaises(TypeError, self.module.warn_explicit, |
| 339 | None, UserWarning, None, None) |
| 340 | # Either 'message' needs to be an instance of Warning or 'category' |
| 341 | # needs to be a subclass. |
| 342 | self.assertRaises(TypeError, self.module.warn_explicit, |
| 343 | None, None, None, 1) |
| 344 | # 'registry' must be a dict or None. |
| 345 | self.assertRaises((TypeError, AttributeError), |
| 346 | self.module.warn_explicit, |
| 347 | None, Warning, None, 1, registry=42) |
| 348 | |
Hirokazu Yamamoto | 1c0c003 | 2009-07-17 06:55:42 +0000 | [diff] [blame] | 349 | def test_bad_str(self): |
| 350 | # issue 6415 |
| 351 | # Warnings instance with a bad format string for __str__ should not |
| 352 | # trigger a bus error. |
| 353 | class BadStrWarning(Warning): |
| 354 | """Warning with a bad format string for __str__.""" |
| 355 | def __str__(self): |
| 356 | return ("A bad formatted string %(err)" % |
| 357 | {"err" : "there is no %(err)s"}) |
| 358 | |
| 359 | with self.assertRaises(ValueError): |
| 360 | self.module.warn(BadStrWarning()) |
| 361 | |
| 362 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 363 | class CWarnTests(BaseTest, WarnTests): |
| 364 | module = c_warnings |
| 365 | |
Nick Coghlan | fce769e | 2009-04-11 14:30:59 +0000 | [diff] [blame] | 366 | # As an early adopter, we sanity check the |
| 367 | # test.support.import_fresh_module utility function |
| 368 | def test_accelerated(self): |
| 369 | self.assertFalse(original_warnings is self.module) |
| 370 | self.assertFalse(hasattr(self.module.warn, '__code__')) |
| 371 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 372 | class PyWarnTests(BaseTest, WarnTests): |
| 373 | module = py_warnings |
| 374 | |
Nick Coghlan | fce769e | 2009-04-11 14:30:59 +0000 | [diff] [blame] | 375 | # As an early adopter, we sanity check the |
| 376 | # test.support.import_fresh_module utility function |
| 377 | def test_pure_python(self): |
| 378 | self.assertFalse(original_warnings is self.module) |
| 379 | self.assertTrue(hasattr(self.module.warn, '__code__')) |
| 380 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 381 | |
| 382 | class WCmdLineTests(unittest.TestCase): |
| 383 | |
| 384 | def test_improper_input(self): |
| 385 | # Uses the private _setoption() function to test the parsing |
| 386 | # of command-line warning arguments |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 387 | with original_warnings.catch_warnings(module=self.module): |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 388 | self.assertRaises(self.module._OptionError, |
| 389 | self.module._setoption, '1:2:3:4:5:6') |
| 390 | self.assertRaises(self.module._OptionError, |
| 391 | self.module._setoption, 'bogus::Warning') |
| 392 | self.assertRaises(self.module._OptionError, |
| 393 | self.module._setoption, 'ignore:2::4:-5') |
| 394 | self.module._setoption('error::Warning::0') |
| 395 | self.assertRaises(UserWarning, self.module.warn, 'convert to error') |
| 396 | |
Antoine Pitrou | cf9f980 | 2010-11-10 13:55:25 +0000 | [diff] [blame] | 397 | def test_improper_option(self): |
| 398 | # Same as above, but check that the message is printed out when |
| 399 | # the interpreter is executed. This also checks that options are |
| 400 | # actually parsed at all. |
| 401 | rc, out, err = assert_python_ok("-Wxxx", "-c", "pass") |
| 402 | self.assertIn(b"Invalid -W option ignored: invalid action: 'xxx'", err) |
| 403 | |
| 404 | def test_warnings_bootstrap(self): |
| 405 | # Check that the warnings module does get loaded when -W<some option> |
| 406 | # is used (see issue #10372 for an example of silent bootstrap failure). |
| 407 | rc, out, err = assert_python_ok("-Wi", "-c", |
| 408 | "import sys; sys.modules['warnings'].warn('foo', RuntimeWarning)") |
| 409 | # '-Wi' was observed |
| 410 | self.assertFalse(out.strip()) |
| 411 | self.assertNotIn(b'RuntimeWarning', err) |
| 412 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 413 | class CWCmdLineTests(BaseTest, WCmdLineTests): |
| 414 | module = c_warnings |
| 415 | |
| 416 | class PyWCmdLineTests(BaseTest, WCmdLineTests): |
| 417 | module = py_warnings |
| 418 | |
| 419 | |
| 420 | class _WarningsTests(BaseTest): |
| 421 | |
| 422 | """Tests specific to the _warnings module.""" |
| 423 | |
| 424 | module = c_warnings |
| 425 | |
| 426 | def test_filter(self): |
| 427 | # Everything should function even if 'filters' is not in warnings. |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 428 | with original_warnings.catch_warnings(module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 429 | self.module.filterwarnings("error", "", Warning, "", 0) |
| 430 | self.assertRaises(UserWarning, self.module.warn, |
| 431 | 'convert to error') |
| 432 | del self.module.filters |
| 433 | self.assertRaises(UserWarning, self.module.warn, |
| 434 | 'convert to error') |
| 435 | |
| 436 | def test_onceregistry(self): |
| 437 | # Replacing or removing the onceregistry should be okay. |
| 438 | global __warningregistry__ |
| 439 | message = UserWarning('onceregistry test') |
| 440 | try: |
| 441 | original_registry = self.module.onceregistry |
| 442 | __warningregistry__ = {} |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 443 | with original_warnings.catch_warnings(record=True, |
| 444 | module=self.module) as w: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 445 | self.module.resetwarnings() |
| 446 | self.module.filterwarnings("once", category=UserWarning) |
| 447 | self.module.warn_explicit(message, UserWarning, "file", 42) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 448 | self.assertEqual(w[-1].message, message) |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 449 | del w[:] |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 450 | self.module.warn_explicit(message, UserWarning, "file", 42) |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 451 | self.assertEquals(len(w), 0) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 452 | # Test the resetting of onceregistry. |
| 453 | self.module.onceregistry = {} |
| 454 | __warningregistry__ = {} |
| 455 | self.module.warn('onceregistry test') |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 456 | self.assertEqual(w[-1].message.args, message.args) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 457 | # Removal of onceregistry is okay. |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 458 | del w[:] |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 459 | del self.module.onceregistry |
| 460 | __warningregistry__ = {} |
| 461 | self.module.warn_explicit(message, UserWarning, "file", 42) |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 462 | self.assertEquals(len(w), 0) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 463 | finally: |
| 464 | self.module.onceregistry = original_registry |
| 465 | |
Brett Cannon | 0759dd6 | 2009-04-01 18:13:07 +0000 | [diff] [blame] | 466 | def test_default_action(self): |
| 467 | # Replacing or removing defaultaction should be okay. |
| 468 | message = UserWarning("defaultaction test") |
| 469 | original = self.module.defaultaction |
| 470 | try: |
| 471 | with original_warnings.catch_warnings(record=True, |
| 472 | module=self.module) as w: |
| 473 | self.module.resetwarnings() |
| 474 | registry = {} |
| 475 | self.module.warn_explicit(message, UserWarning, "<test>", 42, |
| 476 | registry=registry) |
| 477 | self.assertEqual(w[-1].message, message) |
| 478 | self.assertEqual(len(w), 1) |
| 479 | self.assertEqual(len(registry), 1) |
| 480 | del w[:] |
| 481 | # Test removal. |
| 482 | del self.module.defaultaction |
| 483 | __warningregistry__ = {} |
| 484 | registry = {} |
| 485 | self.module.warn_explicit(message, UserWarning, "<test>", 43, |
| 486 | registry=registry) |
| 487 | self.assertEqual(w[-1].message, message) |
| 488 | self.assertEqual(len(w), 1) |
| 489 | self.assertEqual(len(registry), 1) |
| 490 | del w[:] |
| 491 | # Test setting. |
| 492 | self.module.defaultaction = "ignore" |
| 493 | __warningregistry__ = {} |
| 494 | registry = {} |
| 495 | self.module.warn_explicit(message, UserWarning, "<test>", 44, |
| 496 | registry=registry) |
| 497 | self.assertEqual(len(w), 0) |
| 498 | finally: |
| 499 | self.module.defaultaction = original |
| 500 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 501 | def test_showwarning_missing(self): |
| 502 | # Test that showwarning() missing is okay. |
| 503 | text = 'del showwarning test' |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 504 | with original_warnings.catch_warnings(module=self.module): |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 505 | self.module.filterwarnings("always", category=UserWarning) |
| 506 | del self.module.showwarning |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 507 | with support.captured_output('stderr') as stream: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 508 | self.module.warn(text) |
| 509 | result = stream.getvalue() |
Benjamin Peterson | 577473f | 2010-01-19 00:09:57 +0000 | [diff] [blame] | 510 | self.assertIn(text, result) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 511 | |
Christian Heimes | 8dc226f | 2008-05-06 23:45:46 +0000 | [diff] [blame] | 512 | def test_showwarning_not_callable(self): |
Brett Cannon | fcc0527 | 2009-04-01 20:27:29 +0000 | [diff] [blame] | 513 | with original_warnings.catch_warnings(module=self.module): |
| 514 | self.module.filterwarnings("always", category=UserWarning) |
| 515 | old_showwarning = self.module.showwarning |
| 516 | self.module.showwarning = 23 |
| 517 | try: |
| 518 | self.assertRaises(TypeError, self.module.warn, "Warning!") |
| 519 | finally: |
| 520 | self.module.showwarning = old_showwarning |
Christian Heimes | 8dc226f | 2008-05-06 23:45:46 +0000 | [diff] [blame] | 521 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 522 | def test_show_warning_output(self): |
| 523 | # With showarning() missing, make sure that output is okay. |
| 524 | text = 'test show_warning' |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 525 | with original_warnings.catch_warnings(module=self.module): |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 526 | self.module.filterwarnings("always", category=UserWarning) |
| 527 | del self.module.showwarning |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 528 | with support.captured_output('stderr') as stream: |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 529 | warning_tests.inner(text) |
| 530 | result = stream.getvalue() |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 531 | self.assertEqual(result.count('\n'), 2, |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 532 | "Too many newlines in %r" % result) |
| 533 | first_line, second_line = result.split('\n', 1) |
| 534 | expected_file = os.path.splitext(warning_tests.__file__)[0] + '.py' |
Neal Norwitz | 32dde22 | 2008-04-15 06:43:13 +0000 | [diff] [blame] | 535 | first_line_parts = first_line.rsplit(':', 3) |
| 536 | path, line, warning_class, message = first_line_parts |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 537 | line = int(line) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 538 | self.assertEqual(expected_file, path) |
| 539 | self.assertEqual(warning_class, ' ' + UserWarning.__name__) |
| 540 | self.assertEqual(message, ' ' + text) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 541 | expected_line = ' ' + linecache.getline(path, line).strip() + '\n' |
| 542 | assert expected_line |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 543 | self.assertEqual(second_line, expected_line) |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 544 | |
| 545 | |
Christian Heimes | 5fb7c2a | 2007-12-24 08:52:31 +0000 | [diff] [blame] | 546 | class WarningsDisplayTests(unittest.TestCase): |
| 547 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 548 | """Test the displaying of warnings and the ability to overload functions |
| 549 | related to displaying warnings.""" |
| 550 | |
Christian Heimes | 5fb7c2a | 2007-12-24 08:52:31 +0000 | [diff] [blame] | 551 | def test_formatwarning(self): |
| 552 | message = "msg" |
| 553 | category = Warning |
| 554 | file_name = os.path.splitext(warning_tests.__file__)[0] + '.py' |
| 555 | line_num = 3 |
| 556 | file_line = linecache.getline(file_name, line_num).strip() |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 557 | format = "%s:%s: %s: %s\n %s\n" |
| 558 | expect = format % (file_name, line_num, category.__name__, message, |
| 559 | file_line) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 560 | self.assertEqual(expect, self.module.formatwarning(message, |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 561 | category, file_name, line_num)) |
| 562 | # Test the 'line' argument. |
| 563 | file_line += " for the win!" |
| 564 | expect = format % (file_name, line_num, category.__name__, message, |
| 565 | file_line) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 566 | self.assertEqual(expect, self.module.formatwarning(message, |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 567 | category, file_name, line_num, file_line)) |
Christian Heimes | 5fb7c2a | 2007-12-24 08:52:31 +0000 | [diff] [blame] | 568 | |
| 569 | def test_showwarning(self): |
| 570 | file_name = os.path.splitext(warning_tests.__file__)[0] + '.py' |
| 571 | line_num = 3 |
| 572 | expected_file_line = linecache.getline(file_name, line_num).strip() |
| 573 | message = 'msg' |
| 574 | category = Warning |
| 575 | file_object = StringIO() |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 576 | expect = self.module.formatwarning(message, category, file_name, |
| 577 | line_num) |
| 578 | self.module.showwarning(message, category, file_name, line_num, |
Christian Heimes | 5fb7c2a | 2007-12-24 08:52:31 +0000 | [diff] [blame] | 579 | file_object) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 580 | self.assertEqual(file_object.getvalue(), expect) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 581 | # Test 'line' argument. |
| 582 | expected_file_line += "for the win!" |
| 583 | expect = self.module.formatwarning(message, category, file_name, |
| 584 | line_num, expected_file_line) |
| 585 | file_object = StringIO() |
| 586 | self.module.showwarning(message, category, file_name, line_num, |
| 587 | file_object, expected_file_line) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 588 | self.assertEqual(expect, file_object.getvalue()) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 589 | |
| 590 | class CWarningsDisplayTests(BaseTest, WarningsDisplayTests): |
| 591 | module = c_warnings |
| 592 | |
| 593 | class PyWarningsDisplayTests(BaseTest, WarningsDisplayTests): |
| 594 | module = py_warnings |
Christian Heimes | 5fb7c2a | 2007-12-24 08:52:31 +0000 | [diff] [blame] | 595 | |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 596 | |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 597 | class CatchWarningTests(BaseTest): |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 598 | |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 599 | """Test catch_warnings().""" |
| 600 | |
| 601 | def test_catch_warnings_restore(self): |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 602 | wmod = self.module |
| 603 | orig_filters = wmod.filters |
| 604 | orig_showwarning = wmod.showwarning |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 605 | # Ensure both showwarning and filters are restored when recording |
| 606 | with wmod.catch_warnings(module=wmod, record=True): |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 607 | wmod.filters = wmod.showwarning = object() |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 608 | self.assertTrue(wmod.filters is orig_filters) |
| 609 | self.assertTrue(wmod.showwarning is orig_showwarning) |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 610 | # Same test, but with recording disabled |
| 611 | with wmod.catch_warnings(module=wmod, record=False): |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 612 | wmod.filters = wmod.showwarning = object() |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 613 | self.assertTrue(wmod.filters is orig_filters) |
| 614 | self.assertTrue(wmod.showwarning is orig_showwarning) |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 615 | |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 616 | def test_catch_warnings_recording(self): |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 617 | wmod = self.module |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 618 | # Ensure warnings are recorded when requested |
| 619 | with wmod.catch_warnings(module=wmod, record=True) as w: |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 620 | self.assertEqual(w, []) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 621 | self.assertTrue(type(w) is list) |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 622 | wmod.simplefilter("always") |
| 623 | wmod.warn("foo") |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 624 | self.assertEqual(str(w[-1].message), "foo") |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 625 | wmod.warn("bar") |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 626 | self.assertEqual(str(w[-1].message), "bar") |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 627 | self.assertEqual(str(w[0].message), "foo") |
| 628 | self.assertEqual(str(w[1].message), "bar") |
Brett Cannon | 1cd0247 | 2008-09-09 01:52:27 +0000 | [diff] [blame] | 629 | del w[:] |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 630 | self.assertEqual(w, []) |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 631 | # Ensure warnings are not recorded when not requested |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 632 | orig_showwarning = wmod.showwarning |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 633 | with wmod.catch_warnings(module=wmod, record=False) as w: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 634 | self.assertTrue(w is None) |
| 635 | self.assertTrue(wmod.showwarning is orig_showwarning) |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 636 | |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 637 | def test_catch_warnings_reentry_guard(self): |
| 638 | wmod = self.module |
| 639 | # Ensure catch_warnings is protected against incorrect usage |
| 640 | x = wmod.catch_warnings(module=wmod, record=True) |
| 641 | self.assertRaises(RuntimeError, x.__exit__) |
| 642 | with x: |
| 643 | self.assertRaises(RuntimeError, x.__enter__) |
| 644 | # Same test, but with recording disabled |
| 645 | x = wmod.catch_warnings(module=wmod, record=False) |
| 646 | self.assertRaises(RuntimeError, x.__exit__) |
| 647 | with x: |
| 648 | self.assertRaises(RuntimeError, x.__enter__) |
| 649 | |
| 650 | def test_catch_warnings_defaults(self): |
| 651 | wmod = self.module |
| 652 | orig_filters = wmod.filters |
| 653 | orig_showwarning = wmod.showwarning |
| 654 | # Ensure default behaviour is not to record warnings |
| 655 | with wmod.catch_warnings(module=wmod) as w: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 656 | self.assertTrue(w is None) |
| 657 | self.assertTrue(wmod.showwarning is orig_showwarning) |
| 658 | self.assertTrue(wmod.filters is not orig_filters) |
| 659 | self.assertTrue(wmod.filters is orig_filters) |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 660 | if wmod is sys.modules['warnings']: |
| 661 | # Ensure the default module is this one |
| 662 | with wmod.catch_warnings() as w: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 663 | self.assertTrue(w is None) |
| 664 | self.assertTrue(wmod.showwarning is orig_showwarning) |
| 665 | self.assertTrue(wmod.filters is not orig_filters) |
| 666 | self.assertTrue(wmod.filters is orig_filters) |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 667 | |
| 668 | def test_check_warnings(self): |
| 669 | # Explicit tests for the test.support convenience wrapper |
| 670 | wmod = self.module |
Florent Xicluna | 53b506be | 2010-03-18 20:00:57 +0000 | [diff] [blame] | 671 | if wmod is not sys.modules['warnings']: |
| 672 | return |
| 673 | with support.check_warnings(quiet=False) as w: |
| 674 | self.assertEqual(w.warnings, []) |
| 675 | wmod.simplefilter("always") |
| 676 | wmod.warn("foo") |
| 677 | self.assertEqual(str(w.message), "foo") |
| 678 | wmod.warn("bar") |
| 679 | self.assertEqual(str(w.message), "bar") |
| 680 | self.assertEqual(str(w.warnings[0].message), "foo") |
| 681 | self.assertEqual(str(w.warnings[1].message), "bar") |
| 682 | w.reset() |
| 683 | self.assertEqual(w.warnings, []) |
| 684 | |
| 685 | with support.check_warnings(): |
| 686 | # defaults to quiet=True without argument |
| 687 | pass |
| 688 | with support.check_warnings(('foo', UserWarning)): |
| 689 | wmod.warn("foo") |
| 690 | |
| 691 | with self.assertRaises(AssertionError): |
| 692 | with support.check_warnings(('', RuntimeWarning)): |
| 693 | # defaults to quiet=False with argument |
| 694 | pass |
| 695 | with self.assertRaises(AssertionError): |
| 696 | with support.check_warnings(('foo', RuntimeWarning)): |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 697 | wmod.warn("foo") |
Benjamin Peterson | fcf5d63 | 2008-10-16 23:24:44 +0000 | [diff] [blame] | 698 | |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 699 | class CCatchWarningTests(CatchWarningTests): |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 700 | module = c_warnings |
| 701 | |
Brett Cannon | ec92e18 | 2008-09-02 02:46:59 +0000 | [diff] [blame] | 702 | class PyCatchWarningTests(CatchWarningTests): |
Nick Coghlan | b130493 | 2008-07-13 12:25:08 +0000 | [diff] [blame] | 703 | module = py_warnings |
| 704 | |
Christian Heimes | 5fb7c2a | 2007-12-24 08:52:31 +0000 | [diff] [blame] | 705 | |
Philip Jenvey | 0805ca3 | 2010-04-07 04:04:10 +0000 | [diff] [blame] | 706 | class EnvironmentVariableTests(BaseTest): |
| 707 | |
| 708 | def test_single_warning(self): |
| 709 | newenv = os.environ.copy() |
| 710 | newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning" |
| 711 | p = subprocess.Popen([sys.executable, |
| 712 | "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"], |
| 713 | stdout=subprocess.PIPE, env=newenv) |
Benjamin Peterson | ad6139a | 2010-04-11 21:16:33 +0000 | [diff] [blame] | 714 | self.assertEqual(p.communicate()[0], b"['ignore::DeprecationWarning']") |
| 715 | self.assertEqual(p.wait(), 0) |
Philip Jenvey | 0805ca3 | 2010-04-07 04:04:10 +0000 | [diff] [blame] | 716 | |
| 717 | def test_comma_separated_warnings(self): |
| 718 | newenv = os.environ.copy() |
| 719 | newenv["PYTHONWARNINGS"] = ("ignore::DeprecationWarning," |
| 720 | "ignore::UnicodeWarning") |
| 721 | p = subprocess.Popen([sys.executable, |
| 722 | "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"], |
| 723 | stdout=subprocess.PIPE, env=newenv) |
Benjamin Peterson | ad6139a | 2010-04-11 21:16:33 +0000 | [diff] [blame] | 724 | self.assertEqual(p.communicate()[0], |
Philip Jenvey | 0805ca3 | 2010-04-07 04:04:10 +0000 | [diff] [blame] | 725 | b"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']") |
Benjamin Peterson | ad6139a | 2010-04-11 21:16:33 +0000 | [diff] [blame] | 726 | self.assertEqual(p.wait(), 0) |
Philip Jenvey | 0805ca3 | 2010-04-07 04:04:10 +0000 | [diff] [blame] | 727 | |
| 728 | def test_envvar_and_command_line(self): |
| 729 | newenv = os.environ.copy() |
| 730 | newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning" |
| 731 | p = subprocess.Popen([sys.executable, "-W" "ignore::UnicodeWarning", |
| 732 | "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"], |
| 733 | stdout=subprocess.PIPE, env=newenv) |
Benjamin Peterson | ad6139a | 2010-04-11 21:16:33 +0000 | [diff] [blame] | 734 | self.assertEqual(p.communicate()[0], |
Philip Jenvey | 0805ca3 | 2010-04-07 04:04:10 +0000 | [diff] [blame] | 735 | b"['ignore::UnicodeWarning', 'ignore::DeprecationWarning']") |
Benjamin Peterson | ad6139a | 2010-04-11 21:16:33 +0000 | [diff] [blame] | 736 | self.assertEqual(p.wait(), 0) |
Philip Jenvey | 0805ca3 | 2010-04-07 04:04:10 +0000 | [diff] [blame] | 737 | |
Philip Jenvey | e53de3d | 2010-04-14 03:01:39 +0000 | [diff] [blame] | 738 | @unittest.skipUnless(sys.getfilesystemencoding() != 'ascii', |
| 739 | 'requires non-ascii filesystemencoding') |
| 740 | def test_nonascii(self): |
| 741 | newenv = os.environ.copy() |
| 742 | newenv["PYTHONWARNINGS"] = "ignore:DeprecaciónWarning" |
| 743 | newenv["PYTHONIOENCODING"] = "utf-8" |
| 744 | p = subprocess.Popen([sys.executable, |
| 745 | "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"], |
| 746 | stdout=subprocess.PIPE, env=newenv) |
| 747 | self.assertEqual(p.communicate()[0], |
| 748 | "['ignore:DeprecaciónWarning']".encode('utf-8')) |
| 749 | self.assertEqual(p.wait(), 0) |
| 750 | |
Philip Jenvey | 0805ca3 | 2010-04-07 04:04:10 +0000 | [diff] [blame] | 751 | class CEnvironmentVariableTests(EnvironmentVariableTests): |
| 752 | module = c_warnings |
| 753 | |
| 754 | class PyEnvironmentVariableTests(EnvironmentVariableTests): |
| 755 | module = py_warnings |
| 756 | |
| 757 | |
Victor Stinner | 7d79b8b | 2010-05-19 20:40:50 +0000 | [diff] [blame] | 758 | class BootstrapTest(unittest.TestCase): |
| 759 | def test_issue_8766(self): |
| 760 | # "import encodings" emits a warning whereas the warnings is not loaded |
| 761 | # or not completly loaded (warnings imports indirectly encodings by |
| 762 | # importing linecache) yet |
| 763 | with support.temp_cwd() as cwd, support.temp_cwd('encodings'): |
| 764 | env = os.environ.copy() |
| 765 | env['PYTHONPATH'] = cwd |
| 766 | |
| 767 | # encodings loaded by initfsencoding() |
| 768 | retcode = subprocess.call([sys.executable, '-c', 'pass'], env=env) |
| 769 | self.assertEqual(retcode, 0) |
| 770 | |
| 771 | # Use -W to load warnings module at startup |
| 772 | retcode = subprocess.call( |
| 773 | [sys.executable, '-c', 'pass', '-W', 'always'], |
| 774 | env=env) |
| 775 | self.assertEqual(retcode, 0) |
| 776 | |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 777 | def test_main(): |
Christian Heimes | dae2a89 | 2008-04-19 00:55:37 +0000 | [diff] [blame] | 778 | py_warnings.onceregistry.clear() |
| 779 | c_warnings.onceregistry.clear() |
Victor Stinner | 7d79b8b | 2010-05-19 20:40:50 +0000 | [diff] [blame] | 780 | support.run_unittest( |
| 781 | CFilterTests, PyFilterTests, |
| 782 | CWarnTests, PyWarnTests, |
| 783 | CWCmdLineTests, PyWCmdLineTests, |
| 784 | _WarningsTests, |
| 785 | CWarningsDisplayTests, PyWarningsDisplayTests, |
| 786 | CCatchWarningTests, PyCatchWarningTests, |
| 787 | CEnvironmentVariableTests, PyEnvironmentVariableTests, |
| 788 | BootstrapTest, |
| 789 | ) |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 790 | |
Raymond Hettinger | d6f6e50 | 2003-07-13 08:37:40 +0000 | [diff] [blame] | 791 | |
| 792 | if __name__ == "__main__": |
Christian Heimes | 33fe809 | 2008-04-13 13:53:33 +0000 | [diff] [blame] | 793 | test_main() |