]> git.madduck.net Git - etc/vim.git/blob - tests/data/preview/long_strings.py

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Use dashes for pycodestyle max line length config (#3513)
[etc/vim.git] / tests / data / preview / long_strings.py
1 x = "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three."
2
3 x += "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three."
4
5 y = (
6     'Short string'
7 )
8
9 print('This is a really long string inside of a print statement with extra arguments attached at the end of it.', x, y, z)
10
11 print("This is a really long string inside of a print statement with no extra arguments attached at the end of it.")
12
13 D1 = {"The First": "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.", "The Second": "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary."}
14
15 D2 = {1.0: "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.", 2.0: "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary."}
16
17 D3 = {x: "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.", y: "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary."}
18
19 D4 = {"A long and ridiculous {}".format(string_key): "This is a really really really long string that has to go i,side of a dictionary. It is soooo bad.", some_func("calling", "some", "stuff"): "This is a really really really long string that has to go inside of a dictionary. It is {soooo} bad (#{x}).".format(sooo="soooo", x=2), "A %s %s" % ("formatted", "string"): "This is a really really really long string that has to go inside of a dictionary. It is %s bad (#%d)." % ("soooo", 2)}
20
21 D5 = {  # Test for https://github.com/psf/black/issues/3261
22     ("This is a really long string that can't be expected to fit in one line and is used as a nested dict's key"): {"inner": "value"},
23 }
24
25 D6 = {  # Test for https://github.com/psf/black/issues/3261
26     ("This is a really long string that can't be expected to fit in one line and is used as a dict's key"): ["value1", "value2"],
27 }
28
29 L1 = ["The is a short string", "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a list literal, so it's expected to be wrapped in parens when spliting to avoid implicit str concatenation.", short_call("arg", {"key": "value"}), "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a list literal.", ("parens should be stripped for short string in list")]
30
31 L2 = ["This is a really long string that can't be expected to fit in one line and is the only child of a list literal."]
32
33 S1 = {"The is a short string", "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a set literal, so it's expected to be wrapped in parens when spliting to avoid implicit str concatenation.", short_call("arg", {"key": "value"}), "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a set literal.", ("parens should be stripped for short string in set")}
34
35 S2 = {"This is a really long string that can't be expected to fit in one line and is the only child of a set literal."}
36
37 T1 = ("The is a short string", "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a tuple literal, so it's expected to be wrapped in parens when spliting to avoid implicit str concatenation.", short_call("arg", {"key": "value"}), "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a tuple literal.", ("parens should be stripped for short string in list"))
38
39 T2 = ("This is a really long string that can't be expected to fit in one line and is the only child of a tuple literal.",)
40
41 func_with_keywords(my_arg, my_kwarg="Long keyword strings also need to be wrapped, but they will probably need to be handled a little bit differently.")
42
43 bad_split1 = (
44     'But what should happen when code has already been formatted but in the wrong way? Like'
45     " with a space at the end instead of the beginning. Or what about when it is split too soon?"
46 )
47
48 bad_split2 = "But what should happen when code has already " \
49              "been formatted but in the wrong way? Like " \
50              "with a space at the end instead of the " \
51              "beginning. Or what about when it is split too " \
52              "soon? In the case of a split that is too " \
53              "short, black will try to honer the custom " \
54              "split."
55
56 bad_split3 = (
57     "What if we have inline comments on "  # First Comment
58     "each line of a bad split? In that "  # Second Comment
59     "case, we should just leave it alone."  # Third Comment
60 )
61
62 bad_split_func1(
63     "But what should happen when code has already "
64     "been formatted but in the wrong way? Like "
65     "with a space at the end instead of the "
66     "beginning. Or what about when it is split too "
67     "soon? In the case of a split that is too "
68     "short, black will try to honer the custom "
69     "split.",
70     xxx, yyy, zzz
71 )
72
73 bad_split_func2(
74     xxx, yyy, zzz,
75     long_string_kwarg="But what should happen when code has already been formatted but in the wrong way? Like "
76                       "with a space at the end instead of the beginning. Or what about when it is split too "
77                       "soon?",
78 )
79
80 bad_split_func3(
81     (
82         "But what should happen when code has already "
83         r"been formatted but in the wrong way? Like "
84         "with a space at the end instead of the "
85         r"beginning. Or what about when it is split too "
86         r"soon? In the case of a split that is too "
87         "short, black will try to honer the custom "
88         "split."
89     ),
90     xxx,
91     yyy,
92     zzz,
93 )
94
95 inline_comments_func1(
96     "if there are inline "
97     "comments in the middle "
98     # Here is the standard alone comment.
99     "of the implicitly concatenated "
100     "string, we should handle "
101     "them correctly",
102     xxx,
103 )
104
105 inline_comments_func2(
106     "what if the string is very very very very very very very very very very long and this part does "
107     "not fit into a single line? "
108     # Here is the standard alone comment.
109     "then the string should still be properly handled by merging and splitting "
110     "it into parts that fit in line length.",
111     xxx,
112 )
113
114 raw_string = r"This is a long raw string. When re-formatting this string, black needs to make sure it prepends the 'r' onto the new string."
115
116 fmt_string1 = "We also need to be sure to preserve any and all {} which may or may not be attached to the string in question.".format("method calls")
117
118 fmt_string2 = "But what about when the string is {} but {}".format("short", "the method call is really really really really really really really really long?")
119
120 old_fmt_string1 = "While we are on the topic of %s, we should also note that old-style formatting must also be preserved, since some %s still uses it." % ("formatting", "code")
121
122 old_fmt_string2 = "This is a %s %s %s %s" % ("really really really really really", "old", "way to format strings!", "Use f-strings instead!")
123
124 old_fmt_string3 = "Whereas only the strings after the percent sign were long in the last example, this example uses a long initial string as well. This is another %s %s %s %s" % ("really really really really really", "old", "way to format strings!", "Use f-strings instead!")
125
126 fstring = f"f-strings definitely make things more {difficult} than they need to be for {{black}}. But boy they sure are handy. The problem is that some lines will need to have the 'f' whereas others do not. This {line}, for example, needs one."
127
128 fstring_with_no_fexprs = f"Some regular string that needs to get split certainly but is NOT an fstring by any means whatsoever."
129
130 comment_string = "Long lines with inline comments should have their comments appended to the reformatted string's enclosing right parentheses."  # This comment gets thrown to the top.
131
132 arg_comment_string = print("Long lines with inline comments which are apart of (and not the only member of) an argument list should have their comments appended to the reformatted string's enclosing left parentheses.",  # This comment gets thrown to the top.
133     "Arg #2", "Arg #3", "Arg #4", "Arg #5")
134
135 pragma_comment_string1 = "Lines which end with an inline pragma comment of the form `# <pragma>: <...>` should be left alone."  # noqa: E501
136
137 pragma_comment_string2 = "Lines which end with an inline pragma comment of the form `# <pragma>: <...>` should be left alone."  # noqa
138
139 """This is a really really really long triple quote string and it should not be touched."""
140
141 triple_quote_string = """This is a really really really long triple quote string assignment and it should not be touched."""
142
143 assert some_type_of_boolean_expression, "Followed by a really really really long string that is used to provide context to the AssertionError exception."
144
145 assert some_type_of_boolean_expression, "Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic string {}.".format("formatting")
146
147 assert some_type_of_boolean_expression, "Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic string %s." % "formatting"
148
149 assert some_type_of_boolean_expression, "Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic %s %s." % ("string", "formatting")
150
151 some_function_call("With a reallly generic name and with a really really long string that is, at some point down the line, " + added + " to a variable and then added to another string.")
152
153 some_function_call("With a reallly generic name and with a really really long string that is, at some point down the line, " + added + " to a variable and then added to another string. But then what happens when the final string is also supppppperrrrr long?! Well then that second (realllllllly long) string should be split too.", "and a second argument", and_a_third)
154
155 return "A really really really really really really really really really really really really really long {} {}".format("return", "value")
156
157 func_with_bad_comma(
158     "This is a really long string argument to a function that has a trailing comma which should NOT be there.",
159 )
160
161 func_with_bad_comma(
162     "This is a really long string argument to a function that has a trailing comma which should NOT be there.", # comment after comma
163 )
164
165 func_with_bad_comma(
166     (
167         "This is a really long string argument to a function that has a trailing comma"
168         " which should NOT be there."
169     ),
170 )
171
172 func_with_bad_comma(
173     (
174         "This is a really long string argument to a function that has a trailing comma"
175         " which should NOT be there."
176     ), # comment after comma
177 )
178
179 func_with_bad_parens_that_wont_fit_in_one_line(
180     ("short string that should have parens stripped"),
181     x,
182     y,
183     z
184 )
185
186 func_with_bad_parens_that_wont_fit_in_one_line(
187     x,
188     y,
189     ("short string that should have parens stripped"),
190     z
191 )
192
193 func_with_bad_parens(
194     ("short string that should have parens stripped"),
195     x,
196     y,
197     z,
198 )
199
200 func_with_bad_parens(
201     x,
202     y,
203     ("short string that should have parens stripped"),
204     z,
205 )
206
207 annotated_variable: Final = "This is a large " + STRING + " that has been " + CONCATENATED + "using the '+' operator."
208 annotated_variable: Final = "This is a large string that has a type annotation attached to it. A type annotation should NOT stop a long string from being wrapped."
209 annotated_variable: Literal["fakse_literal"] = "This is a large string that has a type annotation attached to it. A type annotation should NOT stop a long string from being wrapped."
210
211 backslashes = "This is a really long string with \"embedded\" double quotes and 'single' quotes that also handles checking for an even number of backslashes \\"
212 backslashes = "This is a really long string with \"embedded\" double quotes and 'single' quotes that also handles checking for an even number of backslashes \\\\"
213 backslashes = "This is a really 'long' string with \"embedded double quotes\" and 'single' quotes that also handles checking for an odd number of backslashes \\\", like this...\\\\\\"
214
215 short_string = (
216     "Hi"
217     " there."
218 )
219
220 func_call(
221     short_string=(
222         "Hi"
223         " there."
224     )
225 )
226
227 raw_strings = r"Don't" " get" r" merged" " unless they are all raw."
228
229 def foo():
230     yield "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three."
231
232 x = f"This is a {{really}} long string that needs to be split without a doubt (i.e. most definitely). In short, this {string} that can't possibly be {{expected}} to fit all together on one line. In {fact} it may even take up three or more lines... like four or five... but probably just four."
233
234 long_unmergable_string_with_pragma = (
235     "This is a really long string that can't be merged because it has a likely pragma at the end"  # type: ignore
236     " of it."
237 )
238
239 long_unmergable_string_with_pragma = (
240     "This is a really long string that can't be merged because it has a likely pragma at the end"  # noqa
241     " of it."
242 )
243
244 long_unmergable_string_with_pragma = (
245     "This is a really long string that can't be merged because it has a likely pragma at the end"  # pylint: disable=some-pylint-check
246     " of it."
247 )
248
249 string_with_nameescape = (
250     "........................................................................ \N{LAO KO LA}"
251 )
252
253 string_with_nameescape = (
254     "........................................................................... \N{LAO KO LA}"
255 )
256
257 string_with_nameescape = (
258     "............................................................................ \N{LAO KO LA}"
259 )
260
261 string_with_nameescape_and_escaped_backslash = (
262     "...................................................................... \\\N{LAO KO LA}"
263 )
264
265 string_with_nameescape_and_escaped_backslash = (
266     "......................................................................... \\\N{LAO KO LA}"
267 )
268
269 string_with_nameescape_and_escaped_backslash = (
270     ".......................................................................... \\\N{LAO KO LA}"
271 )
272
273 string_with_escaped_nameescape = (
274     "........................................................................ \\N{LAO KO LA}"
275 )
276
277 string_with_escaped_nameescape = (
278     "........................................................................... \\N{LAO KO LA}"
279 )
280
281 msg = lambda x: f"this is a very very very long lambda value {x} that doesn't fit on a single line"
282
283 dict_with_lambda_values = {
284     "join": lambda j: (
285         f"{j.__class__.__name__}({some_function_call(j.left)}, "
286         f"{some_function_call(j.right)})"
287     ),
288 }
289
290 # Complex string concatenations with a method call in the middle.
291 code = (
292     ("    return [\n")
293     + (
294         ", \n".join(
295             "        (%r, self.%s, visitor.%s)"
296             % (attrname, attrname, visit_name)
297             for attrname, visit_name in names
298         )
299     )
300     + ("\n    ]\n")
301 )
302
303
304 # Test case of an outer string' parens enclose an inner string's parens.
305 call(body=("%s %s" % ((",".join(items)), suffix)))
306
307
308 # output
309
310
311 x = (
312     "This is a really long string that can't possibly be expected to fit all together"
313     " on one line. In fact it may even take up three or more lines... like four or"
314     " five... but probably just three."
315 )
316
317 x += (
318     "This is a really long string that can't possibly be expected to fit all together"
319     " on one line. In fact it may even take up three or more lines... like four or"
320     " five... but probably just three."
321 )
322
323 y = "Short string"
324
325 print(
326     (
327         "This is a really long string inside of a print statement with extra arguments"
328         " attached at the end of it."
329     ),
330     x,
331     y,
332     z,
333 )
334
335 print(
336     "This is a really long string inside of a print statement with no extra arguments"
337     " attached at the end of it."
338 )
339
340 D1 = {
341     "The First": (
342         "This is a really long string that can't possibly be expected to fit all"
343         " together on one line. Also it is inside a dictionary, so formatting is more"
344         " difficult."
345     ),
346     "The Second": (
347         "This is another really really (not really) long string that also can't be"
348         " expected to fit on one line and is, like the other string, inside a"
349         " dictionary."
350     ),
351 }
352
353 D2 = {
354     1.0: (
355         "This is a really long string that can't possibly be expected to fit all"
356         " together on one line. Also it is inside a dictionary, so formatting is more"
357         " difficult."
358     ),
359     2.0: (
360         "This is another really really (not really) long string that also can't be"
361         " expected to fit on one line and is, like the other string, inside a"
362         " dictionary."
363     ),
364 }
365
366 D3 = {
367     x: (
368         "This is a really long string that can't possibly be expected to fit all"
369         " together on one line. Also it is inside a dictionary, so formatting is more"
370         " difficult."
371     ),
372     y: (
373         "This is another really really (not really) long string that also can't be"
374         " expected to fit on one line and is, like the other string, inside a"
375         " dictionary."
376     ),
377 }
378
379 D4 = {
380     "A long and ridiculous {}".format(string_key): (
381         "This is a really really really long string that has to go i,side of a"
382         " dictionary. It is soooo bad."
383     ),
384     some_func("calling", "some", "stuff"): (
385         "This is a really really really long string that has to go inside of a"
386         " dictionary. It is {soooo} bad (#{x}).".format(sooo="soooo", x=2)
387     ),
388     "A %s %s"
389     % ("formatted", "string"): (
390         "This is a really really really long string that has to go inside of a"
391         " dictionary. It is %s bad (#%d)." % ("soooo", 2)
392     ),
393 }
394
395 D5 = {  # Test for https://github.com/psf/black/issues/3261
396     "This is a really long string that can't be expected to fit in one line and is used as a nested dict's key": {
397         "inner": "value"
398     },
399 }
400
401 D6 = {  # Test for https://github.com/psf/black/issues/3261
402     "This is a really long string that can't be expected to fit in one line and is used as a dict's key": [
403         "value1",
404         "value2",
405     ],
406 }
407
408 L1 = [
409     "The is a short string",
410     (
411         "This is a really long string that can't possibly be expected to fit all"
412         " together on one line. Also it is inside a list literal, so it's expected to"
413         " be wrapped in parens when spliting to avoid implicit str concatenation."
414     ),
415     short_call("arg", {"key": "value"}),
416     (
417         "This is another really really (not really) long string that also can't be"
418         " expected to fit on one line and is, like the other string, inside a list"
419         " literal."
420     ),
421     "parens should be stripped for short string in list",
422 ]
423
424 L2 = [
425     "This is a really long string that can't be expected to fit in one line and is the"
426     " only child of a list literal."
427 ]
428
429 S1 = {
430     "The is a short string",
431     (
432         "This is a really long string that can't possibly be expected to fit all"
433         " together on one line. Also it is inside a set literal, so it's expected to be"
434         " wrapped in parens when spliting to avoid implicit str concatenation."
435     ),
436     short_call("arg", {"key": "value"}),
437     (
438         "This is another really really (not really) long string that also can't be"
439         " expected to fit on one line and is, like the other string, inside a set"
440         " literal."
441     ),
442     "parens should be stripped for short string in set",
443 }
444
445 S2 = {
446     "This is a really long string that can't be expected to fit in one line and is the"
447     " only child of a set literal."
448 }
449
450 T1 = (
451     "The is a short string",
452     (
453         "This is a really long string that can't possibly be expected to fit all"
454         " together on one line. Also it is inside a tuple literal, so it's expected to"
455         " be wrapped in parens when spliting to avoid implicit str concatenation."
456     ),
457     short_call("arg", {"key": "value"}),
458     (
459         "This is another really really (not really) long string that also can't be"
460         " expected to fit on one line and is, like the other string, inside a tuple"
461         " literal."
462     ),
463     "parens should be stripped for short string in list",
464 )
465
466 T2 = (
467     (
468         "This is a really long string that can't be expected to fit in one line and is"
469         " the only child of a tuple literal."
470     ),
471 )
472
473 func_with_keywords(
474     my_arg,
475     my_kwarg=(
476         "Long keyword strings also need to be wrapped, but they will probably need to"
477         " be handled a little bit differently."
478     ),
479 )
480
481 bad_split1 = (
482     "But what should happen when code has already been formatted but in the wrong way?"
483     " Like with a space at the end instead of the beginning. Or what about when it is"
484     " split too soon?"
485 )
486
487 bad_split2 = (
488     "But what should happen when code has already "
489     "been formatted but in the wrong way? Like "
490     "with a space at the end instead of the "
491     "beginning. Or what about when it is split too "
492     "soon? In the case of a split that is too "
493     "short, black will try to honer the custom "
494     "split."
495 )
496
497 bad_split3 = (
498     "What if we have inline comments on "  # First Comment
499     "each line of a bad split? In that "  # Second Comment
500     "case, we should just leave it alone."  # Third Comment
501 )
502
503 bad_split_func1(
504     (
505         "But what should happen when code has already "
506         "been formatted but in the wrong way? Like "
507         "with a space at the end instead of the "
508         "beginning. Or what about when it is split too "
509         "soon? In the case of a split that is too "
510         "short, black will try to honer the custom "
511         "split."
512     ),
513     xxx,
514     yyy,
515     zzz,
516 )
517
518 bad_split_func2(
519     xxx,
520     yyy,
521     zzz,
522     long_string_kwarg=(
523         "But what should happen when code has already been formatted but in the wrong"
524         " way? Like with a space at the end instead of the beginning. Or what about"
525         " when it is split too soon?"
526     ),
527 )
528
529 bad_split_func3(
530     (
531         "But what should happen when code has already "
532         r"been formatted but in the wrong way? Like "
533         "with a space at the end instead of the "
534         r"beginning. Or what about when it is split too "
535         r"soon? In the case of a split that is too "
536         "short, black will try to honer the custom "
537         "split."
538     ),
539     xxx,
540     yyy,
541     zzz,
542 )
543
544 inline_comments_func1(
545     "if there are inline comments in the middle "
546     # Here is the standard alone comment.
547     "of the implicitly concatenated string, we should handle them correctly",
548     xxx,
549 )
550
551 inline_comments_func2(
552     "what if the string is very very very very very very very very very very long and"
553     " this part does not fit into a single line? "
554     # Here is the standard alone comment.
555     "then the string should still be properly handled by merging and splitting "
556     "it into parts that fit in line length.",
557     xxx,
558 )
559
560 raw_string = (
561     r"This is a long raw string. When re-formatting this string, black needs to make"
562     r" sure it prepends the 'r' onto the new string."
563 )
564
565 fmt_string1 = (
566     "We also need to be sure to preserve any and all {} which may or may not be"
567     " attached to the string in question.".format("method calls")
568 )
569
570 fmt_string2 = "But what about when the string is {} but {}".format(
571     "short",
572     "the method call is really really really really really really really really long?",
573 )
574
575 old_fmt_string1 = (
576     "While we are on the topic of %s, we should also note that old-style formatting"
577     " must also be preserved, since some %s still uses it." % ("formatting", "code")
578 )
579
580 old_fmt_string2 = "This is a %s %s %s %s" % (
581     "really really really really really",
582     "old",
583     "way to format strings!",
584     "Use f-strings instead!",
585 )
586
587 old_fmt_string3 = (
588     "Whereas only the strings after the percent sign were long in the last example,"
589     " this example uses a long initial string as well. This is another %s %s %s %s"
590     % (
591         "really really really really really",
592         "old",
593         "way to format strings!",
594         "Use f-strings instead!",
595     )
596 )
597
598 fstring = (
599     f"f-strings definitely make things more {difficult} than they need to be for"
600     " {black}. But boy they sure are handy. The problem is that some lines will need"
601     f" to have the 'f' whereas others do not. This {line}, for example, needs one."
602 )
603
604 fstring_with_no_fexprs = (
605     f"Some regular string that needs to get split certainly but is NOT an fstring by"
606     f" any means whatsoever."
607 )
608
609 comment_string = (  # This comment gets thrown to the top.
610     "Long lines with inline comments should have their comments appended to the"
611     " reformatted string's enclosing right parentheses."
612 )
613
614 arg_comment_string = print(
615     (  # This comment gets thrown to the top.
616         "Long lines with inline comments which are apart of (and not the only member"
617         " of) an argument list should have their comments appended to the reformatted"
618         " string's enclosing left parentheses."
619     ),
620     "Arg #2",
621     "Arg #3",
622     "Arg #4",
623     "Arg #5",
624 )
625
626 pragma_comment_string1 = "Lines which end with an inline pragma comment of the form `# <pragma>: <...>` should be left alone."  # noqa: E501
627
628 pragma_comment_string2 = "Lines which end with an inline pragma comment of the form `# <pragma>: <...>` should be left alone."  # noqa
629
630 """This is a really really really long triple quote string and it should not be touched."""
631
632 triple_quote_string = """This is a really really really long triple quote string assignment and it should not be touched."""
633
634 assert some_type_of_boolean_expression, (
635     "Followed by a really really really long string that is used to provide context to"
636     " the AssertionError exception."
637 )
638
639 assert some_type_of_boolean_expression, (
640     "Followed by a really really really long string that is used to provide context to"
641     " the AssertionError exception, which uses dynamic string {}.".format("formatting")
642 )
643
644 assert some_type_of_boolean_expression, (
645     "Followed by a really really really long string that is used to provide context to"
646     " the AssertionError exception, which uses dynamic string %s." % "formatting"
647 )
648
649 assert some_type_of_boolean_expression, (
650     "Followed by a really really really long string that is used to provide context to"
651     " the AssertionError exception, which uses dynamic %s %s."
652     % ("string", "formatting")
653 )
654
655 some_function_call(
656     "With a reallly generic name and with a really really long string that is, at some"
657     " point down the line, "
658     + added
659     + " to a variable and then added to another string."
660 )
661
662 some_function_call(
663     "With a reallly generic name and with a really really long string that is, at some"
664     " point down the line, "
665     + added
666     + " to a variable and then added to another string. But then what happens when the"
667     " final string is also supppppperrrrr long?! Well then that second (realllllllly"
668     " long) string should be split too.",
669     "and a second argument",
670     and_a_third,
671 )
672
673 return (
674     "A really really really really really really really really really really really"
675     " really really long {} {}".format("return", "value")
676 )
677
678 func_with_bad_comma(
679     (
680         "This is a really long string argument to a function that has a trailing comma"
681         " which should NOT be there."
682     ),
683 )
684
685 func_with_bad_comma(
686     (  # comment after comma
687         "This is a really long string argument to a function that has a trailing comma"
688         " which should NOT be there."
689     ),
690 )
691
692 func_with_bad_comma(
693     (
694         "This is a really long string argument to a function that has a trailing comma"
695         " which should NOT be there."
696     ),
697 )
698
699 func_with_bad_comma(
700     (  # comment after comma
701         "This is a really long string argument to a function that has a trailing comma"
702         " which should NOT be there."
703     ),
704 )
705
706 func_with_bad_parens_that_wont_fit_in_one_line(
707     "short string that should have parens stripped", x, y, z
708 )
709
710 func_with_bad_parens_that_wont_fit_in_one_line(
711     x, y, "short string that should have parens stripped", z
712 )
713
714 func_with_bad_parens(
715     "short string that should have parens stripped",
716     x,
717     y,
718     z,
719 )
720
721 func_with_bad_parens(
722     x,
723     y,
724     "short string that should have parens stripped",
725     z,
726 )
727
728 annotated_variable: Final = (
729     "This is a large "
730     + STRING
731     + " that has been "
732     + CONCATENATED
733     + "using the '+' operator."
734 )
735 annotated_variable: Final = (
736     "This is a large string that has a type annotation attached to it. A type"
737     " annotation should NOT stop a long string from being wrapped."
738 )
739 annotated_variable: Literal["fakse_literal"] = (
740     "This is a large string that has a type annotation attached to it. A type"
741     " annotation should NOT stop a long string from being wrapped."
742 )
743
744 backslashes = (
745     "This is a really long string with \"embedded\" double quotes and 'single' quotes"
746     " that also handles checking for an even number of backslashes \\"
747 )
748 backslashes = (
749     "This is a really long string with \"embedded\" double quotes and 'single' quotes"
750     " that also handles checking for an even number of backslashes \\\\"
751 )
752 backslashes = (
753     "This is a really 'long' string with \"embedded double quotes\" and 'single' quotes"
754     ' that also handles checking for an odd number of backslashes \\", like'
755     " this...\\\\\\"
756 )
757
758 short_string = "Hi there."
759
760 func_call(short_string="Hi there.")
761
762 raw_strings = r"Don't" " get" r" merged" " unless they are all raw."
763
764
765 def foo():
766     yield (
767         "This is a really long string that can't possibly be expected to fit all"
768         " together on one line. In fact it may even take up three or more lines... like"
769         " four or five... but probably just three."
770     )
771
772
773 x = (
774     "This is a {really} long string that needs to be split without a doubt (i.e."
775     f" most definitely). In short, this {string} that can't possibly be {{expected}} to"
776     f" fit all together on one line. In {fact} it may even take up three or more"
777     " lines... like four or five... but probably just four."
778 )
779
780 long_unmergable_string_with_pragma = (
781     "This is a really long string that can't be merged because it has a likely pragma at the end"  # type: ignore
782     " of it."
783 )
784
785 long_unmergable_string_with_pragma = (
786     "This is a really long string that can't be merged because it has a likely pragma at the end"  # noqa
787     " of it."
788 )
789
790 long_unmergable_string_with_pragma = (
791     "This is a really long string that can't be merged because it has a likely pragma at the end"  # pylint: disable=some-pylint-check
792     " of it."
793 )
794
795 string_with_nameescape = (
796     "........................................................................"
797     " \N{LAO KO LA}"
798 )
799
800 string_with_nameescape = (
801     "..........................................................................."
802     " \N{LAO KO LA}"
803 )
804
805 string_with_nameescape = (
806     "............................................................................"
807     " \N{LAO KO LA}"
808 )
809
810 string_with_nameescape_and_escaped_backslash = (
811     "......................................................................"
812     " \\\N{LAO KO LA}"
813 )
814
815 string_with_nameescape_and_escaped_backslash = (
816     "........................................................................."
817     " \\\N{LAO KO LA}"
818 )
819
820 string_with_nameescape_and_escaped_backslash = (
821     ".........................................................................."
822     " \\\N{LAO KO LA}"
823 )
824
825 string_with_escaped_nameescape = (
826     "........................................................................ \\N{LAO"
827     " KO LA}"
828 )
829
830 string_with_escaped_nameescape = (
831     "..........................................................................."
832     " \\N{LAO KO LA}"
833 )
834
835 msg = (
836     lambda x: (
837         f"this is a very very very long lambda value {x} that doesn't fit on a single"
838         " line"
839     )
840 )
841
842 dict_with_lambda_values = {
843     "join": lambda j: (
844         f"{j.__class__.__name__}({some_function_call(j.left)}, "
845         f"{some_function_call(j.right)})"
846     ),
847 }
848
849 # Complex string concatenations with a method call in the middle.
850 code = (
851     "    return [\n"
852     + ", \n".join(
853         "        (%r, self.%s, visitor.%s)" % (attrname, attrname, visit_name)
854         for attrname, visit_name in names
855     )
856     + "\n    ]\n"
857 )
858
859
860 # Test case of an outer string' parens enclose an inner string's parens.
861 call(body="%s %s" % (",".join(items), suffix))