Lines Matching refs:self
29 def assertAllRaise(self, exception_type, regex, error_strings):
31 with self.subTest(str=str):
32 with self.assertRaisesRegex(exception_type, regex):
35 def test__format__lookup(self):
38 def __format__(self, spec):
46 y.__format__ = types.MethodType(lambda self, spec: 'instance', y)
48 self.assertEqual(f'{y}', format(y))
49 self.assertEqual(f'{y}', 'class')
50 self.assertEqual(format(x), format(y))
55 self.assertEqual(x.__format__(''), 'class')
56 self.assertEqual(y.__format__(''), 'instance')
59 self.assertEqual(type(x).__format__(x, ''), 'class')
60 self.assertEqual(type(y).__format__(y, ''), 'class')
62 def test_ast(self):
65 def __init__(self):
66 self.called = False
67 def __call__(self):
68 self.called = True
78 self.assertFalse(x.called)
84 self.assertTrue(x.called)
86 def test_ast_line_numbers(self):
91 self.assertEqual(type(t), ast.Module)
92 self.assertEqual(len(t.body), 2)
94 self.assertEqual(type(t.body[0]), ast.Assign)
95 self.assertEqual(t.body[0].lineno, 2)
97 self.assertEqual(type(t.body[1]), ast.Expr)
98 self.assertEqual(type(t.body[1].value), ast.JoinedStr)
99 self.assertEqual(len(t.body[1].value.values), 1)
100 self.assertEqual(type(t.body[1].value.values[0]), ast.FormattedValue)
101 self.assertEqual(t.body[1].lineno, 3)
102 self.assertEqual(t.body[1].value.lineno, 3)
103 self.assertEqual(t.body[1].value.values[0].lineno, 3)
106 self.assertEqual(type(binop), ast.BinOp)
107 self.assertEqual(type(binop.left), ast.Name)
108 self.assertEqual(type(binop.op), ast.Mult)
109 self.assertEqual(type(binop.right), ast.Call)
110 self.assertEqual(binop.lineno, 3)
111 self.assertEqual(binop.left.lineno, 3)
112 self.assertEqual(binop.right.lineno, 3)
113 self.assertEqual(binop.col_offset, 3)
114 self.assertEqual(binop.left.col_offset, 3)
115 self.assertEqual(binop.right.col_offset, 7)
117 def test_ast_line_numbers_multiple_formattedvalues(self):
122 self.assertEqual(type(t), ast.Module)
123 self.assertEqual(len(t.body), 2)
125 self.assertEqual(type(t.body[0]), ast.Expr)
126 self.assertEqual(type(t.body[0].value), ast.JoinedStr)
127 self.assertEqual(t.body[0].lineno, 2)
129 self.assertEqual(type(t.body[1]), ast.Expr)
130 self.assertEqual(type(t.body[1].value), ast.JoinedStr)
131 self.assertEqual(len(t.body[1].value.values), 4)
132 self.assertEqual(type(t.body[1].value.values[0]), ast.Constant)
133 self.assertEqual(type(t.body[1].value.values[0].value), str)
134 self.assertEqual(type(t.body[1].value.values[1]), ast.FormattedValue)
135 self.assertEqual(type(t.body[1].value.values[2]), ast.Constant)
136 self.assertEqual(type(t.body[1].value.values[2].value), str)
137 self.assertEqual(type(t.body[1].value.values[3]), ast.FormattedValue)
138 self.assertEqual(t.body[1].lineno, 3)
139 self.assertEqual(t.body[1].value.lineno, 3)
140 self.assertEqual(t.body[1].value.values[0].lineno, 3)
141 self.assertEqual(t.body[1].value.values[1].lineno, 3)
142 self.assertEqual(t.body[1].value.values[2].lineno, 3)
143 self.assertEqual(t.body[1].value.values[3].lineno, 3)
146 self.assertEqual(type(binop1), ast.BinOp)
147 self.assertEqual(type(binop1.left), ast.Name)
148 self.assertEqual(type(binop1.op), ast.Mult)
149 self.assertEqual(type(binop1.right), ast.Call)
150 self.assertEqual(binop1.lineno, 3)
151 self.assertEqual(binop1.left.lineno, 3)
152 self.assertEqual(binop1.right.lineno, 3)
153 self.assertEqual(binop1.col_offset, 8)
154 self.assertEqual(binop1.left.col_offset, 8)
155 self.assertEqual(binop1.right.col_offset, 12)
158 self.assertEqual(type(binop2), ast.BinOp)
159 self.assertEqual(type(binop2.left), ast.Name)
160 self.assertEqual(type(binop2.op), ast.Add)
161 self.assertEqual(type(binop2.right), ast.Call)
162 self.assertEqual(binop2.lineno, 3)
163 self.assertEqual(binop2.left.lineno, 3)
164 self.assertEqual(binop2.right.lineno, 3)
165 self.assertEqual(binop2.col_offset, 23)
166 self.assertEqual(binop2.left.col_offset, 23)
167 self.assertEqual(binop2.right.col_offset, 27)
169 def test_ast_line_numbers_nested(self):
174 self.assertEqual(type(t), ast.Module)
175 self.assertEqual(len(t.body), 2)
177 self.assertEqual(type(t.body[0]), ast.Assign)
178 self.assertEqual(t.body[0].lineno, 2)
180 self.assertEqual(type(t.body[1]), ast.Expr)
181 self.assertEqual(type(t.body[1].value), ast.JoinedStr)
182 self.assertEqual(len(t.body[1].value.values), 1)
183 self.assertEqual(type(t.body[1].value.values[0]), ast.FormattedValue)
184 self.assertEqual(t.body[1].lineno, 3)
185 self.assertEqual(t.body[1].value.lineno, 3)
186 self.assertEqual(t.body[1].value.values[0].lineno, 3)
189 self.assertEqual(type(binop), ast.BinOp)
190 self.assertEqual(type(binop.left), ast.Name)
191 self.assertEqual(type(binop.op), ast.Mult)
192 self.assertEqual(type(binop.right), ast.JoinedStr)
193 self.assertEqual(binop.lineno, 3)
194 self.assertEqual(binop.left.lineno, 3)
195 self.assertEqual(binop.right.lineno, 3)
196 self.assertEqual(binop.col_offset, 3)
197 self.assertEqual(binop.left.col_offset, 3)
198 self.assertEqual(binop.right.col_offset, 7)
200 self.assertEqual(len(binop.right.values), 3)
201 self.assertEqual(type(binop.right.values[0]), ast.Constant)
202 self.assertEqual(type(binop.right.values[0].value), str)
203 self.assertEqual(type(binop.right.values[1]), ast.FormattedValue)
204 self.assertEqual(type(binop.right.values[2]), ast.Constant)
205 self.assertEqual(type(binop.right.values[2].value), str)
206 self.assertEqual(binop.right.values[0].lineno, 3)
207 self.assertEqual(binop.right.values[1].lineno, 3)
208 self.assertEqual(binop.right.values[2].lineno, 3)
210 self.assertEqual(type(call), ast.Call)
211 self.assertEqual(call.lineno, 3)
212 self.assertEqual(call.col_offset, 11)
214 def test_ast_line_numbers_duplicate_expression(self):
220 self.assertEqual(type(t), ast.Module)
221 self.assertEqual(len(t.body), 2)
223 self.assertEqual(type(t.body[0]), ast.Assign)
224 self.assertEqual(t.body[0].lineno, 2)
226 self.assertEqual(type(t.body[1]), ast.Expr)
227 self.assertEqual(type(t.body[1].value), ast.JoinedStr)
228 self.assertEqual(len(t.body[1].value.values), 5)
229 self.assertEqual(type(t.body[1].value.values[0]), ast.FormattedValue)
230 self.assertEqual(type(t.body[1].value.values[1]), ast.Constant)
231 self.assertEqual(type(t.body[1].value.values[1].value), str)
232 self.assertEqual(type(t.body[1].value.values[2]), ast.FormattedValue)
233 self.assertEqual(type(t.body[1].value.values[3]), ast.Constant)
234 self.assertEqual(type(t.body[1].value.values[3].value), str)
235 self.assertEqual(type(t.body[1].value.values[4]), ast.FormattedValue)
236 self.assertEqual(t.body[1].lineno, 3)
237 self.assertEqual(t.body[1].value.lineno, 3)
238 self.assertEqual(t.body[1].value.values[0].lineno, 3)
239 self.assertEqual(t.body[1].value.values[1].lineno, 3)
240 self.assertEqual(t.body[1].value.values[2].lineno, 3)
241 self.assertEqual(t.body[1].value.values[3].lineno, 3)
242 self.assertEqual(t.body[1].value.values[4].lineno, 3)
245 self.assertEqual(type(binop), ast.BinOp)
246 self.assertEqual(type(binop.left), ast.Name)
247 self.assertEqual(type(binop.op), ast.Mult)
248 self.assertEqual(type(binop.right), ast.Call)
249 self.assertEqual(binop.lineno, 3)
250 self.assertEqual(binop.left.lineno, 3)
251 self.assertEqual(binop.right.lineno, 3)
252 self.assertEqual(binop.col_offset, 3)
253 self.assertEqual(binop.left.col_offset, 3)
254 self.assertEqual(binop.right.col_offset, 7)
257 self.assertEqual(type(binop), ast.BinOp)
258 self.assertEqual(type(binop.left), ast.Name)
259 self.assertEqual(type(binop.op), ast.Mult)
260 self.assertEqual(type(binop.right), ast.Call)
261 self.assertEqual(binop.lineno, 3)
262 self.assertEqual(binop.left.lineno, 3)
263 self.assertEqual(binop.right.lineno, 3)
264 self.assertEqual(binop.col_offset, 13)
265 self.assertEqual(binop.left.col_offset, 13)
266 self.assertEqual(binop.right.col_offset, 17)
269 self.assertEqual(type(binop), ast.BinOp)
270 self.assertEqual(type(binop.left), ast.Name)
271 self.assertEqual(type(binop.op), ast.Mult)
272 self.assertEqual(type(binop.right), ast.Call)
273 self.assertEqual(binop.lineno, 3)
274 self.assertEqual(binop.left.lineno, 3)
275 self.assertEqual(binop.right.lineno, 3)
276 self.assertEqual(binop.col_offset, 23)
277 self.assertEqual(binop.left.col_offset, 23)
278 self.assertEqual(binop.right.col_offset, 27)
280 def test_ast_numbers_fstring_with_formatting(self):
283 self.assertEqual(len(t.body), 1)
284 self.assertEqual(t.body[0].lineno, 1)
286 self.assertEqual(type(t.body[0]), ast.Expr)
287 self.assertEqual(type(t.body[0].value), ast.JoinedStr)
288 self.assertEqual(len(t.body[0].value.values), 3)
290 self.assertEqual(type(t.body[0].value.values[0]), ast.Constant)
291 self.assertEqual(type(t.body[0].value.values[1]), ast.FormattedValue)
292 self.assertEqual(type(t.body[0].value.values[2]), ast.Constant)
297 self.assertEqual(type(name), ast.Name)
298 self.assertEqual(name.lineno, 1)
299 self.assertEqual(name.end_lineno, 1)
300 self.assertEqual(name.col_offset, 22)
301 self.assertEqual(name.end_col_offset, 25)
303 def test_ast_line_numbers_multiline_fstring(self):
315 self.assertEqual(type(t), ast.Module)
316 self.assertEqual(len(t.body), 2)
318 self.assertEqual(type(t.body[0]), ast.Assign)
319 self.assertEqual(t.body[0].lineno, 2)
321 self.assertEqual(type(t.body[1]), ast.Expr)
322 self.assertEqual(type(t.body[1].value), ast.JoinedStr)
323 self.assertEqual(len(t.body[1].value.values), 3)
324 self.assertEqual(type(t.body[1].value.values[0]), ast.Constant)
325 self.assertEqual(type(t.body[1].value.values[0].value), str)
326 self.assertEqual(type(t.body[1].value.values[1]), ast.FormattedValue)
327 self.assertEqual(type(t.body[1].value.values[2]), ast.Constant)
328 self.assertEqual(type(t.body[1].value.values[2].value), str)
329 self.assertEqual(t.body[1].lineno, 3)
330 self.assertEqual(t.body[1].value.lineno, 3)
331 self.assertEqual(t.body[1].value.values[0].lineno, 3)
332 self.assertEqual(t.body[1].value.values[1].lineno, 3)
333 self.assertEqual(t.body[1].value.values[2].lineno, 3)
334 self.assertEqual(t.body[1].col_offset, 0)
335 self.assertEqual(t.body[1].value.col_offset, 0)
336 self.assertEqual(t.body[1].value.values[0].col_offset, 0)
337 self.assertEqual(t.body[1].value.values[1].col_offset, 0)
338 self.assertEqual(t.body[1].value.values[2].col_offset, 0)
342 self.assertEqual(type(binop), ast.BinOp)
343 self.assertEqual(type(binop.left), ast.Name)
344 self.assertEqual(type(binop.op), ast.Mult)
345 self.assertEqual(type(binop.right), ast.Call)
346 self.assertEqual(binop.lineno, 4)
347 self.assertEqual(binop.left.lineno, 4)
348 self.assertEqual(binop.right.lineno, 6)
349 self.assertEqual(binop.col_offset, 3)
350 self.assertEqual(binop.left.col_offset, 3)
351 self.assertEqual(binop.right.col_offset, 7)
359 self.assertEqual(type(t), ast.Module)
360 self.assertEqual(len(t.body), 1)
362 self.assertEqual(type(t.body[0]), ast.Assign)
363 self.assertEqual(type(t.body[0].value), ast.JoinedStr)
364 self.assertEqual(len(t.body[0].value.values), 3)
365 self.assertEqual(type(t.body[0].value.values[1]), ast.FormattedValue)
366 self.assertEqual(t.body[0].lineno, 2)
367 self.assertEqual(t.body[0].value.lineno, 2)
368 self.assertEqual(t.body[0].value.values[0].lineno, 2)
369 self.assertEqual(t.body[0].value.values[1].lineno, 2)
370 self.assertEqual(t.body[0].value.values[2].lineno, 2)
371 self.assertEqual(t.body[0].col_offset, 0)
372 self.assertEqual(t.body[0].value.col_offset, 4)
373 self.assertEqual(t.body[0].value.values[0].col_offset, 4)
374 self.assertEqual(t.body[0].value.values[1].col_offset, 4)
375 self.assertEqual(t.body[0].value.values[2].col_offset, 4)
377 self.assertEqual(t.body[0].value.values[1].value.lineno, 3)
378 self.assertEqual(t.body[0].value.values[1].value.end_lineno, 3)
379 self.assertEqual(t.body[0].value.values[1].value.col_offset, 11)
380 self.assertEqual(t.body[0].value.values[1].value.end_col_offset, 16)
382 def test_ast_line_numbers_with_parentheses(self):
388 self.assertEqual(type(t), ast.Module)
389 self.assertEqual(len(t.body), 1)
392 self.assertEqual(type(call), ast.Call)
393 self.assertEqual(call.lineno, 3)
394 self.assertEqual(call.end_lineno, 3)
395 self.assertEqual(call.col_offset, 8)
396 self.assertEqual(call.end_col_offset, 15)
408 self.assertEqual(type(t), ast.Module)
409 self.assertEqual(len(t.body), 1)
412 self.assertEqual(type(fstring), ast.JoinedStr)
413 self.assertEqual(len(fstring.values), 3)
416 self.assertEqual(type(wat1), ast.Constant)
417 self.assertEqual(wat1.lineno, 4)
418 self.assertEqual(wat1.end_lineno, 6)
419 self.assertEqual(wat1.col_offset, 12)
420 self.assertEqual(wat1.end_col_offset, 18)
423 self.assertEqual(type(call), ast.Call)
424 self.assertEqual(call.lineno, 5)
425 self.assertEqual(call.end_lineno, 5)
426 self.assertEqual(call.col_offset, 27)
427 self.assertEqual(call.end_col_offset, 31)
429 self.assertEqual(type(wat2), ast.Constant)
430 self.assertEqual(wat2.lineno, 4)
431 self.assertEqual(wat2.end_lineno, 6)
432 self.assertEqual(wat2.col_offset, 12)
433 self.assertEqual(wat2.end_col_offset, 18)
435 def test_docstring(self):
438 self.assertIsNone(f.__doc__)
442 self.assertIsNone(g.__doc__)
444 def test_literal_eval(self):
445 with self.assertRaisesRegex(ValueError, 'malformed node or string'):
448 def test_ast_compile_time_concat(self):
455 self.assertEqual(x[0], 'foo3')
457 def test_compile_time_concat_errors(self):
458 self.assertAllRaise(SyntaxError,
464 def test_literal(self):
465 self.assertEqual(f'', '')
466 self.assertEqual(f'a', 'a')
467 self.assertEqual(f' ', ' ')
469 def test_unterminated_string(self):
470 self.assertAllRaise(SyntaxError, 'f-string: unterminated string',
477 def test_mismatched_parens(self):
478 self.assertAllRaise(SyntaxError, r"f-string: closing parenthesis '\}' "
482 self.assertAllRaise(SyntaxError, r"f-string: closing parenthesis '\)' "
486 self.assertAllRaise(SyntaxError, r"f-string: closing parenthesis '\]' "
490 self.assertAllRaise(SyntaxError, r"f-string: closing parenthesis '\}' "
494 self.assertAllRaise(SyntaxError, r"f-string: closing parenthesis '\}' "
498 self.assertRaises(SyntaxError, eval, "f'{" + "("*500 + "}'")
500 def test_double_braces(self):
501 self.assertEqual(f'{{', '{')
502 self.assertEqual(f'a{{', 'a{')
503 self.assertEqual(f'{{b', '{b')
504 self.assertEqual(f'a{{b', 'a{b')
505 self.assertEqual(f'}}', '}')
506 self.assertEqual(f'a}}', 'a}')
507 self.assertEqual(f'}}b', '}b')
508 self.assertEqual(f'a}}b', 'a}b')
509 self.assertEqual(f'{{}}', '{}')
510 self.assertEqual(f'a{{}}', 'a{}')
511 self.assertEqual(f'{{b}}', '{b}')
512 self.assertEqual(f'{{}}c', '{}c')
513 self.assertEqual(f'a{{b}}', 'a{b}')
514 self.assertEqual(f'a{{}}c', 'a{}c')
515 self.assertEqual(f'{{b}}c', '{b}c')
516 self.assertEqual(f'a{{b}}c', 'a{b}c')
518 self.assertEqual(f'{{{10}', '{10')
519 self.assertEqual(f'}}{10}', '}10')
520 self.assertEqual(f'}}{{{10}', '}{10')
521 self.assertEqual(f'}}a{{{10}', '}a{10')
523 self.assertEqual(f'{10}{{', '10{')
524 self.assertEqual(f'{10}}}', '10}')
525 self.assertEqual(f'{10}}}{{', '10}{')
526 self.assertEqual(f'{10}}}a{{' '}', '10}a{}')
529 self.assertEqual(f'{"{{}}"}', '{{}}')
531 self.assertAllRaise(TypeError, 'unhashable type',
535 def test_compile_time_concat(self):
537 self.assertEqual('abc' f'## {x}ghi', 'abc## defghi')
538 self.assertEqual('abc' f'{x}' 'ghi', 'abcdefghi')
539 self.assertEqual('abc' f'{x}' 'gh' f'i{x:4}', 'abcdefghidef ')
540 self.assertEqual('{x}' f'{x}', '{x}def')
541 self.assertEqual('{x' f'{x}', '{xdef')
542 self.assertEqual('{x}' f'{x}', '{x}def')
543 self.assertEqual('{{x}}' f'{x}', '{{x}}def')
544 self.assertEqual('{{x' f'{x}', '{{xdef')
545 self.assertEqual('x}}' f'{x}', 'x}}def')
546 self.assertEqual(f'{x}' 'x}}', 'defx}}')
547 self.assertEqual(f'{x}' '', 'def')
548 self.assertEqual('' f'{x}' '', 'def')
549 self.assertEqual('' f'{x}', 'def')
550 self.assertEqual(f'{x}' '2', 'def2')
551 self.assertEqual('1' f'{x}' '2', '1def2')
552 self.assertEqual('1' f'{x}', '1def')
553 self.assertEqual(f'{x}' f'-{x}', 'def-def')
554 self.assertEqual('' f'', '')
555 self.assertEqual('' f'' '', '')
556 self.assertEqual('' f'' '' f'', '')
557 self.assertEqual(f'', '')
558 self.assertEqual(f'' '', '')
559 self.assertEqual(f'' '' f'', '')
560 self.assertEqual(f'' '' f'' '', '')
562 self.assertAllRaise(SyntaxError, "f-string: expecting '}'",
566 def test_comments(self):
569 self.assertEqual(f'{"#"}', '#')
570 self.assertEqual(f'{d["#"]}', 'hash')
572 self.assertAllRaise(SyntaxError, "f-string expression part cannot include '#'",
577 self.assertAllRaise(SyntaxError, r"f-string: unmatched '\)'",
582 def test_many_expressions(self):
595 self.assertEqual(eval(build_fstr(i)), (x+' ')*i)
598 self.assertEqual(eval(build_fstr(255)*256), (x+' ')*(255*256))
601 self.assertEqual(eval(s), (x+' ')*254)
605 self.assertEqual(eval(s), '1xy' * 1024)
607 def test_format_specifier_expressions(self):
611 self.assertEqual(f'result: {value:{width}.{precision}}', 'result: 12.35')
612 self.assertEqual(f'result: {value:{width!r}.{precision}}', 'result: 12.35')
613 self.assertEqual(f'result: {value:{width:0}.{precision:1}}', 'result: 12.35')
614 self.assertEqual(f'result: {value:{1}{0:0}.{precision:1}}', 'result: 12.35')
615 self.assertEqual(f'result: {value:{ 1}{ 0:0}.{ precision:1}}', 'result: 12.35')
616 self.assertEqual(f'{10:#{1}0x}', ' 0xa')
617 self.assertEqual(f'{10:{"#"}1{0}{"x"}}', ' 0xa')
618 self.assertEqual(f'{-10:-{"#"}1{0}x}', ' -0xa')
619 self.assertEqual(f'{-10:{"-"}#{1}0{"x"}}', ' -0xa')
620 self.assertEqual(f'{10:#{3 != {4:5} and width}x}', ' 0xa')
622 self.assertAllRaise(SyntaxError, "f-string: expecting '}'",
628 self.assertAllRaise(SyntaxError, "f-string: invalid syntax",
633 self.assertAllRaise(SyntaxError, "f-string: expressions nested too deeply",
638 self.assertAllRaise(SyntaxError, 'f-string: invalid conversion character',
644 def test_side_effect_order(self):
646 def __init__(self):
647 self.i = 0
648 def __format__(self, spec):
649 self.i += 1
650 return str(self.i)
653 self.assertEqual(f'{x} {x}', '1 2')
655 def test_missing_expression(self):
656 self.assertAllRaise(SyntaxError, 'f-string: empty expression not allowed',
669 self.assertAllRaise(SyntaxError, "f-string: expression required before '!'",
690 self.assertAllRaise(SyntaxError, "f-string: expression required before ':'",
698 self.assertAllRaise(SyntaxError, "f-string: expression required before '='",
708 self.assertAllRaise(SyntaxError, r"invalid non-printable character U\+00A0",
713 def test_parens_in_expressions(self):
714 self.assertEqual(f'{3,}', '(3,)')
720 self.assertAllRaise(SyntaxError, 'f-string: invalid syntax',
725 self.assertAllRaise(SyntaxError, r"f-string: unmatched '\)'",
729 self.assertAllRaise(SyntaxError, 'unterminated string literal',
732 def test_newlines_before_syntax_error(self):
733 self.assertAllRaise(SyntaxError, "invalid syntax",
736 def test_backslashes_in_string_part(self):
737 self.assertEqual(f'\t', '\t')
738 self.assertEqual(r'\t', '\\t')
739 self.assertEqual(rf'\t', '\\t')
740 self.assertEqual(f'{2}\t', '2\t')
741 self.assertEqual(f'{2}\t{3}', '2\t3')
742 self.assertEqual(f'\t{3}', '\t3')
744 self.assertEqual(f'\u0394', '\u0394')
745 self.assertEqual(r'\u0394', '\\u0394')
746 self.assertEqual(rf'\u0394', '\\u0394')
747 self.assertEqual(f'{2}\u0394', '2\u0394')
748 self.assertEqual(f'{2}\u0394{3}', '2\u03943')
749 self.assertEqual(f'\u0394{3}', '\u03943')
751 self.assertEqual(f'\U00000394', '\u0394')
752 self.assertEqual(r'\U00000394', '\\U00000394')
753 self.assertEqual(rf'\U00000394', '\\U00000394')
754 self.assertEqual(f'{2}\U00000394', '2\u0394')
755 self.assertEqual(f'{2}\U00000394{3}', '2\u03943')
756 self.assertEqual(f'\U00000394{3}', '\u03943')
758 self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}', '\u0394')
759 self.assertEqual(f'{2}\N{GREEK CAPITAL LETTER DELTA}', '2\u0394')
760 self.assertEqual(f'{2}\N{GREEK CAPITAL LETTER DELTA}{3}', '2\u03943')
761 self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}{3}', '\u03943')
762 self.assertEqual(f'2\N{GREEK CAPITAL LETTER DELTA}', '2\u0394')
763 self.assertEqual(f'2\N{GREEK CAPITAL LETTER DELTA}3', '2\u03943')
764 self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}3', '\u03943')
766 self.assertEqual(f'\x20', ' ')
767 self.assertEqual(r'\x20', '\\x20')
768 self.assertEqual(rf'\x20', '\\x20')
769 self.assertEqual(f'{2}\x20', '2 ')
770 self.assertEqual(f'{2}\x20{3}', '2 3')
771 self.assertEqual(f'\x20{3}', ' 3')
773 self.assertEqual(f'2\x20', '2 ')
774 self.assertEqual(f'2\x203', '2 3')
775 self.assertEqual(f'\x203', ' 3')
777 with self.assertWarns(DeprecationWarning): # invalid escape sequence
779 self.assertEqual(value, '\\42')
780 self.assertEqual(f'\\{6*7}', '\\42')
781 self.assertEqual(fr'\{6*7}', '\\42')
786 self.assertEqual(f'\N{AMPERSAND}', '&')
787 self.assertEqual(f'\\N{AMPERSAND}', '\\Nspam')
788 self.assertEqual(fr'\N{AMPERSAND}', '\\Nspam')
789 self.assertEqual(f'\\\N{AMPERSAND}', '\\&')
791 def test_misformed_unicode_character_name(self):
794 self.assertAllRaise(SyntaxError, r"\(unicode error\) 'unicodeescape' codec can't decode bytes in position .*: malformed \\N character escape",
810 def test_no_backslashes_in_expression_part(self):
811 self.assertAllRaise(SyntaxError, 'f-string expression part cannot include a backslash',
822 def test_no_escapes_for_braces(self):
827 self.assertEqual(f'\x7b1+1}}', '{1+1}')
828 self.assertEqual(f'\x7b1+1', '{1+1')
829 self.assertEqual(f'\u007b1+1', '{1+1')
830 self.assertEqual(f'\N{LEFT CURLY BRACKET}1+1\N{RIGHT CURLY BRACKET}', '{1+1}')
832 def test_newlines_in_expressions(self):
833 self.assertEqual(f'{0}', '0')
834 self.assertEqual(rf'''{3+
837 def test_lambda(self):
839 self.assertEqual(f'{(lambda y:x*y)("8")!r}', "'88888'")
840 self.assertEqual(f'{(lambda y:x*y)("8")!r:10}', "'88888' ")
841 self.assertEqual(f'{(lambda y:x*y)("8"):10}', "88888 ")
845 self.assertAllRaise(SyntaxError, 'f-string: invalid syntax',
849 def test_yield(self):
857 self.assertEqual(next(g), 8)
858 self.assertEqual(next(g), None)
860 def test_yield_send(self):
866 self.assertEqual(the_lambda(4), 40)
867 self.assertEqual(g.send('string'), 'x:string')
869 def test_expressions_with_triple_quoted_strings(self):
870 self.assertEqual(f"{'''x'''}", 'x')
871 self.assertEqual(f"{'''eric's'''}", "eric's")
874 self.assertEqual(f'{"x" """eric"s""" "y"}', 'xeric"sy')
875 self.assertEqual(f'{"x" """eric"s"""}', 'xeric"s')
876 self.assertEqual(f'{"""eric"s""" "y"}', 'eric"sy')
877 self.assertEqual(f'{"""x""" """eric"s""" "y"}', 'xeric"sy')
878 self.assertEqual(f'{"""x""" """eric"s""" """y"""}', 'xeric"sy')
879 self.assertEqual(f'{r"""x""" """eric"s""" """y"""}', 'xeric"sy')
881 def test_multiple_vars(self):
884 self.assertEqual(f'{x}{y}', '98abc')
886 self.assertEqual(f'X{x}{y}', 'X98abc')
887 self.assertEqual(f'{x}X{y}', '98Xabc')
888 self.assertEqual(f'{x}{y}X', '98abcX')
890 self.assertEqual(f'X{x}Y{y}', 'X98Yabc')
891 self.assertEqual(f'X{x}{y}Y', 'X98abcY')
892 self.assertEqual(f'{x}X{y}Y', '98XabcY')
894 self.assertEqual(f'X{x}Y{y}Z', 'X98YabcZ')
896 def test_closure(self):
902 self.assertEqual(outer('987')(), 'x:987')
903 self.assertEqual(outer(7)(), 'x:7')
905 def test_arguments(self):
910 self.assertEqual(f('foo', 10), 'x=foofoo ')
912 self.assertEqual(f(10, 10), 'x= 20')
914 def test_locals(self):
916 self.assertEqual(f'v:{value}', 'v:123')
918 def test_missing_variable(self):
919 with self.assertRaises(NameError):
922 def test_missing_format_spec(self):
924 def __format__(self, spec):
929 self.assertEqual(f'{O():x}', 'x')
930 self.assertEqual(f'{O()}', '*')
931 self.assertEqual(f'{O():}', '*')
933 self.assertEqual(f'{3:}', '3')
934 self.assertEqual(f'{3!s:}', '3')
936 def test_global(self):
937 self.assertEqual(f'g:{a_global}', 'g:global variable')
938 self.assertEqual(f'g:{a_global!r}', "g:'global variable'")
941 self.assertEqual(f'g:{a_global} l:{a_local}',
943 self.assertEqual(f'g:{a_global!r}',
945 self.assertEqual(f'g:{a_global} l:{a_local!r}',
948 self.assertIn("module 'unittest' from", f'{unittest}')
950 def test_shadowed_global(self):
952 self.assertEqual(f'g:{a_global}', 'g:really a local')
953 self.assertEqual(f'g:{a_global!r}', "g:'really a local'")
956 self.assertEqual(f'g:{a_global} l:{a_local}',
958 self.assertEqual(f'g:{a_global!r}',
960 self.assertEqual(f'g:{a_global} l:{a_local!r}',
963 def test_call(self):
967 self.assertEqual(f'{foo(10)}', 'x=10')
969 def test_nested_fstrings(self):
971 self.assertEqual(f'{f"{0}"*3}', '000')
972 self.assertEqual(f'{f"{y}"*3}', '555')
974 def test_invalid_string_prefixes(self):
998 self.assertAllRaise(SyntaxError, 'invalid syntax',
1001 def test_leading_trailing_spaces(self):
1002 self.assertEqual(f'{ 3}', '3')
1003 self.assertEqual(f'{ 3}', '3')
1004 self.assertEqual(f'{3 }', '3')
1005 self.assertEqual(f'{3 }', '3')
1007 self.assertEqual(f'expr={ {x: y for x, y in [(1, 2), ]}}',
1009 self.assertEqual(f'expr={ {x: y for x, y in [(1, 2), ]} }',
1012 def test_not_equal(self):
1017 self.assertEqual(f'{3!=4}', 'True')
1018 self.assertEqual(f'{3!=4:}', 'True')
1019 self.assertEqual(f'{3!=4!s}', 'True')
1020 self.assertEqual(f'{3!=4!s:.3}', 'Tru')
1022 def test_equal_equal(self):
1026 self.assertEqual(f'{0==1}', 'False')
1028 def test_conversions(self):
1029 self.assertEqual(f'{3.14:10.10}', ' 3.14')
1030 self.assertEqual(f'{3.14!s:10.10}', '3.14 ')
1031 self.assertEqual(f'{3.14!r:10.10}', '3.14 ')
1032 self.assertEqual(f'{3.14!a:10.10}', '3.14 ')
1034 self.assertEqual(f'{"a"}', 'a')
1035 self.assertEqual(f'{"a"!r}', "'a'")
1036 self.assertEqual(f'{"a"!a}', "'a'")
1039 self.assertEqual(f'{"a!r"}', "a!r")
1042 self.assertEqual(f'{3.14:!<10.10}', '3.14!!!!!!')
1044 self.assertAllRaise(SyntaxError, 'f-string: invalid conversion character',
1054 self.assertAllRaise(SyntaxError, "f-string: expecting '}'",
1061 def test_assignment(self):
1062 self.assertAllRaise(SyntaxError, r'invalid syntax',
1068 def test_del(self):
1069 self.assertAllRaise(SyntaxError, 'invalid syntax',
1074 def test_mismatched_braces(self):
1075 self.assertAllRaise(SyntaxError, "f-string: single '}' is not allowed",
1088 self.assertAllRaise(SyntaxError, "f-string: expecting '}'",
1109 self.assertEqual(f'{"{"}', '{')
1110 self.assertEqual(f'{"}"}', '}')
1111 self.assertEqual(f'{3:{"}"}>10}', '}}}}}}}}}3')
1112 self.assertEqual(f'{2:{"{"}>10}', '{{{{{{{{{2')
1114 def test_if_conditional(self):
1125 self.assertEqual(flag, expected)
1133 self.assertEqual(flag, expected)
1141 self.assertEqual(flag, expected)
1152 def test_empty_format_specifier(self):
1154 self.assertEqual(f'{x}', 'test')
1155 self.assertEqual(f'{x:}', 'test')
1156 self.assertEqual(f'{x!s:}', 'test')
1157 self.assertEqual(f'{x!r:}', "'test'")
1159 def test_str_format_differences(self):
1164 self.assertEqual(f'{d[0]}', 'integer')
1165 self.assertEqual(f'{d["a"]}', 'string')
1166 self.assertEqual(f'{d[a]}', 'integer')
1167 self.assertEqual('{d[a]}'.format(d=d), 'string')
1168 self.assertEqual('{d[0]}'.format(d=d), 'integer')
1170 def test_errors(self):
1172 self.assertAllRaise(TypeError, 'unsupported',
1176 self.assertAllRaise(ValueError, 'Unknown format code',
1181 def test_filename_in_syntaxerror(self):
1189 self.assertIn(file_path.encode('ascii', 'backslashreplace'), stderr)
1191 def test_loop(self):
1193 self.assertEqual(f'i:{i}', 'i:' + str(i))
1195 def test_dict(self):
1200 self.assertEqual(f'''{d["'"]}''', 'squote')
1201 self.assertEqual(f"""{d['"']}""", 'dquote')
1203 self.assertEqual(f'{d["foo"]}', 'bar')
1204 self.assertEqual(f"{d['foo']}", 'bar')
1206 def test_backslash_char(self):
1209 self.assertEqual(eval('f"\\\n"'), '')
1210 self.assertEqual(eval('f"\\\r"'), '')
1212 def test_debug_conversion(self):
1214 self.assertEqual(f'{x=}', 'x=' + repr(x))
1215 self.assertEqual(f'{x =}', 'x =' + repr(x))
1216 self.assertEqual(f'{x=!s}', 'x=' + str(x))
1217 self.assertEqual(f'{x=!r}', 'x=' + repr(x))
1218 self.assertEqual(f'{x=!a}', 'x=' + ascii(x))
1221 self.assertEqual(f'{x=:.2f}', 'x=' + format(x, '.2f'))
1222 self.assertEqual(f'{x=:}', 'x=' + format(x, ''))
1223 self.assertEqual(f'{x=!r:^20}', 'x=' + format(repr(x), '^20'))
1224 self.assertEqual(f'{x=!s:^20}', 'x=' + format(str(x), '^20'))
1225 self.assertEqual(f'{x=!a:^20}', 'x=' + format(ascii(x), '^20'))
1228 self.assertEqual(f'{3*x+15=}', '3*x+15=42')
1233 self.assertEqual(f'{tenπ=:.2f}', 'tenπ=31.40')
1236 self.assertEqual(f'{"Σ"=}', '"Σ"=\'Σ\'')
1239 self.assertEqual(f'{f"{3.1415=:.1f}":*^20}', '*****3.1415=3.1*****')
1244 self.assertEqual(f'alpha α {pi=} ω omega', "alpha α pi='π' ω omega")
1247 self.assertEqual(f'''{
1254 self.assertEqual(f'{0==1}', 'False')
1255 self.assertEqual(f'{0!=1}', 'True')
1256 self.assertEqual(f'{0<=1}', 'True')
1257 self.assertEqual(f'{0>=1}', 'False')
1258 self.assertEqual(f'{(x:="5")}', '5')
1259 self.assertEqual(x, '5')
1260 self.assertEqual(f'{(x:=5)}', '5')
1261 self.assertEqual(x, 5)
1262 self.assertEqual(f'{"="}', '=')
1267 self.assertEqual(f'{x:=10}', ' 20')
1277 self.assertEqual(f'{f(a="3=")}', '0')
1278 self.assertEqual(x, '3=')
1279 self.assertEqual(f'{f(a=4)}', '3=')
1280 self.assertEqual(x, 4)
1284 def __format__(self, s):
1286 def __repr__(self):
1289 self.assertEqual(f'{C()=}', 'C()=REPR')
1290 self.assertEqual(f'{C()=!r}', 'C()=REPR')
1291 self.assertEqual(f'{C()=:}', 'C()=FORMAT-')
1292 self.assertEqual(f'{C()=: }', 'C()=FORMAT- ')
1293 self.assertEqual(f'{C()=:x}', 'C()=FORMAT-x')
1294 self.assertEqual(f'{C()=!r:*^20}', 'C()=********REPR********')
1296 self.assertRaises(SyntaxError, eval, "f'{C=]'")
1300 self.assertEqual(f'X{x=}Y', 'Xx='+repr(x)+'Y')
1303 self.assertEqual(f'X{x =}Y', 'Xx ='+repr(x)+'Y')
1304 self.assertEqual(f'X{x= }Y', 'Xx= '+repr(x)+'Y')
1305 self.assertEqual(f'X{x = }Y', 'Xx = '+repr(x)+'Y')
1313 #self.assertEqual(f'X{x =}Y', 'Xx\t='+repr(x)+'Y')
1314 #self.assertEqual(f'X{x = }Y', 'Xx\t=\t'+repr(x)+'Y')
1316 def test_walrus(self):
1320 self.assertEqual(f'{x:=10}', ' 20')
1323 self.assertEqual(f'{(x:=10)}', '10')
1324 self.assertEqual(x, 10)
1326 def test_invalid_syntax_error_message(self):
1327 with self.assertRaisesRegex(SyntaxError, "f-string: invalid syntax"):
1330 def test_with_two_commas_in_format_specifier(self):
1332 with self.assertRaisesRegex(ValueError, error_msg):
1335 def test_with_two_underscore_in_format_specifier(self):
1337 with self.assertRaisesRegex(ValueError, error_msg):
1340 def test_with_a_commas_and_an_underscore_in_format_specifier(self):
1342 with self.assertRaisesRegex(ValueError, error_msg):
1345 def test_with_an_underscore_and_a_comma_in_format_specifier(self):
1347 with self.assertRaisesRegex(ValueError, error_msg):
1350 def test_syntax_error_for_starred_expressions(self):
1352 with self.assertRaisesRegex(SyntaxError, error_msg):
1356 with self.assertRaisesRegex(SyntaxError, error_msg):