Continue enhancing/improving tests

Author: zuo

Lib/test/datetimetester.py

@@ -2125,17 +2125,22 @@ def test_fromisocalendar_type_errors(self):
                     self.theclass.fromisocalendar(*isocal)
 
     def test_strftime_strptime_roundtrip_concerning_locale_specific_year(self):
-        concerned_formats = '%c', '%x'  # gh-124529
+        concerned_formats = '%c', '%x'
 
         def run_subtest():
-            reason = (f'test strftime/strptime roundtrip concerning '
-                      f'locale-specific year representation '
-                      f'- for {fmt=} and {year=}')
+            reason = (f"test strftime/strptime roundtrip concerning "
+                      f"locale-specific year representation "
+                      f"- for {fmt=} and {year=}")
+            fail_msg = f"{reason} - failed"
             initial = expected = self.theclass.strptime(f'{year:04}', '%Y')
             with self.subTest(reason=reason):
                 formatted = initial.strftime(fmt)
-                parsed = self.theclass.strptime(formatted, fmt)
-                self.assertEqual(parsed, expected, msg=reason)
+                try:
+                    parsed = self.theclass.strptime(formatted, fmt)
+                except ValueError as exc:
+                    # gh-124529
+                    self.fail(f"{fail_msg}; parsing error: {exc!r}")
+                self.assertEqual(parsed, expected, fail_msg)
 
         sample = self.theclass.strptime(f'1999-03-17', '%Y-%m-%d')
         for fmt in concerned_formats:
@@ -2161,17 +2166,22 @@ def run_subtest():
                               f"severely wrong with current locale?)")
 
     def test_strptime_accepting_locale_specific_year_with_fewer_digits(self):
-        concerned_formats = '%c', '%x'  # gh-124529
+        concerned_formats = '%c', '%x'
 
         def run_subtest():
             input_str = sample_str.replace(sample_digits, year_digits)
-            reason = (f'test strptime accepting locale-specific '
-                      f'year representation with fewer digits '
-                      f'- for {fmt=} and {input_str=} ({year=})')
+            reason = (f"test strptime accepting locale-specific "
+                      f"year representation with fewer digits "
+                      f"- for {fmt=} and {input_str=} ({year=})")
+            fail_msg = f"{reason} - failed"
             expected = sample.replace(year=year)
             with self.subTest(reason=reason):
-                parsed = self.theclass.strptime(input_str, fmt)
-                self.assertEqual(parsed, expected, msg=reason)
+                try:
+                    parsed = self.theclass.strptime(input_str, fmt)
+                except ValueError as exc:
+                    # gh-124529
+                    self.fail(f"{fail_msg}; parsing error: {exc!r}")
+                self.assertEqual(parsed, expected, fail_msg)
 
         sample = self.theclass.strptime(f'1999-03-17', '%Y-%m-%d')
         for fmt in concerned_formats:

Lib/test/test_strptime.py

@@ -174,22 +174,26 @@ def test_compile(self):
                 # gh-124529
                 params = _input_str_and_expected_year_for_few_digits_year(fmt)
                 if params is None:
-                    self.skipTest(f"this subtest needs locale for which "
-                                  f"{fmt!r} includes year in some variant")
+                    self.fail(f"it seems that using {fmt=} results in value "
+                              f"which does not include year representation "
+                              f"in any expected format (is there something "
+                              f"severely wrong with current locale?)")
                 input_string, _ = params
                 compiled = self.time_re.compile(fmt)
                 found = compiled.match(input_string)
                 self.assertTrue(found,
                                 (f"Matching failed on '{input_string}' "
                                  f"using '{compiled.pattern}' regex"))
-        for directive in ('y', 'Y'):
+        for directive in ('y', 'Y', 'G'):
             fmt = "%" + directive
             with self.subTest(f"{fmt!r} should not match input containing "
                               f"year with fewer digits than usual"):
                 params = _input_str_and_expected_year_for_few_digits_year(fmt)
                 if params is None:
-                    self.skipTest(f"this subtest needs locale for which "
-                                  f"{fmt!r} includes year in some variant")
+                    self.fail(f"it seems that using {fmt=} results in value "
+                              f"which does not include year representation "
+                              f"in any expected format (is there something "
+                              f"severely wrong with current locale?)")
                 input_string, _ = params
                 compiled = self.time_re.compile(fmt)
                 found = compiled.match(input_string)
@@ -334,8 +338,10 @@ def helper_for_directives_accepting_few_digits_year(self, directive):
         fmt = "%" + directive
         params = _input_str_and_expected_year_for_few_digits_year(fmt)
         if params is None:
-            self.skipTest(f"test needs locale for which {fmt!r} "
-                          f"includes year in some variant")
+            self.fail(f"it seems that using {fmt=} results in value "
+                      f"which does not include year representation "
+                      f"in any expected format (is there something "
+                      f"severely wrong with current locale?)")
         input_string, expected_year = params
         try:
             output_year = _strptime._strptime(input_string, fmt)[0][0]