]> git.madduck.net Git - etc/vim.git/blob - tests/data/long_strings__regression.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:

Hypothesis is now formatted with Black 20.8b1 (#1729)
[etc/vim.git] / 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 # output
357
358
359 class A:
360     def foo():
361         result = type(message)("")
362
363
364 # Don't merge multiline (e.g. triple-quoted) strings.
365 def foo():
366     query = (
367         """SELECT xxxxxxxxxxxxxxxxxxxx(xxx)"""
368         """ FROM xxxxxxxxxxxxxxxx WHERE xxxxxxxxxx AND xxx <> xxxxxxxxxxxxxx()"""
369     )
370
371
372 # There was a bug where tuples were being identified as long strings.
373 long_tuple = (
374     "Apple",
375     "Berry",
376     "Cherry",
377     "Dill",
378     "Evergreen",
379     "Fig",
380     "Grape",
381     "Harry",
382     "Iglu",
383     "Jaguar",
384 )
385
386 stupid_format_method_bug = (
387     "Some really long string that just so happens to be the {} {} to force the 'format'"
388     " method to hang over the line length boundary. This is pretty annoying.".format(
389         "perfect", "length"
390     )
391 )
392
393
394 class A:
395     def foo():
396         os.system(
397             "This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx"
398             " xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx"
399             " xxxx.".format("xxxxxxxxxx", "xxxxxx", "xxxxxxxxxx")
400         )
401
402
403 class A:
404     def foo():
405         XXXXXXXXXXXX.append(
406             (
407                 "xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx, xxxx_xxxx_xxxxxxxxxx={})"
408                 .format(xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx),
409                 my_var,
410                 my_other_var,
411             )
412         )
413
414
415 class A:
416     class B:
417         def foo():
418             bar(
419                 "[{}]: xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx={}"
420                 " xxxx_xxxx_xxxxxxxxxx={}, xxxx={})".format(
421                     xxxx._xxxxxxxxxxxxxx, xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx, xxxxxxx
422                 ),
423                 varX,
424                 varY,
425                 varZ,
426             )
427
428
429 def foo(xxxx):
430     for (xxx_xxxx, _xxx_xxx, _xxx_xxxxx, xxx_xxxx) in xxxx:
431         for xxx in xxx_xxxx:
432             assert ("x" in xxx) or (xxx in xxx_xxx_xxxxx), (
433                 "{0} xxxxxxx xx {1}, xxx {1} xx xxx xx xxxx xx xxx xxxx: xxx xxxx {2}"
434                 .format(xxx_xxxx, xxx, xxxxxx.xxxxxxx(xxx_xxx_xxxxx))
435             )
436
437
438 class A:
439     def disappearing_comment():
440         return (
441             (  # xx -x xxxxxxx xx xxx xxxxxxx.
442                 "{{xxx_xxxxxxxxxx_xxxxxxxx}} xxx xxxx {} {{xxxx}} >&2".format(
443                     "{xxxx} {xxxxxx}"
444                     if xxxxx.xx_xxxxxxxxxx
445                     else (  # Disappearing Comment
446                         "--xxxxxxx --xxxxxx=x --xxxxxx-xxxxx=xxxxxx"
447                         " --xxxxxx-xxxx=xxxxxxxxxxx.xxx"
448                     )
449                 )
450             ),
451             (x, y, z),
452         )
453
454
455 class A:
456     class B:
457         def foo():
458             xxxxx_xxxx(
459                 xx,
460                 "\t"
461                 "@xxxxxx '{xxxx_xxx}\t' > {xxxxxx_xxxx}.xxxxxxx;"
462                 "{xxxx_xxx} >> {xxxxxx_xxxx}.xxxxxxx 2>&1; xx=$$?;"
463                 "xxxx $$xx".format(
464                     xxxx_xxx=xxxx_xxxxxxx,
465                     xxxxxx_xxxx=xxxxxxx + "/" + xxxx_xxx_xxxx,
466                     x=xxx_xxxxx_xxxxx_xxx,
467                 ),
468                 x,
469                 y,
470                 z,
471             )
472
473
474 func_call_where_string_arg_has_method_call_and_bad_parens(
475     "A long string with {}. This string is so long that it is ridiculous. It can't fit"
476     " on one line at alllll.".format("formatting"),
477 )
478
479 func_call_where_string_arg_has_old_fmt_and_bad_parens(
480     "A long string with {}. This string is so long that it is ridiculous. It can't fit"
481     " on one line at alllll." % "formatting",
482 )
483
484 func_call_where_string_arg_has_old_fmt_and_bad_parens(
485     "A long string with {}. This {} is so long that it is ridiculous. It can't fit on"
486     " one line at alllll." % ("formatting", "string"),
487 )
488
489
490 class A:
491     def append(self):
492         if True:
493             xxxx.xxxxxxx.xxxxx(
494                 "xxxxxxxxxx xxxx xx xxxxxx(%x) xx %x xxxx xx xxx %x.xx"
495                 % (len(self) + 1, xxxx.xxxxxxxxxx, xxxx.xxxxxxxxxx)
496                 + " %.3f (%s) to %.3f (%s).\n"
497                 % (
498                     xxxx.xxxxxxxxx,
499                     xxxx.xxxxxxxxxxxxxx(xxxx.xxxxxxxxx),
500                     x,
501                     xxxx.xxxxxxxxxxxxxx(xx),
502                 )
503             )
504
505
506 class A:
507     def foo():
508         some_func_call(
509             "xxxxxxxxxx",
510             "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
511             '"xxxx xxxxxxx xxxxxx xxxx; xxxx xxxxxx_xxxxx xxxxxx xxxx; '
512             "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" ",
513             None,
514             ("xxxxxxxxxxx",),
515         ),
516
517
518 class A:
519     def foo():
520         some_func_call(
521             "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x "
522             "xxxx, ('xxxxxxx xxxxxx xxxx, xxxx') xxxxxx_xxxxx xxxxxx xxxx; "
523             "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" ",
524             None,
525             ("xxxxxxxxxxx",),
526         ),
527
528
529 xxxxxxx = {
530     "xx": (
531         "xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} -xx {1} -xx"
532         " xxx=xxx_xxxx,xxx_xx,xxx_xxx,xxx_xxxx,xxx_xx,xxx_xxx | xxxxxx -x xxxxxxxx -x"
533         " xxxxxxxx -x"
534     ),
535     "xx": (
536         "xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} -xx {1} -xx"
537         " xxx=xxx_xxxx_xxx_xxxx,xxx_xx_xxx_xxxx,xxx_xxxx_xxx_xxxx,xxx_xx_xxxx_xxxx,xxx_xxx_xxxx,xxx_xxx_xxxx"
538         " xxxx=xxx | xxxxxx -x xxxxxxxx -x xxxxxxxx -x"
539     ),
540 }
541
542
543 class A:
544     def foo(self):
545         if True:
546             xxxxx_xxxxxxxxxxxx(
547                 "xxx xxxxxx xxx xxxxxxxxx.xx xx xxxxxxxx.  xxx xxxxxxxxxxxxx.xx"
548                 " xxxxxxx "
549                 + "xx xxxxxx xxxxxx xxxxxx xx xxxxxxx xxx xxx ${0} xx x xxxxxxxx xxxxx"
550                 .xxxxxx(xxxxxx_xxxxxx_xxx)
551             )
552
553
554 class A:
555     class B:
556         def foo():
557             row = {
558                 "xxxxxxxxxxxxxxx": xxxxxx_xxxxx_xxxx,
559                 # 'xxxxxxxxxxxxxxxxxxxxxxx'
560                 # 'xxxxxxxxxxxxxxxxxxxxxx'
561                 # 'xxxxxxxxxxxxxxxxxx'
562                 # 'xxxxxxxxxxxxxxxxx'
563                 "xxxxxxxxxx": xxxxx_xxxxx,
564             }
565
566
567 class A:
568     def xxxx_xxx_xx_xxxxxxxxxx_xxxx_xxxxxxxxx(xxxx):
569         xxxxxxxx = [
570             xxxxxxxxxxxxxxxx(
571                 "xxxx",
572                 xxxxxxxxxxx={
573                     "xxxx": 1.0,
574                 },
575                 xxxxxx={"xxxxxx 1": xxxxxx(xxxx="xxxxxx 1", xxxxxx=600.0)},
576                 xxxxxxxx_xxxxxxx=0.0,
577             ),
578             xxxxxxxxxxxxxxxx(
579                 "xxxxxxx",
580                 xxxxxxxxxxx={
581                     "xxxx": 1.0,
582                 },
583                 xxxxxx={"xxxxxx 1": xxxxxx(xxxx="xxxxxx 1", xxxxxx=200.0)},
584                 xxxxxxxx_xxxxxxx=0.0,
585             ),
586             xxxxxxxxxxxxxxxx(
587                 "xxxx",
588             ),
589         ]
590
591
592 some_dictionary = {
593     "xxxxx006": [
594         "xxx-xxx"
595         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx=="
596         " xxxxx000 xxxxxxxxxx\n",
597         "xxx-xxx"
598         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx=="
599         " xxxxx010 xxxxxxxxxx\n",
600     ],
601     "xxxxx016": [
602         "xxx-xxx"
603         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx=="
604         " xxxxx000 xxxxxxxxxx\n",
605         "xxx-xxx"
606         " xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx=="
607         " xxxxx010 xxxxxxxxxx\n",
608     ],
609 }
610
611
612 def foo():
613     xxx_xxx = (  # xxxx xxxxxxxxxx xxxx xx xxxx xx xxx xxxxxxxx xxxxxx xxxxx.
614         'xxxx xxx xxxxxxxx_xxxx xx "xxxxxxxxxx".\n xxx: xxxxxx xxxxxxxx_xxxx=xxxxxxxxxx'
615     )
616
617
618 some_tuple = ("some string", "some string which should be joined")
619
620 some_commented_string = (  # This comment gets thrown to the top.
621     "This string is long but not so long that it needs hahahah toooooo be so greatttt"
622     " {} that I just can't think of any more good words to say about it at"
623     " allllllllllll".format("ha")  # comments here are fine
624 )
625
626 some_commented_string = (
627     "This string is long but not so long that it needs hahahah toooooo be so greatttt"  # But these
628     " {} that I just can't think of any more good words to say about it at"  # comments will stay
629     " allllllllllll".format("ha")  # comments here are fine
630 )
631
632 lpar_and_rpar_have_comments = func_call(  # LPAR Comment
633     "Long really ridiculous type of string that shouldn't really even exist at all. I"
634     " mean commmme onnn!!!",  # Comma Comment
635 )  # RPAR Comment
636
637 cmd_fstring = (
638     "sudo -E deluge-console info --detailed --sort-reverse=time_added "
639     f"{'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
640 )
641
642 cmd_fstring = (
643     "sudo -E deluge-console info --detailed --sort-reverse=time_added"
644     f" {'' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
645 )
646
647 cmd_fstring = (
648     "sudo -E deluge-console info --detailed --sort-reverse=time_added"
649     f" {'{{}}' if ID is None else ID} | perl -nE 'print if /^{field}:/'"
650 )
651
652 cmd_fstring = (
653     "sudo -E deluge-console info --detailed --sort-reverse=time_added {'' if ID is"
654     f" None else ID}} | perl -nE 'print if /^{field}:/'"
655 )
656
657 fstring = (
658     "This string really doesn't need to be an {{fstring}}, but this one most"
659     f" certainly, absolutely {does}."
660 )
661
662 fstring = f"We have to remember to escape {braces}. Like {{these}}. But not {this}."
663
664
665 class A:
666     class B:
667         def foo():
668             st_error = STError(
669                 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
670                 " no parent)."
671             )
672
673
674 def foo():
675     user_regex = _lazy_re_compile(
676         r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*\Z"  # dot-atom
677         r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"\Z)',  # quoted-string
678         re.IGNORECASE,
679     )
680
681
682 def foo():
683     user_regex = _lazy_re_compile(
684         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
685         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  # quoted-string
686         xyz,
687     )
688
689
690 def foo():
691     user_regex = _lazy_re_compile(
692         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"  # dot-atom
693         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",  # quoted-string
694         xyz,
695     )
696
697
698 class A:
699     class B:
700         def foo():
701             if not hasattr(module, name):
702                 raise ValueError(
703                     "Could not find object %s in %s.\n"
704                     "Please note that you cannot serialize things like inner "
705                     "classes. Please move the object into the main module "
706                     "body to use migrations.\n"
707                     "For more information, see "
708                     "https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
709                     % (name, module_name, get_docs_version())
710                 )
711
712
713 class A:
714     class B:
715         def foo():
716             if not hasattr(module, name):
717                 raise ValueError(
718                     "Could not find object %s in %s.\nPlease note that you cannot"
719                     " serialize things like inner classes. Please move the object into"
720                     " the main module body to use migrations.\nFor more information,"
721                     " see https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values"
722                     % (name, module_name, get_docs_version())
723                 )
724
725
726 x = (
727     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
728     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
729     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
730     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
731 )
732
733
734 class Step(StepBase):
735     def who(self):
736         self.cmd = (
737             "SR AAAA-CORRECT NAME IS {last_name} {first_name}{middle_name}"
738             " {title}/P{passenger_association}".format(
739                 last_name=last_name,
740                 first_name=first_name,
741                 middle_name=middle_name,
742                 title=title,
743                 passenger_association=passenger_association,
744             )
745         )
746
747
748 xxxxxxx_xxxxxx_xxxxxxx = xxx(
749     [
750         xxxxxxxxxxxx(
751             xxxxxx_xxxxxxx=(
752                 '((x.aaaaaaaaa = "xxxxxx.xxxxxxxxxxxxxxxxxxxxx") || (x.xxxxxxxxx ='
753                 ' "xxxxxxxxxxxx")) && '
754                 # xxxxx xxxxxxxxxxxx xxxx xxx (xxxxxxxxxxxxxxxx) xx x xxxxxxxxx xx xxxxxx.
755                 "(x.bbbbbbbbbbbb.xxx != "
756                 '"xxx:xxx:xxx::cccccccccccc:xxxxxxx-xxxx/xxxxxxxxxxx/xxxxxxxxxxxxxxxxx") && '
757             )
758         )
759     ]
760 )
761
762 if __name__ == "__main__":
763     for i in range(4, 8):
764         cmd = (
765             r"for pid in $(ps aux | grep paster | grep -v grep | grep '\-%d' | awk"
766             r" '{print $2}'); do kill $pid; done" % (i)
767         )
768
769
770 def A():
771     def B():
772         def C():
773             def D():
774                 def E():
775                     def F():
776                         def G():
777                             assert (
778                                 c_float(val[0][0] / val[0][1]).value
779                                 == c_float(value[0][0] / value[0][1]).value
780                             ), "%s didn't roundtrip" % tag
781
782
783 class xxxxxxxxxxxxxxxxxxxxx(xxxx.xxxxxxxxxxxxx):
784     def xxxxxxx_xxxxxx(xxxx):
785         assert xxxxxxx_xxxx in [
786             x.xxxxx.xxxxxx.xxxxx.xxxxxx,
787             x.xxxxx.xxxxxx.xxxxx.xxxx,
788         ], (
789             "xxxxxxxxxxx xxxxxxx xxxx (xxxxxx xxxx) %x xxx xxxxx" % xxxxxxx_xxxx
790         )
791
792
793 value.__dict__[
794     key
795 ] = "test"  # set some Thrift field to non-None in the struct aa bb cc dd ee