| import unittest |
| |
| from test.test_string._support import TStringBaseCase, fstring |
| |
| |
| class TestTString(unittest.TestCase, TStringBaseCase): |
| def test_string_representation(self): |
| # Test __repr__ |
| t = t"Hello" |
| self.assertEqual(repr(t), "Template(strings=('Hello',), interpolations=())") |
| |
| name = "Python" |
| t = t"Hello, {name}" |
| self.assertEqual(repr(t), |
| "Template(strings=('Hello, ', ''), " |
| "interpolations=(Interpolation('Python', 'name', None, ''),))" |
| ) |
| |
| def test_interpolation_basics(self): |
| # Test basic interpolation |
| name = "Python" |
| t = t"Hello, {name}" |
| self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) |
| self.assertEqual(fstring(t), "Hello, Python") |
| |
| # Multiple interpolations |
| first = "Python" |
| last = "Developer" |
| t = t"{first} {last}" |
| self.assertTStringEqual( |
| t, ("", " ", ""), [(first, 'first'), (last, 'last')] |
| ) |
| self.assertEqual(fstring(t), "Python Developer") |
| |
| # Interpolation with expressions |
| a = 10 |
| b = 20 |
| t = t"Sum: {a + b}" |
| self.assertTStringEqual(t, ("Sum: ", ""), [(a + b, "a + b")]) |
| self.assertEqual(fstring(t), "Sum: 30") |
| |
| # Interpolation with function |
| def square(x): |
| return x * x |
| t = t"Square: {square(5)}" |
| self.assertTStringEqual( |
| t, ("Square: ", ""), [(square(5), "square(5)")] |
| ) |
| self.assertEqual(fstring(t), "Square: 25") |
| |
| # Test attribute access in expressions |
| class Person: |
| def __init__(self, name): |
| self.name = name |
| |
| def upper(self): |
| return self.name.upper() |
| |
| person = Person("Alice") |
| t = t"Name: {person.name}" |
| self.assertTStringEqual( |
| t, ("Name: ", ""), [(person.name, "person.name")] |
| ) |
| self.assertEqual(fstring(t), "Name: Alice") |
| |
| # Test method calls |
| t = t"Name: {person.upper()}" |
| self.assertTStringEqual( |
| t, ("Name: ", ""), [(person.upper(), "person.upper()")] |
| ) |
| self.assertEqual(fstring(t), "Name: ALICE") |
| |
| # Test dictionary access |
| data = {"name": "Bob", "age": 30} |
| t = t"Name: {data['name']}, Age: {data['age']}" |
| self.assertTStringEqual( |
| t, ("Name: ", ", Age: ", ""), |
| [(data["name"], "data['name']"), (data["age"], "data['age']")], |
| ) |
| self.assertEqual(fstring(t), "Name: Bob, Age: 30") |
| |
| def test_format_specifiers(self): |
| # Test basic format specifiers |
| value = 3.14159 |
| t = t"Pi: {value:.2f}" |
| self.assertTStringEqual( |
| t, ("Pi: ", ""), [(value, "value", None, ".2f")] |
| ) |
| self.assertEqual(fstring(t), "Pi: 3.14") |
| |
| def test_conversions(self): |
| # Test !s conversion (str) |
| obj = object() |
| t = t"Object: {obj!s}" |
| self.assertTStringEqual(t, ("Object: ", ""), [(obj, "obj", "s")]) |
| self.assertEqual(fstring(t), f"Object: {str(obj)}") |
| |
| # Test !r conversion (repr) |
| t = t"Data: {obj!r}" |
| self.assertTStringEqual(t, ("Data: ", ""), [(obj, "obj", "r")]) |
| self.assertEqual(fstring(t), f"Data: {repr(obj)}") |
| |
| # Test !a conversion (ascii) |
| text = "Café" |
| t = t"ASCII: {text!a}" |
| self.assertTStringEqual(t, ("ASCII: ", ""), [(text, "text", "a")]) |
| self.assertEqual(fstring(t), f"ASCII: {ascii(text)}") |
| |
| # Test !z conversion (error) |
| num = 1 |
| with self.assertRaises(SyntaxError): |
| eval("t'{num!z}'") |
| |
| def test_debug_specifier(self): |
| # Test debug specifier |
| value = 42 |
| t = t"Value: {value=}" |
| self.assertTStringEqual( |
| t, ("Value: value=", ""), [(value, "value", "r")] |
| ) |
| self.assertEqual(fstring(t), "Value: value=42") |
| |
| # Test debug specifier with format (conversion default to !r) |
| t = t"Value: {value=:.2f}" |
| self.assertTStringEqual( |
| t, ("Value: value=", ""), [(value, "value", None, ".2f")] |
| ) |
| self.assertEqual(fstring(t), "Value: value=42.00") |
| |
| # Test debug specifier with conversion |
| t = t"Value: {value=!s}" |
| self.assertTStringEqual( |
| t, ("Value: value=", ""), [(value, "value", "s")] |
| ) |
| |
| # Test white space in debug specifier |
| t = t"Value: {value = }" |
| self.assertTStringEqual( |
| t, ("Value: value = ", ""), [(value, "value", "r")] |
| ) |
| self.assertEqual(fstring(t), "Value: value = 42") |
| |
| def test_raw_tstrings(self): |
| path = r"C:\Users" |
| t = rt"{path}\Documents" |
| self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")]) |
| self.assertEqual(fstring(t), r"C:\Users\Documents") |
| |
| # Test alternative prefix |
| t = tr"{path}\Documents" |
| self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")]) |
| |
| def test_template_concatenation(self): |
| # Test template + template |
| t1 = t"Hello, " |
| t2 = t"world" |
| combined = t1 + t2 |
| self.assertTStringEqual(combined, ("Hello, world",), ()) |
| self.assertEqual(fstring(combined), "Hello, world") |
| |
| # Test template + string |
| t1 = t"Hello" |
| expected_msg = 'can only concatenate string.templatelib.Template ' \ |
| '\\(not "str"\\) to string.templatelib.Template' |
| with self.assertRaisesRegex(TypeError, expected_msg): |
| t1 + ", world" |
| |
| # Test template + template with interpolation |
| name = "Python" |
| t1 = t"Hello, " |
| t2 = t"{name}" |
| combined = t1 + t2 |
| self.assertTStringEqual(combined, ("Hello, ", ""), [(name, "name")]) |
| self.assertEqual(fstring(combined), "Hello, Python") |
| |
| # Test string + template |
| expected_msg = 'can only concatenate str ' \ |
| '\\(not "string.templatelib.Template"\\) to str' |
| with self.assertRaisesRegex(TypeError, expected_msg): |
| "Hello, " + t"{name}" |
| |
| def test_nested_templates(self): |
| # Test a template inside another template expression |
| name = "Python" |
| inner = t"{name}" |
| t = t"Language: {inner}" |
| |
| t_interp = t.interpolations[0] |
| self.assertEqual(t.strings, ("Language: ", "")) |
| self.assertEqual(t_interp.value.strings, ("", "")) |
| self.assertEqual(t_interp.value.interpolations[0].value, name) |
| self.assertEqual(t_interp.value.interpolations[0].expression, "name") |
| self.assertEqual(t_interp.value.interpolations[0].conversion, None) |
| self.assertEqual(t_interp.value.interpolations[0].format_spec, "") |
| self.assertEqual(t_interp.expression, "inner") |
| self.assertEqual(t_interp.conversion, None) |
| self.assertEqual(t_interp.format_spec, "") |
| |
| def test_syntax_errors(self): |
| for case, err in ( |
| ("t'", "unterminated t-string literal"), |
| ("t'''", "unterminated triple-quoted t-string literal"), |
| ("t''''", "unterminated triple-quoted t-string literal"), |
| ("t'{", "'{' was never closed"), |
| ("t'{'", "t-string: expecting '}'"), |
| ("t'{a'", "t-string: expecting '}'"), |
| ("t'}'", "t-string: single '}' is not allowed"), |
| ("t'{}'", "t-string: valid expression required before '}'"), |
| ("t'{=x}'", "t-string: valid expression required before '='"), |
| ("t'{!x}'", "t-string: valid expression required before '!'"), |
| ("t'{:x}'", "t-string: valid expression required before ':'"), |
| ("t'{x;y}'", "t-string: expecting '=', or '!', or ':', or '}'"), |
| ("t'{x=y}'", "t-string: expecting '!', or ':', or '}'"), |
| ("t'{x!s!}'", "t-string: expecting ':' or '}'"), |
| ("t'{x!s:'", "t-string: expecting '}', or format specs"), |
| ("t'{x!}'", "t-string: missing conversion character"), |
| ("t'{x=!}'", "t-string: missing conversion character"), |
| ("t'{x!z}'", "t-string: invalid conversion character 'z': " |
| "expected 's', 'r', or 'a'"), |
| ("t'{lambda:1}'", "t-string: lambda expressions are not allowed " |
| "without parentheses"), |
| ("t'{x:{;}}'", "t-string: expecting a valid expression after '{'"), |
| ("t'{1:d\n}'", "t-string: newlines are not allowed in format specifiers") |
| ): |
| with self.subTest(case), self.assertRaisesRegex(SyntaxError, err): |
| eval(case) |
| |
| def test_runtime_errors(self): |
| # Test missing variables |
| with self.assertRaises(NameError): |
| eval("t'Hello, {name}'") |
| |
| def test_literal_concatenation(self): |
| # Test concatenation of t-string literals |
| t = t"Hello, " t"world" |
| self.assertTStringEqual(t, ("Hello, world",), ()) |
| self.assertEqual(fstring(t), "Hello, world") |
| |
| # Test concatenation with interpolation |
| name = "Python" |
| t = t"Hello, " t"{name}" |
| self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) |
| self.assertEqual(fstring(t), "Hello, Python") |
| |
| # Test disallowed mix of t-string and string/f-string (incl. bytes) |
| what = 't' |
| expected_msg = 'cannot mix t-string literals with string or bytes literals' |
| for case in ( |
| "t'{what}-string literal' 'str literal'", |
| "t'{what}-string literal' u'unicode literal'", |
| "t'{what}-string literal' f'f-string literal'", |
| "t'{what}-string literal' r'raw string literal'", |
| "t'{what}-string literal' rf'raw f-string literal'", |
| "t'{what}-string literal' b'bytes literal'", |
| "t'{what}-string literal' br'raw bytes literal'", |
| "'str literal' t'{what}-string literal'", |
| "u'unicode literal' t'{what}-string literal'", |
| "f'f-string literal' t'{what}-string literal'", |
| "r'raw string literal' t'{what}-string literal'", |
| "rf'raw f-string literal' t'{what}-string literal'", |
| "b'bytes literal' t'{what}-string literal'", |
| "br'raw bytes literal' t'{what}-string literal'", |
| ): |
| with self.subTest(case): |
| with self.assertRaisesRegex(SyntaxError, expected_msg): |
| eval(case) |
| |
| def test_triple_quoted(self): |
| # Test triple-quoted t-strings |
| t = t""" |
| Hello, |
| world |
| """ |
| self.assertTStringEqual( |
| t, ("\n Hello,\n world\n ",), () |
| ) |
| self.assertEqual(fstring(t), "\n Hello,\n world\n ") |
| |
| # Test triple-quoted with interpolation |
| name = "Python" |
| t = t""" |
| Hello, |
| {name} |
| """ |
| self.assertTStringEqual( |
| t, ("\n Hello,\n ", "\n "), [(name, "name")] |
| ) |
| self.assertEqual(fstring(t), "\n Hello,\n Python\n ") |
| |
| if __name__ == '__main__': |
| unittest.main() |
