waste time dealing with bad unicode test env. life

Author: gpshead

Lib/test/test_traceback_timestamps.py

@@ -46,71 +46,67 @@ def cause_exception():
     def test_no_traceback_timestamps(self):
         """Test that traceback timestamps are not shown by default"""
         result = script_helper.assert_python_ok(self.script_path)
-        stderr = result.err.decode()
-        self.assertNotIn("<@", stderr)  # No timestamp should be present
+        self.assertNotIn(b"<@", result.err)  # No timestamp should be present
 
     def test_traceback_timestamps_env_var(self):
         """Test that PYTHON_TRACEBACK_TIMESTAMPS env var enables timestamps"""
         result = script_helper.assert_python_ok(
             self.script_path, PYTHON_TRACEBACK_TIMESTAMPS="us"
         )
-        stderr = result.err.decode()
-        self.assertIn("<@", stderr)  # Timestamp should be present
+        self.assertIn(b"<@", result.err)  # Timestamp should be present
 
     def test_traceback_timestamps_flag_us(self):
         """Test -X traceback_timestamps=us flag"""
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps=us", self.script_path
         )
-        stderr = result.err.decode()
-        self.assertIn("<@", stderr)  # Timestamp should be present
+        self.assertIn(b"<@", result.err)  # Timestamp should be present
 
     def test_traceback_timestamps_flag_ns(self):
         """Test -X traceback_timestamps=ns flag"""
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps=ns", self.script_path
         )
-        stderr = result.err.decode()
-        self.assertIn("<@", stderr)  # Timestamp should be present
-        self.assertIn("ns>", stderr)  # Should have ns format
+        stderr = result.err
+        self.assertIn(b"<@", result.err)  # Timestamp should be present
+        self.assertIn(b"ns>", result.err)  # Should have ns format
 
     def test_traceback_timestamps_flag_iso(self):
         """Test -X traceback_timestamps=iso flag"""
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps=iso", self.script_path
         )
-        stderr = result.err.decode()
-        self.assertIn("<@", stderr)  # Timestamp should be present
+        self.assertIn(b"<@", result.err)  # Timestamp should be present
         # ISO format with Z suffix for UTC
-        self.assertRegex(stderr, r"<@\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z>")
+        self.assertRegex(result.err, br"<@\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z>")
 
     def test_traceback_timestamps_flag_value(self):
         """Test that sys.flags.traceback_timestamps shows the right value"""
         # Default should be empty string
         result = script_helper.assert_python_ok(self.flags_script_path)
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "''")
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"''")
 
         # With us flag
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps=us", self.flags_script_path
         )
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "'us'")
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"'us'")
 
         # With ns flag
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps=ns", self.flags_script_path
         )
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "'ns'")
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"'ns'")
 
         # With iso flag
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps=iso", self.flags_script_path
         )
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "'iso'")
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"'iso'")
 
     def test_traceback_timestamps_env_var_precedence(self):
         """Test that -X flag takes precedence over env var"""
@@ -121,72 +117,70 @@ def test_traceback_timestamps_env_var_precedence(self):
             "import sys; print(repr(sys.flags.traceback_timestamps))",
             PYTHON_TRACEBACK_TIMESTAMPS="ns",
         )
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "'us'")
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"'us'")
 
     def test_traceback_timestamps_flag_no_value(self):
         """Test -X traceback_timestamps with no value defaults to 'us'"""
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps", self.flags_script_path
         )
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "'us'")
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"'us'")
 
     def test_traceback_timestamps_flag_zero(self):
         """Test -X traceback_timestamps=0 disables the feature"""
         # Check that setting to 0 results in empty string in sys.flags
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps=0", self.flags_script_path
         )
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "''")
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"''")
 
         # Check that no timestamps appear in traceback
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps=0", self.script_path
         )
-        stderr = result.err.decode()
-        self.assertNotIn("<@", stderr)  # No timestamp should be present
+        self.assertNotIn(b"<@", result.err)  # No timestamp should be present
 
     def test_traceback_timestamps_flag_one(self):
         """Test -X traceback_timestamps=1 is equivalent to 'us'"""
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps=1", self.flags_script_path
         )
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "'us'")
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"'us'")
 
     def test_traceback_timestamps_env_var_zero(self):
         """Test PYTHON_TRACEBACK_TIMESTAMPS=0 disables the feature"""
         result = script_helper.assert_python_ok(
             self.flags_script_path, PYTHON_TRACEBACK_TIMESTAMPS="0"
         )
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "''")
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"''")
 
     def test_traceback_timestamps_env_var_one(self):
         """Test PYTHON_TRACEBACK_TIMESTAMPS=1 is equivalent to 'us'"""
         result = script_helper.assert_python_ok(
             self.flags_script_path, PYTHON_TRACEBACK_TIMESTAMPS="1"
         )
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "'us'")
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"'us'")
 
     def test_traceback_timestamps_invalid_env_var(self):
         """Test that invalid env var values are silently ignored"""
         result = script_helper.assert_python_ok(
             self.flags_script_path, PYTHON_TRACEBACK_TIMESTAMPS="invalid"
         )
-        stdout = result.out.decode().strip()
-        self.assertEqual(stdout, "''")  # Should default to empty string
+        stdout = result.out.strip()
+        self.assertEqual(stdout, b"''")  # Should default to empty string
 
     def test_traceback_timestamps_invalid_flag(self):
         """Test that invalid flag values cause an error"""
         result = script_helper.assert_python_failure(
             "-X", "traceback_timestamps=invalid", self.flags_script_path
         )
-        stderr = result.err.decode()
-        self.assertIn("Invalid -X traceback_timestamps=value option", stderr)
+        self.assertIn(b"Invalid -X traceback_timestamps=value option", result.err)
 
 
 class StripExcTimestampsTests(unittest.TestCase):
@@ -224,14 +218,14 @@ def test_strip_exc_timestamps_function(self):
                     "-X", f"traceback_timestamps={mode}",
                     self.script_strip_path
                 )
-                output = result.out.decode() + result.err.decode()
+                output = result.out.decode() + result.err.decode(errors='replace')
 
                 # call strip_exc_timestamps in a process using the same mode as what generated our output.
                 result = script_helper.assert_python_ok(
                     "-X", f"traceback_timestamps={mode}",
                     self.script_strip_path, output
                 )
-                stripped_output = result.out.decode() + result.err.decode()
+                stripped_output = result.out.decode() + result.err.decode(errors='replace')
 
                 # Verify original strings have timestamps and stripped ones don't
                 self.assertIn("ZeroDivisionError: division by zero <@", output)
@@ -246,13 +240,13 @@ def test_strip_exc_timestamps_with_disabled_timestamps(self):
         result = script_helper.assert_python_failure(
             "-X", "traceback_timestamps=0", self.script_strip_path
         )
-        output = result.out.decode() + result.err.decode()
+        output = result.out.decode() + result.err.decode(errors='replace')
 
         # call strip_exc_timestamps in a process using the same mode as what generated our output.
         result = script_helper.assert_python_ok(
             "-X", "traceback_timestamps=0", self.script_strip_path, output
         )
-        stripped_output = result.out.decode() + result.err.decode()
+        stripped_output = result.out.decode() + result.err.decode(errors='replace')
 
         # All strings should be unchanged by the strip function
         self.assertIn("ZeroDivisionError: division by zero\n", stripped_output)