Debian Codegraph @

Lib/test/test_fstring.py

raw
1 # -*- coding: utf-8 -*-
2 # There are tests here with unicode string literals and
3 # identifiers. There's a code in ast.c that was added because of a
4 # failure with a non-ascii-only expression. So, I have tests for
5 # that. There are workarounds that would let me run tests for that
6 # code without unicode identifiers and strings, but just using them
7 # directly seems like the easiest and therefore safest thing to do.
8 # Unicode identifiers in tests is allowed by PEP 3131.
9
10 import ast
11 import datetime
12 import dis
13 import os
14 import re
15 import types
16 import decimal
17 import unittest
18 import warnings
19 from test import support
20 from test.support.os_helper import temp_cwd
21 from test.support.script_helper import assert_python_failure, assert_python_ok
22
23 a_global = 'global variable'
24
25 # You could argue that I'm too strict in looking for specific error
26 # values with assertRaisesRegex, but without it it's way too easy to
27 # make a syntax error in the test strings. Especially with all of the
28 # triple quotes, raw strings, backslashes, etc. I think it's a
29 # worthwhile tradeoff. When I switched to this method, I found many
30 # examples where I wasn't testing what I thought I was.
31
32 class TestCase(unittest.TestCase):
33 def assertAllRaise(self, exception_type, regex, error_strings):
34 for str in error_strings:
35 with self.subTest(str=str):
36 with self.assertRaisesRegex(exception_type, regex):
37 eval(str)
38
39 def test__format__lookup(self):
40 # Make sure __format__ is looked up on the type, not the instance.
41 class X:
42 def __format__(self, spec):
43 return 'class'
44
45 x = X()
46
47 # Add a bound __format__ method to the 'y' instance, but not
48 # the 'x' instance.
49 y = X()
50 y.__format__ = types.MethodType(lambda self, spec: 'instance', y)
51
52 self.assertEqual(f'{y}', format(y))
53 self.assertEqual(f'{y}', 'class')
54 self.assertEqual(format(x), format(y))
55
56 # __format__ is not called this way, but still make sure it
57 # returns what we expect (so we can make sure we're bypassing
58 # it).
59 self.assertEqual(x.__format__(''), 'class')
60 self.assertEqual(y.__format__(''), 'instance')
61
62 # This is how __format__ is actually called.
63 self.assertEqual(type(x).__format__(x, ''), 'class')
64 self.assertEqual(type(y).__format__(y, ''), 'class')
65
66 def test_ast(self):
67 # Inspired by http://bugs.python.org/issue24975
68 class X:
69 def __init__(self):
70 self.called = False
71 def __call__(self):
72 self.called = True
73 return 4
74 x = X()
75 expr = """
76 a = 10
77 f'{a * x()}'"""
78 t = ast.parse(expr)
79 c = compile(t, '', 'exec')
80
81 # Make sure x was not called.
82 self.assertFalse(x.called)
83
84 # Actually run the code.
85 exec(c)
86
87 # Make sure x was called.
88 self.assertTrue(x.called)
89
90 def test_ast_line_numbers(self):
91 expr = """
92 a = 10
93 f'{a * x()}'"""
94 t = ast.parse(expr)
95 self.assertEqual(type(t), ast.Module)
96 self.assertEqual(len(t.body), 2)
97 # check `a = 10`
98 self.assertEqual(type(t.body[0]), ast.Assign)
99 self.assertEqual(t.body[0].lineno, 2)
100 # check `f'...'`
101 self.assertEqual(type(t.body[1]), ast.Expr)
102 self.assertEqual(type(t.body[1].value), ast.JoinedStr)
103 self.assertEqual(len(t.body[1].value.values), 1)
104 self.assertEqual(type(t.body[1].value.values[0]), ast.FormattedValue)
105 self.assertEqual(t.body[1].lineno, 3)
106 self.assertEqual(t.body[1].value.lineno, 3)
107 self.assertEqual(t.body[1].value.values[0].lineno, 3)
108 # check the binop location
109 binop = t.body[1].value.values[0].value
110 self.assertEqual(type(binop), ast.BinOp)
111 self.assertEqual(type(binop.left), ast.Name)
112 self.assertEqual(type(binop.op), ast.Mult)
113 self.assertEqual(type(binop.right), ast.Call)
114 self.assertEqual(binop.lineno, 3)
115 self.assertEqual(binop.left.lineno, 3)
116 self.assertEqual(binop.right.lineno, 3)
117 self.assertEqual(binop.col_offset, 3)
118 self.assertEqual(binop.left.col_offset, 3)
119 self.assertEqual(binop.right.col_offset, 7)
120
121 def test_ast_line_numbers_multiple_formattedvalues(self):
122 expr = """
123 f'no formatted values'
124 f'eggs {a * x()} spam {b + y()}'"""
125 t = ast.parse(expr)
126 self.assertEqual(type(t), ast.Module)
127 self.assertEqual(len(t.body), 2)
128 # check `f'no formatted value'`
129 self.assertEqual(type(t.body[0]), ast.Expr)
130 self.assertEqual(type(t.body[0].value), ast.JoinedStr)
131 self.assertEqual(t.body[0].lineno, 2)
132 # check `f'...'`
133 self.assertEqual(type(t.body[1]), ast.Expr)
134 self.assertEqual(type(t.body[1].value), ast.JoinedStr)
135 self.assertEqual(len(t.body[1].value.values), 4)
136 self.assertEqual(type(t.body[1].value.values[0]), ast.Constant)
137 self.assertEqual(type(t.body[1].value.values[0].value), str)
138 self.assertEqual(type(t.body[1].value.values[1]), ast.FormattedValue)
139 self.assertEqual(type(t.body[1].value.values[2]), ast.Constant)
140 self.assertEqual(type(t.body[1].value.values[2].value), str)
141 self.assertEqual(type(t.body[1].value.values[3]), ast.FormattedValue)
142 self.assertEqual(t.body[1].lineno, 3)
143 self.assertEqual(t.body[1].value.lineno, 3)
144 self.assertEqual(t.body[1].value.values[0].lineno, 3)
145 self.assertEqual(t.body[1].value.values[1].lineno, 3)
146 self.assertEqual(t.body[1].value.values[2].lineno, 3)
147 self.assertEqual(t.body[1].value.values[3].lineno, 3)
148 # check the first binop location
149 binop1 = t.body[1].value.values[1].value
150 self.assertEqual(type(binop1), ast.BinOp)
151 self.assertEqual(type(binop1.left), ast.Name)
152 self.assertEqual(type(binop1.op), ast.Mult)
153 self.assertEqual(type(binop1.right), ast.Call)
154 self.assertEqual(binop1.lineno, 3)
155 self.assertEqual(binop1.left.lineno, 3)
156 self.assertEqual(binop1.right.lineno, 3)
157 self.assertEqual(binop1.col_offset, 8)
158 self.assertEqual(binop1.left.col_offset, 8)
159 self.assertEqual(binop1.right.col_offset, 12)
160 # check the second binop location
161 binop2 = t.body[1].value.values[3].value
162 self.assertEqual(type(binop2), ast.BinOp)
163 self.assertEqual(type(binop2.left), ast.Name)
164 self.assertEqual(type(binop2.op), ast.Add)
165 self.assertEqual(type(binop2.right), ast.Call)
166 self.assertEqual(binop2.lineno, 3)
167 self.assertEqual(binop2.left.lineno, 3)
168 self.assertEqual(binop2.right.lineno, 3)
169 self.assertEqual(binop2.col_offset, 23)
170 self.assertEqual(binop2.left.col_offset, 23)
171 self.assertEqual(binop2.right.col_offset, 27)
172
173 def test_ast_line_numbers_nested(self):
174 expr = """
175 a = 10
176 f'{a * f"-{x()}-"}'"""
177 t = ast.parse(expr)
178 self.assertEqual(type(t), ast.Module)
179 self.assertEqual(len(t.body), 2)
180 # check `a = 10`
181 self.assertEqual(type(t.body[0]), ast.Assign)
182 self.assertEqual(t.body[0].lineno, 2)
183 # check `f'...'`
184 self.assertEqual(type(t.body[1]), ast.Expr)
185 self.assertEqual(type(t.body[1].value), ast.JoinedStr)
186 self.assertEqual(len(t.body[1].value.values), 1)
187 self.assertEqual(type(t.body[1].value.values[0]), ast.FormattedValue)
188 self.assertEqual(t.body[1].lineno, 3)
189 self.assertEqual(t.body[1].value.lineno, 3)
190 self.assertEqual(t.body[1].value.values[0].lineno, 3)
191 # check the binop location
192 binop = t.body[1].value.values[0].value
193 self.assertEqual(type(binop), ast.BinOp)
194 self.assertEqual(type(binop.left), ast.Name)
195 self.assertEqual(type(binop.op), ast.Mult)
196 self.assertEqual(type(binop.right), ast.JoinedStr)
197 self.assertEqual(binop.lineno, 3)
198 self.assertEqual(binop.left.lineno, 3)
199 self.assertEqual(binop.right.lineno, 3)
200 self.assertEqual(binop.col_offset, 3)
201 self.assertEqual(binop.left.col_offset, 3)
202 self.assertEqual(binop.right.col_offset, 7)
203 # check the nested call location
204 self.assertEqual(len(binop.right.values), 3)
205 self.assertEqual(type(binop.right.values[0]), ast.Constant)
206 self.assertEqual(type(binop.right.values[0].value), str)
207 self.assertEqual(type(binop.right.values[1]), ast.FormattedValue)
208 self.assertEqual(type(binop.right.values[2]), ast.Constant)
209 self.assertEqual(type(binop.right.values[2].value), str)
210 self.assertEqual(binop.right.values[0].lineno, 3)
211 self.assertEqual(binop.right.values[1].lineno, 3)
212 self.assertEqual(binop.right.values[2].lineno, 3)
213 call = binop.right.values[1].value
214 self.assertEqual(type(call), ast.Call)
215 self.assertEqual(call.lineno, 3)
216 self.assertEqual(call.col_offset, 11)
217
218 def test_ast_line_numbers_duplicate_expression(self):
219 expr = """
220 a = 10
221 f'{a * x()} {a * x()} {a * x()}'
222 """
223 t = ast.parse(expr)
224 self.assertEqual(type(t), ast.Module)
225 self.assertEqual(len(t.body), 2)
226 # check `a = 10`
227 self.assertEqual(type(t.body[0]), ast.Assign)
228 self.assertEqual(t.body[0].lineno, 2)
229 # check `f'...'`
230 self.assertEqual(type(t.body[1]), ast.Expr)
231 self.assertEqual(type(t.body[1].value), ast.JoinedStr)
232 self.assertEqual(len(t.body[1].value.values), 5)
233 self.assertEqual(type(t.body[1].value.values[0]), ast.FormattedValue)
234 self.assertEqual(type(t.body[1].value.values[1]), ast.Constant)
235 self.assertEqual(type(t.body[1].value.values[1].value), str)
236 self.assertEqual(type(t.body[1].value.values[2]), ast.FormattedValue)
237 self.assertEqual(type(t.body[1].value.values[3]), ast.Constant)
238 self.assertEqual(type(t.body[1].value.values[3].value), str)
239 self.assertEqual(type(t.body[1].value.values[4]), ast.FormattedValue)
240 self.assertEqual(t.body[1].lineno, 3)
241 self.assertEqual(t.body[1].value.lineno, 3)
242 self.assertEqual(t.body[1].value.values[0].lineno, 3)
243 self.assertEqual(t.body[1].value.values[1].lineno, 3)
244 self.assertEqual(t.body[1].value.values[2].lineno, 3)
245 self.assertEqual(t.body[1].value.values[3].lineno, 3)
246 self.assertEqual(t.body[1].value.values[4].lineno, 3)
247 # check the first binop location
248 binop = t.body[1].value.values[0].value
249 self.assertEqual(type(binop), ast.BinOp)
250 self.assertEqual(type(binop.left), ast.Name)
251 self.assertEqual(type(binop.op), ast.Mult)
252 self.assertEqual(type(binop.right), ast.Call)
253 self.assertEqual(binop.lineno, 3)
254 self.assertEqual(binop.left.lineno, 3)
255 self.assertEqual(binop.right.lineno, 3)
256 self.assertEqual(binop.col_offset, 3)
257 self.assertEqual(binop.left.col_offset, 3)
258 self.assertEqual(binop.right.col_offset, 7)
259 # check the second binop location
260 binop = t.body[1].value.values[2].value
261 self.assertEqual(type(binop), ast.BinOp)
262 self.assertEqual(type(binop.left), ast.Name)
263 self.assertEqual(type(binop.op), ast.Mult)
264 self.assertEqual(type(binop.right), ast.Call)
265 self.assertEqual(binop.lineno, 3)
266 self.assertEqual(binop.left.lineno, 3)
267 self.assertEqual(binop.right.lineno, 3)
268 self.assertEqual(binop.col_offset, 13)
269 self.assertEqual(binop.left.col_offset, 13)
270 self.assertEqual(binop.right.col_offset, 17)
271 # check the third binop location
272 binop = t.body[1].value.values[4].value
273 self.assertEqual(type(binop), ast.BinOp)
274 self.assertEqual(type(binop.left), ast.Name)
275 self.assertEqual(type(binop.op), ast.Mult)
276 self.assertEqual(type(binop.right), ast.Call)
277 self.assertEqual(binop.lineno, 3)
278 self.assertEqual(binop.left.lineno, 3)
279 self.assertEqual(binop.right.lineno, 3)
280 self.assertEqual(binop.col_offset, 23)
281 self.assertEqual(binop.left.col_offset, 23)
282 self.assertEqual(binop.right.col_offset, 27)
283
284 def test_ast_numbers_fstring_with_formatting(self):
285
286 t = ast.parse('f"Here is that pesky {xxx:.3f} again"')
287 self.assertEqual(len(t.body), 1)
288 self.assertEqual(t.body[0].lineno, 1)
289
290 self.assertEqual(type(t.body[0]), ast.Expr)
291 self.assertEqual(type(t.body[0].value), ast.JoinedStr)
292 self.assertEqual(len(t.body[0].value.values), 3)
293
294 self.assertEqual(type(t.body[0].value.values[0]), ast.Constant)
295 self.assertEqual(type(t.body[0].value.values[1]), ast.FormattedValue)
296 self.assertEqual(type(t.body[0].value.values[2]), ast.Constant)
297
298 _, expr, _ = t.body[0].value.values
299
300 name = expr.value
301 self.assertEqual(type(name), ast.Name)
302 self.assertEqual(name.lineno, 1)
303 self.assertEqual(name.end_lineno, 1)
304 self.assertEqual(name.col_offset, 22)
305 self.assertEqual(name.end_col_offset, 25)
306
307 def test_ast_line_numbers_multiline_fstring(self):
308 # See bpo-30465 for details.
309 expr = """
310 a = 10
311 f'''
312 {a
313 *
314 x()}
315 non-important content
316 '''
317 """
318 t = ast.parse(expr)
319 self.assertEqual(type(t), ast.Module)
320 self.assertEqual(len(t.body), 2)
321 # check `a = 10`
322 self.assertEqual(type(t.body[0]), ast.Assign)
323 self.assertEqual(t.body[0].lineno, 2)
324 # check `f'...'`
325 self.assertEqual(type(t.body[1]), ast.Expr)
326 self.assertEqual(type(t.body[1].value), ast.JoinedStr)
327 self.assertEqual(len(t.body[1].value.values), 3)
328 self.assertEqual(type(t.body[1].value.values[0]), ast.Constant)
329 self.assertEqual(type(t.body[1].value.values[0].value), str)
330 self.assertEqual(type(t.body[1].value.values[1]), ast.FormattedValue)
331 self.assertEqual(type(t.body[1].value.values[2]), ast.Constant)
332 self.assertEqual(type(t.body[1].value.values[2].value), str)
333 self.assertEqual(t.body[1].lineno, 3)
334 self.assertEqual(t.body[1].value.lineno, 3)
335 self.assertEqual(t.body[1].value.values[0].lineno, 3)
336 self.assertEqual(t.body[1].value.values[1].lineno, 4)
337 self.assertEqual(t.body[1].value.values[2].lineno, 6)
338 self.assertEqual(t.body[1].col_offset, 0)
339 self.assertEqual(t.body[1].value.col_offset, 0)
340 self.assertEqual(t.body[1].value.values[0].col_offset, 4)
341 self.assertEqual(t.body[1].value.values[1].col_offset, 2)
342 self.assertEqual(t.body[1].value.values[2].col_offset, 11)
343 # NOTE: the following lineno information and col_offset is correct for
344 # expressions within FormattedValues.
345 binop = t.body[1].value.values[1].value
346 self.assertEqual(type(binop), ast.BinOp)
347 self.assertEqual(type(binop.left), ast.Name)
348 self.assertEqual(type(binop.op), ast.Mult)
349 self.assertEqual(type(binop.right), ast.Call)
350 self.assertEqual(binop.lineno, 4)
351 self.assertEqual(binop.left.lineno, 4)
352 self.assertEqual(binop.right.lineno, 6)
353 self.assertEqual(binop.col_offset, 3)
354 self.assertEqual(binop.left.col_offset, 3)
355 self.assertEqual(binop.right.col_offset, 7)
356
357 expr = """
358 a = f'''
359 {blech}
360 '''
361 """
362 t = ast.parse(expr)
363 self.assertEqual(type(t), ast.Module)
364 self.assertEqual(len(t.body), 1)
365 # Check f'...'
366 self.assertEqual(type(t.body[0]), ast.Assign)
367 self.assertEqual(type(t.body[0].value), ast.JoinedStr)
368 self.assertEqual(len(t.body[0].value.values), 3)
369 self.assertEqual(type(t.body[0].value.values[1]), ast.FormattedValue)
370 self.assertEqual(t.body[0].lineno, 2)
371 self.assertEqual(t.body[0].value.lineno, 2)
372 self.assertEqual(t.body[0].value.values[0].lineno, 2)
373 self.assertEqual(t.body[0].value.values[1].lineno, 3)
374 self.assertEqual(t.body[0].value.values[2].lineno, 3)
375 self.assertEqual(t.body[0].col_offset, 0)
376 self.assertEqual(t.body[0].value.col_offset, 4)
377 self.assertEqual(t.body[0].value.values[0].col_offset, 8)
378 self.assertEqual(t.body[0].value.values[1].col_offset, 10)
379 self.assertEqual(t.body[0].value.values[2].col_offset, 17)
380 # Check {blech}
381 self.assertEqual(t.body[0].value.values[1].value.lineno, 3)
382 self.assertEqual(t.body[0].value.values[1].value.end_lineno, 3)
383 self.assertEqual(t.body[0].value.values[1].value.col_offset, 11)
384 self.assertEqual(t.body[0].value.values[1].value.end_col_offset, 16)
385
386 def test_ast_line_numbers_with_parentheses(self):
387 expr = """
388 x = (
389 f" {test(t)}"
390 )"""
391 t = ast.parse(expr)
392 self.assertEqual(type(t), ast.Module)
393 self.assertEqual(len(t.body), 1)
394 # check the joinedstr location
395 joinedstr = t.body[0].value
396 self.assertEqual(type(joinedstr), ast.JoinedStr)
397 self.assertEqual(joinedstr.lineno, 3)
398 self.assertEqual(joinedstr.end_lineno, 3)
399 self.assertEqual(joinedstr.col_offset, 4)
400 self.assertEqual(joinedstr.end_col_offset, 17)
401 # check the formatted value location
402 fv = t.body[0].value.values[1]
403 self.assertEqual(type(fv), ast.FormattedValue)
404 self.assertEqual(fv.lineno, 3)
405 self.assertEqual(fv.end_lineno, 3)
406 self.assertEqual(fv.col_offset, 7)
407 self.assertEqual(fv.end_col_offset, 16)
408 # check the test(t) location
409 call = t.body[0].value.values[1].value
410 self.assertEqual(type(call), ast.Call)
411 self.assertEqual(call.lineno, 3)
412 self.assertEqual(call.end_lineno, 3)
413 self.assertEqual(call.col_offset, 8)
414 self.assertEqual(call.end_col_offset, 15)
415
416 expr = """
417 x = (
418 u'wat',
419 u"wat",
420 b'wat',
421 b"wat",
422 f'wat',
423 f"wat",
424 )
425
426 y = (
427 u'''wat''',
428 u\"\"\"wat\"\"\",
429 b'''wat''',
430 b\"\"\"wat\"\"\",
431 f'''wat''',
432 f\"\"\"wat\"\"\",
433 )
434 """
435 t = ast.parse(expr)
436 self.assertEqual(type(t), ast.Module)
437 self.assertEqual(len(t.body), 2)
438 x, y = t.body
439
440 # Check the single quoted string offsets first.
441 offsets = [
442 (elt.col_offset, elt.end_col_offset)
443 for elt in x.value.elts
444 ]
445 self.assertTrue(all(
446 offset == (4, 10)
447 for offset in offsets
448 ))
449
450 # Check the triple quoted string offsets.
451 offsets = [
452 (elt.col_offset, elt.end_col_offset)
453 for elt in y.value.elts
454 ]
455 self.assertTrue(all(
456 offset == (4, 14)
457 for offset in offsets
458 ))
459
460 expr = """
461 x = (
462 'PERL_MM_OPT', (
463 f'wat'
464 f'some_string={f(x)} '
465 f'wat'
466 ),
467 )
468 """
469 t = ast.parse(expr)
470 self.assertEqual(type(t), ast.Module)
471 self.assertEqual(len(t.body), 1)
472 # check the fstring
473 fstring = t.body[0].value.elts[1]
474 self.assertEqual(type(fstring), ast.JoinedStr)
475 self.assertEqual(len(fstring.values), 3)
476 wat1, middle, wat2 = fstring.values
477 # check the first wat
478 self.assertEqual(type(wat1), ast.Constant)
479 self.assertEqual(wat1.lineno, 4)
480 self.assertEqual(wat1.end_lineno, 5)
481 self.assertEqual(wat1.col_offset, 14)
482 self.assertEqual(wat1.end_col_offset, 26)
483 # check the call
484 call = middle.value
485 self.assertEqual(type(call), ast.Call)
486 self.assertEqual(call.lineno, 5)
487 self.assertEqual(call.end_lineno, 5)
488 self.assertEqual(call.col_offset, 27)
489 self.assertEqual(call.end_col_offset, 31)
490 # check the second wat
491 self.assertEqual(type(wat2), ast.Constant)
492 self.assertEqual(wat2.lineno, 5)
493 self.assertEqual(wat2.end_lineno, 6)
494 self.assertEqual(wat2.col_offset, 32)
495 # wat ends at the offset 17, but the whole f-string
496 # ends at the offset 18 (since the quote is part of the
497 # f-string but not the wat string)
498 self.assertEqual(wat2.end_col_offset, 17)
499 self.assertEqual(fstring.end_col_offset, 18)
500
501 def test_ast_fstring_empty_format_spec(self):
502 expr = "f'{expr:}'"
503
504 mod = ast.parse(expr)
505 self.assertEqual(type(mod), ast.Module)
506 self.assertEqual(len(mod.body), 1)
507
508 fstring = mod.body[0].value
509 self.assertEqual(type(fstring), ast.JoinedStr)
510 self.assertEqual(len(fstring.values), 1)
511
512 fv = fstring.values[0]
513 self.assertEqual(type(fv), ast.FormattedValue)
514
515 format_spec = fv.format_spec
516 self.assertEqual(type(format_spec), ast.JoinedStr)
517 self.assertEqual(len(format_spec.values), 0)
518
519 def test_ast_fstring_format_spec(self):
520 expr = "f'{1:{name}}'"
521
522 mod = ast.parse(expr)
523 self.assertEqual(type(mod), ast.Module)
524 self.assertEqual(len(mod.body), 1)
525
526 fstring = mod.body[0].value
527 self.assertEqual(type(fstring), ast.JoinedStr)
528 self.assertEqual(len(fstring.values), 1)
529
530 fv = fstring.values[0]
531 self.assertEqual(type(fv), ast.FormattedValue)
532
533 format_spec = fv.format_spec
534 self.assertEqual(type(format_spec), ast.JoinedStr)
535 self.assertEqual(len(format_spec.values), 1)
536
537 format_spec_value = format_spec.values[0]
538 self.assertEqual(type(format_spec_value), ast.FormattedValue)
539 self.assertEqual(format_spec_value.value.id, 'name')
540
541 expr = "f'{1:{name1}{name2}}'"
542
543 mod = ast.parse(expr)
544 self.assertEqual(type(mod), ast.Module)
545 self.assertEqual(len(mod.body), 1)
546
547 fstring = mod.body[0].value
548 self.assertEqual(type(fstring), ast.JoinedStr)
549 self.assertEqual(len(fstring.values), 1)
550
551 fv = fstring.values[0]
552 self.assertEqual(type(fv), ast.FormattedValue)
553
554 format_spec = fv.format_spec
555 self.assertEqual(type(format_spec), ast.JoinedStr)
556 self.assertEqual(len(format_spec.values), 2)
557
558 format_spec_value = format_spec.values[0]
559 self.assertEqual(type(format_spec_value), ast.FormattedValue)
560 self.assertEqual(format_spec_value.value.id, 'name1')
561
562 format_spec_value = format_spec.values[1]
563 self.assertEqual(type(format_spec_value), ast.FormattedValue)
564 self.assertEqual(format_spec_value.value.id, 'name2')
565
566
567 def test_docstring(self):
568 def f():
569 f'''Not a docstring'''
570 self.assertIsNone(f.__doc__)
571 def g():
572 '''Not a docstring''' \
573 f''
574 self.assertIsNone(g.__doc__)
575
576 def test_literal_eval(self):
577 with self.assertRaisesRegex(ValueError, 'malformed node or string'):
578 ast.literal_eval("f'x'")
579
580 def test_ast_compile_time_concat(self):
581 x = ['']
582
583 expr = """x[0] = 'foo' f'{3}'"""
584 t = ast.parse(expr)
585 c = compile(t, '', 'exec')
586 exec(c)
587 self.assertEqual(x[0], 'foo3')
588
589 def test_compile_time_concat_errors(self):
590 self.assertAllRaise(SyntaxError,
591 'cannot mix bytes and nonbytes literals',
592 [r"""f'' b''""",
593 r"""b'' f''""",
594 ])
595
596 def test_literal(self):
597 self.assertEqual(f'', '')
598 self.assertEqual(f'a', 'a')
599 self.assertEqual(f' ', ' ')
600
601 def test_unterminated_string(self):
602 self.assertAllRaise(SyntaxError, 'unterminated string',
603 [r"""f'{"x'""",
604 r"""f'{"x}'""",
605 r"""f'{("x'""",
606 r"""f'{("x}'""",
607 ])
608
609 @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
610 def test_mismatched_parens(self):
611 self.assertAllRaise(SyntaxError, r"closing parenthesis '\}' "
612 r"does not match opening parenthesis '\('",
613 ["f'{((}'",
614 ])
615 self.assertAllRaise(SyntaxError, r"closing parenthesis '\)' "
616 r"does not match opening parenthesis '\['",
617 ["f'{a[4)}'",
618 ])
619 self.assertAllRaise(SyntaxError, r"closing parenthesis '\]' "
620 r"does not match opening parenthesis '\('",
621 ["f'{a(4]}'",
622 ])
623 self.assertAllRaise(SyntaxError, r"closing parenthesis '\}' "
624 r"does not match opening parenthesis '\['",
625 ["f'{a[4}'",
626 ])
627 self.assertAllRaise(SyntaxError, r"closing parenthesis '\}' "
628 r"does not match opening parenthesis '\('",
629 ["f'{a(4}'",
630 ])
631 self.assertRaises(SyntaxError, eval, "f'{" + "("*20 + "}'")
632
633 @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
634 def test_fstring_nested_too_deeply(self):
635 def raises_syntax_or_memory_error(txt):
636 try:
637 eval(txt)
638 except SyntaxError:
639 pass
640 except MemoryError:
641 pass
642 except Exception as ex:
643 self.fail(f"Should raise SyntaxError or MemoryError, not {type(ex)}")
644 else:
645 self.fail("No exception raised")
646
647 raises_syntax_or_memory_error('f"{1+2:{1+2:{1+1:{1}}}}"')
648
649 def create_nested_fstring(n):
650 if n == 0:
651 return "1+1"
652 prev = create_nested_fstring(n-1)
653 return f'f"{{{prev}}}"'
654
655 raises_syntax_or_memory_error(create_nested_fstring(160))
656 raises_syntax_or_memory_error("f'{" + "("*100 + "}'")
657 raises_syntax_or_memory_error("f'{" + "("*1000 + "}'")
658 raises_syntax_or_memory_error("f'{" + "("*10_000 + "}'")
659
660 def test_syntax_error_in_nested_fstring(self):
661 # See gh-104016 for more information on this crash
662 self.assertAllRaise(SyntaxError,
663 "invalid syntax",
664 ['f"{1 1:' + ('{f"1:' * 199)])
665
666 def test_double_braces(self):
667 self.assertEqual(f'{{', '{')
668 self.assertEqual(f'a{{', 'a{')
669 self.assertEqual(f'{{b', '{b')
670 self.assertEqual(f'a{{b', 'a{b')
671 self.assertEqual(f'}}', '}')
672 self.assertEqual(f'a}}', 'a}')
673 self.assertEqual(f'}}b', '}b')
674 self.assertEqual(f'a}}b', 'a}b')
675 self.assertEqual(f'{{}}', '{}')
676 self.assertEqual(f'a{{}}', 'a{}')
677 self.assertEqual(f'{{b}}', '{b}')
678 self.assertEqual(f'{{}}c', '{}c')
679 self.assertEqual(f'a{{b}}', 'a{b}')
680 self.assertEqual(f'a{{}}c', 'a{}c')
681 self.assertEqual(f'{{b}}c', '{b}c')
682 self.assertEqual(f'a{{b}}c', 'a{b}c')
683
684 self.assertEqual(f'{{{10}', '{10')
685 self.assertEqual(f'}}{10}', '}10')
686 self.assertEqual(f'}}{{{10}', '}{10')
687 self.assertEqual(f'}}a{{{10}', '}a{10')
688
689 self.assertEqual(f'{10}{{', '10{')
690 self.assertEqual(f'{10}}}', '10}')
691 self.assertEqual(f'{10}}}{{', '10}{')
692 self.assertEqual(f'{10}}}a{{' '}', '10}a{}')
693
694 # Inside of strings, don't interpret doubled brackets.
695 self.assertEqual(f'{"{{}}"}', '{{}}')
696
697 self.assertAllRaise(TypeError, 'unhashable type',
698 ["f'{ {{}} }'", # dict in a set
699 ])
700
701 def test_compile_time_concat(self):
702 x = 'def'
703 self.assertEqual('abc' f'## {x}ghi', 'abc## defghi')
704 self.assertEqual('abc' f'{x}' 'ghi', 'abcdefghi')
705 self.assertEqual('abc' f'{x}' 'gh' f'i{x:4}', 'abcdefghidef ')
706 self.assertEqual('{x}' f'{x}', '{x}def')
707 self.assertEqual('{x' f'{x}', '{xdef')
708 self.assertEqual('{x}' f'{x}', '{x}def')
709 self.assertEqual('{{x}}' f'{x}', '{{x}}def')
710 self.assertEqual('{{x' f'{x}', '{{xdef')
711 self.assertEqual('x}}' f'{x}', 'x}}def')
712 self.assertEqual(f'{x}' 'x}}', 'defx}}')
713 self.assertEqual(f'{x}' '', 'def')
714 self.assertEqual('' f'{x}' '', 'def')
715 self.assertEqual('' f'{x}', 'def')
716 self.assertEqual(f'{x}' '2', 'def2')
717 self.assertEqual('1' f'{x}' '2', '1def2')
718 self.assertEqual('1' f'{x}', '1def')
719 self.assertEqual(f'{x}' f'-{x}', 'def-def')
720 self.assertEqual('' f'', '')
721 self.assertEqual('' f'' '', '')
722 self.assertEqual('' f'' '' f'', '')
723 self.assertEqual(f'', '')
724 self.assertEqual(f'' '', '')
725 self.assertEqual(f'' '' f'', '')
726 self.assertEqual(f'' '' f'' '', '')
727
728 # This is not really [f'{'] + [f'}'] since we treat the inside
729 # of braces as a purely new context, so it is actually f'{ and
730 # then eval(' f') (a valid expression) and then }' which would
731 # constitute a valid f-string.
732 self.assertEqual(f'{' f'}', ' f')
733
734 self.assertAllRaise(SyntaxError, "expecting '}'",
735 ['''f'{3' f"}"''', # can't concat to get a valid f-string
736 ])
737
738 def test_comments(self):
739 # These aren't comments, since they're in strings.
740 d = {'#': 'hash'}
741 self.assertEqual(f'{"#"}', '#')
742 self.assertEqual(f'{d["#"]}', 'hash')
743
744 self.assertAllRaise(SyntaxError, "'{' was never closed",
745 ["f'{1#}'", # error because everything after '#' is a comment
746 "f'{#}'",
747 "f'one: {1#}'",
748 "f'{1# one} {2 this is a comment still#}'",
749 ])
750 self.assertAllRaise(SyntaxError, r"f-string: unmatched '\)'",
751 ["f'{)#}'", # When wrapped in parens, this becomes
752 # '()#)'. Make sure that doesn't compile.
753 ])
754 self.assertEqual(f'''A complex trick: {
755 2 # two
756 }''', 'A complex trick: 2')
757 self.assertEqual(f'''
758 {
759 40 # forty
760 + # plus
761 2 # two
762 }''', '\n42')
763 self.assertEqual(f'''
764 {
765 40 # forty
766 + # plus
767 2 # two
768 }''', '\n42')
769
770 self.assertEqual(f'''
771 # this is not a comment
772 { # the following operation it's
773 3 # this is a number
774 * 2}''', '\n# this is not a comment\n6')
775 self.assertEqual(f'''
776 {# f'a {comment}'
777 86 # constant
778 # nothing more
779 }''', '\n86')
780
781 self.assertAllRaise(SyntaxError, r"f-string: valid expression required before '}'",
782 ["""f'''
783 {
784 # only a comment
785 }'''
786 """, # this is equivalent to f'{}'
787 ])
788
789 def test_many_expressions(self):
790 # Create a string with many expressions in it. Note that
791 # because we have a space in here as a literal, we're actually
792 # going to use twice as many ast nodes: one for each literal
793 # plus one for each expression.
794 def build_fstr(n, extra=''):
795 return "f'" + ('{x} ' * n) + extra + "'"
796
797 x = 'X'
798 width = 1
799
800 # Test around 256.
801 for i in range(250, 260):
802 self.assertEqual(eval(build_fstr(i)), (x+' ')*i)
803
804 # Test concatenating 2 largs fstrings.
805 self.assertEqual(eval(build_fstr(255)*256), (x+' ')*(255*256))
806
807 s = build_fstr(253, '{x:{width}} ')
808 self.assertEqual(eval(s), (x+' ')*254)
809
810 # Test lots of expressions and constants, concatenated.
811 s = "f'{1}' 'x' 'y'" * 1024
812 self.assertEqual(eval(s), '1xy' * 1024)
813
814 def test_format_specifier_expressions(self):
815 width = 10
816 precision = 4
817 value = decimal.Decimal('12.34567')
818 self.assertEqual(f'result: {value:{width}.{precision}}', 'result: 12.35')
819 self.assertEqual(f'result: {value:{width!r}.{precision}}', 'result: 12.35')
820 self.assertEqual(f'result: {value:{width:0}.{precision:1}}', 'result: 12.35')
821 self.assertEqual(f'result: {value:{1}{0:0}.{precision:1}}', 'result: 12.35')
822 self.assertEqual(f'result: {value:{ 1}{ 0:0}.{ precision:1}}', 'result: 12.35')
823 self.assertEqual(f'{10:#{1}0x}', ' 0xa')
824 self.assertEqual(f'{10:{"#"}1{0}{"x"}}', ' 0xa')
825 self.assertEqual(f'{-10:-{"#"}1{0}x}', ' -0xa')
826 self.assertEqual(f'{-10:{"-"}#{1}0{"x"}}', ' -0xa')
827 self.assertEqual(f'{10:#{3 != {4:5} and width}x}', ' 0xa')
828 self.assertEqual(f'result: {value:{width:{0}}.{precision:1}}', 'result: 12.35')
829
830 self.assertAllRaise(SyntaxError, "f-string: expecting ':' or '}'",
831 ["""f'{"s"!r{":10"}}'""",
832 # This looks like a nested format spec.
833 ])
834
835 self.assertAllRaise(SyntaxError,
836 "f-string: expecting a valid expression after '{'",
837 [# Invalid syntax inside a nested spec.
838 "f'{4:{/5}}'",
839 ])
840
841 self.assertAllRaise(SyntaxError, 'f-string: invalid conversion character',
842 [# No expansion inside conversion or for
843 # the : or ! itself.
844 """f'{"s"!{"r"}}'""",
845 ])
846
847 def test_custom_format_specifier(self):
848 class CustomFormat:
849 def __format__(self, format_spec):
850 return format_spec
851
852 self.assertEqual(f'{CustomFormat():\n}', '\n')
853 self.assertEqual(f'{CustomFormat():\u2603}', '☃')
854 with self.assertWarns(SyntaxWarning):
855 exec(r'f"{F():¯\_(ツ)_/¯}"', {'F': CustomFormat})
856
857 def test_side_effect_order(self):
858 class X:
859 def __init__(self):
860 self.i = 0
861 def __format__(self, spec):
862 self.i += 1
863 return str(self.i)
864
865 x = X()
866 self.assertEqual(f'{x} {x}', '1 2')
867
868 def test_missing_expression(self):
869 self.assertAllRaise(SyntaxError,
870 "f-string: valid expression required before '}'",
871 ["f'{}'",
872 "f'{ }'"
873 "f' {} '",
874 "f'{10:{ }}'",
875 "f' { } '",
876
877 # The Python parser ignores also the following
878 # whitespace characters in additional to a space.
879 "f'''{\t\f\r\n}'''",
880 ])
881
882 self.assertAllRaise(SyntaxError,
883 "f-string: valid expression required before '!'",
884 ["f'{!r}'",
885 "f'{ !r}'",
886 "f'{!}'",
887 "f'''{\t\f\r\n!a}'''",
888
889 # Catch empty expression before the
890 # missing closing brace.
891 "f'{!'",
892 "f'{!s:'",
893
894 # Catch empty expression before the
895 # invalid conversion.
896 "f'{!x}'",
897 "f'{ !xr}'",
898 "f'{!x:}'",
899 "f'{!x:a}'",
900 "f'{ !xr:}'",
901 "f'{ !xr:a}'",
902 ])
903
904 self.assertAllRaise(SyntaxError,
905 "f-string: valid expression required before ':'",
906 ["f'{:}'",
907 "f'{ :!}'",
908 "f'{:2}'",
909 "f'''{\t\f\r\n:a}'''",
910 "f'{:'",
911 "F'{[F'{:'}[F'{:'}]]]",
912 ])
913
914 self.assertAllRaise(SyntaxError,
915 "f-string: valid expression required before '='",
916 ["f'{=}'",
917 "f'{ =}'",
918 "f'{ =:}'",
919 "f'{ =!}'",
920 "f'''{\t\f\r\n=}'''",
921 "f'{='",
922 ])
923
924 # Different error message is raised for other whitespace characters.
925 self.assertAllRaise(SyntaxError, r"invalid non-printable character U\+00A0",
926 ["f'''{\xa0}'''",
927 "\xa0",
928 ])
929
930 def test_parens_in_expressions(self):
931 self.assertEqual(f'{3,}', '(3,)')
932
933 self.assertAllRaise(SyntaxError,
934 "f-string: expecting a valid expression after '{'",
935 ["f'{,}'",
936 ])
937
938 self.assertAllRaise(SyntaxError, r"f-string: unmatched '\)'",
939 ["f'{3)+(4}'",
940 ])
941
942 def test_newlines_before_syntax_error(self):
943 self.assertAllRaise(SyntaxError,
944 "f-string: expecting a valid expression after '{'",
945 ["f'{.}'", "\nf'{.}'", "\n\nf'{.}'"])
946
947 def test_backslashes_in_string_part(self):
948 self.assertEqual(f'\t', '\t')
949 self.assertEqual(r'\t', '\\t')
950 self.assertEqual(rf'\t', '\\t')
951 self.assertEqual(f'{2}\t', '2\t')
952 self.assertEqual(f'{2}\t{3}', '2\t3')
953 self.assertEqual(f'\t{3}', '\t3')
954
955 self.assertEqual(f'\u0394', '\u0394')
956 self.assertEqual(r'\u0394', '\\u0394')
957 self.assertEqual(rf'\u0394', '\\u0394')
958 self.assertEqual(f'{2}\u0394', '2\u0394')
959 self.assertEqual(f'{2}\u0394{3}', '2\u03943')
960 self.assertEqual(f'\u0394{3}', '\u03943')
961
962 self.assertEqual(f'\U00000394', '\u0394')
963 self.assertEqual(r'\U00000394', '\\U00000394')
964 self.assertEqual(rf'\U00000394', '\\U00000394')
965 self.assertEqual(f'{2}\U00000394', '2\u0394')
966 self.assertEqual(f'{2}\U00000394{3}', '2\u03943')
967 self.assertEqual(f'\U00000394{3}', '\u03943')
968
969 self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}', '\u0394')
970 self.assertEqual(f'{2}\N{GREEK CAPITAL LETTER DELTA}', '2\u0394')
971 self.assertEqual(f'{2}\N{GREEK CAPITAL LETTER DELTA}{3}', '2\u03943')
972 self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}{3}', '\u03943')
973 self.assertEqual(f'2\N{GREEK CAPITAL LETTER DELTA}', '2\u0394')
974 self.assertEqual(f'2\N{GREEK CAPITAL LETTER DELTA}3', '2\u03943')
975 self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}3', '\u03943')
976
977 self.assertEqual(f'\x20', ' ')
978 self.assertEqual(r'\x20', '\\x20')
979 self.assertEqual(rf'\x20', '\\x20')
980 self.assertEqual(f'{2}\x20', '2 ')
981 self.assertEqual(f'{2}\x20{3}', '2 3')
982 self.assertEqual(f'\x20{3}', ' 3')
983
984 self.assertEqual(f'2\x20', '2 ')
985 self.assertEqual(f'2\x203', '2 3')
986 self.assertEqual(f'\x203', ' 3')
987
988 with self.assertWarns(SyntaxWarning): # invalid escape sequence
989 value = eval(r"f'\{6*7}'")
990 self.assertEqual(value, '\\42')
991 with self.assertWarns(SyntaxWarning): # invalid escape sequence
992 value = eval(r"f'\g'")
993 self.assertEqual(value, '\\g')
994 self.assertEqual(f'\\{6*7}', '\\42')
995 self.assertEqual(fr'\{6*7}', '\\42')
996
997 AMPERSAND = 'spam'
998 # Get the right unicode character (&), or pick up local variable
999 # depending on the number of backslashes.
1000 self.assertEqual(f'\N{AMPERSAND}', '&')
1001 self.assertEqual(f'\\N{AMPERSAND}', '\\Nspam')
1002 self.assertEqual(fr'\N{AMPERSAND}', '\\Nspam')
1003 self.assertEqual(f'\\\N{AMPERSAND}', '\\&')
1004
1005 def test_misformed_unicode_character_name(self):
1006 # These test are needed because unicode names are parsed
1007 # differently inside f-strings.
1008 self.assertAllRaise(SyntaxError, r"\(unicode error\) 'unicodeescape' codec can't decode bytes in position .*: malformed \\N character escape",
1009 [r"f'\N'",
1010 r"f'\N '",
1011 r"f'\N '", # See bpo-46503.
1012 r"f'\N{'",
1013 r"f'\N{GREEK CAPITAL LETTER DELTA'",
1014
1015 # Here are the non-f-string versions,
1016 # which should give the same errors.
1017 r"'\N'",
1018 r"'\N '",
1019 r"'\N '",
1020 r"'\N{'",
1021 r"'\N{GREEK CAPITAL LETTER DELTA'",
1022 ])
1023
1024 def test_backslashes_in_expression_part(self):
1025 self.assertEqual(f"{(
1026 1 +
1027 2
1028 )}", "3")
1029
1030 self.assertEqual("\N{LEFT CURLY BRACKET}", '{')
1031 self.assertEqual(f'{"\N{LEFT CURLY BRACKET}"}', '{')
1032 self.assertEqual(rf'{"\N{LEFT CURLY BRACKET}"}', '{')
1033
1034 self.assertAllRaise(SyntaxError,
1035 "f-string: valid expression required before '}'",
1036 ["f'{\n}'",
1037 ])
1038
1039 def test_invalid_backslashes_inside_fstring_context(self):
1040 # All of these variations are invalid python syntax,
1041 # so they are also invalid in f-strings as well.
1042 cases = [
1043 formatting.format(expr=expr)
1044 for formatting in [
1045 "{expr}",
1046 "f'{{{expr}}}'",
1047 "rf'{{{expr}}}'",
1048 ]
1049 for expr in [
1050 r"\'a\'",
1051 r"\t3",
1052 r"\\"[0],
1053 ]
1054 ]
1055 self.assertAllRaise(SyntaxError, 'unexpected character after line continuation',
1056 cases)
1057
1058 def test_no_escapes_for_braces(self):
1059 """
1060 Only literal curly braces begin an expression.
1061 """
1062 # \x7b is '{'.
1063 self.assertEqual(f'\x7b1+1}}', '{1+1}')
1064 self.assertEqual(f'\x7b1+1', '{1+1')
1065 self.assertEqual(f'\u007b1+1', '{1+1')
1066 self.assertEqual(f'\N{LEFT CURLY BRACKET}1+1\N{RIGHT CURLY BRACKET}', '{1+1}')
1067
1068 def test_newlines_in_expressions(self):
1069 self.assertEqual(f'{0}', '0')
1070 self.assertEqual(rf'''{3+
1071 4}''', '7')
1072
1073 def test_lambda(self):
1074 x = 5
1075 self.assertEqual(f'{(lambda y:x*y)("8")!r}', "'88888'")
1076 self.assertEqual(f'{(lambda y:x*y)("8")!r:10}', "'88888' ")
1077 self.assertEqual(f'{(lambda y:x*y)("8"):10}', "88888 ")
1078
1079 # lambda doesn't work without parens, because the colon
1080 # makes the parser think it's a format_spec
1081 # emit warning if we can match a format_spec
1082 self.assertAllRaise(SyntaxError,
1083 "f-string: lambda expressions are not allowed "
1084 "without parentheses",
1085 ["f'{lambda x:x}'",
1086 "f'{lambda :x}'",
1087 "f'{lambda *arg, :x}'",
1088 "f'{1, lambda:x}'",
1089 "f'{lambda x:}'",
1090 "f'{lambda :}'",
1091 ])
1092 # Ensure the detection of invalid lambdas doesn't trigger detection
1093 # for valid lambdas in the second error pass
1094 with self.assertRaisesRegex(SyntaxError, "invalid syntax"):
1095 compile("lambda name_3=f'{name_4}': {name_3}\n1 $ 1", "<string>", "exec")
1096
1097 # but don't emit the paren warning in general cases
1098 with self.assertRaisesRegex(SyntaxError, "f-string: expecting a valid expression after '{'"):
1099 eval("f'{+ lambda:None}'")
1100
1101 def test_valid_prefixes(self):
1102 self.assertEqual(F'{1}', "1")
1103 self.assertEqual(FR'{2}', "2")
1104 self.assertEqual(fR'{3}', "3")
1105
1106 def test_roundtrip_raw_quotes(self):
1107 self.assertEqual(fr"\'", "\\'")
1108 self.assertEqual(fr'\"', '\\"')
1109 self.assertEqual(fr'\"\'', '\\"\\\'')
1110 self.assertEqual(fr'\'\"', '\\\'\\"')
1111 self.assertEqual(fr'\"\'\"', '\\"\\\'\\"')
1112 self.assertEqual(fr'\'\"\'', '\\\'\\"\\\'')
1113 self.assertEqual(fr'\"\'\"\'', '\\"\\\'\\"\\\'')
1114
1115 def test_fstring_backslash_before_double_bracket(self):
1116 deprecated_cases = [
1117 (r"f'\{{\}}'", '\\{\\}'),
1118 (r"f'\{{'", '\\{'),
1119 (r"f'\{{{1+1}'", '\\{2'),
1120 (r"f'\}}{1+1}'", '\\}2'),
1121 (r"f'{1+1}\}}'", '2\\}')
1122 ]
1123 for case, expected_result in deprecated_cases:
1124 with self.subTest(case=case, expected_result=expected_result):
1125 with self.assertWarns(SyntaxWarning):
1126 result = eval(case)
1127 self.assertEqual(result, expected_result)
1128 self.assertEqual(fr'\{{\}}', '\\{\\}')
1129 self.assertEqual(fr'\{{', '\\{')
1130 self.assertEqual(fr'\{{{1+1}', '\\{2')
1131 self.assertEqual(fr'\}}{1+1}', '\\}2')
1132 self.assertEqual(fr'{1+1}\}}', '2\\}')
1133
1134 def test_fstring_backslash_before_double_bracket_warns_once(self):
1135 with self.assertWarns(SyntaxWarning) as w:
1136 eval(r"f'\{{'")
1137 self.assertEqual(len(w.warnings), 1)
1138 self.assertEqual(w.warnings[0].category, SyntaxWarning)
1139
1140 def test_fstring_backslash_prefix_raw(self):
1141 self.assertEqual(f'\\', '\\')
1142 self.assertEqual(f'\\\\', '\\\\')
1143 self.assertEqual(fr'\\', r'\\')
1144 self.assertEqual(fr'\\\\', r'\\\\')
1145 self.assertEqual(rf'\\', r'\\')
1146 self.assertEqual(rf'\\\\', r'\\\\')
1147 self.assertEqual(Rf'\\', R'\\')
1148 self.assertEqual(Rf'\\\\', R'\\\\')
1149 self.assertEqual(fR'\\', R'\\')
1150 self.assertEqual(fR'\\\\', R'\\\\')
1151 self.assertEqual(FR'\\', R'\\')
1152 self.assertEqual(FR'\\\\', R'\\\\')
1153
1154 def test_fstring_format_spec_greedy_matching(self):
1155 self.assertEqual(f"{1:}}}", "1}")
1156 self.assertEqual(f"{1:>3{5}}}}", " 1}")
1157
1158 def test_yield(self):
1159 # Not terribly useful, but make sure the yield turns
1160 # a function into a generator
1161 def fn(y):
1162 f'y:{yield y*2}'
1163 f'{yield}'
1164
1165 g = fn(4)
1166 self.assertEqual(next(g), 8)
1167 self.assertEqual(next(g), None)
1168
1169 def test_yield_send(self):
1170 def fn(x):
1171 yield f'x:{yield (lambda i: x * i)}'
1172
1173 g = fn(10)
1174 the_lambda = next(g)
1175 self.assertEqual(the_lambda(4), 40)
1176 self.assertEqual(g.send('string'), 'x:string')
1177
1178 def test_expressions_with_triple_quoted_strings(self):
1179 self.assertEqual(f"{'''x'''}", 'x')
1180 self.assertEqual(f"{'''eric's'''}", "eric's")
1181
1182 # Test concatenation within an expression
1183 self.assertEqual(f'{"x" """eric"s""" "y"}', 'xeric"sy')
1184 self.assertEqual(f'{"x" """eric"s"""}', 'xeric"s')
1185 self.assertEqual(f'{"""eric"s""" "y"}', 'eric"sy')
1186 self.assertEqual(f'{"""x""" """eric"s""" "y"}', 'xeric"sy')
1187 self.assertEqual(f'{"""x""" """eric"s""" """y"""}', 'xeric"sy')
1188 self.assertEqual(f'{r"""x""" """eric"s""" """y"""}', 'xeric"sy')
1189
1190 def test_multiple_vars(self):
1191 x = 98
1192 y = 'abc'
1193 self.assertEqual(f'{x}{y}', '98abc')
1194
1195 self.assertEqual(f'X{x}{y}', 'X98abc')
1196 self.assertEqual(f'{x}X{y}', '98Xabc')
1197 self.assertEqual(f'{x}{y}X', '98abcX')
1198
1199 self.assertEqual(f'X{x}Y{y}', 'X98Yabc')
1200 self.assertEqual(f'X{x}{y}Y', 'X98abcY')
1201 self.assertEqual(f'{x}X{y}Y', '98XabcY')
1202
1203 self.assertEqual(f'X{x}Y{y}Z', 'X98YabcZ')
1204
1205 def test_closure(self):
1206 def outer(x):
1207 def inner():
1208 return f'x:{x}'
1209 return inner
1210
1211 self.assertEqual(outer('987')(), 'x:987')
1212 self.assertEqual(outer(7)(), 'x:7')
1213
1214 def test_arguments(self):
1215 y = 2
1216 def f(x, width):
1217 return f'x={x*y:{width}}'
1218
1219 self.assertEqual(f('foo', 10), 'x=foofoo ')
1220 x = 'bar'
1221 self.assertEqual(f(10, 10), 'x= 20')
1222
1223 def test_locals(self):
1224 value = 123
1225 self.assertEqual(f'v:{value}', 'v:123')
1226
1227 def test_missing_variable(self):
1228 with self.assertRaises(NameError):
1229 f'v:{value}'
1230
1231 def test_missing_format_spec(self):
1232 class O:
1233 def __format__(self, spec):
1234 if not spec:
1235 return '*'
1236 return spec
1237
1238 self.assertEqual(f'{O():x}', 'x')
1239 self.assertEqual(f'{O()}', '*')
1240 self.assertEqual(f'{O():}', '*')
1241
1242 self.assertEqual(f'{3:}', '3')
1243 self.assertEqual(f'{3!s:}', '3')
1244
1245 def test_global(self):
1246 self.assertEqual(f'g:{a_global}', 'g:global variable')
1247 self.assertEqual(f'g:{a_global!r}', "g:'global variable'")
1248
1249 a_local = 'local variable'
1250 self.assertEqual(f'g:{a_global} l:{a_local}',
1251 'g:global variable l:local variable')
1252 self.assertEqual(f'g:{a_global!r}',
1253 "g:'global variable'")
1254 self.assertEqual(f'g:{a_global} l:{a_local!r}',
1255 "g:global variable l:'local variable'")
1256
1257 self.assertIn("module 'unittest' from", f'{unittest}')
1258
1259 def test_shadowed_global(self):
1260 a_global = 'really a local'
1261 self.assertEqual(f'g:{a_global}', 'g:really a local')
1262 self.assertEqual(f'g:{a_global!r}', "g:'really a local'")
1263
1264 a_local = 'local variable'
1265 self.assertEqual(f'g:{a_global} l:{a_local}',
1266 'g:really a local l:local variable')
1267 self.assertEqual(f'g:{a_global!r}',
1268 "g:'really a local'")
1269 self.assertEqual(f'g:{a_global} l:{a_local!r}',
1270 "g:really a local l:'local variable'")
1271
1272 def test_call(self):
1273 def foo(x):
1274 return 'x=' + str(x)
1275
1276 self.assertEqual(f'{foo(10)}', 'x=10')
1277
1278 def test_nested_fstrings(self):
1279 y = 5
1280 self.assertEqual(f'{f"{0}"*3}', '000')
1281 self.assertEqual(f'{f"{y}"*3}', '555')
1282
1283 def test_invalid_string_prefixes(self):
1284 single_quote_cases = ["fu''",
1285 "uf''",
1286 "Fu''",
1287 "fU''",
1288 "Uf''",
1289 "uF''",
1290 "ufr''",
1291 "urf''",
1292 "fur''",
1293 "fru''",
1294 "rfu''",
1295 "ruf''",
1296 "FUR''",
1297 "Fur''",
1298 "fb''",
1299 "fB''",
1300 "Fb''",
1301 "FB''",
1302 "bf''",
1303 "bF''",
1304 "Bf''",
1305 "BF''",]
1306 double_quote_cases = [case.replace("'", '"') for case in single_quote_cases]
1307 self.assertAllRaise(SyntaxError, 'prefixes are incompatible',
1308 single_quote_cases + double_quote_cases)
1309
1310 def test_leading_trailing_spaces(self):
1311 self.assertEqual(f'{ 3}', '3')
1312 self.assertEqual(f'{ 3}', '3')
1313 self.assertEqual(f'{3 }', '3')
1314 self.assertEqual(f'{3 }', '3')
1315
1316 self.assertEqual(f'expr={ {x: y for x, y in [(1, 2), ]}}',
1317 'expr={1: 2}')
1318 self.assertEqual(f'expr={ {x: y for x, y in [(1, 2), ]} }',
1319 'expr={1: 2}')
1320
1321 def test_not_equal(self):
1322 # There's a special test for this because there's a special
1323 # case in the f-string parser to look for != as not ending an
1324 # expression. Normally it would, while looking for !s or !r.
1325
1326 self.assertEqual(f'{3!=4}', 'True')
1327 self.assertEqual(f'{3!=4:}', 'True')
1328 self.assertEqual(f'{3!=4!s}', 'True')
1329 self.assertEqual(f'{3!=4!s:.3}', 'Tru')
1330
1331 def test_equal_equal(self):
1332 # Because an expression ending in = has special meaning,
1333 # there's a special test for ==. Make sure it works.
1334
1335 self.assertEqual(f'{0==1}', 'False')
1336
1337 def test_conversions(self):
1338 self.assertEqual(f'{3.14:10.10}', ' 3.14')
1339 self.assertEqual(f'{1.25!s:10.10}', '1.25 ')
1340 self.assertEqual(f'{1.25!r:10.10}', '1.25 ')
1341 self.assertEqual(f'{1.25!a:10.10}', '1.25 ')
1342
1343 self.assertEqual(f'{"a"}', 'a')
1344 self.assertEqual(f'{"a"!r}', "'a'")
1345 self.assertEqual(f'{"a"!a}', "'a'")
1346
1347 # Conversions can have trailing whitespace after them since it
1348 # does not provide any significance
1349 self.assertEqual(f"{3!s }", "3")
1350 self.assertEqual(f'{1.25!s :10.10}', '1.25 ')
1351
1352 # Not a conversion.
1353 self.assertEqual(f'{"a!r"}', "a!r")
1354
1355 # Not a conversion, but show that ! is allowed in a format spec.
1356 self.assertEqual(f'{3.14:!<10.10}', '3.14!!!!!!')
1357
1358 self.assertAllRaise(SyntaxError, "f-string: expecting '}'",
1359 ["f'{3!'",
1360 "f'{3!s'",
1361 ])
1362
1363 self.assertAllRaise(SyntaxError, 'f-string: missing conversion character',
1364 ["f'{3!}'",
1365 "f'{3!:'",
1366 "f'{3!:}'",
1367 ])
1368
1369 for conv_identifier in 'g', 'A', 'G', 'ä', 'ɐ':
1370 self.assertAllRaise(SyntaxError,
1371 "f-string: invalid conversion character %r: "
1372 "expected 's', 'r', or 'a'" % conv_identifier,
1373 ["f'{3!" + conv_identifier + "}'"])
1374
1375 for conv_non_identifier in '3', '!':
1376 self.assertAllRaise(SyntaxError,
1377 "f-string: invalid conversion character",
1378 ["f'{3!" + conv_non_identifier + "}'"])
1379
1380 for conv in ' s', ' s ':
1381 self.assertAllRaise(SyntaxError,
1382 "f-string: conversion type must come right after the"
1383 " exclamation mark",
1384 ["f'{3!" + conv + "}'"])
1385
1386 self.assertAllRaise(SyntaxError,
1387 "f-string: invalid conversion character 'ss': "
1388 "expected 's', 'r', or 'a'",
1389 ["f'{3!ss}'",
1390 "f'{3!ss:}'",
1391 "f'{3!ss:s}'",
1392 ])
1393
1394 def test_assignment(self):
1395 self.assertAllRaise(SyntaxError, r'invalid syntax',
1396 ["f'' = 3",
1397 "f'{0}' = x",
1398 "f'{x}' = x",
1399 ])
1400
1401 def test_del(self):
1402 self.assertAllRaise(SyntaxError, 'invalid syntax',
1403 ["del f''",
1404 "del '' f''",
1405 ])
1406
1407 def test_mismatched_braces(self):
1408 self.assertAllRaise(SyntaxError, "f-string: single '}' is not allowed",
1409 ["f'{{}'",
1410 "f'{{}}}'",
1411 "f'}'",
1412 "f'x}'",
1413 "f'x}x'",
1414 r"f'\u007b}'",
1415
1416 # Can't have { or } in a format spec.
1417 "f'{3:}>10}'",
1418 "f'{3:}}>10}'",
1419 ])
1420
1421 self.assertAllRaise(SyntaxError, "f-string: expecting '}'",
1422 ["f'{3'",
1423 "f'{3!'",
1424 "f'{3:'",
1425 "f'{3!s'",
1426 "f'{3!s:'",
1427 "f'{3!s:3'",
1428 "f'x{'",
1429 "f'x{x'",
1430 "f'{x'",
1431 "f'{3:s'",
1432 "f'{{{'",
1433 "f'{{}}{'",
1434 "f'{'",
1435 "f'{i='", # See gh-93418.
1436 ])
1437
1438 self.assertAllRaise(SyntaxError,
1439 "f-string: expecting a valid expression after '{'",
1440 ["f'{3:{{>10}'",
1441 ])
1442
1443 # But these are just normal strings.
1444 self.assertEqual(f'{"{"}', '{')
1445 self.assertEqual(f'{"}"}', '}')
1446 self.assertEqual(f'{3:{"}"}>10}', '}}}}}}}}}3')
1447 self.assertEqual(f'{2:{"{"}>10}', '{{{{{{{{{2')
1448
1449 def test_if_conditional(self):
1450 # There's special logic in compile.c to test if the
1451 # conditional for an if (and while) are constants. Exercise
1452 # that code.
1453
1454 def test_fstring(x, expected):
1455 flag = 0
1456 if f'{x}':
1457 flag = 1
1458 else:
1459 flag = 2
1460 self.assertEqual(flag, expected)
1461
1462 def test_concat_empty(x, expected):
1463 flag = 0
1464 if '' f'{x}':
1465 flag = 1
1466 else:
1467 flag = 2
1468 self.assertEqual(flag, expected)
1469
1470 def test_concat_non_empty(x, expected):
1471 flag = 0
1472 if ' ' f'{x}':
1473 flag = 1
1474 else:
1475 flag = 2
1476 self.assertEqual(flag, expected)
1477
1478 test_fstring('', 2)
1479 test_fstring(' ', 1)
1480
1481 test_concat_empty('', 2)
1482 test_concat_empty(' ', 1)
1483
1484 test_concat_non_empty('', 1)
1485 test_concat_non_empty(' ', 1)
1486
1487 def test_empty_format_specifier(self):
1488 x = 'test'
1489 self.assertEqual(f'{x}', 'test')
1490 self.assertEqual(f'{x:}', 'test')
1491 self.assertEqual(f'{x!s:}', 'test')
1492 self.assertEqual(f'{x!r:}', "'test'")
1493
1494 def test_str_format_differences(self):
1495 d = {'a': 'string',
1496 0: 'integer',
1497 }
1498 a = 0
1499 self.assertEqual(f'{d[0]}', 'integer')
1500 self.assertEqual(f'{d["a"]}', 'string')
1501 self.assertEqual(f'{d[a]}', 'integer')
1502 self.assertEqual('{d[a]}'.format(d=d), 'string')
1503 self.assertEqual('{d[0]}'.format(d=d), 'integer')
1504
1505 def test_errors(self):
1506 # see issue 26287
1507 self.assertAllRaise(TypeError, 'unsupported',
1508 [r"f'{(lambda: 0):x}'",
1509 r"f'{(0,):x}'",
1510 ])
1511 self.assertAllRaise(ValueError, 'Unknown format code',
1512 [r"f'{1000:j}'",
1513 r"f'{1000:j}'",
1514 ])
1515
1516 def test_filename_in_syntaxerror(self):
1517 # see issue 38964
1518 with temp_cwd() as cwd:
1519 file_path = os.path.join(cwd, 't.py')
1520 with open(file_path, 'w', encoding="utf-8") as f:
1521 f.write('f"{a b}"') # This generates a SyntaxError
1522 _, _, stderr = assert_python_failure(file_path,
1523 PYTHONIOENCODING='ascii')
1524 self.assertIn(file_path.encode('ascii', 'backslashreplace'), stderr)
1525
1526 def test_loop(self):
1527 for i in range(1000):
1528 self.assertEqual(f'i:{i}', 'i:' + str(i))
1529
1530 def test_dict(self):
1531 d = {'"': 'dquote',
1532 "'": 'squote',
1533 'foo': 'bar',
1534 }
1535 self.assertEqual(f'''{d["'"]}''', 'squote')
1536 self.assertEqual(f"""{d['"']}""", 'dquote')
1537
1538 self.assertEqual(f'{d["foo"]}', 'bar')
1539 self.assertEqual(f"{d['foo']}", 'bar')
1540
1541 def test_backslash_char(self):
1542 # Check eval of a backslash followed by a control char.
1543 # See bpo-30682: this used to raise an assert in pydebug mode.
1544 self.assertEqual(eval('f"\\\n"'), '')
1545 self.assertEqual(eval('f"\\\r"'), '')
1546
1547 def test_debug_conversion(self):
1548 x = 'A string'
1549 self.assertEqual(f'{x=}', 'x=' + repr(x))
1550 self.assertEqual(f'{x =}', 'x =' + repr(x))
1551 self.assertEqual(f'{x=!s}', 'x=' + str(x))
1552 self.assertEqual(f'{x=!r}', 'x=' + repr(x))
1553 self.assertEqual(f'{x=!a}', 'x=' + ascii(x))
1554
1555 x = 2.71828
1556 self.assertEqual(f'{x=:.2f}', 'x=' + format(x, '.2f'))
1557 self.assertEqual(f'{x=:}', 'x=' + format(x, ''))
1558 self.assertEqual(f'{x=!r:^20}', 'x=' + format(repr(x), '^20'))
1559 self.assertEqual(f'{x=!s:^20}', 'x=' + format(str(x), '^20'))
1560 self.assertEqual(f'{x=!a:^20}', 'x=' + format(ascii(x), '^20'))
1561
1562 x = 9
1563 self.assertEqual(f'{3*x+15=}', '3*x+15=42')
1564
1565 # There is code in ast.c that deals with non-ascii expression values. So,
1566 # use a unicode identifier to trigger that.
1567 tenπ = 31.4
1568 self.assertEqual(f'{tenπ=:.2f}', 'tenπ=31.40')
1569
1570 # Also test with Unicode in non-identifiers.
1571 self.assertEqual(f'{"Σ"=}', '"Σ"=\'Σ\'')
1572
1573 # Make sure nested fstrings still work.
1574 self.assertEqual(f'{f"{3.1415=:.1f}":*^20}', '*****3.1415=3.1*****')
1575
1576 # Make sure text before and after an expression with = works
1577 # correctly.
1578 pi = 'π'
1579 self.assertEqual(f'alpha α {pi=} ω omega', "alpha α pi='π' ω omega")
1580
1581 # Check multi-line expressions.
1582 self.assertEqual(f'''{
1583 3
1584 =}''', '\n3\n=3')
1585
1586 # Since = is handled specially, make sure all existing uses of
1587 # it still work.
1588
1589 self.assertEqual(f'{0==1}', 'False')
1590 self.assertEqual(f'{0!=1}', 'True')
1591 self.assertEqual(f'{0<=1}', 'True')
1592 self.assertEqual(f'{0>=1}', 'False')
1593 self.assertEqual(f'{(x:="5")}', '5')
1594 self.assertEqual(x, '5')
1595 self.assertEqual(f'{(x:=5)}', '5')
1596 self.assertEqual(x, 5)
1597 self.assertEqual(f'{"="}', '=')
1598
1599 x = 20
1600 # This isn't an assignment expression, it's 'x', with a format
1601 # spec of '=10'. See test_walrus: you need to use parens.
1602 self.assertEqual(f'{x:=10}', ' 20')
1603
1604 # Test named function parameters, to make sure '=' parsing works
1605 # there.
1606 def f(a):
1607 nonlocal x
1608 oldx = x
1609 x = a
1610 return oldx
1611 x = 0
1612 self.assertEqual(f'{f(a="3=")}', '0')
1613 self.assertEqual(x, '3=')
1614 self.assertEqual(f'{f(a=4)}', '3=')
1615 self.assertEqual(x, 4)
1616
1617 # Check debug expressions in format spec
1618 y = 20
1619 self.assertEqual(f"{2:{y=}}", "yyyyyyyyyyyyyyyyyyy2")
1620 self.assertEqual(f"{datetime.datetime.now():h1{y=}h2{y=}h3{y=}}",
1621 'h1y=20h2y=20h3y=20')
1622
1623 # Make sure __format__ is being called.
1624 class C:
1625 def __format__(self, s):
1626 return f'FORMAT-{s}'
1627 def __repr__(self):
1628 return 'REPR'
1629
1630 self.assertEqual(f'{C()=}', 'C()=REPR')
1631 self.assertEqual(f'{C()=!r}', 'C()=REPR')
1632 self.assertEqual(f'{C()=:}', 'C()=FORMAT-')
1633 self.assertEqual(f'{C()=: }', 'C()=FORMAT- ')
1634 self.assertEqual(f'{C()=:x}', 'C()=FORMAT-x')
1635 self.assertEqual(f'{C()=!r:*^20}', 'C()=********REPR********')
1636 self.assertEqual(f"{C():{20=}}", 'FORMAT-20=20')
1637
1638 self.assertRaises(SyntaxError, eval, "f'{C=]'")
1639
1640
1641 # Make sure leading and following text works.
1642 x = 'foo'
1643 self.assertEqual(f'X{x=}Y', 'Xx='+repr(x)+'Y')
1644
1645 # Make sure whitespace around the = works.
1646 self.assertEqual(f'X{x =}Y', 'Xx ='+repr(x)+'Y')
1647 self.assertEqual(f'X{x= }Y', 'Xx= '+repr(x)+'Y')
1648 self.assertEqual(f'X{x = }Y', 'Xx = '+repr(x)+'Y')
1649 self.assertEqual(f"sadsd {1 + 1 = :{1 + 1:1d}f}", "sadsd 1 + 1 = 2.000000")
1650
1651 self.assertEqual(f"{1+2 = # my comment
1652 }", '1+2 = \n 3')
1653
1654 self.assertEqual(f'{""" # booo
1655 """=}', '""" # booo\n """=\' # booo\\n \'')
1656
1657 self.assertEqual(f'{" # nooo "=}', '" # nooo "=\' # nooo \'')
1658 self.assertEqual(f'{" \" # nooo \" "=}', '" \\" # nooo \\" "=\' " # nooo " \'')
1659
1660 self.assertEqual(f'{ # some comment goes here
1661 """hello"""=}', ' \n """hello"""=\'hello\'')
1662 self.assertEqual(f'{"""# this is not a comment
1663 a""" # this is a comment
1664 }', '# this is not a comment\n a')
1665
1666 # These next lines contains tabs. Backslash escapes don't
1667 # work in f-strings.
1668 # patchcheck doesn't like these tabs. So the only way to test
1669 # this will be to dynamically created and exec the f-strings. But
1670 # that's such a hassle I'll save it for another day. For now, convert
1671 # the tabs to spaces just to shut up patchcheck.
1672 #self.assertEqual(f'X{x =}Y', 'Xx\t='+repr(x)+'Y')
1673 #self.assertEqual(f'X{x = }Y', 'Xx\t=\t'+repr(x)+'Y')
1674
1675 def test_debug_expressions_are_raw_strings(self):
1676 with warnings.catch_warnings():
1677 warnings.simplefilter('ignore', SyntaxWarning)
1678 self.assertEqual(eval("""f'{b"\\N{OX}"=}'"""), 'b"\\N{OX}"=b\'\\\\N{OX}\'')
1679 self.assertEqual(f'{r"\xff"=}', 'r"\\xff"=\'\\\\xff\'')
1680 self.assertEqual(f'{r"\n"=}', 'r"\\n"=\'\\\\n\'')
1681 self.assertEqual(f"{'\''=}", "'\\''=\"'\"")
1682 self.assertEqual(f'{'\xc5'=}', r"'\xc5'='Å'")
1683
1684 def test_walrus(self):
1685 x = 20
1686 # This isn't an assignment expression, it's 'x', with a format
1687 # spec of '=10'.
1688 self.assertEqual(f'{x:=10}', ' 20')
1689
1690 # This is an assignment expression, which requires parens.
1691 self.assertEqual(f'{(x:=10)}', '10')
1692 self.assertEqual(x, 10)
1693
1694 def test_invalid_syntax_error_message(self):
1695 with self.assertRaisesRegex(SyntaxError,
1696 "f-string: expecting '=', or '!', or ':', or '}'"):
1697 compile("f'{a $ b}'", "?", "exec")
1698
1699 def test_with_two_commas_in_format_specifier(self):
1700 error_msg = re.escape("Cannot specify ',' with ','.")
1701 with self.assertRaisesRegex(ValueError, error_msg):
1702 f'{1:,,}'
1703
1704 def test_with_two_underscore_in_format_specifier(self):
1705 error_msg = re.escape("Cannot specify '_' with '_'.")
1706 with self.assertRaisesRegex(ValueError, error_msg):
1707 f'{1:__}'
1708
1709 def test_with_a_commas_and_an_underscore_in_format_specifier(self):
1710 error_msg = re.escape("Cannot specify both ',' and '_'.")
1711 with self.assertRaisesRegex(ValueError, error_msg):
1712 f'{1:,_}'
1713
1714 def test_with_an_underscore_and_a_comma_in_format_specifier(self):
1715 error_msg = re.escape("Cannot specify both ',' and '_'.")
1716 with self.assertRaisesRegex(ValueError, error_msg):
1717 f'{1:_,}'
1718
1719 def test_syntax_error_for_starred_expressions(self):
1720 with self.assertRaisesRegex(SyntaxError, "can't use starred expression here"):
1721 compile("f'{*a}'", "?", "exec")
1722
1723 with self.assertRaisesRegex(SyntaxError,
1724 "f-string: expecting a valid expression after '{'"):
1725 compile("f'{**a}'", "?", "exec")
1726
1727 def test_not_closing_quotes(self):
1728 self.assertAllRaise(SyntaxError, "unterminated f-string literal", ['f"', "f'"])
1729 self.assertAllRaise(SyntaxError, "unterminated triple-quoted f-string literal",
1730 ['f"""', "f'''"])
1731 # Ensure that the errors are reported at the correct line number.
1732 data = '''\
1733 x = 1 + 1
1734 y = 2 + 2
1735 z = f"""
1736 sdfjnsdfjsdf
1737 sdfsdfs{1+
1738 2} dfigdf {3+
1739 4}sdufsd""
1740 '''
1741 try:
1742 compile(data, "?", "exec")
1743 except SyntaxError as e:
1744 self.assertEqual(e.text, 'z = f"""')
1745 self.assertEqual(e.lineno, 3)
1746 def test_syntax_error_after_debug(self):
1747 self.assertAllRaise(SyntaxError, "f-string: expecting a valid expression after '{'",
1748 [
1749 "f'{1=}{;'",
1750 "f'{1=}{+;'",
1751 "f'{1=}{2}{;'",
1752 "f'{1=}{3}{;'",
1753 ])
1754 self.assertAllRaise(SyntaxError, "f-string: expecting '=', or '!', or ':', or '}'",
1755 [
1756 "f'{1=}{1;'",
1757 "f'{1=}{1;}'",
1758 ])
1759
1760 def test_debug_in_file(self):
1761 with temp_cwd():
1762 script = 'script.py'
1763 with open('script.py', 'w') as f:
1764 f.write(f"""\
1765 print(f'''{{
1766 3
1767 =}}''')""")
1768
1769 _, stdout, _ = assert_python_ok(script)
1770 self.assertEqual(stdout.decode('utf-8').strip().replace('\r\n', '\n').replace('\r', '\n'),
1771 "3\n=3")
1772
1773 def test_syntax_warning_infinite_recursion_in_file(self):
1774 with temp_cwd():
1775 script = 'script.py'
1776 with open(script, 'w') as f:
1777 f.write(r"print(f'\{1}')")
1778
1779 _, stdout, stderr = assert_python_ok(script)
1780 self.assertIn(rb'\1', stdout)
1781 self.assertEqual(len(stderr.strip().splitlines()), 2)
1782
1783 def test_fstring_without_formatting_bytecode(self):
1784 # f-string without any formatting should emit the same bytecode
1785 # as a normal string. See gh-99606.
1786 def get_code(s):
1787 return [(i.opname, i.oparg) for i in dis.get_instructions(s)]
1788
1789 for s in ["", "some string"]:
1790 self.assertEqual(get_code(f"'{s}'"), get_code(f"f'{s}'"))
1791
1792 def test_gh129093(self):
1793 self.assertEqual(f'{1==2=}', '1==2=False')
1794 self.assertEqual(f'{1 == 2=}', '1 == 2=False')
1795 self.assertEqual(f'{1!=2=}', '1!=2=True')
1796 self.assertEqual(f'{1 != 2=}', '1 != 2=True')
1797
1798 self.assertEqual(f'{(1) != 2=}', '(1) != 2=True')
1799 self.assertEqual(f'{(1*2) != (3)=}', '(1*2) != (3)=True')
1800
1801 self.assertEqual(f'{1 != 2 == 3 != 4=}', '1 != 2 == 3 != 4=False')
1802 self.assertEqual(f'{1 == 2 != 3 == 4=}', '1 == 2 != 3 == 4=False')
1803
1804 self.assertEqual(f'{f'{1==2=}'=}', "f'{1==2=}'='1==2=False'")
1805 self.assertEqual(f'{f'{1 == 2=}'=}', "f'{1 == 2=}'='1 == 2=False'")
1806 self.assertEqual(f'{f'{1!=2=}'=}', "f'{1!=2=}'='1!=2=True'")
1807 self.assertEqual(f'{f'{1 != 2=}'=}', "f'{1 != 2=}'='1 != 2=True'")
1808
1809 def test_newlines_in_format_specifiers(self):
1810 cases = [
1811 """f'{1:d\n}'""",
1812 """f'__{
1813 1:d
1814 }__'""",
1815 '''f"{value:.
1816 {'2f'}}"''',
1817 '''f"{value:
1818 {'.2f'}f}"''',
1819 '''f"{value:
1820 #{'x'}}"''',
1821 ]
1822 self.assertAllRaise(SyntaxError, "f-string: newlines are not allowed in format specifiers", cases)
1823
1824 valid_cases = [
1825 """f'''__{
1826 1:d
1827 }__'''""",
1828 """f'''{1:d\n}'''""",
1829 ]
1830
1831 for case in valid_cases:
1832 compile(case, "<string>", "exec")
1833
1834 def test_raw_fstring_format_spec(self):
1835 # Test raw f-string format spec behavior (Issue #137314).
1836 #
1837 # Raw f-strings should preserve literal backslashes in format specifications,
1838 # not interpret them as escape sequences.
1839 class UnchangedFormat:
1840 """Test helper that returns the format spec unchanged."""
1841 def __format__(self, format):
1842 return format
1843
1844 # Test basic escape sequences
1845 self.assertEqual(f"{UnchangedFormat():\xFF}", 'ÿ')
1846 self.assertEqual(rf"{UnchangedFormat():\xFF}", '\\xFF')
1847
1848 # Test nested expressions with raw/non-raw combinations
1849 self.assertEqual(rf"{UnchangedFormat():{'\xFF'}}", 'ÿ')
1850 self.assertEqual(f"{UnchangedFormat():{r'\xFF'}}", '\\xFF')
1851 self.assertEqual(rf"{UnchangedFormat():{r'\xFF'}}", '\\xFF')
1852
1853 # Test continuation character in format specs
1854 self.assertEqual(f"""{UnchangedFormat():{'a'\
1855 'b'}}""", 'ab')
1856 self.assertEqual(rf"""{UnchangedFormat():{'a'\
1857 'b'}}""", 'ab')
1858
1859 # Test multiple format specs in same raw f-string
1860 self.assertEqual(rf"{UnchangedFormat():\xFF} {UnchangedFormat():\n}", '\\xFF \\n')
1861
1862 def test_gh139516(self):
1863 with temp_cwd():
1864 script = 'script.py'
1865 with open(script, 'wb') as f:
1866 f.write('''def f(a): pass\nf"{f(a=lambda: 'à'\n)}"'''.encode())
1867 assert_python_ok(script)
1868
1869
1870 if __name__ == '__main__':
1871 unittest.main()