Doc/reference/ @willingc @AA-Turner
**/*weakref* @kumaraditya303
+
+# Colorize
+Lib/_colorize.py @hugovk
+Lib/test/test__colorize.py @hugovk
return False
if os.environ.get("PYTHON_COLORS") == "1":
return True
- if "NO_COLOR" in os.environ:
- return False
+ if "NO_COLOR" in os.environ:
+ return False
if not COLORIZE:
return False
- if not sys.flags.ignore_environment:
- if "FORCE_COLOR" in os.environ:
- return True
- if os.environ.get("TERM") == "dumb":
- return False
+ if "FORCE_COLOR" in os.environ:
+ return True
+ if os.environ.get("TERM") == "dumb":
+ return False
if not hasattr(file, "fileno"):
return False
"without_optimizer",
"force_not_colorized",
"force_not_colorized_test_class",
+ "make_clean_env",
"BrokenIter",
"in_systemd_nspawn_sync_suppressed",
"run_no_yield_async_fn", "run_yielding_async_fn", "async_yield",
return cls
+def make_clean_env() -> dict[str, str]:
+ clean_env = os.environ.copy()
+ for k in clean_env.copy():
+ if k.startswith("PYTHON"):
+ clean_env.pop(k)
+ clean_env.pop("FORCE_COLOR", None)
+ clean_env.pop("NO_COLOR", None)
+ return clean_env
+
+
def initialized_with_pyrepl():
"""Detect whether PyREPL was used during Python initialization."""
# If the main module has a __file__ attribute it's a Python module, which means PyREPL.
import unittest
import unittest.mock
import _colorize
-from test.support import force_not_colorized
+from test.support import force_not_colorized, make_clean_env
ORIGINAL_CAN_COLORIZE = _colorize.can_colorize
class TestColorizeFunction(unittest.TestCase):
+ def setUp(self):
+ # Remove PYTHON* environment variables to isolate from local user
+ # settings and simulate running with `-E`. Such variables should be
+ # added to test methods later to patched os.environ.
+ patcher = unittest.mock.patch("os.environ", new=make_clean_env())
+ self.addCleanup(patcher.stop)
+ patcher.start()
+
@force_not_colorized
def test_colorized_detection_checks_for_environment_variables(self):
flags = unittest.mock.MagicMock(ignore_environment=False)
id = _testcapi.instancemethod(id)
testfunction = _testcapi.instancemethod(testfunction)
+
CURRENT_THREAD_REGEX = r'Current thread.*:\n' if not support.Py_GIL_DISABLED else r'Stack .*:\n'
+
+@support.force_not_colorized_test_class
class CAPITest(unittest.TestCase):
def test_instancemethod(self):
importlib.invalidate_caches()
return to_return
+
+@support.force_not_colorized_test_class
class CmdLineTest(unittest.TestCase):
def _check_output(self, script_name, exit_code, data,
expected_file, expected_argv0,
rc, out, err = self.assertRunNotOK('-q', '-d', 'dinsdale', self.pkgdir)
self.assertRegex(out, b'File "dinsdale')
+ @support.force_not_colorized
def test_d_runtime_error(self):
bazfn = script_helper.make_script(self.pkgdir, 'baz', 'raise Exception')
self.assertRunOK('-q', '-d', 'dinsdale', self.pkgdir)
import sys
from codecs import BOM_UTF8
-from test import support
+from test.support import force_not_colorized
from test.support import os_helper
from test.support import script_helper
from test.support import warnings_helper
self.assertEqual(cm.exception.text, "ä = '''thîs is ")
self.assertEqual(cm.exception.offset, 5)
+ @force_not_colorized
def test_EOFS_with_file(self):
expect = ("(<string>, line 1)")
with os_helper.temp_dir() as temp_dir:
self.assertEqual(str(cm.exception), expect)
@unittest.skipIf(not sys.executable, "sys.executable required")
+ @force_not_colorized
def test_line_continuation_EOF_from_file_bpo2180(self):
"""Ensure tok_nextc() does not add too many ending newlines."""
with os_helper.temp_dir() as temp_dir:
@cpython_only
@unittest.skipIf(_testcapi is None, "requires _testcapi")
+ @force_not_colorized
def test_recursion_normalizing_infinite_exception(self):
# Issue #30697. Test that a RecursionError is raised when
# maximum recursion depth has been exceeded when creating
self.assertEqual(result[-len(expected):], expected)
+@support.force_not_colorized_test_class
class SyntaxErrorTests(unittest.TestCase):
maxDiff = None
from test.support import os_helper
from test.support import (
- STDLIB_DIR, swap_attr, swap_item, cpython_only, is_apple_mobile, is_emscripten,
- is_wasi, run_in_subinterp, run_in_subinterp_with_config, Py_TRACE_REFS,
- requires_gil_enabled, Py_GIL_DISABLED, no_rerun)
+ STDLIB_DIR,
+ swap_attr,
+ swap_item,
+ cpython_only,
+ is_apple_mobile,
+ is_emscripten,
+ is_wasi,
+ run_in_subinterp,
+ run_in_subinterp_with_config,
+ Py_TRACE_REFS,
+ requires_gil_enabled,
+ Py_GIL_DISABLED,
+ no_rerun,
+ force_not_colorized_test_class,
+)
from test.support.import_helper import (
forget, make_legacy_pyc, unlink, unload, ready_to_import,
DirsOnSysPath, CleanImport, import_module)
return cls.parse(text.decode())
+@force_not_colorized_test_class
class ImportTests(unittest.TestCase):
def setUp(self):
self.assertEqual(src.splitlines(True), lines)
class TestGetsourceInteractive(unittest.TestCase):
+ @support.force_not_colorized
def test_getclasses_interactive(self):
# bpo-44648: simulate a REPL session;
# there is no `__file__` in the __main__ module
)
-def make_clean_env() -> dict[str, str]:
- clean_env = os.environ.copy()
- for k in clean_env.copy():
- if k.startswith("PYTHON"):
- clean_env.pop(k)
- clean_env.pop("FORCE_COLOR", None)
- clean_env.pop("NO_COLOR", None)
- return clean_env
-
-
class FakeConsole(Console):
def __init__(self, events, encoding="utf-8") -> None:
self.events = iter(events)
import tempfile
from unittest import TestCase, skipUnless, skipIf
from unittest.mock import patch
-from test.support import force_not_colorized
+from test.support import force_not_colorized, make_clean_env
from test.support import SHORT_TIMEOUT
from test.support.import_helper import import_module
from test.support.os_helper import unlink
multiline_input,
code_to_events,
clean_screen,
- make_clean_env,
)
from _pyrepl.console import Event
from _pyrepl.readline import (ReadlineAlikeReader, ReadlineConfig,
f'{", ".join(output.splitlines())}')
+@support.force_not_colorized_test_class
class ProgramsTestCase(BaseTestCase):
"""
Test various ways to run the Python test suite. Use options close
self.run_batch(script, *rt_args, *self.regrtest_args, *self.tests)
+@support.force_not_colorized_test_class
class ArgsTestCase(BaseTestCase):
"""
Test arguments of the Python test suite.
return output
+@support.force_not_colorized_test_class
class TestInteractiveInterpreter(unittest.TestCase):
@cpython_only
self.assertEqual(exit_code, 0, "".join(output))
+
+@support.force_not_colorized_test_class
class TestInteractiveModeSyntaxErrors(unittest.TestCase):
def test_interactive_syntax_error_correct_line(self):
import textwrap
import unittest
import warnings
-from test.support import (infinite_recursion, no_tracing, verbose,
- requires_subprocess, requires_resource)
+from test.support import (
+ force_not_colorized_test_class,
+ infinite_recursion,
+ no_tracing,
+ requires_resource,
+ requires_subprocess,
+ verbose,
+)
from test.support.import_helper import forget, make_legacy_pyc, unload
from test.support.os_helper import create_empty_file, temp_dir, FakePath
from test.support.script_helper import make_script, make_zip_script
self.assertEqual(result['s'], "non-ASCII: h\xe9")
+@force_not_colorized_test_class
class TestExit(unittest.TestCase):
STATUS_CONTROL_C_EXIT = 0xC000013A
EXPECTED_CODE = (
return
self.fail(f"unexpected output: {stderr!a}")
+ @force_not_colorized
def test_sys_xoptions_invalid(self):
for nframe in INVALID_NFRAME:
with self.subTest(nframe=nframe):
import sys
import unicodedata
import unittest
-from test.support import (open_urlresource, requires_resource, script_helper,
- cpython_only, check_disallow_instantiation)
+from test.support import (
+ open_urlresource,
+ requires_resource,
+ script_helper,
+ cpython_only,
+ check_disallow_instantiation,
+ force_not_colorized,
+)
class UnicodeMethodsTest(unittest.TestCase):
# Ensure that the type disallows instantiation (bpo-43916)
check_disallow_instantiation(self, unicodedata.UCD)
+ @force_not_colorized
def test_failed_import_during_compiling(self):
# Issue 4367
# Decoding \N escapes requires the unicodedata module. If it can't be
from test import support
import unittest
import test.test_unittest
-from test.support import force_not_colorized
from test.test_unittest.test_result import BufferedWriter
+@support.force_not_colorized_test_class
class Test_TestProgram(unittest.TestCase):
def test_discovery_from_dotted_path(self):
self.assertEqual(['test.test_unittest', 'test.test_unittest2'],
program.testNames)
- @force_not_colorized
def test_NonExit(self):
stream = BufferedWriter()
program = unittest.main(exit=False,
'expected failures=1, unexpected successes=1)\n')
self.assertEndsWith(out, expected)
- @force_not_colorized
def test_Exit(self):
stream = BufferedWriter()
with self.assertRaises(SystemExit) as cm:
'expected failures=1, unexpected successes=1)\n')
self.assertEndsWith(out, expected)
- @force_not_colorized
def test_ExitAsDefault(self):
stream = BufferedWriter()
with self.assertRaises(SystemExit):
'expected failures=1, unexpected successes=1)\n')
self.assertEndsWith(out, expected)
- @force_not_colorized
def test_ExitSkippedSuite(self):
stream = BufferedWriter()
with self.assertRaises(SystemExit) as cm:
expected = '\n\nOK (skipped=1)\n'
self.assertEndsWith(out, expected)
- @force_not_colorized
def test_ExitEmptySuite(self):
stream = BufferedWriter()
with self.assertRaises(SystemExit) as cm:
import unittest
from unittest.util import strclass
from test.support import warnings_helper
-from test.support import (
- captured_stdout,
- force_not_colorized,
- force_not_colorized_test_class,
-)
+from test.support import captured_stdout, force_not_colorized_test_class
from test.test_unittest.support import BufferedWriter
raise ValueError('bad cleanup2')
+@force_not_colorized_test_class
class Test_TestResult(unittest.TestCase):
# Note: there are not separate tests for TestResult.wasSuccessful(),
# TestResult.errors, TestResult.failures, TestResult.testsRun or
self.assertIs(test_case, test)
self.assertIsInstance(formatted_exc, str)
- @force_not_colorized
def test_addFailure_filter_traceback_frames(self):
class Foo(unittest.TestCase):
def test_1(self):
self.assertEqual(len(dropped), 1)
self.assertIn("raise self.failureException(msg)", dropped[0])
- @force_not_colorized
def test_addFailure_filter_traceback_frames_context(self):
class Foo(unittest.TestCase):
def test_1(self):
self.assertEqual(len(dropped), 1)
self.assertIn("raise self.failureException(msg)", dropped[0])
- @force_not_colorized
def test_addFailure_filter_traceback_frames_chained_exception_self_loop(self):
class Foo(unittest.TestCase):
def test_1(self):
formatted_exc = result.failures[0][1]
self.assertEqual(formatted_exc.count("Exception: Loop\n"), 1)
- @force_not_colorized
def test_addFailure_filter_traceback_frames_chained_exception_cycle(self):
class Foo(unittest.TestCase):
def test_1(self):
result.addUnexpectedSuccess(None)
self.assertTrue(result.shouldStop)
- @force_not_colorized
def testFailFastSetByRunner(self):
stream = BufferedWriter()
runner = unittest.TextTestRunner(stream=stream, failfast=True)
self.assertEndsWith(stream.getvalue(), '\n\nOK\n')
+@force_not_colorized_test_class
class Test_TextTestResult(unittest.TestCase):
maxDiff = None
test.run(result)
return stream.getvalue()
- @force_not_colorized
def testDotsOutput(self):
self.assertEqual(self._run_test('testSuccess', 1), '.')
self.assertEqual(self._run_test('testSkip', 1), 's')
self.assertEqual(self._run_test('testExpectedFailure', 1), 'x')
self.assertEqual(self._run_test('testUnexpectedSuccess', 1), 'u')
- @force_not_colorized
def testLongOutput(self):
classname = f'{__name__}.{self.Test.__qualname__}'
self.assertEqual(self._run_test('testSuccess', 2),
self.assertEqual(self._run_test('testUnexpectedSuccess', 2),
f'testUnexpectedSuccess ({classname}.testUnexpectedSuccess) ... unexpected success\n')
- @force_not_colorized
def testDotsOutputSubTestSuccess(self):
self.assertEqual(self._run_test('testSubTestSuccess', 1), '.')
- @force_not_colorized
def testLongOutputSubTestSuccess(self):
classname = f'{__name__}.{self.Test.__qualname__}'
self.assertEqual(self._run_test('testSubTestSuccess', 2),
f'testSubTestSuccess ({classname}.testSubTestSuccess) ... ok\n')
- @force_not_colorized
def testDotsOutputSubTestMixed(self):
self.assertEqual(self._run_test('testSubTestMixed', 1), 'sFE')
- @force_not_colorized
def testLongOutputSubTestMixed(self):
classname = f'{__name__}.{self.Test.__qualname__}'
self.assertEqual(self._run_test('testSubTestMixed', 2),
f' testSubTestMixed ({classname}.testSubTestMixed) [fail] (c=3) ... FAIL\n'
f' testSubTestMixed ({classname}.testSubTestMixed) [error] (d=4) ... ERROR\n')
- @force_not_colorized
def testDotsOutputTearDownFail(self):
out = self._run_test('testSuccess', 1, AssertionError('fail'))
self.assertEqual(out, 'F')
out = self._run_test('testSkip', 1, AssertionError('fail'))
self.assertEqual(out, 'sF')
- @force_not_colorized
def testLongOutputTearDownFail(self):
classname = f'{__name__}.{self.Test.__qualname__}'
out = self._run_test('testSuccess', 2, AssertionError('fail'))
import pickle
import subprocess
from test import support
-from test.support import force_not_colorized
import unittest
from unittest.case import _Outcome
self.assertTrue(test.doCleanups())
self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3), dict(four='hello', five='goodbye'))])
- @force_not_colorized
+ @support.force_not_colorized
def testCleanUpWithErrors(self):
class TestableTest(unittest.TestCase):
def testNothing(self):
self.assertEqual(test._cleanups, [])
+@support.force_not_colorized_test_class
class TestClassCleanup(unittest.TestCase):
def test_addClassCleanUp(self):
class TestableTest(unittest.TestCase):
self.assertIsInstance(e2[1], CustomError)
self.assertEqual(str(e2[1]), 'cleanup1')
- @force_not_colorized
def test_with_errors_addCleanUp(self):
ordering = []
class TestableTest(unittest.TestCase):
['setUpClass', 'setUp', 'cleanup_exc',
'tearDownClass', 'cleanup_good'])
- @force_not_colorized
def test_run_with_errors_addClassCleanUp(self):
ordering = []
class TestableTest(unittest.TestCase):
['setUpClass', 'setUp', 'test', 'cleanup_good',
'tearDownClass', 'cleanup_exc'])
- @force_not_colorized
def test_with_errors_in_addClassCleanup_and_setUps(self):
ordering = []
class_blow_up = False
['setUpClass', 'setUp', 'tearDownClass',
'cleanup_exc'])
- @force_not_colorized
def test_with_errors_in_tearDownClass(self):
ordering = []
class TestableTest(unittest.TestCase):
'inner setup', 'inner test', 'inner cleanup',
'end outer test', 'outer cleanup'])
- @force_not_colorized
def test_run_empty_suite_error_message(self):
class EmptyTest(unittest.TestCase):
pass
self.assertIn("\nNO TESTS RAN\n", runner.stream.getvalue())
+@support.force_not_colorized_test_class
class TestModuleCleanUp(unittest.TestCase):
def test_add_and_do_ModuleCleanup(self):
module_cleanups = []
self.assertEqual(cleanups,
[((1, 2), {'function': 'hello'})])
- @force_not_colorized
def test_run_module_cleanUp(self):
blowUp = True
ordering = []
'tearDownClass', 'cleanup_good'])
self.assertEqual(unittest.case._module_cleanups, [])
- @force_not_colorized
def test_run_module_cleanUp_when_teardown_exception(self):
ordering = []
class Module(object):
self.assertEqual(cleanups,
[((1, 2), {'function': 3, 'self': 4})])
- @force_not_colorized
def test_with_errors_in_addClassCleanup(self):
ordering = []
['setUpModule', 'setUpClass', 'test', 'tearDownClass',
'cleanup_exc', 'tearDownModule', 'cleanup_good'])
- @force_not_colorized
def test_with_errors_in_addCleanup(self):
ordering = []
class Module(object):
['setUpModule', 'setUp', 'test', 'tearDown',
'cleanup_exc', 'tearDownModule', 'cleanup_good'])
- @force_not_colorized
def test_with_errors_in_addModuleCleanup_and_setUps(self):
ordering = []
module_blow_up = False
expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY)
self.assertEqual(runner._makeResult(), expectedresult)
- @force_not_colorized
+ @support.force_not_colorized
@support.requires_subprocess()
def test_warnings(self):
"""
--- /dev/null
+When ``-E`` is set, only ignore ``PYTHON_COLORS`` and not
+``FORCE_COLOR``/``NO_COLOR``/``TERM`` when colourising output.
+Patch by Hugo van Kemenade.
projects / thirdparty / Python / cpython.git / commitdiff
