Apply suggestions

* Update tests
* Add test cases for missing colons
* Check missing colons

Author: donbarbos

Lib/_strptime.py

@@ -557,8 +557,17 @@ def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
         raise ValueError("time data %r does not match format %r" %
                          (data_string, format))
     if len(data_string) != found.end():
-        raise ValueError("unconverted data remains: %s" %
-                          data_string[found.end():])
+        rest = data_string[found.end():]
+        # Specific check for '%:z' directive
+        if (
+            "colon_z" in found.re.groupindex
+            and found.group("colon_z") is not None
+            and rest[0] != ":"
+        ):
+            raise ValueError(
+                f"Missing colon in %:z before '{rest}', got '{data_string}'"
+            )
+        raise ValueError("unconverted data remains: %s" % rest)
 
     iso_year = year = None
     month = day = 1

Lib/test/test_strptime.py

@@ -406,45 +406,50 @@ def test_offset(self):
         (*_, offset), _, offset_fraction = _strptime._strptime("-013030.000001", "%z")
         self.assertEqual(offset, -(one_hour + half_hour + half_minute))
         self.assertEqual(offset_fraction, -1)
+
+        cases = [
+            ("+01:00", one_hour, 0),
+            ("-01:30", -(one_hour + half_hour), 0),
+            ("-01:30:30", -(one_hour + half_hour + half_minute), 0),
+            ("-01:30:30.000001", -(one_hour + half_hour + half_minute), -1),
+            ("+01:30:30.001", +(one_hour + half_hour + half_minute), 1000),
+            ("Z", 0, 0),
+        ]
         for directive in ("%z", "%:z"):
-            (*_, offset), _, offset_fraction = _strptime._strptime("+01:00",
-                                                                   directive)
-            self.assertEqual(offset, one_hour)
-            self.assertEqual(offset_fraction, 0)
-            (*_, offset), _, offset_fraction = _strptime._strptime("-01:30",
-                                                                   directive)
-            self.assertEqual(offset, -(one_hour + half_hour))
-            self.assertEqual(offset_fraction, 0)
-            (*_, offset), _, offset_fraction = _strptime._strptime("-01:30:30",
-                                                                   directive)
-            self.assertEqual(offset, -(one_hour + half_hour + half_minute))
-            self.assertEqual(offset_fraction, 0)
-            (*_, offset), _, offset_fraction = _strptime._strptime("-01:30:30.000001",
-                                                                   directive)
-            self.assertEqual(offset, -(one_hour + half_hour + half_minute))
-            self.assertEqual(offset_fraction, -1)
-            (*_, offset), _, offset_fraction = _strptime._strptime("+01:30:30.001",
-                                                                   directive)
-            self.assertEqual(offset, one_hour + half_hour + half_minute)
-            self.assertEqual(offset_fraction, 1000)
-            (*_, offset), _, offset_fraction = _strptime._strptime("Z",
-                                                                   directive)
-            self.assertEqual(offset, 0)
-            self.assertEqual(offset_fraction, 0)
+            for offset_str, expected_offset, expected_fraction in cases:
+                with self.subTest(offset_str=offset_str, directive=directive):
+                    (*_, offset), _, offset_fraction = _strptime._strptime(
+                        offset_str, directive
+                    )
+                    self.assertEqual(offset, expected_offset)
+                    self.assertEqual(offset_fraction, expected_fraction)
 
     def test_bad_offset(self):
+        error_cases_any_z = [
+            "-01:30:30.",         # Decimal point not followed with digits
+            "-01:30:30.1234567",  # Too many digits after decimal point
+            "-01:30:30:123456",   # Colon as decimal separator
+            "-0130:30",           # Incorrect use of colons
+        ]
         for directive in ("%z", "%:z"):
-            with self.assertRaises(ValueError):
-                _strptime._strptime("-01:30:30.", directive)
-            with self.assertRaises(ValueError):
-                _strptime._strptime("-01:30:30.1234567", directive)
-            with self.assertRaises(ValueError):
-                _strptime._strptime("-01:30:30:123456", directive)
-        with self.assertRaises(ValueError):
-            _strptime._strptime("-0130:30", "%z")
+            for timestr in error_cases_any_z:
+                with self.subTest(timestr=timestr, directive=directive):
+                    with self.assertRaises(ValueError):
+                        _strptime._strptime(timestr, directive)
+
+        required_colons_cases = ["-013030", "+0130", "-01:3030.123456"]
+        for timestr in required_colons_cases:
+            with self.subTest(timestr=timestr):
+                with self.assertRaises(ValueError):
+                    _strptime._strptime(timestr, "%:z")
+
         with self.assertRaises(ValueError) as err:
             _strptime._strptime("-01:3030", "%z")
         self.assertEqual("Inconsistent use of : in -01:3030", str(err.exception))
+        with self.assertRaises(ValueError) as err:
+            _strptime._strptime("-01:3030", "%:z")
+        self.assertEqual("Missing colon in %:z before '30', got '-01:3030'",
+                         str(err.exception))
 
     @skip_if_buggy_ucrt_strfptime
     def test_timezone(self):