improve tests

Author: methane

Lib/test/test_dstring.py

@@ -1,37 +1,100 @@
 import unittest
 
 
+_dstring_prefixes = "d db df dt dr drb drf drt".split()
+_dstring_prefixes += [p.upper() for p in _dstring_prefixes]
+
 class DStringTestCase(unittest.TestCase):
     def assertAllRaise(self, exception_type, regex, error_strings):
         for str in error_strings:
             with self.subTest(str=str):
                 with self.assertRaisesRegex(exception_type, regex) as cm:
                     eval(str)
-                # print("Testing expression:", repr(str))
-                # print(repr(cm.exception))
-                # print(repr(cm.exception.text))
 
     def test_single_quote(self):
         exprs = [
-            "d'hello'",
-            'D"hello"',
-            "d'hello\\nworld'",
+            f"{p}'hello, world'" for p in _dstring_prefixes
+        ] + [
+            f'{p}"hello, world"' for p in _dstring_prefixes
         ]
         self.assertAllRaise(SyntaxError, "d-string must be triple-quoted", exprs)
 
     def test_empty_dstring(self):
         exprs = [
-            "d''''''",
-            'D""""""',
+            f"{p}''''''" for p in _dstring_prefixes
+        ] + [
+            f'{p}""""""' for p in _dstring_prefixes
         ]
         self.assertAllRaise(SyntaxError, "d-string must start with a newline", exprs)
 
-    def test_simple_dstring(self):
-        self.assertEqual(eval('d"""\n  hello world\n  """'), "hello world\n")
-        self.assertEqual(eval('d"""\n  hello world\n """'), " hello world\n")
-        self.assertEqual(eval('d"""\n  hello world\n"""'), "  hello world\n")
-        self.assertEqual(eval('d"""\n  hello world\\\n """'), " hello world")
-        self.assertEqual(eval('dr"""\n  hello world\\\n """'), " hello world\\\n")
+        for prefix in _dstring_prefixes:
+            expr = f"{prefix}'''\n'''"
+            expr2 = f'{prefix}"""\n"""'
+            with self.subTest(expr=expr):
+                v = eval(expr)
+                v2 = eval(expr2)
+                if 't' in prefix.lower():
+                    self.assertEqual(v.strings, ("",))
+                    self.assertEqual(v2.strings, ("",))
+                elif 'b' in prefix.lower():
+                    self.assertEqual(v, b"")
+                    self.assertEqual(v2, b"")
+                else:
+                    self.assertEqual(v, "")
+                    self.assertEqual(v2, "")
+
+    def test_dedent(self):
+        # Basic dedent - remove common leading whitespace
+        result = eval("""\
+None or d'''
+hello
+world
+'''""")
+        self.assertEqual(result, "hello\nworld\n")
+
+        # Dedent with varying indentation
+        result = eval("""\
+None or d'''
+     line1
+       line2
+    line3
+      '''""")
+        self.assertEqual(result, " line1\n   line2\nline3\n  ")
+
+        # Dedent with tabs
+        result = eval("""\
+None or d'''
+\thello
+\tworld
+\t'''""")
+        self.assertEqual(result, "hello\nworld\n")
+
+        # Mixed spaces and tabs (using common leading whitespace)
+        result = eval("""\
+None or d'''
+\t\t    hello
+\t\t    world
+\t\t  '''""")
+        self.assertEqual(result, "  hello\n  world\n")
+
+        # Empty lines do not affect the calculation of common leading whitespace
+        result = eval("""\
+None or d'''
+    hello
+
+    world
+    '''""")
+        self.assertEqual(result, "hello\n\nworld\n")
+
+        # Lines with only whitespace also have their indentation removed.
+        result = eval("""\
+None or d'''
+    hello
+  \n\
+      \n\
+    world
+    '''""")
+        self.assertEqual(result, "hello\n\n  \nworld\n")
 
 
 if __name__ == '__main__':

Parser/action_helpers.c

@@ -1481,6 +1481,13 @@ _get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b
     Py_ssize_t common_indent_len = 0;
 
     if (is_dedent) {
+        if (total_items == 0) {
+            RAISE_SYNTAX_ERROR_KNOWN_LOCATION(
+                a,
+                "d-string must start with a newline"
+            );
+            return NULL;
+        }
         expr_ty first_item = asdl_seq_GET(raw_expressions, 0);
         if (first_item->kind != Constant_kind
                 || PyUnicode_ReadChar(first_item->v.Constant.value, 0) != '\n') {

Parser/lexer/lexer.c

@@ -1124,7 +1124,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t
                 case 'd':
                 case 'D':
                     if (quote_size != 3) {
-                        return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "d-string must be a multiline string"));
+                        return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "d-string must be triple-quoted"));
                     }
                     break;
                 default: