tests/data/long_strings__regression.py

   1 class A:
   2     def foo():
   3         result = type(message)("")
   4
   5
   6 # Don't merge multiline (e.g. triple-quoted) strings.
   7 def foo():
   8     query = (
   9         """SELECT xxxxxxxxxxxxxxxxxxxx(xxx)"""
  10         """ FROM xxxxxxxxxxxxxxxx WHERE xxxxxxxxxx AND xxx <> xxxxxxxxxxxxxx()""")
  11
  12 # There was a bug where tuples were being identified as long strings.
  13 long_tuple = ('Apple', 'Berry', 'Cherry', 'Dill', 'Evergreen', 'Fig',
  14            'Grape', 'Harry', 'Iglu', 'Jaguar')
  15
  16 stupid_format_method_bug = "Some really long string that just so happens to be the {} {} to force the 'format' method to hang over the line length boundary. This is pretty annoying.".format("perfect", "length")
  17
  18 class A:
  19     def foo():
  20         os.system("This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxxx.".format("xxxxxxxxxx", "xxxxxx", "xxxxxxxxxx"))
  21
  22
  23 class A:
  24     def foo():
  25         XXXXXXXXXXXX.append(
  26             (
  27                 "xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx, xxxx_xxxx_xxxxxxxxxx={})".format(
  28                     xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx
  29                 ),
  30                 my_var,
  31                 my_other_var,
  32             )
  33         )
  34
  35 class A:
  36     class B:
  37         def foo():
  38             bar(
  39                 (
  40                     "[{}]: xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx={}"
  41                     " xxxx_xxxx_xxxxxxxxxx={}, xxxx={})"
  42                     .format(xxxx._xxxxxxxxxxxxxx, xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx, xxxxxxx)
  43                 ),
  44                 varX,
  45                 varY,
  46                 varZ,
  47             )
  48
  49 def foo(xxxx):
  50     for (xxx_xxxx, _xxx_xxx, _xxx_xxxxx, xxx_xxxx) in xxxx:
  51         for xxx in xxx_xxxx:
  52             assert ("x" in xxx) or (
  53                 xxx in xxx_xxx_xxxxx
  54             ), "{0} xxxxxxx xx {1}, xxx {1} xx xxx xx xxxx xx xxx xxxx: xxx xxxx {2}".format(
  55                 xxx_xxxx, xxx, xxxxxx.xxxxxxx(xxx_xxx_xxxxx)
  56             )
  57
  58 class A:
  59     def disappearing_comment():
  60         return (
  61             (  # xx -x xxxxxxx xx xxx xxxxxxx.
  62                 '{{xxx_xxxxxxxxxx_xxxxxxxx}} xxx xxxx'
  63                 ' {} {{xxxx}} >&2'
  64                 .format(
  65                     "{xxxx} {xxxxxx}"
  66                     if xxxxx.xx_xxxxxxxxxx
  67                     else ( # Disappearing Comment
  68                         "--xxxxxxx --xxxxxx=x --xxxxxx-xxxxx=xxxxxx"
  69                         " --xxxxxx-xxxx=xxxxxxxxxxx.xxx"
  70                     )
  71                 )
  72             ),
  73             (x, y, z),
  74         )
  75
  76 class A:
  77     class B:
  78         def foo():
  79             xxxxx_xxxx(
  80                 xx, "\t"
  81                 "@xxxxxx '{xxxx_xxx}\t' > {xxxxxx_xxxx}.xxxxxxx;"
  82                 "{xxxx_xxx} >> {xxxxxx_xxxx}.xxxxxxx 2>&1; xx=$$?;"
  83                 "xxxx $$xx"
  84                 .format(xxxx_xxx=xxxx_xxxxxxx, xxxxxx_xxxx=xxxxxxx + "/" + xxxx_xxx_xxxx, x=xxx_xxxxx_xxxxx_xxx),
  85                 x,
  86                 y,
  87                 z,
  88             )
  89
  90 func_call_where_string_arg_has_method_call_and_bad_parens(
  91     (
  92         "A long string with {}. This string is so long that it is ridiculous. It can't fit on one line at alllll.".format("formatting")
  93     ),
  94 )
  95
  96 func_call_where_string_arg_has_old_fmt_and_bad_parens(
  97     (
  98         "A long string with {}. This string is so long that it is ridiculous. It can't fit on one line at alllll." % "formatting"
  99     ),
 100 )
 101
 102 func_call_where_string_arg_has_old_fmt_and_bad_parens(
 103     (
 104         "A long string with {}. This {} is so long that it is ridiculous. It can't fit on one line at alllll." % ("formatting", "string")
 105     ),
 106 )
 107
 108 class A:
 109     def append(self):
 110         if True:
 111             xxxx.xxxxxxx.xxxxx( ('xxxxxxxxxx xxxx xx xxxxxx(%x) xx %x xxxx xx xxx %x.xx'
 112                                  % (len(self) + 1,
 113                                     xxxx.xxxxxxxxxx,
 114                                     xxxx.xxxxxxxxxx))
 115                                 + (' %.3f (%s) to %.3f (%s).\n'
 116                                    % (xxxx.xxxxxxxxx,
 117                                       xxxx.xxxxxxxxxxxxxx(xxxx.xxxxxxxxx),
 118                                       x,
 119                                       xxxx.xxxxxxxxxxxxxx( xx)
 120                                       )))
 121
 122 class A:
 123     def foo():
 124         some_func_call(
 125             'xxxxxxxxxx',
 126             (
 127                 "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
 128                 "\"xxxx xxxxxxx xxxxxx xxxx; xxxx xxxxxx_xxxxx xxxxxx xxxx; "
 129                 "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" "
 130             ),
 131             None,
 132             ('xxxxxxxxxxx',),
 133         ),
 134
 135 class A:
 136     def foo():
 137         some_func_call(
 138             (
 139                 "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
 140                 "xxxx, ('xxxxxxx xxxxxx xxxx, xxxx') xxxxxx_xxxxx xxxxxx xxxx; "
 141                 "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" "
 142             ),
 143             None,
 144             ('xxxxxxxxxxx',),
 145         ),
 146
 147 xxxxxxx = { 'xx' : 'xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} \
 148 -xx {1} -xx xxx=xxx_xxxx,xxx_xx,xxx_xxx,xxx_xxxx,xxx_xx,xxx_xxx |\
 149  xxxxxx -x xxxxxxxx -x xxxxxxxx -x',
 150          'xx' : 'xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} \
 151 -xx {1} -xx xxx=xxx_xxxx_xxx_xxxx,xxx_xx_xxx_xxxx,xxx_xxxx_xxx_xxxx,\
 152 xxx_xx_xxxx_xxxx,xxx_xxx_xxxx,xxx_xxx_xxxx xxxx=xxx | xxxxxx -x xxxxxxxx -x xxxxxxxx -x'
 153 }
 154
 155 class A:
 156     def foo(self):
 157         if True:
 158             xxxxx_xxxxxxxxxxxx('xxx xxxxxx xxx xxxxxxxxx.xx xx xxxxxxxx.  xxx xxxxxxxxxxxxx.xx xxxxxxx '
 159                                + 'xx xxxxxx xxxxxx xxxxxx xx xxxxxxx xxx xxx ${0} xx x xxxxxxxx xxxxx'.xxxxxx(xxxxxx_xxxxxx_xxx))
 160
 161 class A:
 162     class B:
 163         def foo():
 164             row = {
 165                 'xxxxxxxxxxxxxxx' : xxxxxx_xxxxx_xxxx,
 166                 # 'xxxxxxxxxxxxxxxxxxxxxxx'
 167                 # 'xxxxxxxxxxxxxxxxxxxxxx'
 168                 # 'xxxxxxxxxxxxxxxxxx'
 169                 # 'xxxxxxxxxxxxxxxxx'
 170                 'xxxxxxxxxx' : xxxxx_xxxxx,
 171                 }
 172
 173 class A:
 174     def xxxx_xxx_xx_xxxxxxxxxx_xxxx_xxxxxxxxx(xxxx):
 175         xxxxxxxx = [
 176             xxxxxxxxxxxxxxxx(
 177                 'xxxx',
 178                 xxxxxxxxxxx={
 179                     'xxxx' : 1.0,
 180                 },
 181                 xxxxxx={'xxxxxx 1' : xxxxxx(xxxx='xxxxxx 1', xxxxxx=600.0)},
 182                 xxxxxxxx_xxxxxxx=0.0,
 183             ),
 184             xxxxxxxxxxxxxxxx(
 185                 'xxxxxxx',
 186                 xxxxxxxxxxx={
 187                     'xxxx' : 1.0,
 188                 },
 189                 xxxxxx={'xxxxxx 1' : xxxxxx(xxxx='xxxxxx 1', xxxxxx=200.0)},
 190                 xxxxxxxx_xxxxxxx=0.0,
 191             ),
 192             xxxxxxxxxxxxxxxx(
 193                 'xxxx',
 194             ),
 195         ]
 196
 197 some_dictionary = {
 198     'xxxxx006': ['xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx== xxxxx000 xxxxxxxxxx\n',
 199                  'xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx== xxxxx010 xxxxxxxxxx\n'],
 200     'xxxxx016': ['xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx== xxxxx000 xxxxxxxxxx\n',
 201                  'xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx== xxxxx010 xxxxxxxxxx\n']
 202 }
 203
 204 def foo():
 205     xxx_xxx = (
 206         'xxxx xxx xxxxxxxx_xxxx xx "xxxxxxxxxx".'
 207         '\n xxx: xxxxxx xxxxxxxx_xxxx=xxxxxxxxxx'
 208     ) # xxxx xxxxxxxxxx xxxx xx xxxx xx xxx xxxxxxxx xxxxxx xxxxx.
 209
 210 some_tuple = ("some string", "some string" " which should be joined")
 211
 212 some_commented_string = (
 213     "This string is long but not so long that it needs hahahah toooooo be so greatttt"  # This comment gets thrown to the top.
 214     " {} that I just can't think of any more good words to say about it at"
 215     " allllllllllll".format("ha")  # comments here are fine
 216 )
 217
 218 some_commented_string = (
 219     "This string is long but not so long that it needs hahahah toooooo be so greatttt"  # But these
 220     " {} that I just can't think of any more good words to say about it at"  # comments will stay
 221     " allllllllllll".format("ha")  # comments here are fine
 222 )
 223
 224 lpar_and_rpar_have_comments = func_call(  # LPAR Comment
 225     "Long really ridiculous type of string that shouldn't really even exist at all. I mean commmme onnn!!!",  # Comma Comment
 226 )  # RPAR Comment
 227
 228 cmd_fstring = (
 229     f"sudo -E deluge-console info --detailed --sort-reverse=time_added "
 230     f"{'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 231 )
 232
 233 cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 234
 235 cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {'{{}}' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 236
 237 cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {{'' if ID is None else ID}} | perl -nE 'print if /^{field}:/'"
 238
 239 fstring = f"This string really doesn't need to be an {{{{fstring}}}}, but this one most certainly, absolutely {does}."
 240
 241 fstring = (
 242     f"We have to remember to escape {braces}."
 243     " Like {these}."
 244     f" But not {this}."
 245 )
 246
 247 class A:
 248     class B:
 249         def foo():
 250             st_error = STError(
 251                 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
 252                 " no parent)."
 253             )
 254
 255 def foo():
 256     user_regex = _lazy_re_compile(
 257         r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*\Z"  # dot-atom
 258         r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"\Z)',  # quoted-string
 259         re.IGNORECASE)
 260
 261 def foo():
 262     user_regex = _lazy_re_compile(
 263         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
 264         'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',  # quoted-string
 265         xyz
 266     )
 267
 268 def foo():
 269     user_regex = _lazy_re_compile(
 270         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
 271         'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',  # quoted-string
 272         xyz
 273     )
 274
 275 class A:
 276     class B:
 277         def foo():
 278             if not hasattr(module, name):
 279                 raise ValueError(
 280                     "Could not find object %s in %s.\n"
 281                     "Please note that you cannot serialize things like inner "
 282                     "classes. Please move the object into the main module "
 283                     "body to use migrations.\n"
 284                     "For more information, see "
 285                     "https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
 286                     % (name, module_name, get_docs_version()))
 287
 288 class A:
 289     class B:
 290         def foo():
 291             if not hasattr(module, name):
 292                 raise ValueError(
 293                     "Could not find object %s in %s.\nPlease note that you cannot serialize things like inner classes. Please move the object into the main module body to use migrations.\nFor more information, see https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
 294                     % (name, module_name, get_docs_version()))
 295
 296 x = (
 297     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 298     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 299     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 300     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 301 )
 302
 303 class Step(StepBase):
 304     def who(self):
 305         self.cmd = 'SR AAAA-CORRECT NAME IS {last_name} {first_name}{middle_name} {title}/P{passenger_association}'.format(
 306             last_name=last_name,
 307             first_name=first_name,
 308             middle_name=middle_name,
 309             title=title,
 310             passenger_association=passenger_association,
 311         )
 312
 313 xxxxxxx_xxxxxx_xxxxxxx = xxx(
 314     [
 315         xxxxxxxxxxxx(
 316             xxxxxx_xxxxxxx=(
 317                 '((x.aaaaaaaaa = "xxxxxx.xxxxxxxxxxxxxxxxxxxxx") || (x.xxxxxxxxx = "xxxxxxxxxxxx")) && '
 318                 # xxxxx xxxxxxxxxxxx xxxx xxx (xxxxxxxxxxxxxxxx) xx x xxxxxxxxx xx xxxxxx.
 319                 "(x.bbbbbbbbbbbb.xxx != "
 320                 '"xxx:xxx:xxx::cccccccccccc:xxxxxxx-xxxx/xxxxxxxxxxx/xxxxxxxxxxxxxxxxx") && '
 321             )
 322         )
 323     ]
 324 )
 325
 326 if __name__ == "__main__":
 327     for i in range(4, 8):
 328         cmd = (
 329             r"for pid in $(ps aux | grep paster | grep -v grep | grep '\-%d' | awk '{print $2}'); do kill $pid; done"
 330             % (i)
 331         )
 332
 333 def A():
 334     def B():
 335         def C():
 336             def D():
 337                 def E():
 338                     def F():
 339                         def G():
 340                             assert (
 341                                 c_float(val[0][0] / val[0][1]).value
 342                                 == c_float(value[0][0] / value[0][1]).value
 343                             ), "%s didn't roundtrip" % tag
 344
 345 class xxxxxxxxxxxxxxxxxxxxx(xxxx.xxxxxxxxxxxxx):
 346     def xxxxxxx_xxxxxx(xxxx):
 347         assert xxxxxxx_xxxx in [
 348             x.xxxxx.xxxxxx.xxxxx.xxxxxx,
 349             x.xxxxx.xxxxxx.xxxxx.xxxx,
 350         ], ("xxxxxxxxxxx xxxxxxx xxxx (xxxxxx xxxx) %x xxx xxxxx" % xxxxxxx_xxxx)
 351
 352 value.__dict__[
 353     key
 354 ] = "test"  # set some Thrift field to non-None in the struct aa bb cc dd ee
 355
 356 RE_ONE_BACKSLASH = {
 357     "asdf_hjkl_jkl": re.compile(
 358         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\ )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 359     ),
 360 }
 361
 362 RE_TWO_BACKSLASHES = {
 363     "asdf_hjkl_jkl": re.compile(
 364         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\\ )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 365     ),
 366 }
 367
 368 RE_THREE_BACKSLASHES = {
 369     "asdf_hjkl_jkl": re.compile(
 370         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\\\ )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 371     ),
 372 }
 373
 374 # We do NOT split on f-string expressions.
 375 print(f"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam. {[f'{i}' for i in range(10)]}")
 376 x = f"This is a long string which contains an f-expr that should not split {{{[i for i in range(5)]}}}."
 377
 378 # The parens should NOT be removed in this case.
 379 (
 380     "my very long string that should get formatted if I'm careful to make sure it goes"
 381     " over 88 characters which it has now"
 382 )
 383
 384 # The parens should NOT be removed in this case.
 385 (
 386     "my very long string that should get formatted if I'm careful to make sure it goes over 88 characters which"
 387     " it has now"
 388 )
 389
 390 # The parens should NOT be removed in this case.
 391 (
 392     "my very long string"
 393     " that should get formatted"
 394     " if I'm careful to make sure"
 395     " it goes over 88 characters which"
 396     " it has now"
 397 )
 398
 399
 400 def _legacy_listen_examples():
 401     text += (
 402         "    \"listen for the '%(event_name)s' event\"\n"
 403         "\n    # ... (event logic logic logic) ...\n"
 404         % {
 405             "since": since,
 406         }
 407     )
 408
 409
 410 assert str(suffix_arr) == (
 411     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 412     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 413     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 414 )
 415 assert str(suffix_arr) != (
 416     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 417     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 418     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 419 )
 420 assert str(suffix_arr) <= (
 421     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 422     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 423     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 424 )
 425 assert str(suffix_arr) >= (
 426     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 427     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 428     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 429 )
 430 assert str(suffix_arr) < (
 431     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 432     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 433     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 434 )
 435 assert str(suffix_arr) > (
 436     "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 437     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 438     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 439 )
 440 assert str(suffix_arr) in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 441 assert str(suffix_arr) not in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 442
 443 # output
 444
 445
 446 class A:
 447     def foo():
 448         result = type(message)("")
 449
 450
 451 # Don't merge multiline (e.g. triple-quoted) strings.
 452 def foo():
 453     query = (
 454         """SELECT xxxxxxxxxxxxxxxxxxxx(xxx)"""
 455         """ FROM xxxxxxxxxxxxxxxx WHERE xxxxxxxxxx AND xxx <> xxxxxxxxxxxxxx()"""
 456     )
 457
 458
 459 # There was a bug where tuples were being identified as long strings.
 460 long_tuple = (
 461     "Apple",
 462     "Berry",
 463     "Cherry",
 464     "Dill",
 465     "Evergreen",
 466     "Fig",
 467     "Grape",
 468     "Harry",
 469     "Iglu",
 470     "Jaguar",
 471 )
 472
 473 stupid_format_method_bug = (
 474     "Some really long string that just so happens to be the {} {} to force the 'format'"
 475     " method to hang over the line length boundary. This is pretty annoying.".format(
 476         "perfect", "length"
 477     )
 478 )
 479
 480
 481 class A:
 482     def foo():
 483         os.system(
 484             "This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx"
 485             " xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx"
 486             " xxxx.".format("xxxxxxxxxx", "xxxxxx", "xxxxxxxxxx")
 487         )
 488
 489
 490 class A:
 491     def foo():
 492         XXXXXXXXXXXX.append(
 493             (
 494                 "xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx, xxxx_xxxx_xxxxxxxxxx={})"
 495                 .format(xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx),
 496                 my_var,
 497                 my_other_var,
 498             )
 499         )
 500
 501
 502 class A:
 503     class B:
 504         def foo():
 505             bar(
 506                 "[{}]: xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx={}"
 507                 " xxxx_xxxx_xxxxxxxxxx={}, xxxx={})".format(
 508                     xxxx._xxxxxxxxxxxxxx, xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx, xxxxxxx
 509                 ),
 510                 varX,
 511                 varY,
 512                 varZ,
 513             )
 514
 515
 516 def foo(xxxx):
 517     for (xxx_xxxx, _xxx_xxx, _xxx_xxxxx, xxx_xxxx) in xxxx:
 518         for xxx in xxx_xxxx:
 519             assert ("x" in xxx) or (xxx in xxx_xxx_xxxxx), (
 520                 "{0} xxxxxxx xx {1}, xxx {1} xx xxx xx xxxx xx xxx xxxx: xxx xxxx {2}"
 521                 .format(xxx_xxxx, xxx, xxxxxx.xxxxxxx(xxx_xxx_xxxxx))
 522             )
 523
 524
 525 class A:
 526     def disappearing_comment():
 527         return (
 528             (  # xx -x xxxxxxx xx xxx xxxxxxx.
 529                 "{{xxx_xxxxxxxxxx_xxxxxxxx}} xxx xxxx {} {{xxxx}} >&2".format(
 530                     "{xxxx} {xxxxxx}"
 531                     if xxxxx.xx_xxxxxxxxxx
 532                     else (  # Disappearing Comment
 533                         "--xxxxxxx --xxxxxx=x --xxxxxx-xxxxx=xxxxxx"
 534                         " --xxxxxx-xxxx=xxxxxxxxxxx.xxx"
 535                     )
 536                 )
 537             ),
 538             (x, y, z),
 539         )
 540
 541
 542 class A:
 543     class B:
 544         def foo():
 545             xxxxx_xxxx(
 546                 xx,
 547                 "\t"
 548                 "@xxxxxx '{xxxx_xxx}\t' > {xxxxxx_xxxx}.xxxxxxx;"
 549                 "{xxxx_xxx} >> {xxxxxx_xxxx}.xxxxxxx 2>&1; xx=$$?;"
 550                 "xxxx $$xx".format(
 551                     xxxx_xxx=xxxx_xxxxxxx,
 552                     xxxxxx_xxxx=xxxxxxx + "/" + xxxx_xxx_xxxx,
 553                     x=xxx_xxxxx_xxxxx_xxx,
 554                 ),
 555                 x,
 556                 y,
 557                 z,
 558             )
 559
 560
 561 func_call_where_string_arg_has_method_call_and_bad_parens(
 562     "A long string with {}. This string is so long that it is ridiculous. It can't fit"
 563     " on one line at alllll.".format("formatting"),
 564 )
 565
 566 func_call_where_string_arg_has_old_fmt_and_bad_parens(
 567     "A long string with {}. This string is so long that it is ridiculous. It can't fit"
 568     " on one line at alllll." % "formatting",
 569 )
 570
 571 func_call_where_string_arg_has_old_fmt_and_bad_parens(
 572     "A long string with {}. This {} is so long that it is ridiculous. It can't fit on"
 573     " one line at alllll." % ("formatting", "string"),
 574 )
 575
 576
 577 class A:
 578     def append(self):
 579         if True:
 580             xxxx.xxxxxxx.xxxxx(
 581                 "xxxxxxxxxx xxxx xx xxxxxx(%x) xx %x xxxx xx xxx %x.xx"
 582                 % (len(self) + 1, xxxx.xxxxxxxxxx, xxxx.xxxxxxxxxx)
 583                 + " %.3f (%s) to %.3f (%s).\n"
 584                 % (
 585                     xxxx.xxxxxxxxx,
 586                     xxxx.xxxxxxxxxxxxxx(xxxx.xxxxxxxxx),
 587                     x,
 588                     xxxx.xxxxxxxxxxxxxx(xx),
 589                 )
 590             )
 591
 592
 593 class A:
 594     def foo():
 595         some_func_call(
 596             "xxxxxxxxxx",
 597             "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
 598             '"xxxx xxxxxxx xxxxxx xxxx; xxxx xxxxxx_xxxxx xxxxxx xxxx; '
 599             "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" ",
 600             None,
 601             ("xxxxxxxxxxx",),
 602         ),
 603
 604
 605 class A:
 606     def foo():
 607         some_func_call(
 608             "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
 609             "xxxx, ('xxxxxxx xxxxxx xxxx, xxxx') xxxxxx_xxxxx xxxxxx xxxx; "
 610             "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" ",
 611             None,
 612             ("xxxxxxxxxxx",),
 613         ),
 614
 615
 616 xxxxxxx = {
 617     "xx": (
 618         "xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} -xx {1} -xx"
 619         " xxx=xxx_xxxx,xxx_xx,xxx_xxx,xxx_xxxx,xxx_xx,xxx_xxx | xxxxxx -x xxxxxxxx -x"
 620         " xxxxxxxx -x"
 621     ),
 622     "xx": (
 623         "xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} -xx {1} -xx"
 624         " xxx=xxx_xxxx_xxx_xxxx,xxx_xx_xxx_xxxx,xxx_xxxx_xxx_xxxx,xxx_xx_xxxx_xxxx,xxx_xxx_xxxx,xxx_xxx_xxxx"
 625         " xxxx=xxx | xxxxxx -x xxxxxxxx -x xxxxxxxx -x"
 626     ),
 627 }
 628
 629
 630 class A:
 631     def foo(self):
 632         if True:
 633             xxxxx_xxxxxxxxxxxx(
 634                 "xxx xxxxxx xxx xxxxxxxxx.xx xx xxxxxxxx.  xxx xxxxxxxxxxxxx.xx"
 635                 " xxxxxxx "
 636                 + "xx xxxxxx xxxxxx xxxxxx xx xxxxxxx xxx xxx ${0} xx x xxxxxxxx xxxxx"
 637                 .xxxxxx(xxxxxx_xxxxxx_xxx)
 638             )
 639
 640
 641 class A:
 642     class B:
 643         def foo():
 644             row = {
 645                 "xxxxxxxxxxxxxxx": xxxxxx_xxxxx_xxxx,
 646                 # 'xxxxxxxxxxxxxxxxxxxxxxx'
 647                 # 'xxxxxxxxxxxxxxxxxxxxxx'
 648                 # 'xxxxxxxxxxxxxxxxxx'
 649                 # 'xxxxxxxxxxxxxxxxx'
 650                 "xxxxxxxxxx": xxxxx_xxxxx,
 651             }
 652
 653
 654 class A:
 655     def xxxx_xxx_xx_xxxxxxxxxx_xxxx_xxxxxxxxx(xxxx):
 656         xxxxxxxx = [
 657             xxxxxxxxxxxxxxxx(
 658                 "xxxx",
 659                 xxxxxxxxxxx={
 660                     "xxxx": 1.0,
 661                 },
 662                 xxxxxx={"xxxxxx 1": xxxxxx(xxxx="xxxxxx 1", xxxxxx=600.0)},
 663                 xxxxxxxx_xxxxxxx=0.0,
 664             ),
 665             xxxxxxxxxxxxxxxx(
 666                 "xxxxxxx",
 667                 xxxxxxxxxxx={
 668                     "xxxx": 1.0,
 669                 },
 670                 xxxxxx={"xxxxxx 1": xxxxxx(xxxx="xxxxxx 1", xxxxxx=200.0)},
 671                 xxxxxxxx_xxxxxxx=0.0,
 672             ),
 673             xxxxxxxxxxxxxxxx(
 674                 "xxxx",
 675             ),
 676         ]
 677
 678
 679 some_dictionary = {
 680     "xxxxx006": [
 681         "xxx-xxx"
 682         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx=="
 683         " xxxxx000 xxxxxxxxxx\n",
 684         "xxx-xxx"
 685         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx=="
 686         " xxxxx010 xxxxxxxxxx\n",
 687     ],
 688     "xxxxx016": [
 689         "xxx-xxx"
 690         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx=="
 691         " xxxxx000 xxxxxxxxxx\n",
 692         "xxx-xxx"
 693         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx=="
 694         " xxxxx010 xxxxxxxxxx\n",
 695     ],
 696 }
 697
 698
 699 def foo():
 700     xxx_xxx = (  # xxxx xxxxxxxxxx xxxx xx xxxx xx xxx xxxxxxxx xxxxxx xxxxx.
 701         'xxxx xxx xxxxxxxx_xxxx xx "xxxxxxxxxx".\n xxx: xxxxxx xxxxxxxx_xxxx=xxxxxxxxxx'
 702     )
 703
 704
 705 some_tuple = ("some string", "some string which should be joined")
 706
 707 some_commented_string = (  # This comment gets thrown to the top.
 708     "This string is long but not so long that it needs hahahah toooooo be so greatttt"
 709     " {} that I just can't think of any more good words to say about it at"
 710     " allllllllllll".format("ha")  # comments here are fine
 711 )
 712
 713 some_commented_string = (
 714     "This string is long but not so long that it needs hahahah toooooo be so greatttt"  # But these
 715     " {} that I just can't think of any more good words to say about it at"  # comments will stay
 716     " allllllllllll".format("ha")  # comments here are fine
 717 )
 718
 719 lpar_and_rpar_have_comments = func_call(  # LPAR Comment
 720     "Long really ridiculous type of string that shouldn't really even exist at all. I"
 721     " mean commmme onnn!!!",  # Comma Comment
 722 )  # RPAR Comment
 723
 724 cmd_fstring = (
 725     "sudo -E deluge-console info --detailed --sort-reverse=time_added "
 726     f"{'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 727 )
 728
 729 cmd_fstring = (
 730     "sudo -E deluge-console info --detailed --sort-reverse=time_added"
 731     f" {'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 732 )
 733
 734 cmd_fstring = (
 735     "sudo -E deluge-console info --detailed --sort-reverse=time_added"
 736     f" {'{{}}' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
 737 )
 738
 739 cmd_fstring = (
 740     "sudo -E deluge-console info --detailed --sort-reverse=time_added {'' if ID is"
 741     f" None else ID}} | perl -nE 'print if /^{field}:/'"
 742 )
 743
 744 fstring = (
 745     "This string really doesn't need to be an {{fstring}}, but this one most"
 746     f" certainly, absolutely {does}."
 747 )
 748
 749 fstring = f"We have to remember to escape {braces}. Like {{these}}. But not {this}."
 750
 751
 752 class A:
 753     class B:
 754         def foo():
 755             st_error = STError(
 756                 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
 757                 " no parent)."
 758             )
 759
 760
 761 def foo():
 762     user_regex = _lazy_re_compile(
 763         r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*\Z"  # dot-atom
 764         r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"\Z)',  # quoted-string
 765         re.IGNORECASE,
 766     )
 767
 768
 769 def foo():
 770     user_regex = _lazy_re_compile(
 771         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
 772         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  # quoted-string
 773         xyz,
 774     )
 775
 776
 777 def foo():
 778     user_regex = _lazy_re_compile(
 779         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
 780         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  # quoted-string
 781         xyz,
 782     )
 783
 784
 785 class A:
 786     class B:
 787         def foo():
 788             if not hasattr(module, name):
 789                 raise ValueError(
 790                     "Could not find object %s in %s.\n"
 791                     "Please note that you cannot serialize things like inner "
 792                     "classes. Please move the object into the main module "
 793                     "body to use migrations.\n"
 794                     "For more information, see "
 795                     "https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
 796                     % (name, module_name, get_docs_version())
 797                 )
 798
 799
 800 class A:
 801     class B:
 802         def foo():
 803             if not hasattr(module, name):
 804                 raise ValueError(
 805                     "Could not find object %s in %s.\nPlease note that you cannot"
 806                     " serialize things like inner classes. Please move the object into"
 807                     " the main module body to use migrations.\nFor more information,"
 808                     " see https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
 809                     % (name, module_name, get_docs_version())
 810                 )
 811
 812
 813 x = (
 814     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 815     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 816     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 817     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 818 )
 819
 820
 821 class Step(StepBase):
 822     def who(self):
 823         self.cmd = (
 824             "SR AAAA-CORRECT NAME IS {last_name} {first_name}{middle_name}"
 825             " {title}/P{passenger_association}".format(
 826                 last_name=last_name,
 827                 first_name=first_name,
 828                 middle_name=middle_name,
 829                 title=title,
 830                 passenger_association=passenger_association,
 831             )
 832         )
 833
 834
 835 xxxxxxx_xxxxxx_xxxxxxx = xxx(
 836     [
 837         xxxxxxxxxxxx(
 838             xxxxxx_xxxxxxx=(
 839                 '((x.aaaaaaaaa = "xxxxxx.xxxxxxxxxxxxxxxxxxxxx") || (x.xxxxxxxxx ='
 840                 ' "xxxxxxxxxxxx")) && '
 841                 # xxxxx xxxxxxxxxxxx xxxx xxx (xxxxxxxxxxxxxxxx) xx x xxxxxxxxx xx xxxxxx.
 842                 "(x.bbbbbbbbbbbb.xxx != "
 843                 '"xxx:xxx:xxx::cccccccccccc:xxxxxxx-xxxx/xxxxxxxxxxx/xxxxxxxxxxxxxxxxx") && '
 844             )
 845         )
 846     ]
 847 )
 848
 849 if __name__ == "__main__":
 850     for i in range(4, 8):
 851         cmd = (
 852             r"for pid in $(ps aux | grep paster | grep -v grep | grep '\-%d' | awk"
 853             r" '{print $2}'); do kill $pid; done" % (i)
 854         )
 855
 856
 857 def A():
 858     def B():
 859         def C():
 860             def D():
 861                 def E():
 862                     def F():
 863                         def G():
 864                             assert (
 865                                 c_float(val[0][0] / val[0][1]).value
 866                                 == c_float(value[0][0] / value[0][1]).value
 867                             ), "%s didn't roundtrip" % tag
 868
 869
 870 class xxxxxxxxxxxxxxxxxxxxx(xxxx.xxxxxxxxxxxxx):
 871     def xxxxxxx_xxxxxx(xxxx):
 872         assert xxxxxxx_xxxx in [
 873             x.xxxxx.xxxxxx.xxxxx.xxxxxx,
 874             x.xxxxx.xxxxxx.xxxxx.xxxx,
 875         ], (
 876             "xxxxxxxxxxx xxxxxxx xxxx (xxxxxx xxxx) %x xxx xxxxx" % xxxxxxx_xxxx
 877         )
 878
 879
 880 value.__dict__[
 881     key
 882 ] = "test"  # set some Thrift field to non-None in the struct aa bb cc dd ee
 883
 884 RE_ONE_BACKSLASH = {
 885     "asdf_hjkl_jkl": re.compile(
 886         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\ )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 887     ),
 888 }
 889
 890 RE_TWO_BACKSLASHES = {
 891     "asdf_hjkl_jkl": re.compile(
 892         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\\"
 893         r" )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 894     ),
 895 }
 896
 897 RE_THREE_BACKSLASHES = {
 898     "asdf_hjkl_jkl": re.compile(
 899         r"(?<!([0-9]\ ))(?<=(^|\ ))([A-Z]+(\ )?|[0-9](\ )|[a-z](\\\ )){4,7}([A-Z]|[0-9]|[a-z])($|\b)(?!(\ ?([0-9]\ )|(\.)))"
 900     ),
 901 }
 902
 903 # We do NOT split on f-string expressions.
 904 print(
 905     "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam."
 906     f" {[f'{i}' for i in range(10)]}"
 907 )
 908 x = (
 909     "This is a long string which contains an f-expr that should not split"
 910     f" {{{[i for i in range(5)]}}}."
 911 )
 912
 913 # The parens should NOT be removed in this case.
 914 (
 915     "my very long string that should get formatted if I'm careful to make sure it goes"
 916     " over 88 characters which it has now"
 917 )
 918
 919 # The parens should NOT be removed in this case.
 920 (
 921     "my very long string that should get formatted if I'm careful to make sure it goes"
 922     " over 88 characters which it has now"
 923 )
 924
 925 # The parens should NOT be removed in this case.
 926 (
 927     "my very long string"
 928     " that should get formatted"
 929     " if I'm careful to make sure"
 930     " it goes over 88 characters which"
 931     " it has now"
 932 )
 933
 934
 935 def _legacy_listen_examples():
 936     text += (
 937         "    \"listen for the '%(event_name)s' event\"\n"
 938         "\n    # ... (event logic logic logic) ...\n"
 939         % {
 940             "since": since,
 941         }
 942     )
 943
 944
 945 assert (
 946     str(suffix_arr)
 947     == "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 948     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 949     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 950 )
 951 assert (
 952     str(suffix_arr)
 953     != "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 954     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 955     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 956 )
 957 assert (
 958     str(suffix_arr)
 959     <= "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 960     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 961     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 962 )
 963 assert (
 964     str(suffix_arr)
 965     >= "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 966     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 967     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 968 )
 969 assert (
 970     str(suffix_arr)
 971     < "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 972     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 973     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 974 )
 975 assert (
 976     str(suffix_arr)
 977     > "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', "
 978     "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', "
 979     "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']"
 980 )
 981 assert (
 982     str(suffix_arr)
 983     in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$',"
 984     " 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$', 'rykangaroo$',"
 985     " 'ykangaroo$']"
 986 )
 987 assert (
 988     str(suffix_arr)
 989     not in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$',"
 990     " 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$',"
 991     " 'rykangaroo$', 'ykangaroo$']"
 992 )