.vim/bundle/black/tests/data/cases/preview_long_strings.py

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