Fix string mutation for \N{...} and \U{...} and remove capitalize mutation (#409)

I removed the string capitalize mutation as I think that most bugs are already covered by the XX...XX and upper/lower-casing mutations. So I don't think this is worth the additional test runs.

Author: Otto-AA

e2e_projects/my_lib/src/my_lib/__init__.py

@@ -57,4 +57,9 @@ def from_coords(coords) -> 'Point':
 
     @property
     def coords(self):
-        return self.x, self.y
+        return self.x, self.y
+
+
+def escape_sequences():
+    return "foo" \
+           "FOO\\\'\"\a\b\f\n\r\t\v\111\x10\N{ghost}\u1234\U0001F51F"

e2e_projects/my_lib/tests/test_my_lib.py

@@ -1,4 +1,4 @@
-from my_lib import hello, Point, badly_tested, make_greeter, fibonacci, cached_fibonacci
+from my_lib import hello, Point, badly_tested, make_greeter, fibonacci, cached_fibonacci, escape_sequences
 
 """These tests are flawed on purpose, some mutants survive and some are killed."""
 
@@ -31,3 +31,6 @@ def test_point_from_coords():
 def test_fibonacci():
     assert fibonacci(1) == 1
     assert cached_fibonacci(1) == 1
+
+def test_escape_sequences():
+    assert escape_sequences().lower() == "foofoo\\\'\"\a\b\f\n\r\t\v\111\x10\N{ghost}\u1234\U0001F51F".lower()

mutmut/node_mutation.py

@@ -12,7 +12,8 @@
     ]
 ]
 
-CHARACTER_AFTER_BACKSLASH = re.compile(r"\\([A-Z])")
+# pattern to match (nearly) all chars in a string that are not part of an escape sequence
+NON_ESCAPE_SEQUENCE = re.compile(r"((?<!\\)[^\\]+)")
 
 def operator_number(
     node: cst.BaseNumber
@@ -42,9 +43,9 @@ def operator_string(
 
         supported_str_mutations: list[Callable[[str], str]] = [
             lambda x: "XX" + x + "XX",
-            lambda x: x.lower(),
-            lambda x: CHARACTER_AFTER_BACKSLASH.sub(lambda match: f"\\{match.group(1).lower()}", x.upper()),
-            lambda x: x.capitalize(),
+            # do not modify escape sequences, as this could break python syntax
+            lambda x: NON_ESCAPE_SEQUENCE.sub(lambda match: match.group(1).lower(), x),
+            lambda x: NON_ESCAPE_SEQUENCE.sub(lambda match: match.group(1).upper(), x),
         ]
 
         for mut_func in supported_str_mutations:

tests/e2e/snapshots/my_lib.json

@@ -40,6 +40,11 @@
     "my_lib.x\u01c1Point\u01c1to_origin__mutmut_1": 1,
     "my_lib.x\u01c1Point\u01c1to_origin__mutmut_2": 1,
     "my_lib.x\u01c1Point\u01c1to_origin__mutmut_3": 0,
-    "my_lib.x\u01c1Point\u01c1to_origin__mutmut_4": 0
+    "my_lib.x\u01c1Point\u01c1to_origin__mutmut_4": 0,
+    "my_lib.x_escape_sequences__mutmut_1": 1,
+    "my_lib.x_escape_sequences__mutmut_2": 0,
+    "my_lib.x_escape_sequences__mutmut_3": 1,
+    "my_lib.x_escape_sequences__mutmut_4": 0,
+    "my_lib.x_escape_sequences__mutmut_5": 0
   }
 }

tests/test_mutation.py

@@ -125,8 +125,9 @@ def mutated_module(source: str) -> str:
         ('x: list[A | None]', []),
         ('a: Optional[int] = None', 'a: Optional[int] = ""'),
         ('a: int = 1', ['a: int = 2', 'a: int = None']),
-        ('a: str = "FoO"', ['a: str = "XXFoOXX"', 'a: str = "foo"', 'a: str = "FOO"', 'a: str = "Foo"', 'a: str = None']),
-        ('a: str = "Fo\\t"', ['a: str = "XXFo\\tXX"', 'a: str = "fo\\t"', 'a: str = "FO\\t"', 'a: str = None']),
+        ('a: str = "FoO"', ['a: str = "XXFoOXX"', 'a: str = "foo"', 'a: str = "FOO"', 'a: str = None']),
+        (r'a: str = "Fo\t"', [r'a: str = "XXFo\tXX"', r'a: str = "FO\t"', r'a: str = "fo\t"', 'a: str = None']),
+        (r'a: str = "Fo\N{ghost} \U11223344"', [r'a: str = "XXFo\N{ghost} \U11223344XX"', r'a: str = "FO\N{GHOST} \U11223344"', r'a: str = "fo\N{ghost} \U11223344"', 'a: str = None']),
         ('lambda: 0', ['lambda: 1', 'lambda: None']),
         ("1 in (1, 2)", ['2 in (1, 2)', '1 not in (1, 2)', '1 in (2, 2)', '1 in (1, 3)']),
         ('1+1', ['2+1', '1 - 1', '1+2']),
@@ -149,9 +150,9 @@ def mutated_module(source: str) -> str:
         ('1e-3', '1.001'),
         ('True', 'False'),
         ('False', 'True'),
-        ('"FoO"', ['"XXFoOXX"', '"foo"', '"FOO"', '"Foo"']),
-        ("'FoO'", ["'XXFoOXX'", "'foo'", "'FOO'", "'Foo'"]),
-        ("u'FoO'", ["u'XXFoOXX'", "u'foo'", "u'FOO'", "u'Foo'"]),
+        ('"FoO"', ['"XXFoOXX"', '"foo"', '"FOO"']),
+        ("'FoO'", ["'XXFoOXX'", "'foo'", "'FOO'"]),
+        ("u'FoO'", ["u'XXFoOXX'", "u'foo'", "u'FOO'"]),
         ("10", "11"),
         ("10.", "11.0"),
         ("0o10", "9"),