Lines Matching full:n
23 EXPECT_EQ("a\n//b\nc", messUp("a\n//b\nc"));
24 EXPECT_EQ("a\n#b\nc", messUp("a\n#b\nc"));
25 EXPECT_EQ("a\n#b c d\ne", messUp("a\n#b\\\nc\\\nd\ne"));
45 verifyFormat("\nint i;", " \n\t \v \f int i;");
47 verifyFormat("int i;\nint j;", " int i;\n int j;");
51 verifyFormat("int i;", " \n\t \v \f int i;", Style);
59 verifyFormat("{\n"
60 " {\n"
61 " {\n"
62 " }\n"
63 " }\n"
87 verifyFormat("if (a) {\n"
88 " f();\n"
92 verifyNoChange("if (a) {\n"
93 " f();\n"
96 verifyNoChange("/*\r\n"
97 "\r\n"
103 verifyFormat("class C {\n"
104 " int i;\n"
106 "class C {\n"
107 " int i;\n"
108 "\n"
112 verifyFormat("namespace N {\n"
113 "\n"
114 "int i;\n"
116 "namespace N {\n"
117 "\n"
118 "int i;\n"
121 verifyFormat("/* something */ namespace N {\n"
122 "\n"
123 "int i;\n"
125 "/* something */ namespace N {\n"
126 "\n"
127 "int i;\n"
130 verifyFormat("inline namespace N {\n"
131 "\n"
132 "int i;\n"
134 "inline namespace N {\n"
135 "\n"
136 "int i;\n"
139 verifyFormat("/* something */ inline namespace N {\n"
140 "\n"
141 "int i;\n"
143 "/* something */ inline namespace N {\n"
144 "\n"
145 "int i;\n"
148 verifyFormat("export namespace N {\n"
149 "\n"
150 "int i;\n"
152 "export namespace N {\n"
153 "\n"
154 "int i;\n"
157 verifyFormat("extern /**/ \"C\" /**/ {\n"
158 "\n"
159 "int i;\n"
161 "extern /**/ \"C\" /**/ {\n"
162 "\n"
163 "int i;\n"
171 verifyFormat("namespace N\n"
172 "{\n"
173 "\n"
174 "int i;\n"
176 "namespace N\n"
177 "{\n"
178 "\n"
179 "\n"
180 "int i;\n"
183 verifyFormat("/* something */ namespace N\n"
184 "{\n"
185 "\n"
186 "int i;\n"
188 "/* something */ namespace N {\n"
189 "\n"
190 "\n"
191 "int i;\n"
194 verifyFormat("inline namespace N\n"
195 "{\n"
196 "\n"
197 "int i;\n"
199 "inline namespace N\n"
200 "{\n"
201 "\n"
202 "\n"
203 "int i;\n"
206 verifyFormat("/* something */ inline namespace N\n"
207 "{\n"
208 "\n"
209 "int i;\n"
211 "/* something */ inline namespace N\n"
212 "{\n"
213 "\n"
214 "int i;\n"
217 verifyFormat("export namespace N\n"
218 "{\n"
219 "\n"
220 "int i;\n"
222 "export namespace N\n"
223 "{\n"
224 "\n"
225 "int i;\n"
228 verifyFormat("namespace a\n"
229 "{\n"
230 "namespace b\n"
231 "{\n"
232 "\n"
233 "class AA {};\n"
234 "\n"
235 "} // namespace b\n"
237 "namespace a\n"
238 "{\n"
239 "namespace b\n"
240 "{\n"
241 "\n"
242 "\n"
243 "class AA {};\n"
244 "\n"
245 "\n"
246 "}\n"
249 verifyFormat("namespace A /* comment */\n"
250 "{\n"
251 "class B {}\n"
254 verifyFormat("namespace A\n"
255 "{ /* comment */\n"
256 "class B {}\n"
259 verifyFormat("namespace A\n"
260 "{ /* comment */\n"
261 "\n"
262 "class B {}\n"
263 "\n"
266 "namespace A { /* comment */\n"
267 "\n"
268 "\n"
269 "class B {}\n"
270 "\n"
271 "\n"
274 verifyFormat("namespace A /* comment */\n"
275 "{\n"
276 "\n"
277 "class B {}\n"
278 "\n"
280 "namespace A/* comment */ {\n"
281 "\n"
282 "\n"
283 "class B {}\n"
284 "\n"
285 "\n"
292 verifyFormat("extern \"C\" int f() {\n"
293 " int i = 42;\n"
294 " return i;\n"
296 "extern \"C\" int f() {\n"
297 "\n"
298 " int i = 42;\n"
299 " return i;\n"
304 verifyFormat("void f() {\n"
305 "\n"
306 " if (a) {\n"
307 "\n"
308 " f();\n"
309 " }\n"
311 "void f() {\n"
312 "\n"
313 " if (a) {\n"
314 "\n"
315 " f();\n"
316 "\n"
317 " }\n"
318 "\n"
320 verifyFormat("void f() {\n"
321 " if (a) {\n"
322 " f();\n"
323 " }\n"
325 "void f() {\n"
326 "\n"
327 " if (a) {\n"
328 "\n"
329 " f();\n"
330 "\n"
331 " }\n"
332 "\n"
337 verifyFormat("void f() {\n"
338 " if (a) {\n"
339 " f();\n"
340 "\n"
341 " } else if (b) {\n"
342 " f();\n"
343 " }\n"
345 "void f() {\n"
346 " if (a) {\n"
347 " f();\n"
348 "\n"
349 " } else if (b) {\n"
350 " f();\n"
351 "\n"
352 " }\n"
353 "\n"
359 verifyNoChange("namespace {\n"
360 "int i;\n"
361 "\n"
364 verifyFormat("namespace {\n"
365 "int i;\n"
368 verifyNoChange("namespace {\n"
369 "int i;\n"
370 "\n"
373 verifyFormat("namespace {\n"
374 "int i;\n"
377 verifyNoChange("namespace {\n"
378 "int i;\n"
379 "\n"
381 verifyFormat("namespace {\n"
382 "int i;\n"
383 "\n"
385 "namespace {\n"
386 "int i;\n"
387 "\n"
398 verifyFormat("class Foo\n"
399 "{\n"
400 " Foo() {}\n"
401 "\n"
402 " void funk() {}\n"
404 "class Foo\n"
405 "{\n"
406 " Foo()\n"
407 " {\n"
408 " }\n"
409 "\n"
410 " void funk() {}\n"
441 verifyFormat("if (true)\n f();\ng();");
442 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();");
443 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();");
444 verifyFormat("if constexpr (true)\n"
446 verifyFormat("if CONSTEXPR (true)\n"
448 verifyFormat("if constexpr (a)\n"
449 " if constexpr (b)\n"
450 " if constexpr (c)\n"
451 " g();\n"
453 verifyFormat("if CONSTEXPR (a)\n"
454 " if CONSTEXPR (b)\n"
455 " if CONSTEXPR (c)\n"
456 " g();\n"
458 verifyFormat("if constexpr (a)\n"
459 " if constexpr (b) {\n"
460 " f();\n"
461 " }\n"
463 verifyFormat("if CONSTEXPR (a)\n"
464 " if CONSTEXPR (b) {\n"
465 " f();\n"
466 " }\n"
469 verifyFormat("if consteval {\n}");
470 verifyFormat("if !consteval {\n}");
471 verifyFormat("if not consteval {\n}");
472 verifyFormat("if consteval {\n} else {\n}");
473 verifyFormat("if !consteval {\n} else {\n}");
474 verifyFormat("if consteval {\n"
475 " f();\n"
477 verifyFormat("if !consteval {\n"
478 " f();\n"
480 verifyFormat("if consteval {\n"
481 " f();\n"
482 "} else {\n"
483 " g();\n"
485 verifyFormat("if CONSTEVAL {\n"
486 " f();\n"
488 verifyFormat("if !CONSTEVAL {\n"
489 " f();\n"
492 verifyFormat("if (a)\n"
494 verifyFormat("if (a) {\n"
495 " g()\n"
497 verifyFormat("if (a)\n"
498 " g();\n"
499 "else\n"
501 verifyFormat("if (a) {\n"
502 " g();\n"
503 "} else\n"
505 verifyFormat("if (a)\n"
506 " g();\n"
507 "else {\n"
508 " g();\n"
510 verifyFormat("if (a) {\n"
511 " g();\n"
512 "} else {\n"
513 " g();\n"
515 verifyFormat("if (a)\n"
516 " g();\n"
517 "else if (b)\n"
518 " g();\n"
519 "else\n"
521 verifyFormat("if (a) {\n"
522 " g();\n"
523 "} else if (b)\n"
524 " g();\n"
525 "else\n"
527 verifyFormat("if (a)\n"
528 " g();\n"
529 "else if (b) {\n"
530 " g();\n"
531 "} else\n"
533 verifyFormat("if (a)\n"
534 " g();\n"
535 "else if (b)\n"
536 " g();\n"
537 "else {\n"
538 " g();\n"
540 verifyFormat("if (a)\n"
541 " g();\n"
542 "else if (b) {\n"
543 " g();\n"
544 "} else {\n"
545 " g();\n"
547 verifyFormat("if (a) {\n"
548 " g();\n"
549 "} else if (b) {\n"
550 " g();\n"
551 "} else {\n"
552 " g();\n"
560 verifyFormat("if (a)\n"
561 " // comment\n"
564 verifyFormat("{\n"
565 " if (a)\n"
566 " label:\n"
567 " f();\n"
570 verifyFormat("#define A \\\n"
571 " if (a) \\\n"
572 " label: \\\n"
575 verifyFormat("if (a)\n"
578 verifyFormat("if (a)\n"
582 verifyFormat("if (a) // Can't merge this\n"
585 verifyFormat("if (a) /* still don't merge */\n"
588 verifyFormat("if (a) { // Never merge this\n"
589 " f();\n"
592 verifyFormat("if (a) { /* Never merge this */\n"
593 " f();\n"
596 verifyFormat("MYIF (a)\n"
597 " // comment\n"
600 verifyFormat("{\n"
601 " MYIF (a)\n"
602 " label:\n"
603 " f();\n"
606 verifyFormat("#define A \\\n"
607 " MYIF (a) \\\n"
608 " label: \\\n"
611 verifyFormat("MYIF (a)\n"
614 verifyFormat("MYIF (a)\n"
618 verifyFormat("MYIF (a) // Can't merge this\n"
621 verifyFormat("MYIF (a) /* still don't merge */\n"
624 verifyFormat("MYIF (a) { // Never merge this\n"
625 " f();\n"
628 verifyFormat("MYIF (a) { /* Never merge this */\n"
629 " f();\n"
638 verifyFormat("if (aaaaaaaaa)\n"
642 verifyFormat("FI (aaaaaaaaa)\n"
647 verifyFormat("if (a)\n return;", AllowsMergedIf);
648 verifyFormat("FI (a)\n return;", AllowsMergedIf);
654 verifyFormat("if (a)\n"
655 " // comment\n"
656 " f();\n"
657 "else\n"
658 " // comment\n"
661 verifyFormat("{\n"
662 " if (a)\n"
663 " label:\n"
664 " f();\n"
665 " else\n"
666 " label:\n"
667 " f();\n"
670 verifyFormat("if (a)\n"
671 " ;\n"
672 "else\n"
675 verifyFormat("if (a) {\n"
676 "} else {\n"
679 verifyFormat("if (a) return;\n"
680 "else if (b) return;\n"
683 verifyFormat("if (a) {\n"
686 verifyFormat("if (a) {\n"
687 "} else if (b) return;\n"
690 verifyFormat("if (a) return;\n"
691 "else if (b) {\n"
694 verifyFormat("if (a)\n"
695 " if (b) return;\n"
698 verifyFormat("if constexpr (a)\n"
699 " if constexpr (b) return;\n"
700 " else if constexpr (c) return;\n"
703 verifyFormat("MYIF (a)\n"
704 " // comment\n"
705 " f();\n"
706 "else\n"
707 " // comment\n"
710 verifyFormat("{\n"
711 " MYIF (a)\n"
712 " label:\n"
713 " f();\n"
714 " else\n"
715 " label:\n"
716 " f();\n"
719 verifyFormat("MYIF (a)\n"
720 " ;\n"
721 "else\n"
724 verifyFormat("MYIF (a) {\n"
725 "} else {\n"
728 verifyFormat("MYIF (a) return;\n"
729 "else MYIF (b) return;\n"
732 verifyFormat("MYIF (a) {\n"
735 verifyFormat("MYIF (a) {\n"
736 "} else MYIF (b) return;\n"
739 verifyFormat("MYIF (a) return;\n"
740 "else MYIF (b) {\n"
743 verifyFormat("MYIF (a)\n"
744 " MYIF (b) return;\n"
747 verifyFormat("MYIF constexpr (a)\n"
748 " MYIF constexpr (b) return;\n"
749 " else MYIF constexpr (c) return;\n"
760 verifyFormat("if (a)\n"
761 " f();\n"
762 "else {\n"
763 " g();\n"
766 verifyFormat("if (a)\n"
767 " f();\n"
768 "else\n"
773 verifyFormat("if (a) {\n"
774 " g()\n"
777 verifyFormat("if (a)\n"
778 " g();\n"
779 "else\n"
782 verifyFormat("if (a) {\n"
783 " g();\n"
784 "} else\n"
787 verifyFormat("if (a)\n"
788 " g();\n"
789 "else {\n"
790 " g();\n"
793 verifyFormat("if (a) {\n"
794 " g();\n"
795 "} else {\n"
796 " g();\n"
799 verifyFormat("if (a)\n"
800 " g();\n"
801 "else if (b)\n"
802 " g();\n"
803 "else\n"
806 verifyFormat("if (a) {\n"
807 " g();\n"
808 "} else if (b)\n"
809 " g();\n"
810 "else\n"
813 verifyFormat("if (a)\n"
814 " g();\n"
815 "else if (b) {\n"
816 " g();\n"
817 "} else\n"
820 verifyFormat("if (a)\n"
821 " g();\n"
822 "else if (b)\n"
823 " g();\n"
824 "else {\n"
825 " g();\n"
828 verifyFormat("if (a)\n"
829 " g();\n"
830 "else if (b) {\n"
831 " g();\n"
832 "} else {\n"
833 " g();\n"
836 verifyFormat("if (a) {\n"
837 " g();\n"
838 "} else if (b) {\n"
839 " g();\n"
840 "} else {\n"
841 " g();\n"
844 verifyFormat("MYIF (a)\n"
845 " f();\n"
846 "else {\n"
847 " g();\n"
850 verifyFormat("MYIF (a)\n"
851 " f();\n"
852 "else\n"
857 verifyFormat("MYIF (a) {\n"
858 " g()\n"
861 verifyFormat("MYIF (a)\n"
862 " g();\n"
863 "else\n"
866 verifyFormat("MYIF (a) {\n"
867 " g();\n"
868 "} else\n"
871 verifyFormat("MYIF (a)\n"
872 " g();\n"
873 "else {\n"
874 " g();\n"
877 verifyFormat("MYIF (a) {\n"
878 " g();\n"
879 "} else {\n"
880 " g();\n"
883 verifyFormat("MYIF (a)\n"
884 " g();\n"
885 "else MYIF (b)\n"
886 " g();\n"
887 "else\n"
890 verifyFormat("MYIF (a)\n"
891 " g();\n"
892 "else if (b)\n"
893 " g();\n"
894 "else\n"
897 verifyFormat("MYIF (a) {\n"
898 " g();\n"
899 "} else MYIF (b)\n"
900 " g();\n"
901 "else\n"
904 verifyFormat("MYIF (a) {\n"
905 " g();\n"
906 "} else if (b)\n"
907 " g();\n"
908 "else\n"
911 verifyFormat("MYIF (a)\n"
912 " g();\n"
913 "else MYIF (b) {\n"
914 " g();\n"
915 "} else\n"
918 verifyFormat("MYIF (a)\n"
919 " g();\n"
920 "else if (b) {\n"
921 " g();\n"
922 "} else\n"
925 verifyFormat("MYIF (a)\n"
926 " g();\n"
927 "else MYIF (b)\n"
928 " g();\n"
929 "else {\n"
930 " g();\n"
933 verifyFormat("MYIF (a)\n"
934 " g();\n"
935 "else if (b)\n"
936 " g();\n"
937 "else {\n"
938 " g();\n"
941 verifyFormat("MYIF (a)\n"
942 " g();\n"
943 "else MYIF (b) {\n"
944 " g();\n"
945 "} else {\n"
946 " g();\n"
949 verifyFormat("MYIF (a)\n"
950 " g();\n"
951 "else if (b) {\n"
952 " g();\n"
953 "} else {\n"
954 " g();\n"
957 verifyFormat("MYIF (a) {\n"
958 " g();\n"
959 "} else MYIF (b) {\n"
960 " g();\n"
961 "} else {\n"
962 " g();\n"
965 verifyFormat("MYIF (a) {\n"
966 " g();\n"
967 "} else if (b) {\n"
968 " g();\n"
969 "} else {\n"
970 " g();\n"
977 verifyFormat("if (a) f();\n"
978 "else {\n"
979 " g();\n"
982 verifyFormat("if (a) f();\n"
983 "else {\n"
984 " if (a) f();\n"
985 " else {\n"
986 " g();\n"
987 " }\n"
988 " g();\n"
993 verifyFormat("if (a) {\n"
994 " g()\n"
997 verifyFormat("if (a) g();\n"
998 "else\n"
1001 verifyFormat("if (a) {\n"
1002 " g();\n"
1003 "} else\n"
1006 verifyFormat("if (a) g();\n"
1007 "else {\n"
1008 " g();\n"
1011 verifyFormat("if (a) {\n"
1012 " g();\n"
1013 "} else {\n"
1014 " g();\n"
1017 verifyFormat("if (a) g();\n"
1018 "else if (b)\n"
1019 " g();\n"
1020 "else\n"
1023 verifyFormat("if (a) {\n"
1024 " g();\n"
1025 "} else if (b)\n"
1026 " g();\n"
1027 "else\n"
1030 verifyFormat("if (a) g();\n"
1031 "else if (b) {\n"
1032 " g();\n"
1033 "} else\n"
1036 verifyFormat("if (a) g();\n"
1037 "else if (b)\n"
1038 " g();\n"
1039 "else {\n"
1040 " g();\n"
1043 verifyFormat("if (a) g();\n"
1044 "else if (b) {\n"
1045 " g();\n"
1046 "} else {\n"
1047 " g();\n"
1050 verifyFormat("if (a) {\n"
1051 " g();\n"
1052 "} else if (b) {\n"
1053 " g();\n"
1054 "} else {\n"
1055 " g();\n"
1058 verifyFormat("MYIF (a) f();\n"
1059 "else {\n"
1060 " g();\n"
1063 verifyFormat("MYIF (a) f();\n"
1064 "else {\n"
1065 " if (a) f();\n"
1066 " else {\n"
1067 " g();\n"
1068 " }\n"
1069 " g();\n"
1074 verifyFormat("MYIF (a) {\n"
1075 " g()\n"
1078 verifyFormat("MYIF (a) g();\n"
1079 "else\n"
1082 verifyFormat("MYIF (a) {\n"
1083 " g();\n"
1084 "} else\n"
1087 verifyFormat("MYIF (a) g();\n"
1088 "else {\n"
1089 " g();\n"
1092 verifyFormat("MYIF (a) {\n"
1093 " g();\n"
1094 "} else {\n"
1095 " g();\n"
1098 verifyFormat("MYIF (a) g();\n"
1099 "else MYIF (b)\n"
1100 " g();\n"
1101 "else\n"
1104 verifyFormat("MYIF (a) g();\n"
1105 "else if (b)\n"
1106 " g();\n"
1107 "else\n"
1110 verifyFormat("MYIF (a) {\n"
1111 " g();\n"
1112 "} else MYIF (b)\n"
1113 " g();\n"
1114 "else\n"
1117 verifyFormat("MYIF (a) {\n"
1118 " g();\n"
1119 "} else if (b)\n"
1120 " g();\n"
1121 "else\n"
1124 verifyFormat("MYIF (a) g();\n"
1125 "else MYIF (b) {\n"
1126 " g();\n"
1127 "} else\n"
1130 verifyFormat("MYIF (a) g();\n"
1131 "else if (b) {\n"
1132 " g();\n"
1133 "} else\n"
1136 verifyFormat("MYIF (a) g();\n"
1137 "else MYIF (b)\n"
1138 " g();\n"
1139 "else {\n"
1140 " g();\n"
1143 verifyFormat("MYIF (a) g();\n"
1144 "else if (b)\n"
1145 " g();\n"
1146 "else {\n"
1147 " g();\n"
1150 verifyFormat("MYIF (a) g();\n"
1151 "else MYIF (b) {\n"
1152 " g();\n"
1153 "} else {\n"
1154 " g();\n"
1157 verifyFormat("MYIF (a) g();\n"
1158 "else if (b) {\n"
1159 " g();\n"
1160 "} else {\n"
1161 " g();\n"
1164 verifyFormat("MYIF (a) {\n"
1165 " g();\n"
1166 "} else MYIF (b) {\n"
1167 " g();\n"
1168 "} else {\n"
1169 " g();\n"
1172 verifyFormat("MYIF (a) {\n"
1173 " g();\n"
1174 "} else if (b) {\n"
1175 " g();\n"
1176 "} else {\n"
1177 " g();\n"
1184 verifyFormat("if (a) f();\n"
1185 "else {\n"
1186 " g();\n"
1189 verifyFormat("if (a) f();\n"
1190 "else {\n"
1191 " if (a) f();\n"
1192 " else {\n"
1193 " g();\n"
1194 " }\n"
1195 " g();\n"
1200 verifyFormat("if (a) {\n"
1201 " g()\n"
1204 verifyFormat("if (a) g();\n"
1207 verifyFormat("if (a) {\n"
1208 " g();\n"
1211 verifyFormat("if (a) g();\n"
1212 "else {\n"
1213 " g();\n"
1216 verifyFormat("if (a) {\n"
1217 " g();\n"
1218 "} else {\n"
1219 " g();\n"
1222 verifyFormat("if (a) g();\n"
1223 "else if (b) g();\n"
1226 verifyFormat("if (a) {\n"
1227 " g();\n"
1228 "} else if (b) g();\n"
1231 verifyFormat("if (a) g();\n"
1232 "else if (b) {\n"
1233 " g();\n"
1236 verifyFormat("if (a) g();\n"
1237 "else if (b) g();\n"
1238 "else {\n"
1239 " g();\n"
1242 verifyFormat("if (a) g();\n"
1243 "else if (b) {\n"
1244 " g();\n"
1245 "} else {\n"
1246 " g();\n"
1249 verifyFormat("if (a) {\n"
1250 " g();\n"
1251 "} else if (b) {\n"
1252 " g();\n"
1253 "} else {\n"
1254 " g();\n"
1257 verifyFormat("MYIF (a) f();\n"
1258 "else {\n"
1259 " g();\n"
1262 verifyFormat("MYIF (a) f();\n"
1263 "else {\n"
1264 " if (a) f();\n"
1265 " else {\n"
1266 " g();\n"
1267 " }\n"
1268 " g();\n"
1273 verifyFormat("MYIF (a) {\n"
1274 " g()\n"
1277 verifyFormat("MYIF (a) g();\n"
1280 verifyFormat("MYIF (a) {\n"
1281 " g();\n"
1284 verifyFormat("MYIF (a) g();\n"
1285 "else {\n"
1286 " g();\n"
1289 verifyFormat("MYIF (a) {\n"
1290 " g();\n"
1291 "} else {\n"
1292 " g();\n"
1295 verifyFormat("MYIF (a) g();\n"
1296 "else MYIF (b) g();\n"
1299 verifyFormat("MYIF (a) g();\n"
1300 "else if (b) g();\n"
1303 verifyFormat("MYIF (a) {\n"
1304 " g();\n"
1305 "} else MYIF (b) g();\n"
1308 verifyFormat("MYIF (a) {\n"
1309 " g();\n"
1310 "} else if (b) g();\n"
1313 verifyFormat("MYIF (a) g();\n"
1314 "else MYIF (b) {\n"
1315 " g();\n"
1318 verifyFormat("MYIF (a) g();\n"
1319 "else if (b) {\n"
1320 " g();\n"
1323 verifyFormat("MYIF (a) g();\n"
1324 "else MYIF (b) g();\n"
1325 "else {\n"
1326 " g();\n"
1329 verifyFormat("MYIF (a) g();\n"
1330 "else if (b) g();\n"
1331 "else {\n"
1332 " g();\n"
1335 verifyFormat("MYIF (a) g();\n"
1336 "else MYIF (b) {\n"
1337 " g();\n"
1338 "} else {\n"
1339 " g();\n"
1342 verifyFormat("MYIF (a) g();\n"
1343 "else if (b) {\n"
1344 " g();\n"
1345 "} else {\n"
1346 " g();\n"
1349 verifyFormat("MYIF (a) {\n"
1350 " g();\n"
1351 "} else MYIF (b) {\n"
1352 " g();\n"
1353 "} else {\n"
1354 " g();\n"
1357 verifyFormat("MYIF (a) {\n"
1358 " g();\n"
1359 "} else if (b) {\n"
1360 " g();\n"
1361 "} else {\n"
1362 " g();\n"
1368 verifyFormat("while (true)\n"
1370 verifyFormat("for (;;)\n"
1382 verifyFormat("for (;;)\n"
1385 verifyFormat("for (;;)\n"
1388 verifyFormat("while (true)\n"
1391 verifyFormat("BOOST_FOREACH (int &v, vec)\n"
1394 verifyFormat("for (;;)\n"
1397 verifyFormat("for (;;) // Can't merge this\n"
1400 verifyFormat("for (;;) /* still don't merge */\n"
1403 verifyFormat("do a++;\n"
1406 verifyFormat("do /* Don't merge */\n"
1407 " a++;\n"
1410 verifyFormat("do // Don't merge\n"
1411 " a++;\n"
1414 verifyFormat("do\n"
1415 " // Don't merge\n"
1416 " a++;\n"
1421 verifyFormat("{\n"
1422 " do\n"
1423 " label:\n"
1424 " a++;\n"
1425 " while (true);\n"
1430 verifyFormat("while (1) //\n"
1433 verifyFormat("for (;;) /**/\n"
1436 verifyFormat("while (true) /**/\n"
1448 verifyFormat("for (;;) {\n"
1449 " f();\n"
1451 verifyFormat("/*comment*/ for (;;) {\n"
1452 " f();\n"
1454 verifyFormat("BOOST_FOREACH (int v, vec) {\n"
1455 " f();\n"
1457 verifyFormat("/*comment*/ BOOST_FOREACH (int v, vec) {\n"
1458 " f();\n"
1460 verifyFormat("while (true) {\n"
1461 " f();\n"
1463 verifyFormat("/*comment*/ while (true) {\n"
1464 " f();\n"
1466 verifyFormat("if (true) {\n"
1467 " f();\n"
1469 verifyFormat("/*comment*/ if (true) {\n"
1470 " f();\n"
1479 verifyFormat("if (i > 0) {\n"
1480 " return i;\n"
1521 verifyFormat("if (true) {\n"
1522 " ffffffffffffffffffffffff();\n"
1525 verifyFormat("if (true) {\n"
1526 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
1529 verifyFormat("if (true) { //\n"
1530 " f();\n"
1533 verifyFormat("if (true) {\n"
1534 " f();\n"
1535 " f();\n"
1538 verifyFormat("if (true) {\n"
1539 " f();\n"
1540 "} else {\n"
1541 " f();\n"
1546 verifyFormat("MYIF (true) {\n"
1547 " ffffffffffffffffffffffff();\n"
1550 verifyFormat("MYIF (true) {\n"
1551 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
1554 verifyFormat("MYIF (true) { //\n"
1555 " f();\n"
1558 verifyFormat("MYIF (true) {\n"
1559 " f();\n"
1560 " f();\n"
1563 verifyFormat("MYIF (true) {\n"
1564 " f();\n"
1565 "} else {\n"
1566 " f();\n"
1570 verifyFormat("struct A2 {\n"
1571 " int X;\n"
1574 verifyFormat("typedef struct A2 {\n"
1575 " int X;\n"
1578 verifyFormat("template <int> struct A2 {\n"
1579 " struct B {};\n"
1586 verifyFormat("if (true) {\n"
1587 " f();\n"
1590 verifyFormat("if (true) {\n"
1591 " f();\n"
1592 "} else {\n"
1593 " f();\n"
1597 verifyFormat("MYIF (true) {\n"
1598 " f();\n"
1601 verifyFormat("MYIF (true) {\n"
1602 " f();\n"
1603 "} else {\n"
1604 " f();\n"
1610 verifyFormat("while (true) {\n"
1611 " f();\n"
1615 verifyFormat("for (;;) {\n"
1616 " f();\n"
1620 verifyFormat("BOOST_FOREACH (int v, vec) {\n"
1621 " f();\n"
1649 verifyFormat("if (true)\n"
1650 "{\n"
1651 " ffffffffffffffffffffffff();\n"
1654 verifyFormat("if (true)\n"
1655 "{\n"
1656 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
1659 verifyFormat("if (true)\n"
1660 "{ //\n"
1661 " f();\n"
1664 verifyFormat("if (true)\n"
1665 "{\n"
1666 " f();\n"
1667 " f();\n"
1670 verifyFormat("if (true)\n"
1671 "{\n"
1672 " f();\n"
1673 "} else\n"
1674 "{\n"
1675 " f();\n"
1680 verifyFormat("MYIF (true)\n"
1681 "{\n"
1682 " ffffffffffffffffffffffff();\n"
1685 verifyFormat("MYIF (true)\n"
1686 "{\n"
1687 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
1690 verifyFormat("MYIF (true)\n"
1691 "{ //\n"
1692 " f();\n"
1695 verifyFormat("MYIF (true)\n"
1696 "{\n"
1697 " f();\n"
1698 " f();\n"
1701 verifyFormat("MYIF (true)\n"
1702 "{\n"
1703 " f();\n"
1704 "} else\n"
1705 "{\n"
1706 " f();\n"
1713 verifyFormat("if (true)\n"
1714 "{\n"
1715 " f();\n"
1718 verifyFormat("if (true)\n"
1719 "{\n"
1720 " f();\n"
1721 "} else\n"
1722 "{\n"
1723 " f();\n"
1727 verifyFormat("MYIF (true)\n"
1728 "{\n"
1729 " f();\n"
1732 verifyFormat("MYIF (true)\n"
1733 "{\n"
1734 " f();\n"
1735 "} else\n"
1736 "{\n"
1737 " f();\n"
1743 verifyFormat("while (true)\n"
1744 "{\n"
1745 " f();\n"
1749 verifyFormat("for (;;)\n"
1750 "{\n"
1751 " f();\n"
1755 verifyFormat("BOOST_FOREACH (int v, vec)\n"
1756 "{\n"
1757 " f();\n"
1765 verifyFormat("while (i > 0)\n"
1766 "{\n"
1767 " --i;\n"
1771 verifyFormat("if (a)\n"
1772 "{\n"
1773 " ++b;\n"
1777 verifyFormat("if (a)\n"
1778 "{\n"
1779 " b = 1;\n"
1780 "} else\n"
1781 "{\n"
1782 " b = 0;\n"
1786 verifyFormat("if (a)\n"
1787 "{\n"
1788 " b = 1;\n"
1789 "} else if (c)\n"
1790 "{\n"
1791 " b = 2;\n"
1792 "} else\n"
1793 "{\n"
1794 " b = 0;\n"
1800 verifyFormat("if (a)\n"
1801 "{\n"
1802 " b = 1;\n"
1803 "}\n"
1804 "else\n"
1805 "{\n"
1806 " b = 0;\n"
1810 verifyFormat("if (a)\n"
1811 "{\n"
1812 " b = 1;\n"
1813 "}\n"
1814 "else if (c)\n"
1815 "{\n"
1816 " b = 2;\n"
1817 "}\n"
1818 "else\n"
1819 "{\n"
1820 " b = 0;\n"
1830 verifyNoChange("/* comment */ #define A (parentheses)\n"
1832 verifyFormat("/* comment */ #define A (parentheses)\n"
1833 "#\n");
1834 verifyFormat("/* comment */ #define A (parentheses)\n"
1849 "\\\n"
1859 " \\\n"
1860 " N "
1861 " \\\n"
1862 " {\n"
1865 // verifyFormat("#define AAA N { //", Style);
1879 verifyFormat("#define Foo(Bar) {#Bar}", "#define Foo(Bar) \\\n"
1880 " { \\\n"
1881 " #Bar \\\n"
1883 verifyFormat("#define Foo(Bar) {#Bar}", "#define Foo(Bar) \\\n"
1892 verifyFormat("#define A \\\n"
1893 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n"
1894 " { \\\n"
1895 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
1896 " }\n"
1898 "#define A \\\n"
1899 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
1900 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
1901 " }\n"
1907 verifyFormat("if (true)\n"
1908 " if (true)\n"
1909 " if (true)\n"
1910 " f();\n"
1911 " else\n"
1912 " g();\n"
1913 " else\n"
1914 " h();\n"
1915 "else\n"
1917 verifyFormat("if (true)\n"
1918 " if (true)\n"
1919 " if (true) {\n"
1920 " if (true)\n"
1921 " f();\n"
1922 " } else {\n"
1923 " g();\n"
1924 " }\n"
1925 " else\n"
1926 " h();\n"
1927 "else {\n"
1928 " i();\n"
1930 verifyFormat("if (true)\n"
1931 " if constexpr (true)\n"
1932 " if (true) {\n"
1933 " if constexpr (true)\n"
1934 " f();\n"
1935 " } else {\n"
1936 " g();\n"
1937 " }\n"
1938 " else\n"
1939 " h();\n"
1940 "else {\n"
1941 " i();\n"
1943 verifyFormat("if (true)\n"
1944 " if CONSTEXPR (true)\n"
1945 " if (true) {\n"
1946 " if CONSTEXPR (true)\n"
1947 " f();\n"
1948 " } else {\n"
1949 " g();\n"
1950 " }\n"
1951 " else\n"
1952 " h();\n"
1953 "else {\n"
1954 " i();\n"
1956 verifyFormat("void f() {\n"
1957 " if (a) {\n"
1958 " } else {\n"
1959 " }\n"
1964 verifyFormat("if (a) {\n} else if (b) {\n}");
1965 verifyFormat("if (a)\n"
1966 " f();\n"
1967 "else if (b)\n"
1968 " g();\n"
1969 "else\n"
1971 verifyFormat("if (a)\n"
1972 " f();\n"
1973 "else // comment\n"
1974 " if (b) {\n"
1975 " g();\n"
1976 " h();\n"
1978 verifyFormat("if constexpr (a)\n"
1979 " f();\n"
1980 "else if constexpr (b)\n"
1981 " g();\n"
1982 "else\n"
1984 verifyFormat("if CONSTEXPR (a)\n"
1985 " f();\n"
1986 "else if CONSTEXPR (b)\n"
1987 " g();\n"
1988 "else\n"
1990 verifyFormat("if (a) {\n"
1991 " f();\n"
1992 "}\n"
1993 "// or else ..\n"
1994 "else {\n"
1995 " g()\n"
1998 verifyFormat("if (a) {\n"
1999 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2000 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
2002 verifyFormat("if (a) {\n"
2003 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2004 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
2006 verifyFormat("if (a) {\n"
2007 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2008 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
2010 verifyFormat("if (a) {\n"
2011 "} else if (\n"
2012 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
2015 verifyFormat("if (a) {\n"
2016 "} else if constexpr (\n"
2017 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
2020 verifyFormat("if (a) {\n"
2021 "} else if CONSTEXPR (\n"
2022 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
2060 "function<int(int &)> res1 = [](int &a) { return 0000000000000; },\n"
2066 verifyFormat("Const unsigned int *c;\n"
2067 "const unsigned int *d;\n"
2068 "Const unsigned int &e;\n"
2069 "const unsigned int &f;\n"
2070 "int *f1(int *a, int &b, int &&c);\n"
2071 "double *(*f2)(int *a, double &&b);\n"
2072 "const unsigned &&g;\n"
2076 verifyFormat("Const unsigned int *c;\n"
2077 "const unsigned int *d;\n"
2078 "Const unsigned int &e;\n"
2079 "const unsigned int &f;\n"
2080 "int *f1(int *a, int &b, int &&c);\n"
2081 "double *(*f2)(int *a, double &&b);\n"
2082 "const unsigned &&g;\n"
2117 "function<int(int&)> res1 = [](int& a) { return 0000000000000; },\n"
2124 verifyFormat("Const unsigned int* c;\n"
2125 "const unsigned int* d;\n"
2126 "Const unsigned int& e;\n"
2127 "const unsigned int& f;\n"
2128 "int* f1(int* a, int& b, int&& c);\n"
2129 "double* (*f2)(int* a, double&& b);\n"
2130 "const unsigned&& g;\n"
2134 verifyFormat("Const unsigned int* c;\n"
2135 "const unsigned int* d;\n"
2136 "Const unsigned int& e;\n"
2137 "const unsigned int& f;\n"
2138 "int* f1(int* a, int& b, int&& c);\n"
2139 "double* (*f2)(int* a, double&& b);\n"
2140 "const unsigned&& g;\n"
2162 verifyFormat("Const unsigned int *c;\n"
2163 "const unsigned int *d;\n"
2164 "Const unsigned int& e;\n"
2165 "const unsigned int& f;\n"
2166 "int *f1(int *a, int& b, int&& c);\n"
2167 "double *(*f2)(int *a, double&& b);\n"
2168 "const unsigned&& g;\n"
2172 verifyFormat("Const unsigned int *c;\n"
2173 "const unsigned int *d;\n"
2174 "Const unsigned int& e;\n"
2175 "const unsigned int& f;\n"
2176 "int *f1(int *a, int& b, int&& c);\n"
2177 "double *(*f2)(int *a, double&& b);\n"
2178 "const unsigned&& g;\n"
2209 "function<int(int &)> res1 = [](int & a) { return 0000000000000; },\n"
2215 verifyFormat("Const unsigned int* c;\n"
2216 "const unsigned int* d;\n"
2217 "Const unsigned int & e;\n"
2218 "const unsigned int & f;\n"
2219 "int* f1(int* a, int & b, int && c);\n"
2220 "double* (*f2)(int* a, double && b);\n"
2221 "const unsigned && g;\n"
2225 verifyFormat("Const unsigned int* c;\n"
2226 "const unsigned int* d;\n"
2227 "Const unsigned int & e;\n"
2228 "const unsigned int & f;\n"
2229 "int* f1(int* a, int & b, int && c);\n"
2230 "double* (*f2)(int* a, double && b);\n"
2231 "const unsigned && g;\n"
2253 verifyFormat("Const unsigned int * c;\n"
2254 "const unsigned int * d;\n"
2255 "Const unsigned int &e;\n"
2256 "const unsigned int &f;\n"
2257 "int * f1(int * a, int &b, int &&c);\n"
2258 "double * (*f2)(int * a, double &&b);\n"
2259 "const unsigned &&g;\n"
2263 verifyFormat("Const unsigned int * c;\n"
2264 "const unsigned int * d;\n"
2265 "Const unsigned int &e;\n"
2266 "const unsigned int &f;\n"
2267 "int * f1(int * a, int &b, int &&c);\n"
2268 "double * (*f2)(int * a, double &&b);\n"
2269 "const unsigned &&g;\n"
2280 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
2281 " ++VeryVeryLongLoopVariable)\n"
2283 verifyFormat("for (;;)\n"
2285 verifyFormat("for (;;) {\n}");
2286 verifyFormat("for (;;) {\n"
2287 " f();\n"
2289 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
2292 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
2293 " E = UnwrappedLines.end();\n"
2294 " I != E; ++I) {\n}");
2297 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
2298 " ++IIIII) {\n}");
2299 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
2300 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
2301 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
2302 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
2303 " I = FD->getDeclsInPrototypeScope().begin(),\n"
2304 " E = FD->getDeclsInPrototypeScope().end();\n"
2305 " I != E; ++I) {\n}");
2306 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
2307 " I = Container.begin(),\n"
2308 " E = Container.end();\n"
2309 " I != E; ++I) {\n}",
2313 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
2314 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
2315 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2316 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
2317 " ++aaaaaaaaaaa) {\n}");
2318 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2319 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
2320 " ++i) {\n}");
2321 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
2322 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
2324 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
2325 " aaaaaaaaaa);\n"
2326 " iter; ++iter) {\n"
2328 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2329 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
2330 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
2334 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
2335 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
2336 verifyFormat("Foo *x;\nfor (x in y) {\n}");
2338 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
2342 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
2343 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
2344 " aaaaaaaaaaaaaaaa,\n"
2345 " aaaaaaaaaaaaaaaa,\n"
2346 " aaaaaaaaaaaaaaaa);\n"
2347 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
2351 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
2352 " E = UnwrappedLines.end();\n"
2353 " I != E;\n"
2354 " ++I) {\n}",
2359 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
2363 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
2364 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
2365 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
2366 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
2367 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
2368 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
2369 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
2370 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
2377 verifyFormat("void f() {\n"
2378 " for (;;) {\n"
2379 " }\n"
2380 " foreach (Item *item, itemlist) {\n"
2381 " }\n"
2382 " Q_FOREACH (Item *item, itemlist) {\n"
2383 " }\n"
2384 " BOOST_FOREACH (Item *item, itemlist) {\n"
2385 " }\n"
2386 " UNKNOWN_FOREACH(Item * item, itemlist) {}\n"
2389 verifyFormat("void f() {\n"
2390 " for (;;)\n"
2391 " int j = 1;\n"
2392 " Q_FOREACH (int v, vec)\n"
2393 " v *= 2;\n"
2394 " for (;;) {\n"
2395 " int j = 1;\n"
2396 " }\n"
2397 " Q_FOREACH (int v, vec) {\n"
2398 " v *= 2;\n"
2399 " }\n"
2406 verifyFormat("void f() {\n"
2407 " for (;;)\n"
2408 " int j = 1;\n"
2409 " Q_FOREACH (int &v, vec)\n"
2410 " v *= 2;\n"
2411 " for (;;) {\n"
2412 " int j = 1;\n"
2413 " }\n"
2414 " Q_FOREACH (int &v, vec) {\n"
2415 " int j = 1;\n"
2416 " }\n"
2423 verifyFormat("void f() {\n"
2424 " for (;;) int j = 1;\n"
2425 " Q_FOREACH (int &v, vec) int j = 1;\n"
2426 " for (;;) {\n"
2427 " int j = 1;\n"
2428 " }\n"
2429 " Q_FOREACH (int &v, vec) {\n"
2430 " int j = 1;\n"
2431 " }\n"
2438 verifyFormat("void f() {\n"
2439 " for (;;) int j = 1;\n"
2440 " Q_FOREACH (int &v, vec) int j = 1;\n"
2441 " for (;;) { int j = 1; }\n"
2442 " Q_FOREACH (int &v, vec) { int j = 1; }\n"
2448 verifyFormat("void f() {\n"
2449 " for (;;) {\n"
2450 " }\n"
2451 " foreach(Item *item, itemlist) {\n"
2452 " }\n"
2453 " Q_FOREACH(Item *item, itemlist) {\n"
2454 " }\n"
2455 " BOOST_FOREACH(Item *item, itemlist) {\n"
2456 " }\n"
2457 " UNKNOWN_FOREACH(Item * item, itemlist) {}\n"
2462 verifyFormat("#define foreach(x, y)\n"
2463 "#define Q_FOREACH(x, y)\n"
2464 "#define BOOST_FOREACH(x, y)\n"
2468 verifyFormat("#define foreach (x, y)\n"
2469 "#define Q_FOREACH (x, y)\n"
2470 "#define BOOST_FOREACH (x, y)\n"
2478 verifyFormat("while (true) {\n}");
2479 verifyFormat("while (true)\n"
2481 verifyFormat("while () {\n}");
2482 verifyFormat("while () {\n"
2483 " f();\n"
2488 verifyFormat("do {\n"
2489 " do_something();\n"
2491 verifyFormat("do\n"
2492 " do_something();\n"
2497 verifyFormat("switch (x) {\n"
2498 "case 1:\n"
2499 " f();\n"
2500 " break;\n"
2501 "case kFoo:\n"
2502 "case ns::kBar:\n"
2503 "case kBaz:\n"
2504 " break;\n"
2505 "default:\n"
2506 " g();\n"
2507 " break;\n"
2509 verifyFormat("switch (x) {\n"
2510 "case 1: {\n"
2511 " f();\n"
2512 " break;\n"
2513 "}\n"
2514 "case 2: {\n"
2515 " break;\n"
2516 "}\n"
2518 verifyFormat("switch (x) {\n"
2519 "case 1: {\n"
2520 " f();\n"
2521 " {\n"
2522 " g();\n"
2523 " h();\n"
2524 " }\n"
2525 " break;\n"
2526 "}\n"
2528 verifyFormat("switch (x) {\n"
2529 "case 1: {\n"
2530 " f();\n"
2531 " if (foo) {\n"
2532 " g();\n"
2533 " h();\n"
2534 " }\n"
2535 " break;\n"
2536 "}\n"
2538 verifyFormat("switch (x) {\n"
2539 "case 1: {\n"
2540 " f();\n"
2541 " g();\n"
2542 "} break;\n"
2544 verifyFormat("switch (test)\n"
2546 verifyFormat("switch (x) {\n"
2547 "default: {\n"
2548 " // Do nothing.\n"
2549 "}\n"
2551 verifyFormat("switch (x) {\n"
2552 "// comment\n"
2553 "// if 1, do f()\n"
2554 "case 1:\n"
2555 " f();\n"
2557 verifyFormat("switch (x) {\n"
2558 "case 1:\n"
2559 " // Do amazing stuff\n"
2560 " {\n"
2561 " f();\n"
2562 " g();\n"
2563 " }\n"
2564 " break;\n"
2566 verifyFormat("#define A \\\n"
2567 " switch (x) { \\\n"
2568 " case a: \\\n"
2569 " foo = b; \\\n"
2572 verifyFormat("#define OPERATION_CASE(name) \\\n"
2573 " case OP_name: \\\n"
2576 verifyFormat("switch (x) {\n"
2577 "case 1:;\n"
2578 "default:;\n"
2579 " int i;\n"
2582 verifyGoogleFormat("switch (x) {\n"
2583 " case 1:\n"
2584 " f();\n"
2585 " break;\n"
2586 " case kFoo:\n"
2587 " case ns::kBar:\n"
2588 " case kBaz:\n"
2589 " break;\n"
2590 " default:\n"
2591 " g();\n"
2592 " break;\n"
2594 verifyGoogleFormat("switch (x) {\n"
2595 " case 1: {\n"
2596 " f();\n"
2597 " break;\n"
2598 " }\n"
2600 verifyGoogleFormat("switch (test)\n"
2603 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
2604 " case OP_name: \\\n"
2606 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
2607 " // Get the correction operation class.\n"
2608 " switch (OpCode) {\n"
2609 " CASE(Add);\n"
2610 " CASE(Subtract);\n"
2611 " default:\n"
2612 " return operations::Unknown;\n"
2613 " }\n"
2614 "#undef OPERATION_CASE\n"
2616 verifyFormat("DEBUG({\n"
2617 " switch (x) {\n"
2618 " case A:\n"
2619 " f();\n"
2620 " break;\n"
2621 " // fallthrough\n"
2622 " case B:\n"
2623 " g();\n"
2624 " break;\n"
2625 " }\n"
2627 verifyNoChange("DEBUG({\n"
2628 " switch (x) {\n"
2629 " case A:\n"
2630 " f();\n"
2631 " break;\n"
2632 " // On B:\n"
2633 " case B:\n"
2634 " g();\n"
2635 " break;\n"
2636 " }\n"
2638 verifyFormat("switch (n) {\n"
2639 "case 0: {\n"
2640 " return false;\n"
2641 "}\n"
2642 "default: {\n"
2643 " return true;\n"
2644 "}\n"
2646 "switch (n)\n"
2647 "{\n"
2648 "case 0: {\n"
2649 " return false;\n"
2650 "}\n"
2651 "default: {\n"
2652 " return true;\n"
2653 "}\n"
2655 verifyFormat("switch (a) {\n"
2656 "case (b):\n"
2657 " return;\n"
2660 verifyFormat("switch (a) {\n"
2661 "case some_namespace::\n"
2662 " some_constant:\n"
2663 " return;\n"
2667 verifyFormat("switch (a) {\n"
2668 "[[likely]] case 1:\n"
2669 " return;\n"
2671 verifyFormat("switch (a) {\n"
2672 "[[likely]] [[other::likely]] case 1:\n"
2673 " return;\n"
2675 verifyFormat("switch (x) {\n"
2676 "case 1:\n"
2677 " return;\n"
2678 "[[likely]] case 2:\n"
2679 " return;\n"
2681 verifyFormat("switch (a) {\n"
2682 "case 1:\n"
2683 "[[likely]] case 2:\n"
2684 " return;\n"
2689 verifyFormat("switch (a) {\n"
2690 "LIKELY case b:\n"
2691 " return;\n"
2694 verifyFormat("switch (a) {\n"
2695 "LIKELY OTHER_LIKELY() case b:\n"
2696 " return;\n"
2699 verifyFormat("switch (a) {\n"
2700 "case 1:\n"
2701 " return;\n"
2702 "LIKELY case 2:\n"
2703 " return;\n"
2706 verifyFormat("switch (a) {\n"
2707 "case 1:\n"
2708 "LIKELY case 2:\n"
2709 " return;\n"
2719 verifyFormat("switch (n)\n"
2720 "{\n"
2721 " case 0:\n"
2722 " {\n"
2723 " return false;\n"
2724 " }\n"
2725 " default:\n"
2726 " {\n"
2727 " return true;\n"
2728 " }\n"
2730 "switch (n) {\n"
2731 " case 0: {\n"
2732 " return false;\n"
2733 " }\n"
2734 " default: {\n"
2735 " return true;\n"
2736 " }\n"
2740 verifyFormat("switch (n)\n"
2741 "{\n"
2742 " case 0: {\n"
2743 " return false;\n"
2744 " }\n"
2745 " default: {\n"
2746 " return true;\n"
2747 " }\n"
2749 "switch (n) {\n"
2750 " case 0:\n"
2751 " {\n"
2752 " return false;\n"
2753 " }\n"
2754 " default:\n"
2755 " {\n"
2756 " return true;\n"
2757 " }\n"
2762 verifyFormat("switch (n)\n"
2763 "{\n"
2764 "case 0:\n"
2765 " {\n"
2766 " return false;\n"
2767 " }\n"
2768 "case 1:\n"
2769 " break;\n"
2770 "default:\n"
2771 " {\n"
2772 " return true;\n"
2773 " }\n"
2775 "switch (n) {\n"
2776 "case 0: {\n"
2777 " return false;\n"
2778 "}\n"
2779 "case 1:\n"
2780 " break;\n"
2781 "default: {\n"
2782 " return true;\n"
2783 "}\n"
2788 verifyFormat("switch (n)\n"
2789 "{\n"
2790 " case 0:\n"
2791 " {\n"
2792 " return false;\n"
2793 " }\n"
2794 " case 1:\n"
2795 " break;\n"
2796 " default:\n"
2797 " {\n"
2798 " return true;\n"
2799 " }\n"
2801 "switch (n) {\n"
2802 "case 0: {\n"
2803 " return false;\n"
2804 "}\n"
2805 "case 1:\n"
2806 " break;\n"
2807 "default: {\n"
2808 " return true;\n"
2809 "}\n"
2815 verifyFormat("switch (x) {\n"
2816 "case 'A' ... 'Z':\n"
2817 "case 1 ... 5:\n"
2818 "case a ... b:\n"
2819 " break;\n"
2830 verifyFormat("enum {\n"
2831 " A,\n"
2832 " B,\n"
2833 " C\n"
2836 verifyFormat("typedef enum {\n"
2837 " A,\n"
2838 " B,\n"
2839 " C\n"
2842 verifyFormat("enum {\n"
2843 " A,\n"
2846 verifyFormat("typedef enum {\n"
2847 " A,\n"
2852 verifyFormat("enum\n"
2853 "{\n"
2854 " A,\n"
2855 " B,\n"
2856 " C\n"
2859 verifyFormat("typedef enum\n"
2860 "{\n"
2861 " A,\n"
2862 " B,\n"
2863 " C\n"
2871 verifyFormat("template <typename T>\n"
2872 "concept c = requires(T x) {\n"
2873 " { x + 1 } -> std::same_as<int>;\n"
2876 verifyFormat("template <typename T>\n"
2877 "concept c = requires(T x) {\n"
2878 " { x + 1 } -> std::same_as<int>;\n"
2879 " { x + 2 } -> std::same_as<int>;\n"
2883 verifyFormat("template <typename T>\n"
2884 "concept c = requires(T x) {\n"
2885 " {\n"
2886 " x + 1\n"
2887 " } -> std::same_as<int>;\n"
2890 verifyFormat("template <typename T>\n"
2891 "concept c = requires(T x) {\n"
2892 " {\n"
2893 " x + 1\n"
2894 " } -> std::same_as<int>;\n"
2895 " {\n"
2896 " x + 2\n"
2897 " } -> std::same_as<int>;\n"
2905 verifyFormat("switch (a) {\n"
2906 "case 1: x = 1; break;\n"
2907 "case 2: return;\n"
2908 "case 3:\n"
2909 "case 4:\n"
2910 "case 5: return;\n"
2911 "case 6: // comment\n"
2912 " return;\n"
2913 "case 7:\n"
2914 " // comment\n"
2915 " return;\n"
2916 "case 8:\n"
2917 " x = 8; // comment\n"
2918 " break;\n"
2919 "default: y = 1; break;\n"
2922 verifyFormat("switch (a) {\n"
2923 "case 0: return; // comment\n"
2924 "case 1: break; // comment\n"
2925 "case 2: return;\n"
2926 "// comment\n"
2927 "case 3: return;\n"
2928 "// comment 1\n"
2929 "// comment 2\n"
2930 "// comment 3\n"
2931 "case 4: break; /* comment */\n"
2932 "case 5:\n"
2933 " // comment\n"
2934 " break;\n"
2935 "case 6: /* comment */ x = 1; break;\n"
2936 "case 7: x = /* comment */ 1; break;\n"
2937 "case 8:\n"
2938 " x = 1; /* comment */\n"
2939 " break;\n"
2940 "case 9:\n"
2941 " break; // comment line 1\n"
2942 " // comment line 2\n"
2945 verifyFormat("switch (a) {\n"
2946 "case 1:\n"
2947 " x = 8;\n"
2948 " // fall through\n"
2949 "case 2: x = 8;\n"
2950 "// comment\n"
2951 "case 3:\n"
2952 " return; /* comment line 1\n"
2953 " * comment line 2 */\n"
2954 "case 4: i = 8;\n"
2955 "// something else\n"
2956 "#if FOO\n"
2957 "case 5: break;\n"
2958 "#endif\n"
2960 "switch (a) {\n"
2961 "case 1: x = 8;\n"
2962 " // fall through\n"
2963 "case 2:\n"
2964 " x = 8;\n"
2965 "// comment\n"
2966 "case 3:\n"
2967 " return; /* comment line 1\n"
2968 " * comment line 2 */\n"
2969 "case 4:\n"
2970 " i = 8;\n"
2971 "// something else\n"
2972 "#if FOO\n"
2973 "case 5: break;\n"
2974 "#endif\n"
2977 verifyFormat("switch (a) {\n"
2978 "case 0:\n"
2980 "long long comment\n"
2981 " // line\n"
2983 "switch (a) {\n"
2985 "long long long long comment line\n"
2988 verifyFormat("switch (a) {\n"
2989 "case 0:\n"
2991 "long long comment\n"
2992 " line */\n"
2994 "switch (a) {\n"
2996 "long long long long comment line */\n"
2999 verifyFormat("switch (a) {\n"
3000 "#if FOO\n"
3001 "case 0: return 0;\n"
3002 "#endif\n"
3005 verifyFormat("switch (a) {\n"
3006 "case 1: {\n"
3007 "}\n"
3008 "case 2: {\n"
3009 " return;\n"
3010 "}\n"
3011 "case 3: {\n"
3012 " x = 1;\n"
3013 " return;\n"
3014 "}\n"
3015 "case 4:\n"
3016 " if (x)\n"
3017 " return;\n"
3021 verifyFormat("#define X \\\n"
3022 " case 0: break;\n"
3025 verifyFormat("switch (a) {\n"
3026 "case 1: x = 1; break;\n"
3027 "case 2: return;\n"
3028 "case 3:\n"
3029 "case 4:\n"
3030 "case 5: return;\n"
3031 "default:\n"
3032 " y = 1;\n"
3033 " break;\n"
3039 verifyFormat("switch (n) {\n"
3040 " default /*comments*/:\n"
3041 " return true;\n"
3042 " case 0:\n"
3043 " return false;\n"
3045 "switch (n) {\n"
3046 "default/*comments*/:\n"
3047 " return true;\n"
3048 "case 0:\n"
3049 " return false;\n"
3056 verifyFormat("switch (n)\n"
3057 "{\n"
3058 " case 0:\n"
3059 " {\n"
3060 " return false;\n"
3061 " }\n"
3062 " default:\n"
3063 " {\n"
3064 " return true;\n"
3065 " }\n"
3067 "switch (n) {\n"
3068 " case 0: {\n"
3069 " return false;\n"
3070 " }\n"
3071 " default:\n"
3072 " {\n"
3073 " return true;\n"
3074 " }\n"
3080 verifyFormat("void f() {\n"
3081 " some_code();\n"
3082 "test_label:\n"
3083 " some_other_code();\n"
3084 " {\n"
3085 " some_more_code();\n"
3086 " another_label:\n"
3087 " some_more_code();\n"
3088 " }\n"
3090 verifyFormat("{\n"
3091 " some_code();\n"
3092 "test_label:\n"
3093 " some_other_code();\n"
3095 verifyFormat("{\n"
3096 " some_code();\n"
3097 "test_label:;\n"
3098 " int i = 0;\n"
3100 verifyFormat("{\n"
3101 " some_code();\n"
3102 "test_label: { some_other_code(); }\n"
3104 verifyFormat("{\n"
3105 " some_code();\n"
3106 "test_label: {\n"
3107 " some_other_code();\n"
3108 " some_other_code();\n"
3109 "}\n"
3111 verifyFormat("{\n"
3112 "L0:\n"
3113 "[[foo]] L1:\n"
3114 "[[bar]] [[baz]] L2:\n"
3115 " g();\n"
3117 verifyFormat("{\n"
3118 "[[foo]] L1: {\n"
3119 "[[bar]] [[baz]] L2:\n"
3120 " g();\n"
3121 "}\n"
3123 verifyFormat("{\n"
3124 "[[foo]] L1:\n"
3125 " f();\n"
3126 " {\n"
3127 " [[bar]] [[baz]] L2:\n"
3128 " g();\n"
3129 " }\n"
3134 verifyFormat("void f() {\n"
3135 " some_code();\n"
3136 "test_label:\n"
3137 " some_other_code();\n"
3138 " {\n"
3139 " some_more_code();\n"
3140 "another_label:\n"
3141 " some_more_code();\n"
3142 " }\n"
3145 verifyFormat("{\n"
3146 " some_code();\n"
3147 "test_label:\n"
3148 " some_other_code();\n"
3151 verifyFormat("{\n"
3152 " some_code();\n"
3153 "test_label:;\n"
3154 " int i = 0;\n"
3157 verifyFormat("{\n"
3158 " some_code();\n"
3159 "test_label: { some_other_code(); }\n"
3162 verifyFormat("{\n"
3163 "[[foo]] L1:\n"
3164 " f();\n"
3165 " {\n"
3166 "[[bar]] [[baz]] L2:\n"
3167 " g();\n"
3168 " }\n"
3173 verifyFormat("#define FOO \\\n"
3174 "label: \\\n"
3182 verifyFormat("{\n"
3183 " some_code();\n"
3184 "test_label:\n"
3185 "{\n"
3186 " some_other_code();\n"
3187 "}\n"
3190 verifyFormat("{\n"
3191 "[[foo]] L1:\n"
3192 "{\n"
3193 "[[bar]] [[baz]] L2:\n"
3194 " g();\n"
3195 "}\n"
3205 verifyFormat("if (foo) {\n"
3206 " bar();\n"
3209 verifyFormat("if (foo) {\n"
3210 " bar();\n"
3211 "} else {\n"
3212 " baz();\n"
3215 verifyFormat("if (foo && bar) {\n"
3216 " baz();\n"
3219 verifyFormat("if (foo) {\n"
3220 " bar();\n"
3221 "} else if (baz) {\n"
3222 " quux();\n"
3225 verifyFormat("if (foo) {\n"
3226 " bar();\n"
3227 "} else if (baz) {\n"
3228 " quux();\n"
3229 "} else {\n"
3230 " foobar();\n"
3233 verifyFormat("for (;;) {\n"
3234 " foo();\n"
3237 verifyFormat("while (1) {\n"
3238 " foo();\n"
3241 verifyFormat("switch (foo) {\n"
3242 "case bar:\n"
3243 " return;\n"
3246 verifyFormat("try {\n"
3247 " foo();\n"
3248 "} catch (...) {\n"
3249 " bar();\n"
3252 verifyFormat("do {\n"
3253 " foo();\n"
3254 "} while (bar &&\n"
3258 verifyFormat("void f() {\n"
3259 " if (a1 && a2 &&\n"
3260 " a3)\n"
3261 " {\n"
3262 " quux();\n"
3263 " }\n"
3266 verifyFormat("if (foo && bar &&\n"
3267 " baz)\n"
3268 "{\n"
3269 " quux();\n"
3272 verifyFormat("if (foo && bar &&\n"
3273 " baz)\n"
3274 "{\n"
3275 " quux();\n"
3277 "if (foo && bar &&\n"
3278 " baz) {\n"
3279 " quux();\n"
3282 verifyFormat("if (foo) {\n"
3283 " bar();\n"
3284 "} else if (baz ||\n"
3285 " quux)\n"
3286 "{\n"
3287 " foobar();\n"
3290 verifyFormat("if (foo) {\n"
3291 " bar();\n"
3292 "} else if (baz ||\n"
3293 " quux)\n"
3294 "{\n"
3295 " foobar();\n"
3296 "} else {\n"
3297 " barbaz();\n"
3301 verifyFormat("for (int i = 0;\n"
3302 " i < 10; ++i)\n"
3303 "{\n"
3304 " foo();\n"
3307 verifyFormat("foreach (int i,\n"
3308 " list)\n"
3309 "{\n"
3310 " foo();\n"
3315 verifyFormat("foreach (int i, list) {\n"
3316 " foo();\n"
3321 verifyFormat("while (foo || bar ||\n"
3322 " baz)\n"
3323 "{\n"
3324 " quux();\n"
3327 verifyFormat("switch (\n"
3328 " foo = barbaz)\n"
3329 "{\n"
3330 "case quux:\n"
3331 " return;\n"
3334 verifyFormat("try {\n"
3335 " foo();\n"
3336 "} catch (\n"
3337 " Exception &bar)\n"
3338 "{\n"
3339 " baz();\n"
3344 verifyFormat("try {\n"
3345 " foo();\n"
3346 "} catch (Exception &bar) {\n"
3347 " baz();\n"
3354 verifyFormat("if (foo) {\n"
3355 " bar();\n"
3356 "}\n"
3357 "else if (baz ||\n"
3358 " quux)\n"
3359 "{\n"
3360 " foobar();\n"
3361 "}\n"
3362 "else {\n"
3363 " barbaz();\n"
3369 verifyFormat("try {\n"
3370 " foo();\n"
3371 "}\n"
3372 "catch (...) {\n"
3373 " baz();\n"
3387 verifyFormat("void shortfunction()\n"
3388 "{\n"
3389 " bar();\n"
3392 verifyFormat("struct T shortfunction()\n"
3393 "{\n"
3394 " return bar();\n"
3404 verifyFormat("struct T\n"
3405 "{\n"
3410 verifyFormat("void shortfunction() {\n"
3411 " bar();\n"
3414 verifyFormat("struct T shortfunction() {\n"
3415 " return bar();\n"
3418 verifyFormat("struct T\n"
3419 "{\n"
3428 verifyFormat("do {\n"
3429 " foo();\n"
3433 verifyFormat("do {\n"
3434 " foo();\n"
3435 "}\n"
3449 verifyFormat("class A {\n"
3450 "public:\n"
3451 "public: // comment\n"
3452 "protected:\n"
3453 "private:\n"
3454 " void f() {}\n"
3456 verifyFormat("export class A {\n"
3457 "public:\n"
3458 "public: // comment\n"
3459 "protected:\n"
3460 "private:\n"
3461 " void f() {}\n"
3463 verifyGoogleFormat("class A {\n"
3464 " public:\n"
3465 " protected:\n"
3466 " private:\n"
3467 " void f() {}\n"
3469 verifyGoogleFormat("export class A {\n"
3470 " public:\n"
3471 " protected:\n"
3472 " private:\n"
3473 " void f() {}\n"
3475 verifyFormat("class A {\n"
3476 "public slots:\n"
3477 " void f1() {}\n"
3478 "public Q_SLOTS:\n"
3479 " void f2() {}\n"
3480 "protected slots:\n"
3481 " void f3() {}\n"
3482 "protected Q_SLOTS:\n"
3483 " void f4() {}\n"
3484 "private slots:\n"
3485 " void f5() {}\n"
3486 "private Q_SLOTS:\n"
3487 " void f6() {}\n"
3488 "signals:\n"
3489 " void g1();\n"
3490 "Q_SIGNALS:\n"
3491 " void g2();\n"
3496 verifyFormat("for (Signals signals : f()) {\n}");
3497 verifyFormat("{\n"
3498 " signals.set(); // This needs indentation.\n"
3500 verifyFormat("void f() {\n"
3501 "label:\n"
3502 " signals.baz();\n"
3545 verifyFormat("class A {\n"
3546 "public:\n"
3547 " std::unique_ptr<int *[]> b() { return nullptr; }\n"
3548 "\n"
3549 "private:\n"
3550 " int c;\n"
3551 "};\n"
3552 "class B {\n"
3553 "public:\n"
3554 " std::unique_ptr<int *[] /* okay */> b() { return nullptr; }\n"
3555 "\n"
3556 "private:\n"
3557 " int c;\n"
3562 verifyFormat("class A {\n"
3563 "public:\n"
3564 " void f();\n"
3565 "\n"
3566 "private:\n"
3567 " void g() {}\n"
3568 " // test\n"
3569 "protected:\n"
3570 " int h;\n"
3572 "class A {\n"
3573 "public:\n"
3574 "void f();\n"
3575 "private:\n"
3576 "void g() {}\n"
3577 "// test\n"
3578 "protected:\n"
3579 "int h;\n"
3581 verifyFormat("class A {\n"
3582 "protected:\n"
3583 "public:\n"
3584 " void f();\n"
3586 "class A {\n"
3587 "protected:\n"
3588 "\n"
3589 "public:\n"
3590 "\n"
3591 " void f();\n"
3595 verifyFormat("#define B \\\n"
3596 " class A { \\\n"
3597 " protected: \\\n"
3598 " public: \\\n"
3599 " void f(); \\\n"
3601 "#define B \\\n"
3602 " class A { \\\n"
3603 " protected: \\\n"
3604 " \\\n"
3605 " public: \\\n"
3606 " \\\n"
3607 " void f(); \\\n"
3611 verifyFormat("#define A private:\n"
3612 "\n"
3614 "#define A private:\n"
3615 "\n"
3624 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
3626 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
3627 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
3631 verifyFormat("class AAAAAAAAAAAA : public B,\n"
3632 " public C,\n"
3633 " public D,\n"
3634 " public E,\n"
3635 " public F,\n"
3638 verifyFormat("class\n"
3639 " ReallyReallyLongClassName {\n"
3640 " int i;\n"
3643 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
3645 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
3646 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
3648 verifyFormat("template <class R, class C>\n"
3649 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
3660 verifyFormat("class MyClass\n"
3661 " : public X\n"
3664 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
3665 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
3668 verifyFormat("struct aaaaaaaaaaaaa\n"
3669 " : public aaaaaaaaaaaaaaaaaaa< // break\n"
3680 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
3681 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
3684 verifyFormat("struct aaaaaaaaaaaaa :\n"
3685 " public aaaaaaaaaaaaaaaaaaa< // break\n"
3694 verifyFormat("class MyClass : public X,\n"
3698 "class AAAAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
3702 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
3705 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
3706 " : public OnceBreak,\n"
3707 " public AlwaysBreak,\n"
3713 verifyFormat("class A {\n} a, b;");
3714 verifyFormat("struct A {\n} a, b;");
3715 verifyFormat("union A {\n} a, b;");
3717 verifyFormat("constexpr class A {\n} a, b;");
3718 verifyFormat("constexpr struct A {\n} a, b;");
3719 verifyFormat("constexpr union A {\n} a, b;");
3721 verifyFormat("namespace {\nclass A {\n} a, b;\n} // namespace");
3722 verifyFormat("namespace {\nstruct A {\n} a, b;\n} // namespace");
3723 verifyFormat("namespace {\nunion A {\n} a, b;\n} // namespace");
3725 verifyFormat("namespace {\nconstexpr class A {\n} a, b;\n} // namespace");
3726 verifyFormat("namespace {\nconstexpr struct A {\n} a, b;\n} // namespace");
3727 verifyFormat("namespace {\nconstexpr union A {\n} a, b;\n} // namespace");
3729 verifyFormat("namespace ns {\n"
3730 "class {\n"
3731 "} a, b;\n"
3733 verifyFormat("namespace ns {\n"
3734 "const class {\n"
3735 "} a, b;\n"
3737 verifyFormat("namespace ns {\n"
3738 "constexpr class C {\n"
3739 "} a, b;\n"
3741 verifyFormat("namespace ns {\n"
3742 "class { /* comment */\n"
3743 "} a, b;\n"
3745 verifyFormat("namespace ns {\n"
3746 "const class { /* comment */\n"
3747 "} a, b;\n"
3752 verifyFormat("enum {\n"
3753 " Zero,\n"
3754 " One = 1,\n"
3755 " Two = One + 1,\n"
3756 " Three = (One + Two),\n"
3757 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
3758 " Five = (One, Two, Three, Four, 5)\n"
3760 verifyGoogleFormat("enum {\n"
3761 " Zero,\n"
3762 " One = 1,\n"
3763 " Two = One + 1,\n"
3764 " Three = (One + Two),\n"
3765 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
3766 " Five = (One, Two, Three, Four, 5)\n"
3774 verifyFormat("enum {\n"
3775 " Bar = Foo<int, int>::value\n"
3782 verifyFormat("enum KeepEmptyLines {\n"
3783 " ONE,\n"
3784 "\n"
3785 " TWO,\n"
3786 "\n"
3787 " THREE\n"
3789 "enum KeepEmptyLines {\n"
3790 " ONE,\n"
3791 "\n"
3792 " TWO,\n"
3793 "\n"
3794 "\n"
3795 " THREE\n"
3797 verifyFormat("enum E { // comment\n"
3798 " ONE,\n"
3799 " TWO\n"
3800 "};\n"
3805 verifyFormat("enum {\n"
3806 " VOID,\n"
3807 " CHAR,\n"
3808 " SHORT,\n"
3809 " INT,\n"
3810 " LONG,\n"
3811 " SIGNED,\n"
3812 " UNSIGNED,\n"
3813 " BOOL,\n"
3814 " FLOAT,\n"
3815 " DOUBLE,\n"
3816 " COMPLEX\n"
3820 verifyFormat("enum [[nodiscard]] E {\n"
3821 " ONE,\n"
3822 " TWO,\n"
3824 verifyFormat("enum [[nodiscard]] E {\n"
3825 " // Comment 1\n"
3826 " ONE,\n"
3827 " // Comment 2\n"
3828 " TWO,\n"
3830 verifyFormat("enum [[clang::enum_extensibility(open)]] E {\n"
3831 " // Comment 1\n"
3832 " ONE,\n"
3833 " // Comment 2\n"
3834 " TWO\n"
3836 verifyFormat("enum [[nodiscard]] [[clang::enum_extensibility(open)]] E {\n"
3837 " // Comment 1\n"
3838 " ONE,\n"
3839 " // Comment 2\n"
3840 " TWO\n"
3842 verifyFormat("enum [[clang::enum_extensibility(open)]] E { // foo\n"
3843 " A,\n"
3844 " // bar\n"
3845 " B\n"
3847 "enum [[clang::enum_extensibility(open)]] E{// foo\n"
3848 " A,\n"
3849 " // bar\n"
3853 verifyFormat("enum X f() {\n"
3854 " a();\n"
3855 " return 42;\n"
3857 verifyFormat("enum X Type::f() {\n"
3858 " a();\n"
3859 " return 42;\n"
3861 verifyFormat("enum ::X f() {\n"
3862 " a();\n"
3863 " return 42;\n"
3865 verifyFormat("enum ns::X f() {\n"
3866 " a();\n"
3867 " return 42;\n"
3872 verifyFormat("enum Type {\n"
3873 " One = 0; // These semicolons should be commas.\n"
3874 " Two = 1;\n"
3876 verifyFormat("namespace n {\n"
3877 "enum Type {\n"
3878 " One,\n"
3879 " Two, // missing };\n"
3880 " int i;\n"
3881 "}\n"
3886 verifyFormat("enum struct {\n"
3887 " Zero,\n"
3888 " One = 1,\n"
3889 " Two = One + 1,\n"
3890 " Three = (One + Two),\n"
3891 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
3892 " Five = (One, Two, Three, Four, 5)\n"
3900 verifyFormat("enum struct X f() {\n a();\n return 42;\n}");
3902 verifyFormat("enum struct [[nodiscard]] E {\n"
3903 " ONE,\n"
3904 " TWO,\n"
3906 verifyFormat("enum struct [[nodiscard]] E {\n"
3907 " // Comment 1\n"
3908 " ONE,\n"
3909 " // Comment 2\n"
3910 " TWO,\n"
3915 verifyFormat("enum class {\n"
3916 " Zero,\n"
3917 " One = 1,\n"
3918 " Two = One + 1,\n"
3919 " Three = (One + Two),\n"
3920 " Four = (Zero && (One ^ Two)) | (One << Two),\n"
3921 " Five = (One, Two, Three, Four, 5)\n"
3929 verifyFormat("enum class X f() {\n a();\n return 42;\n}");
3931 verifyFormat("enum class [[nodiscard]] E {\n"
3932 " ONE,\n"
3933 " TWO,\n"
3935 verifyFormat("enum class [[nodiscard]] E {\n"
3936 " // Comment 1\n"
3937 " ONE,\n"
3938 " // Comment 2\n"
3939 " TWO,\n"
3944 verifyFormat("enum X : int {\n"
3945 " A, // Force multiple lines.\n"
3946 " B\n"
3956 verifyFormat("typedef enum {\n"
3957 " ZERO = 0,\n"
3958 " ONE = 1,\n"
3959 " TWO = 2,\n"
3960 " THREE = 3\n"
3967 verifyFormat("typedef enum\n"
3968 "{\n"
3969 " ZERO = 0,\n"
3970 " ONE = 1,\n"
3971 " TWO = 2,\n"
3972 " THREE = 3\n"
3981 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
3982 " // Information about someDecentlyLongValue.\n"
3983 " someDecentlyLongValue,\n"
3984 " // Information about anotherDecentlyLongValue.\n"
3985 " anotherDecentlyLongValue,\n"
3986 " // Information about aThirdDecentlyLongValue.\n"
3987 " aThirdDecentlyLongValue\n"
3989 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
3990 " // Information about someDecentlyLongValue.\n"
3991 " someDecentlyLongValue,\n"
3992 " // Information about anotherDecentlyLongValue.\n"
3993 " anotherDecentlyLongValue,\n"
3994 " // Information about aThirdDecentlyLongValue.\n"
3995 " aThirdDecentlyLongValue\n"
3997 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
3998 " a = 1,\n"
3999 " b = 2,\n"
4000 " c = 3,\n"
4002 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
4003 " a = 1,\n"
4004 " b = 2,\n"
4005 " c = 3,\n"
4007 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
4008 " a = 1,\n"
4009 " b = 2,\n"
4010 " c = 3,\n"
4012 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
4013 " a = 1,\n"
4014 " b = 2,\n"
4015 " c = 3,\n"
4020 verifyFormat("struct Bitfields {\n"
4021 " unsigned sClass : 8;\n"
4022 " unsigned ValueKind : 2;\n"
4024 verifyFormat("struct A {\n"
4025 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
4026 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
4028 verifyFormat("struct MyStruct {\n"
4029 " uchar data;\n"
4030 " uchar : 8;\n"
4031 " uchar : 8;\n"
4032 " uchar other;\n"
4036 verifyFormat("struct Bitfields {\n"
4037 " unsigned sClass:8;\n"
4038 " unsigned ValueKind:2;\n"
4039 " uchar other;\n"
4042 verifyFormat("struct A {\n"
4043 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:1,\n"
4044 " bbbbbbbbbbbbbbbbbbbbbbbbb:2;\n"
4048 verifyFormat("struct Bitfields {\n"
4049 " unsigned sClass :8;\n"
4050 " unsigned ValueKind :2;\n"
4051 " uchar other;\n"
4055 verifyFormat("struct Bitfields {\n"
4056 " unsigned sClass: 8;\n"
4057 " unsigned ValueKind: 2;\n"
4058 " uchar other;\n"
4067 verifyFormat("namespace some_namespace {\n"
4068 "class A {};\n"
4069 "void f() { f(); }\n"
4072 verifyFormat("#define M(x) x##x\n"
4073 "namespace M(x) {\n"
4074 "class A {};\n"
4075 "void f() { f(); }\n"
4078 verifyFormat("#define M(x) x##x\n"
4079 "namespace N::inline M(x) {\n"
4080 "class A {};\n"
4081 "void f() { f(); }\n"
4084 verifyFormat("#define M(x) x##x\n"
4085 "namespace M(x)::inline N {\n"
4086 "class A {};\n"
4087 "void f() { f(); }\n"
4090 verifyFormat("#define M(x) x##x\n"
4091 "namespace N::M(x) {\n"
4092 "class A {};\n"
4093 "void f() { f(); }\n"
4096 verifyFormat("#define M(x) x##x\n"
4097 "namespace M::N(x) {\n"
4098 "class A {};\n"
4099 "void f() { f(); }\n"
4102 verifyFormat("namespace N::inline D {\n"
4103 "class A {};\n"
4104 "void f() { f(); }\n"
4107 verifyFormat("namespace N::inline D::E {\n"
4108 "class A {};\n"
4109 "void f() { f(); }\n"
4112 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
4113 "class A {};\n"
4114 "void f() { f(); }\n"
4117 verifyFormat("/* something */ namespace some_namespace {\n"
4118 "class A {};\n"
4119 "void f() { f(); }\n"
4122 verifyFormat("namespace {\n"
4123 "class A {};\n"
4124 "void f() { f(); }\n"
4127 verifyFormat("/* something */ namespace {\n"
4128 "class A {};\n"
4129 "void f() { f(); }\n"
4132 verifyFormat("inline namespace X {\n"
4133 "class A {};\n"
4134 "void f() { f(); }\n"
4137 verifyFormat("/* something */ inline namespace X {\n"
4138 "class A {};\n"
4139 "void f() { f(); }\n"
4142 verifyFormat("export namespace X {\n"
4143 "class A {};\n"
4144 "void f() { f(); }\n"
4147 verifyFormat("using namespace some_namespace;\n"
4148 "class A {};\n"
4156 verifyFormat("namespace {\n"
4157 "class A {};\n"
4161 verifyFormat("namespace {\n"
4162 "int SomeVariable = 0; // comment\n"
4165 verifyFormat("#ifndef HEADER_GUARD\n"
4166 "#define HEADER_GUARD\n"
4167 "namespace my_namespace {\n"
4168 "int i;\n"
4169 "} // my_namespace\n"
4171 "#ifndef HEADER_GUARD\n"
4172 " #define HEADER_GUARD\n"
4173 " namespace my_namespace {\n"
4174 "int i;\n"
4175 "} // my_namespace\n"
4179 verifyFormat("namespace A::B {\n"
4180 "class C {};\n"
4186 verifyFormat("namespace out {\n"
4187 " int i;\n"
4188 " namespace in {\n"
4189 " int i;\n"
4190 " } // namespace in\n"
4192 "namespace out {\n"
4193 "int i;\n"
4194 "namespace in {\n"
4195 "int i;\n"
4196 "} // namespace in\n"
4204 verifyFormat("namespace {\n"
4205 " void f() {\n"
4206 " return;\n"
4207 " }\n"
4210 verifyFormat("namespace { /* comment */\n"
4211 " void f() {\n"
4212 " return;\n"
4213 " }\n"
4216 verifyFormat("namespace { // comment\n"
4217 " void f() {\n"
4218 " return;\n"
4219 " }\n"
4222 verifyFormat("namespace {\n"
4223 " int some_int;\n"
4224 " void f() {\n"
4225 " return;\n"
4226 " }\n"
4229 verifyFormat("namespace interface {\n"
4230 " void f() {\n"
4231 " return;\n"
4232 " }\n"
4235 verifyFormat("namespace {\n"
4236 " class X {\n"
4237 " void f() { return; }\n"
4238 " };\n"
4241 verifyFormat("namespace {\n"
4242 " class X { /* comment */\n"
4243 " void f() { return; }\n"
4244 " };\n"
4247 verifyFormat("namespace {\n"
4248 " class X { // comment\n"
4249 " void f() { return; }\n"
4250 " };\n"
4253 verifyFormat("namespace {\n"
4254 " struct X {\n"
4255 " void f() { return; }\n"
4256 " };\n"
4259 verifyFormat("namespace {\n"
4260 " union X {\n"
4261 " void f() { return; }\n"
4262 " };\n"
4265 verifyFormat("extern \"C\" {\n"
4266 "void f() {\n"
4267 " return;\n"
4268 "}\n"
4271 verifyFormat("namespace {\n"
4272 " class X {\n"
4273 " void f() { return; }\n"
4274 " } x;\n"
4277 verifyFormat("namespace {\n"
4278 " [[nodiscard]] class X {\n"
4279 " void f() { return; }\n"
4280 " };\n"
4283 verifyFormat("namespace {\n"
4284 " static class X {\n"
4285 " void f() { return; }\n"
4286 " } x;\n"
4289 verifyFormat("namespace {\n"
4290 " constexpr class X {\n"
4291 " void f() { return; }\n"
4292 " } x;\n"
4297 verifyFormat("extern \"C\" {\n"
4298 " void f() {\n"
4299 " return;\n"
4300 " }\n"
4305 verifyFormat("namespace out {\n"
4306 "int i;\n"
4307 "namespace in {\n"
4308 " int i;\n"
4309 "} // namespace in\n"
4311 "namespace out {\n"
4312 "int i;\n"
4313 "namespace in {\n"
4314 "int i;\n"
4315 "} // namespace in\n"
4320 verifyFormat("template <class T>\n"
4321 "concept a_concept = X<>;\n"
4322 "namespace B {\n"
4323 "struct b_struct {};\n"
4326 verifyFormat("template <int I>\n"
4327 "constexpr void foo()\n"
4328 " requires(I == 42)\n"
4329 "{}\n"
4330 "namespace ns {\n"
4331 "void foo() {}\n"
4338 verifyFormat("namespace ns1 { namespace ns2 { namespace ns3 {\n"
4339 "// block for debug mode\n"
4340 "#ifndef NDEBUG\n"
4341 "#endif\n"
4350 verifyFormat("TESTSUITE(A) {\n"
4351 "int foo();\n"
4355 verifyFormat("TESTSUITE(A, B) {\n"
4356 "int foo();\n"
4362 verifyFormat("TESTSUITE(A) {\n"
4363 " int foo();\n"
4366 verifyFormat("TESTSUITE(A) {\n"
4367 " namespace B {\n"
4368 " int foo();\n"
4369 " } // namespace B\n"
4372 verifyFormat("namespace A {\n"
4373 " TESTSUITE(B) {\n"
4374 " int foo();\n"
4375 " } // TESTSUITE(B)\n"
4380 verifyFormat("TESTSUITE(A) {\n"
4381 "TESTSUITE(B) {\n"
4382 " int foo();\n"
4383 "} // TESTSUITE(B)\n"
4386 verifyFormat("TESTSUITE(A) {\n"
4387 "namespace B {\n"
4388 " int foo();\n"
4389 "} // namespace B\n"
4392 verifyFormat("namespace A {\n"
4393 "TESTSUITE(B) {\n"
4394 " int foo();\n"
4395 "} // TESTSUITE(B)\n"
4402 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
4406 verifyFormat("TESTSUITE(out) { TESTSUITE(in) {\n"
4408 "TESTSUITE(out) {\n"
4409 "TESTSUITE(in) {\n"
4410 "} // TESTSUITE(in)\n"
4414 verifyFormat("TESTSUITE(out) { TESTSUITE(in) {\n"
4416 "TESTSUITE(out) {\n"
4417 "TESTSUITE(in) {\n"
4418 "} // TESTSUITE(in)\n"
4423 verifyFormat("namespace out {\n"
4424 "TESTSUITE(in) {\n"
4425 "} // TESTSUITE(in)\n"
4428 verifyFormat("TESTSUITE(out) {\n"
4429 "namespace in {\n"
4430 "} // namespace in\n"
4434 verifyFormat("TESTSUITE(out) {\n"
4435 "FOOBAR(in) {\n"
4436 "} // FOOBAR(in)\n"
4446 verifyFormat("namespace A { namespace B {\n"
4450 verifyFormat("namespace out { namespace in {\n"
4452 "namespace out {\n"
4453 "namespace in {\n"
4454 "} // namespace in\n"
4459 verifyFormat("namespace out {\n"
4460 "namespace in1 {\n"
4461 "} // namespace in1\n"
4462 "namespace in2 {\n"
4463 "} // namespace in2\n"
4467 verifyFormat("namespace out {\n"
4468 "int i;\n"
4469 "namespace in {\n"
4470 "int j;\n"
4471 "} // namespace in\n"
4472 "int k;\n"
4474 "namespace out { int i;\n"
4475 "namespace in { int j; } // namespace in\n"
4480 verifyFormat("namespace A { namespace B { namespace C {\n"
4482 "namespace A { namespace B {\n"
4483 "namespace C {\n"
4484 "}} // namespace B::C\n"
4489 verifyFormat("namespace aaaaaaaaaa {\n"
4490 "namespace bbbbbbbbbb {\n"
4492 "namespace aaaaaaaaaa {\n"
4493 "namespace bbbbbbbbbb {\n"
4494 "} // namespace bbbbbbbbbb\n"
4498 verifyFormat("namespace aaaaaa { namespace bbbbbb {\n"
4499 "namespace cccccc {\n"
4501 "namespace aaaaaa {\n"
4502 "namespace bbbbbb {\n"
4503 "namespace cccccc {\n"
4504 "} // namespace cccccc\n"
4505 "} // namespace bbbbbb\n"
4509 verifyFormat("namespace a { namespace b {\n"
4510 "namespace c {\n"
4517 verifyFormat("namespace out { namespace in {\n"
4519 "namespace out {\n"
4520 "namespace in {\n"
4521 "}; // namespace in\n"
4526 verifyFormat("namespace out { namespace in {\n"
4528 "namespace out {\n"
4529 "namespace in {\n"
4530 "} // namespace in\n"
4535 verifyFormat("namespace out { namespace in {\n"
4536 " int i;\n"
4538 "namespace out {\n"
4539 "namespace in {\n"
4540 "int i;\n"
4541 "} // namespace in\n"
4544 verifyFormat("namespace out { namespace mid {\n"
4545 " namespace in {\n"
4546 " int j;\n"
4547 " } // namespace in\n"
4548 " int k;\n"
4550 "namespace out { namespace mid {\n"
4551 "namespace in { int j; } // namespace in\n"
4555 verifyFormat("namespace A { namespace B { namespace C {\n"
4556 " int i;\n"
4557 "}}} // namespace A::B::C\n"
4558 "int main() {\n"
4559 " if (true)\n"
4560 " return 0;\n"
4562 "namespace A { namespace B {\n"
4563 "namespace C {\n"
4564 " int i;\n"
4565 "}} // namespace B::C\n"
4566 "} // namespace A\n"
4567 "int main() {\n"
4568 " if (true)\n"
4569 " return 0;\n"
4573 verifyFormat("namespace A { namespace B { namespace C {\n"
4574 "#ifdef FOO\n"
4575 " int i;\n"
4576 "#endif\n"
4577 "}}} // namespace A::B::C\n"
4578 "int main() {\n"
4579 " if (true)\n"
4580 " return 0;\n"
4582 "namespace A { namespace B {\n"
4583 "namespace C {\n"
4584 "#ifdef FOO\n"
4585 " int i;\n"
4586 "#endif\n"
4587 "}} // namespace B::C\n"
4588 "} // namespace A\n"
4589 "int main() {\n"
4590 " if (true)\n"
4591 " return 0;\n"
4596 verifyFormat("namespace out { namespace in {\n"
4597 " int i;\n"
4599 "namespace out {\n"
4600 "namespace in {\n"
4601 "int i;\n"
4602 "} // namespace in\n"
4605 verifyFormat("namespace out { namespace mid { namespace in {\n"
4606 " int i;\n"
4608 "namespace out {\n"
4609 "namespace mid {\n"
4610 "namespace in {\n"
4611 "int i;\n"
4612 "} // namespace in\n"
4613 "} // namespace mid\n"
4621 verifyFormat("namespace out { namespace in {\n"
4624 verifyFormat("namespace out { namespace in {\n"
4626 "namespace out {\n"
4627 "namespace in {\n"
4628 "} // namespace in\n"
4636 verifyFormat("extern \"C\" {\n"
4637 "int foo();\n"
4641 verifyFormat("extern \"C\" int foo() {\n"
4642 " int i = 42;\n"
4643 " return i;\n"
4651 verifyFormat("extern \"C\" int foo()\n"
4652 "{\n"
4653 " int i = 42;\n"
4654 " return i;\n"
4660 verifyFormat("extern \"C\"\n"
4663 verifyFormat("extern \"C\"\n"
4664 "{\n"
4665 " int foo();\n"
4675 verifyFormat("extern \"C\" { /*9*/\n"
4678 verifyFormat("extern \"C\" {\n"
4679 " int foo10();\n"
4684 verifyFormat("extern \"C\" { /*11*/\n"
4687 verifyFormat("extern \"C\" {\n"
4688 "int foo12();\n"
4693 verifyFormat("extern \"C\"\n"
4694 "{\n"
4695 "int i;\n"
4702 verifyFormat("extern \"C\"\n"
4703 "{ /*13*/\n"
4706 verifyFormat("extern \"C\"\n{\n"
4707 " int foo14();\n"
4713 verifyFormat("extern \"C\" { /*15*/\n"
4716 verifyFormat("extern \"C\" {\n"
4717 "int foo16();\n"
4722 verifyFormat("extern \"C\"\n"
4723 "{ /*13*/\n"
4726 verifyFormat("extern \"C\"\n"
4727 "{\n"
4728 "int foo14();\n"
4733 verifyFormat("extern \"C\"\n"
4734 "{ /*13*/\n"
4737 verifyFormat("extern \"C\"\n"
4738 "{\n"
4739 " int foo14();\n"
4748 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
4749 " \"cpuid\\n\\t\"\n"
4750 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
4751 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
4754 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
4755 " __asm {\n"
4756 " mov edx,[that] // vtable in edx\n"
4757 " mov eax,methodIndex\n"
4758 " call [edx][eax*4] // stdcall\n"
4759 " }\n"
4761 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
4762 " __asm {\n"
4763 " mov edx,[that] // vtable in edx\n"
4764 " mov eax,methodIndex\n"
4765 " call [edx][eax*4] // stdcall\n"
4766 " }\n"
4768 verifyNoChange("_asm {\n"
4769 " xor eax, eax;\n"
4770 " cpuid;\n"
4772 verifyFormat("void function() {\n"
4773 " // comment\n"
4774 " asm(\"\");\n"
4776 verifyFormat("__asm {\n"
4777 "}\n"
4779 "__asm {\n"
4780 "}\n"
4785 const StringRef Code2{"asm(\"xyz\"\n"
4786 " : \"=a\"(a), \"=d\"(b)\n"
4788 const StringRef Code3{"asm(\"xyz\" : \"=a\"(a), \"=d\"(b)\n"
4803 verifyFormat("try {\n"
4804 " throw a * b;\n"
4805 "} catch (int a) {\n"
4806 " // Do nothing.\n"
4807 "} catch (...) {\n"
4808 " exit(42);\n"
4812 verifyFormat("int f() try { return 4; } catch (...) {\n"
4813 " return 5;\n"
4815 verifyFormat("class A {\n"
4816 " int a;\n"
4817 " A() try : a(0) {\n"
4818 " } catch (...) {\n"
4819 " throw;\n"
4820 " }\n"
4822 verifyFormat("class A {\n"
4823 " int a;\n"
4824 " A() try : a(0), b{1} {\n"
4825 " } catch (...) {\n"
4826 " throw;\n"
4827 " }\n"
4829 verifyFormat("class A {\n"
4830 " int a;\n"
4831 " A() try : a(0), b{1}, c{2} {\n"
4832 " } catch (...) {\n"
4833 " throw;\n"
4834 " }\n"
4836 verifyFormat("class A {\n"
4837 " int a;\n"
4838 " A() try : a(0), b{1}, c{2} {\n"
4839 " { // New scope.\n"
4840 " }\n"
4841 " } catch (...) {\n"
4842 " throw;\n"
4843 " }\n"
4854 verifyFormat("if (try < size) {\n return true;\n}");
4859 verifyFormat("if (catch < size) {\n return true;\n}");
4865 verifyFormat("try {\n"
4866 " int bar = 1;\n"
4867 "}\n"
4868 "catch (...) {\n"
4869 " int bar = 1;\n"
4872 verifyFormat("#if NO_EX\n"
4873 "try\n"
4874 "#endif\n"
4875 "{\n"
4876 "}\n"
4877 "#if NO_EX\n"
4878 "catch (...) {\n"
4881 verifyFormat("try /* abc */ {\n"
4882 " int bar = 1;\n"
4883 "}\n"
4884 "catch (...) {\n"
4885 " int bar = 1;\n"
4888 verifyFormat("try\n"
4889 "// abc\n"
4890 "{\n"
4891 " int bar = 1;\n"
4892 "}\n"
4893 "catch (...) {\n"
4894 " int bar = 1;\n"
4900 verifyFormat("__try {\n"
4901 " int a = b * c;\n"
4902 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
4903 " // Do nothing.\n"
4906 verifyFormat("__try {\n"
4907 " int a = b * c;\n"
4908 "} __finally {\n"
4909 " // Do nothing.\n"
4912 verifyFormat("DEBUG({\n"
4913 " __try {\n"
4914 " } __finally {\n"
4915 " }\n"
4920 verifyFormat("try {\n"
4921 " f();\n"
4922 "} catch {\n"
4923 " g();\n"
4925 verifyFormat("try {\n"
4926 " f();\n"
4927 "} catch (A a) MACRO(x) {\n"
4928 " g();\n"
4929 "} catch (B b) MACRO(x) {\n"
4930 " g();\n"
4939 verifyFormat("try {\n"
4940 " // something\n"
4941 "} catch (...) {\n"
4942 " // something\n"
4947 verifyFormat("try {\n"
4948 " // something\n"
4949 "}\n"
4950 "catch (...) {\n"
4951 " // something\n"
4954 verifyFormat("__try {\n"
4955 " // something\n"
4956 "}\n"
4957 "__finally {\n"
4958 " // something\n"
4961 verifyFormat("@try {\n"
4962 " // something\n"
4963 "}\n"
4964 "@finally {\n"
4965 " // something\n"
4969 verifyFormat("try\n"
4970 "{\n"
4971 " // something\n"
4972 "}\n"
4973 "catch (...)\n"
4974 "{\n"
4975 " // something\n"
4979 verifyFormat("try\n"
4980 " {\n"
4981 " // something white\n"
4982 " }\n"
4983 "catch (...)\n"
4984 " {\n"
4985 " // something white\n"
4989 verifyFormat("try\n"
4990 " {\n"
4991 " // something\n"
4992 " }\n"
4993 "catch (...)\n"
4994 " {\n"
4995 " // something\n"
5000 verifyFormat("try {\n"
5001 " // something\n"
5002 "}\n"
5003 "catch (...) {\n"
5004 " // something\n"
5012 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
5017 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
5019 verifyFormat("S s = {a,\n"
5020 "\n"
5022 "S s = {\n"
5023 " a,\n"
5024 "\n"
5025 " b\n"
5031 verifyFormat("static int Variable[1] = {\n"
5038 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
5039 " .bbbbbbbbbb = 2,\n"
5040 " .cccccccccc = 3,\n"
5041 " .dddddddddd = 4,\n"
5043 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
5044 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
5045 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
5046 " .ccccccccccccccccccccccccccc = 3,\n"
5047 " .ddddddddddddddddddddddddddd = 4,\n"
5053 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
5054 " [2] = bbbbbbbbbb,\n"
5055 " [3] = cccccccccc,\n"
5056 " [4] = dddddddddd,\n"
5058 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
5059 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5060 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
5061 " [3] = cccccccccccccccccccccccccccccccccccccc,\n"
5062 " [4] = dddddddddddddddddddddddddddddddddddddd,\n"
5065 verifyFormat("for (const TestCase &test_case : {\n"
5066 " TestCase{\n"
5067 " .a = 1,\n"
5068 " .b = 1,\n"
5069 " },\n"
5070 " TestCase{\n"
5071 " .a = 2,\n"
5072 " .b = 2,\n"
5073 " },\n"
5074 " }) {\n"
5085 verifyFormat("enum class {\n"
5086 " One,\n"
5087 " Two,\n"
5090 verifyFormat("class Foo {\n"
5091 " Foo() {}\n"
5092 " void bar();\n"
5095 verifyFormat("void foo() {\n"
5096 " auto bar = baz;\n"
5097 " return baz;\n"
5100 verifyFormat("auto foo = [&] {\n"
5101 " auto bar = baz;\n"
5102 " return baz;\n"
5105 verifyFormat("{\n"
5106 " auto bar = baz;\n"
5107 " return baz;\n"
5111 verifyFormat("SomeClass clazz(\n"
5112 " \"xxxxxxxxxxxxxxxxxx\", \"yyyyyyyyyyyyyyyyyy\",\n"
5118 verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n"
5121 verifyFormat("SomeStruct s{\n"
5122 " \"xxxxxxxxxxxxxxxx\", \"yyyyyyyyyyyyyyyy\",\n"
5126 verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n"
5129 verifyFormat("SomeStruct s{\n"
5130 " .foo = \"xxxxxxxxxxxxx\",\n"
5131 " .bar = \"yyyyyyyyyyyyy\",\n"
5135 verifyFormat("SomeStruct s{\n"
5136 " \"xxxxxxxxxxxxx\",\n"
5137 " \"yyyyyyyyyyyyy\",\n"
5138 " \"zzzzzzzzzzzzz\",\n"
5141 verifyFormat("SomeStruct{\n"
5142 " \"xxxxxxxxxxxxx\",\n"
5143 " \"yyyyyyyyyyyyy\",\n"
5144 " \"zzzzzzzzzzzzz\",\n"
5147 verifyFormat("new SomeStruct{\n"
5148 " \"xxxxxxxxxxxxx\",\n"
5149 " \"yyyyyyyyyyyyy\",\n"
5150 " \"zzzzzzzzzzzzz\",\n"
5154 verifyFormat("class SomeClass {\n"
5155 " SomeStruct s{\n"
5156 " \"xxxxxxxxxxxxx\",\n"
5157 " \"yyyyyyyyyyyyy\",\n"
5158 " \"zzzzzzzzzzzzz\",\n"
5159 " };\n"
5163 verifyFormat("SomeClass::SomeClass : strct{\n"
5164 " \"xxxxxxxxxxxxx\",\n"
5165 " \"yyyyyyyyyyyyy\",\n"
5166 " \"zzzzzzzzzzzzz\",\n"
5170 verifyFormat("SomeStruct s = SomeStruct{\n"
5171 " \"xxxxxxxxxxxxx\",\n"
5172 " \"yyyyyyyyyyyyy\",\n"
5173 " \"zzzzzzzzzzzzz\",\n"
5177 verifyFormat("SomeStruct s = {\n"
5178 " \"xxxxxxxxxxxxx\",\n"
5179 " \"yyyyyyyyyyyyy\",\n"
5180 " \"zzzzzzzzzzzzz\",\n"
5184 verifyFormat("s = {\n"
5185 " \"xxxxxxxxxxxxx\",\n"
5186 " \"yyyyyyyyyyyyy\",\n"
5187 " \"zzzzzzzzzzzzz\",\n"
5191 verifyFormat("return {\n"
5192 " \"xxxxxxxxxxxxx\",\n"
5193 " \"yyyyyyyyyyyyy\",\n"
5194 " \"zzzzzzzzzzzzz\",\n"
5198 verifyFormat("auto initializerList = {\n"
5199 " \"xxxxxxxxxxxxx\",\n"
5200 " \"yyyyyyyyyyyyy\",\n"
5201 " \"zzzzzzzzzzzzz\",\n"
5205 verifyFormat("func({\n"
5206 " \"xxxxxxxxxxxxx\",\n"
5207 " \"yyyyyyyyyyyyy\",\n"
5208 " \"zzzzzzzzzzzzz\",\n"
5212 verifyFormat("SomeStruct s = {\n"
5213 " {{init1, init2, init3, init4, init5},\n"
5216 verifyFormat("SomeStruct s = {\n"
5217 " {{\n"
5218 " .init1 = 1,\n"
5219 " .init2 = 2,\n"
5220 " .init3 = 3,\n"
5221 " .init4 = 4,\n"
5222 " .init5 = 5,\n"
5223 " },\n"
5226 verifyFormat("SomeArrayT a[3] = {\n"
5227 " {\n"
5228 " foo,\n"
5229 " bar,\n"
5230 " },\n"
5231 " {\n"
5232 " foo,\n"
5233 " bar,\n"
5234 " },\n"
5235 " SomeArrayT{},\n"
5238 verifyFormat("SomeArrayT a[3] = {\n"
5239 " {foo},\n"
5240 " {\n"
5241 " {\n"
5242 " init1,\n"
5243 " init2,\n"
5244 " init3,\n"
5245 " },\n"
5246 " {\n"
5247 " init1,\n"
5248 " init2,\n"
5249 " init3,\n"
5250 " },\n"
5251 " },\n"
5252 " {baz},\n"
5258 verifyFormat("SomeStruct s{\"xxxxxxxxxxxxx\", \"yyyyyyyyyyyyy\",\n"
5265 verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
5269 verifyFormat("somes Status::global_reps[3] = {\n"
5270 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
5271 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
5274 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
5275 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
5276 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
5278 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
5283 "SomeArrayOfSomeType a = {\n"
5284 " {{1, 2, 3},\n"
5285 " {1, 2, 3},\n"
5286 " {111111111111111111111111111111, 222222222222222222222222222222,\n"
5287 " 333333333333333333333333333333},\n"
5288 " {1, 2, 3},\n"
5291 "SomeArrayOfSomeType a = {\n"
5292 " {{1, 2, 3}},\n"
5293 " {{1, 2, 3}},\n"
5294 " {{111111111111111111111111111111, 222222222222222222222222222222,\n"
5295 " 333333333333333333333333333333}},\n"
5296 " {{1, 2, 3}},\n"
5299 verifyFormat("struct {\n"
5300 " unsigned bit;\n"
5301 " const char *const name;\n"
5302 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
5303 " {kOsWin, \"Windows\"},\n"
5304 " {kOsLinux, \"Linux\"},\n"
5306 verifyFormat("struct {\n"
5307 " unsigned bit;\n"
5308 " const char *const name;\n"
5309 "} kBitsToOs[] = {\n"
5310 " {kOsMac, \"Mac\"},\n"
5311 " {kOsWin, \"Windows\"},\n"
5312 " {kOsLinux, \"Linux\"},\n"
5313 " {kOsCrOS, \"Chrome OS\"},\n"
5319 " \\\n"
5324 verifyFormat("virtual void write(ELFWriter *writerrr,\n"
5328 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
5331 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
5341 verifyFormat("#define Q \\\n"
5342 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n"
5355 verifyFormat("#\n;\n;\n;");
5359 verifyFormat("#line 42 \"test\"", "# \\\n line \\\n 42 \\\n \"test\"");
5360 verifyFormat("#define A B", "# \\\n define \\\n A \\\n B",
5365 verifyFormat("#line 42 \"test\"", "# \\\n line \\\n 42 \\\n \"test\"");
5366 verifyFormat("#define A B", "# \\\n define \\\n A \\\n B");
5377 verifyFormat("const char *c = STRINGIFY(\n"
5379 "const char * c = STRINGIFY(\n"
5393 verifyFormat("#ifdef __linux__\n"
5394 "void foo() {\n"
5395 " int x = 0;\n"
5396 "}\n"
5397 "#define FOO\n"
5398 "#endif\n"
5399 "void bar() {\n"
5400 " int y = 0;\n"
5405 verifyFormat("#ifdef __linux__\n"
5406 "void foo() {\n"
5407 " int x = 0;\n"
5408 "}\n"
5409 "# define FOO foo\n"
5410 "#endif\n"
5411 "void bar() {\n"
5412 " int y = 0;\n"
5417 verifyFormat("#ifdef __linux__\n"
5418 "void foo() {\n"
5419 " int x = 0;\n"
5420 "}\n"
5421 " #define FOO foo\n"
5422 "#endif\n"
5423 "void bar() {\n"
5424 " int y = 0;\n"
5427 verifyFormat("#if 1\n"
5428 " // some comments\n"
5429 " // another\n"
5430 " #define foo 1\n"
5431 "// not a define comment\n"
5432 "void bar() {\n"
5433 " // comment\n"
5434 " int y = 0;\n"
5436 "#if 1\n"
5437 "// some comments\n"
5438 "// another\n"
5439 "#define foo 1\n"
5440 "// not a define comment\n"
5441 "void bar() {\n"
5442 " // comment\n"
5443 " int y = 0;\n"
5448 verifyFormat("#ifdef foo\n"
5449 "#define bar() \\\n"
5450 " if (A) { \\\n"
5451 " B(); \\\n"
5452 " } \\\n"
5453 " C();\n"
5456 verifyFormat("if (emacs) {\n"
5457 "#ifdef is\n"
5458 "#define lit \\\n"
5459 " if (af) { \\\n"
5460 " return duh(); \\\n"
5461 " }\n"
5462 "#endif\n"
5465 verifyFormat("#if abc\n"
5466 "#ifdef foo\n"
5467 "#define bar() \\\n"
5468 " if (A) { \\\n"
5469 " if (B) { \\\n"
5470 " C(); \\\n"
5471 " } \\\n"
5472 " } \\\n"
5473 " D();\n"
5474 "#endif\n"
5477 verifyFormat("#ifndef foo\n"
5478 "#define foo\n"
5479 "if (emacs) {\n"
5480 "#ifdef is\n"
5481 "#define lit \\\n"
5482 " if (af) { \\\n"
5483 " return duh(); \\\n"
5484 " }\n"
5485 "#endif\n"
5486 "}\n"
5489 verifyFormat("#if 1\n"
5490 "#define X \\\n"
5491 " { \\\n"
5492 " x; \\\n"
5493 " x; \\\n"
5494 " }\n"
5497 verifyFormat("#define X \\\n"
5498 " { \\\n"
5499 " x; \\\n"
5500 " x; \\\n"
5505 verifyFormat("#ifdef foo\n"
5506 "#define bar() \\\n"
5507 " if (A) { \\\n"
5508 " B(); \\\n"
5509 " } \\\n"
5510 " C();\n"
5514 verifyFormat("#ifdef foo\n"
5515 "#define bar() \\\n"
5516 " if (A) { \\\n"
5517 " B(); \\\n"
5518 " } \\\n"
5519 " C();\n"
5525 verifyFormat("#if 1\n"
5526 "#define X \\\n"
5527 " { \\\n"
5528 " x; \\\n"
5529 " x; \\\n"
5530 " }\n"
5533 verifyFormat("#define X \\\n"
5534 " { \\\n"
5535 " x; \\\n"
5536 " x; \\\n"
5543 verifyFormat("#ifdef foo\n"
5544 "# define bar() \\\n"
5545 " if (A) { \\\n"
5546 " B(); \\\n"
5547 " } \\\n"
5548 " C();\n"
5551 verifyFormat("#if abc\n"
5552 "# ifdef foo\n"
5553 "# define bar() \\\n"
5554 " if (A) { \\\n"
5555 " if (B) { \\\n"
5556 " C(); \\\n"
5557 " } \\\n"
5558 " } \\\n"
5559 " D();\n"
5560 "# endif\n"
5563 verifyFormat("#ifndef foo\n"
5564 "#define foo\n"
5565 "if (emacs) {\n"
5566 "#ifdef is\n"
5567 "# define lit \\\n"
5568 " if (af) { \\\n"
5569 " return duh(); \\\n"
5570 " }\n"
5571 "#endif\n"
5572 "}\n"
5575 verifyFormat("#define X \\\n"
5576 " { \\\n"
5577 " x; \\\n"
5578 " x; \\\n"
5584 verifyFormat("#ifdef foo\n"
5585 "# define bar() \\\n"
5586 " if (A) { \\\n"
5587 " B(); \\\n"
5588 " } \\\n"
5589 " C();\n"
5595 verifyFormat("#define X \\\n"
5596 " { \\\n"
5597 " x; \\\n"
5598 " x; \\\n"
5605 verifyFormat("if (emacs) {\n"
5606 "#ifdef is\n"
5607 " #define lit \\\n"
5608 " if (af) { \\\n"
5609 " return duh(); \\\n"
5610 " }\n"
5611 "#endif\n"
5614 verifyFormat("#if abc\n"
5615 " #ifdef foo\n"
5616 " #define bar() \\\n"
5617 " if (A) { \\\n"
5618 " B(); \\\n"
5619 " } \\\n"
5620 " C();\n"
5621 " #endif\n"
5624 verifyFormat("#if 1\n"
5625 " #define X \\\n"
5626 " { \\\n"
5627 " x; \\\n"
5628 " x; \\\n"
5629 " }\n"
5634 verifyFormat("#ifdef foo\n"
5635 " #define bar() \\\n"
5636 " if (A) { \\\n"
5637 " B(); \\\n"
5638 " } \\\n"
5639 " C();\n"
5645 verifyFormat("#if 1\n"
5646 " #define X \\\n"
5647 " { \\\n"
5648 " x; \\\n"
5649 " x; \\\n"
5650 " }\n"
5657 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
5658 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
5660 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
5662 verifyFormat("#define A A\n#define A A");
5663 verifyFormat("#define A(X) A\n#define A A");
5666 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
5670 verifyFormat("// somecomment\n"
5671 "#include \"a.h\"\n"
5672 "#define A( \\\n"
5673 " A, B)\n"
5674 "#include \"b.h\"\n"
5676 " // somecomment\n"
5677 " #include \"a.h\"\n"
5678 "#define A(A,\\\n"
5679 " B)\n"
5680 " #include \"b.h\"\n"
5688 verifyFormat("#define A \\\n"
5689 " c; \\\n"
5690 " e;\n"
5692 "#define A c; e;\n"
5698 verifyFormat("{\n"
5703 verifyFormat("int x,\n"
5704 "#define A\n"
5706 "int x,\n#define A\ny;");
5718 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
5719 verifyFormat("#define A \\\n"
5720 " { \\\n"
5721 " f(#c); \\\n"
5725 verifyFormat("#define A(X) \\\n"
5729 verifyFormat("#define A(a, b, c) \\\n"
5735 verifyFormat("{\n"
5736 " {\n"
5737 "#define GEN_ID(_x) char *_x{#_x}\n"
5738 " GEN_ID(one);\n"
5739 " }\n"
5756 "#define A \\\n"
5757 " \\\n"
5760 verifyNoChange("#define A \\\n"
5761 " \\\n"
5762 " a; \\\n"
5765 verifyNoChange("#define A \\\n"
5766 " a; \\\n"
5767 " \\\n"
5774 verifyFormat("#define SOMECASES \\\n"
5775 " case 1: \\\n"
5778 verifyFormat("#define MACRO(a) \\\n"
5779 " if (a) \\\n"
5780 " f(); \\\n"
5781 " else \\\n"
5785 verifyIncompleteFormat("#define STR(x) #x\n"
5787 verifyFormat("#pragma omp threadprivate( \\\n"
5792 verifyIncompleteFormat("({\n"
5793 "#define b \\\n"
5794 " } \\\n"
5795 " a\n"
5798 verifyFormat("#define A \\\n"
5799 " { \\\n"
5800 " {\n"
5801 "#define B \\\n"
5802 " } \\\n"
5805 verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
5806 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
5807 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
5808 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}");
5809 verifyNoCrash("#else\n"
5810 "#else\n"
5811 "#endif\n"
5813 verifyNoCrash("#else\n"
5814 "#if X\n"
5815 "#endif\n"
5817 verifyNoCrash("#else\n"
5818 "#endif\n"
5819 "#if X\n"
5821 verifyNoCrash("#if X\n"
5822 "#else\n"
5823 "#else\n"
5824 "#endif\n"
5826 verifyNoCrash("#if X\n"
5827 "#elif Y\n"
5828 "#elif Y\n"
5829 "#endif\n"
5831 verifyNoCrash("#endif\n"
5833 verifyNoCrash("#endif\n"
5835 verifyNoCrash("#endif\n"
5841 verifyFormat("class A : public QObject {\n"
5842 " Q_OBJECT\n"
5843 "\n"
5844 " A() {}\n"
5846 "class A : public QObject {\n"
5847 " Q_OBJECT\n"
5848 "\n"
5849 " A() {\n}\n"
5851 verifyFormat("MACRO\n"
5853 "MACRO\n"
5855 verifyFormat("SOME_MACRO\n"
5856 "namespace {\n"
5857 "void f();\n"
5859 "SOME_MACRO\n"
5860 " namespace {\n"
5861 "void f( );\n"
5867 verifyFormat("class A : public QObject {\n"
5868 " Q_Object A() {}\n"
5870 "class A : public QObject {\n"
5871 " Q_Object\n"
5872 " A() {\n}\n"
5876 verifyFormat("SOME_WEIRD_LOG_MACRO << SomeThing;", "SOME_WEIRD_LOG_MACRO\n"
5880 "GGGG(ffff(xxxxxxxxxxxxxxxxxxxx)->yyyyyyyyyyyyyyyyyyyy)\n"
5884 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
5885 "(n, buffers))",
5889 verifyNoChange("/**/ FOO(a)\n"
5894 verifyFormat("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
5895 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
5896 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
5897 "class X {};\n"
5898 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
5900 " INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
5901 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
5902 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
5903 " class X {};\n"
5904 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
5908 verifyFormat("int q() {\n"
5909 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
5910 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
5911 " IPC_END_MESSAGE_MAP()\n"
5913 "int q() {\n"
5914 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
5915 " IPC_MESSAGE_HANDLER(xxx, qqq)\n"
5916 " IPC_END_MESSAGE_MAP()\n"
5920 verifyFormat("#define LIST(L) \\\n"
5921 " L(A) \\\n"
5922 " L(B) \\\n"
5924 "#define LIST(L) \\\n"
5925 " L(A) \\\n"
5926 " L(B) \\\n"
5931 verifyFormat("int q() {\n"
5932 " f(x);\n"
5933 " f(x) {}\n"
5934 " f(x)->g();\n"
5935 " f(x)->*g();\n"
5936 " f(x).g();\n"
5937 " f(x) = x;\n"
5938 " f(x) += x;\n"
5939 " f(x) -= x;\n"
5940 " f(x) *= x;\n"
5941 " f(x) /= x;\n"
5942 " f(x) %= x;\n"
5943 " f(x) &= x;\n"
5944 " f(x) |= x;\n"
5945 " f(x) ^= x;\n"
5946 " f(x) >>= x;\n"
5947 " f(x) <<= x;\n"
5948 " f(x)[y].z();\n"
5949 " LOG(INFO) << x;\n"
5950 " ifstream(x) >> x;\n"
5952 "int q() {\n"
5953 " f(x)\n;\n"
5954 " f(x)\n {}\n"
5955 " f(x)\n->g();\n"
5956 " f(x)\n->*g();\n"
5957 " f(x)\n.g();\n"
5958 " f(x)\n = x;\n"
5959 " f(x)\n += x;\n"
5960 " f(x)\n -= x;\n"
5961 " f(x)\n *= x;\n"
5962 " f(x)\n /= x;\n"
5963 " f(x)\n %= x;\n"
5964 " f(x)\n &= x;\n"
5965 " f(x)\n |= x;\n"
5966 " f(x)\n ^= x;\n"
5967 " f(x)\n >>= x;\n"
5968 " f(x)\n <<= x;\n"
5969 " f(x)\n[y].z();\n"
5970 " LOG(INFO)\n << x;\n"
5971 " ifstream(x)\n >> x;\n"
5973 verifyFormat("int q() {\n"
5974 " F(x)\n"
5975 " if (1) {\n"
5976 " }\n"
5977 " F(x)\n"
5978 " while (1) {\n"
5979 " }\n"
5980 " F(x)\n"
5981 " G(x);\n"
5982 " F(x)\n"
5983 " try {\n"
5984 " Q();\n"
5985 " } catch (...) {\n"
5986 " }\n"
5988 "int q() {\n"
5989 "F(x)\n"
5990 "if (1) {}\n"
5991 "F(x)\n"
5992 "while (1) {}\n"
5993 "F(x)\n"
5994 "G(x);\n"
5995 "F(x)\n"
5996 "try { Q(); } catch (...) {}\n"
5998 verifyFormat("class A {\n"
5999 " A() : t(0) {}\n"
6000 " A(int i) noexcept() : {}\n"
6001 " A(X x)\n" // FIXME: function-level try blocks are broken.
6002 " try : t(0) {\n"
6003 " } catch (...) {\n"
6004 " }\n"
6006 "class A {\n"
6007 " A()\n : t(0) {}\n"
6008 " A(int i)\n noexcept() : {}\n"
6009 " A(X x)\n"
6010 " try : t(0) {} catch (...) {}\n"
6016 verifyFormat("void f()\n"
6017 "try\n"
6018 "{\n"
6020 "void f() try {\n"
6023 verifyFormat("class SomeClass {\n"
6024 "public:\n"
6025 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
6027 "class SomeClass {\n"
6028 "public:\n"
6029 " SomeClass()\n"
6030 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
6032 verifyFormat("class SomeClass {\n"
6033 "public:\n"
6034 " SomeClass()\n"
6035 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
6037 "class SomeClass {\n"
6038 "public:\n"
6039 " SomeClass()\n"
6040 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
6050 verifyFormat("FOO(a)\n"
6053 verifyFormat("FOO(a);\n"
6056 verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
6059 verifyFormat("FOO()\n"
6062 verifyFormat("FOO\n"
6065 verifyFormat("void f() {\n"
6066 " FOO(a)\n"
6067 " return a;\n"
6070 verifyFormat("FOO(a)\n"
6073 verifyFormat("int a = 0;\n"
6074 "FOO(b)\n"
6077 verifyFormat("int a = 0;\n"
6078 "int x = FOO(a)\n"
6081 verifyFormat("void foo(int a) { FOO(a) }\n"
6094 verifyFormat("#define A \\\n"
6095 " f({ \\\n"
6096 " g(); \\\n"
6104 verifyFormat("#ifdef _WIN32\n"
6105 "#define A 0\n"
6106 "#ifdef VAR2\n"
6107 "#define B 1\n"
6108 "#include <someheader.h>\n"
6109 "#define MACRO \\\n"
6110 " some_very_long_func_aaaaaaaaaa();\n"
6111 "#endif\n"
6112 "#else\n"
6113 "#define A 1\n"
6117 verifyFormat("#if 1\n"
6118 "# define __STR(x) #x\n"
6121 verifyFormat("#ifdef _WIN32\n"
6122 "# define A 0\n"
6123 "# ifdef VAR2\n"
6124 "# define B 1\n"
6125 "# include <someheader.h>\n"
6126 "# define MACRO \\\n"
6127 " some_very_long_func_aaaaaaaaaa();\n"
6128 "# endif\n"
6129 "#else\n"
6130 "# define A 1\n"
6133 verifyFormat("#if A\n"
6134 "# define MACRO \\\n"
6135 " void a(int x) { \\\n"
6136 " b(); \\\n"
6137 " c(); \\\n"
6138 " d(); \\\n"
6139 " e(); \\\n"
6140 " f(); \\\n"
6141 " }\n"
6145 verifyFormat("// file comment\n"
6146 "// file comment\n"
6147 "#ifndef HEADER_H\n"
6148 "#define HEADER_H\n"
6149 "code();\n"
6153 verifyFormat("#ifndef HEADER_H\n"
6154 "#define HEADER_H\n"
6155 "code();\n"
6160 verifyFormat("#ifndef NOT_GUARD\n"
6161 "# define FOO\n"
6162 "code();\n"
6167 verifyFormat("code();\n"
6168 "code();\n"
6169 "#ifndef NOT_GUARD\n"
6170 "# define NOT_GUARD\n"
6171 "code();\n"
6174 verifyFormat("#ifndef NOT_GUARD\n"
6175 "# define NOT_GUARD\n"
6176 "code();\n"
6177 "#endif\n"
6181 verifyFormat("#ifndef HEADER_H\n"
6182 "#define HEADER_H\n"
6183 "code();\n"
6187 verifyFormat("#ifndef NOT_GUARD\n"
6188 "# define NOT_GUARD\n"
6189 "code();\n"
6190 "#else\n"
6193 verifyFormat("#ifndef NOT_GUARD\n"
6194 "# define NOT_GUARD\n"
6195 "code();\n"
6196 "#elif FOO\n"
6200 verifyFormat("#ifndef FOO\n"
6201 "# define 1\n"
6205 verifyFormat("#ifndef FOO\n"
6206 "#define FOO\n"
6207 "#if 1\n"
6208 "int i;\n"
6209 "# define A 0\n"
6210 "#endif\n"
6214 verifyFormat("#if 1\n"
6215 "int x;\n"
6216 "#elif\n"
6217 "int y;\n"
6218 "#else\n"
6219 "int z;\n"
6226 verifyFormat("#ifndef NOT_GUARD\n"
6227 "code();\n"
6228 "#define NOT_GUARD\n"
6229 "code();\n"
6231 "#ifndef NOT_GUARD\n"
6232 "code();\n"
6233 "# define NOT_GUARD\n"
6234 "code();\n"
6241 verifyFormat("#ifdef WIN32\n"
6242 "# pragma once\n"
6243 "#endif\n"
6244 "#ifndef HEADER_H\n"
6245 "# define HEADER_H\n"
6246 "code();\n"
6248 "#ifdef WIN32\n"
6249 "# pragma once\n"
6250 "#endif\n"
6251 "#ifndef HEADER_H\n"
6252 "#define HEADER_H\n"
6253 "code();\n"
6259 verifyFormat("code();\n"
6260 "#ifndef HEADER_H\n"
6261 "#define HEADER_H\n"
6262 "code();\n"
6264 "code();\n"
6265 "#ifndef HEADER_H\n"
6266 "# define HEADER_H\n"
6267 "code();\n"
6275 "void f() {\n"
6276 "#if 1\n"
6277 "// Preprocessor aligned.\n"
6278 "# define A 0\n"
6279 " // Code. Separated by blank line.\n"
6280 "\n"
6281 "# define B 0\n"
6282 " // Code. Not aligned with #\n"
6283 "# define C 0\n"
6286 "void f() {\n"
6287 "#if 1\n"
6288 "// Preprocessor aligned.\n"
6289 "# define A 0\n"
6290 "// Code. Separated by blank line.\n"
6291 "\n"
6292 "# define B 0\n"
6293 " // Code. Not aligned with #\n"
6294 "# define C 0\n"
6302 "void f() {\n"
6303 "#if 1\n"
6304 "/* Preprocessor aligned. */\n"
6305 "# define A 0\n"
6306 " /* Code. Separated by blank line. */\n"
6307 "\n"
6308 "# define B 0\n"
6309 " /* Code. Not aligned with # */\n"
6310 "# define C 0\n"
6313 "void f() {\n"
6314 "#if 1\n"
6315 "/* Preprocessor aligned. */\n"
6316 "# define A 0\n"
6317 "/* Code. Separated by blank line. */\n"
6318 "\n"
6319 "# define B 0\n"
6320 " /* Code. Not aligned with # */\n"
6321 "# define C 0\n"
6329 "void f() {\n"
6330 "// Preprocessor aligned.\n"
6331 "#define A 0\n"
6332 " // Code. Separated by blank line.\n"
6333 "\n"
6334 "#define B 0\n"
6335 " // Code. Not aligned with #\n"
6336 "#define C 0\n";
6338 "void f() {\n"
6339 "// Preprocessor aligned.\n"
6340 "#define A 0\n"
6341 "// Code. Separated by blank line.\n"
6342 "\n"
6343 "#define B 0\n"
6344 " // Code. Not aligned with #\n"
6345 "#define C 0\n";
6355 verifyFormat("#ifdef _WIN32\n"
6356 "#\tdefine A 0\n"
6357 "#\tifdef VAR2\n"
6358 "#\t\tdefine B 1\n"
6359 "#\t\tinclude <someheader.h>\n"
6360 "#\t\tdefine MACRO \\\n"
6361 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
6362 "#\tendif\n"
6363 "#else\n"
6364 "#\tdefine A 1\n"
6370 verifyFormat("#ifndef HEADER_H\n"
6371 "#define HEADER_H\n"
6372 "#define A() \\\n"
6373 " int i; \\\n"
6374 " int j;\n"
6380 verifyFormat("#ifdef _WIN32\n"
6381 " #define A 0\n"
6382 " #ifdef VAR2\n"
6383 " #define B 1\n"
6384 " #include <someheader.h>\n"
6385 " #define MACRO \\\n"
6386 " some_very_long_func_aaaaaaaaaa();\n"
6387 " #endif\n"
6388 "#else\n"
6389 " #define A 1\n"
6392 verifyFormat("#if A\n"
6393 " #define MACRO \\\n"
6394 " void a(int x) { \\\n"
6395 " b(); \\\n"
6396 " c(); \\\n"
6397 " d(); \\\n"
6398 " e(); \\\n"
6399 " f(); \\\n"
6400 " }\n"
6407 const char *Expected = "void f() {\n"
6408 "// Aligned to preprocessor.\n"
6409 "#if 1\n"
6410 " // Aligned to code.\n"
6411 " int a;\n"
6412 " #if 1\n"
6413 " // Aligned to preprocessor.\n"
6414 " #define A 0\n"
6415 " // Aligned to code.\n"
6416 " int b;\n"
6417 " #endif\n"
6418 "#endif\n"
6420 const char *ToFormat = "void f() {\n"
6421 "// Aligned to preprocessor.\n"
6422 "#if 1\n"
6423 "// Aligned to code.\n"
6424 "int a;\n"
6425 "#if 1\n"
6426 "// Aligned to preprocessor.\n"
6427 "#define A 0\n"
6428 "// Aligned to code.\n"
6429 "int b;\n"
6430 "#endif\n"
6431 "#endif\n"
6437 const char *Expected = "void f() {\n"
6438 "/* Aligned to preprocessor. */\n"
6439 "#if 1\n"
6440 " /* Aligned to code. */\n"
6441 " int a;\n"
6442 " #if 1\n"
6443 " /* Aligned to preprocessor. */\n"
6444 " #define A 0\n"
6445 " /* Aligned to code. */\n"
6446 " int b;\n"
6447 " #endif\n"
6448 "#endif\n"
6450 const char *ToFormat = "void f() {\n"
6451 "/* Aligned to preprocessor. */\n"
6452 "#if 1\n"
6453 "/* Aligned to code. */\n"
6454 "int a;\n"
6455 "#if 1\n"
6456 "/* Aligned to preprocessor. */\n"
6457 "#define A 0\n"
6458 "/* Aligned to code. */\n"
6459 "int b;\n"
6460 "#endif\n"
6461 "#endif\n"
6468 verifyFormat("// Comment\n"
6469 "\n"
6470 "#if 1\n"
6481 verifyFormat("void f1() {\n"
6482 "#if 1\n"
6483 " int foo = 1;\n"
6484 " int foobar = 2;\n"
6485 "#endif\n"
6486 "}\n"
6487 "#if 1\n"
6488 "int baz = 3;\n"
6489 "#endif\n"
6490 "void f2() {\n"
6491 "#if 1\n"
6492 " char *foobarbaz = \"foobarbaz\";\n"
6493 " int quux = 4;\n"
6498 verifyFormat("void f1() {\n"
6499 "#if 1\n"
6500 "#else\n"
6501 " int foo = 1;\n"
6502 " int foobar = 2;\n"
6503 "#endif\n"
6504 "}\n"
6505 "#if 1\n"
6506 "#else\n"
6507 "int baz = 3;\n"
6508 "#endif\n"
6509 "void f2() {\n"
6510 "#if 1\n"
6511 "#else\n"
6512 " char *foobarbaz = \"foobarbaz\";\n"
6513 " int quux = 4;\n"
6516 verifyFormat("auto foo = [] { return; };\n"
6517 "#if FOO\n"
6518 "#else\n"
6519 "count = bar;\n"
6520 "mbid = bid;\n"
6525 verifyFormat("void f1() {\n"
6526 "#if 1\n"
6527 "#else\n"
6528 " int foo = 1;\n"
6529 " int foobar = 2;\n"
6530 "#endif\n"
6531 "}\n"
6532 "#if 1\n"
6533 "int baz = 3;\n"
6534 "#endif\n"
6535 "void f2() {\n"
6536 "#if 1\n"
6537 "#else\n"
6538 " // prevent alignment with #else in f1\n"
6539 " char *foobarbaz = \"foobarbaz\";\n"
6540 " int quux = 4;\n"
6545 verifyFormat("void f1() {\n"
6546 "#if 1\n"
6547 "#else\n"
6548 "#if 2\n"
6549 "#else\n"
6550 " int foo = 1;\n"
6551 " int foobar = 2;\n"
6552 "#endif\n"
6553 "#endif\n"
6554 "}\n"
6555 "#if 1\n"
6556 "#else\n"
6557 "#if 2\n"
6558 "int baz = 3;\n"
6559 "#endif\n"
6560 "#endif\n"
6561 "void f2() {\n"
6562 "#if 1\n"
6563 "#if 2\n"
6564 "#else\n"
6565 " // prevent alignment with #else in f1\n"
6566 " char *foobarbaz = \"foobarbaz\";\n"
6567 " int quux = 4;\n"
6568 "#endif\n"
6569 "#endif\n"
6573 verifyFormat("#if FOO\n"
6574 "int a = 1;\n"
6575 "#else\n"
6576 "int ab = 2;\n"
6577 "#endif\n"
6578 "#ifdef BAR\n"
6579 "int abc = 3;\n"
6580 "#elifdef BAZ\n"
6581 "int abcd = 4;\n"
6585 verifyFormat("void f() {\n"
6586 " if (foo) {\n"
6587 "#if FOO\n"
6588 " int a = 1;\n"
6589 "#else\n"
6590 " bool a = true;\n"
6591 "#endif\n"
6592 " int abc = 3;\n"
6593 "#ifndef BAR\n"
6594 " int abcd = 4;\n"
6595 "#elif BAZ\n"
6596 " bool abcd = true;\n"
6597 "#endif\n"
6598 " }\n"
6602 verifyFormat("void f() {\n"
6603 "#if FOO\n"
6604 " a = 1;\n"
6605 "#else\n"
6606 " ab = 2;\n"
6607 "#endif\n"
6608 "}\n"
6609 "void g() {\n"
6610 "#if BAR\n"
6611 " abc = 3;\n"
6612 "#elifndef BAZ\n"
6613 " abcd = 4;\n"
6614 "#endif\n"
6620 verifyFormat("{\n"
6621 " {\n"
6622 " a #c;\n"
6623 " }\n"
6628 verifyFormat("#define A \\\n { \\\n {\nint i;",
6630 verifyFormat("#define A \\\n } \\\n }\nint i;",
6636 verifyFormat("#define A \\\n int i; \\\n int j;",
6637 "#define A \\\nint i;\\\n int j;", Narrow);
6638 verifyFormat("#define A\n\nint i;", "#define A \\\n\n int i;");
6640 verifyFormat("/* \\ \\ \\\n */", "\\\n/* \\ \\ \\\n */");
6641 verifyNoChange("<a\n\\\\\n>");
6645 verifyFormat("#define MACRO(x) \\\n"
6646 "private: \\\n"
6651 verifyFormat("#define A \\\r\n int i; \\\r\n int j;",
6652 "#define A \\\r\nint i;\\\r\n int j;", Narrow);
6653 verifyFormat("#define A\r\n\r\nint i;", "#define A \\\r\n\r\n int i;");
6655 verifyFormat("/* \\ \\ \\\r\n */", "\\\r\n/* \\ \\ \\\r\n */");
6656 verifyNoChange("<a\r\n\\\\\r\n>");
6657 verifyFormat("#define MACRO(x) \\\r\n"
6658 "private: \\\r\n"
6662 constexpr StringRef Code{"#define A \\\n"
6663 " int a123; \\\n"
6664 " int a; \\\n"
6668 constexpr StringRef Code2{"#define A \\\n"
6669 " int a123; \\\n"
6670 " int a; \\\n"
6687 verifyNoChange("#define A \\\n"
6688 " class Foo { \\\n"
6689 " void bar(); \\\n"
6690 "\\\n"
6691 "\\\n"
6692 "\\\n"
6693 " public: \\\n"
6694 " void baz(); \\\n"
6700 verifyFormat("#define A \\\n"
6701 " int v( \\\n"
6702 " a); \\\n"
6709 " \\\n"
6710 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
6711 "\n"
6712 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
6715 "\\\n"
6716 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
6717 " \n"
6718 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
6723 verifyFormat("int\n"
6724 "#define A\n"
6726 "int\n#define A\na;");
6727 verifyFormat("functionCallTo(\n"
6728 " someOtherFunction(\n"
6729 " withSomeParameters, whichInSequence,\n"
6730 " areLongerThanALine(andAnotherCall,\n"
6731 "#define A B\n"
6732 " withMoreParamters,\n"
6733 " whichStronglyInfluenceTheLayout),\n"
6734 " andMoreParameters),\n"
6737 verifyFormat("Foo::Foo()\n"
6738 "#ifdef BAR\n"
6739 " : baz(0)\n"
6740 "#endif\n"
6741 "{\n"
6743 verifyFormat("void f() {\n"
6744 " if (true)\n"
6745 "#ifdef A\n"
6746 " f(42);\n"
6747 " x();\n"
6748 "#else\n"
6749 " g();\n"
6750 " x();\n"
6751 "#endif\n"
6753 verifyFormat("void f(param1, param2,\n"
6754 " param3,\n"
6755 "#ifdef A\n"
6756 " param4(param5,\n"
6757 "#ifdef A1\n"
6758 " param6,\n"
6759 "#ifdef A2\n"
6760 " param7),\n"
6761 "#else\n"
6762 " param8),\n"
6763 " param9,\n"
6764 "#endif\n"
6765 " param10,\n"
6766 "#endif\n"
6767 " param11)\n"
6768 "#else\n"
6769 " param12)\n"
6770 "#endif\n"
6771 "{\n"
6772 " x();\n"
6775 verifyFormat("#if 1\n"
6777 verifyFormat("#if 1\n"
6778 "#endif\n"
6779 "#if 1\n"
6780 "#else\n"
6782 verifyFormat("DEBUG({\n"
6783 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6784 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
6785 "});\n"
6786 "#if a\n"
6787 "#else\n"
6790 verifyIncompleteFormat("void f(\n"
6791 "#if A\n"
6792 ");\n"
6793 "#else\n"
6798 verifyFormat("#if 0\n"
6799 "{\n"
6800 "#else\n"
6801 "{\n"
6802 "#endif\n"
6803 " x;\n"
6806 verifyFormat("#if 0\n"
6807 "#endif\n"
6808 "#if X\n"
6809 "int something_fairly_long; // Align here please\n"
6812 verifyFormat("#if 0\n"
6813 "#endif\n"
6814 "#if X\n"
6815 "#else // Align\n"
6816 ";\n"
6819 verifyFormat("void SomeFunction(int param1,\n"
6820 " template <\n"
6821 "#ifdef A\n"
6822 "#if 0\n"
6823 "#endif\n"
6824 " MyType<Some>>\n"
6825 "#else\n"
6826 " Type1, Type2>\n"
6827 "#endif\n"
6828 " param2,\n"
6829 " param3) {\n"
6830 " f();\n"
6835 verifyFormat("#endif\n"
6842 verifyFormat("#if 0\n"
6843 "#elif 1\n"
6844 "#endif\n"
6845 "void foo() {\n"
6846 " if (test) foo2();\n"
6853 verifyFormat("functionCall({\n"
6854 " int i;\n"
6855 " int j;\n"
6857 verifyFormat("functionCall(\n"
6858 " {\n"
6859 " int i;\n"
6860 " int j;\n"
6861 " },\n"
6863 verifyFormat("functionA(functionB({\n"
6864 " int i;\n"
6865 " int j;\n"
6866 " }),\n"
6868 verifyFormat("functionCall(\n"
6869 " {\n"
6870 " int i;\n"
6871 " int j;\n"
6872 " },\n"
6873 " aaaa, bbbb, // comment\n"
6875 verifyFormat("functionA(functionB({\n"
6876 " int i;\n"
6877 " int j;\n"
6878 " }),\n"
6879 " aaaa, bbbb, // comment\n"
6882 verifyFormat("functionCall(aaaa, bbbb, {\n"
6883 " int i;\n"
6884 " int j;\n"
6887 "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
6888 " {\n"
6889 " int i; // break\n"
6890 " },\n"
6891 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
6893 verifyFormat("DEBUG({\n"
6894 " if (a)\n"
6895 " f();\n"
6900 verifyFormat("SOME_MACRO { int i; }\n"
6906 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
6907 " struct s {\n"
6908 " int i;\n"
6909 " };\n"
6910 " s kBitsToOs[] = {{10}};\n"
6911 " for (int i = 0; i < 10; ++i)\n"
6912 " return;\n"
6914 verifyFormat("call(parameter, {\n"
6915 " something();\n"
6916 " // Comment using all columns.\n"
6917 " somethingelse();\n"
6920 verifyFormat("DEBUG( //\n"
6922 verifyFormat("DEBUG( //\n"
6923 " {\n"
6924 " f(); //\n"
6925 " },\n"
6928 verifyFormat("call(parameter, {\n"
6929 " something();\n"
6930 " // Comment too\n"
6931 " // looooooooooong.\n"
6932 " somethingElse();\n"
6934 "call(parameter, {\n"
6935 " something();\n"
6936 " // Comment too looooooooooong.\n"
6937 " somethingElse();\n"
6941 verifyFormat("DEBUG({ // comment\n"
6942 " int i;\n"
6944 "DEBUG({ // comment\n"
6945 "int i;\n"
6947 verifyFormat("DEBUG({\n"
6948 " int i;\n"
6949 "\n"
6950 " // comment\n"
6951 " int j;\n"
6953 "DEBUG({\n"
6954 " int i;\n"
6955 "\n"
6956 " // comment\n"
6957 " int j;\n"
6960 verifyFormat("DEBUG({\n"
6961 " if (a)\n"
6962 " return;\n"
6964 verifyGoogleFormat("DEBUG({\n"
6965 " if (a) return;\n"
6969 verifyFormat("Debug(\n"
6970 " aaaaa,\n"
6971 " {\n"
6972 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
6973 " },\n"
6983 verifyFormat("#define MACRO() \\\n"
6984 " Debug(aaa, /* force line break */ \\\n"
6985 " { \\\n"
6986 " int i; \\\n"
6987 " int j; \\\n"
6989 "#define MACRO() Debug(aaa, /* force line break */ \\\n"
6993 verifyFormat("#define A \\\n"
6994 " [] { \\\n"
6995 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
6996 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
6998 "#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
7015 verifyFormat("if (a)\n"
7016 "{\n"
7017 "} else if (b)\n"
7018 "{\n"
7019 "} else\n"
7023 verifyFormat("if (a) {\n"
7024 "} else if (b) {\n"
7025 "} else {\n"
7029 verifyFormat("if (a) { }\n"
7030 "else if (b) { }\n"
7043 verifyFormat("FOO_BEGIN\n"
7044 " FOO_ENTRY\n"
7047 verifyFormat("FOO_BEGIN\n"
7048 " NESTED_FOO_BEGIN\n"
7049 " NESTED_FOO_ENTRY\n"
7050 " NESTED_FOO_END\n"
7053 verifyFormat("FOO_BEGIN(Foo, Bar)\n"
7054 " int x;\n"
7055 " x = 1;\n"
7060 verifyNoCrash("for (;;)\n"
7061 " FOO_BEGIN\n"
7062 " foo();\n"
7073 "void f() {\n"
7074 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
7075 " parameter, parameter, parameter)),\n"
7076 " SecondLongCall(parameter));\n"
7079 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7080 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
7081 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
7084 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7085 " [aaaaaaaaaaaaaaaaaaaaaaaa\n"
7086 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
7089 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
7090 " aaaaaaaaaaaaaaaaaaaaaaaa<\n"
7091 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
7093 verifyFormat("int a = bbbb && ccc &&\n"
7094 " fffff(\n"
7095 "#define A Just forcing a new line\n"
7101 "bool aaaaaaa =\n"
7102 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
7105 "bool aaaaaaa =\n"
7106 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
7109 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
7110 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
7112 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
7113 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
7116 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
7117 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
7120 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
7121 " aaaaaa) &&\n"
7123 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
7124 " aaaaaa) >>\n"
7126 verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
7127 " SourceMgr.getSpellingColumnNumber(\n"
7128 " TheLine.Last->FormatTok.Tok.getLocation()) -\n"
7131 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
7132 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
7133 " cccccc) {\n}");
7134 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
7135 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
7136 " cccccc) {\n}");
7137 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
7138 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
7139 " cccccc) {\n}");
7140 verifyFormat("b = a &&\n"
7141 " // Comment\n"
7147 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7148 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
7151 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7152 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
7155 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
7156 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
7159 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
7164 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7165 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
7169 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7170 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7171 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7177 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7178 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
7179 " 5) {\n"
7181 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7182 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
7183 " 5) {\n"
7189 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
7190 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
7191 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
7194 verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
7195 " .aaa(aaaaaaaaaaaaa) *\n"
7196 " aaaaaaa +\n"
7202 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7203 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7204 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
7205 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
7206 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
7207 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
7208 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
7209 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
7211 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
7212 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7213 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
7214 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
7215 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7216 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
7217 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
7218 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
7219 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
7220 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
7221 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7222 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
7223 verifyFormat("if () {\n"
7224 "} else if (aaaaa && bbbbb > // break\n"
7225 " ccccc) {\n"
7227 verifyFormat("if () {\n"
7228 "} else if constexpr (aaaaa && bbbbb > // break\n"
7229 " ccccc) {\n"
7231 verifyFormat("if () {\n"
7232 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
7233 " ccccc) {\n"
7235 verifyFormat("if () {\n"
7236 "} else if (aaaaa &&\n"
7237 " bbbbb > // break\n"
7238 " ccccc &&\n"
7239 " ddddd) {\n"
7243 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
7244 " b;\n"
7245 "return aaaaaaaaaaaaaaaaaaa +\n"
7259 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7260 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7261 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7262 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7263 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7264 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7265 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7266 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7269 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7270 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7271 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7272 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
7274 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7275 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7276 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7277 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
7279 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7280 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7281 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7282 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
7284 verifyFormat("if () {\n"
7285 "} else if (aaaaa\n"
7286 " && bbbbb // break\n"
7287 " > ccccc) {\n"
7290 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7293 verifyFormat("return (a)\n"
7294 " // comment\n"
7298 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7299 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7303 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7309 "unsigned ContentSize =\n"
7310 " sizeof(int16_t) // DWARF ARange version number\n"
7311 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
7312 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
7315 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
7320 verifyFormat("zzzzzzzzzz\n"
7321 " = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7331 verifyFormat("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
7332 "\t&& (someOtherLongishConditionPart1\n"
7344 verifyFormat("struct Foo {\n"
7345 " Foo(\n"
7346 " int arg1,\n"
7347 " int arg2)\n"
7348 " : Base(\n"
7349 " arg1,\n"
7350 " arg2) {}\n"
7353 verifyFormat("return abc\n"
7354 " ? foo(\n"
7355 " a,\n"
7356 " b,\n"
7357 " bar(\n"
7358 " abc))\n"
7368 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7369 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7370 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7371 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7372 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7373 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7374 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7375 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7378 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7379 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7380 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7381 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
7383 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7384 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7385 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7386 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
7388 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7389 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7390 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7391 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
7393 verifyFormat("if () {\n"
7394 "} else if (aaaaa\n"
7395 " && bbbbb // break\n"
7396 " > ccccc) {\n"
7399 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7402 verifyFormat("return (a)\n"
7403 " // comment\n"
7407 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7408 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7411 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
7412 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
7416 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7417 " : ccccccccccccccc ? dddddddddddddddddd\n"
7418 " : eeeeeeeeeeeeeeeeee)\n"
7419 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
7422 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7426 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
7431 verifyFormat("zzzzzzzzzzzzz\n"
7432 " = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7439 "unsigned ContentSize\n"
7440 " = sizeof(int16_t) // DWARF ARange version number\n"
7441 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
7442 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
7448 "unsigned ContentSize =\n"
7449 " sizeof(int16_t) // DWARF ARange version number\n"
7450 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
7451 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
7457 "unsigned ContentSize =\n"
7458 " sizeof(int16_t) // DWARF ARange version number\n"
7459 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
7460 " + sizeof(int8_t) // Pointer Size (in bytes)\n"
7468 verifyFormat("bool x = aaaaa //\n"
7469 " || bbbbb\n"
7470 " //\n"
7477 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
7478 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7482 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7483 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7484 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7485 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7486 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7487 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7488 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7489 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7493 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7494 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7497 verifyFormat("int a = aa\n"
7498 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
7503 verifyFormat("return (a > b\n"
7504 " // comment1\n"
7505 " // comment2\n"
7513 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7514 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7523 verifyFormat("void test() {\n"
7524 " someFunction(\n"
7525 " this + argument + is + quite\n"
7526 " + long + so + it + gets + wrapped\n"
7527 " + but + remains + bin - packed);\n"
7530 verifyFormat("void test() {\n"
7531 " someFunction(arg1,\n"
7532 " this + argument + is\n"
7533 " + quite + long + so\n"
7534 " + it + gets + wrapped\n"
7535 " + but + remains + bin\n"
7536 " - packed,\n"
7537 " arg3);\n"
7540 verifyFormat("void test() {\n"
7541 " someFunction(\n"
7542 " arg1,\n"
7543 " this + argument + has\n"
7544 " + anotherFunc(nested,\n"
7545 " calls + whose\n"
7546 " + arguments\n"
7547 " + are + also\n"
7548 " + wrapped,\n"
7549 " in + addition)\n"
7550 " + to + being + bin - packed,\n"
7551 " arg3);\n"
7556 verifyFormat("void test() {\n"
7557 " someFunction(\n"
7558 " arg1,\n"
7559 " this + argument + has +\n"
7560 " anotherFunc(nested,\n"
7561 " calls + whose +\n"
7562 " arguments +\n"
7563 " are + also +\n"
7564 " wrapped,\n"
7565 " in + addition) +\n"
7566 " to + being + bin - packed,\n"
7567 " arg3);\n"
7575 verifyFormat("bool b =\n"
7576 " is_default_constructible_v<hash<T>> and\n"
7577 " is_copy_constructible_v<hash<T>> and\n"
7578 " is_move_constructible_v<hash<T>> and\n"
7579 " is_copy_assignable_v<hash<T>> and\n"
7580 " is_move_assignable_v<hash<T>> and\n"
7581 " is_destructible_v<hash<T>> and\n"
7582 " is_swappable_v<hash<T>> and\n"
7587 verifyFormat("bool b = is_default_constructible_v<hash<T>>\n"
7588 " and is_copy_constructible_v<hash<T>>\n"
7589 " and is_move_constructible_v<hash<T>>\n"
7590 " and is_copy_assignable_v<hash<T>>\n"
7591 " and is_move_assignable_v<hash<T>>\n"
7592 " and is_destructible_v<hash<T>>\n"
7593 " and is_swappable_v<hash<T>>\n"
7598 verifyFormat("bool b = is_default_constructible_v<hash<T>>\n"
7599 " and is_copy_constructible_v<hash<T>>\n"
7600 " and is_move_constructible_v<hash<T>>\n"
7601 " and is_copy_assignable_v<hash<T>>\n"
7602 " and is_move_assignable_v<hash<T>>\n"
7603 " and is_destructible_v<hash<T>>\n"
7604 " and is_swappable_v<hash<T>>\n"
7613 verifyFormat("Constructor()\n"
7616 verifyFormat("Constructor()\n"
7620 verifyFormat("template <typename T>\n"
7625 "SomeClass::Constructor()\n"
7629 "SomeClass::Constructor()\n"
7630 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
7633 "SomeClass::Constructor()\n"
7634 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
7636 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7637 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7640 verifyFormat("Constructor()\n"
7641 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
7642 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7643 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
7646 verifyFormat("Constructor()\n"
7647 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7650 verifyFormat("Constructor(int Parameter = 0)\n"
7651 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
7653 verifyFormat("Constructor()\n"
7654 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
7657 verifyFormat("Constructor()\n"
7658 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7663 verifyFormat("Constructor()\n"
7664 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
7665 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
7670 verifyFormat("MyClass::MyClass()\n"
7671 " : a(a),\n"
7672 " b(b),\n"
7675 verifyFormat("MyClass::MyClass()\n"
7676 " : a(a), // comment\n"
7677 " b(b),\n"
7680 verifyFormat("MyClass::MyClass(int a)\n"
7681 " : b(a), // comment\n"
7682 " c(a + 1) { // lined up\n"
7685 verifyFormat("Constructor()\n"
7690 verifyFormat("SomeClass::Constructor()\n"
7691 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
7692 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
7695 verifyFormat("SomeClass::Constructor()\n"
7696 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
7697 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
7700 verifyFormat("MyClass::MyClass(int var)\n"
7701 " : some_var_(var), // 4 space indent\n"
7702 " some_other_var_(var + 1) { // lined up\n"
7705 verifyFormat("Constructor()\n"
7706 " : aaaaa(aaaaaa),\n"
7707 " aaaaa(aaaaaa),\n"
7708 " aaaaa(aaaaaa),\n"
7709 " aaaaa(aaaaaa),\n"
7712 verifyFormat("Constructor()\n"
7713 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
7718 "Constructor()\n"
7719 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
7720 " aaaaaaaaaaa().aaa(),\n"
7724 verifyFormat("Constructor()\n"
7725 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
7729 verifyFormat("Constructor()\n"
7730 " : // Comment forcing unwanted break.\n"
7732 "Constructor() :\n"
7733 " // Comment forcing unwanted break.\n"
7749 verifyFormat("Constructor()\n"
7755 verifyFormat("Constructor()\n"
7756 " : aaaaaaaaaaaaaaaaaaaa(a)\n"
7762 verifyFormat("Constructor()\n"
7765 verifyFormat("Constructor()\n"
7768 verifyFormat("Constructor()\n"
7769 " : aaaaaaaaaaaaaaaaaaaa(a)\n"
7770 " , bbbbbbbbbbbbbbbbbbbbb(b)\n"
7776 verifyFormat("Constructor()\n"
7781 verifyFormat("Constructor()\n"
7782 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
7787 verifyFormat("Constructor()\n"
7790 verifyFormat("Constructor()\n"
7793 verifyFormat("Constructor()\n"
7794 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
7795 " bbbbbbbbbbbbbbbbbbbbb(b),\n"
7801 verifyFormat("Constructor() :\n"
7806 verifyFormat("Constructor() :\n"
7807 " aaaaaaaaaaaaaaaaaa(a),\n"
7812 verifyFormat("Constructor() :\n"
7815 verifyFormat("Constructor() :\n"
7818 verifyFormat("Constructor() :\n"
7819 " aaaaaaaaaaaaaaaaaaaa(a),\n"
7820 " bbbbbbbbbbbbbbbbbbbbb(b),\n"
7831 verifyFormat("SomeClassWithALongName::Constructor(\n"
7832 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
7833 " : aaaaaaaaaaaaaaaaaaaa(a)\n"
7838 verifyFormat("SomeClassWithALongName::Constructor(\n"
7839 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
7840 " int bbbbbbbbbbbbb,\n"
7841 " int cccccccccccccccc)\n"
7846 verifyFormat("SomeClassWithALongName::Constructor(\n"
7847 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
7848 " int bbbbbbbbbbbbb,\n"
7849 " int cccccccccccccccc)\n"
7855 verifyFormat("SomeClassWithALongName::Constructor(\n"
7856 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
7857 " int bbbbbbbbbbbbb)\n"
7858 " : aaaaaaaaaaaaaaaaaaaa(a)\n"
7865 verifyFormat("SomeClassWithALongName::Constructor(\n"
7866 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
7867 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
7872 verifyFormat("SomeClassWithALongName::Constructor(\n"
7873 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
7874 " int bbbbbbbbbbbbb,\n"
7875 " int cccccccccccccccc)\n"
7880 verifyFormat("SomeClassWithALongName::Constructor(\n"
7881 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
7882 " int bbbbbbbbbbbbb,\n"
7883 " int cccccccccccccccc)\n"
7889 verifyFormat("SomeClassWithALongName::Constructor(\n"
7890 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
7891 " int bbbbbbbbbbbbb)\n"
7892 " : aaaaaaaaaaaaaaaaaaaa(a),\n"
7898 verifyFormat("SomeClassWithALongName::Constructor(\n"
7899 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
7900 " aaaaaaaaaaaaaaaaaaaa(a),\n"
7905 verifyFormat("SomeClassWithALongName::Constructor(\n"
7906 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
7907 " int bbbbbbbbbbbbb,\n"
7908 " int cccccccccccccccc) :\n"
7913 verifyFormat("SomeClassWithALongName::Constructor(\n"
7914 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
7915 " int bbbbbbbbbbbbb,\n"
7916 " int cccccccccccccccc) :\n"
7922 verifyFormat("SomeClassWithALongName::Constructor(\n"
7923 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
7924 " int bbbbbbbbbbbbb) :\n"
7925 " aaaaaaaaaaaaaaaaaaaa(a),\n"
7932 verifyNoChange("Foo(Bar bar, Baz baz)\n"
7947 verifyFormat("void foo() {\n"
7948 " FunctionCallWithReallyLongName(\n"
7949 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
7953 verifyFormat("void foo() {\n"
7954 " FunctionCallWithReallyLongName(\n"
7955 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7956 " bbbbbbbbbbbb);\n"
7961 verifyFormat("void foo() {\n"
7962 " auto VariableWithReallyLongName = {\n"
7963 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
7967 verifyFormat("void foo() {\n"
7968 " auto VariableWithReallyLongName = {\n"
7969 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7970 " bbbbbbbbbbbb};\n"
7979 verifyFormat("void FunctionCallWithReallyLongName(\n"
7983 verifyFormat("void FunctionCallWithReallyLongName(\n"
7984 " int aaaaaaaaaaaaaaaaaaaaaaa,\n"
7993 StringRef Input = "functionCall(paramA, paramB, paramC);\n"
7997 verifyFormat(StringRef("functionCall(paramA, paramB,\n"
7998 " paramC);\n"
7999 "void functionDecl(int A, int B,\n"
8003 verifyFormat(StringRef("functionCall(paramA, paramB,\n"
8004 " paramC);\n"
8005 "void functionDecl(int A, int B,\n"
8011 verifyFormat(StringRef("functionCall(\n"
8012 " paramA, paramB, paramC);\n"
8013 "void functionDecl(\n"
8017 verifyFormat("functionCall(\n"
8018 " paramA, paramB, paramC\n"
8019 ");\n"
8020 "void functionDecl(\n"
8021 " int A, int B, int C\n"
8029 verifyFormat(StringRef("functionCall(\n"
8030 " paramA, paramB, paramC);\n"
8031 "void functionDecl(\n"
8037 verifyFormat(StringRef("functionCall(paramA, paramB,\n"
8038 " paramC);\n"
8039 "void functionDecl(int A, int B,\n"
8043 verifyFormat(StringRef("functionCall(\n"
8044 " paramA, paramB, paramC);\n"
8045 "void functionDecl(\n"
8051 StringRef Input = "void functionDecl(paramA, paramB, paramC);\n"
8052 "void emptyFunctionDefinition() {}\n"
8053 "void functionDefinition(int A, int B, int C) {}\n"
8060 verifyFormat("void functionDecl(paramA, paramB, paramC);\n"
8061 "void emptyFunctionDefinition() {}\n"
8062 "void functionDefinition(\n"
8063 " int A, int B, int C) {}\n"
8064 "Class::Class(\n"
8065 " int A, int B)\n"
8072 verifyFormat("void functionDecl(paramA, paramB, paramC);\n"
8073 "void emptyFunctionDefinition() {}\n"
8074 "void functionDefinition(\n"
8075 " int A,\n"
8076 " int B,\n"
8077 " int C) {}\n"
8078 "Class::Class(\n"
8079 " int A,\n"
8080 " int B)\n"
8090 verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n"
8093 verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n"
8096 verifyFormat("asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
8097 " \"cpuid\\n\\t\"\n"
8098 " \"xchgq\\t%%rbx %%rsi\\n\\t\",\n"
8106 verifyFormat("asm volatile(\"string\",\n"
8107 " :\n"
8110 verifyFormat("asm volatile(\"string\",\n"
8111 " : val1\n"
8116 verifyFormat("asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
8117 " \"cpuid\\n\\t\"\n"
8118 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
8119 " : \"=a\"(*rEAX)\n"
8122 verifyFormat("asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
8123 " \"cpuid\\n\\t\"\n"
8124 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
8125 " :\n"
8128 verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n"
8129 " :\n"
8132 verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n"
8133 " : val1\n"
8145 verifyFormat("Constructor() :\n"
8148 verifyFormat("Constructor() :\n"
8152 verifyFormat("template <typename T>\n"
8156 "Class::Class(int some, int arguments, int loooooooooooooooooooong,\n"
8157 " int mooooooooooooore) noexcept :\n"
8162 "SomeClass::Constructor() :\n"
8166 "SomeClass::Constructor() : // NOLINT\n"
8172 "SomeClass::Constructor() :\n"
8176 "SomeClass::Constructor() : // NOLINT\n"
8182 "SomeClass::Constructor() :\n"
8187 "SomeClass::Constructor() :\n"
8188 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
8192 "SomeClass::Constructor() :\n"
8193 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
8197 "Ctor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8201 verifyFormat("Constructor() :\n"
8202 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
8203 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8204 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
8208 verifyFormat("Constructor() :\n"
8209 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8213 verifyFormat("Constructor(int Parameter = 0) :\n"
8214 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
8217 verifyFormat("Constructor() :\n"
8218 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
8221 verifyFormat("Constructor() :\n"
8222 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8228 verifyFormat("Constructor() :\n"
8229 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
8230 " aaaaaaaaaaa(aaaaaaaaaaa),\n"
8236 verifyFormat("SomeClass::Constructor() :\n"
8237 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
8238 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
8241 verifyFormat("SomeClass::Constructor() :\n"
8242 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
8243 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
8246 verifyFormat("Foo::Foo(int i, int j) : // NOLINT\n"
8247 " i(i), // comment\n"
8250 verifyFormat("MyClass::MyClass(int var) :\n"
8251 " some_var_(var), // 4 space indent\n"
8252 " some_other_var_(var + 1) { // lined up\n"
8255 verifyFormat("Constructor() :\n"
8256 " aaaaa(aaaaaa),\n"
8257 " aaaaa(aaaaaa),\n"
8258 " aaaaa(aaaaaa),\n"
8259 " aaaaa(aaaaaa),\n"
8262 verifyFormat("Constructor() :\n"
8263 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
8267 verifyFormat("Constructor() :\n"
8268 " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
8269 " aaaaaaaaaaa().aaa(),\n"
8273 verifyFormat("Constructor() :\n"
8274 " aaaaaaaaaaaaaaaaaaaa(a),\n"
8278 verifyFormat("Constructor() :\n"
8279 " // Comment forcing unwanted break.\n"
8282 verifyFormat("Constructor() : // NOLINT\n"
8286 " on a single\n"
8287 " // line.\n"
8290 " on a single line.\n"
8295 verifyFormat("SomeClass::Constructor() :\n"
8298 verifyFormat("SomeClass::Constructor() noexcept :\n"
8301 verifyFormat("SomeClass::Constructor() :\n"
8304 verifyFormat("SomeClass::Constructor() :\n"
8305 " a(a) {\n"
8306 " foo();\n"
8307 " bar();\n"
8312 verifyFormat("SomeClass::Constructor() :\n"
8313 " a(a), b(b), c(c) {\n"
8316 verifyFormat("SomeClass::Constructor() :\n"
8317 " a(a) {\n"
8325 verifyFormat("SomeClass::Constructor() :\n"
8326 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8334 "class SomeClass\n"
8335 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8340 "class SomeClass\n"
8341 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8346 "class SomeClass :\n"
8347 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8352 "class SomeClass\n"
8353 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8366 "extern CFRunLoopTimerRef\n"
8367 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
8368 " CFTimeInterval interval, CFOptionFlags flags,\n"
8369 " CFIndex order, CFRunLoopTimerCallBack callout,\n"
8374 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
8375 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
8376 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
8377 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
8381 "aaaaa(\n"
8382 " aaaaa,\n"
8383 " aaaaa(\n"
8384 " aaaaa,\n"
8385 " aaaaa(\n"
8386 " aaaaa,\n"
8387 " aaaaa(\n"
8388 " aaaaa,\n"
8389 " aaaaa(\n"
8390 " aaaaa,\n"
8391 " aaaaa(\n"
8392 " aaaaa,\n"
8393 " aaaaa(\n"
8394 " aaaaa,\n"
8395 " aaaaa(\n"
8396 " aaaaa,\n"
8397 " aaaaa(\n"
8398 " aaaaa,\n"
8399 " aaaaa(\n"
8400 " aaaaa,\n"
8401 " aaaaa(\n"
8402 " aaaaa,\n"
8403 " aaaaa(\n"
8404 " aaaaa,\n"
8408 "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n"
8409 " a),\n"
8410 " a),\n"
8411 " a),\n"
8412 " a),\n"
8413 " a),\n"
8414 " a),\n"
8415 " a),\n"
8416 " a),\n"
8417 " a),\n"
8418 " a),\n"
8419 " a),\n"
8420 " a),\n"
8421 " a),\n"
8422 " a),\n"
8423 " a),\n"
8424 " a),\n"
8432 std::string input = "Constructor()\n"
8433 " : aaaa(a,\n";
8435 input += " a,\n";
8445 "void f() {\n"
8446 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
8447 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
8448 " f();\n"
8450 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
8451 " Intervals[i - 1].getRange().getLast()) {\n}");
8457 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
8459 verifyFormat("template <class TemplateIt>\n"
8460 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
8465 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8470 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
8475 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8476 "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
8483 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
8484 " Cccccccccccccc cccccccccc,\n"
8485 " Cccccccccccccc cccccccccc,\n"
8486 " Cccccccccccccc cccccccccc,\n"
8489 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8490 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
8491 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
8494 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
8495 " Cccccccccccccc cccccccccc,\n"
8496 " Cccccccccccccc cccccccccc,\n"
8497 " Cccccccccccccc cccccccccc,\n"
8498 " Cccccccccccccc cccccccccc,\n"
8499 " Cccccccccccccc cccccccccc,\n"
8501 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
8502 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
8503 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
8504 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
8508 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8509 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8510 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8512 verifyFormat("void SomeLoooooooooooongFunction(\n"
8513 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8514 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8518 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
8520 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
8522 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
8525 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
8528 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
8530 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8532 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
8535 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
8536 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8538 verifyGoogleFormat("template <typename T>\n"
8539 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8540 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
8545 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8548 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
8556 verifyFormat("const aaaa::bbbbbbb &\n"
8557 "ccccccccc::operator++() {\n"
8558 " stuff();\n"
8560 "const aaaa::bbbbbbb\n"
8571 verifyFormat("struct S {\n"
8572 " auto bar() const -> int;\n"
8574 verifyFormat("template <size_t Order, typename T>\n"
8575 "auto load_img(const std::string &filename)\n"
8577 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
8580 verifyFormat("template <typename T>\n"
8581 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
8585 verifyFormat("#define MAKE_DEF(NAME) \\\n"
8601 "template <class... T>\n"
8625 verifyFormat("void someLongFunction(\n"
8626 " int someLoooooooooooooongParameter) const {\n}",
8628 verifyFormat("LoooooongReturnType\n"
8631 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
8634 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
8636 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
8638 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
8640 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
8643 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
8647 verifyFormat("void someLongFunction(\n"
8650 verifyFormat("void someLongFunction(\n"
8653 verifyFormat("void someLongFunction(\n"
8656 verifyFormat("void someLongFunction(\n"
8659 verifyFormat("void someLongFunction(\n"
8662 verifyFormat("void someLongFunction(\n"
8665 verifyFormat("void someLongFunction(\n"
8670 verifyFormat("void someLongFunction(\n"
8671 " int someLongParameter) const\n"
8672 "{\n"
8677 verifyFormat("void someLongFunction(\n"
8678 " int someLongParameter) const\n"
8679 " {\n"
8684 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
8685 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8690 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8692 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
8694 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
8696 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
8701 "void aaaaaaaaaaaaaaaaaa()\n"
8702 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
8704 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8710 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8714 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8718 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
8722 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
8727 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8731 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8735 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ABSL_GUARDED_BY(aaaaaaaaaaaa) =\n"
8739 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ABSL_GUARDED_BY(aaaaaaaaaaaa) =\n"
8745 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
8747 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
8749 verifyFormat("template <typename T>\n"
8750 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
8754 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8756 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
8758 verifyFormat("MACRO(abc).function() // wrap\n"
8760 verifyFormat("MACRO(abc)->function() // wrap\n"
8762 verifyFormat("MACRO(abc)::function() // wrap\n"
8768 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
8769 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
8770 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
8771 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8772 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
8776 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8779 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8780 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8784 "aaaaaaaa(aaaaaaaaaaaaa,\n"
8785 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8786 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
8787 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8790 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
8794 "void f() {\n"
8795 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8796 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
8799 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8802 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8805 "aaaaaa(aaa,\n"
8806 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8807 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
8809 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
8810 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8814 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
8816 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
8818 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
8824 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
8825 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
8826 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
8829 verifyFormat("{\n {\n {\n"
8830 " Annotation.SpaceRequiredBefore =\n"
8831 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
8832 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
8833 " }\n }\n}");
8836 verifyFormat("f(g(h(a, // comment\n"
8837 " b, c),\n"
8838 " d, e),\n"
8840 "f(g(h(a, // comment\n"
8845 "const int kTrackingOptions = NSTrackingMouseMoved |\n"
8846 " NSTrackingMouseEnteredAndExited |\n"
8854 verifyFormat("void f() {\n"
8855 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
8856 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
8859 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
8860 " int aaaaaaaaaaaaaaaaaaaa,\n"
8865 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8873 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
8877 "void fffffffffff(\n"
8878 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
8886 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
8887 " aaaaaaaaaaaaaaaaaaaa,\n"
8890 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
8891 " aaaaaaaaaaaaa,\n"
8895 "aaaaaaaa(aaaaaaaaaaaaa,\n"
8896 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8897 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
8898 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8901 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
8904 verifyFormat("void f() {\n"
8905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8906 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
8911 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8912 " aaaaaaaaaaaa,\n"
8916 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
8917 " ddddddddddddddddddddddddddddd),\n"
8921 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
8922 " aaaaaaaaaaaaaaaaaaaaaaa,\n"
8923 " aaaaaaaaaaaaaaaaaaaaaaa>\n"
8926 verifyFormat("a(\"a\"\n"
8927 " \"a\",\n"
8931 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
8932 " aaaaaaaaa,\n"
8936 "void f() {\n"
8937 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
8938 " .aaaaaaa();\n"
8942 "template <class SomeType, class SomeOtherType>\n"
8950 verifyFormat("void f(int a,\n"
8953 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8954 " int bbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8962 "void someLongFunctionName(\n"
8963 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8968 "void someLongFunctionName(\n"
8969 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8970 " int b\n"
8978 verifyFormat("void f(int a,\n"
8979 " int b) {\n"
8980 " f(a, b);\n"
8986 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8987 " int bbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8988 " int cccccccccccccccccccccccc) {\n"
8989 " f(aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8990 " cccccccccccccccccccccccc);\n"
8994 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8995 " int bbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8996 " int cccccccccccccccccccccccc) {\n"
8997 " f(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8998 " bbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8999 " cccccccccccccccccccccccc);\n"
9006 verifyFormat("void f(\n"
9007 " int a,\n"
9008 " int b) {\n"
9009 " f(a, b);\n"
9018 "void someLongFunctionName(\n"
9019 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9020 " int b) {\n"
9021 " someLongFunctionName(\n"
9022 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, b);\n"
9027 "void someLongFunctionName(\n"
9028 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9029 " int b\n"
9030 ") {\n"
9031 " someLongFunctionName(\n"
9032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, b\n"
9033 " );\n"
9041 verifyFormat("aaa(aaaa,\n"
9042 " aaaa,\n"
9043 " aaaa);\n"
9044 "aaa(aaaa,\n"
9045 " aaaa,\n"
9047 "aaa(aaaa,\n" // one-per-line
9048 " aaaa,\n"
9049 " aaaa );\n"
9052 verifyFormat("aaa(aaaa, aaaa,\n"
9053 " aaaa);\n"
9054 "aaa(aaaa, aaaa,\n"
9056 "aaa(aaaa, aaaa,\n" // bin-packed
9057 " aaaa );\n"
9065 verifyFormat("export {\n"
9066 " int x;\n"
9067 " int y;\n"
9069 "export {\n"
9070 "int x;\n"
9071 "int y;\n"
9076 verifyFormat("export {\n"
9077 "int x;\n"
9078 "int y;\n"
9080 "export {\n"
9081 " int x;\n"
9082 " int y;\n"
9092 verifyFormat("export {\n"
9096 verifyFormat("export {\n"
9097 "int x;\n"
9101 verifyFormat("export {\n"
9102 "int x;\n"
9104 "export\n"
9105 "{\n"
9106 "int x;\n"
9110 verifyFormat("export {\n"
9114 verifyFormat("export {\n"
9115 "int x;\n"
9121 "export {\n"
9126 "export {\n"
9127 "int x;\n"
9132 "export\n"
9133 "{\n"
9134 "int x;\n"
9139 "export {\n"
9144 "export {\n"
9145 "int x;\n"
9151 "export {\n"
9155 verifyFormat("export {\n"
9156 "int x;\n"
9160 verifyFormat("export {\n"
9161 "int x;\n"
9163 "export\n"
9164 "{\n"
9165 "int x;\n"
9171 verifyFormat("export {\n"
9172 "int x;\n"
9178 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
9179 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
9180 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
9181 " .StartsWith(\".init\", ORDER_INIT)\n"
9182 " .StartsWith(\".fini\", ORDER_FINI)\n"
9183 " .StartsWith(\".hash\", ORDER_HASH)\n"
9186 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
9188 verifyFormat("aaaaaaa->aaaaaaa\n"
9189 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9190 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
9193 "aaaaaaa->aaaaaaa\n"
9194 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
9197 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
9200 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
9201 " aaaaaa->aaaaaaaaaaaa()\n"
9202 " ->aaaaaaaaaaaaaaaa(\n"
9203 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
9206 "void f() {\n"
9207 " someo->Add((new util::filetools::Handler(dir))\n"
9208 " ->OnEvent1(NewPermanentCallback(\n"
9209 " this, &HandlerHolderClass::EventHandlerCBA))\n"
9210 " ->OnEvent2(NewPermanentCallback(\n"
9211 " this, &HandlerHolderClass::EventHandlerCBB))\n"
9212 " ->OnEvent3(NewPermanentCallback(\n"
9213 " this, &HandlerHolderClass::EventHandlerCBC))\n"
9214 " ->OnEvent5(NewPermanentCallback(\n"
9215 " this, &HandlerHolderClass::EventHandlerCBD))\n"
9216 " ->OnEvent6(NewPermanentCallback(\n"
9217 " this, &HandlerHolderClass::EventHandlerCBE)));\n"
9222 verifyFormat("aaaaaaaaaaaaaaa()\n"
9223 " .aaaaaaaaaaaaaaa()\n"
9224 " .aaaaaaaaaaaaaaa()\n"
9225 " .aaaaaaaaaaaaaaa()\n"
9227 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
9228 " .aaaaaaaaaaaaaaa()\n"
9229 " .aaaaaaaaaaaaaaa()\n"
9231 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
9232 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
9234 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
9235 " ->aaaaaaaaaaaaaae(0)\n"
9239 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
9240 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
9242 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
9243 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
9245 verifyFormat("aaa()\n"
9246 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
9247 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
9250 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
9251 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
9253 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
9254 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
9258 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
9263 "return !soooooooooooooome_map\n"
9264 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
9267 "return aaaaaaaaaaaaaaaa\n"
9268 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
9271 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
9273 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
9275 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
9278 verifyFormat("aaaaaaaaaaaaaaaaaa\n"
9279 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
9282 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9283 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
9287 verifyFormat("test() {\n"
9288 " ([]() -> {\n"
9289 " int b = 32;\n"
9290 " return 3;\n"
9291 " }).foo();\n"
9293 verifyFormat("test() {\n"
9294 " (\n"
9295 " []() -> {\n"
9296 " int b = 32;\n"
9297 " return 3;\n"
9298 " },\n"
9299 " foo, bar)\n"
9300 " .foo();\n"
9302 verifyFormat("test() {\n"
9303 " ([]() -> {\n"
9304 " int b = 32;\n"
9305 " return 3;\n"
9306 " })\n"
9307 " .foo()\n"
9308 " .bar();\n"
9310 verifyFormat("test() {\n"
9311 " ([]() -> {\n"
9312 " int b = 32;\n"
9313 " return 3;\n"
9314 " })\n"
9315 " .foo(\"aaaaaaaaaaaaaaaaa\"\n"
9316 " \"bbbb\");\n"
9323 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
9324 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
9326 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
9327 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
9329 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
9330 " ccccccccccccccccccccccccc) {\n}");
9331 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
9332 " ccccccccccccccccccccccccc) {\n}");
9334 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
9335 " ccccccccccccccccccccccccc) {\n}");
9336 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
9337 " ccccccccccccccccccccccccc) {\n}");
9340 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
9341 " ccccccccccccccccccccccccc) {\n}");
9343 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
9344 " ccccccccccccccccccccccccc) {\n}");
9346 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
9347 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
9348 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
9350 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
9351 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
9352 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
9355 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
9356 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
9357 " aaaaaaaaaaaaaaa != aa) {\n}");
9358 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
9359 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
9360 " aaaaaaaaaaaaaaa != aa) {\n}");
9365 "unsigned Cost =\n"
9366 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
9369 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
9373 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
9375 verifyFormat("unsigned OriginalStartColumn =\n"
9376 " SourceMgr.getSpellingColumnNumber(\n"
9377 " Current.FormatTok.getStartOfNonWhitespace()) -\n"
9383 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
9388 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
9395 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
9398 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
9401 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
9404 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
9407 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
9408 " aaaaaaaaaaaaaaaaaaaaaaaa +\n"
9414 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
9417 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
9420 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
9423 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
9425 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9427 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9428 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
9430 verifyFormat("return\n"
9431 " // true if code is one of a or b.\n"
9437 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
9440 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
9443 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
9447 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9450 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
9453 verifyFormat("SomeLongVariableName->someFunction(\n"
9457 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
9461 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
9465 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
9469 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
9470 " ccccccc(aaaaaaaaaaaaaaaaa, //\n"
9475 verifyFormat("for (int foo = 0; foo < FOO;\n"
9476 " ++foo) {\n"
9477 " bar(foo);\n"
9485 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9486 " aaaaaaaaaaa aaaaaaaa,\n"
9487 " aaaaaaaaa aaaaaaa,\n"
9490 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
9491 " aaaaaaaaaaa aaaaaaaaa,\n"
9492 " aaaaaaaaaaa aaaaaaaaa,\n"
9495 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
9496 " aaaaaaaaaaaaaaa,\n"
9497 " aaaaaaaaaaaaaaaaaaaaa,\n"
9501 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
9505 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
9509 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
9510 " aaaaaaaaaaaaaaaaaaaaa(\n"
9511 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
9515 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
9516 " aaaaaaaaaaaaaaaaaaaaa(\n"
9517 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
9521 "fooooooooooo(new BARRRRRRRRR(\n"
9525 "fooooooooooo(::new BARRRRRRRRR(\n"
9529 "fooooooooooo(new FOO::BARRRR(\n"
9536 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9537 " aaaaaaaaaaa aaaaaaaa,\n"
9538 " aaaaaaaaa aaaaaaa,\n"
9539 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9542 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
9543 " aaaaaaaaaaa aaaaaaaaa,\n"
9544 " aaaaaaaaaaa aaaaaaaaa,\n"
9545 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9548 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
9549 " aaaaaaaaaaaaaaa,\n"
9550 " aaaaaaaaaaaaaaaaaaaaa,\n"
9551 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9554 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
9555 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)\n"
9558 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
9559 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)\n"
9563 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
9564 " aaaaaaaaaaaaaaaaaaaaa(\n"
9565 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)\n"
9566 " ),\n"
9567 " aaaaaaaaaaaaaaaa\n"
9571 "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
9572 " aaaaaaaaaaaaaaaaaaaaa(\n"
9573 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)\n"
9574 " ) &&\n"
9575 " aaaaaaaaaaaaaaaa\n"
9578 verifyFormat("void foo(\n"
9579 " void (*foobarpntr)(\n"
9580 " aaaaaaaaaaaaaaaaaa *,\n"
9581 " bbbbbbbbbbbbbb *,\n"
9582 " cccccccccccccccccccc *,\n"
9583 " dddddddddddddddddd *\n"
9584 " )\n"
9587 verifyFormat("aaaaaaa<bbbbbbbb> const aaaaaaaaaa{\n"
9588 " aaaaaaaaaaaaa(aaaaaaaaaaa, aaaaaaaaaaaaaaaa)\n"
9592 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9593 " const bool &aaaaaaaaa, const void *aaaaaaaaaa\n"
9594 ") const {\n"
9595 " return true;\n"
9598 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaa(\n"
9599 " const bool &aaaaaaaaaa, const void *aaaaaaaaaa\n"
9602 verifyFormat("void aaaaaaaaa(\n"
9603 " int aaaaaa, int bbbbbb, int cccccc, int dddddddddd\n"
9607 "x = aaaaaaaaaaaaaaa(\n"
9608 " \"a aaaaaaa aaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa aaaaaaaaaaaaa\"\n"
9612 verifyFormat("auto lambda =\n"
9613 " [&b](\n"
9614 " auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9621 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
9626 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
9631 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
9636 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
9643 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9644 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9647 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
9648 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9651 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9653 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
9654 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9657 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
9660 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9661 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9662 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9665 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9666 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9668 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9669 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9670 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
9671 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9673 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9674 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9675 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9676 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
9677 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9678 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
9680 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9681 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9682 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9683 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
9685 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9686 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9688 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
9689 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9690 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9693 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9694 " ? aaaaaaaaaaaaaaa\n"
9696 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
9697 " aaaaaaaaa\n"
9698 " ? b\n"
9700 verifyFormat("return aaaa == bbbb\n"
9701 " // comment\n"
9702 " ? aaaa\n"
9704 verifyFormat("unsigned Indent =\n"
9705 " format(TheLine.First,\n"
9706 " IndentForLevel[TheLine.Level] >= 0\n"
9707 " ? IndentForLevel[TheLine.Level]\n"
9708 " : TheLine * 2,\n"
9711 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
9712 " ? aaaaaaaaaaaaaaa\n"
9713 " : bbbbbbbbbbbbbbb //\n"
9714 " ? ccccccccccccccc\n"
9716 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
9717 " ? aaaaaaaaaaaaaaa\n"
9718 " : (bbbbbbbbbbbbbbb //\n"
9719 " ? ccccccccccccccc\n"
9722 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9723 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
9724 " aaaaaaaaaaaaaaaaaaaaa +\n"
9725 " aaaaaaaaaaaaaaaaaaaaa\n"
9728 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9729 " : aaaaaaaaaaaaaaaaaaaaaa\n"
9735 "void f() {\n"
9736 " g(aaa,\n"
9737 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
9738 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9739 " ? aaaaaaaaaaaaaaa\n"
9740 " : aaaaaaaaaaaaaaa);\n"
9744 "void f() {\n"
9745 " g(aaa,\n"
9746 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
9747 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9748 " ?: aaaaaaaaaaaaaaa);\n"
9752 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
9753 " // comment.\n"
9754 " ccccccccccccccccccccccccccccccccccccccc\n"
9755 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9759 verifyFormat("return a != b\n"
9760 " // comment\n"
9761 " ? a = b\n"
9763 verifyFormat("return a != b\n"
9764 " // comment\n"
9765 " ? a = a != b\n"
9766 " // comment\n"
9767 " ? a = b\n"
9768 " : a\n"
9770 verifyFormat("return a != b\n"
9771 " // comment\n"
9772 " ? a\n"
9773 " : a = a != b\n"
9774 " // comment\n"
9775 " ? a = b\n"
9781 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
9782 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9785 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
9786 " : bbbbbbbbbb ? 2222222222222222\n"
9789 verifyFormat("return aaaaaaaaaa ? 1111111111111111\n"
9790 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
9793 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
9794 " : bbbbbbbbbbbbbb ? 222222\n"
9797 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
9798 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9799 " : cccccccccccccc ? 3333333333333333\n"
9802 verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
9803 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9806 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
9807 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9811 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9812 " : cccccccccccccccccc)\n"
9813 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9817 "return aaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9818 " : cccccccccccccccccc)\n"
9819 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9823 "return aaaaaaaaa ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9824 " : dddddddddddddddddd)\n"
9825 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9829 "return aaaaaaaaa ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9830 " : dddddddddddddddddd)\n"
9831 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9835 "return aaaaaaaaa ? 1111111111111111\n"
9836 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9837 " : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9841 "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
9842 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9843 " : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9847 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9848 " : ccccccccccccccc ? dddddddddddddddddd\n"
9849 " : eeeeeeeeeeeeeeeeee)\n"
9850 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9854 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9855 " : ccccccccccccccc ? dddddddddddddddddd\n"
9856 " : eeeeeeeeeeeeeeeeee)\n"
9857 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9861 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9862 " : cccccccccccc ? dddddddddddddddddd\n"
9863 " : eeeeeeeeeeeeeeeeee)\n"
9864 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9868 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9869 " : cccccccccccccccccc\n"
9870 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9874 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9875 " : cccccccccccccccc ? dddddddddddddddddd\n"
9876 " : eeeeeeeeeeeeeeeeee\n"
9877 " : bbbbbbbbbbbbbb ? 2222222222222222\n"
9880 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
9881 " ? (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9882 " : cccccccccccccccccc ? dddddddddddddddddd\n"
9883 " : eeeeeeeeeeeeeeeeee)\n"
9884 " : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
9887 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
9888 " ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
9889 " : cccccccccccccccc ? dddddddddddddddddd\n"
9890 " : eeeeeeeeeeeeeeeeee\n"
9891 " : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
9901 verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
9902 " bbbb ? cccccccccccccccccc :\n"
9907 "MMMMMMMMMMMMMMMMMMMMMMMMMMM = A ?\n"
9908 " /*\n"
9909 " */\n"
9910 " function() {\n"
9911 " try {\n"
9912 " return JJJJJJJJJJJJJJ(\n"
9913 " pppppppppppppppppppppppppppppppppppppppppppppppppp);\n"
9914 " }\n"
9915 " } :\n"
9917 "MMMMMMMMMMMMMMMMMMMMMMMMMMM = A ?\n"
9918 " /*\n"
9919 " */\n"
9920 " function() {\n"
9921 " try {\n"
9922 " return JJJJJJJJJJJJJJ(\n"
9923 " pppppppppppppppppppppppppppppppppppppppppppppppppp);\n"
9924 " }\n"
9925 " } :\n"
9934 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
9935 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
9939 "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
9940 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
9944 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
9947 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
9948 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
9952 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
9956 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9957 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
9958 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9962 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9963 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9966 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
9967 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9968 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
9969 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9972 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9973 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
9974 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9975 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
9976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9977 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
9980 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9981 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
9982 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9983 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
9986 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
9987 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
9990 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
9991 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
9992 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
9996 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
9997 " aaaaaaaaaaaaaaa :\n"
10000 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
10001 " aaaaaaaaa ?\n"
10002 " b :\n"
10005 verifyFormat("unsigned Indent =\n"
10006 " format(TheLine.First,\n"
10007 " IndentForLevel[TheLine.Level] >= 0 ?\n"
10008 " IndentForLevel[TheLine.Level] :\n"
10009 " TheLine * 2,\n"
10012 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
10013 " aaaaaaaaaaaaaaa :\n"
10014 " bbbbbbbbbbbbbbb ? //\n"
10015 " ccccccccccccccc :\n"
10018 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
10019 " aaaaaaaaaaaaaaa :\n"
10020 " (bbbbbbbbbbbbbbb ? //\n"
10021 " ccccccccccccccc :\n"
10024 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
10025 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
10028 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
10029 " aaaaa :\n"
10034 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
10035 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10038 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
10039 " bbbbbbbbbb ? 2222222222222222 :\n"
10042 verifyFormat("return aaaaaaaaaa ? 1111111111111111 :\n"
10043 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10046 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
10047 " bbbbbbbbbbbbbbbb ? 222222 :\n"
10050 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
10051 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10052 " cccccccccccccccc ? 3333333333333333 :\n"
10055 verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
10056 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10059 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
10060 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10064 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10065 " cccccccccccccccccc) :\n"
10066 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10070 "return aaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10071 " cccccccccccccccccc) :\n"
10072 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10076 "return aaaaaaaaa ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10077 " dddddddddddddddddd) :\n"
10078 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10082 "return aaaaaaaaa ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10083 " dddddddddddddddddd) :\n"
10084 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10088 "return aaaaaaaaa ? 1111111111111111 :\n"
10089 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10090 " a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10094 "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
10095 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10096 " (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10100 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10101 " ccccccccccccccccc ? dddddddddddddddddd :\n"
10102 " eeeeeeeeeeeeeeeeee) :\n"
10103 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10107 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10108 " ccccccccccccc ? dddddddddddddddddd :\n"
10109 " eeeeeeeeeeeeeeeeee) :\n"
10110 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10114 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10115 " ccccccccccccccccc ? dddddddddddddddddd :\n"
10116 " eeeeeeeeeeeeeeeeee) :\n"
10117 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10121 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10122 " cccccccccccccccccc :\n"
10123 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10127 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10128 " cccccccccccccccccc ? dddddddddddddddddd :\n"
10129 " eeeeeeeeeeeeeeeeee :\n"
10130 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10133 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
10134 " (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10135 " cccccccccccccccccc ? dddddddddddddddddd :\n"
10136 " eeeeeeeeeeeeeeeeee) :\n"
10137 " bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10140 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
10141 " aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
10142 " cccccccccccccccccccc ? dddddddddddddddddd :\n"
10143 " eeeeeeeeeeeeeeeeee :\n"
10144 " bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
10150 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
10154 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
10155 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
10156 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
10159 "bool aaaaaaaaaaaaaaaaaaaaa =\n"
10160 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
10162 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
10164 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
10166 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
10172 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10173 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
10176 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
10180 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
10181 verifyFormat("/*comment*/ for (int *p, *q; p != q; p = p->next) {\n}", Style);
10182 verifyFormat("if (int *p, *q; p != q) {\n p = p->next;\n}", Style);
10183 verifyFormat("/*comment*/ if (int *p, *q; p != q) {\n p = p->next;\n}",
10185 verifyFormat("switch (int *p, *q; p != q) {\n default:\n break;\n}",
10188 "/*comment*/ switch (int *p, *q; p != q) {\n default:\n break;\n}",
10191 verifyFormat("if ([](int* p, int* q) {}()) {\n}", Style);
10192 verifyFormat("for ([](int* p, int* q) {}();;) {\n}", Style);
10193 verifyFormat("for (; [](int* p, int* q) {}();) {\n}", Style);
10194 verifyFormat("for (;; [](int* p, int* q) {}()) {\n}", Style);
10195 verifyFormat("switch ([](int* p, int* q) {}()) {\n default:\n break;\n}",
10207 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
10210 "looooooooooooooooooooooooongFunction(\n"
10211 " \"short literal\"\n"
10213 verifyFormat("someFunction(\"Always break between multi-line\"\n"
10214 " \" string literals\",\n"
10216 verifyFormat("fun + \"1243\" /* comment */\n"
10218 "fun + \"1243\" /* comment */\n"
10222 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10223 " \"aaaaaaaaaaaaaaaaaaaaa\"\n"
10229 verifyFormat("a = a + \"a\"\n"
10230 " \"a\"\n"
10232 verifyFormat("f(\"a\", \"b\"\n"
10236 "#define LL_FORMAT \"ll\"\n"
10237 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
10240 verifyFormat("#define A(X) \\\n"
10241 " \"aaaaa\" #X \"bbbbbb\" \\\n"
10244 verifyFormat("#define A \"def\"\n"
10245 "f(\"abc\" A \"ghi\"\n"
10248 verifyFormat("f(L\"a\"\n"
10250 verifyFormat("#define A(X) \\\n"
10251 " L\"aaaaa\" #X L\"bbbbbb\" \\\n"
10255 verifyFormat("f(@\"a\"\n"
10257 verifyFormat("NSString s = @\"a\"\n"
10258 " @\"b\"\n"
10260 verifyFormat("NSString s = @\"a\"\n"
10261 " \"b\"\n"
10271 verifyFormat("class A {\n"
10272 " int f() { return 1; }\n"
10273 " int g();\n"
10274 " long\n"
10275 " foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaar();\n"
10276 "};\n"
10277 "int f() { return 1; }\n"
10278 "int g();\n"
10279 "int foooooooooooooooooooooooooooo::\n"
10285 verifyFormat("class A {\n"
10286 " int f() { return 1; }\n"
10287 " int g();\n"
10288 " long\n"
10289 " foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaar();\n"
10290 "};\n"
10291 "int f() { return 1; }\n"
10292 "int g();\n"
10293 "int\n"
10299 verifyFormat("class A {\n"
10300 " int f() { return 1; }\n"
10301 " int g();\n"
10302 " long foooooooooooooooooooooooooooo::\n"
10303 " baaaaaaaaaaaaaaaaaaaar();\n"
10304 "};\n"
10305 "int f() { return 1; }\n"
10306 "int g();\n"
10307 "int foooooooooooooooooooooooooooo::\n"
10315 verifyFormat("SomeType\n"
10318 verifyFormat("class E {\n"
10319 " int\n"
10320 " f() {\n"
10321 " return 1;\n"
10322 " }\n"
10323 " int\n"
10324 " g();\n"
10325 " long\n"
10326 " foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaar();\n"
10327 "};\n"
10328 "int\n"
10329 "f() {\n"
10330 " return 1;\n"
10331 "}\n"
10332 "int\n"
10333 "g();\n"
10334 "int\n"
10341 verifyFormat("class B {\n"
10342 " int f() { return 1; }\n"
10343 " int g();\n"
10344 "};\n"
10345 "int\n"
10346 "f() {\n"
10347 " return 1;\n"
10348 "}\n"
10355 verifyFormat("class C {\n"
10356 " int f() { return 1; }\n"
10357 " int g();\n"
10358 "};\n"
10359 "int\n"
10360 "f() {\n"
10361 " return 1;\n"
10362 "}\n"
10363 "int\n"
10364 "g();\n"
10365 "int\n"
10372 verifyFormat("class D {\n"
10373 " int\n"
10374 " f() {\n"
10375 " return 1;\n"
10376 " }\n"
10377 " int g();\n"
10378 "};\n"
10379 "int\n"
10380 "f() {\n"
10381 " return 1;\n"
10382 "}\n"
10385 verifyFormat("const char *\n"
10386 "f(void) {\n" // Break here.
10387 " return \"\";\n"
10388 "}\n"
10391 verifyFormat("template <class T>\n"
10392 "T *\n"
10393 "f(T &c) {\n" // Break here.
10394 " return NULL;\n"
10395 "}\n"
10398 verifyFormat("class C {\n"
10399 " int\n"
10400 " operator+() {\n"
10401 " return 1;\n"
10402 " }\n"
10403 " int\n"
10404 " operator()() {\n"
10405 " return 1;\n"
10406 " }\n"
10409 verifyFormat("void\n"
10410 "A::operator()() {}\n"
10411 "void\n"
10412 "A::operator>>() {}\n"
10413 "void\n"
10414 "A::operator+() {}\n"
10415 "void\n"
10416 "A::operator*() {}\n"
10417 "void\n"
10418 "A::operator->() {}\n"
10419 "void\n"
10420 "A::operator void *() {}\n"
10421 "void\n"
10422 "A::operator void &() {}\n"
10423 "void\n"
10424 "A::operator void &&() {}\n"
10425 "void\n"
10426 "A::operator char *() {}\n"
10427 "void\n"
10428 "A::operator[]() {}\n"
10429 "void\n"
10430 "A::operator!() {}\n"
10431 "void\n"
10432 "A::operator**() {}\n"
10433 "void\n"
10434 "A::operator<Foo> *() {}\n"
10435 "void\n"
10436 "A::operator<Foo> **() {}\n"
10437 "void\n"
10438 "A::operator<Foo> &() {}\n"
10439 "void\n"
10442 verifyFormat("constexpr auto\n"
10443 "operator()() const -> reference {}\n"
10444 "constexpr auto\n"
10445 "operator>>() const -> reference {}\n"
10446 "constexpr auto\n"
10447 "operator+() const -> reference {}\n"
10448 "constexpr auto\n"
10449 "operator*() const -> reference {}\n"
10450 "constexpr auto\n"
10451 "operator->() const -> reference {}\n"
10452 "constexpr auto\n"
10453 "operator++() const -> reference {}\n"
10454 "constexpr auto\n"
10455 "operator void *() const -> reference {}\n"
10456 "constexpr auto\n"
10457 "operator void **() const -> reference {}\n"
10458 "constexpr auto\n"
10459 "operator void *() const -> reference {}\n"
10460 "constexpr auto\n"
10461 "operator void &() const -> reference {}\n"
10462 "constexpr auto\n"
10463 "operator void &&() const -> reference {}\n"
10464 "constexpr auto\n"
10465 "operator char *() const -> reference {}\n"
10466 "constexpr auto\n"
10467 "operator!() const -> reference {}\n"
10468 "constexpr auto\n"
10473 verifyFormat("void *\n"
10476 verifyFormat("void *\n"
10480 verifyFormat("const char *\n"
10481 "f(void)\n" // Break here.
10482 "{\n"
10483 " return \"\";\n"
10484 "}\n"
10487 verifyFormat("template <class T>\n"
10488 "T *\n" // Problem here: no line break
10489 "f(T &c)\n" // Break here.
10490 "{\n"
10491 " return NULL;\n"
10492 "}\n"
10495 verifyFormat("int\n"
10496 "foo(A<bool> a)\n"
10497 "{\n"
10498 " return a;\n"
10501 verifyFormat("int\n"
10502 "foo(A<8> a)\n"
10503 "{\n"
10504 " return a;\n"
10507 verifyFormat("int\n"
10508 "foo(A<B<bool>, 8> a)\n"
10509 "{\n"
10510 " return a;\n"
10513 verifyFormat("int\n"
10514 "foo(A<B<8>, bool> a)\n"
10515 "{\n"
10516 " return a;\n"
10519 verifyFormat("int\n"
10520 "foo(A<B<bool>, bool> a)\n"
10521 "{\n"
10522 " return a;\n"
10525 verifyFormat("int\n"
10526 "foo(A<B<8>, 8> a)\n"
10527 "{\n"
10528 " return a;\n"
10534 verifyFormat("int f(i);\n" // No break here.
10535 "int\n" // Break here.
10536 "f(i)\n"
10537 "{\n"
10538 " return i + 1;\n"
10539 "}\n"
10540 "int\n" // Break here.
10541 "f(i)\n"
10542 "{\n"
10543 " return i + 1;\n"
10546 verifyFormat("int f(a, b, c);\n" // No break here.
10547 "int\n" // Break here.
10548 "f(a, b, c)\n" // Break here.
10549 "short a, b;\n"
10550 "float c;\n"
10551 "{\n"
10552 " return a + b < c;\n"
10553 "}\n"
10554 "int\n" // Break here.
10555 "f(a, b, c)\n" // Break here.
10556 "short a, b;\n"
10557 "float c;\n"
10558 "{\n"
10559 " return a + b < c;\n"
10562 verifyFormat("byte *\n" // Break here.
10563 "f(a)\n" // Break here.
10564 "byte a[];\n"
10565 "{\n"
10566 " return a;\n"
10569 verifyFormat("byte *\n"
10570 "f(a)\n"
10571 "byte /* K&R C */ a[];\n"
10572 "{\n"
10573 " return a;\n"
10574 "}\n"
10575 "byte *\n"
10576 "g(p)\n"
10577 "byte /* K&R C */ *p;\n"
10578 "{\n"
10579 " return p;\n"
10582 verifyFormat("bool f(int a, int) override;\n"
10583 "Bar g(int a, Bar) final;\n"
10586 verifyFormat("int\n"
10589 verifyFormat("bool\n"
10590 "f(size_t = 0, bool b = false)\n"
10591 "{\n"
10592 " return !b;\n"
10598 verifyFormat("Tttttttttttttttttttttttt ppppppppppppppp\n"
10601 verifyFormat("Tttttttttttttttttttttttt ppppppppppppppp\n"
10604 verifyFormat("Tttttttttttttttttttttttt ppppppppppppppp\n"
10605 " ABSL_GUARDED_BY(mutex1)\n"
10608 verifyFormat("Tttttt f(int a, int b)\n"
10609 " ABSL_GUARDED_BY(mutex1)\n"
10618 verifyFormat("void\n"
10619 "foo (int a, /*abc*/ int b) // def\n"
10620 "{\n"
10624 verifyFormat("void\n"
10625 "foo (int a, /* abc */ int b) /* def */\n"
10626 "{\n"
10641 verifyFormat("aaaa = \"bbbb\"\n"
10644 verifyFormat("aaaa =\n"
10645 " \"bbbb\"\n"
10648 verifyFormat("aaaa(\"bbbb\"\n"
10651 verifyFormat("aaaa(\n"
10652 " \"bbbb\"\n"
10655 verifyFormat("aaaa(qqq, \"bbbb\"\n"
10658 verifyFormat("aaaa(qqq,\n"
10659 " \"bbbb\"\n"
10662 verifyFormat("aaaa(qqq,\n"
10663 " L\"bbbb\"\n"
10666 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
10669 verifyFormat("string s = someFunction(\n"
10670 " \"abc\"\n"
10675 verifyFormat("string foo = abc ? \"x\"\n"
10676 " \"blah blah blah blah blah blah\"\n"
10681 verifyFormat("f(\"aaaa\"\n"
10686 verifyNoChange("x = \"a\\\n"
10687 "b\\\n"
10690 verifyFormat("xxxx =\n"
10691 " \"a\\\n"
10692 "b\\\n"
10694 "xxxx = \"a\\\n"
10695 "b\\\n"
10699 verifyFormat("NSString *const kString =\n"
10700 " @\"aaaa\"\n"
10702 "NSString *const kString = @\"aaaa\"\n"
10712 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10713 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10716 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
10719 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10722 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
10725 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
10726 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
10729 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10730 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10732 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10733 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
10734 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10736 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
10739 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10742 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
10745 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
10747 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10748 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
10749 " aaaaaaaaaaaaaaaaaaaaa)\n"
10751 verifyFormat("LOG_IF(aaa == //\n"
10752 " bbb)\n"
10756 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
10758 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
10759 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10761 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
10763 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
10764 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10766 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
10767 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10768 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10772 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10776 verifyFormat("llvm::errs() << \"\n"
10778 "llvm::errs() << \"\n<<a;");
10780 verifyFormat("void f() {\n"
10781 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
10782 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
10786 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
10790 // Handle '\n'.
10791 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
10792 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
10793 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
10794 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
10795 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
10796 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
10797 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
10801 verifyFormat("return out << \"somepacket = {\\n\"\n"
10802 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
10803 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
10804 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
10805 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
10808 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
10809 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
10812 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
10813 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
10814 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
10815 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
10817 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
10820 "void f() {\n"
10821 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
10822 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
10827 "llvm::errs()\n"
10828 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10829 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10830 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10833 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
10834 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10835 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
10836 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10837 " << \"aaaaaaaaaaaaaaaaaaa: \"\n"
10841 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
10842 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
10844 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
10845 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
10847 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
10850 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
10854 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
10855 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
10862 verifyNoChange("QStringList() << \"foo\"\n"
10866 "log_error(log, \"foo\"\n"
10872 "aaaaaaaaaaaaaaaaa =\n"
10875 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
10876 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
10878 "if (a) {\n"
10879 " f();\n"
10880 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
10881 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
10884 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
10885 " 100000000 + 10000000) {\n}");
10889 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
10892 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
10896 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
10900 "ShortObject->shortFunction(\n"
10901 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
10904 verifyFormat("loooooooooooooongFunction(\n"
10908 "function(LoooooooooooooooooooooooooooooooooooongObject\n"
10911 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
10913 verifyFormat("void f() {\n"
10914 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
10915 " .Times(2)\n"
10916 " .WillRepeatedly(Return(SomeValue));\n"
10918 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
10920 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
10921 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10922 " .aaaaa(aaaaa),\n"
10924 verifyFormat("void f() {\n"
10925 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10926 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
10928 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
10929 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10930 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
10931 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
10933 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10934 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10935 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10936 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
10940 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
10941 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
10943 "aaaaaaaaaaa->aaaaaaaaa(\n"
10944 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
10948 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10950 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
10952 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
10955 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
10956 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10961 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
10962 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
10963 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
10964 " aaaaaaaaaaaaaaaaaaa,\n"
10970 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10971 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
10974 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10976 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10977 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10979 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
10985 verifyFormat("template <typename T>\n"
10987 verifyFormat("template <typename T>\n"
10988 "// T should be one of {A, B}.\n"
10991 "template <typename T>\n"
10993 verifyFormat("template <typename T>\n"
10994 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
10997 "template <typename T>\n"
10998 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
11001 "template <typename T>\n"
11002 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
11003 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
11005 verifyFormat("template <typename T>\n"
11006 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
11009 "template <typename T1, typename T2 = char, typename T3 = char,\n"
11010 " typename T4 = char>\n"
11012 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
11013 " template <typename> class cccccccccccccccccccccc,\n"
11014 " typename ddddddddddddd>\n"
11017 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
11020 verifyFormat("void f() {\n"
11021 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
11022 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
11029 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
11030 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
11031 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
11032 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
11033 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
11034 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
11037 verifyFormat("static_cast<A< //\n"
11038 " B> *>(\n"
11039 "\n"
11041 "static_cast<A<//\n"
11042 " B>*>(\n"
11043 "\n"
11045 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
11053 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
11054 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
11056 verifyFormat("template <template <typename> class Fooooooo,\n"
11057 " template <typename> class Baaaaaaar>\n"
11060 verifyFormat("template <typename T> // T can be A, B or C.\n"
11063 verifyFormat("template <typename T>\n"
11066 verifyFormat("template <typename T>\n"
11069 verifyFormat("template <typename T>\n"
11072 verifyFormat("template <enum E> class A {\n"
11073 "public:\n"
11074 " E *f();\n"
11088 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
11089 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
11092 verifyFormat("template <template <typename> class Fooooooo,\n"
11093 " template <typename> class Baaaaaaar>\n"
11096 verifyFormat("template <typename T> // T can be A, B or C.\n"
11099 verifyFormat("template <enum E> class A {\n"
11100 "public:\n"
11101 " E *f();\n"
11112 verifyNoChange("template <typename T>\n"
11117 verifyNoChange("template <typename T>\n"
11122 verifyNoChange("template <typename T>\n"
11127 verifyNoChange("template <typename T>\n"
11128 "// T can be A, B or C.\n"
11131 verifyFormat("template <typename T> // T can be A, B or C.\n"
11135 verifyNoChange("template <typename T>\n"
11140 verifyNoChange("template <enum E>\n"
11141 "class A {\n"
11142 "public:\n"
11143 " E *f();\n"
11146 verifyFormat("template <enum E> class A {\n"
11147 "public:\n"
11148 " E *f();\n"
11152 verifyNoChange("template <auto x>\n"
11153 "constexpr int simple(int) {\n"
11154 " char c;\n"
11155 " return 1;\n"
11158 verifyFormat("template <auto x> constexpr int simple(int) {\n"
11159 " char c;\n"
11160 " return 1;\n"
11165 verifyNoChange("template <auto x>\n"
11166 "requires(x > 1)\n"
11167 "constexpr int with_req(int) {\n"
11168 " return 1;\n"
11171 verifyFormat("template <auto x> requires(x > 1)\n"
11172 "constexpr int with_req(int) {\n"
11173 " return 1;\n"
11181 verifyFormat("// Baseline - no comments.\n"
11182 "template <\n"
11183 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
11187 verifyFormat("template <\n"
11188 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
11190 "template <\n"
11191 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
11196 "template <\n"
11197 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
11199 "template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
11203 verifyFormat("template <\n"
11204 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
11205 " // multiline\n"
11207 "template <\n"
11208 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
11209 " // multiline\n"
11214 "template <typename aaaaaaaaaa<\n"
11215 " bbbbbbbbbbbb>::value> // trailing loooong\n"
11217 "template <\n"
11218 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
11228 "template <typename... a> struct q {};\n"
11229 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
11230 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
11236 "template <typename... a> struct r {};\n"
11237 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
11238 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
11243 verifyFormat("template <typename... a> struct s {};\n"
11244 "extern s<\n"
11246 "aaaaaaaaaaaaaaaaaaaaaa,\n"
11248 "aaaaaaaaaaaaaaaaaaaaaa>\n"
11253 verifyFormat("template <typename... a> struct t {};\n"
11254 "extern t<\n"
11256 "aaaaaaaaaaaaaaaaaaaaaa,\n"
11258 "aaaaaaaaaaaaaaaaaaaaaa>\n"
11265 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
11268 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
11269 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
11274 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
11275 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
11279 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
11284 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
11287 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
11288 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
11289 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
11293 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
11294 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11298 "LongClassNameToShowTheIssue::AndAnotherLongClassNameToShowTheIssue::\n"
11299 " AndAnotherLongClassNameToShowTheIssue() {}\n"
11300 "LongClassNameToShowTheIssue::AndAnotherLongClassNameToShowTheIssue::\n"
11356 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11368 verifyFormat("void f() {\n"
11369 " while (a < b && c > d) {\n"
11370 " }\n"
11372 verifyFormat("template <typename... Types>\n"
11375 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
11383 verifyFormat("#define FOO(typeName, realClass) \\\n"
11403 verifyFormat("int a = 1 << 2; /* foo\n"
11405 "int a=1<<2; /* foo\n"
11408 verifyFormat("int b = 256 >> 1; /* foo\n"
11410 "int b =256>>1 ; /* foo\n"
11424 verifyFormat("void f() {\n"
11425 " (a->*f)();\n"
11426 " a->*x;\n"
11427 " (a.*f)();\n"
11428 " ((*a).*f)();\n"
11429 " a.*x;\n"
11431 verifyFormat("void f() {\n"
11432 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
11433 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
11436 "(aaaaaaaaaa->*bbbbbbb)(\n"
11458 verifyFormat("if (i == -1) {\n}");
11459 verifyFormat("if (i != -1) {\n}");
11460 verifyFormat("if (i > -1) {\n}");
11461 verifyFormat("if (i < -1) {\n}");
11466 verifyFormat("if (!(a->f())) {\n}");
11467 verifyFormat("if (!+i) {\n}");
11469 verifyFormat("for (x = 0; -10 < x; --x) {\n}");
11481 verifyFormat("n * sizeof char16;");
11482 verifyGoogleFormat("n * alignof char16;");
11488 verifyFormat("switch (a) {\n"
11489 "case -1:\n"
11490 " break;\n"
11516 verifyFormat("if (!aaaaaaaaaa( // break\n"
11517 " aaaaa)) {\n"
11519 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
11521 verifyFormat("*aaa = aaaaaaa( // break\n"
11552 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
11554 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
11558 "ostream &operator<<(ostream &OutputStream,\n"
11560 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
11561 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
11562 " return left.group < right.group;\n"
11572 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
11592 verifyFormat("::operator new(n * sizeof(foo));");
11594 verifyFormat("foo() { ::operator new(n * sizeof(foo)); }");
11624 verifyGoogleFormat("template <typename T>\n"
11719 verifyFormat("struct f {\n"
11720 " template <class T>\n"
11721 " int &foo(const std::string &str) & noexcept {}\n"
11725 verifyFormat("struct f {\n"
11726 " template <class T>\n"
11727 " int &foo(const std::string &str) && noexcept {}\n"
11731 verifyFormat("struct f {\n"
11732 " template <class T>\n"
11733 " int &foo(const std::string &str) const & noexcept {}\n"
11737 verifyFormat("struct f {\n"
11738 " template <class T>\n"
11739 " int &foo(const std::string &str) const & noexcept {}\n"
11743 verifyFormat("struct f {\n"
11744 " template <class T>\n"
11745 " auto foo(const std::string &str) && noexcept -> int & {}\n"
11753 verifyFormat("struct f {\n"
11754 " template <class T>\n"
11755 " int& foo(const std::string& str) & noexcept {}\n"
11759 verifyFormat("struct f {\n"
11760 " template <class T>\n"
11761 " int& foo(const std::string& str) && noexcept {}\n"
11765 verifyFormat("struct f {\n"
11766 " template <class T>\n"
11767 " int& foo(const std::string& str) const& noexcept {}\n"
11771 verifyFormat("struct f {\n"
11772 " template <class T>\n"
11773 " int& foo(const std::string& str) const&& noexcept {}\n"
11777 verifyFormat("struct f {\n"
11778 " template <class T>\n"
11779 " auto foo(const std::string& str) && noexcept -> int& {}\n"
11785 verifyFormat("struct f {\n"
11786 " template <class T>\n"
11787 " DEPRECATED(reason)\n"
11788 " Type &foo(arguments) {}\n"
11792 verifyFormat("struct f {\n"
11793 " template <class T>\n"
11794 " DEPRECATED(reason)\n"
11795 " Type& foo(arguments) {}\n"
11805 std::string Prefix = "void a() &;\n"
11806 "void b() &;\n";
11810 Prefix = "void operator()() &&;\n"
11811 "void operator()() &&;\n";
11815 Prefix = "void a() const &;\n"
11816 "void b() const &;\n";
11824 const StringRef Code("int* p;\n"
11825 "int *q;\n"
11829 verifyFormat("int *p;\n"
11830 "int *q;\n"
11835 verifyFormat("int* p;\n"
11836 "int* q;\n"
11841 verifyFormat("int * p;\n"
11842 "int * q;\n"
11848 verifyFormat("void f() {\n"
11849 " A *a = new A;\n"
11850 " A *a = new (placement) A;\n"
11851 " delete a;\n"
11852 " delete (A *)a;\n"
11854 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
11856 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
11857 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
11867 verifyFormat("void new(link p);\n"
11869 "void new (link p);\n"
11872 verifyFormat("{\n"
11873 " p->new();\n"
11874 "}\n"
11875 "{\n"
11876 " p->delete();\n"
11878 "{\n"
11879 " p->new ();\n"
11880 "}\n"
11881 "{\n"
11882 " p->delete ();\n"
11890 verifyFormat("struct A {\n"
11891 " int *a;\n"
11892 " A(int *p) : a(new (p) int) {\n"
11893 " new (p) int;\n"
11894 " int *b = new (p) int;\n"
11895 " int *c = new (p) int(3);\n"
11896 " delete (b);\n"
11897 " }\n"
11906 verifyFormat("struct A {\n"
11907 " int *a;\n"
11908 " A(int *p) : a(new(p) int) {\n"
11909 " new(p) int;\n"
11910 " int *b = new(p) int;\n"
11911 " int *c = new(p) int(3);\n"
11912 " delete(b);\n"
11913 " }\n"
12003 verifyFormat("for (char **a = b; *a; ++a) {\n}");
12004 verifyFormat("for (; a && b;) {\n}");
12008 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
12030 verifyGoogleFormat("template <typename T>\n"
12036 verifyFormat("for (;; *a = b) {\n}", Left);
12059 verifyFormat("void foo(int * // this is the first paramters\n"
12060 " ,\n"
12062 verifyFormat("double term = a * // first\n"
12065 "int *MyValues = {\n"
12066 " *A, // Operator detection might be confused by the '{'\n"
12067 " *BB // Operator detection might be confused by previous comment\n"
12085 verifyFormat("void f() {\n"
12086 " for (const int &v : Values) {\n"
12087 " }\n"
12089 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
12090 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
12091 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
12094 verifyFormat("#define MACRO \\\n"
12095 " int *i = a * b; \\\n"
12157 "template <class T, class = typename std::enable_if<\n"
12158 " std::is_integral<T>::value &&\n"
12159 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
12162 verifyFormat("template <class T,\n"
12163 " class = typename std::enable_if<\n"
12164 " std::is_integral<T>::value &&\n"
12165 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
12166 " class U>\n"
12170 "template <class T,\n"
12171 " class = typename ::std::enable_if<\n"
12172 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
12178 verifyFormat("struct {\n"
12181 verifyFormat("union {\n"
12184 verifyFormat("class {\n"
12190 verifyFormat("struct {\n"
12193 verifyFormat("union {\n"
12196 verifyFormat("class {\n"
12202 verifyFormat("struct {\n"
12205 verifyFormat("union {\n"
12208 verifyFormat("class {\n"
12211 verifyFormat("struct {\n"
12214 verifyFormat("union {\n"
12217 verifyFormat("class {\n"
12222 verifyFormat("struct {\n"
12225 verifyFormat("union {\n"
12228 verifyFormat("class {\n"
12231 verifyFormat("struct {\n"
12234 verifyFormat("union {\n"
12237 verifyFormat("class {\n"
12305 verifyFormat("#define OP(x) \\\n"
12306 " ostream &operator<<(ostream &s, const A &a) { \\\n"
12307 " return s << a.DebugString(); \\\n"
12309 "#define OP(x) \\\n"
12310 " ostream &operator<<(ostream &s, const A &a) { \\\n"
12311 " return s << a.DebugString(); \\\n"
12315 verifyFormat("#define FOO \\\n"
12316 " void foo() { \\\n"
12317 " operator+(a * b); \\\n"
12343 verifyFormat("string // break\n"
12345 verifyFormat("string // break\n"
12347 verifyGoogleFormat("template <typename T>\n"
12357 verifyFormat("int operator()(T (&&)[N]) { return 1; }");
12358 verifyFormat("int operator()(T (&)[N]) { return 0; }");
12362 verifyFormat("class c {\n"
12363 " void func(type &a) { a & member; }\n"
12364 " anotherType &member;\n"
12370 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
12375 verifyFormat("__attribute__((nodebug)) void\n"
12378 verifyFormat("__unused void\n"
12474 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
12477 verifyFormat("class [[nodiscard]] f {\npublic:\n f() {}\n}");
12478 verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n f() {}\n}");
12479 verifyFormat("class [[gnu::unused]] f {\npublic:\n f() {}\n}");
12483 verifyFormat("int a() {}\n"
12485 verifyFormat("NSArray *arr;\n"
12502 verifyFormat("[[unused]] int b() {\n"
12503 " return 42;\n"
12510 verifyFormat("class S {\n"
12511 " S(S&&) = default;\n"
12514 verifyFormat("class [[nodiscard]] S {\n"
12515 " S(S&&) = default;\n"
12518 verifyFormat("class __attribute((maybeunused)) S {\n"
12519 " S(S&&) = default;\n"
12522 verifyFormat("struct S {\n"
12523 " S(S&&) = default;\n"
12526 verifyFormat("struct [[nodiscard]] S {\n"
12527 " S(S&&) = default;\n"
12534 verifyFormat("MACRO;\n"
12535 "__attribute__((maybe_unused)) int foo() {\n"
12536 " //...\n"
12539 verifyFormat("MACRO;\n"
12540 "[[nodiscard]] int foo() {\n"
12541 " //...\n"
12544 verifyNoChange("MACRO\n\n"
12545 "__attribute__((maybe_unused)) int foo() {\n"
12546 " //...\n"
12549 verifyNoChange("MACRO\n\n"
12550 "[[nodiscard]] int foo() {\n"
12551 " //...\n"
12557 verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
12560 verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
12564 "shared_ptr<ALongTypeName> &C d) {\n}",
12586 verifyFormat("int *a;\n"
12587 "int *a;\n"
12589 "int *a;\n"
12590 "int* a;\n"
12593 verifyFormat("int* a;\n"
12594 "int* a;\n"
12596 "int* a;\n"
12597 "int* a;\n"
12600 verifyFormat("int *a;\n"
12601 "int *a;\n"
12603 "int *a;\n"
12604 "int * a;\n"
12607 verifyFormat("auto x = [] {\n"
12608 " int *a;\n"
12609 " int *a;\n"
12610 " int *a;\n"
12612 "auto x=[]{int *a;\n"
12613 "int * a;\n"
12631 verifyFormat("template <bool B, bool C> class A {\n"
12632 " static_assert(B && C, \"Something is wrong\");\n"
12635 verifyFormat("template <typename T> struct S {\n"
12636 " explicit(Bar<T> && Foo<T>) S(const S &);\n"
12644 verifyFormat("void f() {\n"
12645 " x[aaaaaaaaa -\n"
12646 " b] = 23;\n"
12656 verifyFormat("if (static_cast<int>(A) + B >= 0)\n ;");
12660 "static_cast<const void *>(R)\n"
12707 verifyFormat("{\n"
12708 " (void)F;\n"
12712 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
12713 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
12778 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
12782 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
12783 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
12795 verifyFormat("template <class CallbackClass>\n"
12801 "template <class CallbackClass>\n"
12811 verifyFormat("std::function<\n"
12812 " LooooooooooongTemplatedType<\n"
12813 " SomeType>*(\n"
12814 " LooooooooooooooooongType type)>\n"
12825 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
12827 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
12829 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
12833 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
12835 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
12837 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
12839 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
12843 verifyFormat("LooooooooooooooooongType\n"
12849 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
12851 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
12853 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
12855 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
12857 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
12859 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
12861 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
12863 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
12865 verifyFormat("typeof(LoooooooooooooooooooooooooooooooooooooooooongName)\n"
12867 verifyFormat("_Atomic(LooooooooooooooooooooooooooooooooooooooooongName)\n"
12869 verifyFormat("__underlying_type(LooooooooooooooooooooooooooooooongName)\n"
12871 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
12873 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
12877 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
12881 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
12885 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
12889 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
12895 "LoooooooooooooooooooooooooooooooooooooooongType // break\n"
12898 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
12901 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
12902 " SourceLocation L, IdentifierIn *II,\n"
12904 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
12905 "ReallyReaaallyLongFunctionName(\n"
12906 " const std::string &SomeParameter,\n"
12907 " const SomeType<string, SomeOtherTemplateParameter>\n"
12908 " &ReallyReallyLongParameterName,\n"
12909 " const SomeType<string, SomeOtherTemplateParameter>\n"
12911 verifyFormat("template <typename A>\n"
12912 "SomeLoooooooooooooooooooooongType<\n"
12913 " typename some_namespace::SomeOtherType<A>::Type>\n"
12917 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
12920 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
12923 "some_namespace::LongReturnType\n"
12924 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
12927 verifyGoogleFormat("template <typename T>\n"
12928 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
12930 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
12933 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
12934 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
12936 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
12937 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
12939 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
12940 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
12941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
12944 verifyFormat("template <typename T> // Templates on own line.\n"
12945 "static int // Some comment.\n"
12953 verifyFormat("struct foo {\n"
12954 "private:\n"
12955 " void f() {}\n"
12956 "\n"
12957 "private:\n"
12958 " int i;\n"
12959 "\n"
12960 "protected:\n"
12961 " int j;\n"
12964 verifyFormat("struct foo {\n"
12965 "private:\n"
12966 " void f() {}\n"
12967 "\n"
12968 "private:\n"
12969 " int i;\n"
12970 "\n"
12971 "protected:\n"
12972 " int j;\n"
12974 "struct foo {\n"
12975 "private:\n"
12976 " void f() {}\n"
12977 "private:\n"
12978 " int i;\n"
12979 "protected:\n"
12980 " int j;\n"
12983 verifyFormat("struct foo { /* comment */\n"
12984 "private:\n"
12985 " int i;\n"
12986 " // comment\n"
12987 "private:\n"
12988 " int j;\n"
12991 verifyFormat("struct foo {\n"
12992 "#ifdef FOO\n"
12993 "#endif\n"
12994 "private:\n"
12995 " int i;\n"
12996 "#ifdef FOO\n"
12997 "private:\n"
12998 "#endif\n"
12999 " int j;\n"
13003 verifyFormat("struct foo {\n"
13004 "private:\n"
13005 " void f() {}\n"
13006 "private:\n"
13007 " int i;\n"
13008 "protected:\n"
13009 " int j;\n"
13012 verifyFormat("struct foo {\n"
13013 "private:\n"
13014 " void f() {}\n"
13015 "private:\n"
13016 " int i;\n"
13017 "protected:\n"
13018 " int j;\n"
13020 "struct foo {\n"
13021 "\n"
13022 "private:\n"
13023 " void f() {}\n"
13024 "\n"
13025 "private:\n"
13026 " int i;\n"
13027 "\n"
13028 "protected:\n"
13029 " int j;\n"
13032 verifyFormat("struct foo { /* comment */\n"
13033 "private:\n"
13034 " int i;\n"
13035 " // comment\n"
13036 "private:\n"
13037 " int j;\n"
13039 "struct foo { /* comment */\n"
13040 "\n"
13041 "private:\n"
13042 " int i;\n"
13043 " // comment\n"
13044 "\n"
13045 "private:\n"
13046 " int j;\n"
13049 verifyFormat("struct foo {\n"
13050 "#ifdef FOO\n"
13051 "#endif\n"
13052 "private:\n"
13053 " int i;\n"
13054 "#ifdef FOO\n"
13055 "private:\n"
13056 "#endif\n"
13057 " int j;\n"
13059 "struct foo {\n"
13060 "#ifdef FOO\n"
13061 "#endif\n"
13062 "\n"
13063 "private:\n"
13064 " int i;\n"
13065 "#ifdef FOO\n"
13066 "\n"
13067 "private:\n"
13068 "#endif\n"
13069 " int j;\n"
13073 verifyFormat("struct foo {\n"
13074 "private:\n"
13075 " void f() {}\n"
13076 "\n"
13077 "private:\n"
13078 " int i;\n"
13079 "\n"
13080 "protected:\n"
13081 " int j;\n"
13084 verifyFormat("struct foo {\n"
13085 "private:\n"
13086 " void f() {}\n"
13087 "\n"
13088 "private:\n"
13089 " int i;\n"
13090 "\n"
13091 "protected:\n"
13092 " int j;\n"
13094 "struct foo {\n"
13095 "private:\n"
13096 " void f() {}\n"
13097 "private:\n"
13098 " int i;\n"
13099 "protected:\n"
13100 " int j;\n"
13103 verifyFormat("struct foo { /* comment */\n"
13104 "private:\n"
13105 " int i;\n"
13106 " // comment\n"
13107 "\n"
13108 "private:\n"
13109 " int j;\n"
13112 verifyFormat("struct foo {\n"
13113 "#ifdef FOO\n"
13114 "#endif\n"
13115 "\n"
13116 "private:\n"
13117 " int i;\n"
13118 "#ifdef FOO\n"
13119 "\n"
13120 "private:\n"
13121 "#endif\n"
13122 " int j;\n"
13124 "struct foo {\n"
13125 "#ifdef FOO\n"
13126 "#endif\n"
13127 "private:\n"
13128 " int i;\n"
13129 "#ifdef FOO\n"
13130 "private:\n"
13131 "#endif\n"
13132 " int j;\n"
13136 verifyNoChange("struct foo {\n"
13137 "\n"
13138 "private:\n"
13139 " void f() {}\n"
13140 "\n"
13141 "private:\n"
13142 " int i;\n"
13143 "\n"
13144 "protected:\n"
13145 " int j;\n"
13148 verifyFormat("struct foo {\n"
13149 "private:\n"
13150 " void f() {}\n"
13151 "private:\n"
13152 " int i;\n"
13153 "protected:\n"
13154 " int j;\n"
13157 verifyNoChange("struct foo { /* comment */\n"
13158 "\n"
13159 "private:\n"
13160 " int i;\n"
13161 " // comment\n"
13162 "\n"
13163 "private:\n"
13164 " int j;\n"
13167 verifyFormat("struct foo { /* comment */\n"
13168 "private:\n"
13169 " int i;\n"
13170 " // comment\n"
13171 "private:\n"
13172 " int j;\n"
13175 verifyNoChange("struct foo {\n"
13176 "#ifdef FOO\n"
13177 "#endif\n"
13178 "\n"
13179 "private:\n"
13180 " int i;\n"
13181 "#ifdef FOO\n"
13182 "\n"
13183 "private:\n"
13184 "#endif\n"
13185 " int j;\n"
13188 verifyFormat("struct foo {\n"
13189 "#ifdef FOO\n"
13190 "#endif\n"
13191 "private:\n"
13192 " int i;\n"
13193 "#ifdef FOO\n"
13194 "private:\n"
13195 "#endif\n"
13196 " int j;\n"
13201 verifyFormat("struct foo {\n"
13202 "FOO private:\n"
13203 " int i;\n"
13204 "BAR(x) protected:\n"
13205 " int j;\n"
13211 verifyFormat("struct foo {\n"
13212 "private:\n"
13213 " void f() {}\n"
13214 "\n"
13215 "private:\n"
13216 " int i;\n"
13217 "\n"
13218 "public:\n"
13219 "protected:\n"
13220 " int j;\n"
13225 verifyFormat("struct foo {\n"
13226 "private:\n"
13227 " void f() {}\n"
13228 "private:\n"
13229 " int i;\n"
13230 "public:\n"
13231 "protected:\n"
13232 " int j;\n"
13237 verifyFormat("struct foo {\n"
13238 "private:\n"
13239 " void f() {}\n"
13240 "\n"
13241 "private:\n"
13242 " int i;\n"
13243 "\n"
13244 "public:\n"
13245 "\n"
13246 "protected:\n"
13247 " int j;\n"
13256 verifyFormat("struct foo {\n"
13257 "private:\n"
13258 " void f() {}\n"
13259 "\n"
13260 "private:\n"
13261 " int i;\n"
13262 "\n"
13263 "protected:\n"
13264 " int j;\n"
13269 verifyFormat("struct foo {\n"
13270 "private:\n"
13271 " void f() {}\n"
13272 "\n"
13273 "private:\n"
13274 " int i;\n"
13275 "\n"
13276 "protected:\n"
13277 " int j;\n"
13279 "struct foo {\n"
13280 "private:\n"
13281 "\n"
13282 " void f() {}\n"
13283 "\n"
13284 "private:\n"
13285 "\n"
13286 " int i;\n"
13287 "\n"
13288 "protected:\n"
13289 "\n"
13290 " int j;\n"
13295 verifyFormat("struct foo {\n"
13296 "private:\n"
13297 "\n"
13298 " void f() {}\n"
13299 "\n"
13300 "private:\n"
13301 "\n"
13302 " int i;\n"
13303 "\n"
13304 "protected:\n"
13305 "\n"
13306 " int j;\n"
13311 verifyFormat("struct foo {\n"
13312 "private:\n"
13313 "\n"
13314 " void f() {}\n"
13315 "\n"
13316 "private:\n"
13317 "\n"
13318 " int i;\n"
13319 "\n"
13320 "protected:\n"
13321 "\n"
13322 " int j;\n"
13324 "struct foo {\n"
13325 "private:\n"
13326 " void f() {}\n"
13327 "\n"
13328 "private:\n"
13329 " int i;\n"
13330 "\n"
13331 "protected:\n"
13332 " int j;\n"
13339 verifyFormat("struct foo {\n"
13340 "private:\n"
13341 " void f() {}\n"
13342 "\n"
13343 "private:\n"
13344 " int i;\n"
13345 "\n"
13346 "protected:\n"
13347 " int j;\n"
13352 verifyFormat("struct foo {\n"
13353 "private:\n"
13354 " void f() {}\n"
13355 "\n"
13356 "private:\n"
13357 " int i;\n"
13358 "\n"
13359 "protected:\n"
13360 " int j;\n"
13362 "struct foo {\n"
13363 "private:\n"
13364 "\n\n\n"
13365 " void f() {}\n"
13366 "\n"
13367 "private:\n"
13368 "\n\n\n"
13369 " int i;\n"
13370 "\n"
13371 "protected:\n"
13372 "\n\n\n"
13373 " int j;\n"
13378 verifyNoChange("struct foo {\n"
13379 "private:\n"
13380 "\n"
13381 " void f() {}\n"
13382 "\n"
13383 "private:\n"
13384 "\n"
13385 " int i;\n"
13386 "\n"
13387 "protected:\n"
13388 "\n"
13389 " int j;\n"
13393 verifyFormat("struct foo {\n"
13394 "private:\n"
13395 " void f() {}\n"
13396 "\n"
13397 "private:\n"
13398 " int i;\n"
13399 "\n"
13400 "protected:\n"
13401 " int j;\n"
13405 verifyFormat("struct foo {\n"
13406 "private:\n"
13407 "\n"
13408 " void f() {}\n"
13409 "\n"
13410 "private:\n"
13411 "\n"
13412 " int i;\n"
13413 "\n"
13414 "protected:\n"
13415 "\n"
13416 " int j;\n"
13418 "struct foo {\n"
13419 "private:\n"
13420 "\n\n\n"
13421 " void f() {}\n"
13422 "\n"
13423 "private:\n"
13424 "\n\n\n"
13425 " int i;\n"
13426 "\n"
13427 "protected:\n"
13428 "\n\n\n"
13429 " int j;\n"
13434 verifyNoChange("struct foo {\n"
13435 "private:\n"
13436 "\n\n\n"
13437 " void f() {}\n"
13438 "\n"
13439 "private:\n"
13440 "\n\n\n"
13441 " int i;\n"
13442 "\n"
13443 "protected:\n"
13444 "\n\n\n"
13445 " int j;\n"
13451 verifyFormat("struct foo {\n"
13452 "private:\n"
13453 " // comment\n"
13454 " void f() {}\n"
13455 "\n"
13456 "private: /* comment */\n"
13457 " int i;\n"
13460 verifyFormat("struct foo {\n"
13461 "private:\n"
13462 " // comment\n"
13463 " void f() {}\n"
13464 "\n"
13465 "private: /* comment */\n"
13466 " int i;\n"
13468 "struct foo {\n"
13469 "private:\n"
13470 "\n"
13471 " // comment\n"
13472 " void f() {}\n"
13473 "\n"
13474 "private: /* comment */\n"
13475 "\n"
13476 " int i;\n"
13481 verifyFormat("struct foo {\n"
13482 "private:\n"
13483 "\n"
13484 " // comment\n"
13485 " void f() {}\n"
13486 "\n"
13487 "private: /* comment */\n"
13488 "\n"
13489 " int i;\n"
13491 "struct foo {\n"
13492 "private:\n"
13493 " // comment\n"
13494 " void f() {}\n"
13495 "\n"
13496 "private: /* comment */\n"
13497 " int i;\n"
13500 verifyFormat("struct foo {\n"
13501 "private:\n"
13502 "\n"
13503 " // comment\n"
13504 " void f() {}\n"
13505 "\n"
13506 "private: /* comment */\n"
13507 "\n"
13508 " int i;\n"
13514 verifyFormat("struct foo {\n"
13515 "private:\n"
13516 "#ifdef FOO\n"
13517 "#endif\n"
13518 " void f() {}\n"
13521 verifyFormat("struct foo {\n"
13522 "private:\n"
13523 "#ifdef FOO\n"
13524 "#endif\n"
13525 " void f() {}\n"
13527 "struct foo {\n"
13528 "private:\n"
13529 "\n"
13530 "#ifdef FOO\n"
13531 "#endif\n"
13532 " void f() {}\n"
13535 verifyNoChange("struct foo {\n"
13536 "#ifdef FOO\n"
13537 "#else\n"
13538 "private:\n"
13539 "\n"
13540 "#endif\n"
13543 verifyFormat("struct foo {\n"
13544 "#ifdef FOO\n"
13545 "#else\n"
13546 "private:\n"
13547 "\n"
13548 "#endif\n"
13550 "struct foo {\n"
13551 "#ifdef FOO\n"
13552 "#else\n"
13553 "private:\n"
13554 "\n"
13555 "\n"
13556 "#endif\n"
13559 verifyFormat("struct foo {\n"
13560 "#ifdef FOO\n"
13561 "private:\n"
13562 "#else\n"
13563 "#endif\n"
13565 "struct foo {\n"
13566 "#ifdef FOO\n"
13567 "private:\n"
13568 "\n"
13569 "\n"
13570 "#else\n"
13571 "#endif\n"
13574 verifyFormat("struct foo {\n"
13575 "#if 0\n"
13576 "#else\n"
13577 "#endif\n"
13578 "#ifdef FOO\n"
13579 "private:\n"
13580 "#endif\n"
13582 "struct foo {\n"
13583 "#if 0\n"
13584 "#else\n"
13585 "#endif\n"
13586 "#ifdef FOO\n"
13587 "private:\n"
13588 "\n"
13589 "\n"
13590 "#endif\n"
13595 verifyFormat("struct foo {\n"
13596 "private:\n"
13597 "\n"
13598 "#ifdef FOO\n"
13599 "#endif\n"
13600 " void f() {}\n"
13602 "struct foo {\n"
13603 "private:\n"
13604 "#ifdef FOO\n"
13605 "#endif\n"
13606 " void f() {}\n"
13609 verifyFormat("struct foo {\n"
13610 "private:\n"
13611 "\n"
13612 "#ifdef FOO\n"
13613 "#endif\n"
13614 " void f() {}\n"
13625 verifyFormat("struct foo {\n"
13626 "private:\n"
13627 "\n"
13628 "protected:\n"
13636 verifyFormat("struct foo {\n"
13637 "private:\n"
13638 "protected:\n"
13640 "struct foo {\n"
13641 "private:\n"
13642 "\n\n\n"
13643 "protected:\n"
13651 verifyNoChange("struct foo {\n"
13652 "private:\n"
13653 "\n\n\n"
13654 "protected:\n"
13658 verifyNoChange("struct foo {\n"
13659 "private:\n"
13660 "\n\n\n"
13661 "protected:\n"
13665 verifyNoChange("struct foo {\n"
13666 "private:\n"
13667 "\n\n\n"
13668 "protected:\n"
13678 verifyNoChange("struct foo {\n"
13679 "private:\n"
13680 "\n\n\n"
13681 "protected:\n"
13688 verifyNoChange("struct foo {\n"
13689 "private:\n"
13690 "\n\n\n"
13691 "protected:\n"
13697 verifyNoChange("struct foo {\n"
13698 "private:\n"
13699 "\n\n\n"
13700 "protected:\n"
13707 verifyFormat("struct foo {\n"
13708 "private:\n"
13709 "protected:\n"
13711 "struct foo {\n"
13712 "private:\n"
13713 "\n\n\n"
13714 "protected:\n"
13720 verifyNoChange("struct foo {\n"
13721 "private:\n"
13722 "\n\n\n"
13723 "protected:\n"
13730 verifyFormat("struct foo {\n"
13731 "private:\n"
13732 "protected:\n"
13734 "struct foo {\n"
13735 "private:\n"
13736 "\n\n\n"
13737 "protected:\n"
13743 verifyFormat("struct foo {\n"
13744 "private:\n"
13745 "protected:\n"
13747 "struct foo {\n"
13748 "private:\n"
13749 "\n\n\n"
13750 "protected:\n"
13756 verifyFormat("struct foo {\n"
13757 "private:\n"
13758 "protected:\n"
13760 "struct foo {\n"
13761 "private:\n"
13762 "\n\n\n"
13763 "protected:\n"
13769 verifyFormat("struct foo {\n"
13770 "private:\n"
13771 "protected:\n"
13773 "struct foo {\n"
13774 "private:\n"
13775 "\n\n\n"
13776 "protected:\n"
13782 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
13784 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
13786 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
13787 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
13788 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13790 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13792 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13793 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
13796 "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
13797 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
13799 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
13802 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
13805 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
13806 " .aaaaaaa[0]\n"
13810 verifyFormat("{\n"
13811 " (*a)[0] = 1;\n"
13826 verifyFormat("#include <string>\n"
13827 "#include <a/b/c.h>\n"
13828 "#include \"a/b/string\"\n"
13829 "#include \"string.h\"\n"
13830 "#include \"string.h\"\n"
13831 "#include <a-a>\n"
13832 "#include < path with space >\n"
13834 "#include \"abc.h\" // this is included for ABC\n"
13835 "#include \"some long include\" // with a comment\n"
13836 "#include \"some very long include path\"\n"
13847 verifyFormat("#if __has_include(<strstream>)\n"
13848 "#include <strstream>\n"
13868 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
13880 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
13881 " double *min_x,\n"
13882 " double *max_x,\n"
13883 " double *min_y,\n"
13884 " double *max_y,\n"
13885 " double *min_z,\n"
13892 verifyFormat("void f() {\n"
13893 " if (0)\n"
13894 " return;\n"
13895 "}\n"
13898 verifyFormat("void f() {\n"
13899 " if (0)\n"
13900 " return\n"
13901 "}\n"
13907 verifyFormat("void f() {\n"
13908 " if (a)\n"
13909 " return\n"
13912 verifyFormat("namespace N {\n"
13913 "void f()\n"
13915 "namespace N { void f() }");
13916 verifyFormat("namespace N {\n"
13917 "void f() {}\n"
13918 "void g()\n"
13919 "} // namespace N",
13920 "namespace N { void f( ) { } void g( ) }");
13924 verifyFormat("int aaaaaaaa =\n"
13925 " // Overlylongcomment\n"
13928 verifyFormat("function(\n"
13929 " ShortArgument,\n"
13936 verifyFormat("class A {\n"
13937 "public\n"
13938 " void f() {}\n"
13940 verifyFormat("public\n"
13942 verifyFormat("public\n"
13944 verifyFormat("public\n"
13945 "{\n"
13947 verifyFormat("public\n"
13955 verifyNoCrash("struct X {\n"
13956 " operator iunt(\n"
13958 verifyNoCrash("struct Foo {\n"
13959 " operator foo(bar\n"
13976 verifyFormat("do {\n}");
13977 verifyFormat("do {\n}\n"
13979 verifyFormat("do {\n}\n"
13981 verifyFormat("do {\n"
13982 " f();\n"
13987 verifyFormat("if {\n foo;\n foo();\n}");
13988 verifyFormat("switch {\n foo;\n foo();\n}");
13989 verifyIncompleteFormat("for {\n foo;\n foo();\n}");
13991 verifyFormat("while {\n foo;\n foo();\n}");
13992 verifyFormat("do {\n foo;\n foo();\n} while;");
13996 verifyIncompleteFormat("namespace {\n"
13997 "class Foo { Foo (\n"
13998 "};\n"
14003 verifyFormat("{\n"
14004 " {\n"
14006 "{\n"
14007 "{\n"
14009 verifyFormat("{\n"
14010 " {\n"
14012 "{\n"
14013 " {\n"
14015 verifyFormat("{\n"
14016 " {\n"
14018 verifyFormat("{\n"
14019 " {\n"
14020 " }\n"
14021 "}\n"
14023 "{\n"
14024 " {\n"
14025 " }\n"
14026 " }\n"
14029 verifyFormat("{\n"
14030 " {\n"
14031 " breakme(\n"
14032 " qwe);\n"
14034 "{\n"
14035 " {\n"
14036 " breakme(qwe);\n"
14042 verifyFormat("int x = {\n"
14043 " avariable,\n"
14054 verifyFormat("vector<int> x{\n"
14055 " 1,\n"
14056 " 2,\n"
14057 " 3,\n"
14058 " 4,\n"
14073 verifyFormat("class Class {\n"
14074 " T member = {arg1, arg2};\n"
14088 verifyFormat("Node n{1, Node{1000}, //\n"
14090 verifyFormat("Aaaa aaaaaaa{\n"
14091 " {\n"
14092 " aaaa,\n"
14093 " },\n"
14095 verifyFormat("class C : public D {\n"
14096 " SomeClass SC{2};\n"
14098 verifyFormat("class C : public A {\n"
14099 " class D : public B {\n"
14100 " void f() { int i{2}; }\n"
14101 " };\n"
14106 "class A {\n"
14107 " A() : a{} {}\n"
14108 " A() : Base<int>{} {}\n"
14109 " A() : Base<Foo<int>>{} {}\n"
14110 " A(int b) : b(b) {}\n"
14111 " A(int a, int b) : a(a), bs{{bs...}} { f(); }\n"
14112 " int a, b;\n"
14113 " explicit Expr(const Scalar<Result> &x) : u{Constant<Result>{x}} {}\n"
14115 "{}\n"
14121 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
14122 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
14123 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
14128 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
14131 verifyFormat("const Aaaaaa aaaaa = {\n"
14132 " aaaaaaaaaaa,\n"
14133 " bbbbbbbbbbb,\n"
14134 " ccccccccccc,\n"
14135 " ddddddddddd,\n"
14141 verifyFormat("void f() {\n"
14142 " return; // comment\n"
14143 "}\n"
14145 verifyFormat("void f() {\n"
14146 " if (a) {\n"
14147 " f();\n"
14148 " }\n"
14149 "}\n"
14155 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
14156 " bbbbb,\n"
14157 " ccccc,\n"
14158 " ddddd,\n"
14159 " eeeee,\n"
14160 " ffffff,\n"
14161 " ggggg,\n"
14162 " hhhhhh,\n"
14163 " iiiiii,\n"
14164 " jjjjjj,\n"
14167 verifyFormat("const Aaaaaa aaaaa = {\n"
14168 " aaaaa,\n"
14169 " bbbbb,\n"
14170 " ccccc,\n"
14171 " ddddd,\n"
14172 " eeeee,\n"
14173 " ffffff,\n"
14174 " ggggg,\n"
14175 " hhhhhh,\n"
14176 " iiiiii,\n"
14177 " jjjjjj,\n"
14178 " kkkkkk,\n"
14182 "const Aaaaaa aaaaa = {\n"
14183 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n"
14184 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n"
14185 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
14190 verifyFormat("static uint8 CddDp83848Reg[] = {\n"
14191 " CDDDP83848_BMCR_REGISTER,\n"
14192 " CDDDP83848_BMSR_REGISTER,\n"
14194 "static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
14195 " CDDDP83848_BMSR_REGISTER,\n"
14201 verifyFormat("Constructor::Constructor()\n"
14202 " : some_value{ //\n"
14203 " aaaaaaa, //\n"
14209 verifyFormat("function({// First element:\n"
14210 " 1,\n"
14211 " // Second element:\n"
14213 "function({\n"
14214 " // First element:\n"
14215 " 1,\n"
14216 " // Second element:\n"
14218 verifyFormat("std::vector<int> MyNumbers{\n"
14219 " // First element:\n"
14220 " 1,\n"
14221 " // Second element:\n"
14223 "std::vector<int> MyNumbers{// First element:\n"
14224 " 1,\n"
14225 " // Second element:\n"
14230 verifyFormat("vector<int> SomeVector = {\n"
14231 " // aaa\n"
14232 " 1,\n"
14233 " 2,\n"
14235 "vector<int> SomeVector = { // aaa\n"
14245 "std::runtime_error{\n"
14265 verifyFormat("class Class {\n"
14266 " T member = { arg1, arg2 };\n"
14270 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
14271 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
14272 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
14279 "someFunction(OtherParam,\n"
14280 " BracedList{ // comment 1 (Forcing interesting break)\n"
14281 " param1, param2,\n"
14282 " // comment 2\n"
14286 "std::this_thread::sleep_for(\n"
14289 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
14290 " aaaaaaa,\n"
14291 " aaaaaaaaaa,\n"
14292 " aaaaa,\n"
14293 " aaaaaaaaaaaaaaa,\n"
14294 " aaa,\n"
14295 " aaaaaaaaaa,\n"
14296 " a,\n"
14297 " aaaaaaaaaaaaaaaaaaaaa,\n"
14298 " aaaaaaaaaaaa,\n"
14299 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
14300 " aaaaaaa,\n"
14308 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
14309 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
14310 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
14311 " { \"ccccccccccccccccccccc\", 2 }\n"
14314 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
14315 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
14316 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
14317 " { \"ccccccccccccccccccccc\", 2 }\n"
14333 verifyFormat("vector< int > x{ // comment 1\n"
14337 verifyFormat("vector< int > x{\n"
14341 verifyFormat("vector< int > x{ 1, 2,\n"
14344 verifyFormat("vector< int > x{\n"
14345 " 1,\n"
14346 " 2,\n"
14347 " 3,\n"
14348 " 4,\n"
14358 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14359 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14360 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14361 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14362 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14364 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
14365 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14366 " 1, 22, 333, 4444, 55555, //\n"
14367 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14370 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14371 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14372 " 1, 22, 333, 4444, 55555, 666666, // comment\n"
14373 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
14374 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
14375 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n"
14377 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
14378 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
14380 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
14381 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
14382 " // Separating comment.\n"
14384 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
14385 " // Leading comment\n"
14386 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
14388 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
14391 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
14394 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
14398 "static unsigned SomeValues[10][3] = {\n"
14399 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n"
14401 verifyFormat("static auto fields = new vector<string>{\n"
14402 " \"aaaaaaaaaaaaa\",\n"
14403 " \"aaaaaaaaaaaaa\",\n"
14404 " \"aaaaaaaaaaaa\",\n"
14405 " \"aaaaaaaaaaaaaa\",\n"
14406 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
14407 " \"aaaaaaaaaaaa\",\n"
14408 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
14411 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
14412 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
14417 verifyFormat("vector<int> x = {\n"
14418 " 1, 1, 1, 1, 1, 1, 1, 1,\n"
14421 verifyFormat("vector<int> x = {\n"
14422 " 1, 1, 1, 1, 1, 1, 1, 1, //\n"
14425 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
14426 " 1, 1, 1, 1,\n"
14431 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n"
14432 " 1111111111, 2222222222, 33333333333, 4444444444, //\n"
14433 " 111111111, 222222222, 3333333333, 444444444, //\n"
14436 verifyFormat("int aaaaa[] = {\n"
14437 " 1, 2, 3, // comment\n"
14438 " 4, 5, 6 // comment\n"
14444 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
14445 " {aaaaaaaaaaaaaaaaaaa},\n"
14446 " {aaaaaaaaaaaaaaaaaaaaa},\n"
14450 "SomeStruct my_struct_array = {\n"
14451 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
14452 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
14453 " {aaa, aaa},\n"
14454 " {aaa, aaa},\n"
14455 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
14456 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
14460 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
14466 verifyFormat("void f() {\n"
14467 " struct Dummy {};\n"
14468 " f(v);\n"
14470 verifyFormat("void foo() {\n"
14471 " { // asdf\n"
14472 " {\n"
14473 " int a;\n"
14474 " }\n"
14475 " }\n"
14476 " {\n"
14477 " {\n"
14478 " int b;\n"
14479 " }\n"
14480 " }\n"
14482 verifyFormat("namespace n {\n"
14483 "void foo() {\n"
14484 " {\n"
14485 " {\n"
14486 " statement();\n"
14487 " if (false) {\n"
14488 " }\n"
14489 " }\n"
14490 " }\n"
14491 " {\n"
14492 " }\n"
14493 "}\n"
14494 "} // namespace n");
14498 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14499 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14500 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14501 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14502 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
14507 verifyFormat("std::vector<int> a = {\n"
14508 " aaaaaaaa,\n"
14509 " aaaaaaaa,\n"
14510 " aaaaaaaa,\n"
14511 " aaaaaaaa,\n"
14512 " aaaaaaaaaa,\n"
14513 " aaaaaaaa,\n"
14516 verifyFormat("vector<int> aaaa = {\n"
14517 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
14518 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
14519 " aaaaaa.aaaaaaa,\n"
14520 " aaaaaa.aaaaaaa,\n"
14521 " aaaaaa.aaaaaaa,\n"
14522 " aaaaaa.aaaaaaa,\n"
14526 verifyFormat("someFunction(Param, {List1, List2,\n"
14529 verifyFormat("someFunction(Param, Param,\n"
14530 " {List1, List2,\n"
14533 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
14538 "waarudo::unit desk = {\n"
14541 "Output{1, 2}; },\n"
14546 verifyFormat("waarudo::unit desk = {\n"
14557 verifyFormat("void f() {\n"
14558 " return 42;\n"
14561 verifyFormat("void f() {\n"
14562 " // Comment\n"
14564 verifyFormat("{\n"
14565 "#error {\n"
14566 " int a;\n"
14568 verifyFormat("{\n"
14569 " int a;\n"
14570 "#error {\n"
14574 verifyFormat("void f() {\n"
14577 verifyFormat("void f() {\n"
14578 " int a;\n"
14581 verifyFormat("void f() {\n"
14586 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
14589 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
14590 verifyGoogleFormat("class C {\n"
14591 " C()\n"
14592 " : iiiiiiii(nullptr),\n"
14593 " kkkkkkk(nullptr),\n"
14594 " mmmmmmm(nullptr),\n"
14595 " nnnnnnn(nullptr) {}\n"
14600 verifyFormat("class C {\n"
14601 " A() : b(0) {}\n"
14604 verifyFormat("A()\n"
14605 " : b(0) {\n"
14607 "A()\n:b(0)\n{\n}", NoColumnLimit);
14612 verifyFormat("class C {\n"
14613 "#pragma foo\n"
14614 " int foo { return 0; }\n"
14617 verifyFormat("class C {\n"
14618 "#pragma foo\n"
14619 " void foo {}\n"
14626 verifyFormat("A() : b(0) {\n"
14629 verifyNoChange("A()\n"
14630 " : b(0) {\n"
14633 verifyFormat("A()\n"
14634 " : b(0) {\n"
14636 "A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit);
14638 verifyFormat("#define A \\\n"
14639 " void f() { \\\n"
14640 " int i; \\\n"
14643 verifyFormat("#define A \\\n"
14646 verifyFormat("#define A \\\n"
14647 " void f() { \\\n"
14648 " int i; \\\n"
14649 " } \\\n"
14652 verifyFormat("#define A \\\n"
14653 " void f() { int i; } \\\n"
14658 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14659 " aaaaaaaaaaaaaaaaaa,\n"
14664 verifyFormat(Code, "void foo() { /* Empty */\n"
14666 verifyFormat(Code, "void foo() {\n"
14667 "/* Empty */\n"
14674 verifyFormat("class C {\n"
14675 " int f() {}\n"
14678 verifyFormat("class C {\n"
14679 " int f() {\n"
14680 " return 42;\n"
14681 " }\n"
14685 verifyFormat("int f() {\n"
14686 " return 42;\n"
14694 verifyFormat("class C {\n"
14695 " int f() {}\n"
14703 verifyFormat("class C {\n"
14704 " int f() { return 42; }\n"
14707 verifyFormat("int f() {\n"
14708 " return 42;\n"
14713 verifyFormat("class C {\n"
14714 " int f() {}\n"
14719 verifyFormat("auto lambda = []() {\n"
14720 " // comment\n"
14721 " f();\n"
14722 " g();\n"
14726 verifyFormat("class C {\n"
14727 "#ifdef A\n"
14728 " int f() { return 42; }\n"
14729 "#endif\n"
14733 verifyFormat("struct S {\n"
14734 "// comment\n"
14735 "#ifdef FOO\n"
14736 " int foo() { bar(); }\n"
14737 "#endif\n"
14744 verifyFormat("class C {\n"
14745 " int f() { return 42; }\n"
14748 verifyFormat("int f()\n"
14749 "{\n"
14750 " return 42;\n"
14756 verifyFormat("class C {\n"
14757 " int f() {}\n"
14763 verifyFormat("class C\n"
14764 "{\n"
14765 " int f() { return 42; }\n"
14768 verifyFormat("struct C\n"
14769 "{\n"
14770 " int f() { return 42; }\n"
14773 verifyFormat("int f()\n"
14774 "{\n"
14775 " return 42;\n"
14779 verifyFormat("class C\n"
14780 "{\n"
14781 " int f() { return 42; }\n"
14784 verifyFormat("struct C\n"
14785 "{\n"
14786 " int f() { return 42; }\n"
14789 verifyFormat("struct C\n"
14790 "// comment\n"
14791 "/* comment */\n"
14792 "// comment\n"
14793 "{\n"
14794 " int f() { return 42; }\n"
14797 verifyFormat("/* comment */ struct C\n"
14798 "{\n"
14799 " int f() { return 42; }\n"
14808 verifyFormat("class C {\n"
14809 " int f() { return 42; }\n"
14812 verifyFormat("int f() {\n"
14813 " return 42;\n"
14818 verifyFormat("class C {\n"
14819 " int f() {}\n"
14822 verifyFormat("int f() {\n"
14829 verifyFormat("class C {\n"
14830 " int f() { return 42; }\n"
14833 verifyFormat("int f()\n"
14834 "{\n"
14835 " return 42;\n"
14840 verifyFormat("int f()\n"
14841 "{\n"
14844 verifyFormat("class C {\n"
14845 " int f() {}\n"
14857 verifyFormat("int f()\n"
14860 verifyFormat("int f()\n"
14861 "{\n"
14862 " return 42;\n"
14865 verifyFormat("int f()\n"
14866 "{\n"
14867 " // some comment\n"
14873 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
14876 verifyFormat("int f()\n"
14877 "{\n"
14878 " return 0;\n"
14883 verifyFormat("class Foo {\n"
14884 " int f() {}\n"
14887 verifyFormat("class Foo {\n"
14888 " int f() { return 0; }\n"
14891 verifyFormat("class Foo {\n"
14892 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
14893 " {}\n"
14896 verifyFormat("class Foo {\n"
14897 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
14898 " {\n"
14899 " return 0;\n"
14900 " }\n"
14907 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
14910 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
14911 "{\n"
14912 " return 0;\n"
14927 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
14928 " int bbbbbbbbbbbbbbbbbbbbbbbb)\n"
14929 "{\n"
14932 verifyFormat("class C {\n"
14933 " C()\n"
14934 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa(),\n"
14935 " bbbbbbbbbbbbbbbbbbb()\n"
14936 " {\n"
14937 " }\n"
14938 " void\n"
14939 " m(int aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
14940 " int bbbbbbbbbbbbbbbbbbbbbbbb)\n"
14941 " {\n"
14942 " }\n"
14950 verifyFormat("#ifdef A\n"
14951 "int f() {}\n"
14952 "#else\n"
14953 "int g() {}\n"
14964 verifyFormat("class Foo\n"
14967 verifyFormat("/* something */ class Foo\n"
14970 verifyFormat("template <typename X> class Foo\n"
14973 verifyFormat("class Foo\n"
14974 "{\n"
14975 " Foo();\n"
14978 verifyFormat("typedef class Foo\n"
14979 "{\n"
14985 verifyFormat("class rep\n"
14986 "{\n"
14989 verifyFormat("struct rep\n"
14990 "{\n"
14993 verifyFormat("template <typename T> class rep\n"
14994 "{\n"
14997 verifyFormat("template <typename T> struct rep\n"
14998 "{\n"
15001 verifyFormat("class rep\n"
15002 "{\n"
15003 " int x;\n"
15006 verifyFormat("struct rep\n"
15007 "{\n"
15008 " int x;\n"
15011 verifyFormat("template <typename T> class rep\n"
15012 "{\n"
15013 " int x;\n"
15016 verifyFormat("template <typename T> struct rep\n"
15017 "{\n"
15018 " int x;\n"
15021 verifyFormat("template <typename T> class rep // Foo\n"
15022 "{\n"
15023 " int x;\n"
15026 verifyFormat("template <typename T> struct rep // Bar\n"
15027 "{\n"
15028 " int x;\n"
15032 verifyFormat("template <typename T> class rep<T>\n"
15033 "{\n"
15034 " int x;\n"
15038 verifyFormat("template <typename T> class rep<std::complex<T>>\n"
15039 "{\n"
15040 " int x;\n"
15043 verifyFormat("template <typename T> class rep<std::complex<T>>\n"
15044 "{\n"
15048 verifyFormat("#include \"stdint.h\"\n"
15051 verifyFormat("#include <stdint.h>\n"
15054 verifyFormat("#include <stdint.h>\n"
15056 "#include <stdint.h>\n"
15057 "namespace rep {\n"
15058 "\n"
15059 "\n"
15070 verifyFormat("struct Foo\n"
15073 verifyFormat("/* something */ struct Foo\n"
15076 verifyFormat("template <typename X> struct Foo\n"
15079 verifyFormat("struct Foo\n"
15080 "{\n"
15081 " Foo();\n"
15084 verifyFormat("typedef struct Foo\n"
15085 "{\n"
15097 verifyFormat("union Foo\n"
15100 verifyFormat("/* something */ union Foo\n"
15103 verifyFormat("union Foo\n"
15104 "{\n"
15105 " A,\n"
15108 verifyFormat("typedef union Foo\n"
15109 "{\n"
15120 verifyFormat("namespace Foo\n"
15123 verifyFormat("/* something */ namespace Foo\n"
15126 verifyFormat("inline namespace Foo\n"
15129 verifyFormat("/* something */ inline namespace Foo\n"
15132 verifyFormat("export namespace Foo\n"
15135 verifyFormat("namespace Foo\n"
15136 "{\n"
15137 "void Bar();\n"
15145 verifyFormat("class Foo {\n"
15146 " Foo();\n"
15149 verifyFormat("typedef class Foo {\n"
15150 " Foo();\n"
15153 verifyFormat("struct Foo {\n"
15154 " Foo();\n"
15157 verifyFormat("typedef struct Foo {\n"
15158 " Foo();\n"
15161 verifyFormat("union Foo {\n"
15162 " A,\n"
15165 verifyFormat("typedef union Foo {\n"
15166 " A,\n"
15169 verifyFormat("namespace Foo {\n"
15170 "void Bar();\n"
15179 verifyFormat("class Foo\n"
15180 "{\n"
15181 " Foo();\n"
15184 verifyFormat("typedef class Foo\n"
15185 "{\n"
15186 " Foo();\n"
15189 verifyFormat("struct Foo\n"
15190 "{\n"
15191 " Foo();\n"
15194 verifyFormat("typedef struct Foo\n"
15195 "{\n"
15196 " Foo();\n"
15199 verifyFormat("union Foo\n"
15200 "{\n"
15201 " A,\n"
15204 verifyFormat("typedef union Foo\n"
15205 "{\n"
15206 " A,\n"
15209 verifyFormat("namespace Foo\n"
15210 "{\n"
15211 "void Bar();\n"
15218 verifyFormat("struct foo a = {bar};\nint n;");
15219 verifyFormat("class foo a = {bar};\nint n;");
15220 verifyFormat("union foo a = {bar};\nint n;");
15223 verifyFormat("struct foo f() {}\nint n;");
15224 verifyFormat("class foo f() {}\nint n;");
15225 verifyFormat("union foo f() {}\nint n;");
15228 verifyFormat("template <class X> void f() {}\nint n;");
15229 verifyFormat("template <struct X> void f() {}\nint n;");
15230 verifyFormat("template <union X> void f() {}\nint n;");
15233 verifyFormat("struct {\n} n;");
15235 "template <template <class T, class Y>, class Z> class X {\n} n;");
15236 verifyFormat("union Z {\n int n;\n} x;");
15237 verifyFormat("class MACRO Z {\n} n;");
15238 verifyFormat("class MACRO(X) Z {\n} n;");
15239 verifyFormat("class __attribute__((X)) Z {\n} n;");
15240 verifyFormat("class __declspec(X) Z {\n} n;");
15241 verifyFormat("class A##B##C {\n} n;");
15242 verifyFormat("class alignas(16) Z {\n} n;");
15243 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
15244 verifyFormat("class MACROA MACRO(X) Z {\n} n;");
15247 verifyFormat("class A::B::C {\n} n;");
15251 "template <typename F>\n"
15252 "Matcher(const Matcher<F> &Other,\n"
15253 " typename enable_if_c<is_base_of<F, T>::value &&\n"
15254 " !is_same<F, T>::value>::type * = 0)\n"
15261 verifyFormat("class A<int> f() {}\n"
15262 "int n;");
15263 verifyFormat("template <typename T> class A<T> f() {}\n"
15264 "int n;");
15266 verifyFormat("template <> class Foo<int> F() {\n"
15267 "} n;");
15271 verifyFormat("if (true)\n"
15272 " class X x;\n"
15273 "else\n"
15293 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"
15294 " defined(BBBBBBBB)\n"
15295 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"
15296 " defined(BBBBBBBB)\n"
15305 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
15306 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
15307 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
15311 verifyFormat("#define A \\\n"
15314 verifyFormat("#define A \\\n"
15315 " f(); \\\n"
15316 " if (true)\n"
15319 verifyFormat("#define A \\\n"
15320 " f(); \\\n"
15321 " if (true)\n"
15324 verifyFormat("{\n"
15325 "#ifdef A\n"
15326 " // Comment\n"
15327 " if (true) continue;\n"
15328 "#endif\n"
15329 " // Comment\n"
15330 " if (true) continue;\n"
15334 verifyFormat("#define A \\\n"
15337 verifyFormat("#define A \\\n"
15341 verifyFormat("#define A \\\n"
15342 " if (aaaaaaaaaa) return 1; \\\n"
15346 verifyFormat("#define A \\\n"
15347 " if (aaaaaaaaaa) \\\n"
15348 " return 1; \\\n"
15351 verifyFormat("#define A \\\n"
15352 " if constexpr (aaaaaaa) \\\n"
15353 " return 1; \\\n"
15356 verifyFormat("#define A \\\n"
15357 " if CONSTEXPR (aaaaaaa) \\\n"
15358 " return 1; \\\n"
15362 verifyFormat("//\n"
15363 "#define a \\\n"
15364 " if \\\n"
15372 verifyFormat("class A {\n void f(int *a);\n};");
15373 verifyFormat("class A {\n int *a;\n};");
15374 verifyFormat("namespace a {\n"
15375 "namespace b {\n"
15376 "class A {\n"
15377 " void f() {}\n"
15378 " int *a;\n"
15379 "};\n"
15380 "} // namespace b\n"
15391 std::string Code("A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" // 20x
15392 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
15393 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
15394 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
15395 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
15396 "A(1, 1)\n"
15397 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
15398 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
15399 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
15400 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
15401 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
15402 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
15403 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
15404 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
15405 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
15406 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
15434 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
15436 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
15437 " inRange:(NSRange)range\n"
15438 " outRange:(NSRange)out_range\n"
15439 " outRange1:(NSRange)out_range1\n"
15440 " outRange2:(NSRange)out_range2\n"
15441 " outRange3:(NSRange)out_range3\n"
15442 " outRange4:(NSRange)out_range4\n"
15443 " outRange5:(NSRange)out_range5\n"
15444 " outRange6:(NSRange)out_range6\n"
15445 " outRange7:(NSRange)out_range7\n"
15446 " outRange8:(NSRange)out_range8\n"
15454 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
15455 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
15456 " anotherName:(NSString)bbbbbbbbbbbbbb {\n"
15460 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
15461 " veryLooooooooooongName:(NSString)cccccccccccccc\n"
15462 " anotherName:(NSString)dddddddddddddd {\n"
15484 EXPECT_EQ("\"some text \"\n"
15488 EXPECT_EQ("\"some text \"\n"
15490 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
15491 verifyFormat("#define A \\\n"
15492 " \"some \" \\\n"
15493 " \"text \" \\\n"
15496 verifyFormat("#define A \\\n"
15497 " \"so \" \\\n"
15498 " \"text \" \\\n"
15505 EXPECT_EQ("\"some \"\n"
15509 EXPECT_EQ("\"some \"\n"
15513 EXPECT_EQ("\"some\"\n"
15514 "\" tex\"\n"
15518 EXPECT_EQ("\"some\"\n"
15519 "\" tex\"\n"
15523 EXPECT_EQ("\"some\"\n"
15524 "\"/tex\"\n"
15528 verifyFormat("variable =\n"
15529 " \"long string \"\n"
15534 verifyFormat("variable = f(\n"
15535 " \"long string \"\n"
15536 " \"literal\",\n"
15537 " short,\n"
15543 verifyFormat("f(g(\"long string \"\n"
15544 " \"literal\"),\n"
15548 verifyFormat("f(g(\"long string \"\n"
15549 " \"literal\",\n"
15550 " a),\n"
15554 verifyFormat("f(\"one two\".split(\n"
15557 verifyFormat("f(\"one two three four five six \"\n"
15558 " \"seven\".split(\n"
15564 verifyFormat("f(\"some \"\n"
15565 " \"text\",\n"
15571 "aaaaaaaaaaaaaaaaaaaa(\n"
15572 " aaaaaaaaaaaaaaaaaaaa,\n"
15576 EXPECT_EQ("\"splitmea\"\n"
15577 "\"trandomp\"\n"
15582 EXPECT_EQ("\"split/\"\n"
15583 "\"pathat/\"\n"
15588 EXPECT_EQ("\"split/\"\n"
15589 "\"pathat/\"\n"
15593 EXPECT_EQ("\"split at \"\n"
15594 "\"spaces/at/\"\n"
15595 "\"slashes.at.any$\"\n"
15596 "\"non-alphanumeric%\"\n"
15597 "\"1111111111characte\"\n"
15610 verifyFormat("aaaaaaaaaaaa(\n"
15611 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
15617 verifyFormat("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
15623 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
15628 verifyFormat("ffff(\n"
15629 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
15641 verifyFormat("#define A \\\n"
15642 " \"some \" \\\n"
15643 " \"text \" \\\n"
15649 verifyFormat("C a = \"some more \"\n"
15657 verifyFormat("int i = a(b());", "int i=a(\n\n b(\n\n\n )\n\n);",
15665 "(\n"
15675 "u8\"utf8 string \"\n"
15680 "u\"utf16 string \"\n"
15685 "U\"utf32 string \"\n"
15689 EXPECT_EQ("L\"wide string \"\n"
15692 verifyFormat("@\"NSString \"\n"
15717 "_T(\"aaaaaaaaaaaaaa\")\n"
15718 "_T(\"aaaaaaaaaaaaaa\")\n"
15721 verifyFormat("f(x,\n"
15722 " _T(\"aaaaaaaaaaaa\")\n"
15723 " _T(\"aaa\"),\n"
15728 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
15729 // "_T(\"aaaaaaaaaaaaa\")\n"
15730 // "_T(\"aaaaaaaaaaaaa\")\n"
15736 verifyFormat("f(\n"
15737 "#if !TEST\n"
15738 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
15739 "#endif\n"
15741 "f(\n"
15742 "#if !TEST\n"
15743 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
15744 "#endif\n"
15746 verifyFormat("f(\n"
15747 "\n"
15749 "f(\n"
15750 "\n"
15763 verifyFormat("func(a, \"long long \"\n"
15769 verifyFormat("func(a,\n"
15770 " \"long long long \"\n"
15771 " \"long\",\n"
15777 verifyFormat("func(a, b,\n"
15778 " \"long long long \"\n"
15784 verifyFormat("func(a,\n"
15785 " \"long long long \"\n"
15786 " \"long\",\n"
15787 " \"long long long \"\n"
15793 verifyFormat("a << \"line line \"\n"
15798 verifyFormat("abcde << \"line \"\n"
15799 " \"line line\"\n"
15805 verifyFormat("a << b\n"
15806 " << \"line line \"\n"
15811 verifyFormat("abcd << \"line line \"\n"
15812 " \"line\"\n"
15813 " << \"line line \"\n"
15819 verifyFormat("abcd + \"line line \"\n"
15824 verifyFormat("abcd +\n"
15825 " \"line line \"\n"
15826 " \"line line\" +\n"
15834 verifyFormat("someFunction(\n"
15835 " \"long long long \"\n"
15836 " \"long\",\n"
15840 verifyFormat("someFunction(\n"
15841 " \"long long long \"\n"
15842 " \"long\",\n"
15843 " a\n"
15849 verifyFormat("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
15850 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
15852 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
15853 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
15860 verifyFormat("fffffffffff(g(R\"x(\n"
15861 "multiline raw string literal xxxxxxxxxxxxxx\n"
15862 ")x\",\n"
15863 " a),\n"
15865 "fffffffffff(g(R\"x(\n"
15866 "multiline raw string literal xxxxxxxxxxxxxx\n"
15869 verifyFormat("fffffffffff(\n"
15870 " g(R\"x(qqq\n"
15871 "multiline raw string literal xxxxxxxxxxxxxx\n"
15872 ")x\",\n"
15873 " a),\n"
15875 "fffffffffff(g(R\"x(qqq\n"
15876 "multiline raw string literal xxxxxxxxxxxxxx\n"
15880 verifyNoChange("fffffffffff(R\"x(\n"
15881 "multiline raw string literal xxxxxxxxxxxxxx\n"
15884 verifyFormat("fffffffffff(R\"x(\n"
15885 "multiline raw string literal xxxxxxxxxxxxxx\n"
15887 "fffffffffff(R\"x(\n"
15888 "multiline raw string literal xxxxxxxxxxxxxx\n"
15891 verifyFormat("fffffffffff(\n"
15892 " R\"x(\n"
15893 "multiline raw string literal xxxxxxxxxxxxxx\n"
15894 ")x\" +\n"
15896 "fffffffffff(\n"
15897 " R\"x(\n"
15898 "multiline raw string literal xxxxxxxxxxxxxx\n"
15902 "fffffffffff(\n"
15908 verifyFormat("function(\"unterminated,\n"
15910 "function( \"unterminated,\n"
15937 verifyFormat("someFunction(\"aaabbbcccd\"\n"
15941 verifyFormat("someFunction1234567890(\n"
15945 verifyFormat("someFunction1234567890(\n"
15946 " \"aaabbbcccdddeeeff\"\n"
15950 verifyFormat("someFunction1234567890(\n"
15951 " \"aaabbbcccdddeeeff\"\n"
15955 verifyFormat("someFunction(\n"
15956 " \"aaabbbcc ddde \"\n"
15960 verifyFormat("someFunction(\"aaabbbccc \"\n"
15964 verifyFormat("someFunction1234567890(\n"
15965 " \"aaabb \"\n"
15969 verifyFormat("#define A \\\n"
15970 " string s = \\\n"
15971 " \"123456789\" \\\n"
15972 " \"0\"; \\\n"
15976 verifyFormat("someFunction(\n"
15977 " \"aaabbbcc \"\n"
15987 EXPECT_EQ("\"test\"\n"
15988 "\"\\n\"",
15989 format("\"test\\n\"", getLLVMStyleWithColumns(7)));
15991 EXPECT_EQ("\"tes\\\\\"\n"
15992 "\"n\"",
15993 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
15995 EXPECT_EQ("\"\\\\\\\\\"\n"
15996 "\"\\n\"",
15997 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
16000 EXPECT_EQ("\"\\uff01\"\n"
16005 EXPECT_EQ("\"\\x000000000001\"\n"
16011 EXPECT_EQ("\"test\"\n"
16012 "\"\\000000\"\n"
16016 EXPECT_EQ("\"test\\000\"\n"
16017 "\"00000000\"\n"
16023 verifyFormat("void f() {\n"
16024 " return g() {}\n"
16026 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
16027 "g();\n"
16037 verifyFormat("class X {\n"
16038 " void f() {\n"
16039 " }\n"
16048 verifyFormat("void f() {\n"
16049 " someFunction();\n"
16050 " if (true) {\n"
16051 " f();\n"
16052 " }\n"
16055 verifyFormat("class X {\n"
16056 " void f() {\n"
16057 " }\n"
16060 verifyFormat("int x[] = {\n"
16061 " call(),\n"
16067 verifyFormat("double\n"
16078 verifyFormat("if (aaaaaaaa && // q\n"
16079 " bb)\t\t// w\n"
16081 "if (aaaaaaaa &&// q\n"
16082 "bb)// w\n"
16085 verifyFormat("if (aaa && bbb) // w\n"
16087 "if(aaa&&bbb)// w\n"
16091 verifyFormat("class X {\n"
16092 "\tvoid f() {\n"
16093 "\t\tsomeFunction(parameter1,\n"
16094 "\t\t\t parameter2);\n"
16095 "\t}\n"
16098 verifyFormat("#define A \\\n"
16099 "\tvoid f() { \\\n"
16100 "\t\tsomeFunction( \\\n"
16101 "\t\t parameter1, \\\n"
16102 "\t\t parameter2); \\\n"
16105 verifyFormat("int a;\t // x\n"
16112 verifyFormat("unsigned long long big;\n"
16116 verifyFormat("unsigned long long big;\n"
16120 verifyFormat("unsigned long long big;\n"
16126 verifyFormat("class TabWidth4Indent8 {\n"
16127 "\t\tvoid f() {\n"
16128 "\t\t\t\tsomeFunction(parameter1,\n"
16129 "\t\t\t\t\t\t\t parameter2);\n"
16130 "\t\t}\n"
16136 verifyFormat("class TabWidth4Indent4 {\n"
16137 "\tvoid f() {\n"
16138 "\t\tsomeFunction(parameter1,\n"
16139 "\t\t\t\t\t parameter2);\n"
16140 "\t}\n"
16146 verifyFormat("class TabWidth8Indent4 {\n"
16147 " void f() {\n"
16148 "\tsomeFunction(parameter1,\n"
16149 "\t\t parameter2);\n"
16150 " }\n"
16156 verifyFormat("/*\n"
16157 "\t a\t\tcomment\n"
16158 "\t in multiple lines\n"
16160 " /*\t \t \n"
16161 " \t \t a\t\tcomment\t \t\n"
16162 " \t \t in multiple lines\t\n"
16168 verifyFormat("void f() {\n"
16169 "\tunsigned long long big;\n"
16170 "\tchar* ptr;\n"
16174 verifyFormat("void f() {\n"
16175 "\tunsigned long long big;\n"
16176 "\tchar * ptr;\n"
16180 verifyFormat("void f() {\n"
16181 "\tunsigned long long big;\n"
16182 "\tchar *ptr;\n"
16187 verifyFormat("{\n"
16188 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16189 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16190 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16191 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16192 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16193 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16196 verifyFormat("enum AA {\n"
16197 "\ta1, // Force multiple lines\n"
16198 "\ta2,\n"
16199 "\ta3\n"
16202 verifyFormat("if (aaaaaaaa && // q\n"
16203 " bb) // w\n"
16205 "if (aaaaaaaa &&// q\n"
16206 "bb)// w\n"
16209 verifyFormat("class X {\n"
16210 "\tvoid f() {\n"
16211 "\t\tsomeFunction(parameter1,\n"
16212 "\t\t parameter2);\n"
16213 "\t}\n"
16216 verifyFormat("{\n"
16217 "\tQ(\n"
16218 "\t {\n"
16219 "\t\t int a;\n"
16220 "\t\t someFunction(aaaaaaaa,\n"
16221 "\t\t bbbbbbb);\n"
16222 "\t },\n"
16223 "\t p);\n"
16226 verifyFormat("{\n"
16227 "\t/* aaaa\n"
16228 "\t bbbb */\n"
16230 "{\n"
16231 "/* aaaa\n"
16232 " bbbb */\n"
16235 verifyFormat("{\n"
16236 "\t/*\n"
16237 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16238 "\t bbbbbbbbbbbbb\n"
16239 "\t*/\n"
16241 "{\n"
16242 "/*\n"
16243 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16244 "*/\n"
16247 verifyFormat("{\n"
16248 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16249 "\t// bbbbbbbbbbbbb\n"
16251 "{\n"
16252 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16255 verifyFormat("{\n"
16256 "\t/*\n"
16257 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16258 "\t bbbbbbbbbbbbb\n"
16259 "\t*/\n"
16261 "{\n"
16262 "\t/*\n"
16263 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16264 "\t*/\n"
16267 verifyNoChange("{\n"
16268 "\t/*\n"
16269 "\n"
16270 "\t*/\n"
16273 verifyNoChange("{\n"
16274 "\t/*\n"
16275 " asdf\n"
16276 "\t*/\n"
16280 verifyFormat("void f() {\n"
16281 "\treturn true ? aaaaaaaaaaaaaaaaaa\n"
16282 "\t : bbbbbbbbbbbbbbbbbb\n"
16287 verifyFormat("void f() {\n"
16288 "\treturn true ? aaaaaaaaaaaaaaaaaa :\n"
16289 "\t bbbbbbbbbbbbbbbbbb\n"
16292 verifyFormat("void f() {\n"
16293 "\treturn true ?\n"
16294 "\t aaaaaaaaaaaaaaaaaaaa :\n"
16295 "\t bbbbbbbbbbbbbbbbbbbb\n"
16300 verifyFormat("/*\n"
16301 " a\t\tcomment\n"
16302 " in multiple lines\n"
16304 " /*\t \t \n"
16305 " \t \t a\t\tcomment\t \t\n"
16306 " \t \t in multiple lines\t\n"
16309 verifyFormat("/* some\n"
16311 " \t \t /* some\n"
16314 verifyFormat("int a; /* some\n"
16316 " \t \t int a; /* some\n"
16320 verifyFormat("int a; /* some\n"
16322 " \t \t int\ta; /* some\n"
16325 verifyFormat("f(\"\t\t\"); /* some\n"
16327 " \t \t f(\"\t\t\"); /* some\n"
16330 verifyFormat("{\n"
16331 " /*\n"
16332 " * Comment\n"
16333 " */\n"
16334 " int i;\n"
16336 "{\n"
16337 "\t/*\n"
16338 "\t * Comment\n"
16339 "\t */\n"
16340 "\t int i;\n"
16347 verifyFormat("if (aaaaaaaa && // q\n"
16348 " bb) // w\n"
16350 "if (aaaaaaaa &&// q\n"
16351 "bb)// w\n"
16354 verifyFormat("if (aaa && bbb) // w\n"
16356 "if(aaa&&bbb)// w\n"
16359 verifyFormat("class X {\n"
16360 "\tvoid f() {\n"
16361 "\t\tsomeFunction(parameter1,\n"
16362 "\t\t\t parameter2);\n"
16363 "\t}\n"
16366 verifyFormat("#define A \\\n"
16367 "\tvoid f() { \\\n"
16368 "\t\tsomeFunction( \\\n"
16369 "\t\t parameter1, \\\n"
16370 "\t\t parameter2); \\\n"
16375 verifyFormat("class TabWidth4Indent8 {\n"
16376 "\t\tvoid f() {\n"
16377 "\t\t\t\tsomeFunction(parameter1,\n"
16378 "\t\t\t\t\t\t\t parameter2);\n"
16379 "\t\t}\n"
16384 verifyFormat("class TabWidth4Indent4 {\n"
16385 "\tvoid f() {\n"
16386 "\t\tsomeFunction(parameter1,\n"
16387 "\t\t\t\t\t parameter2);\n"
16388 "\t}\n"
16393 verifyFormat("class TabWidth8Indent4 {\n"
16394 " void f() {\n"
16395 "\tsomeFunction(parameter1,\n"
16396 "\t\t parameter2);\n"
16397 " }\n"
16402 verifyFormat("/*\n"
16403 "\t a\t\tcomment\n"
16404 "\t in multiple lines\n"
16406 " /*\t \t \n"
16407 " \t \t a\t\tcomment\t \t\n"
16408 " \t \t in multiple lines\t\n"
16411 verifyFormat("{\n"
16412 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16413 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16414 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16415 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16416 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16417 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16420 verifyFormat("enum AA {\n"
16421 "\ta1, // Force multiple lines\n"
16422 "\ta2,\n"
16423 "\ta3\n"
16426 verifyFormat("if (aaaaaaaa && // q\n"
16427 " bb) // w\n"
16429 "if (aaaaaaaa &&// q\n"
16430 "bb)// w\n"
16433 verifyFormat("class X {\n"
16434 "\tvoid f() {\n"
16435 "\t\tsomeFunction(parameter1,\n"
16436 "\t\t\t parameter2);\n"
16437 "\t}\n"
16440 verifyFormat("{\n"
16441 "\tQ(\n"
16442 "\t {\n"
16443 "\t\t int a;\n"
16444 "\t\t someFunction(aaaaaaaa,\n"
16445 "\t\t\t\t bbbbbbb);\n"
16446 "\t },\n"
16447 "\t p);\n"
16450 verifyFormat("{\n"
16451 "\t/* aaaa\n"
16452 "\t bbbb */\n"
16454 "{\n"
16455 "/* aaaa\n"
16456 " bbbb */\n"
16459 verifyFormat("{\n"
16460 "\t/*\n"
16461 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16462 "\t bbbbbbbbbbbbb\n"
16463 "\t*/\n"
16465 "{\n"
16466 "/*\n"
16467 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16468 "*/\n"
16471 verifyFormat("{\n"
16472 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16473 "\t// bbbbbbbbbbbbb\n"
16475 "{\n"
16476 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16479 verifyFormat("{\n"
16480 "\t/*\n"
16481 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16482 "\t bbbbbbbbbbbbb\n"
16483 "\t*/\n"
16485 "{\n"
16486 "\t/*\n"
16487 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16488 "\t*/\n"
16491 verifyNoChange("{\n"
16492 "\t/*\n"
16493 "\n"
16494 "\t*/\n"
16497 verifyNoChange("{\n"
16498 "\t/*\n"
16499 " asdf\n"
16500 "\t*/\n"
16503 verifyFormat("/* some\n"
16505 " \t \t /* some\n"
16508 verifyFormat("int a; /* some\n"
16510 " \t \t int a; /* some\n"
16513 verifyFormat("int a; /* some\n"
16515 " \t \t int\ta; /* some\n"
16518 verifyFormat("f(\"\t\t\"); /* some\n"
16520 " \t \t f(\"\t\t\"); /* some\n"
16523 verifyFormat("{\n"
16524 "\t/*\n"
16525 "\t * Comment\n"
16526 "\t */\n"
16527 "\tint i;\n"
16529 "{\n"
16530 "\t/*\n"
16531 "\t * Comment\n"
16532 "\t */\n"
16533 "\t int i;\n"
16538 verifyFormat("{\n"
16539 "\t/* aaaa\n"
16540 "\t\t bbbb */\n"
16542 "{\n"
16543 "/* aaaa\n"
16544 "\t bbbb */\n"
16547 verifyFormat("{\n"
16548 "\t/*\n"
16549 "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16550 "\t\tbbbbbbbbbbbbb\n"
16551 "\t*/\n"
16553 "{\n"
16554 "/*\n"
16555 "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16556 "*/\n"
16563 verifyFormat("class Assign {\n"
16564 "\tvoid f() {\n"
16565 "\t\tint x = 123;\n"
16566 "\t\tint random = 4;\n"
16567 "\t\tstd::string alphabet =\n"
16568 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
16569 "\t}\n"
16576 verifyFormat("if (aaaaaaaa && // q\n"
16577 " bb) // w\n"
16579 "if (aaaaaaaa &&// q\n"
16580 "bb)// w\n"
16583 verifyFormat("if (aaa && bbb) // w\n"
16585 "if(aaa&&bbb)// w\n"
16588 verifyFormat("class X {\n"
16589 "\tvoid f() {\n"
16590 "\t\tsomeFunction(parameter1,\n"
16591 "\t\t parameter2);\n"
16592 "\t}\n"
16595 verifyFormat("#define A \\\n"
16596 "\tvoid f() { \\\n"
16597 "\t\tsomeFunction( \\\n"
16598 "\t\t parameter1, \\\n"
16599 "\t\t parameter2); \\\n"
16604 verifyFormat("class TabWidth4Indent8 {\n"
16605 "\t\tvoid f() {\n"
16606 "\t\t\t\tsomeFunction(parameter1,\n"
16607 "\t\t\t\t parameter2);\n"
16608 "\t\t}\n"
16613 verifyFormat("class TabWidth4Indent4 {\n"
16614 "\tvoid f() {\n"
16615 "\t\tsomeFunction(parameter1,\n"
16616 "\t\t parameter2);\n"
16617 "\t}\n"
16622 verifyFormat("class TabWidth8Indent4 {\n"
16623 " void f() {\n"
16624 "\tsomeFunction(parameter1,\n"
16625 "\t parameter2);\n"
16626 " }\n"
16631 verifyFormat("/*\n"
16632 " a\t\tcomment\n"
16633 " in multiple lines\n"
16635 " /*\t \t \n"
16636 " \t \t a\t\tcomment\t \t\n"
16637 " \t \t in multiple lines\t\n"
16640 verifyFormat("{\n"
16641 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16642 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16643 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16644 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16645 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16646 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
16649 verifyFormat("enum AA {\n"
16650 "\ta1, // Force multiple lines\n"
16651 "\ta2,\n"
16652 "\ta3\n"
16655 verifyFormat("if (aaaaaaaa && // q\n"
16656 " bb) // w\n"
16658 "if (aaaaaaaa &&// q\n"
16659 "bb)// w\n"
16662 verifyFormat("class X {\n"
16663 "\tvoid f() {\n"
16664 "\t\tsomeFunction(parameter1,\n"
16665 "\t\t parameter2);\n"
16666 "\t}\n"
16669 verifyFormat("{\n"
16670 "\tQ(\n"
16671 "\t {\n"
16672 "\t\t int a;\n"
16673 "\t\t someFunction(aaaaaaaa,\n"
16674 "\t\t bbbbbbb);\n"
16675 "\t },\n"
16676 "\t p);\n"
16679 verifyFormat("{\n"
16680 "\t/* aaaa\n"
16681 "\t bbbb */\n"
16683 "{\n"
16684 "/* aaaa\n"
16685 " bbbb */\n"
16688 verifyFormat("{\n"
16689 "\t/*\n"
16690 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16691 "\t bbbbbbbbbbbbb\n"
16692 "\t*/\n"
16694 "{\n"
16695 "/*\n"
16696 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16697 "*/\n"
16700 verifyFormat("{\n"
16701 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16702 "\t// bbbbbbbbbbbbb\n"
16704 "{\n"
16705 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16708 verifyFormat("{\n"
16709 "\t/*\n"
16710 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16711 "\t bbbbbbbbbbbbb\n"
16712 "\t*/\n"
16714 "{\n"
16715 "\t/*\n"
16716 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16717 "\t*/\n"
16720 verifyNoChange("{\n"
16721 "\t/*\n"
16722 "\n"
16723 "\t*/\n"
16726 verifyNoChange("{\n"
16727 "\t/*\n"
16728 " asdf\n"
16729 "\t*/\n"
16732 verifyFormat("/* some\n"
16734 " \t \t /* some\n"
16737 verifyFormat("int a; /* some\n"
16739 " \t \t int a; /* some\n"
16742 verifyFormat("int a; /* some\n"
16744 " \t \t int\ta; /* some\n"
16747 verifyFormat("f(\"\t\t\"); /* some\n"
16749 " \t \t f(\"\t\t\"); /* some\n"
16752 verifyFormat("{\n"
16753 "\t/*\n"
16754 "\t * Comment\n"
16755 "\t */\n"
16756 "\tint i;\n"
16758 "{\n"
16759 "\t/*\n"
16760 "\t * Comment\n"
16761 "\t */\n"
16762 "\t int i;\n"
16767 verifyFormat("{\n"
16768 "\t/* aaaa\n"
16769 "\t bbbb */\n"
16771 "{\n"
16772 "/* aaaa\n"
16773 " bbbb */\n"
16776 verifyFormat("{\n"
16777 "\t/*\n"
16778 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
16779 "\t bbbbbbbbbbbbb\n"
16780 "\t*/\n"
16782 "{\n"
16783 "/*\n"
16784 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
16785 "*/\n"
16792 verifyFormat("class Assign {\n"
16793 "\tvoid f() {\n"
16794 "\t\tint x = 123;\n"
16795 "\t\tint random = 4;\n"
16796 "\t\tstd::string alphabet =\n"
16797 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
16798 "\t}\n"
16802 verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb +\n"
16806 verifyFormat("int aaaaaaaaaa =\n"
16809 verifyFormat("return aaaaaaaaaaaaaaaa ? 111111111111111\n"
16810 " : bbbbbbbbbbbbbb ? 222222222222222\n"
16815 verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"
16825 verifyFormat("void a() {\n"
16826 " // line starts with '\t'\n"
16828 "void a(){\n"
16829 "\t// line starts with '\t'\n"
16833 verifyFormat("void a() {\n"
16834 " // line starts with '\t'\n"
16836 "void a(){\n"
16837 "\t\t// line starts with '\t'\n"
16842 verifyFormat("void a() {\n"
16843 " // line starts with '\t'\n"
16845 "void a(){\n"
16846 "\t// line starts with '\t'\n"
16850 verifyFormat("void a() {\n"
16851 " // line starts with '\t'\n"
16853 "void a(){\n"
16854 "\t\t// line starts with '\t'\n"
16859 verifyFormat("void a() {\n"
16860 " // line starts with '\t'\n"
16862 "void a(){\n"
16863 "\t// line starts with '\t'\n"
16867 verifyFormat("void a() {\n"
16868 " // line starts with '\t'\n"
16870 "void a(){\n"
16871 "\t\t// line starts with '\t'\n"
16876 verifyFormat("void a() {\n"
16877 " // line starts with '\t'\n"
16879 "void a(){\n"
16880 "\t// line starts with '\t'\n"
16884 verifyFormat("void a() {\n"
16885 " // line starts with '\t'\n"
16887 "void a(){\n"
16888 "\t\t// line starts with '\t'\n"
16893 verifyFormat("void a() {\n"
16894 "// line starts with '\t'\n"
16896 "void a(){\n"
16897 "\t// line starts with '\t'\n"
16901 verifyFormat("void a() {\n"
16902 "// line starts with '\t'\n"
16904 "void a(){\n"
16905 "\t\t// line starts with '\t'\n"
16911 verifyFormat("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
16912 "q\"; /* some\n"
16914 " \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
16915 "q\"; /* some\n"
16917 verifyFormat("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
16918 "/* some\n"
16920 "// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
16921 " /* some\n"
16923 verifyFormat("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
16924 "qqq\n"
16925 "/* some\n"
16927 "// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
16928 "qqq\n"
16929 " /* some\n"
16931 verifyFormat("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
16932 "wwww; /* some\n"
16934 " inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
16935 "wwww; /* some\n"
16943 verifyFormat("while(true)\n"
16946 verifyFormat("for(;;)\n"
16949 verifyFormat("if(true)\n"
16950 " f();\n"
16951 "else if(true)\n"
16954 verifyFormat("do {\n"
16955 " do_something();\n"
16958 verifyFormat("switch(x) {\n"
16959 "default:\n"
16960 " break;\n"
16978 verifyFormat("#if (foo || bar) && baz\n"
16979 "#elif ((a || b) && c) || d\n"
16989 verifyFormat("void f (int a, T b) {\n"
16990 " while (true)\n"
16991 " continue;\n"
16994 verifyFormat("if (true)\n"
16995 " f ();\n"
16996 "else if (true)\n"
16999 verifyFormat("do {\n"
17000 " do_something ();\n"
17003 verifyFormat("switch (x) {\n"
17004 "default:\n"
17005 " break;\n"
17010 verifyFormat("*(&a + 1);\n"
17011 "&((&a)[1]);\n"
17012 "a[(b + c) * d];\n"
17017 verifyFormat("#if defined(x)\n"
17047 verifyFormat("void f (int a, T b) {\n"
17048 " while (true)\n"
17049 " continue;\n"
17052 verifyFormat("if (true)\n"
17053 " f();\n"
17054 "else if (true)\n"
17057 verifyFormat("do {\n"
17058 " do_something();\n"
17061 verifyFormat("switch (x) {\n"
17062 "default:\n"
17063 " break;\n"
17068 verifyFormat("*(&a + 1);\n"
17069 "&((&a)[1]);\n"
17070 "a[(b + c) * d];\n"
17075 verifyFormat("#if defined(x)\n"
17100 verifyFormat("while (true)\n"
17103 verifyFormat("if (true)\n"
17104 " f();\n"
17105 "else if (true)\n"
17108 verifyFormat("for (;;) {\n"
17109 " do_something();\n"
17112 verifyFormat("do {\n"
17113 " do_something();\n"
17116 verifyFormat("switch (x) {\n"
17117 "default:\n"
17118 " break;\n"
17134 verifyFormat("#if defined(x)\n"
17170 verifyFormat("#if defined(x)\n"
17200 verifyFormat("MYIF (a)\n return;", SpaceIfMacros);
17201 verifyFormat("MYIF (a)\n return;\nelse MYIF (b)\n return;", SpaceIfMacros);
17202 verifyFormat("MYIF (a)\n return;\nelse\n return;", SpaceIfMacros);
17210 verifyFormat("for (;;) {\n"
17213 verifyFormat("foreach (Item *item, itemlist) {\n"
17216 verifyFormat("Q_FOREACH (Item *item, itemlist) {\n"
17219 verifyFormat("BOOST_FOREACH (Item *item, itemlist) {\n"
17231 verifyFormat("void f (int a, T b) {\n"
17232 " while (true)\n"
17233 " continue;\n"
17236 verifyFormat("if (true)\n"
17237 " f();\n"
17238 "else if (true)\n"
17241 verifyFormat("do {\n"
17242 " do_something();\n"
17245 verifyFormat("switch (x) {\n"
17246 "default:\n"
17247 " break;\n"
17252 verifyFormat("*(&a + 1);\n"
17253 "&((&a)[1]);\n"
17254 "a[(b + c) * d];\n"
17259 verifyFormat("#if defined(x)\n"
17304 verifyFormat("void f(auto x)\n"
17305 " requires requires(int i) { x + i; }\n"
17308 verifyFormat("void f(auto x)\n"
17309 " requires(requires(int i) { x + i; })\n"
17312 verifyFormat("if (requires(int i) { x + i; })\n"
17316 verifyFormat("template <typename T>\n"
17317 " requires(Foo<T>)\n"
17322 verifyFormat("void f(auto x)\n"
17323 " requires requires(int i) { x + i; }\n"
17326 verifyFormat("void f(auto x)\n"
17327 " requires (requires(int i) { x + i; })\n"
17330 verifyFormat("if (requires(int i) { x + i; })\n"
17334 verifyFormat("template <typename T>\n"
17335 " requires (Foo<T>)\n"
17341 verifyFormat("void f(auto x)\n"
17342 " requires requires (int i) { x + i; }\n"
17345 verifyFormat("void f(auto x)\n"
17346 " requires(requires (int i) { x + i; })\n"
17349 verifyFormat("if (requires (int i) { x + i; })\n"
17353 verifyFormat("template <typename T>\n"
17354 " requires(Foo<T>)\n"
17359 verifyFormat("void f(auto x)\n"
17360 " requires requires (int i) { x + i; }\n"
17363 verifyFormat("void f(auto x)\n"
17364 " requires (requires (int i) { x + i; })\n"
17367 verifyFormat("if (requires (int i) { x + i; })\n"
17371 verifyFormat("template <typename T>\n"
17372 " requires (Foo<T>)\n"
17397 verifyFormat("while ((bool)1)\n"
17400 verifyFormat("for (;;)\n"
17403 verifyFormat("if (true)\n"
17404 " f();\n"
17405 "else if (true)\n"
17408 verifyFormat("do {\n"
17409 " do_something((int)i);\n"
17412 verifyFormat("switch (x) {\n"
17413 "default:\n"
17414 " break;\n"
17426 verifyFormat("if ((x - y) && (a ^ b))\n"
17429 verifyFormat("for (int i = 0; i < 10; i = (i + 1))\n"
17432 verifyFormat("switch (x / (y + z)) {\n"
17433 "default:\n"
17434 " break;\n"
17443 verifyFormat("if (a)\n"
17454 verifyFormat("while ( (bool)1 )\n"
17457 verifyFormat("for ( ;; )\n"
17460 verifyFormat("if ( true )\n"
17461 " f();\n"
17462 "else if ( true )\n"
17465 verifyFormat("do {\n"
17466 " do_something( (int)i );\n"
17469 verifyFormat("switch ( x ) {\n"
17470 "default:\n"
17471 " break;\n"
17483 verifyFormat("if ( ( x - y ) && ( a ^ b ) )\n"
17486 verifyFormat("for ( int i = 0; i < 10; i = ( i + 1 ) )\n"
17489 verifyFormat("switch ( x / ( y + z ) ) {\n"
17490 "default:\n"
17491 " break;\n"
17516 verifyFormat("while (( bool )1)\n"
17519 verifyFormat("for (;;)\n"
17522 verifyFormat("if (true)\n"
17523 " f( );\n"
17524 "else if (true)\n"
17527 verifyFormat("do {\n"
17528 " do_something(( int )i);\n"
17531 verifyFormat("switch (x) {\n"
17532 "default:\n"
17533 " break;\n"
17545 verifyFormat("if ((x - y) && (a ^ b))\n"
17548 verifyFormat("for (int i = 0; i < 10; i = (i + 1))\n"
17551 verifyFormat("switch (x / (y + z)) {\n"
17552 "default:\n"
17553 " break;\n"
17562 verifyFormat("while (( bool ) 1)\n"
17565 verifyFormat("for (;;)\n"
17568 verifyFormat("if (true)\n"
17569 " f( );\n"
17570 "else if (true)\n"
17573 verifyFormat("do {\n"
17574 " do_something(( int ) i);\n"
17577 verifyFormat("switch (x) {\n"
17578 "default:\n"
17579 " break;\n"
17595 verifyFormat("while ((bool) 1)\n"
17598 verifyFormat("do {\n"
17599 " do_something((int) i);\n"
17623 verifyFormat("void foo( ) {\n"
17624 " size_t foo = (*(function))(\n"
17626 "BarrrrrrrrrrrrLong,\n"
17627 " FoooooooooLooooong);\n"
17639 verifyFormat("void foo( ) {\n"
17640 " size_t foo = (*(function))(\n"
17642 "BarrrrrrrrrrrrLong,\n"
17643 " FoooooooooLooooong);\n"
17648 verifyFormat("void foo( ) {\n"
17649 " size_t foo = (*(function))(\n"
17651 "BarrrrrrrrrrrrLong,\n"
17652 " FoooooooooLooooong\n"
17653 " );\n"
17681 verifyFormat("if (( i = j ))\n"
17689 verifyFormat("while ( (bool)1 )\n"
17692 verifyFormat("while ((i = j))\n"
17695 verifyFormat("do {\n"
17696 " do_something((int)i);\n"
17699 verifyFormat("do {\n"
17700 " do_something((int)i);\n"
17703 verifyFormat("if ( (x - y) && (a ^ b) )\n"
17706 verifyFormat("if ((i = j))\n"
17709 verifyFormat("for ( int i = 0; i < 10; i = (i + 1) )\n"
17712 verifyFormat("switch ( x / (y + z) ) {\n"
17713 "default:\n"
17714 " break;\n"
17717 verifyFormat("if constexpr ((a = b))\n"
17732 verifyFormat("double &operator[](int i) { return 0; }\n"
17768 verifyFormat("double &operator[](int i) { return 0; }\n"
17800 verifyFormat("for (auto a : b) {\n}");
17802 verifyFormat("{\n"
17803 "label0:\n"
17804 " int x = 0;\n"
17806 verifyFormat("switch (x) {\n"
17807 "case 1:\n"
17808 "default:\n"
17810 verifyFormat("switch (allBraces) {\n"
17811 "case 1: {\n"
17812 " break;\n"
17813 "}\n"
17814 "case 2: {\n"
17815 " [[fallthrough]];\n"
17816 "}\n"
17817 "default: {\n"
17818 " break;\n"
17819 "}\n"
17826 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
17828 verifyFormat("{\n"
17829 "label1:\n"
17830 " int x = 0;\n"
17833 verifyFormat("switch (x) {\n"
17834 "case 1:\n"
17835 "default:\n"
17838 verifyFormat("switch (allBraces) {\n"
17839 "case 1: {\n"
17840 " break;\n"
17841 "}\n"
17842 "case 2: {\n"
17843 " [[fallthrough]];\n"
17844 "}\n"
17845 "default: {\n"
17846 " break;\n"
17847 "}\n"
17852 verifyFormat("Fooooooooooo::Fooooooooooo():\n"
17853 " aaaaaaaaaaaaaaaa(1),\n"
17858 verifyFormat("Fooooooooooo::Fooooooooooo()\n"
17859 " : aaaaaaaaaaaaaaaa(1)\n"
17864 verifyFormat("Fooooooooooo::Fooooooooooo()\n"
17865 " : aaaaaaaaaaaaaaaa(1),\n"
17869 verifyFormat("Fooooooooooo::Fooooooooooo()\n"
17870 ": aaaaaaaaaaaaaaaa(1),\n"
17878 verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
17880 verifyFormat("{\n"
17881 "label2:\n"
17882 " int x = 0;\n"
17885 verifyFormat("switch (x) {\n"
17886 "case 1:\n"
17887 "default:\n"
17890 verifyFormat("switch (allBraces) {\n"
17891 "case 1: {\n"
17892 " break;\n"
17893 "}\n"
17894 "case 2: {\n"
17895 " [[fallthrough]];\n"
17896 "}\n"
17897 "default: {\n"
17898 " break;\n"
17899 "}\n"
17903 verifyFormat("class Foooooooooooooooooooooo\n"
17904 " : public aaaaaaaaaaaaaaaaaa,\n"
17905 " public bbbbbbbbbbbbbbbbbb {\n"
17909 verifyFormat("class Foooooooooooooooooooooo:\n"
17910 " public aaaaaaaaaaaaaaaaaa,\n"
17911 " public bbbbbbbbbbbbbbbbbb {\n"
17915 verifyFormat("class Foooooooooooooooooooooo\n"
17916 " : public aaaaaaaaaaaaaaaaaa\n"
17917 " , public bbbbbbbbbbbbbbbbbb {\n"
17921 verifyFormat("class Foooooooooooooooooooooo\n"
17922 " : public aaaaaaaaaaaaaaaaaa,\n"
17923 " public bbbbbbbbbbbbbbbbbb {\n"
17927 verifyFormat("class Foooooooooooooooooooooo\n"
17928 ": public aaaaaaaaaaaaaaaaaa,\n"
17936 verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
17938 verifyFormat("{\n"
17939 "label2:\n"
17940 " int x = 0;\n"
17943 verifyFormat("switch (x) {\n"
17944 "case 1:\n"
17945 "default:\n"
17948 verifyFormat("switch (allBraces) {\n"
17949 "case 1: {\n"
17950 " break;\n"
17951 "}\n"
17952 "case 2: {\n"
17953 " [[fallthrough]];\n"
17954 "}\n"
17955 "default: {\n"
17956 " break;\n"
17957 "}\n"
17965 verifyFormat("for (auto a : b) {\n}", CaseStyle);
17967 verifyFormat("switch (x) {\n"
17968 "case 1 :\n"
17969 "default :\n"
17972 verifyFormat("switch (allBraces) {\n"
17973 "case 1 : {\n"
17974 " break;\n"
17975 "}\n"
17976 "case 2 : {\n"
17977 " [[fallthrough]];\n"
17978 "}\n"
17979 "default : {\n"
17980 " break;\n"
17981 "}\n"
17985 verifyFormat("switch (x) {\n"
17986 "goto_label:\n"
17987 "default :\n"
17990 verifyFormat("switch (x) {\n"
17991 "goto_label: { break; }\n"
17992 "default : {\n"
17993 " break;\n"
17994 "}\n"
18005 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
18007 verifyFormat("{\n"
18008 "label3:\n"
18009 " int x = 0;\n"
18012 verifyFormat("switch (x) {\n"
18013 "case 1:\n"
18014 "default:\n"
18017 verifyFormat("switch (allBraces) {\n"
18018 "case 1: {\n"
18019 " break;\n"
18020 "}\n"
18021 "case 2: {\n"
18022 " [[fallthrough]];\n"
18023 "}\n"
18024 "default: {\n"
18025 " break;\n"
18026 "}\n"
18037 verifyFormat("for (auto a: b) {\n}", InvertedSpaceStyle);
18039 verifyFormat("{\n"
18040 "label3:\n"
18041 " int x = 0;\n"
18044 verifyFormat("switch (x) {\n"
18045 "case 1 :\n"
18046 "case 2 : {\n"
18047 " break;\n"
18048 "}\n"
18049 "default :\n"
18050 " break;\n"
18053 verifyFormat("switch (allBraces) {\n"
18054 "case 1 : {\n"
18055 " break;\n"
18056 "}\n"
18057 "case 2 : {\n"
18058 " [[fallthrough]];\n"
18059 "}\n"
18060 "default : {\n"
18061 " break;\n"
18062 "}\n"
18167 verifyFormat("#define a 3\n"
18168 "#define bbbb 4\n"
18172 verifyFormat("#define f(x) (x * x)\n"
18173 "#define fff(x, y, z) (x * y + z)\n"
18177 verifyFormat("#define foo(x, y) (x + y)\n"
18181 verifyFormat("#define a 3\n"
18182 "#define bbbb 4\n"
18183 "#define ccc (5)\n"
18184 "#define f(x) (x * x)\n"
18185 "#define fff(x, y, z) (x * y + z)\n"
18190 verifyFormat("#define a 3\n"
18191 "#define bbbb 4\n"
18195 verifyFormat("#define true 1\n"
18199 verifyFormat("#define f(x) (x * x)\n"
18200 "#define fff(x, y, z) (x * y + z)\n"
18204 verifyFormat("#define foo(x, y) (x + y)\n"
18208 verifyFormat("#define a 3\n"
18209 "#define bbbb 4\n"
18210 "#define ccc (5)\n"
18211 "#define f(x) (x * x)\n"
18212 "#define fff(x, y, z) (x * y + z)\n"
18216 verifyFormat("#define a 5\n"
18217 "#define foo(x, y) (x + y)\n"
18218 "#define CCC (6)\n"
18219 "auto lambda = []() {\n"
18220 " auto ii = 0;\n"
18221 " float j = 0;\n"
18222 " return 0;\n"
18223 "};\n"
18224 "int i = 0;\n"
18225 "float i2 = 0;\n"
18226 "auto v = type{\n"
18227 " i = 1, //\n"
18228 " (i = 2), //\n"
18229 " i = 3 //\n"
18236 verifyFormat("#define a \\\n"
18237 " \"aabbbbbbbbbbbb\"\n"
18238 "#define D \\\n"
18239 " \"aabbbbbbbbbbbb\" \\\n"
18240 " \"ccddeeeeeeeee\"\n"
18241 "#define B \\\n"
18242 " \"QQQQQQQQQQQQQ\" \\\n"
18243 " \"FFFFFFFFFFFFF\" \\\n"
18248 verifyFormat("#define a \\\n"
18249 " \"aabbbbbbbbbbbb\"\n"
18250 "#define D \\\n"
18251 " \"aabbbbbbbbbbbb\" \\\n"
18252 " \"ccddeeeeeeeee\"\n"
18253 "#define B \\\n"
18254 " \"QQQQQQQQQQQQQ\" \\\n"
18255 " \"FFFFFFFFFFFFF\" \\\n"
18263 verifyFormat("#define a 3\n"
18264 "// line comment\n"
18265 "#define bbbb 4\n"
18267 "#define a 3\n"
18268 "// line comment\n"
18269 "#define bbbb 4\n"
18273 verifyFormat("#define a 3\n"
18274 "/* block comment */\n"
18275 "#define bbbb 4\n"
18277 "#define a 3\n"
18278 "/* block comment */\n"
18279 "#define bbbb 4\n"
18283 verifyFormat("#define a 3\n"
18284 "/* multi-line *\n"
18285 " * block comment */\n"
18286 "#define bbbb 4\n"
18288 "#define a 3\n"
18289 "/* multi-line *\n"
18290 " * block comment */\n"
18291 "#define bbbb 4\n"
18295 verifyFormat("#define a 3\n"
18296 "// multi-line line comment\n"
18297 "//\n"
18298 "#define bbbb 4\n"
18300 "#define a 3\n"
18301 "// multi-line line comment\n"
18302 "//\n"
18303 "#define bbbb 4\n"
18307 verifyFormat("#define a 3\n"
18308 "// empty lines still break.\n"
18309 "\n"
18310 "#define bbbb 4\n"
18312 "#define a 3\n"
18313 "// empty lines still break.\n"
18314 "\n"
18315 "#define bbbb 4\n"
18322 verifyFormat("#define a 3\n"
18323 "\n"
18324 "#define bbbb 4\n"
18326 "#define a 3\n"
18327 "\n"
18328 "#define bbbb 4\n"
18332 verifyFormat("#define a 3\n"
18333 "\n"
18334 "\n"
18335 "\n"
18336 "#define bbbb 4\n"
18338 "#define a 3\n"
18339 "\n"
18340 "\n"
18341 "\n"
18342 "#define bbbb 4\n"
18346 verifyFormat("#define a 3\n"
18347 "// comments should break alignment\n"
18348 "//\n"
18349 "#define bbbb 4\n"
18351 "#define a 3\n"
18352 "// comments should break alignment\n"
18353 "//\n"
18354 "#define bbbb 4\n"
18360 verifyFormat("#define a 3\n"
18361 "\n"
18362 "// line comment\n"
18363 "#define bbbb 4\n"
18367 verifyFormat("#define a 3\n"
18368 "\n"
18369 "\n"
18370 "/* multi-line *\n"
18371 " * block comment */\n"
18372 "\n"
18373 "\n"
18374 "#define bbbb 4\n"
18376 "#define a 3\n"
18377 "\n"
18378 "\n"
18379 "/* multi-line *\n"
18380 " * block comment */\n"
18381 "\n"
18382 "\n"
18383 "#define bbbb 4\n"
18387 verifyFormat("#define a 3\n"
18388 "\n"
18389 "\n"
18390 "/* multi-line *\n"
18391 " * block comment */\n"
18392 "\n"
18393 "\n"
18394 "#define bbbb 4\n"
18396 "#define a 3\n"
18397 "\n"
18398 "\n"
18399 "/* multi-line *\n"
18400 " * block comment */\n"
18401 "\n"
18402 "\n"
18403 "#define bbbb 4\n"
18416 verifyFormat("int a = 5;\n"
18417 "\n"
18419 "int a = 5;\n"
18420 "\n"
18423 verifyFormat("int a = 5;\n"
18424 "int one = 1;\n"
18425 "\n"
18427 "int a = 5;\n"
18428 "int one = 1;\n"
18429 "\n"
18432 verifyFormat("int a = 5;\n"
18433 "int one = 1;\n"
18434 "\n"
18435 "int oneTwoThree = 123;\n"
18437 "int a = 5;\n"
18438 "int one = 1;\n"
18439 "\n"
18440 "int oneTwoThree = 123;\n"
18445 verifyFormat("int a = 5;\n"
18446 "/* block comment */\n"
18448 "int a = 5;\n"
18449 "/* block comment */\n"
18453 verifyFormat("int a = 5;\n"
18454 "// line comment\n"
18456 "int a = 5;\n"
18457 "// line comment\n"
18462 verifyFormat("int a = 5;\n"
18463 "\n"
18464 "/* block comment */\n"
18466 "int a = 5;\n"
18467 "\n"
18468 "/* block comment */\n"
18472 verifyFormat("int a = 5;\n"
18473 "\n"
18474 "// line comment\n"
18476 "int a = 5;\n"
18477 "\n"
18478 "// line comment\n"
18491 verifyFormat("int a = 5;\n"
18492 "\n"
18494 "int a = 5;\n"
18495 "\n"
18498 verifyFormat("int a = 5;\n"
18499 "float const one = 1;\n"
18500 "\n"
18502 "int a = 5;\n"
18503 "float const one = 1;\n"
18504 "\n"
18509 verifyFormat("float const a = 5;\n"
18510 "/* block comment */\n"
18512 "float const a = 5;\n"
18513 "/* block comment */\n"
18517 verifyFormat("float const a = 5;\n"
18518 "// line comment\n"
18520 "float const a = 5;\n"
18521 "// line comment\n"
18526 verifyFormat("float const a = 5;\n"
18527 "\n"
18528 "/* block comment */\n"
18530 "float const a = 5;\n"
18531 "\n"
18532 "/* block comment */\n"
18536 verifyFormat("float const a = 5;\n"
18537 "\n"
18538 "// line comment\n"
18540 "float const a = 5;\n"
18541 "\n"
18542 "// line comment\n"
18555 verifyFormat("int a : 5;\n"
18556 "\n"
18558 "int a : 5;\n"
18559 "\n"
18562 verifyFormat("int a : 5;\n"
18563 "int one : 1;\n"
18564 "\n"
18566 "int a : 5;\n"
18567 "int one : 1;\n"
18568 "\n"
18573 verifyFormat("int a : 5;\n"
18574 "/* block comment */\n"
18576 "int a : 5;\n"
18577 "/* block comment */\n"
18580 verifyFormat("int a : 5;\n"
18581 "int one : 1;\n"
18582 "// line comment\n"
18584 "int a : 5;\n"
18585 "int one : 1;\n"
18586 "// line comment\n"
18591 verifyFormat("int a : 5;\n"
18592 "/* block comment */\n"
18593 "\n"
18595 "int a : 5;\n"
18596 "/* block comment */\n"
18597 "\n"
18600 verifyFormat("int a : 5;\n"
18601 "int one : 1;\n"
18602 "\n"
18603 "// line comment\n"
18604 "\n"
18606 "int a : 5;\n"
18607 "int one : 1;\n"
18608 "\n"
18609 "// line comment \n"
18610 "\n"
18623 verifyFormat("int a = 5;\n"
18624 "\n"
18626 "int a = 5;\n"
18627 "\n"
18630 verifyFormat("int a = 5;\n"
18631 "int one = 1;\n"
18632 "\n"
18634 "int a = 5;\n"
18635 "int one = 1;\n"
18636 "\n"
18641 verifyFormat("int a = 5;\n"
18642 "/* block comment */\n"
18644 "int a = 5;\n"
18645 "/* block comment */\n"
18649 verifyFormat("int a = 5;\n"
18650 "// line comment\n"
18652 "int a = 5;\n"
18653 "// line comment\n"
18657 verifyFormat("int a = 5;\n"
18658 "/*\n"
18659 " * multi-line block comment\n"
18660 " */\n"
18662 "int a = 5;\n"
18663 "/*\n"
18664 " * multi-line block comment\n"
18665 " */\n"
18669 verifyFormat("int a = 5;\n"
18670 "//\n"
18671 "// multi-line line comment\n"
18672 "//\n"
18674 "int a = 5;\n"
18675 "//\n"
18676 "// multi-line line comment\n"
18677 "//\n"
18682 verifyFormat("int a = 5;\n"
18683 "\n"
18684 "/* block comment */\n"
18686 "int a = 5;\n"
18687 "\n"
18688 "/* block comment */\n"
18692 verifyFormat("int a = 5;\n"
18693 "\n"
18694 "// line comment\n"
18696 "int a = 5;\n"
18697 "\n"
18698 "// line comment\n"
18709 verifyFormat("int a = 5;\n"
18712 verifyFormat("int a = method();\n"
18715 verifyFormat("a &= 5;\n"
18716 "bcd *= 5;\n"
18717 "ghtyf += 5;\n"
18718 "dvfvdb -= 5;\n"
18719 "a /= 5;\n"
18720 "vdsvsv %= 5;\n"
18721 "sfdbddfbdfbb ^= 5;\n"
18722 "dvsdsv |= 5;\n"
18725 verifyFormat("int i = 1, j = 10;\n"
18728 verifyFormat("something = 2000;\n"
18731 verifyFormat("something = 2000;\n"
18732 "another = 911;\n"
18733 "int i = 1, j = 10;\n"
18734 "oneMore = 1;\n"
18737 verifyFormat("int a = 5;\n"
18738 "int one = 1;\n"
18739 "method();\n"
18740 "int oneTwoThree = 123;\n"
18743 verifyFormat("int oneTwoThree = 123;\n"
18744 "int oneTwo = 12;\n"
18747 verifyFormat("int oneTwoThree = 123; // comment\n"
18753 verifyFormat("#if A\n"
18754 "#else\n"
18755 "int aaaaaaaa = 12;\n"
18756 "#endif\n"
18757 "#if B\n"
18758 "#else\n"
18759 "int a = 12;\n"
18762 verifyFormat("enum foo {\n"
18763 "#if A\n"
18764 "#else\n"
18765 " aaaaaaaa = 12;\n"
18766 "#endif\n"
18767 "#if B\n"
18768 "#else\n"
18769 " a = 12;\n"
18770 "#endif\n"
18777 verifyFormat("int a = 5;\n"
18778 "\n"
18780 "int a = 5;\n"
18781 "\n"
18784 verifyFormat("int a = 5;\n"
18785 "int one = 1;\n"
18786 "\n"
18788 "int a = 5;\n"
18789 "int one = 1;\n"
18790 "\n"
18793 verifyFormat("int a = 5;\n"
18794 "int one = 1;\n"
18795 "\n"
18796 "int oneTwoThree = 123;\n"
18798 "int a = 5;\n"
18799 "int one = 1;\n"
18800 "\n"
18801 "int oneTwoThree = 123;\n"
18806 verifyFormat("int a = 5;\n"
18807 "/* block comment */\n"
18809 "int a = 5;\n"
18810 "/* block comment */\n"
18814 verifyFormat("int a = 5;\n"
18815 "// line comment\n"
18817 "int a = 5;\n"
18818 "// line comment\n"
18823 verifyFormat("int a = 5;\n"
18824 "\n"
18825 "/* block comment */\n"
18827 "int a = 5;\n"
18828 "\n"
18829 "/* block comment */\n"
18833 verifyFormat("int a = 5;\n"
18834 "\n"
18835 "// line comment\n"
18837 "int a = 5;\n"
18838 "\n"
18839 "// line comment\n"
18843 verifyFormat("int a = 5;\n"
18844 "//\n"
18845 "// multi-line line comment\n"
18846 "//\n"
18848 "int a = 5;\n"
18849 "//\n"
18850 "// multi-line line comment\n"
18851 "//\n"
18855 verifyFormat("int a = 5;\n"
18856 "/*\n"
18857 " * multi-line block comment\n"
18858 " */\n"
18860 "int a = 5;\n"
18861 "/*\n"
18862 " * multi-line block comment\n"
18863 " */\n"
18867 verifyFormat("int a = 5;\n"
18868 "\n"
18869 "/* block comment */\n"
18870 "\n"
18871 "\n"
18872 "\n"
18874 "int a = 5;\n"
18875 "\n"
18876 "/* block comment */\n"
18877 "\n"
18878 "\n"
18879 "\n"
18883 verifyFormat("int a = 5;\n"
18884 "\n"
18885 "// line comment\n"
18886 "\n"
18887 "\n"
18888 "\n"
18890 "int a = 5;\n"
18891 "\n"
18892 "// line comment\n"
18893 "\n"
18894 "\n"
18895 "\n"
18900 verifyFormat("#define A \\\n"
18901 " int aaaa = 12; \\\n"
18902 " int b = 23; \\\n"
18903 " int ccc = 234; \\\n"
18907 verifyFormat("#define A \\\n"
18908 " int aaaa = 12; \\\n"
18909 " int b = 23; \\\n"
18910 " int ccc = 234; \\\n"
18915 " \\\n"
18917 " \\\n"
18919 " \\\n"
18921 " \\\n"
18925 "k = 4, int l = 5,\n"
18926 " int m = 6) {\n"
18927 " int j = 10;\n"
18928 " otherThing = 1;\n"
18931 verifyFormat("void SomeFunction(int parameter = 0) {\n"
18932 " int i = 1;\n"
18933 " int j = 2;\n"
18934 " int big = 10000;\n"
18937 verifyFormat("class C {\n"
18938 "public:\n"
18939 " int i = 1;\n"
18940 " virtual void f() = 0;\n"
18943 verifyFormat("int i = 1;\n"
18944 "if (SomeType t = getSomething()) {\n"
18945 "}\n"
18946 "int j = 2;\n"
18949 verifyFormat("int j = 7;\n"
18950 "for (int k = 0; k < N; ++k) {\n"
18951 "}\n"
18952 "int j = 2;\n"
18953 "int big = 10000;\n"
18957 verifyFormat("int i = 1;\n"
18958 "LooooooooooongType loooooooooooooooooooooongVariable\n"
18959 " = someLooooooooooooooooongFunction();\n"
18963 verifyFormat("int i = 1;\n"
18964 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
18965 " someLooooooooooooooooongFunction();\n"
18969 verifyFormat("auto lambda = []() {\n"
18970 " auto i = 0;\n"
18971 " return 0;\n"
18972 "};\n"
18973 "int i = 0;\n"
18974 "auto v = type{\n"
18975 " i = 1, //\n"
18976 " (i = 2), //\n"
18977 " i = 3 //\n"
18982 "int i = 1;\n"
18983 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
18984 " loooooooooooooooooooooongParameterB);\n"
18988 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
18989 " typename B = very_long_type_name_1,\n"
18990 " typename T_2 = very_long_type_name_2>\n"
18993 verifyFormat("int a, b = 1;\n"
18994 "int c = 2;\n"
18997 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
19000 verifyFormat("for (int i = 0; i < 1; i++)\n"
19003 verifyFormat("for (i = 0; i < 1; i++)\n"
19004 " x = 1;\n"
19010 verifyFormat("int x = 0;\n"
19011 "int yy = 1; /// specificlennospace\n"
19013 "int x = 0;\n"
19014 "int yy = 1; ///specificlennospace\n"
19024 verifyFormat("sfdbddfbdfbb = 5;\n"
19025 "dvsdsv = 5;\n"
19028 verifyFormat("sfdbddfbdfbb ^= 5;\n"
19029 "dvsdsv |= 5;\n"
19032 verifyFormat("sfdbddfbdfbb ^= 5;\n"
19033 "dvsdsv <<= 5;\n"
19036 verifyFormat("int xxx = 5;\n"
19037 "xxx = 5;\n"
19038 "{\n"
19039 " int yyy = 6;\n"
19040 " yyy = 6;\n"
19043 verifyFormat("int xxx = 5;\n"
19044 "xxx += 5;\n"
19045 "{\n"
19046 " int yyy = 6;\n"
19047 " yyy += 6;\n"
19051 verifyFormat("aa &= 5;\n"
19052 "b <= 10;\n"
19056 verifyFormat("sfdbddfbdfbb = 5;\n"
19057 "dvsdsv = 5;\n"
19060 verifyFormat("sfdbddfbdfbb ^= 5;\n"
19061 "dvsdsv |= 5;\n"
19064 verifyFormat("sfdbddfbdfbb ^= 5;\n"
19065 "dvsdsv <<= 5;\n"
19068 verifyFormat("a += 5;\n"
19069 "one = 1;\n"
19070 "\n"
19072 "a += 5;\n"
19073 "one = 1;\n"
19074 "\n"
19077 verifyFormat("a += 5;\n"
19078 "one = 1;\n"
19079 "//\n"
19081 "a += 5;\n"
19082 "one = 1;\n"
19083 "//\n"
19087 verifyFormat("a += 5;\n"
19088 "one = 1;\n"
19089 "\n"
19091 "a += 5;\n"
19092 "one = 1;\n"
19093 "\n"
19096 verifyFormat("a += 5;\n"
19097 "one = 1;\n"
19098 "//\n"
19100 "a += 5;\n"
19101 "one = 1;\n"
19102 "//\n"
19107 verifyFormat("a += 5;\n"
19108 "one = 1;\n"
19109 "\n"
19111 "a += 5;\n"
19112 "one = 1;\n"
19113 "\n"
19116 verifyFormat("a += 5;\n"
19117 "one = 1;\n"
19118 "//\n"
19120 "a += 5;\n"
19121 "one = 1;\n"
19122 "//\n"
19126 verifyFormat("a += 5;\n"
19127 "one >>= 1;\n"
19128 "\n"
19130 "a += 5;\n"
19131 "one >>= 1;\n"
19132 "\n"
19135 verifyFormat("a += 5;\n"
19136 "one = 1;\n"
19137 "//\n"
19139 "a += 5;\n"
19140 "one = 1;\n"
19141 "//\n"
19149 verifyFormat("int a = 5;\n"
19152 verifyFormat("int a = 5;\n"
19157 verifyFormat("int a = 5;\n"
19160 verifyFormat("int a = method();\n"
19163 verifyFormat("aa <= 5;\n"
19164 "a &= 5;\n"
19165 "bcd *= 5;\n"
19166 "ghtyf += 5;\n"
19167 "dvfvdb -= 5;\n"
19168 "a /= 5;\n"
19169 "vdsvsv %= 5;\n"
19170 "sfdbddfbdfbb ^= 5;\n"
19171 "dvsdsv |= 5;\n"
19174 verifyFormat("int i = 1, j = 10;\n"
19177 verifyFormat("something = 2000;\n"
19180 verifyFormat("something = 2000;\n"
19181 "another = 911;\n"
19182 "int i = 1, j = 10;\n"
19183 "oneMore = 1;\n"
19186 verifyFormat("int a = 5;\n"
19187 "int one = 1;\n"
19188 "method();\n"
19189 "int oneTwoThree = 123;\n"
19192 verifyFormat("int oneTwoThree = 123;\n"
19193 "int oneTwo = 12;\n"
19196 verifyFormat("int oneTwoThree = 123; // comment\n"
19199 verifyFormat("int f() = default;\n"
19200 "int &operator() = default;\n"
19203 verifyFormat("int f() = delete;\n"
19204 "int &operator() = delete;\n"
19207 verifyFormat("int f() = default; // comment\n"
19208 "int &operator() = default; // comment\n"
19211 verifyFormat("int f() = default;\n"
19212 "int &operator() = default;\n"
19215 verifyFormat("int f() = default;\n"
19216 "int &operator() = default;\n"
19219 verifyFormat("int f() = default;\n"
19220 "int &operator() = default;\n"
19223 verifyFormat("int f() = default;\n"
19224 "int &operator() = default;\n"
19227 verifyFormat("int f() = delete;\n"
19228 "int &operator() = delete;\n"
19231 verifyFormat("/* long long padding */ int f() = default;\n"
19232 "int &operator() = default;\n"
19239 verifyFormat("class SSSSSSSSSSSSSSSSSSSSSSSSSSSS {\n"
19240 " void f() = delete;\n"
19241 " SSSSSSSSSSSSSSSSSSSSSSSSSSSS &operator=(\n"
19242 " const SSSSSSSSSSSSSSSSSSSSSSSSSSSS &other) = delete;\n"
19248 verifyFormat("#if A\n"
19249 "#else\n"
19250 "int aaaaaaaa = 12;\n"
19251 "#endif\n"
19252 "#if B\n"
19253 "#else\n"
19254 "int a = 12;\n"
19257 verifyFormat("enum foo {\n"
19258 "#if A\n"
19259 "#else\n"
19260 " aaaaaaaa = 12;\n"
19261 "#endif\n"
19262 "#if B\n"
19263 "#else\n"
19264 " a = 12;\n"
19265 "#endif\n"
19270 verifyFormat("int a = 5;\n"
19271 "\n"
19273 "int a = 5;\n"
19274 "\n"
19277 verifyFormat("int a = 5;\n"
19278 "int one = 1;\n"
19279 "\n"
19281 "int a = 5;\n"
19282 "int one = 1;\n"
19283 "\n"
19286 verifyFormat("int a = 5;\n"
19287 "int one = 1;\n"
19288 "\n"
19289 "int oneTwoThree = 123;\n"
19291 "int a = 5;\n"
19292 "int one = 1;\n"
19293 "\n"
19294 "int oneTwoThree = 123;\n"
19298 verifyFormat("#define A \\\n"
19299 " int aaaa = 12; \\\n"
19300 " int b = 23; \\\n"
19301 " int ccc = 234; \\\n"
19305 verifyFormat("#define A \\\n"
19306 " int aaaa = 12; \\\n"
19307 " int b = 23; \\\n"
19308 " int ccc = 234; \\\n"
19313 " \\\n"
19315 " \\\n"
19317 " \\\n"
19319 " \\\n"
19323 "k = 4, int l = 5,\n"
19324 " int m = 6) {\n"
19325 " int j = 10;\n"
19326 " otherThing = 1;\n"
19329 verifyFormat("void SomeFunction(int parameter = 0) {\n"
19330 " int i = 1;\n"
19331 " int j = 2;\n"
19332 " int big = 10000;\n"
19335 verifyFormat("class C {\n"
19336 "public:\n"
19337 " int i = 1;\n"
19338 " virtual void f() = 0;\n"
19341 verifyFormat("int i = 1;\n"
19342 "if (SomeType t = getSomething()) {\n"
19343 "}\n"
19344 "int j = 2;\n"
19347 verifyFormat("int j = 7;\n"
19348 "for (int k = 0; k < N; ++k) {\n"
19349 "}\n"
19350 "int j = 2;\n"
19351 "int big = 10000;\n"
19355 verifyFormat("int i = 1;\n"
19356 "LooooooooooongType loooooooooooooooooooooongVariable\n"
19357 " = someLooooooooooooooooongFunction();\n"
19361 verifyFormat("int i = 1;\n"
19362 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
19363 " someLooooooooooooooooongFunction();\n"
19367 verifyFormat("auto lambda = []() {\n"
19368 " auto i = 0;\n"
19369 " return 0;\n"
19370 "};\n"
19371 "int i = 0;\n"
19372 "auto v = type{\n"
19373 " i = 1, //\n"
19374 " (i = 2), //\n"
19375 " i = 3 //\n"
19380 "int i = 1;\n"
19381 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
19382 " loooooooooooooooooooooongParameterB);\n"
19386 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
19387 " typename B = very_long_type_name_1,\n"
19388 " typename T_2 = very_long_type_name_2>\n"
19391 verifyFormat("int a, b = 1;\n"
19392 "int c = 2;\n"
19395 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
19398 verifyFormat("for (int i = 0; i < 1; i++)\n"
19401 verifyFormat("for (i = 0; i < 1; i++)\n"
19402 " x = 1;\n"
19408 verifyFormat("int x = 0;\n"
19409 "int yy = 1; /// specificlennospace\n"
19411 "int x = 0;\n"
19412 "int yy = 1; ///specificlennospace\n"
19416 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaa = {};\n"
19417 "auto b = [] {\n"
19418 " f();\n"
19419 " return;\n"
19422 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaa = {};\n"
19423 "auto b = g([] {\n"
19424 " f();\n"
19425 " return;\n"
19428 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaa = {};\n"
19429 "auto b = g(param, [] {\n"
19430 " f();\n"
19431 " return;\n"
19434 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaa = {};\n"
19435 "auto b = [] {\n"
19436 " if (condition) {\n"
19437 " return;\n"
19438 " }\n"
19442 verifyFormat("auto b = f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
19443 " ccc ? aaaaa : bbbbb,\n"
19447 // verifyFormat("auto aaaaaaaaaaaa = f();\n"
19448 // "auto b = f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
19449 // " ccc ? aaaaa : bbbbb,\n"
19459 verifyFormat("int a_long_name = 1;\n"
19460 "auto b = B({a_long_name, a_long_name},\n"
19461 " {a_longer_name_for_wrap,\n"
19464 verifyFormat("int a_long_name = 1;\n"
19465 "auto b = B{{a_long_name, a_long_name},\n"
19466 " {a_longer_name_for_wrap,\n"
19472 verifyFormat("using II = typename TI<T, std::tuple<Types...>>::I;\n"
19473 "using I = std::conditional_t<II::value >= 0,\n"
19474 " std::ic<int, II::value + 1>,\n"
19477 verifyFormat("SomeName = Foo;\n"
19478 "X = func<Type, Type>(looooooooooooooooooooooooong,\n"
19484 verifyFormat("void **ptr = reinterpret_cast< void ** >(unkn);\n"
19487 verifyFormat("quint32 *dstimg = reinterpret_cast< quint32 * >(out(i));\n"
19493 verifyFormat("void **ptr = ( void ** )unkn;\n"
19496 verifyFormat("quint32 *dstimg = ( quint32 * )out.scanLine(i);\n"
19504 verifyFormat("int const a : 5;\n"
19509 verifyFormat("int const a : 5 = 1;\n"
19514 verifyFormat("int const a : 5;\n"
19518 verifyFormat("int const a : 5; // comment\n"
19522 verifyFormat("int const a : 5 = 1;\n"
19527 verifyFormat("int const a : 5 = 1;\n"
19530 verifyFormat("int const a : 5 = {1};\n"
19535 verifyFormat("int const a :5;\n"
19540 verifyFormat("int const a :5;\n"
19545 verifyFormat("int const a : 5;\n"
19552 verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
19562 verifyFormat("float const a = 5;\n"
19565 verifyFormat("int a = 5;\n"
19570 verifyFormat("float const a = 5;\n"
19573 verifyFormat("int a = method();\n"
19576 verifyFormat("int i = 1, j = 10;\n"
19579 verifyFormat("something = 2000;\n"
19582 verifyFormat("float something = 2000;\n"
19583 "double another = 911;\n"
19584 "int i = 1, j = 10;\n"
19585 "const int *oneMore = 1;\n"
19588 verifyFormat("float a = 5;\n"
19589 "int one = 1;\n"
19590 "method();\n"
19591 "const double oneTwoThree = 123;\n"
19594 verifyFormat("int oneTwoThree{0}; // comment\n"
19597 verifyFormat("unsigned int *a;\n"
19598 "int *b;\n"
19599 "unsigned int Const *c;\n"
19600 "unsigned int const *d;\n"
19601 "unsigned int Const &e;\n"
19604 verifyFormat("Const unsigned int *c;\n"
19605 "const unsigned int *d;\n"
19606 "Const unsigned int &e;\n"
19607 "const unsigned int &f;\n"
19608 "const unsigned g;\n"
19611 verifyFormat("float const a = 5;\n"
19612 "\n"
19614 "float const a = 5;\n"
19615 "\n"
19618 verifyFormat("float a = 5;\n"
19619 "int one = 1;\n"
19620 "\n"
19622 "float a = 5;\n"
19623 "int one = 1;\n"
19624 "\n"
19627 verifyFormat("float a = 5;\n"
19628 "int one = 1;\n"
19629 "\n"
19630 "unsigned oneTwoThree = 123;\n"
19632 "float a = 5;\n"
19633 "int one = 1;\n"
19634 "\n"
19635 "unsigned oneTwoThree = 123;\n"
19639 verifyFormat("int a();\n"
19642 verifyFormat("int a(int x);\n"
19645 verifyFormat("int a(const Test & = Test());\n"
19646 "int a1(int &foo, const Test & = Test());\n"
19647 "int a2(int &foo, const Test &name = Test());\n"
19650 verifyFormat("struct Test {\n"
19651 " Test(const Test &) = default;\n"
19652 " ~Test() = default;\n"
19653 " Test &operator=(const Test &) = default;\n"
19660 verifyFormat("int a(int x,\n"
19661 " float y);\n"
19662 "double b(int x,\n"
19664 "int a(int x,\n"
19665 " float y);\n"
19666 "double b(int x,\n"
19672 verifyFormat("double a(int x);\n"
19673 "int b(int y,\n"
19675 "double a(int x);\n"
19676 "int b(int y,\n"
19682 verifyFormat("int function(\n"
19683 " int x,\n"
19688 verifyFormat("int a3(SomeTypeName1 &x,\n"
19689 " SomeTypeName2 &y,\n"
19690 " const Test & = Test());\n"
19695 verifyFormat("int a(int x, void (*fp)(int y));\n"
19699 verifyFormat("struct Test {\n"
19700 " Test(const Test &) = default;\n"
19701 " ~Test() = default;\n"
19702 " Test &operator=(const Test &) = default;\n"
19708 verifyFormat("int func(int a = 1) {\n"
19709 " int b = 2;\n"
19710 " int cc = 3;\n"
19713 verifyFormat("float something = 2000;\n"
19714 "double another = 911;\n"
19715 "int i = 1, j = 10;\n"
19716 "const int *oneMore = 1;\n"
19719 verifyFormat("int oneTwoThree = {0}; // comment\n"
19723 verifyFormat("for (int i = 0; i < n; i++)\n"
19724 " j = i;\n"
19727 verifyFormat("if (int i = 0)\n"
19728 " j = i;\n"
19732 verifyFormat("struct test {\n"
19733 " long long int foo();\n"
19734 " int operator[](int a);\n"
19735 " double bar();\n"
19738 verifyFormat("struct test {\n"
19739 " long long int foo();\n"
19740 " int operator()(int a);\n"
19741 " double bar();\n"
19745 verifyFormat("char *a[] = {\"a\", // comment\n"
19746 " \"bb\"};\n"
19750 verifyFormat("using Fn = int (A::*)();\n"
19751 "using RFn = int (A::*)() &;\n"
19754 verifyFormat("using Fn = int (A::*)();\n"
19755 "using RFn = int *(A::*)() &;\n"
19760 verifyFormat("void SomeFunction(int parameter = 0) {\n"
19761 " int const i = 1;\n"
19762 " int *j = 2;\n"
19763 " int big = 10000;\n"
19764 "\n"
19765 " unsigned oneTwoThree = 123;\n"
19766 " int oneTwo = 12;\n"
19767 " method();\n"
19768 " float k = 2;\n"
19769 " int ll = 10000;\n"
19771 "void SomeFunction(int parameter= 0) {\n"
19772 " int const i= 1;\n"
19773 " int *j=2;\n"
19774 " int big = 10000;\n"
19775 "\n"
19776 "unsigned oneTwoThree =123;\n"
19777 "int oneTwo = 12;\n"
19778 " method();\n"
19779 "float k= 2;\n"
19780 "int ll=10000;\n"
19783 verifyFormat("void SomeFunction(int parameter = 0) {\n"
19784 " int const i = 1;\n"
19785 " int **j = 2, ***k;\n"
19786 " int &k = i;\n"
19787 " int &&l = i + j;\n"
19788 " int big = 10000;\n"
19789 "\n"
19790 " unsigned oneTwoThree = 123;\n"
19791 " int oneTwo = 12;\n"
19792 " method();\n"
19793 " float k = 2;\n"
19794 " int ll = 10000;\n"
19796 "void SomeFunction(int parameter= 0) {\n"
19797 " int const i= 1;\n"
19798 " int **j=2,***k;\n"
19799 "int &k=i;\n"
19800 "int &&l=i+j;\n"
19801 " int big = 10000;\n"
19802 "\n"
19803 "unsigned oneTwoThree =123;\n"
19804 "int oneTwo = 12;\n"
19805 " method();\n"
19806 "float k= 2;\n"
19807 "int ll=10000;\n"
19812 verifyFormat("int *a;\n"
19813 "int **b;\n"
19814 "int ***c;\n"
19821 verifyFormat("void SomeFunction(int parameter = 0) {\n"
19822 " int const i = 1;\n"
19823 " int* j = 2;\n"
19824 " int big = 10000;\n"
19825 "\n"
19826 " unsigned oneTwoThree = 123;\n"
19827 " int oneTwo = 12;\n"
19828 " method();\n"
19829 " float k = 2;\n"
19830 " int ll = 10000;\n"
19832 "void SomeFunction(int parameter= 0) {\n"
19833 " int const i= 1;\n"
19834 " int *j=2;\n"
19835 " int big = 10000;\n"
19836 "\n"
19837 "unsigned oneTwoThree =123;\n"
19838 "int oneTwo = 12;\n"
19839 " method();\n"
19840 "float k= 2;\n"
19841 "int ll=10000;\n"
19844 verifyFormat("void SomeFunction(int parameter = 0) {\n"
19845 " int const i = 1;\n"
19846 " int** j = 2;\n"
19847 " int& k = i;\n"
19848 " int&& l = i + j;\n"
19849 " int big = 10000;\n"
19850 "\n"
19851 " unsigned oneTwoThree = 123;\n"
19852 " int oneTwo = 12;\n"
19853 " method();\n"
19854 " float k = 2;\n"
19855 " int ll = 10000;\n"
19857 "void SomeFunction(int parameter= 0) {\n"
19858 " int const i= 1;\n"
19859 " int **j=2;\n"
19860 "int &k=i;\n"
19861 "int &&l=i+j;\n"
19862 " int big = 10000;\n"
19863 "\n"
19864 "unsigned oneTwoThree =123;\n"
19865 "int oneTwo = 12;\n"
19866 " method();\n"
19867 "float k= 2;\n"
19868 "int ll=10000;\n"
19872 verifyFormat("int* a;\n"
19873 "int** b;\n"
19874 "int*** c;\n"
19878 verifyFormat("int a(SomeType& foo, const Test& = Test());\n"
19885 verifyFormat("void SomeFunction(int parameter = 0) {\n"
19886 " int const i = 1;\n"
19887 " int * j = 2;\n"
19888 " int big = 10000;\n"
19889 "\n"
19890 " unsigned oneTwoThree = 123;\n"
19891 " int oneTwo = 12;\n"
19892 " method();\n"
19893 " float k = 2;\n"
19894 " int ll = 10000;\n"
19896 "void SomeFunction(int parameter= 0) {\n"
19897 " int const i= 1;\n"
19898 " int *j=2;\n"
19899 " int big = 10000;\n"
19900 "\n"
19901 "unsigned oneTwoThree =123;\n"
19902 "int oneTwo = 12;\n"
19903 " method();\n"
19904 "float k= 2;\n"
19905 "int ll=10000;\n"
19908 verifyFormat("void SomeFunction(int parameter = 0) {\n"
19909 " int const i = 1;\n"
19910 " int ** j = 2, ***k;\n"
19911 " int & k = i;\n"
19912 " int && l = i + j;\n"
19913 " int big = 10000;\n"
19914 "\n"
19915 " unsigned oneTwoThree = 123;\n"
19916 " int oneTwo = 12;\n"
19917 " method();\n"
19918 " float k = 2;\n"
19919 " int ll = 10000;\n"
19921 "void SomeFunction(int parameter= 0) {\n"
19922 " int const i= 1;\n"
19923 " int **j=2,***k;\n"
19924 "int &k=i;\n"
19925 "int &&l=i+j;\n"
19926 " int big = 10000;\n"
19927 "\n"
19928 "unsigned oneTwoThree =123;\n"
19929 "int oneTwo = 12;\n"
19930 " method();\n"
19931 "float k= 2;\n"
19932 "int ll=10000;\n"
19936 verifyFormat("int * a;\n"
19937 "int * b;\n"
19938 "int *** c;\n"
19942 verifyFormat("int a(SomeType & foo, const Test & = Test());\n"
19948 verifyFormat("#define A \\\n"
19949 " int aaaa = 12; \\\n"
19950 " float b = 23; \\\n"
19951 " const int ccc = 234; \\\n"
19955 verifyFormat("#define A \\\n"
19956 " int aaaa = 12; \\\n"
19957 " float b = 23; \\\n"
19958 " const int ccc = 234; \\\n"
19963 verifyFormat("#define A \\\n"
19964 " int aaaa = 12; \\\n"
19965 " float b = 23; \\\n"
19966 " const int ccc = 234; \\\n"
19971 "k = 4, int l = 5,\n"
19972 " int m = 6) {\n"
19973 " const int j = 10;\n"
19974 " otherThing = 1;\n"
19977 verifyFormat("void SomeFunction(int parameter = 0) {\n"
19978 " int const i = 1;\n"
19979 " int *j = 2;\n"
19980 " int big = 10000;\n"
19983 verifyFormat("class C {\n"
19984 "public:\n"
19985 " int i = 1;\n"
19986 " virtual void f() = 0;\n"
19989 verifyFormat("float i = 1;\n"
19990 "if (SomeType t = getSomething()) {\n"
19991 "}\n"
19992 "const unsigned j = 2;\n"
19995 verifyFormat("float j = 7;\n"
19996 "for (int k = 0; k < N; ++k) {\n"
19997 "}\n"
19998 "unsigned j = 2;\n"
19999 "int big = 10000;\n"
20003 verifyFormat("float i = 1;\n"
20004 "LooooooooooongType loooooooooooooooooooooongVariable\n"
20005 " = someLooooooooooooooooongFunction();\n"
20009 verifyFormat("int i = 1;\n"
20010 "LooooooooooongType loooooooooooooooooooooongVariable =\n"
20011 " someLooooooooooooooooongFunction();\n"
20016 verifyFormat("auto lambda = []() {\n"
20017 " auto ii = 0;\n"
20018 " float j = 0;\n"
20019 " return 0;\n"
20020 "};\n"
20021 "int i = 0;\n"
20022 "float i2 = 0;\n"
20023 "auto v = type{\n"
20024 " i = 1, //\n"
20025 " (i = 2), //\n"
20026 " i = 3 //\n"
20032 "int i = 1;\n"
20033 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
20034 " loooooooooooooooooooooongParameterB);\n"
20044 verifyFormat("float ii = 1;\n"
20045 "unsigned j = 2;\n"
20046 "int someVerylongVariable = 1;\n"
20047 "AnotherLongType ll = 123456;\n"
20048 "VeryVeryLongType k = 2;\n"
20055 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
20056 " typename LongType, typename B>\n"
20059 verifyFormat("float a, b = 1;\n"
20060 "int c = 2;\n"
20063 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
20067 verifyFormat("float a, b = 1;\n"
20068 "int c = 2;\n"
20071 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
20078 verifyFormat("void foo(float a,\n"
20079 " float b,\n"
20080 " int c,\n"
20081 " uint32_t *d) {\n"
20082 " int *e = 0;\n"
20083 " float f = 0;\n"
20084 " double g = 0;\n"
20085 "}\n"
20086 "void bar(ino_t a,\n"
20087 " int b,\n"
20088 " uint32_t *c,\n"
20097 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
20098 " static const Version verVs2017;\n"
20099 " return true;\n"
20106 verifyFormat("int func() { //\n"
20107 " int b;\n"
20108 " unsigned c;\n"
20115 verifyFormat("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
20120 verifyFormat("unsigned int* a;\n"
20121 "int* b;\n"
20122 "unsigned int Const* c;\n"
20123 "unsigned int const* d;\n"
20124 "unsigned int Const& e;\n"
20127 verifyFormat("Const unsigned int* c;\n"
20128 "const unsigned int* d;\n"
20129 "Const unsigned int& e;\n"
20130 "const unsigned int& f;\n"
20131 "const unsigned g;\n"
20136 verifyFormat("unsigned int * a;\n"
20137 "int * b;\n"
20138 "unsigned int Const * c;\n"
20139 "unsigned int const * d;\n"
20140 "unsigned int Const & e;\n"
20143 verifyFormat("Const unsigned int * c;\n"
20144 "const unsigned int * d;\n"
20145 "Const unsigned int & e;\n"
20146 "const unsigned int & f;\n"
20147 "const unsigned g;\n"
20154 verifyFormat("const auto result{[]() {\n"
20155 " const auto something = 1;\n"
20156 " return 2;\n"
20159 verifyFormat("int foo{[]() {\n"
20160 " int bar{0};\n"
20161 " return 0;\n"
20165 verifyFormat("const auto result{ []() {\n"
20166 " const auto something = 1;\n"
20167 " return 2;\n"
20170 verifyFormat("int foo{ []() {\n"
20171 " int bar{ 0 };\n"
20172 " return 0;\n"
20177 verifyFormat("unsigned int f1(void);\n"
20178 "void f2(void);\n"
20188 verifyFormat("switch (level) {\n"
20189 "case log::info: return \"info\";\n"
20190 "case log::warning: return \"warning\";\n"
20191 "default: return \"default\";\n"
20195 verifyFormat("switch (level) {\n"
20196 "case log::info: return \"info\";\n"
20197 "case log::warning: return \"warning\";\n"
20199 "switch (level) {\n"
20200 "case log::info: return \"info\";\n"
20201 "case log::warning:\n"
20202 " return \"warning\";\n"
20208 verifyFormat("switch (level) {\n"
20209 "case log::info: return \"info\";\n"
20210 "case log::critical:\n"
20211 "case log::warning:\n"
20212 "case log::severe: return \"severe\";\n"
20213 "case log::extra_severe:\n"
20214 " // comment\n"
20215 " return \"extra_severe\";\n"
20220 verifyNoChange("switch (level) {\n"
20221 "case log::info: return \"info\";\n"
20222 "case log::warning: return \"warning\";\n"
20223 "// comment\n"
20224 "case log::critical: return \"critical\";\n"
20225 "default: return \"default\";\n"
20226 "\n"
20227 "case log::severe: return \"severe\";\n"
20233 verifyFormat("switch (level) {\n"
20234 "case log::info: return \"info\";\n"
20235 "case log::warning:\n"
20236 "case log::critical:\n"
20237 "default: return \"default\";\n"
20243 verifyFormat("switch (level) {\n"
20244 "case log::info: return \"info\";\n"
20245 "case log::warning: // fallthrough\n"
20246 "case log::error: return \"error\";\n"
20247 "case log::critical: /*fallthrough*/\n"
20248 "case log::severe: return \"severe\";\n"
20249 "case log::diag: [[fallthrough]];\n"
20250 "default: return \"default\";\n"
20255 verifyFormat("switch (level) {\n"
20256 "case log::info: return \"info\";\n"
20257 "case log::warning: // fallthrough\n"
20258 "case log::error: return \"error\";\n"
20260 "switch (level) {\n"
20261 "case log::info: return \"info\";\n"
20262 "case log::warning: //fallthrough\n"
20263 "case log::error: return \"error\";\n"
20269 verifyFormat("switch (level) {\n"
20270 "case log::critical:\n"
20271 " // comment\n"
20272 " return \"critical\";\n"
20273 "case log::info: return \"info\";\n"
20274 "case log::warning: return \"warning\";\n"
20275 "default:\n"
20276 " // comment\n"
20277 " return \"\";\n"
20278 "case log::error: return \"error\";\n"
20279 "case log::severe: return \"severe\";\n"
20280 "case log::extra_critical:\n"
20281 " // comment\n"
20282 " return \"extra critical\";\n"
20287 verifyFormat("switch (level) {\n"
20288 "case log::info : return \"info\";\n"
20289 "case log::warning : return \"warning\";\n"
20290 "default : return \"default\";\n"
20296 verifyFormat("switch (level) {\n"
20297 "case log::info: return \"info\";\n"
20298 "case log::warning: return \"warning\";\n"
20299 "case log::other:\n"
20300 " switch (sublevel) {\n"
20301 " case log::info: return \"info\";\n"
20302 " case log::warning: return \"warning\";\n"
20303 " }\n"
20304 " break;\n"
20305 "case log::error: return \"error\";\n"
20306 "default: return \"default\";\n"
20308 "switch (level) {\n"
20309 "case log::info: return \"info\";\n"
20310 "case log::warning: return \"warning\";\n"
20311 "case log::other: switch (sublevel) {\n"
20312 " case log::info: return \"info\";\n"
20313 " case log::warning: return \"warning\";\n"
20314 "}\n"
20315 "break;\n"
20316 "case log::error: return \"error\";\n"
20317 "default: return \"default\";\n"
20323 verifyFormat("switch (level) {\n"
20324 "case log::info: return \"info\";\n"
20325 "\n"
20326 "case log::warning: return \"warning\";\n"
20328 "switch (level) {\n"
20329 "case log::info: return \"info\";\n"
20330 "\n"
20331 "case log::warning: return \"warning\";\n"
20337 verifyNoChange("switch (level) {\n"
20338 "case log::info: return \"info\";\n"
20339 "\n"
20340 "/* block comment */\n"
20341 "\n"
20342 "// line comment\n"
20343 "case log::warning: return \"warning\";\n"
20349 verifyFormat("switch (level) {\n"
20350 "case log::info: return \"info\";\n"
20351 "//\n"
20352 "case log::warning: return \"warning\";\n"
20358 verifyFormat("switch (level) {\n"
20359 "case log::info : return \"info\";\n"
20360 "case log::warning: return \"warning\";\n"
20361 "default : return \"default\";\n"
20367 verifyFormat("switch (level) {\n"
20368 "case log::info : return \"info\";\n"
20369 "case log::warning :\n"
20370 "case log::critical:\n"
20371 "default : return \"default\";\n"
20376 verifyFormat("switch (level) {\n"
20377 "case log::info : return \"info\";\n"
20378 "case log::warning :\n"
20379 "case log::critical:\n"
20380 "case log::severe : return \"severe\";\n"
20381 "default:\n"
20382 " // comment\n"
20383 " return \"default\";\n"
20390 verifyFormat("switch (level) {\n"
20391 "case log::critical:\n"
20392 " // comment\n"
20393 " return \"critical\";\n"
20394 "case log::info : return \"info\";\n"
20395 "case log::warning: return \"warning\";\n"
20396 "default:\n"
20397 " // comment\n"
20398 " return \"\";\n"
20399 "case log::error : return \"error\";\n"
20400 "case log::severe: return \"severe\";\n"
20401 "case log::extra_critical:\n"
20402 " // comment\n"
20403 " return \"extra critical\";\n"
20408 verifyFormat("switch (level) {\n"
20409 "case log::info : return \"info\";\n"
20410 "case log::warning : return \"warning\";\n"
20411 "case log::error :\n"
20412 "default : return \"default\";\n"
20434 verifyFormat("void foo() {\n"
20435 " int myVar = 5;\n"
20436 " double x = 3.14;\n"
20437 " auto str = \"Hello \"\n"
20438 " \"World\";\n"
20439 " auto s = \"Hello \"\n"
20440 " \"Again\";\n"
20445 verifyFormat("void foo() {\n"
20446 " const int capacityBefore = Entries.capacity();\n"
20447 " const auto newEntry = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
20448 " std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
20449 " const X newEntry2 = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
20450 " std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
20456 verifyFormat("void foo() {\n"
20457 " int myVar = 5;\n"
20458 " double x = 3.14;\n"
20459 " auto str = \"Hello \"\n"
20460 " \"World\";\n"
20461 " auto s = \"Hello \"\n"
20462 " \"Again\";\n"
20467 verifyFormat("void foo() {\n"
20468 " const int capacityBefore = Entries.capacity();\n"
20469 " const auto newEntry = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
20470 " std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
20471 " const X newEntry2 = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
20472 " std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
20479 verifyFormat("void foo() {\n"
20480 " int myVar = 5;\n"
20481 " double x = 3.14;\n"
20482 " auto str = \"Hello \"\n"
20483 " \"World\";\n"
20484 " auto s = \"Hello \"\n"
20485 " \"Again\";\n"
20490 verifyFormat("void foo() {\n"
20491 " const int capacityBefore = Entries.capacity();\n"
20492 " const auto newEntry = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
20493 " std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
20494 " const X newEntry2 = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
20495 " std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
20503 verifyFormat("void foo() {\n"
20504 " int myVar = 5;\n"
20505 " double x = 3.14;\n"
20506 " auto str = \"Hello \"\n"
20507 " \"World\";\n"
20508 " auto s = \"Hello \"\n"
20509 " \"Again\";\n"
20514 verifyFormat("void foo() {\n"
20515 " const int capacityBefore = Entries.capacity();\n"
20516 " const auto newEntry = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
20517 " std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
20518 " const X newEntry2 = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
20519 " std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
20528 verifyFormat("void foo() {\n"
20529 " int i1 = 1;\n"
20530 " int j = 0;\n"
20531 " int k = bar(\n"
20532 " argument1,\n"
20533 " argument2);\n"
20537 verifyFormat("unsigned i = 0;\n"
20538 "int a[] = {\n"
20539 " 1234567890,\n"
20546 verifyFormat("void SomeFunc() {\n"
20547 " newWatcher.maxAgeUsec = ToLegacyTimestamp(GetMaxAge(FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec),\n"
20548 " seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
20549 " newWatcher.maxAge = ToLegacyTimestamp(GetMaxAge(FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec),\n"
20550 " seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
20551 " newWatcher.max = ToLegacyTimestamp(GetMaxAge(FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec),\n"
20552 " seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
20560 verifyFormat("void SomeFunc() {\n"
20561 " newWatcher.maxAgeUsec = ToLegacyTimestamp(GetMaxAge(\n"
20562 " FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec), seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
20563 " newWatcher.maxAge = ToLegacyTimestamp(GetMaxAge(\n"
20564 " FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec), seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
20565 " newWatcher.max = ToLegacyTimestamp(GetMaxAge(\n"
20566 " FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec), seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
20575 verifyFormat("void foo1(void) {\n"
20576 " BYTE p[1] = 1;\n"
20577 " A B = {.one_foooooooooooooooo = 2,\n"
20578 " .two_fooooooooooooo = 3,\n"
20579 " .three_fooooooooooooo = 4};\n"
20580 " BYTE payload = 2;\n"
20586 verifyFormat("void foo2(void) {\n"
20587 " BYTE p[1] = 1;\n"
20588 " A B = {.one_foooooooooooooooo = 2,\n"
20589 " .two_fooooooooooooo = 3,\n"
20590 " .three_fooooooooooooo = 4};\n"
20591 " BYTE payload = 2;\n"
20597 verifyFormat("void foo3(void) {\n"
20598 " BYTE p[1] = 1;\n"
20599 " A B = {.one_foooooooooooooooo = 2,\n"
20600 " .two_fooooooooooooo = 3,\n"
20601 " .three_fooooooooooooo = 4};\n"
20602 " BYTE payload = 2;\n"
20608 verifyFormat("void foo4(void) {\n"
20609 " BYTE p[1] = 1;\n"
20610 " A B = {.one_foooooooooooooooo = 2,\n"
20611 " .two_fooooooooooooo = 3,\n"
20612 " .three_fooooooooooooo = 4};\n"
20613 " BYTE payload = 2;\n"
20621 verifyFormat("namespace a\n"
20622 "{\n"
20623 "class A\n"
20624 "{\n"
20625 " void f()\n"
20626 " {\n"
20627 " if (true) {\n"
20628 " a();\n"
20629 " b();\n"
20630 " } else {\n"
20631 " a();\n"
20632 " }\n"
20633 " }\n"
20634 " void g() { return; }\n"
20635 "};\n"
20636 "struct B {\n"
20637 " int x;\n"
20638 "};\n"
20641 verifyFormat("enum X {\n"
20642 " Y = 0,\n"
20645 verifyFormat("struct S {\n"
20646 " int Type;\n"
20647 " union {\n"
20648 " int x;\n"
20649 " double y;\n"
20650 " } Value;\n"
20651 " class C\n"
20652 " {\n"
20653 " MyFavoriteType Value;\n"
20654 " } Class;\n"
20663 verifyFormat("namespace a {\n"
20664 "class A\n"
20665 "{\n"
20666 " void f()\n"
20667 " {\n"
20668 " if (true) {\n"
20669 " a();\n"
20670 " b();\n"
20671 " }\n"
20672 " }\n"
20673 " void g() { return; }\n"
20674 "};\n"
20675 "enum E\n"
20676 "{\n"
20677 " A,\n"
20678 " // foo\n"
20679 " B,\n"
20680 " C\n"
20681 "};\n"
20682 "struct B\n"
20683 "{\n"
20684 " int x;\n"
20685 "};\n"
20688 verifyFormat("struct S\n"
20689 "{\n"
20690 " int Type;\n"
20691 " union\n"
20692 " {\n"
20693 " int x;\n"
20694 " double y;\n"
20695 " } Value;\n"
20696 " class C\n"
20697 " {\n"
20698 " MyFavoriteType Value;\n"
20699 " } Class;\n"
20707 verifyFormat("namespace a {\n"
20708 "class A {\n"
20709 " void f()\n"
20710 " {\n"
20711 " if (true) {\n"
20712 " a();\n"
20713 " b();\n"
20714 " }\n"
20715 " }\n"
20716 " void g() { return; }\n"
20717 "};\n"
20718 "struct B {\n"
20719 " int x;\n"
20720 "};\n"
20724 verifyFormat("void foo()\n"
20725 "{\n"
20726 " if (a) {\n"
20727 " a();\n"
20728 " }\n"
20729 " else {\n"
20730 " b();\n"
20731 " }\n"
20735 verifyFormat("#ifdef _DEBUG\n"
20736 "int foo(int i = 0)\n"
20737 "#else\n"
20738 "int foo(int i = 5)\n"
20739 "#endif\n"
20740 "{\n"
20741 " return i;\n"
20745 verifyFormat("void foo() {}\n"
20746 "void bar()\n"
20747 "#ifdef _DEBUG\n"
20748 "{\n"
20749 " foo();\n"
20750 "}\n"
20751 "#else\n"
20752 "{\n"
20753 "}\n"
20757 verifyFormat("void foobar() { int i = 5; }\n"
20758 "#ifdef _DEBUG\n"
20759 "void bar() {}\n"
20760 "#else\n"
20761 "void bar() { foobar(); }\n"
20770 verifyFormat("namespace a\n"
20771 "{\n"
20772 "void f();\n"
20773 "void g();\n"
20775 "namespace a\n"
20776 "{\n"
20777 "void f();\n"
20778 "void g();\n"
20782 verifyFormat("namespace a\n"
20783 "{\n"
20784 "class A\n"
20785 "{\n"
20786 " void f()\n"
20787 " {\n"
20788 " if (true)\n"
20789 " {\n"
20790 " a();\n"
20791 " b();\n"
20792 " }\n"
20793 " }\n"
20794 " void g() { return; }\n"
20795 "};\n"
20796 "struct B\n"
20797 "{\n"
20798 " int x;\n"
20799 "};\n"
20800 "union C\n"
20801 "{\n"
20802 "};\n"
20806 verifyFormat("void f()\n"
20807 "{\n"
20808 " if (true)\n"
20809 " {\n"
20810 " a();\n"
20811 " }\n"
20812 " else if (false)\n"
20813 " {\n"
20814 " b();\n"
20815 " }\n"
20816 " else\n"
20817 " {\n"
20818 " c();\n"
20819 " }\n"
20823 verifyFormat("void f()\n"
20824 "{\n"
20825 " for (int i = 0; i < 10; ++i)\n"
20826 " {\n"
20827 " a();\n"
20828 " }\n"
20829 " while (false)\n"
20830 " {\n"
20831 " b();\n"
20832 " }\n"
20833 " do\n"
20834 " {\n"
20835 " c();\n"
20836 " } while (false)\n"
20840 verifyFormat("void f(int a)\n"
20841 "{\n"
20842 " switch (a)\n"
20843 " {\n"
20844 " case 0:\n"
20845 " break;\n"
20846 " case 1:\n"
20847 " {\n"
20848 " break;\n"
20849 " }\n"
20850 " case 2:\n"
20851 " {\n"
20852 " }\n"
20853 " break;\n"
20854 " default:\n"
20855 " break;\n"
20856 " }\n"
20860 verifyFormat("enum X\n"
20861 "{\n"
20862 " Y = 0,\n"
20865 verifyFormat("enum X\n"
20866 "{\n"
20867 " Y = 0\n"
20871 verifyFormat("@interface BSApplicationController ()\n"
20872 "{\n"
20873 "@private\n"
20874 " id _extraIvar;\n"
20875 "}\n"
20879 verifyFormat("#ifdef _DEBUG\n"
20880 "int foo(int i = 0)\n"
20881 "#else\n"
20882 "int foo(int i = 5)\n"
20883 "#endif\n"
20884 "{\n"
20885 " return i;\n"
20889 verifyFormat("void foo() {}\n"
20890 "void bar()\n"
20891 "#ifdef _DEBUG\n"
20892 "{\n"
20893 " foo();\n"
20894 "}\n"
20895 "#else\n"
20896 "{\n"
20897 "}\n"
20901 verifyFormat("void foobar() { int i = 5; }\n"
20902 "#ifdef _DEBUG\n"
20903 "void bar() {}\n"
20904 "#else\n"
20905 "void bar() { foobar(); }\n"
20912 verifyFormat("[](int i) { return i + 2; };\n"
20913 "[](int i, int j)\n"
20914 "{\n"
20915 " auto x = i + j;\n"
20916 " auto y = i * j;\n"
20917 " return x ^ y;\n"
20918 "};\n"
20919 "void foo()\n"
20920 "{\n"
20921 " auto shortLambda = [](int i) { return i + 2; };\n"
20922 " auto longLambda = [](int i, int j)\n"
20923 " {\n"
20924 " auto x = i + j;\n"
20925 " auto y = i * j;\n"
20926 " return x ^ y;\n"
20927 " };\n"
20933 verifyFormat("[](int i)\n"
20934 "{\n"
20935 " return i + 2;\n"
20936 "};\n"
20937 "[](int i, int j)\n"
20938 "{\n"
20939 " auto x = i + j;\n"
20940 " auto y = i * j;\n"
20941 " return x ^ y;\n"
20942 "};\n"
20943 "void foo()\n"
20944 "{\n"
20945 " auto shortLambda = [](int i)\n"
20946 " {\n"
20947 " return i + 2;\n"
20948 " };\n"
20949 " auto longLambda = [](int i, int j)\n"
20950 " {\n"
20951 " auto x = i + j;\n"
20952 " auto y = i * j;\n"
20953 " return x ^ y;\n"
20954 " };\n"
20962 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
20963 " // ...\n"
20964 " int i;\n"
20967 verifyFormat("void (^block)(void) = ^{\n"
20968 " // ...\n"
20969 " int i;\n"
20973 verifyFormat("void f()\n"
20974 "{\n"
20975 " // ...\n"
20976 " [object someMethod:@{@\"a\" : @\"b\"}];\n"
20979 verifyFormat("void f()\n"
20980 "{\n"
20981 " // ...\n"
20982 " [object someMethod:@{a : @\"b\"}];\n"
20985 verifyFormat("int f()\n"
20986 "{ // comment\n"
20987 " return 42;\n"
20994 verifyFormat("void f()\n"
20995 "{\n"
20996 " int i;\n"
21005 verifyFormat("void f(bool b)\n"
21006 "{\n"
21007 " if (b)\n"
21008 " {\n"
21009 " return;\n"
21010 " }\n"
21013 verifyFormat("void f(bool b)\n"
21014 "{\n"
21015 " if constexpr (b)\n"
21016 " {\n"
21017 " return;\n"
21018 " }\n"
21021 verifyFormat("void f(bool b)\n"
21022 "{\n"
21023 " if CONSTEXPR (b)\n"
21024 " {\n"
21025 " return;\n"
21026 " }\n"
21029 verifyFormat("void f(bool b)\n"
21030 "{\n"
21031 " if (b) return;\n"
21034 verifyFormat("void f(bool b)\n"
21035 "{\n"
21036 " if constexpr (b) return;\n"
21039 verifyFormat("void f(bool b)\n"
21040 "{\n"
21041 " if CONSTEXPR (b) return;\n"
21044 verifyFormat("void f(bool b)\n"
21045 "{\n"
21046 " while (b)\n"
21047 " {\n"
21048 " return;\n"
21049 " }\n"
21067 verifyFormat("class A;\n"
21068 "namespace B\n"
21069 " {\n"
21070 "class C;\n"
21071 "// Comment\n"
21072 "class D\n"
21073 " {\n"
21074 "public:\n"
21075 " D();\n"
21076 " ~D() {}\n"
21077 "private:\n"
21078 " enum E\n"
21079 " {\n"
21080 " F\n"
21081 " }\n"
21082 " };\n"
21088 verifyFormat("namespace a\n"
21089 " {\n"
21090 "class A\n"
21091 " {\n"
21092 " void f()\n"
21093 " {\n"
21094 " if (true)\n"
21095 " {\n"
21096 " a();\n"
21097 " b();\n"
21098 " }\n"
21099 " }\n"
21100 " void g()\n"
21101 " {\n"
21102 " return;\n"
21103 " }\n"
21104 " };\n"
21105 "struct B\n"
21106 " {\n"
21107 " int x;\n"
21108 " };\n"
21112 verifyFormat("namespace a\n"
21113 " {\n"
21114 "namespace b\n"
21115 " {\n"
21116 "class A\n"
21117 " {\n"
21118 " void f()\n"
21119 " {\n"
21120 " if (true)\n"
21121 " {\n"
21122 " a();\n"
21123 " b();\n"
21124 " }\n"
21125 " }\n"
21126 " void g()\n"
21127 " {\n"
21128 " return;\n"
21129 " }\n"
21130 " };\n"
21131 "struct B\n"
21132 " {\n"
21133 " int x;\n"
21134 " };\n"
21135 " } // namespace b\n"
21140 verifyFormat("namespace a\n"
21141 " {\n"
21142 "namespace b\n"
21143 " {\n"
21144 " class A\n"
21145 " {\n"
21146 " void f()\n"
21147 " {\n"
21148 " if (true)\n"
21149 " {\n"
21150 " a();\n"
21151 " b();\n"
21152 " }\n"
21153 " }\n"
21154 " void g()\n"
21155 " {\n"
21156 " return;\n"
21157 " }\n"
21158 " };\n"
21159 " struct B\n"
21160 " {\n"
21161 " int x;\n"
21162 " };\n"
21163 " } // namespace b\n"
21168 verifyFormat("namespace a\n"
21169 " {\n"
21170 " namespace b\n"
21171 " {\n"
21172 " class A\n"
21173 " {\n"
21174 " void f()\n"
21175 " {\n"
21176 " if (true)\n"
21177 " {\n"
21178 " a();\n"
21179 " b();\n"
21180 " }\n"
21181 " }\n"
21182 " void g()\n"
21183 " {\n"
21184 " return;\n"
21185 " }\n"
21186 " };\n"
21187 " struct B\n"
21188 " {\n"
21189 " int x;\n"
21190 " };\n"
21191 " } // namespace b\n"
21195 verifyFormat("void f()\n"
21196 " {\n"
21197 " if (true)\n"
21198 " {\n"
21199 " a();\n"
21200 " }\n"
21201 " else if (false)\n"
21202 " {\n"
21203 " b();\n"
21204 " }\n"
21205 " else\n"
21206 " {\n"
21207 " c();\n"
21208 " }\n"
21212 verifyFormat("void f()\n"
21213 " {\n"
21214 " for (int i = 0; i < 10; ++i)\n"
21215 " {\n"
21216 " a();\n"
21217 " }\n"
21218 " while (false)\n"
21219 " {\n"
21220 " b();\n"
21221 " }\n"
21222 " do\n"
21223 " {\n"
21224 " c();\n"
21225 " } while (false)\n"
21230 verifyFormat("void switchTest1(int a)\n"
21231 " {\n"
21232 " switch (a)\n"
21233 " {\n"
21234 " case 2:\n"
21235 " {\n"
21236 " }\n"
21237 " break;\n"
21238 " }\n"
21242 verifyFormat("void switchTest2(int a)\n"
21243 " {\n"
21244 " switch (a)\n"
21245 " {\n"
21246 " case 0:\n"
21247 " break;\n"
21248 " case 1:\n"
21249 " {\n"
21250 " break;\n"
21251 " }\n"
21252 " case 2:\n"
21253 " {\n"
21254 " }\n"
21255 " break;\n"
21256 " default:\n"
21257 " break;\n"
21258 " }\n"
21262 verifyFormat("void switchTest3(int a)\n"
21263 " {\n"
21264 " switch (a)\n"
21265 " {\n"
21266 " case 0:\n"
21267 " {\n"
21268 " foo(x);\n"
21269 " }\n"
21270 " break;\n"
21271 " default:\n"
21272 " {\n"
21273 " foo(1);\n"
21274 " }\n"
21275 " break;\n"
21276 " }\n"
21282 verifyFormat("void switchTest4(int a)\n"
21283 " {\n"
21284 " switch (a)\n"
21285 " {\n"
21286 " case 2:\n"
21287 " {\n"
21288 " }\n"
21289 " break;\n"
21290 " }\n"
21294 verifyFormat("void switchTest5(int a)\n"
21295 " {\n"
21296 " switch (a)\n"
21297 " {\n"
21298 " case 0:\n"
21299 " break;\n"
21300 " case 1:\n"
21301 " {\n"
21302 " foo();\n"
21303 " break;\n"
21304 " }\n"
21305 " case 2:\n"
21306 " {\n"
21307 " }\n"
21308 " break;\n"
21309 " default:\n"
21310 " break;\n"
21311 " }\n"
21315 verifyFormat("void switchTest6(int a)\n"
21316 " {\n"
21317 " switch (a)\n"
21318 " {\n"
21319 " case 0:\n"
21320 " {\n"
21321 " foo(x);\n"
21322 " }\n"
21323 " break;\n"
21324 " default:\n"
21325 " {\n"
21326 " foo(1);\n"
21327 " }\n"
21328 " break;\n"
21329 " }\n"
21333 verifyFormat("enum X\n"
21334 " {\n"
21335 " Y = 0, // testing\n"
21339 verifyFormat("enum X\n"
21340 " {\n"
21341 " Y = 0\n"
21344 verifyFormat("enum X\n"
21345 " {\n"
21346 " Y = 0,\n"
21347 " Z = 1\n"
21351 verifyFormat("@interface BSApplicationController ()\n"
21352 " {\n"
21353 "@private\n"
21354 " id _extraIvar;\n"
21355 " }\n"
21359 verifyFormat("#ifdef _DEBUG\n"
21360 "int foo(int i = 0)\n"
21361 "#else\n"
21362 "int foo(int i = 5)\n"
21363 "#endif\n"
21364 " {\n"
21365 " return i;\n"
21369 verifyFormat("void foo() {}\n"
21370 "void bar()\n"
21371 "#ifdef _DEBUG\n"
21372 " {\n"
21373 " foo();\n"
21374 " }\n"
21375 "#else\n"
21376 " {\n"
21377 " }\n"
21381 verifyFormat("void foobar()\n"
21382 " {\n"
21383 " int i = 5;\n"
21384 " }\n"
21385 "#ifdef _DEBUG\n"
21386 "void bar() {}\n"
21387 "#else\n"
21388 "void bar()\n"
21389 " {\n"
21390 " foobar();\n"
21391 " }\n"
21396 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
21397 " // ...\n"
21398 " int i;\n"
21401 verifyFormat("void (^block)(void) = ^{\n"
21402 " // ...\n"
21403 " int i;\n"
21407 verifyFormat("void f()\n"
21408 " {\n"
21409 " [object someMethod:@{@\"a\" : @\"b\"}];\n"
21413 verifyFormat("int f()\n"
21414 " { // comment\n"
21415 " return 42;\n"
21423 verifyFormat("void f(bool b)\n"
21424 " {\n"
21425 " if (b)\n"
21426 " {\n"
21427 " return;\n"
21428 " }\n"
21431 verifyFormat("void f(bool b)\n"
21432 " {\n"
21433 " if (b) return;\n"
21436 verifyFormat("void f(bool b)\n"
21437 " {\n"
21438 " while (b)\n"
21439 " {\n"
21440 " return;\n"
21441 " }\n"
21449 verifyFormat("namespace a\n"
21450 "{\n"
21451 "class A\n"
21452 "{\n"
21453 " void f()\n"
21454 " {\n"
21455 " int a;\n"
21456 " {\n"
21457 " int b;\n"
21458 " }\n"
21459 " if (true)\n"
21460 " {\n"
21461 " a();\n"
21462 " b();\n"
21463 " }\n"
21464 " }\n"
21465 " void g() { return; }\n"
21466 "}\n"
21470 verifyFormat("void f()\n"
21471 "{\n"
21472 " if (true)\n"
21473 " {\n"
21474 " a();\n"
21475 " }\n"
21476 " else if (false)\n"
21477 " {\n"
21478 " b();\n"
21479 " }\n"
21480 " else\n"
21481 " {\n"
21482 " c();\n"
21483 " }\n"
21487 verifyFormat("void f()\n"
21488 "{\n"
21489 " for (int i = 0; i < 10; ++i)\n"
21490 " {\n"
21491 " a();\n"
21492 " }\n"
21493 " while (false)\n"
21494 " {\n"
21495 " b();\n"
21496 " }\n"
21497 " do\n"
21498 " {\n"
21499 " c();\n"
21500 " }\n"
21501 " while (false);\n"
21505 verifyFormat("void f(int a)\n"
21506 "{\n"
21507 " switch (a)\n"
21508 " {\n"
21509 " case 0:\n"
21510 " break;\n"
21511 " case 1:\n"
21512 " {\n"
21513 " break;\n"
21514 " }\n"
21515 " case 2:\n"
21516 " {\n"
21517 " }\n"
21518 " break;\n"
21519 " default:\n"
21520 " break;\n"
21521 " }\n"
21525 verifyFormat("enum X\n"
21526 "{\n"
21527 " Y = 0,\n"
21531 verifyFormat("@interface BSApplicationController ()\n"
21532 "{\n"
21533 "@private\n"
21534 " id _extraIvar;\n"
21535 "}\n"
21539 verifyFormat("#ifdef _DEBUG\n"
21540 "int foo(int i = 0)\n"
21541 "#else\n"
21542 "int foo(int i = 5)\n"
21543 "#endif\n"
21544 "{\n"
21545 " return i;\n"
21549 verifyFormat("void foo() {}\n"
21550 "void bar()\n"
21551 "#ifdef _DEBUG\n"
21552 "{\n"
21553 " foo();\n"
21554 "}\n"
21555 "#else\n"
21556 "{\n"
21557 "}\n"
21561 verifyFormat("void foobar() { int i = 5; }\n"
21562 "#ifdef _DEBUG\n"
21563 "void bar() {}\n"
21564 "#else\n"
21565 "void bar() { foobar(); }\n"
21574 verifyFormat("namespace a {\n"
21575 "class A {\n"
21576 " void f()\n"
21577 " {\n"
21578 " if (true) {\n"
21579 " a();\n"
21580 " b();\n"
21581 " }\n"
21582 " }\n"
21583 " void g() { return; }\n"
21584 "};\n"
21585 "enum E {\n"
21586 " A,\n"
21587 " // foo\n"
21588 " B,\n"
21589 " C\n"
21590 "};\n"
21591 "struct B {\n"
21592 " int x;\n"
21593 "};\n"
21596 verifyFormat("struct S {\n"
21597 " int Type;\n"
21598 " union {\n"
21599 " int x;\n"
21600 " double y;\n"
21601 " } Value;\n"
21602 " class C {\n"
21603 " MyFavoriteType Value;\n"
21604 " } Class;\n"
21610 verifyFormat("void f() {\n"
21611 " try {\n"
21612 " } catch (const Exception &e) {\n"
21613 " }\n"
21620 verifyNoCrash("f({\n"
21621 "table({}, table({{\"\", false}}, {}))\n"
21627 verifyFormat("struct test demo[] = {\n"
21628 " {56, 23, \"hello\"},\n"
21629 " {-1, 93463, \"world\"},\n"
21630 " { 7, 5, \"!!\"}\n"
21634 verifyFormat("struct test demo[] = {\n"
21635 " {56, 23, \"hello\"}, // first line\n"
21636 " {-1, 93463, \"world\"}, // second line\n"
21637 " { 7, 5, \"!!\"} // third line\n"
21641 verifyFormat("struct test demo[4] = {\n"
21642 " { 56, 23, 21, \"oh\"}, // first line\n"
21643 " { -1, 93463, 22, \"my\"}, // second line\n"
21644 " { 7, 5, 1, \"goodness\"} // third line\n"
21645 " {234, 5, 1, \"gracious\"} // fourth line\n"
21649 verifyFormat("struct test demo[3] = {\n"
21650 " {56, 23, \"hello\"},\n"
21651 " {-1, 93463, \"world\"},\n"
21652 " { 7, 5, \"!!\"}\n"
21656 verifyFormat("struct test demo[3] = {\n"
21657 " {int{56}, 23, \"hello\"},\n"
21658 " {int{-1}, 93463, \"world\"},\n"
21659 " { int{7}, 5, \"!!\"}\n"
21663 verifyFormat("struct test demo[] = {\n"
21664 " {56, 23, \"hello\"},\n"
21665 " {-1, 93463, \"world\"},\n"
21666 " { 7, 5, \"!!\"},\n"
21670 verifyFormat("test demo[] = {\n"
21671 " {56, 23, \"hello\"},\n"
21672 " {-1, 93463, \"world\"},\n"
21673 " { 7, 5, \"!!\"},\n"
21677 verifyFormat("demo = std::array<struct test, 3>{\n"
21678 " test{56, 23, \"hello\"},\n"
21679 " test{-1, 93463, \"world\"},\n"
21680 " test{ 7, 5, \"!!\"},\n"
21684 verifyFormat("test demo[] = {\n"
21685 " {56, 23, \"hello\"},\n"
21686 "#if X\n"
21687 " {-1, 93463, \"world\"},\n"
21688 "#endif\n"
21689 " { 7, 5, \"!!\"}\n"
21694 "test demo[] = {\n"
21695 " { 7, 23,\n"
21696 " \"hello world i am a very long line that really, in any\"\n"
21697 " \"just world, ought to be split over multiple lines\"},\n"
21698 " {-1, 93463, \"world\"},\n"
21699 " {56, 5, \"!!\"}\n"
21703 verifyNoCrash("Foo f[] = {\n"
21704 " [0] = { 1, },\n"
21705 " [i] { 1, },\n"
21708 verifyNoCrash("Foo foo[] = {\n"
21709 " [0] = {1, 1},\n"
21710 " [1] { 1, 1, },\n"
21711 " [2] { 1, 1, },\n"
21714 verifyNoCrash("test arr[] = {\n"
21715 "#define FOO(i) {i, i},\n"
21716 "SOME_GENERATOR(FOO)\n"
21717 "{2, 2}\n"
21721 verifyFormat("return GradForUnaryCwise(g, {\n"
21723 " {\"x\", \"dy\"}},\n"
21725 ", \"sign\"}},\n"
21730 verifyFormat("struct test demo[] = {\n"
21731 " { 56, 23, \"hello\" },\n"
21732 " { -1, 93463, \"world\" },\n"
21733 " { 7, 5, \"!!\" }\n"
21740 "test demo[] = {\n"
21742 "in any just world, ought to be split over multiple lines\"},\n"
21744 " \"world\"},\n"
21746 " \"!!\"},\n"
21754 verifyFormat("test demo[] = {\n"
21755 " {56, 23, /* a comment */ \"hello\"},\n"
21756 " {-1, 93463, \"world\"},\n"
21757 " { 7, 5, \"!!\"}\n"
21761 verifyFormat("test demo[] = {\n"
21762 " {56, 23, \"hello\"},\n"
21763 " {-1, 93463, \"world\" /* comment here */},\n"
21764 " { 7, 5, \"!!\"}\n"
21768 verifyFormat("test demo[] = {\n"
21769 " {56, /* a comment */ 23, \"hello\"},\n"
21770 " {-1, 93463, \"world\"},\n"
21771 " { 7, 5, \"!!\"}\n"
21776 verifyFormat("demo = std::array<\n"
21777 " struct test, 3>{\n"
21778 " test{\n"
21779 " 56, 23,\n"
21780 " \"hello \"\n"
21781 " \"world i \"\n"
21782 " \"am a very \"\n"
21783 " \"long line \"\n"
21784 " \"that \"\n"
21785 " \"really, \"\n"
21786 " \"in any \"\n"
21787 " \"just \"\n"
21788 " \"world, \"\n"
21789 " \"ought to \"\n"
21790 " \"be split \"\n"
21791 " \"over \"\n"
21792 " \"multiple \"\n"
21793 " \"lines\"},\n"
21794 " test{-1, 93463,\n"
21795 " \"world\"},\n"
21796 " test{ 7, 5,\n"
21797 " \"!!\" },\n"
21807 verifyFormat("static A x = {\n"
21808 " {{init1, init2, init3, init4},\n"
21809 " {init1, init2, init3, init4}}\n"
21814 verifyFormat("int a[][] = {\n"
21815 " {\n"
21816 " {0, 2}, //\n"
21817 " {1, 2} //\n"
21818 " }\n"
21824 "test demo[] = {\n"
21825 " {56, 23,\n"
21827 ", ought to be split over \"\n"
21828 " \"multiple lines\" },\n"
21829 " {-1, 93463, \"world\"},\n"
21830 " { 7, 5, \"!!\"},\n"
21839 verifyFormat("struct test demo[] = {\n"
21840 " {56, 23, \"hello\"},\n"
21841 " {-1, 93463, \"world\"},\n"
21842 " { 7, 5, \"!!\"}\n"
21843 "};\n"
21844 "static A x = {\n"
21845 " {{init1, init2, init3, init4},\n"
21846 " {init1, init2, init3, init4}}\n"
21852 verifyFormat("struct test demo[] = {\n"
21853 " {56, 23, \"hello\"},\n"
21854 " {-1, 93463, \"world\"},\n"
21855 " { 7, 5, \"!!\"}\n"
21856 "};\n"
21857 "struct test demo[4] = {\n"
21858 " { 56, 23, 21, \"oh\"}, // first line\n"
21859 " { -1, 93463, 22, \"my\"}, // second line\n"
21860 " { 7, 5, 1, \"goodness\"} // third line\n"
21861 " {234, 5, 1, \"gracious\"} // fourth line\n"
21865 "test demo[] = {\n"
21866 " {56,\n"
21868 ", ought to be split over \"\n"
21869 " \"multiple lines\", 23},\n"
21870 " {-1, \"world\", 93463},\n"
21871 " { 7, \"!!\", 5},\n"
21883 verifyFormat("auto foo = Items{\n"
21884 " Section{0, bar(), },\n"
21885 " Section{1, boo() }\n"
21889 verifyFormat("auto foo = Items{\n"
21890 " Section{\n"
21891 " 0, bar(),\n"
21892 " }\n"
21895 verifyFormat("struct test demo[] = {\n"
21896 " {56, 23, \"hello\"},\n"
21897 " {-1, 93463, \"world\"},\n"
21898 " {7, 5, \"!!\" }\n"
21901 verifyFormat("struct test demo[] = {\n"
21902 " {56, 23, \"hello\"}, // first line\n"
21903 " {-1, 93463, \"world\"}, // second line\n"
21904 " {7, 5, \"!!\" } // third line\n"
21907 verifyFormat("struct test demo[4] = {\n"
21908 " {56, 23, 21, \"oh\" }, // first line\n"
21909 " {-1, 93463, 22, \"my\" }, // second line\n"
21910 " {7, 5, 1, \"goodness\"} // third line\n"
21911 " {234, 5, 1, \"gracious\"} // fourth line\n"
21914 verifyFormat("struct test demo[3] = {\n"
21915 " {56, 23, \"hello\"},\n"
21916 " {-1, 93463, \"world\"},\n"
21917 " {7, 5, \"!!\" }\n"
21921 verifyFormat("struct test demo[3] = {\n"
21922 " {int{56}, 23, \"hello\"},\n"
21923 " {int{-1}, 93463, \"world\"},\n"
21924 " {int{7}, 5, \"!!\" }\n"
21927 verifyFormat("struct test demo[] = {\n"
21928 " {56, 23, \"hello\"},\n"
21929 " {-1, 93463, \"world\"},\n"
21930 " {7, 5, \"!!\" },\n"
21933 verifyFormat("test demo[] = {\n"
21934 " {56, 23, \"hello\"},\n"
21935 " {-1, 93463, \"world\"},\n"
21936 " {7, 5, \"!!\" },\n"
21939 verifyFormat("demo = std::array<struct test, 3>{\n"
21940 " test{56, 23, \"hello\"},\n"
21941 " test{-1, 93463, \"world\"},\n"
21942 " test{7, 5, \"!!\" },\n"
21945 verifyFormat("test demo[] = {\n"
21946 " {56, 23, \"hello\"},\n"
21947 "#if X\n"
21948 " {-1, 93463, \"world\"},\n"
21949 "#endif\n"
21950 " {7, 5, \"!!\" }\n"
21954 "test demo[] = {\n"
21955 " {7, 23,\n"
21956 " \"hello world i am a very long line that really, in any\"\n"
21957 " \"just world, ought to be split over multiple lines\"},\n"
21958 " {-1, 93463, \"world\" },\n"
21959 " {56, 5, \"!!\" }\n"
21963 verifyNoCrash("Foo f[] = {\n"
21964 " [0] = { 1, },\n"
21965 " [i] { 1, },\n"
21968 verifyNoCrash("Foo foo[] = {\n"
21969 " [0] = {1, 1},\n"
21970 " [1] { 1, 1, },\n"
21971 " [2] { 1, 1, },\n"
21974 verifyNoCrash("test arr[] = {\n"
21975 "#define FOO(i) {i, i},\n"
21976 "SOME_GENERATOR(FOO)\n"
21977 "{2, 2}\n"
21981 verifyFormat("return GradForUnaryCwise(g, {\n"
21983 "\"dy\"} },\n"
21985 "{\"dy\", \"sign\"}},\n"
21990 verifyFormat("#define FOO \\\n"
21991 " int foo[][2] = { \\\n"
21992 " {0, 1} \\\n"
21997 verifyFormat("struct test demo[] = {\n"
21998 " { 56, 23, \"hello\" },\n"
21999 " { -1, 93463, \"world\" },\n"
22000 " { 7, 5, \"!!\" }\n"
22007 "test demo[] = {\n"
22009 "just world, ought to be split over multiple lines\"},\n"
22011 " },\n"
22013 " },\n"
22021 verifyFormat("test demo[] = {\n"
22022 " {56, 23, /* a comment */ \"hello\"},\n"
22023 " {-1, 93463, \"world\" },\n"
22024 " {7, 5, \"!!\" }\n"
22028 verifyFormat("test demo[] = {\n"
22029 " {56, 23, \"hello\" },\n"
22030 " {-1, 93463, \"world\" /* comment here */},\n"
22031 " {7, 5, \"!!\" }\n"
22035 verifyFormat("test demo[] = {\n"
22036 " {56, /* a comment */ 23, \"hello\"},\n"
22037 " {-1, 93463, \"world\"},\n"
22038 " {7, 5, \"!!\" }\n"
22041 verifyFormat("Foo foo = {\n"
22042 " // comment\n"
22043 " {1, 2}\n"
22050 "demo = std::array<\n"
22051 " struct test, 3>{\n"
22052 " test{\n"
22053 " 56, 23,\n"
22054 " \"hello \"\n"
22055 " \"world i \"\n"
22056 " \"am a very \"\n"
22057 " \"long line \"\n"
22058 " \"that \"\n"
22059 " \"really, \"\n"
22060 " \"in any \"\n"
22061 " \"just \"\n"
22062 " \"world, \"\n"
22063 " \"ought to \"\n"
22064 " \"be split \"\n"
22065 " \"over \"\n"
22066 " \"multiple \"\n"
22067 " \"lines\"},\n"
22068 " test{-1, 93463,\n"
22069 " \"world\"},\n"
22070 " test{7, 5,\n"
22071 " \"!!\" },\n"
22082 verifyFormat("static A x = {\n"
22083 " {{init1, init2, init3, init4},\n"
22084 " {init1, init2, init3, init4}}\n"
22089 "test demo[] = {\n"
22090 " {56, 23,\n"
22092 ", ought to be split over \"\n"
22093 " \"multiple lines\" },\n"
22094 " {-1, 93463, \"world\"},\n"
22095 " {7, 5, \"!!\" },\n"
22103 verifyNoCrash("Type foo{\n"
22104 " {\n"
22105 " 1, // A\n"
22106 " 2, // B\n"
22107 " 3, // C\n"
22108 " },\n"
22109 " \"hello\",\n"
22112 verifyNoCrash("Type object[X][Y] = {\n"
22113 " {{val}, {val}, {val}},\n"
22114 " {{val}, {val}, // some comment\n"
22115 " {val}}\n"
22121 "T v[] {\n"
22125 "00000000000000000000000000000000000000000000000000000000\" },\n"
22131 verifyFormat("Foo foo[] = {\n"
22132 " {1, 1},\n"
22133 " {1, 1},\n"
22152 verifyFormat("#pragma comment(linker, \\\n"
22153 " \"argument\" \\\n"
22155 "#pragma comment(linker, \\\n"
22156 " \"argument\" \\\n"
22164 verifyFormat("#pragma omp target map(to : var[ : N])");
22165 verifyFormat("#pragma omp target map(to : var[0 : N])");
22166 verifyFormat("#pragma omp target map(always, to : var[0 : N])");
22169 "#pragma omp target \\\n"
22170 " reduction(+ : var) \\\n"
22171 " map(to : A[0 : N]) \\\n"
22172 " map(to : B[0 : N]) \\\n"
22173 " map(from : C[0 : N]) \\\n"
22174 " firstprivate(i) \\\n"
22175 " firstprivate(j) \\\n"
22177 "#pragma omp target reduction(+:var) map(to:A[0:N]) map(to:B[0:N]) "
22178 "map(from:C[0:N]) firstprivate(i) firstprivate(j) firstprivate(k)",
22198 verifyFormat("/*\n"
22199 " *\t9012345\n"
22200 " * /8901\n"
22202 "/*\n"
22203 " *\t9012345 /8901\n"
22206 verifyFormat("/*\n"
22207 " *345678\n"
22208 " *\t/8901\n"
22210 "/*\n"
22211 " *345678\t/8901\n"
22215 verifyFormat("int a; // the\n"
22218 verifyNoChange("int a; /* first line\n"
22219 " * second\n"
22220 " * line third\n"
22221 " * line\n"
22224 verifyFormat("int a; // first line\n"
22225 " // second\n"
22226 " // line third\n"
22228 "int a; // first line\n"
22229 " // second line\n"
22235 verifyFormat("int a; // the comment\n"
22238 verifyNoChange("int a; /* first line\n"
22239 " * second line\n"
22240 " * third line\n"
22243 verifyFormat("int a; // first line\n"
22244 " // second line\n"
22249 verifyFormat("int a; /* first line\n"
22250 " * second line\n"
22251 " * third line\n"
22254 "\n*/",
22257 verifyFormat("// foo bar baz bazfoo\n"
22259 "// foo bar baz bazfoo\n"
22262 verifyFormat("// foo bar baz bazfoo\n"
22264 "// foo bar baz bazfoo\n"
22270 verifyFormat("// foo bar baz bazfoo\n"
22272 "// foo bar baz bazfoo bar\n"
22277 EXPECT_EQ("// foo bar baz bazfoo\n"
22278 "// foo bar baz bazfoo\n"
22280 format("// foo bar baz bazfoo\n"
22281 "// foo bar baz bazfoo bar\n"
22286 EXPECT_EQ("// foo bar baz bazfoo\n"
22287 "// foo bar baz bazfoo\n"
22289 format("// foo bar baz bazfoo\n"
22290 "// foo bar baz bazfoo bar\n"
22297 verifyFormat("// foo foo foo foo\n"
22298 "// foo foo foo foo\n"
22302 verifyFormat("int a = /* long block\n"
22303 " comment */\n"
22312 verifyFormat("int foo(\n"
22317 "int foo(\n"
22326 verifyFormat("foo((\n"
22331 verifyFormat("foo((int)\n"
22333 "foo((\n"
22342 verifyFormat("for (\n"
22343 " int iiiiiiiiiiiiiiiii =\n"
22344 " 0;\n"
22345 " iiiiiiiiiiiiiiiii <\n"
22346 " 2;\n"
22347 " iiiiiiiiiiiiiiiii++) {\n"
22352 verifyFormat("for (int iiiiiiiiiiiiiiiii =\n"
22353 " 0;\n"
22354 " iiiiiiiiiiiiiiiii <\n"
22355 " 2;\n"
22356 " iiiiiiiiiiiiiiiii++) {\n"
22358 "for (\n"
22359 " int iiiiiiiiiiiiiiiii =\n"
22360 " 0;\n"
22361 " iiiiiiiiiiiiiiiii <\n"
22362 " 2;\n"
22363 " iiiiiiiiiiiiiiiii++) {\n"
22374 verifyFormat("aaaaaaaa.aaaaaaaa.bbbbbbbb()\n"
22375 " .ccccccccccccccccccccc(dddddddd);\n"
22376 "aaaaaaaa.aaaaaaaa\n"
22381 verifyFormat("foo->bar\n"
22390 verifyFormat("unsigned long\n"
22394 verifyFormat("unsigned long foo::\n"
22401 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
22402 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
22403 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
22414 verifyFormat("\xef\xbb\xbf\n#include <iostream>");
22419 "\xef\xbb\xbf\n#include <iostream>", Style);
22445 EXPECT_EQ("\"aaaaÄ\"\n"
22449 EXPECT_EQ("\"aaaaaaaÄ\"\n"
22453 EXPECT_EQ("\"Однажды, в \"\n"
22454 "\"студёную \"\n"
22455 "\"зимнюю \"\n"
22461 "\"一 二 三 \"\n"
22462 "\"四 五六 \"\n"
22463 "\"七 八 九 \"\n"
22467 EXPECT_EQ("\"一\t\"\n"
22468 "\"二 \t\"\n"
22469 "\"三 四 \"\n"
22470 "\"五\t\"\n"
22471 "\"六 \t\"\n"
22472 "\"七 \"\n"
22479 EXPECT_EQ("\"aaaaaa\"\n"
22485 verifyFormat("const char *sssss =\n"
22486 " \"一二三四五六七八\\\n"
22488 "const char *sssss = \"一二三四五六七八\\\n"
22495 verifyFormat("// Я из лесу\n"
22496 "// вышел; был\n"
22497 "// сильный\n"
22501 verifyFormat("// 一二三\n"
22502 "// 四五六七\n"
22503 "// 八 九\n"
22509 verifyFormat("/* Гляжу,\n"
22510 " * поднимается\n"
22511 " * медленно в\n"
22512 " * гору\n"
22513 " * Лошадка,\n"
22514 " * везущая\n"
22515 " * хворосту\n"
22517 "/* Гляжу, поднимается медленно в гору\n"
22520 verifyFormat("/* 一二三\n"
22521 " * 四五六七\n"
22522 " * 八 九\n"
22525 verifyFormat("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
22526 " * 𝕓𝕪𝕥𝕖\n"
22538 "SomeClass::Constructor()\n"
22539 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
22545 "SomeClass::Constructor()\n"
22546 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
22552 "SomeClass::Constructor()\n"
22553 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
22558 "SomeLongTemplateVariableName<\n"
22562 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
22568 verifyFormat("SomeClass::Constructor() :\n"
22569 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
22578 verifyFormat("SomeClass::Constructor()\n"
22579 " : a(a)\n"
22580 " , b(b)\n"
22583 verifyFormat("SomeClass::Constructor()\n"
22588 verifyFormat("SomeClass::Constructor()\n"
22591 verifyFormat("SomeClass::Constructor() noexcept\n"
22594 verifyFormat("SomeClass::Constructor()\n"
22595 " : a(a)\n"
22596 " , b(b)\n"
22599 verifyFormat("SomeClass::Constructor()\n"
22600 " : a(a) {\n"
22601 " foo();\n"
22602 " bar();\n"
22607 verifyFormat("SomeClass::Constructor()\n"
22608 " : a(a)\n"
22609 " , b(b)\n"
22610 " , c(c) {\n}",
22612 verifyFormat("SomeClass::Constructor()\n"
22613 " : a(a) {\n}",
22619 verifyFormat("SomeClass::Constructor()\n"
22620 " : a(a)\n"
22621 " , b(b)\n"
22626 verifyFormat("SomeClass::Constructor()\n"
22627 ": a(a)\n"
22628 ", b(b)\n"
22639 "SomeClass::Constructor()\n"
22643 verifyFormat("SomeClass::Constructor()\n"
22646 verifyFormat("SomeClass::Constructor()\n"
22650 "SomeClass::Constructor()\n"
22657 verifyFormat("SomeClass::Constructor()\n"
22658 " : aaaaaaaa(aaaaaaaa)\n"
22659 " , aaaaaaaa(aaaaaaaa)\n"
22663 verifyFormat("SomeClass::Constructor()\n"
22664 " : aaaaaaaa(aaaaaaaa)\n"
22665 " , aaaaaaaa(aaaaaaaa)\n"
22674 verifyFormat("SomeClass::Constructor()\n"
22675 " : a{a}\n"
22678 verifyFormat("SomeClass::Constructor()\n"
22679 " : a{a}\n"
22680 "#if CONDITION\n"
22681 " , b{b}\n"
22682 "#endif\n"
22683 "{\n}",
22686 verifyFormat("SomeClass::Constructor()\n"
22687 "#if CONDITION\n"
22688 " : a{a}\n"
22689 "#endif\n"
22690 " , b{b}\n"
22691 " , c{c} {\n}",
22694 verifyFormat("SomeClass::Constructor()\n"
22695 ": a{a}\n"
22696 "#ifdef CONDITION\n"
22697 ", b{b}\n"
22698 "#else\n"
22699 ", c{c}\n"
22700 "#endif\n"
22701 ", d{d} {\n}",
22704 verifyFormat("SomeClass::Constructor()\n"
22705 " : a{a}\n"
22706 "#if WINDOWS\n"
22707 "#if DEBUG\n"
22708 " , b{0}\n"
22709 "#else\n"
22710 " , b{1}\n"
22711 "#endif\n"
22712 "#else\n"
22713 "#if DEBUG\n"
22714 " , b{2}\n"
22715 "#else\n"
22716 " , b{3}\n"
22717 "#endif\n"
22718 "#endif\n"
22719 "{\n}",
22721 verifyFormat("SomeClass::Constructor()\n"
22722 " : a{a}\n"
22723 "#if WINDOWS\n"
22724 " , b{0}\n"
22725 "#if DEBUG\n"
22726 " , c{0}\n"
22727 "#else\n"
22728 " , c{1}\n"
22729 "#endif\n"
22730 "#else\n"
22731 "#if DEBUG\n"
22732 " , c{2}\n"
22733 "#else\n"
22734 " , c{3}\n"
22735 "#endif\n"
22736 " , b{1}\n"
22737 "#endif\n"
22738 "{\n}",
22751 verifyFormat("namespace outer {\n"
22752 "int i;\n"
22753 "namespace inner {\n"
22754 " int i;\n"
22755 "} // namespace inner\n"
22756 "} // namespace outer\n"
22757 "namespace other_outer {\n"
22758 "int i;\n"
22763 verifyFormat("switch (variable) {\n"
22764 "case 1:\n"
22765 "case 2:\n"
22766 " doSomething();\n"
22767 " break;\n"
22768 "default:\n"
22769 " ++variable;\n"
22775 "void f()\n"
22776 "{\n"
22777 " if (aaaaaaaaaaaaaaaa\n"
22778 " && bbbbbbbbbbbbbbbbbbbbbbbb\n"
22779 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
22780 " return;\n"
22782 "void f() {\n"
22783 "if (aaaaaaaaaaaaaaaa\n"
22784 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
22785 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
22786 "return;\n"
22797 verifyFormat("while (true) {\n"
22798 " continue;\n"
22804 verifyFormat("Constructor()\n"
22805 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
22806 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
22807 " aaaaaaaaaaaaaa)\n"
22808 " , aaaaaaaaaaaaaaaaaaaaaaa()\n"
22809 "{\n"
22812 verifyFormat("SomeClass::Constructor()\n"
22813 " : a(a)\n"
22814 "{\n"
22817 verifyFormat("SomeClass::Constructor()\n"
22818 " : a(a)\n"
22819 "{\n"
22822 verifyFormat("SomeClass::Constructor()\n"
22823 " : a(a)\n"
22824 " , b(b)\n"
22825 " , c(c)\n"
22826 "{\n"
22829 verifyFormat("SomeClass::Constructor()\n"
22830 " : a(a)\n"
22831 "{\n"
22832 " foo();\n"
22833 " bar();\n"
22838 verifyFormat("class C {\n"
22839 "public:\n"
22840 " int i;\n"
22845 verifyFormat("int a; // Do not\n"
22850 verifyFormat("ASSERT(aaaa\n"
22852 "ASSERT ( aaaa\n||bbbb);", Style);
22855 verifyFormat("if (aaaaaaaaaaaaaaa\n"
22856 " || bbbbbbbbbbbbbbb) {\n"
22857 " i++;\n"
22859 "if (aaaaaaaaaaaaaaa\n"
22862 verifyFormat("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
22863 " i++;\n"
22870 verifyFormat("#define aNumber \\\n"
22872 "#define aNumber \\\n"
22877 verifyFormat("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
22879 "NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
22882 verifyFormat("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
22884 "NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
22889 verifyFormat("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
22890 " @\"a\",\n"
22891 " @\"a\"\n"
22892 "]\n"
22894 "NSArray* a = [[NSArray alloc] initWithArray:@[\n"
22895 " @\"a\",\n"
22896 " @\"a\"\n"
22897 " ]\n"
22901 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
22903 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
22908 verifyFormat("[self.a b:c\n"
22910 "[self.a b:c\n"
22927 verifyFormat("void f() {\n"
22928 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
22930 verifyFormat("void f() {\n"
22931 " other(x.begin(), //\n"
22932 " x.end(), //\n"
22933 " [&](int, int) { return 1; });\n"
22935 verifyFormat("void f() {\n"
22936 " other.other.other.other.other(\n"
22937 " x.begin(), x.end(),\n"
22939 "return 1; });\n"
22942 "void f() {\n"
22943 " other.other.other.other.other(\n"
22944 " x.begin(), x.end(),\n"
22945 " [something, rather](int, int, int, int, int, int, int) {\n"
22946 " //\n"
22947 " });\n"
22949 verifyFormat("SomeFunction([]() { // A cool function...\n"
22950 " return 43;\n"
22952 verifyFormat("SomeFunction([]() {\n"
22953 "#define A a\n"
22954 " return 43;\n"
22956 "SomeFunction([](){\n"
22957 "#define A a\n"
22958 "return 43;\n"
22960 verifyFormat("void f() {\n"
22961 " SomeFunction([](decltype(x), A *a) {});\n"
22962 " SomeFunction([](typeof(x), A *a) {});\n"
22963 " SomeFunction([](_Atomic(x), A *a) {});\n"
22964 " SomeFunction([](__underlying_type(x), A *a) {});\n"
22966 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
22968 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
22969 " SomeOtherFunctioooooooooooooooooooooooooon();\n"
22971 verifyFormat("Constructor()\n"
22972 " : Field([] { // comment\n"
22973 " int i;\n"
22975 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
22976 " return some_parameter.size();\n"
22978 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
22980 verifyFormat("int i = aaaaaa ? 1 //\n"
22981 " : [] {\n"
22982 " return 2; //\n"
22984 verifyFormat("llvm::errs() << \"number of twos is \"\n"
22985 " << std::count_if(v.begin(), v.end(), [](int x) {\n"
22986 " return x == 2; // force break\n"
22988 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
22989 " [=](int iiiiiiiiiiii) {\n"
22990 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
22991 " aaaaaaaaaaaaaaaaaaaaaaa;\n"
22995 verifyFormat("SomeFunction({[&] {\n"
22996 " // comment\n"
22997 " },\n"
22998 " [&] {\n"
22999 " // comment\n"
23001 verifyFormat("SomeFunction({[&] {\n"
23002 " // comment\n"
23005 "virtual aaaaaaaaaaaaaaaa(\n"
23006 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
23038 verifyFormat("namespace bar {\n"
23039 "// broken:\n"
23040 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
23042 verifyFormat("namespace bar {\n"
23043 "// broken:\n"
23044 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
23046 verifyFormat("namespace bar {\n"
23047 "// broken:\n"
23048 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
23050 verifyFormat("namespace bar {\n"
23051 "// broken:\n"
23052 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
23054 verifyFormat("namespace bar {\n"
23055 "// broken:\n"
23056 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
23058 verifyFormat("namespace bar {\n"
23059 "// broken:\n"
23060 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
23062 verifyFormat("namespace bar {\n"
23063 "// broken:\n"
23064 "auto foo{[]() -> foo<!5> { return {}; }};\n"
23066 verifyFormat("namespace bar {\n"
23067 "// broken:\n"
23068 "auto foo{[]() -> foo<~5> { return {}; }};\n"
23070 verifyFormat("namespace bar {\n"
23071 "// broken:\n"
23072 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
23074 verifyFormat("namespace bar {\n"
23075 "// broken:\n"
23076 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
23078 verifyFormat("namespace bar {\n"
23079 "// broken:\n"
23080 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
23082 verifyFormat("namespace bar {\n"
23083 "// broken:\n"
23084 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
23086 verifyFormat("namespace bar {\n"
23087 "// broken:\n"
23088 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
23090 verifyFormat("namespace bar {\n"
23091 "// broken:\n"
23092 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
23094 verifyFormat("namespace bar {\n"
23095 "// broken:\n"
23096 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
23098 verifyFormat("namespace bar {\n"
23099 "// broken:\n"
23100 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
23102 verifyFormat("namespace bar {\n"
23103 "// broken:\n"
23104 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
23106 verifyFormat("namespace bar {\n"
23107 "// broken:\n"
23108 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
23122 verifyFormat("namespace bar {\n"
23123 "auto foo{[]() -> foo<false> { ; }};\n"
23125 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
23126 " int j) -> int {\n"
23127 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
23130 "aaaaaaaaaaaaaaaaaaaaaa(\n"
23131 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
23132 " return aaaaaaaaaaaaaaaaa;\n"
23135 verifyFormat("[]() //\n"
23136 " -> int {\n"
23137 " return 1; //\n"
23151 verifyFormat("auto L = []<class T>(T) {\n"
23152 " {\n"
23153 " f();\n"
23154 " g();\n"
23155 " }\n"
23157 verifyFormat("auto L = []<class... T>(T...) {\n"
23158 " {\n"
23159 " f();\n"
23160 " g();\n"
23161 " }\n"
23163 verifyFormat("auto L = []<typename... T>(T...) {\n"
23164 " {\n"
23165 " f();\n"
23166 " g();\n"
23167 " }\n"
23169 verifyFormat("auto L = []<template <typename...> class T>(T...) {\n"
23170 " {\n"
23171 " f();\n"
23172 " g();\n"
23173 " }\n"
23175 verifyFormat("auto L = []</*comment*/ class... T>(T...) {\n"
23176 " {\n"
23177 " f();\n"
23178 " g();\n"
23179 " }\n"
23181 verifyFormat("auto L = []<int... T>(T...) {\n"
23182 " {\n"
23183 " f();\n"
23184 " g();\n"
23185 " }\n"
23187 verifyFormat("auto L = []<Foo... T>(T...) {\n"
23188 " {\n"
23189 " f();\n"
23190 " g();\n"
23191 " }\n"
23204 verifyFormat("auto loooooooooooooooooooooooooooong =\n"
23207 verifyFormat("auto loooooooooooooooooooooooooooongName = SomeFunction(\n"
23213 verifyFormat("SomeFunction(\n"
23214 " []() {\n"
23215 " //\n"
23216 " },\n"
23217 " []() {\n"
23218 " //\n"
23222 verifyFormat("SomeFunction(\n"
23223 " [this] {\n"
23224 " //\n"
23225 " },\n"
23232 verifyFormat("SomeFunction(\n"
23233 " a,\n"
23234 " [this] {\n"
23235 " //\n"
23236 " },\n"
23239 verifyFormat("SomeFunction(\n"
23240 " a,\n"
23241 " [this] {\n"
23242 " //\n"
23243 " },\n"
23249 "something->SomeFunction(\n"
23250 " a,\n"
23251 " [this] {\n"
23253 "D0000000000000000000000000000000000000000000000000000000000001();\n"
23254 " },\n"
23259 verifyFormat("function(1, [this, that] {\n"
23260 " //\n"
23262 verifyFormat("function([this, that] {\n"
23263 " //\n"
23267 verifyFormat("function(a, b, c, //\n"
23268 " d, [this, that] {\n"
23269 " //\n"
23273 verifyFormat("SomeFunction(\n"
23274 " 1,\n"
23275 " [this] {\n"
23276 " //\n"
23277 " },\n"
23278 " [this] {\n"
23279 " //\n"
23280 " },\n"
23288 verifyFormat("double &operator[](int i) { return 0; }\n"
23295 verifyFormat("void f() {\n"
23296 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
23297 " );\n"
23302 verifyFormat("void f() {\n"
23303 " MACRO((const AA &a) { return 1; });\n"
23304 " MACRO((AA &a) { return 1; });\n"
23307 verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
23308 " doo_dah();\n"
23309 " doo_dah();\n"
23310 " })) {\n"
23312 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
23313 " doo_dah();\n"
23314 " doo_dah();\n"
23315 " })) {\n"
23317 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
23318 " doo_dah();\n"
23319 " doo_dah();\n"
23320 " })) {\n"
23322 verifyFormat("auto lambda = []() {\n"
23323 " int a = 2\n"
23324 "#if A\n"
23325 " + 2\n"
23326 "#endif\n"
23327 " ;\n"
23332 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
23333 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
23334 " -> ::std::unordered_set<\n"
23335 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
23336 " //\n"
23340 verifyFormat("very_long_function_name_yes_it_is_really_long(\n"
23341 " [](auto n) noexcept [[back_attr]]\n"
23342 " -> std::unordered_map<very_long_type_name_A,\n"
23343 " very_long_type_name_B> {\n"
23344 " really_do_something();\n"
23347 verifyFormat("very_long_function_name_yes_it_is_really_long(\n"
23348 " [](auto n) constexpr\n"
23349 " -> std::unordered_map<very_long_type_name_A,\n"
23350 " very_long_type_name_B> {\n"
23351 " really_do_something();\n"
23357 verifyFormat("auto c = []() {\n"
23358 " return b;\n"
23361 verifyFormat("auto c = []() {\n"
23367 verifyFormat("auto c = []() {\n"
23368 " return b;\n"
23370 "auto c = []() {\n"
23371 " return b;\n"
23375 "auto c = []() {\n"
23381 verifyFormat("auto c = []() {\n"
23382 " return b;\n"
23396 verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
23397 " []()\n"
23398 " {\n"
23399 " return 17;\n"
23402 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
23403 " []()\n"
23404 " {\n"
23407 verifyFormat("auto fct_SLS_None = []()\n"
23408 "{\n"
23409 " return 17;\n"
23412 verifyFormat("TwoNestedLambdas_SLS_None(\n"
23413 " []()\n"
23414 " {\n"
23415 " return Call(\n"
23416 " []()\n"
23417 " {\n"
23418 " return 17;\n"
23419 " });\n"
23422 verifyFormat("void Fct() {\n"
23423 " return {[]()\n"
23424 " {\n"
23425 " return 17;\n"
23426 " }};\n"
23432 verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
23433 " []()\n"
23434 " {\n"
23435 " return 17;\n"
23441 "ongFunctionName_SLS_Empty(\n"
23444 verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
23445 " []()\n"
23446 " {\n"
23447 " return 17;\n"
23450 verifyFormat("auto fct_SLS_Empty = []()\n"
23451 "{\n"
23452 " return 17;\n"
23455 verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
23456 " []()\n"
23457 " {\n"
23458 " return Call([]() {});\n"
23461 verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
23462 " []()\n"
23463 " {\n"
23464 " return Call([]() {});\n"
23468 "FctWithLongLineInLambda_SLS_Empty(\n"
23469 " []()\n"
23470 " {\n"
23471 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
23472 " AndShouldNotBeConsiderAsInline,\n"
23473 " LambdaBodyMustBeBreak);\n"
23483 verifyFormat("auto fct_SLS_Inline = []()\n"
23484 "{\n"
23485 " return 17;\n"
23492 "FctWithLongLineInLambda_SLS_Inline(\n"
23493 " []()\n"
23494 " {\n"
23495 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
23496 " AndShouldNotBeConsiderAsInline,\n"
23497 " LambdaBodyMustBeBreak);\n"
23501 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
23516 verifyFormat("FctWithOneParam_SLS_All(\n"
23517 " []()\n"
23518 " {\n"
23519 " // A cool function...\n"
23520 " return 43;\n"
23524 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
23532 "FctWithLongLineInLambda_SLS_All(\n"
23533 " []()\n"
23534 " {\n"
23535 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
23536 " AndShouldNotBeConsiderAsInline,\n"
23537 " LambdaBodyMustBeBreak);\n"
23541 "auto fct_SLS_All = []()\n"
23542 "{\n"
23543 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
23544 " AndShouldNotBeConsiderAsInline,\n"
23545 " LambdaBodyMustBeBreak);\n"
23552 "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
23553 " FirstParam,\n"
23554 " SecondParam,\n"
23555 " ThirdParam,\n"
23558 verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
23560 "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
23561 " FirstParam,\n"
23562 " SecondParam,\n"
23563 " ThirdParam,\n"
23567 "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
23568 " SecondParam,\n"
23569 " ThirdParam,\n"
23570 " FourthParam,\n"
23573 verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
23574 " []()\n"
23575 " {\n"
23578 "eConsiderAsInline;\n"
23582 "FctWithLongLineInLambda_SLS_All(\n"
23583 " []()\n"
23584 " {\n"
23585 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
23586 " AndShouldNotBeConsiderAsInline,\n"
23587 " LambdaBodyMustBeBreak);\n"
23590 verifyFormat("FctWithTwoParams_SLS_All(\n"
23591 " []()\n"
23592 " {\n"
23593 " // A cool function...\n"
23594 " return 43;\n"
23595 " },\n"
23601 "FctWithTwoParams_SLS_All(\n"
23605 "FctWithTwoParams_SLS_All(\n"
23606 " 87,\n"
23607 " []()\n"
23608 " {\n"
23610 "LongLineThatWillForceTheLambdaBodyToBeBrokenIntoMultipleLines();\n"
23621 verifyFormat("TwoNestedLambdas_SLS_All(\n"
23622 " []()\n"
23623 " {\n"
23624 " // A cool function...\n"
23625 " return Call([]() { return 17; });\n"
23628 verifyFormat("TwoNestedLambdas_SLS_All(\n"
23629 " []()\n"
23630 " {\n"
23631 " return Call(\n"
23632 " []()\n"
23633 " {\n"
23634 " // A cool function...\n"
23635 " return 17;\n"
23636 " });\n"
23643 verifyFormat("auto select = [this]() -> const Library::Object *\n"
23644 "{\n"
23645 " return MyAssignment::SelectFromList(this);\n"
23649 verifyFormat("auto select = [this]() -> const Library::Object &\n"
23650 "{\n"
23651 " return MyAssignment::SelectFromList(this);\n"
23655 verifyFormat("auto select = [this]() -> std::unique_ptr<Object>\n"
23656 "{\n"
23657 " return MyAssignment::SelectFromList(this);\n"
23661 verifyFormat("namespace test {\n"
23662 "class Test {\n"
23663 "public:\n"
23664 " Test() = default;\n"
23665 "};\n"
23671 verifyFormat("Result doSomething(Promise promise) {\n"
23672 " return promise.then(\n"
23673 " [this, obj = std::move(s)](int bar) mutable {\n"
23674 " return someObject.startAsyncAction().then(\n"
23675 " [this, &obj](Result result) mutable {\n"
23676 " result.processMore();\n"
23677 " });\n"
23678 " });\n"
23682 verifyFormat("Result doSomething(Promise promise) {\n"
23683 " return promise.then(\n"
23684 " [this, obj = std::move(s)](int bar) mutable {\n"
23685 " return obj.startAsyncAction().then(\n"
23686 " [this, &obj](Result result) mutable {\n"
23687 " result.processMore();\n"
23688 " });\n"
23689 " });\n"
23692 verifyFormat("Result doSomething(Promise promise) {\n"
23693 " return promise.then([this, obj = std::move(s)] {\n"
23694 " return obj.startAsyncAction().then(\n"
23695 " [this, &obj](Result result) mutable {\n"
23696 " result.processMore();\n"
23697 " });\n"
23698 " });\n"
23701 verifyFormat("void test() {\n"
23702 " ([]() -> auto {\n"
23703 " int b = 32;\n"
23704 " return 3;\n"
23705 " }).foo();\n"
23708 verifyFormat("void test() {\n"
23709 " []() -> auto {\n"
23710 " int b = 32;\n"
23711 " return 3;\n"
23712 " }\n"
23715 verifyFormat("void test() {\n"
23716 " std::sort(v.begin(), v.end(),\n"
23717 " [](const auto &foo, const auto &bar) {\n"
23718 " return foo.baz < bar.baz;\n"
23719 " });\n"
23722 verifyFormat("void test() {\n"
23723 " (\n"
23724 " []() -> auto {\n"
23725 " int b = 32;\n"
23726 " return 3;\n"
23727 " }, foo, bar)\n"
23728 " .foo();\n"
23731 verifyFormat("void test() {\n"
23732 " ([]() -> auto {\n"
23733 " int b = 32;\n"
23734 " return 3;\n"
23735 " })\n"
23736 " .foo()\n"
23737 " .bar();\n"
23740 verifyFormat("#define A \\\n"
23741 " [] { \\\n"
23742 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
23743 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
23746 verifyFormat("#define SORT(v) \\\n"
23747 " std::sort(v.begin(), v.end(), \\\n"
23748 " [](const auto &foo, const auto &bar) { \\\n"
23749 " return foo.baz < bar.baz; \\\n"
23752 verifyFormat("void foo() {\n"
23753 " aFunction(1, b(c(foo, bar, baz, [](d) {\n"
23754 " auto f = e(d);\n"
23755 " return f;\n"
23756 " })));\n"
23759 verifyFormat("void foo() {\n"
23760 " aFunction(1, b(c(foo, Bar{}, baz, [](d) -> Foo {\n"
23761 " auto f = e(foo, [&] {\n"
23762 " auto g = h();\n"
23763 " return g;\n"
23764 " }, qux, [&] -> Bar {\n"
23765 " auto i = j();\n"
23766 " return i;\n"
23767 " });\n"
23768 " return f;\n"
23769 " })));\n"
23772 verifyFormat("Namespace::Foo::Foo(LongClassName bar,\n"
23773 " AnotherLongClassName baz)\n"
23774 " : baz{baz}, func{[&] {\n"
23775 " auto qux = bar;\n"
23776 " return aFunkyFunctionCall(qux);\n"
23779 verifyFormat("void foo() {\n"
23780 " class Foo {\n"
23781 " public:\n"
23782 " Foo()\n"
23783 " : qux{[](int quux) {\n"
23784 " auto tmp = quux;\n"
23785 " return tmp;\n"
23786 " }} {}\n"
23787 "\n"
23788 " private:\n"
23789 " std::function<void(int quux)> qux;\n"
23790 " };\n"
23794 verifyFormat("Namespace::Foo::Foo(LongClassName bar,\n"
23795 " AnotherLongClassName baz) :\n"
23796 " baz{baz}, func{[&] {\n"
23797 " auto qux = bar;\n"
23798 " return aFunkyFunctionCall(qux);\n"
23802 verifyFormat("Namespace::Foo::Foo(LongClassName bar,\n"
23803 " AnotherLongClassName baz) :\n"
23804 " baz{baz},\n"
23805 " func{[&] {\n"
23806 " auto qux = bar;\n"
23807 " return aFunkyFunctionCall(qux);\n"
23815 verifyFormat("void foo() {\n"
23816 " aFunction(\n"
23817 " [](d) -> Foo {\n"
23818 " auto f = e(d);\n"
23819 " return f;\n"
23820 " }, foo, Bar{}, [] {\n"
23821 " auto g = h();\n"
23822 " return g;\n"
23823 " }, baz);\n"
23829 verifyFormat("void foo() {\n"
23830 " aFunction(\n"
23831 " 1,\n"
23832 " [](d) -> Foo {\n"
23833 " auto f = e(d);\n"
23834 " return f;\n"
23835 " }, foo, Bar{},\n"
23836 " [] {\n"
23837 " auto g = h();\n"
23838 " return g;\n"
23839 " }, bazzzzz,\n"
23840 " quuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuux);\n"
23844 verifyFormat("void foo() {\n"
23845 " aFunction(\n"
23846 " 1,\n"
23847 " [](d) -> Foo {\n"
23848 " auto f = e(d);\n"
23849 " return f;\n"
23850 " },\n"
23851 " foo,\n"
23852 " Bar{},\n"
23853 " [] {\n"
23854 " auto g = h();\n"
23855 " return g;\n"
23856 " },\n"
23857 " bazzzzz,\n"
23858 " quuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuux);\n"
23864 verifyFormat("void foo() {\n"
23865 " aFunction(\n"
23866 " 1, b(c(foo, Bar{}, baz, [](d) -> Foo\n"
23867 " {\n"
23868 " auto f = e(\n"
23869 " [&]\n"
23870 " {\n"
23871 " auto g = h();\n"
23872 " return g;\n"
23873 " }, qux, [&] -> Bar\n"
23874 " {\n"
23875 " auto i = j();\n"
23876 " return i;\n"
23877 " });\n"
23878 " return f;\n"
23879 " })));\n"
23892 verifyFormat("auto k = []() // comment\n"
23899 verifyFormat("auto k = []() // X\n"
23903 "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
23909 verifyFormat("foo([]()\n"
23910 " {\n"
23911 " bar(); //\n"
23912 " return 1; // comment\n"
23914 "foo([]() {\n"
23915 " bar(); //\n"
23916 " return 1; // comment\n"
23919 verifyFormat("foo(\n"
23920 " 1, MACRO {\n"
23921 " baz();\n"
23922 " bar(); // comment\n"
23923 " },\n"
23925 "foo(\n"
23926 " 1, MACRO { baz(); bar(); // comment\n"
23927 " }, []() {}\n"
23933 verifyFormat("auto lambda = []() {\n"
23934 " x(); //\n"
23936 "auto lambda = []() {\n"
23937 "\n"
23938 " x(); //\n"
23939 "\n"
23957 verifyFormat("[operation setCompletionBlock:^{\n"
23958 " [self onOperationDone];\n"
23960 verifyFormat("int i = {[operation setCompletionBlock:^{\n"
23961 " [self onOperationDone];\n"
23963 verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
23964 " f();\n"
23966 verifyFormat("int a = [operation block:^int(int *i) {\n"
23967 " return 1;\n"
23969 verifyFormat("[myObject doSomethingWith:arg1\n"
23970 " aaa:^int(int *a) {\n"
23971 " return 1;\n"
23972 " }\n"
23975 verifyFormat("[operation setCompletionBlock:^{\n"
23976 " [self.delegate newDataAvailable];\n"
23979 verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
23980 " NSString *path = [self sessionFilePath];\n"
23981 " if (path) {\n"
23982 " // ...\n"
23983 " }\n"
23985 verifyFormat("[[SessionService sharedService]\n"
23986 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
23987 " if (window) {\n"
23988 " [self windowDidLoad:window];\n"
23989 " } else {\n"
23990 " [self errorLoadingWindow];\n"
23991 " }\n"
23993 verifyFormat("void (^largeBlock)(void) = ^{\n"
23994 " // ...\n"
23997 verifyFormat("[[SessionService sharedService]\n"
23998 " loadWindowWithCompletionBlock: //\n"
23999 " ^(SessionWindow *window) {\n"
24000 " if (window) {\n"
24001 " [self windowDidLoad:window];\n"
24002 " } else {\n"
24003 " [self errorLoadingWindow];\n"
24004 " }\n"
24007 verifyFormat("[myObject doSomethingWith:arg1\n"
24008 " firstBlock:^(Foo *a) {\n"
24009 " // ...\n"
24010 " int i;\n"
24011 " }\n"
24012 " secondBlock:^(Bar *b) {\n"
24013 " // ...\n"
24014 " int i;\n"
24015 " }\n"
24016 " thirdBlock:^Foo(Bar *b) {\n"
24017 " // ...\n"
24018 " int i;\n"
24020 verifyFormat("[myObject doSomethingWith:arg1\n"
24021 " firstBlock:-1\n"
24022 " secondBlock:^(Bar *b) {\n"
24023 " // ...\n"
24024 " int i;\n"
24027 verifyFormat("f(^{\n"
24028 " @autoreleasepool {\n"
24029 " if (a) {\n"
24030 " g();\n"
24031 " }\n"
24032 " }\n"
24034 verifyFormat("Block b = ^int *(A *a, B *b) {\n"
24036 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
24041 verifyFormat("[operation setCompletionBlock:^{\n"
24042 " [self onOperationDone];\n"
24051 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
24052 " if (window) {\n"
24053 " [self windowDidLoad:window];\n"
24054 " } else {\n"
24055 " [self errorLoadingWindow];\n"
24056 " }\n"
24059 verifyFormat("[[SessionService sharedService]\n"
24060 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
24061 " if (window) {\n"
24062 " [self windowDidLoad:window];\n"
24063 " } else {\n"
24064 " [self errorLoadingWindow];\n"
24065 " }\n"
24067 "[[SessionService sharedService]\n"
24068 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
24069 " if (window) {\n"
24070 " [self windowDidLoad:window];\n"
24071 " } else {\n"
24072 " [self errorLoadingWindow];\n"
24073 " }\n"
24076 verifyFormat("[myObject doSomethingWith:arg1\n"
24077 " firstBlock:^(Foo *a) {\n"
24078 " // ...\n"
24079 " int i;\n"
24080 " }\n"
24081 " secondBlock:^(Bar *b) {\n"
24082 " // ...\n"
24083 " int i;\n"
24084 " }\n"
24085 " thirdBlock:^Foo(Bar *b) {\n"
24086 " // ...\n"
24087 " int i;\n"
24090 verifyFormat("f(^{\n"
24091 " @autoreleasepool {\n"
24092 " if (a) {\n"
24093 " g();\n"
24094 " }\n"
24095 " }\n"
24098 verifyFormat("void (^largeBlock)(void) = ^{\n"
24099 " // ...\n"
24107 verifyFormat("void (^largeBlock)(void) = ^{\n"
24108 " int i;\n"
24114 verifyFormat("int a;\r\n"
24115 "int b;\r\n"
24117 "int a;\r\n"
24118 " int b;\r\n"
24120 verifyFormat("int a;\r\n"
24121 "int b;\r\n"
24122 "int c;\r\n",
24123 "int a;\r\n"
24124 " int b;\n"
24125 " int c;\r\n");
24126 verifyFormat("int a;\n"
24127 "int b;\n"
24129 "int a;\r\n"
24130 " int b;\n"
24133 EXPECT_EQ("\"aaaaaaa \"\r\n"
24134 "\"bbbbbbb\";\r\n",
24135 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
24136 verifyFormat("#define A \\\r\n"
24137 " b; \\\r\n"
24138 " c; \\\r\n"
24140 "#define A \\\r\n"
24141 " b; \\\r\n"
24145 verifyNoChange("/*\r\n"
24146 "multi line block comments\r\n"
24147 "should not introduce\r\n"
24148 "an extra carriage return\r\n"
24150 verifyFormat("/*\r\n"
24151 "\r\n"
24153 "/*\r\n"
24154 " \r\r\r\n"
24160 verifyFormat("union FooBarBazQux {\n"
24161 " int foo;\n"
24162 " int bar;\n"
24163 " int baz;\n"
24165 "union FooBarBazQux {\r\n"
24166 " int foo;\n"
24167 " int bar;\r\n"
24168 " int baz;\n"
24172 verifyFormat("union FooBarBazQux {\r\n"
24173 " int foo;\r\n"
24174 " int bar;\r\n"
24175 " int baz;\r\n"
24177 "union FooBarBazQux {\r\n"
24178 " int foo;\n"
24179 " int bar;\r\n"
24180 " int baz;\n"
24185 verifyFormat("union FooBarBazQux {\n"
24186 " int foo;\n"
24187 " int bar;\n"
24188 " int baz;\n"
24189 " int qux;\n"
24191 "union FooBarBazQux {\r\n"
24192 " int foo;\n"
24193 " int bar;\r\n"
24194 " int baz;\n"
24195 " int qux;\r\n"
24199 verifyFormat("union FooBarBazQux {\r\n"
24200 " int foo;\r\n"
24201 " int bar;\r\n"
24202 " int baz;\r\n"
24203 " int qux;\r\n"
24205 "union FooBarBazQux {\r\n"
24206 " int foo;\n"
24207 " int bar;\r\n"
24208 " int baz;\n"
24209 " int qux;\n"
24214 verifyFormat("union FooBarBazQux {\r\n"
24215 " int foo;\r\n"
24216 " int bar;\r\n"
24217 " int baz;\r\n"
24218 " int qux;\r\n"
24220 "union FooBarBazQux {\r\n"
24221 " int foo;\n"
24222 " int bar;\r\n"
24223 " int baz;\n"
24224 " int qux;\r\n"
24228 verifyFormat("union FooBarBazQux {\n"
24229 " int foo;\n"
24230 " int bar;\n"
24231 " int baz;\n"
24232 " int qux;\n"
24234 "union FooBarBazQux {\r\n"
24235 " int foo;\n"
24236 " int bar;\r\n"
24237 " int baz;\n"
24238 " int qux;\n"
24244 verifyFormat("MY_CLASS(C) {\n"
24245 " int i;\n"
24246 " int j;\n"
24254 verifyFormat("int i =\n"
24255 " longFunction(\n"
24262 verifyFormat("int i =\n"
24263 " longFunction(\n"
24270 verifyFormat("int Foo::getter(\n"
24271 " //\n"
24272 ") const {\n"
24273 " return foo;\n"
24276 verifyFormat("void Foo::setter(\n"
24277 " //\n"
24278 ") {\n"
24279 " foo = 1;\n"
24346 verifyFormat("// clang-format off\n"
24347 "foo<<<1, 1>>>();\n"
24350 verifyFormat("// clang-format off\n"
24351 "foo< < <1, 1> > >();\n"
24371 "aaaaaaaaaaa<<<\n 1, 1>>>();");
24372 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
24378 verifyFormat("< < <", "\\\n<<<");
24382 "aaaallvm::outs()\n <<");
24386 std::string code = "#if A\n"
24387 "#if B\n"
24388 "a.\n"
24389 "#endif\n"
24390 " a = 1;\n"
24391 "#else\n"
24392 "#endif\n"
24393 "#if C\n"
24394 "#else\n"
24395 "#endif\n";
24401 verifyFormat("int a;\n"
24402 "void f() {\n"
24403 " callme(some(parameter1,\n"
24404 "<<<<<<< text by the vcs\n"
24405 " parameter2),\n"
24406 "||||||| text by the vcs\n"
24407 " parameter2),\n"
24408 " parameter3,\n"
24409 "======= text by the vcs\n"
24410 " parameter2, parameter3),\n"
24411 ">>>>>>> text by the vcs\n"
24413 "int a;\n"
24414 "void f() {\n"
24415 " callme(some(parameter1,\n"
24416 "<<<<<<< text by the vcs\n"
24417 " parameter2),\n"
24418 "||||||| text by the vcs\n"
24419 " parameter2),\n"
24420 " parameter3,\n"
24421 "======= text by the vcs\n"
24422 " parameter2,\n"
24423 " parameter3),\n"
24424 ">>>>>>> text by the vcs\n"
24428 verifyFormat("void f() {\n"
24429 " function(\n"
24430 ">>>> text by the vcs\n"
24431 " parameter,\n"
24432 "==== text by the vcs\n"
24433 " parameter,\n"
24434 "==== text by the vcs\n"
24435 " parameter,\n"
24436 "<<<< text by the vcs\n"
24438 "void f() {\n"
24439 " function(\n"
24440 ">>>> text by the vcs\n"
24441 " parameter,\n"
24442 "==== text by the vcs\n"
24443 " parameter,\n"
24444 "==== text by the vcs\n"
24445 " parameter,\n"
24446 "<<<< text by the vcs\n"
24449 verifyNoChange("<<<<<<<\n"
24450 "|||||||\n"
24451 "=======\n"
24454 verifyNoChange("<<<<<<<\n"
24455 "|||||||\n"
24456 "int i;\n"
24457 "=======\n"
24461 verifyFormat("#define Macro \\\n"
24462 "<<<<<<<\n"
24463 "Something \\\n"
24464 "|||||||\n"
24465 "Else \\\n"
24466 "=======\n"
24467 "Other \\\n"
24468 ">>>>>>>\n"
24470 "#define Macro \\\n"
24471 "<<<<<<<\n"
24472 " Something \\\n"
24473 "|||||||\n"
24474 " Else \\\n"
24475 "=======\n"
24476 " Other \\\n"
24477 ">>>>>>>\n"
24478 " End\n"
24491 verifyFormat("int i;\n"
24492 "// clang-format off\n"
24493 " int j;\n"
24494 "// clang-format on\n"
24496 " int i;\n"
24497 " // clang-format off\n"
24498 " int j;\n"
24499 " // clang-format on\n"
24501 verifyFormat("int i;\n"
24502 "/* clang-format off */\n"
24503 " int j;\n"
24504 "/* clang-format on */\n"
24506 " int i;\n"
24507 " /* clang-format off */\n"
24508 " int j;\n"
24509 " /* clang-format on */\n"
24513 verifyFormat("// clang-format off\n"
24514 "// long long long long long long line\n"
24515 "/* clang-format on */\n"
24516 "/* long long long\n"
24517 " * long long long\n"
24518 " * line */\n"
24519 "int i;\n"
24520 "/* clang-format off */\n"
24522 "// clang-format off\n"
24523 "// long long long long long long line\n"
24524 "/* clang-format on */\n"
24525 "/* long long long long long long line */\n"
24526 "int i;\n"
24527 "/* clang-format off */\n"
24531 verifyFormat("int *i;\n"
24532 "// clang-format off:\n"
24533 "int* j;\n"
24534 "// clang-format on: 1\n"
24536 "int* i;\n"
24537 "// clang-format off:\n"
24538 "int* j;\n"
24539 "// clang-format on: 1\n"
24542 verifyFormat("int *i;\n"
24543 "// clang-format off:0\n"
24544 "int* j;\n"
24545 "// clang-format only\n"
24547 "int* i;\n"
24548 "// clang-format off:0\n"
24549 "int* j;\n"
24550 "// clang-format only\n"
24553 verifyNoChange("// clang-format off\n"
24554 "#if 0\n"
24555 " #if SHOULD_STAY_INDENTED\n"
24556 " #endif\n"
24557 "#endif\n"
24563 verifyNoCrash("#define a\\\n /**/}");
24564 verifyNoCrash(" tst %o5 ! are we doing the gray case?\n"
24597 verifyFormat("using std::cin;\n"
24599 "using std::cout;\n"
24661 verifyFormat("for (const auto &&[a, b] : some_range) {\n}",
24662 "for (const auto && [a, b] : some_range) {\n}");
24663 verifyFormat("for (const auto &[a, b] : some_range) {\n}",
24664 "for (const auto & [a, b] : some_range) {\n}");
24665 verifyFormat("for (const auto [a, b] : some_range) {\n}",
24666 "for (const auto[a, b] : some_range) {\n}");
24691 guessLanguage("foo.h", "@interface Foo\n@end"));
24699 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo", "@interface Foo\n@end"));
24710 guessLanguage("foo.h", "#if A\n"
24711 "#define B() C\n"
24712 "#else\n"
24713 "#define B() [NSString a:@\"\"]\n"
24801 guessLanguage("foo.h", "void f() {\n"
24802 " asm (\"mov %[e], %[d]\"\n"
24803 " : [d] \"=rm\" (d)\n"
24804 " [e] \"rm\" (*e));\n"
24807 guessLanguage("foo.h", "void f() {\n"
24808 " _asm (\"mov %[e], %[d]\"\n"
24809 " : [d] \"=rm\" (d)\n"
24810 " [e] \"rm\" (*e));\n"
24813 guessLanguage("foo.h", "void f() {\n"
24814 " __asm (\"mov %[e], %[d]\"\n"
24815 " : [d] \"=rm\" (d)\n"
24816 " [e] \"rm\" (*e));\n"
24819 guessLanguage("foo.h", "void f() {\n"
24820 " __asm__ (\"mov %[e], %[d]\"\n"
24821 " : [d] \"=rm\" (d)\n"
24822 " [e] \"rm\" (*e));\n"
24825 guessLanguage("foo.h", "void f() {\n"
24826 " asm (\"mov %[e], %[d]\"\n"
24827 " : [d] \"=rm\" (d),\n"
24828 " [e] \"rm\" (*e));\n"
24831 guessLanguage("foo.h", "void f() {\n"
24832 " asm volatile (\"mov %[e], %[d]\"\n"
24833 " : [d] \"=rm\" (d)\n"
24834 " [e] \"rm\" (*e));\n"
24857 verifyFormat("struct foo {\n"
24858 " int bar;\n"
24859 " TAILQ_ENTRY(a) bleh;\n"
24873 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
24889 verifyFormat("struct foo {\n"
24890 " int a1;\n"
24891 " _Atomic(a) a2;\n"
24892 " _Atomic(_Atomic(int) *const) a3;\n"
24903 verifyFormat("for (_Atomic(uint64_t) *a = NULL; a;) {\n}");
24932 verifyFormat("_Generic(x,\n"
24933 " float: f,\n"
24934 " default: d,\n"
24935 " long double: ld,\n"
24936 " float _Complex: fc,\n"
24937 " double _Complex: dc,\n"
24940 verifyFormat("while (_Generic(x, //\n"
24941 " long: x)(x) > x) {\n"
24943 verifyFormat("while (_Generic(x, //\n"
24944 " long: x)(x)) {\n"
24946 verifyFormat("x(_Generic(x, //\n"
24951 verifyFormat("#define LIMIT_MAX(T) \\\n"
24952 " _Generic(((T)0), \\\n"
24953 " unsigned int: UINT_MAX, \\\n"
24954 " unsigned long: ULONG_MAX, \\\n"
24957 verifyFormat("_Generic(x,\n"
24958 " struct A: 1,\n"
24963 verifyFormat("_Generic(x,\n"
24964 " struct A: 1,\n"
24994 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces);
24995 verifyFormat("if ( !a )\n return;", Spaces);
24996 verifyFormat("if ( a )\n return;", Spaces);
24997 verifyFormat("if constexpr ( a )\n return;", Spaces);
24998 verifyFormat("MYIF ( a )\n return;", Spaces);
24999 verifyFormat("MYIF ( a )\n return;\nelse MYIF ( b )\n return;", Spaces);
25000 verifyFormat("MYIF ( a )\n return;\nelse\n return;", Spaces);
25001 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces);
25002 verifyFormat("while ( a )\n return;", Spaces);
25003 verifyFormat("while ( (a && b) )\n return;", Spaces);
25004 verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
25005 verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
25008 verifyFormat("while ( ::func() )\n return;", Spaces);
25013 verifyFormat("MYIF( a )\n return;", Spaces);
25014 verifyFormat("MYIF( a )\n return;\nelse MYIF( b )\n return;", Spaces);
25015 verifyFormat("MYIF( a )\n return;\nelse\n return;", Spaces);
25055 verifyFormat("a = v(not;);\n"
25056 "b = v(not+);\n"
25057 "c = v(not x);\n"
25058 "d = v(not 1);\n"
25061 verifyNoChange("#define ASSEMBLER_INSTRUCTION_LIST(V) \\\n"
25062 " V(and) \\\n"
25063 " V(not) \\\n"
25064 " V(not!) \\\n"
25070 verifyFormat("#if defined(while)\n"
25071 "#define while EMIT WARNING C4005\n"
25245 verifyNoChange("FOO(1+2 )\n", Style);
25246 verifyNoChange("FOO(a:b:c)\n", Style);
25253 verifyNoChange("FOO(String-ized&Messy+But,: :\n"
25257 verifyNoChange("FOO(String-ized=&Messy+But,: :\n"
25275 verifyNoChange("#define A ( args ) \\\n"
25276 " {\\\n"
25277 " int a = 1 ;\\\n"
25285 verifyFormat("int a;\n"
25286 "#define A a\n"
25288 "int a ;\n"
25289 "#define A a\n"
25299 verifyFormat("#define A // a\n"
25300 " // very\n"
25301 " // long\n"
25307 verifyNoChange("#define A \\\n"
25308 "Line one with spaces . \\\n"
25311 verifyNoChange("#define A \\\n"
25312 "a a \\\n"
25313 "a \\\n"
25317 verifyNoChange("#define A \\\n"
25318 "a a \\\n"
25319 "a \\\n"
25323 verifyNoChange("#define A \\\n"
25324 "a a \\\n"
25325 "a \\\n"
25331 verifyNoChange("#if A\n"
25332 "#define A a\n"
25335 verifyFormat("#if A\n"
25336 "#define A a\n"
25338 "#if A\n"
25339 " #define A a\n"
25343 verifyNoChange("#if A\n"
25344 "# define A a\n"
25347 verifyFormat("#if A\n"
25348 "# define A a\n"
25350 "#if A\n"
25351 " #define A a\n"
25355 verifyNoChange("#if A\n"
25356 " #define A a\n"
25359 verifyFormat("#if A\n"
25360 " #define A a\n"
25362 "#if A\n"
25363 " # define A a\n"
25369 verifyFormat("#if !defined(A)\n"
25370 "#define A a\n"
25372 "#if ! defined ( A )\n"
25373 " #define A a\n"
25382 verifyFormat("int a; // a\n"
25383 "#define A // a\n"
25385 "int a; // a\n"
25386 "#define A // a\n"
25391 "#define MACRO_WITH_COMMENTS() \\\n"
25392 " public: \\\n"
25393 " /* Documentation parsed by Doxygen for the following method. */ \\\n"
25394 " static MyType getClassTypeId(); \\\n"
25395 " /** Normal comment for the following method. */ \\\n"
25400 verifyNoChange("#define A a\\\n"
25401 " A a \\\n "
25410 verifyFormat("namespace {\n"
25411 "int i;\n"
25412 "int j;\n"
25416 verifyFormat("namespace AAA {\n"
25417 "int i;\n"
25418 "int j;\n"
25422 verifyFormat("namespace Averyveryveryverylongnamespace {\n"
25423 "int i;\n"
25424 "int j;\n"
25426 "namespace Averyveryveryverylongnamespace {\n"
25427 "int i;\n"
25428 "int j;\n"
25434 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
25435 " went::mad::now {\n"
25436 "int i;\n"
25437 "int j;\n"
25438 "} // namespace\n"
25444 "just::gave::up::and_::went::mad::now {\n"
25445 "int i;\n"
25446 "int j;\n"
25453 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
25454 " went::mad::now {\n"
25455 "int i;\n"
25456 "int j;\n"
25457 "} // namespace\n"
25463 "just::gave::up::and_::went::mad::now {\n"
25464 "int i;\n"
25465 "int j;\n"
25466 "} // namespace\n"
25476 verifyFormat("if (argc > 5) [[unlikely]] {\n"
25477 " return 29;\n"
25481 verifyFormat("if (argc > 5) [[likely]] {\n"
25482 " return 29;\n"
25486 verifyFormat("if (argc > 5) [[unlikely]] {\n"
25487 " return 29;\n"
25488 "} else [[likely]] {\n"
25489 " return 42;\n"
25493 verifyFormat("if (argc > 5) [[unlikely]] {\n"
25494 " return 29;\n"
25495 "} else if (argc > 10) [[likely]] {\n"
25496 " return 99;\n"
25497 "} else {\n"
25498 " return 42;\n"
25502 verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
25503 " return 29;\n"
25507 verifyFormat("if (argc > 5) [[unlikely]]\n"
25510 verifyFormat("if (argc > 5) [[likely]]\n"
25514 verifyFormat("while (limit > 0) [[unlikely]] {\n"
25515 " --limit;\n"
25518 verifyFormat("for (auto &limit : limits) [[likely]] {\n"
25519 " --limit;\n"
25523 verifyFormat("for (auto &limit : limits) [[unlikely]]\n"
25526 verifyFormat("while (limit > 0) [[likely]]\n"
25532 verifyFormat("if (argc > 5) UNLIKELY\n"
25536 verifyFormat("if (argc > 5) UNLIKELY {\n"
25537 " return 29;\n"
25540 verifyFormat("if (argc > 5) UNLIKELY {\n"
25541 " return 29;\n"
25542 "} else [[likely]] {\n"
25543 " return 42;\n"
25546 verifyFormat("if (argc > 5) UNLIKELY {\n"
25547 " return 29;\n"
25548 "} else LIKELY {\n"
25549 " return 42;\n"
25552 verifyFormat("if (argc > 5) [[unlikely]] {\n"
25553 " return 29;\n"
25554 "} else LIKELY {\n"
25555 " return 42;\n"
25559 verifyFormat("for (auto &limit : limits) UNLIKELY {\n"
25560 " --limit;\n"
25563 verifyFormat("while (limit > 0) LIKELY {\n"
25564 " --limit;\n"
25568 verifyFormat("while (limit > 0) UNLIKELY\n"
25571 verifyFormat("for (auto &limit : limits) LIKELY\n"
25577 verifyFormat("Constructor()\n"
25578 " : aaaaaa(aaaaaa), aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
25581 verifyFormat("Constructor()\n"
25587 verifyFormat("Constructor()\n"
25588 " : aaaaaa(aaaaaa),\n"
25589 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
25592 verifyFormat("Constructor()\n"
25600 verifyFormat("extern \"C\" {\n"
25601 "int foo();\n"
25607 verifyFormat("extern \"C\"\n"
25608 "{\n"
25609 " int foo ();\n"
25615 verifyFormat("extern \"C\"\n"
25616 "{\n"
25617 " int foo();\n"
25623 verifyFormat("extern \"C\" {\n"
25624 "int foo();\n"
25630 verifyFormat("extern \"C\" {\n"
25631 "int foo();\n"
25637 verifyFormat("extern \"C\"\n"
25638 "{\n"
25639 " int foo();\n"
25645 verifyFormat("extern \"C\" {\n"
25646 "int foo();\n"
25660 verifyFormat("template <typename T>\n"
25663 verifyFormat("template <typename T>\n"
25664 "concept C = ((false || foo()) && C2<T>) ||\n"
25668 verifyFormat("template <typename T>\n"
25672 verifyFormat("template <typename T>\n"
25673 "concept DelayedCheck = true && requires(T t) {\n"
25674 " t.bar();\n"
25675 " t.baz();\n"
25679 verifyFormat("template <typename T>\n"
25680 "concept DelayedCheck = true && requires(T t) { // Comment\n"
25681 " t.bar();\n"
25682 " t.baz();\n"
25686 verifyFormat("template <typename T>\n"
25690 verifyFormat("template <typename T>\n"
25693 verifyFormat("template <typename T>\n"
25696 verifyFormat("template <typename T>\n"
25699 verifyFormat("template <typename T>\n"
25703 verifyFormat("template <typename T>\n"
25704 "concept DelayedCheck =\n"
25708 verifyFormat("template <typename T>\n"
25713 "template <typename T>\n"
25714 "concept DelayedCheck =\n"
25717 verifyFormat("template <typename T>\n"
25721 verifyFormat("template <typename T>\n"
25725 verifyFormat("template <typename T>\n"
25726 "concept Size = 2 < 5 && 2 <= 5 && 8 >= 5 && 8 > 5 &&\n"
25727 " requires(T t) {\n"
25728 " t.bar();\n"
25729 " t.baz();\n"
25733 verifyFormat("template <typename T>\n"
25736 verifyFormat("template <typename T>\n"
25739 verifyFormat("template <typename T>\n"
25742 verifyFormat("template <typename T>\n"
25745 verifyFormat("template <typename T>\n"
25748 verifyFormat("template <typename T>\n"
25751 verifyFormat("template <S T>\n"
25755 "template <typename T>\n"
25756 "concept C = []() { return true; }() && requires(T t) { t.bar(); } &&\n"
25761 verifyFormat("template <typename T>\n"
25763 "t.bar(); } &&\n"
25767 "template <typename T>\n"
25768 "concept C = decltype([]() { return std::true_type{}; }())::value &&\n"
25771 verifyFormat("template <typename T>\n"
25776 verifyFormat("template <typename T>\n"
25778 "}())::value &&\n"
25781 verifyFormat("template <typename T>\n"
25782 "concept C = true;\n"
25785 verifyFormat("template <typename T>\n"
25786 "concept Hashable = requires(T a) {\n"
25788 "std::convertible_to<std::size_t>;\n"
25793 "template <typename T>\n"
25794 "concept EqualityComparable = requires(T a, T b) {\n"
25795 " { a == b } -> std::same_as<bool>;\n"
25800 "template <typename T>\n"
25801 "concept EqualityComparable = requires(T a, T b) {\n"
25802 " { a == b } -> std::same_as<bool>;\n"
25803 " { a != b } -> std::same_as<bool>;\n"
25807 verifyFormat("template <typename T>\n"
25808 "concept WeakEqualityComparable = requires(T a, T b) {\n"
25809 " { a == b };\n"
25810 " { a != b };\n"
25814 verifyFormat("template <typename T>\n"
25817 verifyFormat("template <typename T>\n"
25818 "concept Semiregular =\n"
25820 "CopyAssignable<T> &&\n"
25821 " requires(T a, std::size_t n) {\n"
25822 " requires Same<T *, decltype(&a)>;\n"
25823 " { a.~T() } noexcept;\n"
25824 " requires Same<T *, decltype(new T)>;\n"
25825 " requires Same<T *, decltype(new T[n])>;\n"
25826 " { delete new T; };\n"
25827 " { delete new T[n]; };\n"
25831 verifyFormat("template <typename T>\n"
25832 "concept Semiregular =\n"
25833 " requires(T a, std::size_t n) {\n"
25834 " requires Same<T *, decltype(&a)>;\n"
25835 " { a.~T() } noexcept;\n"
25836 " requires Same<T *, decltype(new T)>;\n"
25837 " requires Same<T *, decltype(new T[n])>;\n"
25838 " { delete new T; };\n"
25839 " { delete new T[n]; };\n"
25840 " { new T } -> std::same_as<T *>;\n"
25846 "template <typename T>\n"
25847 "concept Semiregular =\n"
25848 " DefaultConstructible<T> && requires(T a, std::size_t n) {\n"
25849 " requires Same<T *, decltype(&a)>;\n"
25850 " { a.~T() } noexcept;\n"
25851 " requires Same<T *, decltype(new T)>;\n"
25853 "T[n])>;\n"
25854 " { delete new T; };\n"
25855 " { delete new T[n]; };\n"
25860 verifyFormat("template <typename T>\n"
25861 "concept Two = requires(T t) {\n"
25862 " { t.foo() } -> std::same_as<Bar>;\n"
25863 " } && requires(T &&t) {\n"
25864 " { t.foo() } -> std::same_as<Bar &&>;\n"
25869 "template <typename T>\n"
25870 "concept C = requires(T x) {\n"
25871 " { *x } -> std::convertible_to<typename T::inner>;\n"
25872 " { x + 1 } noexcept -> std::same_as<int>;\n"
25873 " { x * 1 } -> std::convertible_to<T>;\n"
25877 verifyFormat("template <typename T>\n"
25878 "concept C = requires(T x) {\n"
25879 " {\n"
25880 " long_long_long_function_call(1, 2, 3, 4, 5)\n"
25881 " } -> long_long_concept_name<T>;\n"
25882 " {\n"
25883 " long_long_long_function_call(1, 2, 3, 4, 5)\n"
25884 " } noexcept -> long_long_concept_name<T>;\n"
25889 "template <typename T, typename U = T>\n"
25890 "concept Swappable = requires(T &&t, U &&u) {\n"
25891 " swap(std::forward<T>(t), std::forward<U>(u));\n"
25892 " swap(std::forward<U>(u), std::forward<T>(t));\n"
25896 verifyFormat("template <typename T, typename U>\n"
25897 "concept Common = requires(T &&t, U &&u) {\n"
25898 " typename CommonType<T, U>;\n"
25899 " { CommonType<T, U>(std::forward<T>(t)) };\n"
25903 verifyFormat("template <typename T, typename U>\n"
25904 "concept Common = requires(T &&t, U &&u) {\n"
25905 " typename CommonType<T, U>;\n"
25906 " { CommonType<T, U>{std::forward<T>(t)} };\n"
25911 "template <typename T>\n"
25912 "concept C = requires(T t) {\n"
25913 " requires Bar<T> && Foo<T>;\n"
25914 " requires((trait<T> && Baz) || (T2<T> && Foo<T>));\n"
25918 verifyFormat("template <typename T>\n"
25919 "concept HasFoo = requires(T t) {\n"
25920 " { t.foo() };\n"
25921 " t.foo();\n"
25922 " };\n"
25923 "template <typename T>\n"
25924 "concept HasBar = requires(T t) {\n"
25925 " { t.bar() };\n"
25926 " t.bar();\n"
25930 verifyFormat("template <typename T>\n"
25933 verifyFormat("template <typename T, typename U>\n"
25934 "concept FooableWith = requires(T t, U u) {\n"
25935 " typename T::foo_type;\n"
25936 " { t.foo(u) } -> typename T::foo_type;\n"
25937 " t++;\n"
25938 " };\n"
25942 verifyFormat("template <typename T>\n"
25945 verifyFormat("template <typename T>\n"
25948 verifyFormat("template <class T>\n"
25951 verifyFormat("template <class T>\n"
25954 verifyFormat("template <class T>\n"
25957 verifyFormat("template <class T, class T2>\n"
25961 "template <class _InIt, class _OutIt>\n"
25962 "concept _Can_reread_dest =\n"
25963 " std::forward_iterator<_OutIt> &&\n"
25969 "template <typename T>\n"
25970 "concept C = requires(T t) {\n"
25971 " requires Bar<T> && Foo<T>;\n"
25972 " requires((trait<T> && Baz) || (T2<T> && Foo<T>));\n"
25976 verifyFormat("template <typename T>\n"
25977 "concept HasFoo = requires(T t) {\n"
25978 " { t.foo() };\n"
25979 " t.foo();\n"
25980 " };\n"
25981 "template <typename T>\n"
25982 "concept HasBar = requires(T t) {\n"
25983 " { t.bar() };\n"
25984 " t.bar();\n"
25990 verifyFormat("template <typename T>\n"
25992 "}())::value &&\n"
25996 verifyFormat("template <typename T>\n"
25997 "concept Semiregular =\n"
25999 "CopyAssignable<T> &&\n"
26000 " requires(T a, std::size_t n) {\n"
26001 " requires Same<T *, decltype(&a)>;\n"
26002 " { a.~T() } noexcept;\n"
26003 " requires Same<T *, decltype(new T)>;\n"
26004 " requires Same<T *, decltype(new T[n])>;\n"
26005 " { delete new T; };\n"
26006 " { delete new T[n]; };\n"
26012 verifyFormat("template <typename T> concept C =\n"
26013 " requires(T t) {\n"
26014 " requires Bar<T> && Foo<T>;\n"
26015 " requires((trait<T> && Baz) || (T2<T> && Foo<T>));\n"
26019 verifyFormat("template <typename T> concept HasFoo = requires(T t) {\n"
26020 " { t.foo() };\n"
26021 " t.foo();\n"
26022 " };\n"
26023 "template <typename T> concept HasBar = requires(T t) {\n"
26024 " { t.bar() };\n"
26025 " t.bar();\n"
26032 "template <typename T> concept C =\n"
26033 " decltype([]() -> std::true_type { return {}; }())::value &&\n"
26037 verifyFormat("template <typename T> concept Semiregular =\n"
26039 "CopyAssignable<T> &&\n"
26040 " requires(T a, std::size_t n) {\n"
26041 " requires Same<T *, decltype(&a)>;\n"
26042 " { a.~T() } noexcept;\n"
26043 " requires Same<T *, decltype(new T)>;\n"
26044 " requires Same<T *, decltype(new T[n])>;\n"
26045 " { delete new T; };\n"
26046 " { delete new T[n]; };\n"
26052 verifyNoCrash("template <typename T>\n"
26055 verifyNoCrash("template <typename T>\n"
26058 verifyNoCrash("template <typename T>\n"
26061 verifyNoCrash("template <typename T>\n"
26064 verifyNoCrash("template <typename T>\n"
26077 verifyFormat("template <typename T>\n"
26078 " requires(Foo<T> && std::trait<T>)\n"
26082 verifyFormat("template <typename T>\n"
26083 " requires(Foo<T> && std::trait<T>)\n"
26084 "class Bar {\n"
26085 "public:\n"
26086 " Bar(T t);\n"
26087 " bool baz();\n"
26092 "template <typename T>\n"
26093 " requires requires(T &&t) {\n"
26094 " typename T::I;\n"
26095 " requires(F<typename T::I> && std::trait<typename T::I>);\n"
26096 " }\n"
26100 verifyFormat("template <typename T>\n"
26101 " requires(Foo<T> && std::trait<T>)\n"
26105 verifyFormat("template <typename T>\n"
26106 " requires Foo<T> && requires(T t) {\n"
26107 " { t.baz() } -> std::same_as<bool>;\n"
26108 " requires std::same_as<T::Factor, int>;\n"
26109 " }\n"
26110 "inline int bar(T t) {\n"
26111 " return t.baz() ? T::Factor : 5;\n"
26115 verifyFormat("template <typename T>\n"
26116 "inline int bar(T t)\n"
26117 " requires Foo<T> && requires(T t) {\n"
26118 " { t.baz() } -> std::same_as<bool>;\n"
26119 " requires std::same_as<T::Factor, int>;\n"
26120 " }\n"
26121 "{\n"
26122 " return t.baz() ? T::Factor : 5;\n"
26126 verifyFormat("template <typename T>\n"
26127 " requires F<T>\n"
26128 "int bar(T t) {\n"
26129 " return 5;\n"
26133 verifyFormat("template <typename T>\n"
26134 "int bar(T t)\n"
26135 " requires F<T>\n"
26136 "{\n"
26137 " return 5;\n"
26141 verifyFormat("template <typename T>\n"
26142 "int S::bar(T t) &&\n"
26143 " requires F<T>\n"
26144 "{\n"
26145 " return 5;\n"
26149 verifyFormat("template <typename T>\n"
26150 "int bar(T t)\n"
26155 verifyFormat("template <typename T>\n"
26156 "requires F<T>\n"
26157 "int bar(T t) {\n"
26158 " return 5;\n"
26162 verifyFormat("template <typename T>\n"
26163 "int S::bar(T t) &&\n"
26164 "requires F<T>\n"
26165 "{\n"
26166 " return 5;\n"
26170 verifyFormat("template <typename T>\n"
26171 "int bar(T t)\n"
26172 "requires F<T>\n"
26173 "{\n"
26174 " return 5;\n"
26181 verifyFormat("template <typename T>\n"
26182 " requires(Foo<T> && std::trait<T>)\n"
26186 verifyFormat("template <typename T>\n"
26187 " requires(Foo<T> && std::trait<T>)\n"
26188 "class Bar {\n"
26189 "public:\n"
26190 " Bar(T t);\n"
26191 " bool baz();\n"
26196 "template <typename T>\n"
26197 " requires requires(T &&t) {\n"
26198 " typename T::I;\n"
26199 " requires(F<typename T::I> && std::trait<typename T::I>);\n"
26200 " }\n"
26204 verifyFormat("template <typename T>\n"
26205 " requires(Foo<T> && std::trait<T>)\n"
26209 verifyFormat("template <typename T>\n"
26210 " requires Foo<T> && requires(T t) {\n"
26211 " { t.baz() } -> std::same_as<bool>;\n"
26212 " requires std::same_as<T::Factor, int>;\n"
26213 " }\n"
26214 "inline int bar(T t) {\n"
26215 " return t.baz() ? T::Factor : 5;\n"
26219 verifyFormat("template <typename T>\n"
26220 "inline int bar(T t)\n"
26221 " requires Foo<T> && requires(T t) {\n"
26222 " { t.baz() } -> std::same_as<bool>;\n"
26223 " requires std::same_as<T::Factor, int>;\n"
26224 " } {\n"
26225 " return t.baz() ? T::Factor : 5;\n"
26229 verifyFormat("template <typename T>\n"
26230 " requires F<T>\n"
26231 "int bar(T t) {\n"
26232 " return 5;\n"
26236 verifyFormat("template <typename T>\n"
26237 "int bar(T t)\n"
26238 " requires F<T> {\n"
26239 " return 5;\n"
26243 verifyFormat("template <typename T>\n"
26244 "int S::bar(T t) &&\n"
26245 " requires F<T> {\n"
26246 " return 5;\n"
26250 verifyFormat("template <typename T>\n"
26251 "int bar(T t)\n"
26255 verifyFormat("template <typename T>\n"
26256 "int bar(T t)\n"
26262 verifyFormat("template <typename T> requires Foo<T> struct Bar {};\n"
26263 "template <typename T> requires Foo<T> void bar() {}\n"
26264 "template <typename T> void bar() requires Foo<T> {}\n"
26265 "template <typename T> void bar() requires Foo<T>;\n"
26266 "template <typename T> void S::bar() && requires Foo<T> {}\n"
26272 verifyFormat("template <typename AAAAAAA>\n"
26273 "requires Foo<T> struct Bar {};\n"
26274 "template <typename AAAAAAA>\n"
26275 "requires Foo<T> void bar() {}\n"
26276 "template <typename AAAAAAA>\n"
26277 "void bar() requires Foo<T> {}\n"
26278 "template <typename T>\n"
26279 "void S::bar() && requires Foo<T> {}\n"
26280 "template <typename AAAAAAA>\n"
26284 verifyFormat("template <typename T>\n"
26285 "requires Foo<AAAAAAA> struct Bar {};\n"
26286 "template <typename T>\n"
26287 "requires Foo<AAAAAAA> void bar() {}\n"
26288 "template <typename T>\n"
26289 "void bar() requires Foo<AAAAAAA> {}\n"
26290 "template <typename T>\n"
26294 verifyFormat("template <typename AAAAAAA>\n"
26295 "requires Foo<AAAAAAAAAAAAAAAA>\n"
26296 "struct Bar {};\n"
26297 "template <typename AAAAAAA>\n"
26298 "requires Foo<AAAAAAAAAAAAAAAA>\n"
26299 "void bar() {}\n"
26300 "template <typename AAAAAAA>\n"
26301 "void bar()\n"
26302 " requires Foo<AAAAAAAAAAAAAAAA> {}\n"
26303 "template <typename AAAAAAA>\n"
26304 "requires Foo<AAAAAAAA> Bar(T) -> Bar<T>;\n"
26305 "template <typename AAAAAAA>\n"
26306 "requires Foo<AAAAAAAAAAAAAAAA>\n"
26313 verifyFormat("template <typename T>\n"
26314 "requires Foo<T> struct Bar {};\n"
26315 "template <typename T>\n"
26316 "requires Foo<T> void bar() {}\n"
26317 "template <typename T>\n"
26318 "void bar()\n"
26319 "requires Foo<T> {}\n"
26320 "template <typename T>\n"
26321 "void bar()\n"
26322 "requires Foo<T>;\n"
26323 "template <typename T>\n"
26324 "void S::bar() &&\n"
26325 "requires Foo<T> {}\n"
26326 "template <typename T>\n"
26330 verifyFormat("template <typename AAAAAAA>\n"
26331 "requires Foo<AAAAAAAAAAAAAAAA>\n"
26332 "struct Bar {};\n"
26333 "template <typename AAAAAAA>\n"
26334 "requires Foo<AAAAAAAAAAAAAAAA>\n"
26335 "void bar() {}\n"
26336 "template <typename AAAAAAA>\n"
26337 "void bar()\n"
26338 "requires Foo<AAAAAAAAAAAAAAAA> {}\n"
26339 "template <typename AAAAAAA>\n"
26340 "requires Foo<AAAAAAAA> Bar(T) -> Bar<T>;\n"
26341 "template <typename AAAAAAA>\n"
26342 "requires Foo<AAAAAAAAAAAAAAAA>\n"
26349 verifyFormat("template <typename T>\n"
26350 " requires Foo<T> struct Bar {};\n"
26351 "template <typename T>\n"
26352 " requires Foo<T> void bar() {}\n"
26353 "template <typename T>\n"
26354 "void bar()\n"
26355 " requires Foo<T> {}\n"
26356 "template <typename T>\n"
26357 "void S::bar() &&\n"
26358 " requires Foo<T> {}\n"
26359 "template <typename T>\n"
26363 verifyFormat("template <typename AAAAAAA>\n"
26364 " requires Foo<AAAAAAAAAAAAAAAA>\n"
26365 "struct Bar {};\n"
26366 "template <typename AAAAAAA>\n"
26367 " requires Foo<AAAAAAAAAAAAAAAA>\n"
26368 "void bar() {}\n"
26369 "template <typename AAAAAAA>\n"
26370 "void bar()\n"
26371 " requires Foo<AAAAAAAAAAAAAAAA> {}\n"
26372 "template <typename AAAAAAA>\n"
26373 " requires Foo<AAAAAA> Bar(T) -> Bar<T>;\n"
26374 "template <typename AAAAAAA>\n"
26375 " requires Foo<AAAAAAAAAAAAAAAA>\n"
26382 verifyFormat("template <typename T> requires Foo<T>\n"
26383 "struct Bar {};\n"
26384 "template <typename T> requires Foo<T>\n"
26385 "void bar() {}\n"
26386 "template <typename T>\n"
26387 "void bar() requires Foo<T>\n"
26388 "{}\n"
26389 "template <typename T> void bar() requires Foo<T>;\n"
26390 "template <typename T>\n"
26391 "void S::bar() && requires Foo<T>\n"
26392 "{}\n"
26393 "template <typename T> requires Foo<T>\n"
26397 verifyFormat("template <typename AAAAAAA>\n"
26398 "requires Foo<AAAAAAAAAAAAAAAA>\n"
26399 "struct Bar {};\n"
26400 "template <typename AAAAAAA>\n"
26401 "requires Foo<AAAAAAAAAAAAAAAA>\n"
26402 "void bar() {}\n"
26403 "template <typename AAAAAAA>\n"
26404 "void bar()\n"
26405 " requires Foo<AAAAAAAAAAAAAAAA>\n"
26406 "{}\n"
26407 "template <typename AAAAAAA>\n"
26408 "requires Foo<AAAAAAAA>\n"
26409 "Bar(T) -> Bar<T>;\n"
26410 "template <typename AAAAAAA>\n"
26411 "requires Foo<AAAAAAAAAAAAAAAA>\n"
26417 verifyFormat("struct [[nodiscard]] zero_t {\n"
26418 " template <class T>\n"
26419 " requires requires { number_zero_v<T>; }\n"
26420 " [[nodiscard]] constexpr operator T() const {\n"
26421 " return number_zero_v<T>;\n"
26422 " }\n"
26425 verifyFormat("template <class T>\n"
26426 " requires(std::same_as<int, T>)\n"
26432 "template <typename T>\n"
26433 " requires is_default_constructible_v<hash<T>> and\n"
26434 " is_copy_constructible_v<hash<T>> and\n"
26435 " is_move_constructible_v<hash<T>> and\n"
26437 "is_move_assignable_v<hash<T>> and\n"
26438 " is_destructible_v<hash<T>> and is_swappable_v<hash<T>> and\n"
26439 " is_callable_v<hash<T>(T)> and\n"
26440 " is_same_v<size_t, decltype(hash<T>(declval<T>()))> and\n"
26441 " is_same_v<size_t, decltype(hash<T>(declval<T &>()))> and\n"
26442 " is_same_v<size_t, decltype(hash<T>(declval<const T &>()))>\n"
26448 "template <typename T>\n"
26449 " requires is_default_constructible_v<hash<T>>\n"
26450 " and is_copy_constructible_v<hash<T>>\n"
26451 " and is_move_constructible_v<hash<T>>\n"
26453 "is_move_assignable_v<hash<T>>\n"
26454 " and is_destructible_v<hash<T>> and is_swappable_v<hash<T>>\n"
26455 " and is_callable_v<hash<T>(T)>\n"
26456 " and is_same_v<size_t, decltype(hash<T>(declval<T>()))>\n"
26457 " and is_same_v<size_t, decltype(hash<T>(declval<T &>()))>\n"
26459 "&>()))>\n"
26467 verifyFormat("constexpr Foo(Foo const &other)\n"
26468 " requires std::is_copy_constructible<T>\n"
26469 " : value{other.value} {\n"
26470 " do_magic();\n"
26471 " do_more_magic();\n"
26476 verifyFormat("#if 0\n"
26477 "#else\n"
26478 "foo();\n"
26479 "#endif\n"
26487 verifyFormat("template <typename T>\n"
26488 "concept C = requires(T t) {\n"
26489 " typename T::value;\n"
26490 " requires requires(typename T::value v) {\n"
26491 " { t == v } -> std::same_as<bool>;\n"
26492 " };\n"
26496 verifyFormat("template <typename T>\n"
26497 "void bar(T)\n"
26498 " requires Foo<T> && requires(T t) {\n"
26499 " { t.foo() } -> std::same_as<int>;\n"
26500 " } && requires(T t) {\n"
26501 " { t.bar() } -> std::same_as<bool>;\n"
26502 " --t;\n"
26506 verifyFormat("template <typename T>\n"
26507 " requires Foo<T> &&\n"
26508 " requires(T t) {\n"
26509 " { t.foo() } -> std::same_as<int>;\n"
26510 " } && requires(T t) {\n"
26511 " { t.bar() } -> std::same_as<bool>;\n"
26512 " --t;\n"
26513 " }\n"
26517 verifyFormat("template <typename T> void f() {\n"
26518 " if constexpr (requires(T t) {\n"
26519 " { t.bar() } -> std::same_as<bool>;\n"
26520 " }) {\n"
26521 " }\n"
26525 verifyFormat("template <typename T> void f() {\n"
26526 " if constexpr (condition && requires(T t) {\n"
26527 " { t.bar() } -> std::same_as<bool>;\n"
26528 " }) {\n"
26529 " }\n"
26533 verifyFormat("template <typename T> struct C {\n"
26534 " void f()\n"
26535 " requires requires(T t) {\n"
26536 " { t.bar() } -> std::same_as<bool>;\n"
26537 " };\n"
26543 verifyFormat("template <typename T>\n"
26544 "concept C = requires(T t) {\n"
26545 " typename T::value;\n"
26546 " requires requires(typename T::value v) {\n"
26547 " { t == v } -> std::same_as<bool>;\n"
26548 " };\n"
26553 "template <typename T>\n"
26554 "void bar(T)\n"
26555 " requires Foo<T> && requires(T t) {\n"
26556 " { t.foo() } -> std::same_as<int>;\n"
26557 " } && requires(T t) {\n"
26558 " { t.bar() } -> std::same_as<bool>;\n"
26559 " --t;\n"
26563 verifyFormat("template <typename T>\n"
26564 " requires Foo<T> &&\n"
26565 " requires(T t) {\n"
26566 " { t.foo() } -> std::same_as<int>;\n"
26567 " } && requires(T t) {\n"
26568 " { t.bar() } -> std::same_as<bool>;\n"
26569 " --t;\n"
26570 " }\n"
26574 verifyFormat("template <typename T> void f() {\n"
26575 " if constexpr (requires(T t) {\n"
26576 " { t.bar() } -> std::same_as<bool>;\n"
26577 " }) {\n"
26578 " }\n"
26583 "template <typename T> void f() {\n"
26584 " if constexpr (condition && requires(T t) {\n"
26585 " { t.bar() } -> std::same_as<bool>;\n"
26586 " }) {\n"
26587 " }\n"
26591 verifyFormat("template <typename T> struct C {\n"
26592 " void f()\n"
26593 " requires requires(T t) {\n"
26594 " { t.bar() } -> std::same_as<bool>;\n"
26595 " };\n"
26602 StringRef Source = "void Foo::slot() {\n"
26603 " unsigned char MyChar = 'x';\n"
26604 " emit signal(MyChar);\n"
26605 " Q_EMIT signal(MyChar);\n"
26611 verifyFormat("void Foo::slot() {\n"
26612 " unsigned char MyChar = 'x';\n"
26613 " emit signal(MyChar);\n"
26614 " Q_EMIT signal(MyChar);\n"
26622 verifyFormat("void Foo::slot() {\n"
26623 " unsigned char MyChar = 'x';\n"
26624 " emit signal(MyChar);\n"
26625 " Q_EMIT signal(MyChar);\n"
26635 verifyFormat("class C {\n"
26636 " int i;\n"
26639 verifyFormat("union C {\n"
26640 " int i;\n"
26641 " unsigned u;\n"
26645 verifyFormat("class C {\n"
26646 " public:\n"
26647 " int i;\n"
26650 verifyFormat("class C {\n"
26651 " public /* comment */:\n"
26652 " int i;\n"
26655 verifyFormat("struct S {\n"
26656 " private:\n"
26657 " class C {\n"
26658 " int j;\n"
26659 "\n"
26660 " public:\n"
26661 " C();\n"
26662 " };\n"
26663 "\n"
26664 " public:\n"
26665 " int i;\n"
26670 verifyFormat("enum class E {\n"
26671 " A,\n"
26672 " B\n"
26678 verifyFormat("class C {\n"
26679 " public:\n"
26680 " int i;\n"
26683 verifyFormat("class C {\n"
26684 " public /**/:\n"
26685 " int i;\n"
26689 verifyFormat("class C {\n"
26690 " FOO public:\n"
26691 " int i;\n"
26699 "/**\n"
26701 "the LLVM Style.\n"
26703 "everything is working.\n"
26704 " */\n"
26705 "bool foo() {\n"
26706 " /* Single line multi line comment. */\n"
26708 "some long lines, at least for the LLVM Style.\"\n"
26711 "everything is working.\";\n"
26713 "least for the LLVM Style.\n"
26715 "check if everything is working.\n"
26716 " const std::string SmallString = \"Hello World\";\n"
26717 " // Small line comment\n"
26718 " return String.size() > SmallString.size();\n"
26767 verifyFormat("export int func() {\n"
26768 " foo();\n"
26771 verifyFormat("export struct {\n"
26772 " int foo;\n"
26775 verifyFormat("export {\n"
26776 " int foo;\n"
26794 verifyFormat("export namespace hi {\n"
26795 "const char *sayhi();\n"
26818 verifyFormat("for co_await (auto x : range())\n ;");
26819 verifyFormat("for (auto i : arr) {\n"
26822 verifyFormat("for co_await (auto i : arr) {\n"
26825 verifyFormat("for co_await (auto i : foo(T{})) {\n"
26847 verifyFormat("co_await [this](int a, int b) -> Task {\n"
26848 " co_return co_await foo();\n"
26860 verifyFormat("co_yield n++;");
26861 verifyFormat("co_yield ++n;");
26878 verifyFormat("try {\n"
26879 " doA();\n"
26880 "} catch (Exception &e) {\n"
26881 " e.printStackTrace();\n"
26885 verifyFormat("try {\n"
26886 " doA();\n"
26900 verifyFormat("template <int N> struct Foo<char[N]> {};", Style);
26905 verifyFormat("auto aLengthyIdentifier = oneExpressionSoThatWeBreak ? []() {\n"
26906 " ;\n"
26907 " return 5;\n"
26908 "}()\n"
26912 "auto aLengthyIdentifier = oneExpressionSoThatWeBreak ? 2 : []() {\n"
26913 " ;\n"
26914 " return 5;\n"
26919 verifyFormat("auto aLengthyIdentifier = oneExpressionSoThatWeBreak\n"
26920 " ? []() {\n"
26921 " ;\n"
26922 " return 5;\n"
26923 " }()\n"
26926 verifyFormat("auto aLengthyIdentifier =\n"
26927 " oneExpressionSoThatWeBreak ? 2 : []() {\n"
26928 " ;\n"
26929 " return 5;\n"
26934 verifyFormat("auto aLengthyIdentifier =\n"
26935 " oneExpressionSoThatWeBreak ? []() {\n"
26936 " ;\n"
26937 " return 5;\n"
26938 " }()\n"
26941 verifyFormat("auto aLengthyIdentifier =\n"
26942 " oneExpressionSoThatWeBreak\n"
26943 " ? 2\n"
26944 " : []() {\n"
26945 " ;\n"
26946 " return 5;\n"
26954 StringRef Short = "functionCall(paramA, paramB, paramC);\n"
26958 "paramF, paramG, paramH, paramI);\n"
26965 "paramF, paramG, paramH,\n"
26966 " paramI);\n"
26968 "argumentC, int argumentD,\n"
26973 "functionCall(\n"
26974 " paramA,\n"
26975 " paramB,\n"
26976 " paramC,\n"
26977 " paramD,\n"
26978 " paramE,\n"
26979 " paramF,\n"
26980 " paramG,\n"
26981 " paramH,\n"
26982 " paramI\n"
26983 ");\n"
26984 "void functionDecl(\n"
26985 " int argumentA,\n"
26986 " int argumentB,\n"
26987 " int argumentC,\n"
26988 " int argumentD,\n"
26989 " int argumentE\n"
26993 verifyFormat("outerFunctionCall(nestedFunctionCall(argument1),\n"
26995 "argument2, argument3,\n"
27004 "functionCall(\n"
27006 "paramI\n"
27007 ");\n"
27008 "void functionDecl(\n"
27010 "argumentE\n"
27019 "functionCall(\n"
27021 "paramI\n"
27022 ");\n"
27023 "void functionDecl(\n"
27025 "argumentE\n"
27034 verifyFormat("functionCall(\n"
27035 " paramA,\n"
27036 " paramB,\n"
27037 " paramC,\n"
27038 " paramD,\n"
27039 " paramE,\n"
27040 " paramF,\n"
27041 " paramG,\n"
27042 " paramH,\n"
27043 " paramI\n"
27044 ");\n"
27045 "void functionDecl(\n"
27046 " int argumentA,\n"
27047 " int argumentB,\n"
27048 " int argumentC,\n"
27049 " int argumentD,\n"
27050 " int argumentE\n"
27054 verifyFormat("outerFunctionCall(\n"
27055 " nestedFunctionCall(argument1),\n"
27056 " nestedLongFunctionCall(\n"
27057 " argument1,\n"
27058 " argument2,\n"
27059 " argument3,\n"
27060 " argument4,\n"
27061 " argument5\n"
27062 " )\n"
27068 "int a = (\n"
27069 " int\n"
27075 "return (\n"
27076 " true\n"
27082 "void foo(\n"
27088 "void foo(\n"
27089 ") {\n"
27095 "auto string = std::string(\n"
27101 "void (\n"
27102 " *functionPointer\n"
27103 ")\n"
27104 "(\n"
27112 verifyFormat("if (foo()) {\n"
27113 " return;\n"
27117 verifyFormat("if (quiteLongArg !=\n"
27119 "comment\n"
27120 " return;\n"
27126 verifyFormat("if (foo()) {\n"
27127 " return;\n"
27131 verifyFormat("if (quiteLongArg !=\n"
27133 "comment\n"
27134 " return;\n"
27138 verifyFormat("void foo() {\n"
27139 " if (camelCaseName < alsoLongName ||\n"
27140 " anotherEvenLongerName <=\n"
27142 "\n"
27143 " otherName < thisLastName) {\n"
27144 " return;\n"
27145 " } else if (quiteLongName < alsoLongName ||\n"
27146 " anotherEvenLongerName <=\n"
27148 "Name ||\n"
27149 " otherName < thisLastName) {\n"
27150 " return;\n"
27151 " }\n"
27156 verifyFormat("void foo() {\n"
27157 " if (ThisIsRatherALongIfClause && thatIExpectToBeBroken ||\n"
27158 " ontoMultipleLines && whenFormattedCorrectly) {\n"
27159 " if (false) {\n"
27160 " return;\n"
27162 "thatIExpectToBeBroken ||\n"
27163 " ontoMultipleLines && whenFormattedCorrectly) {\n"
27164 " return;\n"
27165 " }\n"
27166 " }\n"
27174 verifyFormat("for (int i = 0; i < 5; ++i) {\n"
27175 " doSomething();\n"
27180 "myReallyLongCountVariable < count;\n"
27181 " myReallyLongCountVariable++) {\n"
27182 " doSomething();\n"
27188 verifyFormat("for (int i = 0; i < 5; ++i) {\n"
27189 " doSomething();\n"
27194 "myReallyLongCountVariable < count;\n"
27195 " myReallyLongCountVariable++) {\n"
27196 " doSomething();\n"
27205 verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n"
27206 " 10000000, 20000000\n"
27209 verifyFormat("SomeStruct s{\n"
27210 " \"xxxxxxxxxxxxxxxx\", \"yyyyyyyyyyyyyyyy\",\n"
27211 " \"zzzzzzzzzzzzzzzz\"\n"
27215 verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n"
27216 " [0] = 10000000, [1] = 20000000\n"
27219 verifyFormat("SomeStruct s{\n"
27220 " .foo = \"xxxxxxxxxxxxx\",\n"
27221 " .bar = \"yyyyyyyyyyyyy\",\n"
27222 " .baz = \"zzzzzzzzzzzzz\"\n"
27226 verifyFormat("SomeStruct s{\n"
27227 " \"xxxxxxxxxxxxx\",\n"
27228 " \"yyyyyyyyyyyyy\",\n"
27229 " \"zzzzzzzzzzzzz\",\n"
27232 verifyFormat("SomeStruct{\n"
27233 " \"xxxxxxxxxxxxx\",\n"
27234 " \"yyyyyyyyyyyyy\",\n"
27235 " \"zzzzzzzzzzzzz\",\n"
27238 verifyFormat("new SomeStruct{\n"
27239 " \"xxxxxxxxxxxxx\",\n"
27240 " \"yyyyyyyyyyyyy\",\n"
27241 " \"zzzzzzzzzzzzz\",\n"
27245 verifyFormat("class SomeClass {\n"
27246 " SomeStruct s{\n"
27247 " \"xxxxxxxxxxxxx\",\n"
27248 " \"yyyyyyyyyyyyy\",\n"
27249 " \"zzzzzzzzzzzzz\",\n"
27250 " };\n"
27254 verifyFormat("SomeClass::SomeClass : strct{\n"
27255 " \"xxxxxxxxxxxxx\",\n"
27256 " \"yyyyyyyyyyyyy\",\n"
27257 " \"zzzzzzzzzzzzz\",\n"
27261 verifyFormat("SomeStruct s = SomeStruct{\n"
27262 " \"xxxxxxxxxxxxx\",\n"
27263 " \"yyyyyyyyyyyyy\",\n"
27264 " \"zzzzzzzzzzzzz\",\n"
27268 verifyFormat("SomeStruct s = {\n"
27269 " \"xxxxxxxxxxxxx\",\n"
27270 " \"yyyyyyyyyyyyy\",\n"
27271 " \"zzzzzzzzzzzzz\",\n"
27275 verifyFormat("s = {\n"
27276 " \"xxxxxxxxxxxxx\",\n"
27277 " \"yyyyyyyyyyyyy\",\n"
27278 " \"zzzzzzzzzzzzz\",\n"
27282 verifyFormat("return {\n"
27283 " \"xxxxxxxxxxxxx\",\n"
27284 " \"yyyyyyyyyyyyy\",\n"
27285 " \"zzzzzzzzzzzzz\",\n"
27289 verifyFormat("auto initializerList = {\n"
27290 " \"xxxxxxxxxxxxx\",\n"
27291 " \"yyyyyyyyyyyyy\",\n"
27292 " \"zzzzzzzzzzzzz\",\n"
27296 verifyFormat("func({\n"
27297 " \"xxxxxxxxxxxxx\",\n"
27298 " \"yyyyyyyyyyyyy\",\n"
27299 " \"zzzzzzzzzzzzz\",\n"
27303 verifyFormat("SomeStruct s = {\n"
27304 " {{init1, init2, init3, init4, init5},\n"
27305 " {init1, init2, init3, init4, init5}}\n"
27308 verifyFormat("SomeStruct s = {\n"
27309 " {{\n"
27310 " .init1 = 1,\n"
27311 " .init2 = 2,\n"
27312 " .init3 = 3,\n"
27313 " .init4 = 4,\n"
27314 " .init5 = 5,\n"
27315 " },\n"
27316 " {init1, init2, init3, init4, init5}}\n"
27319 verifyFormat("SomeArrayT a[3] = {\n"
27320 " {\n"
27321 " foo,\n"
27322 " bar,\n"
27323 " },\n"
27324 " {\n"
27325 " foo,\n"
27326 " bar,\n"
27327 " },\n"
27328 " SomeArrayT{},\n"
27331 verifyFormat("SomeArrayT a[3] = {\n"
27332 " {foo},\n"
27333 " {\n"
27334 " {\n"
27335 " init1,\n"
27336 " init2,\n"
27337 " init3,\n"
27338 " },\n"
27339 " {\n"
27340 " init1,\n"
27341 " init2,\n"
27342 " init3,\n"
27343 " },\n"
27344 " },\n"
27345 " {baz},\n"
27369 verifyFormat("struct test demo[] = {\n"
27370 " {1, 2},\n"
27371 " {3, 4, 5},\n"
27372 " {6, 7, 8}\n"
27375 verifyFormat("struct test demo[] = {\n"
27376 " {1, 2, 3, 4, 5},\n"
27377 " {3, 4, 5},\n"
27378 " {6, 7, 8}\n"
27381 verifyFormat("struct test demo[] = {\n"
27382 " {1, 2, 3, 4, 5},\n"
27383 " {3, 4, 5},\n"
27384 " {6, 7, 8, 9, 10, 11, 12}\n"
27387 verifyFormat("struct test demo[] = {\n"
27388 " {1, 2, 3},\n"
27389 " {3, 4, 5},\n"
27390 " {6, 7, 8, 9, 10, 11, 12}\n"
27394 verifyFormat("S{\n"
27395 " {},\n"
27396 " {},\n"
27397 " {a, b}\n"
27400 verifyFormat("S{\n"
27401 " {},\n"
27402 " {},\n"
27403 " {a, b},\n"
27406 verifyFormat("void foo() {\n"
27407 " auto thing = test{\n"
27408 " {\n"
27409 " {13}, {something}, // A\n"
27410 " }\n"
27411 " };\n"
27413 "void foo() {\n"
27414 " auto thing = test{\n"
27415 " {\n"
27416 " {13},\n"
27417 " {something}, // A\n"
27418 " }\n"
27419 " };\n"
27433 verifyFormat("struct test demo[] = {\n"
27434 " {1, 2},\n"
27435 " {3, 4, 5},\n"
27436 " {6, 7, 8}\n"
27439 verifyFormat("struct test demo[] = {\n"
27440 " {1, 2, 3, 4, 5},\n"
27441 " {3, 4, 5},\n"
27442 " {6, 7, 8}\n"
27445 verifyFormat("struct test demo[] = {\n"
27446 " {1, 2, 3, 4, 5},\n"
27447 " {3, 4, 5},\n"
27448 " {6, 7, 8, 9, 10, 11, 12}\n"
27451 verifyFormat("struct test demo[] = {\n"
27452 " {1, 2, 3},\n"
27453 " {3, 4, 5},\n"
27454 " {6, 7, 8, 9, 10, 11, 12}\n"
27458 verifyFormat("S{\n"
27459 " {},\n"
27460 " {},\n"
27461 " {a, b}\n"
27464 verifyFormat("S{\n"
27465 " {},\n"
27466 " {},\n"
27467 " {a, b},\n"
27470 verifyFormat("void foo() {\n"
27471 " auto thing = test{\n"
27472 " {\n"
27473 " {13}, {something}, // A\n"
27474 " }\n"
27475 " };\n"
27477 "void foo() {\n"
27478 " auto thing = test{\n"
27479 " {\n"
27480 " {13},\n"
27481 " {something}, // A\n"
27482 " }\n"
27483 " };\n"
27504 verifyFormat("class Foo {\n"
27505 " int getSomething() const { return something; }\n"
27507 "class Foo {\n"
27508 " int getSomething() const { return something; };\n"
27512 verifyFormat("class Foo {\n"
27513 " int getSomething() const { return something; }\n"
27515 "class Foo {\n"
27516 " int getSomething() const { return something; };;\n"
27520 verifyFormat("for (;;) {\n"
27524 verifyFormat("class [[deprecated(\"\")]] C {\n"
27525 " int i;\n"
27529 verifyFormat("struct EXPORT_MACRO [[nodiscard]] C {\n"
27530 " int i;\n"
27538 verifyFormat("struct Foo {\n"
27539 " Foo() {}\n"
27540 " ~Foo() {}\n"
27542 "struct Foo {\n"
27543 " Foo() {};\n"
27544 " ~Foo() {};\n"
27550 verifyFormat("void foo() {} //\n"
27552 "void foo() {}; //\n"
27557 verifyFormat("auto sgf = [] {\n"
27558 " ogl = {\n"
27559 " a, b, c, d, e,\n"
27560 " };\n"
27569 constexpr StringRef Code("[[maybe_unused]] const int i;\n"
27570 "[[foo([[]])]] [[maybe_unused]]\n"
27571 "int j;\n"
27572 "[[maybe_unused]]\n"
27573 "foo<int> k;\n"
27574 "[[nodiscard]] inline int f(int &i);\n"
27575 "[[foo([[]])]] [[nodiscard]]\n"
27576 "int g(int &i);\n"
27577 "[[nodiscard]]\n"
27578 "inline int f(int &i) {\n"
27579 " i = 1;\n"
27580 " return 0;\n"
27581 "}\n"
27582 "[[foo([[]])]] [[nodiscard]] int g(int &i) {\n"
27583 " i = 0;\n"
27584 " return 1;\n"
27592 verifyFormat("[[maybe_unused]] const int i;\n"
27593 "[[foo([[]])]] [[maybe_unused]] int j;\n"
27594 "[[maybe_unused]] foo<int> k;\n"
27595 "[[nodiscard]] inline int f(int &i);\n"
27596 "[[foo([[]])]] [[nodiscard]] int g(int &i);\n"
27597 "[[nodiscard]] inline int f(int &i) {\n"
27598 " i = 1;\n"
27599 " return 0;\n"
27600 "}\n"
27601 "[[foo([[]])]] [[nodiscard]] int g(int &i) {\n"
27602 " i = 0;\n"
27603 " return 1;\n"
27608 verifyFormat("[[maybe_unused]]\n"
27609 "const int i;\n"
27610 "[[foo([[]])]] [[maybe_unused]]\n"
27611 "int j;\n"
27612 "[[maybe_unused]]\n"
27613 "foo<int> k;\n"
27614 "[[nodiscard]]\n"
27615 "inline int f(int &i);\n"
27616 "[[foo([[]])]] [[nodiscard]]\n"
27617 "int g(int &i);\n"
27618 "[[nodiscard]]\n"
27619 "inline int f(int &i) {\n"
27620 " i = 1;\n"
27621 " return 0;\n"
27622 "}\n"
27623 "[[foo([[]])]] [[nodiscard]]\n"
27624 "int g(int &i) {\n"
27625 " i = 0;\n"
27626 " return 1;\n"
27630 constexpr StringRef CtrlStmtCode("[[likely]] if (a)\n"
27631 " f();\n"
27632 "else\n"
27633 " g();\n"
27634 "[[foo([[]])]]\n"
27635 "switch (b) {\n"
27636 "[[unlikely]] case 1:\n"
27637 " ++b;\n"
27638 " break;\n"
27639 "[[likely]]\n"
27640 "default:\n"
27641 " return;\n"
27642 "}\n"
27643 "[[unlikely]] for (; c > 0; --c)\n"
27644 " h();\n"
27645 "[[likely]]\n"
27646 "while (d > 0)\n"
27653 verifyFormat("[[likely]] if (a)\n"
27654 " f();\n"
27655 "else\n"
27656 " g();\n"
27657 "[[foo([[]])]] switch (b) {\n"
27658 "[[unlikely]] case 1:\n"
27659 " ++b;\n"
27660 " break;\n"
27661 "[[likely]] default:\n"
27662 " return;\n"
27663 "}\n"
27664 "[[unlikely]] for (; c > 0; --c)\n"
27665 " h();\n"
27666 "[[likely]] while (d > 0)\n"
27671 verifyFormat("[[likely]]\n"
27672 "if (a)\n"
27673 " f();\n"
27674 "else\n"
27675 " g();\n"
27676 "[[foo([[]])]]\n"
27677 "switch (b) {\n"
27678 "[[unlikely]]\n"
27679 "case 1:\n"
27680 " ++b;\n"
27681 " break;\n"
27682 "[[likely]]\n"
27683 "default:\n"
27684 " return;\n"
27685 "}\n"
27686 "[[unlikely]]\n"
27687 "for (; c > 0; --c)\n"
27688 " h();\n"
27689 "[[likely]]\n"
27690 "while (d > 0)\n"
27694 constexpr StringRef CtorDtorCode("struct Foo {\n"
27695 " [[deprecated]] Foo();\n"
27696 " [[deprecated]] Foo() {}\n"
27697 " [[deprecated]] ~Foo();\n"
27698 " [[deprecated]] ~Foo() {}\n"
27699 " [[deprecated]] void f();\n"
27700 " [[deprecated]] void f() {}\n"
27701 "};\n"
27702 "[[deprecated]] Bar::Bar() {}\n"
27703 "[[deprecated]] Bar::~Bar() {}\n"
27705 verifyFormat("struct Foo {\n"
27706 " [[deprecated]]\n"
27707 " Foo();\n"
27708 " [[deprecated]]\n"
27709 " Foo() {}\n"
27710 " [[deprecated]]\n"
27711 " ~Foo();\n"
27712 " [[deprecated]]\n"
27713 " ~Foo() {}\n"
27714 " [[deprecated]]\n"
27715 " void f();\n"
27716 " [[deprecated]]\n"
27717 " void f() {}\n"
27718 "};\n"
27719 "[[deprecated]]\n"
27720 "Bar::Bar() {}\n"
27721 "[[deprecated]]\n"
27722 "Bar::~Bar() {}\n"
27723 "[[deprecated]]\n"
27728 verifyFormat("struct Foo {\n"
27729 " [[deprecated]]\n"
27730 " Foo();\n"
27731 " [[deprecated]]\n"
27732 " Foo()\n"
27733 " {\n"
27734 " }\n"
27735 " [[deprecated]]\n"
27736 " ~Foo();\n"
27737 " [[deprecated]]\n"
27738 " ~Foo()\n"
27739 " {\n"
27740 " }\n"
27741 " [[deprecated]]\n"
27742 " void f();\n"
27743 " [[deprecated]]\n"
27744 " void f()\n"
27745 " {\n"
27746 " }\n"
27747 "};\n"
27748 "[[deprecated]]\n"
27749 "Bar::Bar()\n"
27750 "{\n"
27751 "}\n"
27752 "[[deprecated]]\n"
27753 "Bar::~Bar()\n"
27754 "{\n"
27755 "}\n"
27756 "[[deprecated]]\n"
27757 "void g()\n"
27758 "{\n"
27762 verifyFormat("struct Foo {\n"
27763 " [[maybe_unused]]\n"
27764 " void operator+();\n"
27765 "};\n"
27766 "[[nodiscard]]\n"
27771 verifyFormat("[[nodiscard]]\n"
27780 verifyNoChange("int i;\n", Style);
27781 verifyFormat("int i;\n", "int i;", Style);
27783 constexpr StringRef Code{"namespace {\n"
27784 "int i;\n"
27786 verifyFormat(Code.str() + '\n', Code, Style,
27794 const StringRef Code{"int i;\n\n"};
27796 verifyFormat(Code, "int i;\n\n\n", Style);
27805 verifyFormat("class Foo {\n"
27806 " int interface;\n"
27807 " Foo::Foo(int iface) : interface{iface} {}\n"
27812 verifyFormat("#ifdef\n\n"
27813 "#else\n"
27815 "#ifdef \n"
27816 " \n"
27817 "\n"
27818 "#else \n"
27834 verifyFormat("while (a)\n"
27836 "while (((a)))\n"
27839 verifyFormat("while ((a = b))\n"
27841 "while (((a = b)))\n"
27844 verifyFormat("if (a)\n"
27846 "if (((a)))\n"
27849 verifyFormat("if constexpr ((a = b))\n"
27851 "if constexpr (((a = b)))\n"
27854 verifyFormat("if (({ a; }))\n"
27856 "if ((({ a; })))\n"
27881 verifyFormat("inline decltype(auto) f() {\n"
27882 " if (a) {\n"
27883 " return (a);\n"
27884 " }\n"
27885 " return (b);\n"
27887 "inline decltype(auto) f() {\n"
27888 " if (a) {\n"
27889 " return ((a));\n"
27890 " }\n"
27891 " return ((b));\n"
27894 verifyFormat("auto g() {\n"
27895 " decltype(auto) x = [] {\n"
27896 " auto y = [] {\n"
27897 " if (a) {\n"
27898 " return a;\n"
27899 " }\n"
27900 " return b;\n"
27901 " };\n"
27902 " if (c) {\n"
27903 " return (c);\n"
27904 " }\n"
27905 " return (d);\n"
27906 " };\n"
27907 " if (e) {\n"
27908 " return e;\n"
27909 " }\n"
27910 " return f;\n"
27912 "auto g() {\n"
27913 " decltype(auto) x = [] {\n"
27914 " auto y = [] {\n"
27915 " if (a) {\n"
27916 " return ((a));\n"
27917 " }\n"
27918 " return ((b));\n"
27919 " };\n"
27920 " if (c) {\n"
27921 " return ((c));\n"
27922 " }\n"
27923 " return ((d));\n"
27924 " };\n"
27925 " if (e) {\n"
27926 " return ((e));\n"
27927 " }\n"
27928 " return ((f));\n"
27934 "return (((a + b)) -\n"
27943 verifyFormat("void foo(int arg1,\n"
27949 verifyFormat("void bar(int arg1, double arg2) noexcept(\n"
27950 " noexcept(baz(arg1)) &&\n"
27958 verifyFormat("void foo(int arg1,\n"
27962 verifyFormat("void bar(int arg1, double arg2)\n"
27963 " noexcept(noexcept(baz(arg1)) &&\n"
27967 verifyFormat("void aVeryLongFunctionNameWithoutAnyArguments()\n"
27972 verifyFormat("void foo(int arg1,\n"
27976 verifyFormat("void bar(int arg1, double arg2)\n"
27977 " noexcept(noexcept(baz(arg1)) &&\n"
27986 verifyFormat("A a_{kFlag1,\n"
27987 "#if BUILD_FLAG\n"
27988 " kFlag2,\n"
27989 "#else\n"
27990 " kFlag3,\n"
27991 "#endif\n"
27993 "A a_{\n"
27994 " kFlag1,\n"
27995 "#if BUILD_FLAG\n"
27996 " kFlag2,\n"
27997 "#else\n"
27998 " kFlag3,\n"
27999 "#endif\n"
28000 " kFlag4\n"
28005 verifyFormat("{\n"
28006 " char *a[] = {\n"
28007 " /* abc */ \"abc\",\n"
28008 "#if FOO\n"
28009 " /* xyz */ \"xyz\",\n"
28010 "#endif\n"
28011 " /* last */ \"last\"};\n"
28020 verifyFormat("return \"Code\"\n"
28021 " \"\\0\\52\\26\\55\\55\\0\"\n"
28022 " \"x013\"\n"
28033 "int rus; // А теперь комментарии, например, на русском, 2-байта\n"
28034 "int long_rus; // Верхний коммент еще не превысил границу в 80, однако\n"
28039 verifyNoChange("#define test \\\n"
28040 " /* 测试 */ \\\n"
28041 " \"aa\" \\\n"
28046 verifyFormat("struct foo {\n"
28047 " int iiiiii; ///< iiiiii\n"
28048 " int b; ///< ыыы\n"
28049 " int c; ///< ыыыы\n"
28054 verifyFormat("#define SENSOR_DESC_1 \\\n"
28055 " \"{\" \\\n"
28056 " \"unit_of_measurement: \\\"°C\\\",\" \\\n"
28062 verifyFormat("Languages languages = {\n"
28063 " Language{{'e', 'n'}, U\"Test English\" },\n"
28064 " Language{{'l', 'v'}, U\"Test Latviešu\"},\n"
28065 " Language{{'r', 'u'}, U\"Test Русский\" },\n"
28081 verifyFormat("if (condition1 && condition2) {\n"
28085 verifyFormat("if (condition1 && condition2 &&\n"
28086 " (condition3 || condition4) && condition5 &&\n"
28087 " condition6) {\n"
28091 verifyFormat("if (loooooooooooooooooooooongcondition1 &&\n"
28092 " loooooooooooooooooooooongcondition2) {\n"
28099 verifyFormat("const int result = loooooooongop1 + looooooooongop2 +\n"
28103 verifyFormat("result = longOperand1 + longOperand2 -\n"
28104 " (longOperand3 + longOperand4) -\n"
28108 verifyFormat("const int result =\n"
28113 verifyFormat("std::cin >> longOperand_1 >> longOperand_2 >>\n"
28120 verifyFormat("if (condition1 && condition2) {\n"
28124 verifyFormat("if (condition1 && // comment\n"
28125 " condition2 &&\n"
28126 " (condition3 || condition4) && // comment\n"
28127 " condition5 &&\n"
28128 " condition6) {\n"
28132 verifyFormat("if (loooooooooooooooooooooongcondition1 &&\n"
28133 " loooooooooooooooooooooongcondition2) {\n"
28140 verifyFormat("result = loooooooooooooooooooooongop1 +\n"
28141 " loooooooooooooooooooooongop2 +\n"
28145 verifyFormat("const int result =\n"
28149 verifyFormat("result = longOperand1 +\n"
28150 " longOperand2 -\n"
28151 " (longOperand3 + longOperand4) -\n"
28152 " longOperand5 +\n"
28156 verifyFormat("result = operand1 +\n"
28157 " operand2 -\n"
28158 " operand3 +\n"
28159 " operand4 -\n"
28160 " operand5 +\n"
28167 verifyFormat("result = operand1 +\n"
28168 " operand2 /\n"
28169 " operand3 +\n"
28170 " operand4 /\n"
28171 " operand5 *\n"
28175 verifyFormat("result = operand1 *\n"
28176 " operand2 -\n"
28177 " operand3 *\n"
28178 " operand4 -\n"
28179 " operand5 +\n"
28183 verifyFormat("result = operand1 *\n"
28184 " (operand2 - operand3 * operand4) -\n"
28185 " operand5 +\n"
28189 verifyFormat("result = operand1.member *\n"
28190 " (operand2.member() - operand3->mem * operand4) -\n"
28191 " operand5.member() +\n"
28196 verifyFormat("std::cin >>\n"
28197 " longOperand_1 >>\n"
28198 " longOperand_2 >>\n"
28205 verifyFormat("result = operand1 +\n"
28206 " operand2 / operand3 +\n"
28210 verifyFormat("result = operand1 * operand2 -\n"
28211 " operand3 * operand4 -\n"
28212 " operand5 +\n"
28216 verifyFormat("result = operand1 * (operand2 - operand3 * operand4) -\n"
28217 " operand5 +\n"
28221 verifyFormat("std::uint32_t a = byte_buffer[0] |\n"
28222 " byte_buffer[1] << 8 |\n"
28223 " byte_buffer[2] << 16 |\n"
28228 verifyFormat("std::cin >>\n"
28229 " longOperand_1 >>\n"
28230 " longOperand_2 >>\n"
28238 verifyFormat("if (condition1 && condition2) {\n"
28242 verifyFormat("if (loooooooooooooooooooooongcondition1\n"
28243 " && loooooooooooooooooooooongcondition2) {\n"
28250 verifyFormat("result = loooooooooooooooooooooongop1\n"
28251 " + loooooooooooooooooooooongop2\n"
28255 verifyFormat("const int result =\n"
28259 verifyFormat("result = longOperand1\n"
28260 " + longOperand2\n"
28261 " - (longOperand3 + longOperand4)\n"
28262 " - longOperand5\n"
28266 verifyFormat("result = operand1\n"
28267 " + operand2\n"
28268 " - operand3\n"
28269 " + operand4\n"
28270 " - operand5\n"
28277 verifyFormat("result = operand1\n"
28278 " + operand2\n"
28279 " / operand3\n"
28280 " + operand4\n"
28281 " / operand5\n"
28285 verifyFormat("result = operand1\n"
28286 " * operand2\n"
28287 " - operand3\n"
28288 " * operand4\n"
28289 " - operand5\n"
28293 verifyFormat("result = operand1\n"
28294 " * (operand2 - operand3 * operand4)\n"
28295 " - operand5\n"
28299 verifyFormat("std::uint32_t a = byte_buffer[0]\n"
28300 " | byte_buffer[1]\n"
28301 " << 8\n"
28302 " | byte_buffer[2]\n"
28303 " << 16\n"
28304 " | byte_buffer[3]\n"
28309 verifyFormat("std::cin\n"
28310 " >> longOperand_1\n"
28311 " >> longOperand_2\n"
28318 verifyFormat("result = operand1\n"
28319 " + operand2 / operand3\n"
28323 verifyFormat("result = operand1 * operand2\n"
28324 " - operand3 * operand4\n"
28325 " - operand5\n"
28329 verifyFormat("result = operand1 * (operand2 - operand3 * operand4)\n"
28330 " - operand5\n"
28334 verifyFormat("std::uint32_t a = byte_buffer[0]\n"
28335 " | byte_buffer[1] << 8\n"
28336 " | byte_buffer[2] << 16\n"
28341 verifyFormat("std::cin\n"
28342 " >> longOperand_1\n"
28343 " >> longOperand_2\n"
28353 "int c\n"
28354 "\n"
28359 "enum : unsigned\n"
28360 "\n"
28361 "{\n"
28362 " AA = 0,\n"
28363 " BB\n"
28367 verifyFormat("class B : public E {\n"
28368 "private:\n"
28370 "class B : public E\n"
28371 "\n"
28372 "{\n"
28373 "private:\n"
28379 "struct AAAAAAAAAAAAAAA test[3] = {{56,\n"
28380 "\n"
28381 " 23, \"hello\"},\n"
28386 "int myFunction(\n"
28387 "\n"
28388 " int aaaaaaaaaaaaa,\n"
28389 "\n"
28393 verifyFormat("switch (e) {\n"
28394 "case 1:\n"
28395 " return e;\n"
28396 "case 2:\n"
28397 " return 2;\n"
28399 "switch (\n"
28400 "\n"
28401 " e) {\n"
28402 "case 1:\n"
28403 " return e;\n"
28404 "case 2:\n"
28405 " return 2;\n"
28409 verifyFormat("while (true) {\n"
28411 "while (\n"
28412 "\n"
28413 " true) {\n"
28417 verifyFormat("void loooonFunctionIsVeryLongButNotAsLongAsJavaTypeNames(\n"
28419 "void loooonFunctionIsVeryLongButNotAsLongAsJavaTypeNames\n"
28420 "\n"
28429 constexpr StringRef NoFormFeed{"int i;\n"
28430 "\n"
28433 "int i;\n"
28434 " \f\n"
28438 "int i;\n"
28439 "\n"
28443 "\fint i;\n"
28444 "\n"
28448 "int i;\n"
28449 "\n"
28453 constexpr StringRef FormFeed{"int i;\n"
28454 "\f\n"
28460 "int i;\r\n"
28461 "\f\r\n"
28465 constexpr StringRef FormFeedBeforeEmptyLine{"int i;\n"
28466 "\f\n"
28467 "\n"
28471 "int i;\n"
28472 "\n"
28473 "\f\n"
28477 "int i;\n"
28478 "\f\n"
28479 "\f\n"
28494 verifyFormat("namespace foo {\n"
28495 "class bar;\n"
28496 "class baz;\n"
28501 verifyFormat("namespace foo { namespace baz {\n"
28502 "class qux;\n"
28503 "} // comment\n"
28509 verifyFormat("namespace foo {\n"
28512 verifyFormat("namespace foo {\n"
28522 verifyFormat("namespace foo {\n"
28523 "namespace bar { class baz; }\n"
28527 verifyFormat("namespace foo {\n"
28528 "namespace bar { class baz; }\n"
28529 "namespace qux { class quux; }\n"
28536 verifyFormat("namespace foo {\n"
28537 "int f() { return 5; }\n"
28552 verifyFormat("namespace foo { namespace baar { namespace baaz {\n"
28553 "class quux;\n"
28558 "namespace foo { namespace bar { namespace baz { namespace qux {\n"
28559 "class quux;\n"
28567 verifyFormat("namespace foo { namespace bar { namespace baz {\n"
28568 "class qux;\n"
28583 "namespace foo { namespace bar { namespace baz {\n"
28584 "class qux;\n"
28597 verifyFormat("namespace N {}", Style);
28600 verifyFormat("namespace N {\n"
28601 "int f1(int a) { return 2 * a; }\n"
28603 "namespace N {\n"
28604 "\n"
28605 "\n"
28606 "int f1(int a) { return 2 * a; }\n"
28607 "\n"
28608 "\n"
28613 verifyFormat("namespace N1 {\n"
28614 "namespace N2 {\n"
28615 "int a = 1;\n"
28616 "}\n"
28618 "namespace N1 {\n"
28619 "\n"
28620 "\n"
28621 "namespace N2 {\n"
28622 "\n"
28623 "int a = 1;\n"
28624 "\n"
28625 "}\n"
28626 "\n"
28627 "\n"
28633 verifyFormat("namespace N1 { namespace N2 {\n"
28634 "int a = 1;\n"
28636 "namespace N1 { namespace N2 {\n"
28637 "\n"
28638 "\n"
28639 "int a = 1;\n"
28640 "\n"
28641 "\n"
28653 verifyFormat("namespace N {}", Style);
28656 verifyFormat("namespace N {\n"
28657 "\n"
28658 "int f1(int a) { return 2 * a; }\n"
28659 "\n"
28661 "namespace N {\n"
28662 "int f1(int a) { return 2 * a; }\n"
28667 verifyFormat("namespace N1 {\n"
28668 "namespace N2 {\n"
28669 "\n"
28670 "int a = 1;\n"
28671 "\n"
28672 "}\n"
28674 "namespace N1 {\n"
28675 "namespace N2 {\n"
28676 "int a = 1;\n"
28677 "}\n"
28681 verifyFormat("namespace N1 {\n"
28682 "\n"
28683 "namespace N2 {\n"
28684 "\n"
28685 "\n"
28686 "int a = 1;\n"
28687 "\n"
28688 "\n"
28689 "}\n"
28690 "\n"
28692 "namespace N1 {\n"
28693 "\n"
28694 "namespace N2 {\n"
28695 "\n"
28696 "\n"
28697 "\n"
28698 "int a = 1;\n"
28699 "\n"
28700 "\n"
28701 "\n"
28702 "}\n"
28703 "\n"
28709 verifyFormat("namespace N1 { namespace N2 {\n"
28710 "\n"
28711 "int a = 1;\n"
28712 "\n"
28714 "namespace N1 { namespace N2 {\n"
28715 "int a = 1;\n"