|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
tools/clang/unittests/Format/FormatTest.cpp 94 verifyFormat(Code, getGoogleStyle());
98 verifyFormat(text);
99 verifyFormat(llvm::Twine("void f() { " + text + " }").str());
152 verifyFormat("Method(f1, f2(f3));");
153 verifyFormat("Method(f1(f2, f3()));");
154 verifyFormat("Method(f1(f2, (f3())));");
158 verifyFormat("vector<::Type> v;");
159 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
160 verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
161 verifyFormat("bool a = 2 < ::SomeFunction();");
162 verifyFormat("ALWAYS_INLINE ::std::string getName();");
163 verifyFormat("some::string getName();");
255 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
399 verifyFormat("x = (a) and (b);");
400 verifyFormat("x = (a) or (b);");
401 verifyFormat("x = (a) bitand (b);");
402 verifyFormat("x = (a) bitor (b);");
403 verifyFormat("x = (a) not_eq (b);");
404 verifyFormat("x = (a) and_eq (b);");
405 verifyFormat("x = (a) or_eq (b);");
406 verifyFormat("x = (a) xor (b);");
410 verifyFormat("x = compl(a);");
411 verifyFormat("x = not(a);");
412 verifyFormat("x = bitand(a);");
414 verifyFormat("x = compl a;");
415 verifyFormat("x = not a;");
416 verifyFormat("x = bitand a;");
424 verifyFormat("if (true)\n f();\ng();");
425 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();");
426 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();");
427 verifyFormat("if constexpr (true)\n"
429 verifyFormat("if CONSTEXPR (true)\n"
431 verifyFormat("if constexpr (a)\n"
436 verifyFormat("if CONSTEXPR (a)\n"
441 verifyFormat("if constexpr (a)\n"
446 verifyFormat("if CONSTEXPR (a)\n"
456 verifyFormat("if (a)\n"
460 verifyFormat("{\n"
466 verifyFormat("#define A \\\n"
471 verifyFormat("if (a)\n"
474 verifyFormat("if (a)\n"
478 verifyFormat("if (a) // Can't merge this\n"
481 verifyFormat("if (a) /* still don't merge */\n"
484 verifyFormat("if (a) { // Never merge this\n"
488 verifyFormat("if (a) { /* Never merge this */\n"
494 verifyFormat("if (a) return;", AllowsMergedIf);
495 verifyFormat("if (aaaaaaaaa)\n"
500 verifyFormat("if (a)\n return;", AllowsMergedIf);
508 verifyFormat("if (a)\n"
514 verifyFormat("if (a)\n"
522 verifyFormat("if (a) f();\n"
527 verifyFormat("if (a) f();\n"
541 verifyFormat("while (true) continue;", AllowsMergedLoops);
542 verifyFormat("for (;;) continue;", AllowsMergedLoops);
543 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
544 verifyFormat("while (true)\n"
547 verifyFormat("for (;;)\n"
550 verifyFormat("for (;;)\n"
553 verifyFormat("for (;;) // Can't merge this\n"
556 verifyFormat("for (;;) /* still don't merge */\n"
575 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
576 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
577 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
578 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
579 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
580 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
581 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
582 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
583 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
584 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
585 verifyFormat("if (true) {\n"
589 verifyFormat("if (true) { //\n"
593 verifyFormat("if (true) {\n"
598 verifyFormat("if (true) {\n"
605 verifyFormat("struct A2 {\n"
609 verifyFormat("typedef struct A2 {\n"
613 verifyFormat("template <int> struct A2 {\n"
620 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
621 verifyFormat("if (true) {\n"
625 verifyFormat("if (true) {\n"
633 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
634 verifyFormat("while (true) {\n"
638 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
639 verifyFormat("for (;;) {\n"
650 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
651 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
652 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
653 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
654 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
655 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
656 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
657 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
658 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
659 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
660 verifyFormat("if (true)\n"
665 verifyFormat("if (true)\n"
670 verifyFormat("if (true)\n"
676 verifyFormat("if (true)\n"
687 verifyFormat("if (true) {}", AllowSimpleBracedStatements);
688 verifyFormat("if (true)\n"
693 verifyFormat("if (true)\n"
703 verifyFormat("while (true) {}", AllowSimpleBracedStatements);
704 verifyFormat("while (true)\n"
709 verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
710 verifyFormat("for (;;)\n"
735 verifyFormat("if (true)\n"
745 verifyFormat("if (true)\n"
758 verifyFormat("if (true)\n"
771 verifyFormat("if (true)\n"
784 verifyFormat("void f() {\n"
792 verifyFormat("if (a) {\n} else if (b) {\n}");
793 verifyFormat("if (a)\n"
799 verifyFormat("if constexpr (a)\n"
805 verifyFormat("if CONSTEXPR (a)\n"
811 verifyFormat("if (a) {\n"
819 verifyFormat("if (a) {\n"
823 verifyFormat("if (a) {\n"
827 verifyFormat("if (a) {\n"
831 verifyFormat("if (a) {\n"
836 verifyFormat("if (a) {\n"
841 verifyFormat("if (a) {\n"
849 verifyFormat(
853 verifyFormat("for (;;)\n"
855 verifyFormat("for (;;) {\n}");
856 verifyFormat("for (;;) {\n"
859 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
861 verifyFormat(
866 verifyFormat(
869 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
872 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
876 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
882 verifyFormat(
888 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
891 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
894 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
898 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
904 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
905 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
906 verifyFormat("Foo *x;\nfor (x in y) {\n}");
907 verifyFormat(
912 verifyFormat("for (int aaaaaaaaaaa = 1;\n"
920 verifyFormat(
929 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
933 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
935 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
937 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
939 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
944 verifyFormat("void f() {\n"
952 verifyFormat("#define foreach(x, y)\n"
958 verifyFormat("#define foreach (x, y)\n"
965 verifyFormat("while (true) {\n}");
966 verifyFormat("while (true)\n"
968 verifyFormat("while () {\n}");
969 verifyFormat("while () {\n"
975 verifyFormat("do {\n"
978 verifyFormat("do\n"
984 verifyFormat("switch (x) {\n"
996 verifyFormat("switch (x) {\n"
1005 verifyFormat("switch (x) {\n"
1015 verifyFormat("switch (x) {\n"
1025 verifyFormat("switch (x) {\n"
1031 verifyFormat("switch (test)\n"
1033 verifyFormat("switch (x) {\n"
1038 verifyFormat("switch (x) {\n"
1044 verifyFormat("switch (x) {\n"
1053 verifyFormat("#define A \\\n"
1059 verifyFormat("#define OPERATION_CASE(name) \\\n"
1063 verifyFormat("switch (x) {\n"
1103 verifyFormat("DEBUG({\n"
1155 verifyFormat("switch (a) {\n"
1160 verifyFormat("switch (a) {\n"
1217 verifyFormat("switch (x) {\n"
1228 verifyFormat("switch (a) {\n"
1245 verifyFormat("switch (a) {\n"
1322 verifyFormat("switch (a) {\n"
1328 verifyFormat("switch (a) {\n"
1344 verifyFormat("switch (a) {\n"
1399 verifyFormat("void f() {\n"
1409 verifyFormat("{\n"
1414 verifyFormat("{\n"
1421 verifyFormat("void f() {\n"
1432 verifyFormat("{\n"
1438 verifyFormat("{\n"
1575 verifyFormat("class A {};");
1579 verifyFormat("class A {\n"
1586 verifyFormat("export class A {\n"
1605 verifyFormat("class A {\n"
1625 verifyFormat("signals.set();");
1626 verifyFormat("for (Signals signals : f()) {\n}");
1627 verifyFormat("{\n"
1630 verifyFormat("void f() {\n"
1695 verifyFormat("class A : public B {};");
1696 verifyFormat("class A : public ::B {};");
1698 verifyFormat(
1701 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1704 verifyFormat(
1706 verifyFormat("class AAAAAAAAAAAA : public B,\n"
1713 verifyFormat("class\n"
1718 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1720 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1723 verifyFormat("template <class R, class C>\n"
1726 verifyFormat("class ::A::B {};");
1733 verifyFormat("class MyClass : public X {};",
1735 verifyFormat("class MyClass\n"
1739 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
1743 verifyFormat("struct aaaaaaaaaaaaa\n"
1751 verifyFormat("class MyClass : public X {};",
1753 verifyFormat("class MyClass : public X, public Y {};",
1755 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
1759 verifyFormat("struct aaaaaaaaaaaaa :\n"
1766 verifyFormat("class A {\n} a, b;");
1767 verifyFormat("struct A {\n} a, b;");
1768 verifyFormat("union A {\n} a;");
1772 verifyFormat("enum {\n"
1788 verifyFormat("enum Enum {};");
1789 verifyFormat("enum {};");
1790 verifyFormat("enum X E {} d;");
1791 verifyFormat("enum __attribute__((...)) E {} d;");
1792 verifyFormat("enum __declspec__((...)) E {} d;");
1793 verifyFormat("enum {\n"
1798 verifyFormat("enum ShortEnum { A, B, C };");
1816 verifyFormat("enum E { // comment\n"
1822 verifyFormat("enum X f() {\n"
1826 verifyFormat("enum X Type::f() {\n"
1830 verifyFormat("enum ::X f() {\n"
1834 verifyFormat("enum ns::X f() {\n"
1841 verifyFormat("enum Type {\n"
1845 verifyFormat("namespace n {\n"
1855 verifyFormat("enum struct {\n"
1863 verifyFormat("enum struct Enum {};");
1864 verifyFormat("enum struct {};");
1865 verifyFormat("enum struct X E {} d;");
1866 verifyFormat("enum struct __attribute__((...)) E {} d;");
1867 verifyFormat("enum struct __declspec__((...)) E {} d;");
1868 verifyFormat("enum struct X f() {\n a();\n return 42;\n}");
1872 verifyFormat("enum class {\n"
1880 verifyFormat("enum class Enum {};");
1881 verifyFormat("enum class {};");
1882 verifyFormat("enum class X E {} d;");
1883 verifyFormat("enum class __attribute__((...)) E {} d;");
1884 verifyFormat("enum class __declspec__((...)) E {} d;");
1885 verifyFormat("enum class X f() {\n a();\n return 42;\n}");
1889 verifyFormat("enum X : int {\n"
1893 verifyFormat("enum X : int { A, B };");
1894 verifyFormat("enum X : std::uint32_t { A, B };");
1900 verifyFormat("typedef enum {} EmptyEnum;");
1901 verifyFormat("typedef enum { A, B, C } ShortEnum;");
1902 verifyFormat("typedef enum {\n"
1911 verifyFormat("typedef enum {} EmptyEnum;");
1912 verifyFormat("typedef enum { A, B, C } ShortEnum;");
1913 verifyFormat("typedef enum\n"
1966 verifyFormat("struct Bitfields {\n"
1970 verifyFormat("struct A {\n"
1974 verifyFormat("struct MyStruct {\n"
1986 verifyFormat("namespace some_namespace {\n"
1991 verifyFormat("namespace N::inline D {\n"
1996 verifyFormat("namespace N::inline D::E {\n"
2001 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
2006 verifyFormat("/* something */ namespace some_namespace {\n"
2011 verifyFormat("namespace {\n"
2016 verifyFormat("/* something */ namespace {\n"
2021 verifyFormat("inline namespace X {\n"
2026 verifyFormat("/* something */ inline namespace X {\n"
2031 verifyFormat("export namespace X {\n"
2036 verifyFormat("using namespace some_namespace;\n"
2044 verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
2045 verifyFormat("namespace {\n"
2050 verifyFormat("namespace {\n"
2112 verifyFormat("TESTSUITE(A) {\n"
2117 verifyFormat("TESTSUITE(A, B) {\n"
2124 verifyFormat("TESTSUITE(A) {\n"
2128 verifyFormat("TESTSUITE(A) {\n"
2134 verifyFormat("namespace A {\n"
2142 verifyFormat("TESTSUITE(A) {\n"
2148 verifyFormat("TESTSUITE(A) {\n"
2154 verifyFormat("namespace A {\n"
2164 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
2220 verifyFormat("namespace A { namespace B {\n"
2352 verifyFormat("extern \"C\" {\nint a;");
2353 verifyFormat("extern \"C\" {}");
2354 verifyFormat("extern \"C\" {\n"
2357 verifyFormat("extern \"C\" int foo() {}");
2358 verifyFormat("extern \"C\" int foo();");
2359 verifyFormat("extern \"C\" int foo() {\n"
2367 verifyFormat("extern \"C\" int foo() {}", Style);
2368 verifyFormat("extern \"C\" int foo();", Style);
2369 verifyFormat("extern \"C\" int foo()\n"
2378 verifyFormat("extern \"C\"\n"
2381 verifyFormat("extern \"C\"\n"
2389 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2390 verifyFormat("asm(\"nop\" ::: \"memory\");");
2391 verifyFormat(
2420 verifyFormat("void function() {\n"
2433 verifyFormat("try {\n"
2442 verifyFormat("int f() try { return 4; } catch (...) {\n"
2445 verifyFormat("class A {\n"
2458 verifyFormat("__try {\n"
2464 verifyFormat("__try {\n"
2470 verifyFormat("DEBUG({\n"
2478 verifyFormat("try {\n"
2483 verifyFormat("try {\n"
2497 verifyFormat("try {\n"
2505 verifyFormat("try {\n"
2512 verifyFormat("__try {\n"
2519 verifyFormat("@try {\n"
2527 verifyFormat("try\n"
2537 verifyFormat("try\n"
2547 verifyFormat("try\n"
2558 verifyFormat("try {\n"
2568 verifyFormat("static SomeClass SC = {1, 'a'};");
2570 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2575 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2589 verifyFormat("static int Variable[1] = {\n"
2595 verifyFormat("const struct A a = {.a = 1, .b = 2};");
2596 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2601 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2610 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2611 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2616 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2625 verifyFormat("static A x = {{{}}};\n");
2626 verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2630 verifyFormat("somes Status::global_reps[3] = {\n"
2639 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2643 verifyFormat(
2651 verifyFormat(
2660 verifyFormat("struct {\n"
2667 verifyFormat("struct {\n"
2679 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2685 verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2689 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2692 verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2698 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2700 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2716 verifyFormat("#\n;\n;\n;");
2733 verifyFormat("#define A \\x20");
2734 verifyFormat("#define A \\ x20");
2736 verifyFormat("#define A ''");
2737 verifyFormat("#define A ''qqq");
2738 verifyFormat("#define A `qqq");
2739 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
2745 verifyFormat("a\r\\");
2746 verifyFormat("a\v\\");
2747 verifyFormat("a\f\\");
2751 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2752 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12));
2753 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12));
2755 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12));
2757 verifyFormat("#define A A\n#define A A");
2758 verifyFormat("#define A(X) A\n#define A A");
2760 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2761 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));
2803 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11));
2804 verifyFormat("#define A \\\n"
2810 verifyFormat("#define A(X) \\\n"
2814 verifyFormat("#define A(a, b, c) \\\n"
2818 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
2827 verifyFormat("#define true ((foo)1)", Style);
2829 verifyFormat("#define false((foo)0)", Style);
2859 verifyFormat("#define SOMECASES \\\n"
2863 verifyFormat("#define MACRO(a) \\\n"
2869 verifyFormat("#define A template <typename T>");
2872 verifyFormat("#pragma omp threadprivate( \\\n"
2875 verifyFormat("#d, = };");
2876 verifyFormat("#if \"a");
2883 verifyFormat("#define A \\\n"
2897 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2937 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3099 verifyFormat("MACRO(>)");
3104 verifyFormat("FOO(a) int b = 0;");
3105 verifyFormat("FOO(a)\n"
3108 verifyFormat("FOO(a);\n"
3111 verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3114 verifyFormat("FOO()\n"
3117 verifyFormat("FOO\n"
3120 verifyFormat("void f() {\n"
3125 verifyFormat("FOO(a)\n"
3128 verifyFormat("int a = 0;\n"
3132 verifyFormat("int a = 0;\n"
3136 verifyFormat("void foo(int a) { FOO(a) }\n"
3142 verifyFormat("#define A \\\n"
3153 verifyFormat("#ifdef _WIN32\n"
3166 verifyFormat("#ifdef _WIN32\n"
3178 verifyFormat("#if A\n"
3190 verifyFormat("// file comment\n"
3198 verifyFormat("#ifndef HEADER_H\n"
3205 verifyFormat("#ifndef NOT_GUARD\n"
3212 verifyFormat("code();\n"
3219 verifyFormat("#ifndef NOT_GUARD\n"
3226 verifyFormat("#ifndef HEADER_H\n"
3232 verifyFormat("#ifndef NOT_GUARD\n"
3238 verifyFormat("#ifndef NOT_GUARD\n"
3245 verifyFormat("#ifndef FOO\n"
3250 verifyFormat("#ifndef FOO\n"
3259 verifyFormat("#if 1\n"
3400 verifyFormat("#ifdef _WIN32\n"
3415 verifyFormat("#ifndef HEADER_H\n"
3425 verifyFormat("#ifdef _WIN32\n"
3437 verifyFormat("#if A\n"
3513 verifyFormat("// Comment\n"
3521 verifyFormat("{\n { a #c; }\n}");
3592 verifyFormat("#define A \\\n"
3620 verifyFormat("functionCallTo(\n"
3630 verifyFormat("Foo::Foo()\n"
3636 verifyFormat("void f() {\n"
3646 verifyFormat("void f(param1, param2,\n"
3668 verifyFormat("#if 1\n"
3670 verifyFormat("#if 1\n"
3675 verifyFormat("DEBUG({\n"
3691 verifyFormat("#endif\n"
3698 verifyFormat("#if 0\n"
3708 verifyFormat("functionCall({ int i; });");
3709 verifyFormat("functionCall({\n"
3713 verifyFormat("functionCall(\n"
3719 verifyFormat("functionA(functionB({\n"
3724 verifyFormat("functionCall(\n"
3731 verifyFormat("functionA(functionB({\n"
3737 verifyFormat("functionCall(aaaa, bbbb, { int i; });");
3738 verifyFormat("functionCall(aaaa, bbbb, {\n"
3742 verifyFormat(
3749 verifyFormat("DEBUG({\n"
3762 verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
3770 verifyFormat("call(parameter, {\n"
3776 verifyFormat("DEBUG( //\n"
3778 verifyFormat("DEBUG( //\n"
3816 verifyFormat("DEBUG({\n"
3825 verifyFormat("Debug(\n"
3833 verifyFormat("SomeFunction({MACRO({ return output; }), b});");
3861 verifyFormat("enum E {};");
3862 verifyFormat("enum E {}");
3874 verifyFormat("FOO_BEGIN\n"
3878 verifyFormat("FOO_BEGIN\n"
3884 verifyFormat("FOO_BEGIN(Foo, Bar)\n"
3896 verifyFormat(
3902 verifyFormat(
3907 verifyFormat(
3912 verifyFormat(
3917 verifyFormat("int a = bbbb && ccc &&\n"
3924 verifyFormat(
3928 verifyFormat(
3933 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3936 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3939 verifyFormat(
3944 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3947 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3950 verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
3955 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3958 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3961 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3964 verifyFormat("b = a &&\n"
3970 verifyFormat(
3974 verifyFormat(
3978 verifyFormat(
3982 verifyFormat(
3988 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3992 verifyFormat(
4001 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4005 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4012 verifyFormat(
4018 verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4026 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4035 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4039 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4043 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4047 verifyFormat("if () {\n"
4051 verifyFormat("if () {\n"
4055 verifyFormat("if () {\n"
4059 verifyFormat("if () {\n"
4067 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4082 verifyFormat(
4093 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4098 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4103 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4108 verifyFormat("if () {\n"
4114 verifyFormat("return (a)\n"
4118 verifyFormat(
4124 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4129 verifyFormat(
4136 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4141 verifyFormat("zzzzzzzzzz\n"
4164 verifyFormat("bool x = aaaaa //\n"
4173 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4178 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4189 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4193 verifyFormat("int a = aa\n"
4199 verifyFormat("return (a > b\n"
4209 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4220 verifyFormat("void test() {\n"
4227 verifyFormat("void test() {\n"
4237 verifyFormat("void test() {\n"
4253 verifyFormat("void test() {\n"
4270 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4271 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4273 verifyFormat("Constructor()\n"
4276 verifyFormat("Constructor()\n"
4280 verifyFormat("template <typename T>\n"
4284 verifyFormat(
4288 verifyFormat(
4292 verifyFormat(
4296 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4300 verifyFormat("Constructor()\n"
4306 verifyFormat("Constructor()\n"
4310 verifyFormat("Constructor(int Parameter = 0)\n"
4313 verifyFormat("Constructor()\n"
4317 verifyFormat("Constructor()\n"
4323 verifyFormat("Constructor()\n"
4331 verifyFormat("SomeClass::Constructor()\n"
4336 verifyFormat("SomeClass::Constructor()\n"
4341 verifyFormat("MyClass::MyClass(int var)\n"
4346 verifyFormat("Constructor()\n"
4353 verifyFormat("Constructor()\n"
4358 verifyFormat(
4365 verifyFormat("Constructor()\n"
4393 verifyFormat("Constructor()\n"
4396 verifyFormat("Constructor() : a(a), b(b) {}", Style);
4399 verifyFormat("Constructor()\n"
4403 verifyFormat("Constructor() : a(a), b(b) {}", Style);
4407 verifyFormat("Constructor()\n"
4412 verifyFormat("Constructor()\n"
4419 verifyFormat("Constructor() :\n"
4424 verifyFormat("Constructor() :\n"
4436 verifyFormat("SomeClassWithALongName::Constructor(\n"
4443 verifyFormat("SomeClassWithALongName::Constructor(\n"
4452 verifyFormat("SomeClassWithALongName::Constructor(\n"
4462 verifyFormat("SomeClassWithALongName::Constructor(\n"
4469 verifyFormat("SomeClassWithALongName::Constructor(\n"
4478 verifyFormat("SomeClassWithALongName::Constructor(\n"
4487 verifyFormat("SomeClassWithALongName::Constructor(\n"
4494 verifyFormat("SomeClassWithALongName::Constructor(\n"
4503 verifyFormat("SomeClassWithALongName::Constructor(\n"
4521 verifyFormat("void foo() {\n"
4527 verifyFormat("void foo() {\n"
4535 verifyFormat("void foo() {\n"
4541 verifyFormat("void foo() {\n"
4553 verifyFormat("void FunctionCallWithReallyLongName(\n"
4557 verifyFormat("void FunctionCallWithReallyLongName(\n"
4567 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4568 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
4570 verifyFormat("Constructor() :\n"
4573 verifyFormat("Constructor() :\n"
4577 verifyFormat("template <typename T>\n"
4581 verifyFormat(
4587 verifyFormat(
4592 verifyFormat(
4597 verifyFormat(
4602 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4607 verifyFormat("Constructor() :\n"
4614 verifyFormat("Constructor() :\n"
4619 verifyFormat("Constructor(int Parameter = 0) :\n"
4623 verifyFormat("Constructor() :\n"
4627 verifyFormat("Constructor() :\n"
4634 verifyFormat("Constructor() :\n"
4643 verifyFormat("SomeClass::Constructor() :\n"
4648 verifyFormat("SomeClass::Constructor() :\n"
4653 verifyFormat("MyClass::MyClass(int var) :\n"
4658 verifyFormat("Constructor() :\n"
4665 verifyFormat("Constructor() :\n"
4670 verifyFormat("Constructor() :\n"
4676 verifyFormat("Constructor() :\n"
4690 verifyFormat("SomeClass::Constructor() :\n"
4693 verifyFormat("SomeClass::Constructor() noexcept :\n"
4696 verifyFormat("SomeClass::Constructor() :\n"
4699 verifyFormat("SomeClass::Constructor() :\n"
4707 verifyFormat("SomeClass::Constructor() :\n"
4711 verifyFormat("SomeClass::Constructor() :\n"
4719 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
4720 verifyFormat("SomeClass::Constructor() :\n"
4728 verifyFormat(
4734 verifyFormat(
4740 verifyFormat(
4754 verifyFormat(
4762 verifyFormat(
4769 verifyFormat(
4796 verifyFormat(
4827 verifyFormat(input, OnePerLine);
4832 verifyFormat(
4838 verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
4845 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
4847 verifyFormat("template <class TemplateIt>\n"
4852 verifyFormat(
4858 verifyFormat(
4864 verifyFormat(
4874 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
4879 verifyFormat(
4885 verifyFormat(
4893 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
4900 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4904 verifyFormat("void SomeLoooooooooooongFunction(\n"
4910 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
4912 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
4914 verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
4922 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4924 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
4937 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4940 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
4958 verifyFormat("auto foo() -> int;\n");
4960 verifyFormat("auto operator->() -> int;\n");
4961 verifyFormat("auto operator++(int) -> int;\n");
4963 verifyFormat("struct S {\n"
4966 verifyFormat("template <size_t Order, typename T>\n"
4969 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
4971 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
4972 verifyFormat("template <typename T>\n"
4977 verifyFormat("void f() { auto a = b->c(); }");
4985 verifyFormat("void someLongFunction(\n"
4988 verifyFormat("LoooooongReturnType\n"
4991 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
4994 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
4996 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
4998 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5000 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5007 verifyFormat("void someLongFunction(\n"
5010 verifyFormat("void someLongFunction(\n"
5013 verifyFormat("void someLongFunction(\n"
5016 verifyFormat("void someLongFunction(\n"
5019 verifyFormat("void someLongFunction(\n"
5022 verifyFormat("void someLongFunction(\n"
5025 verifyFormat("void someLongFunction(\n"
5030 verifyFormat("void someLongFunction(\n"
5037 verifyFormat("void someLongFunction(\n"
5044 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5050 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5052 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5054 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5058 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5060 verifyFormat(
5064 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5081 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5083 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5085 verifyFormat("template <typename T>\n"
5090 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5092 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5094 verifyFormat("MACRO(abc).function() // wrap\n"
5096 verifyFormat("MACRO(abc)->function() // wrap\n"
5098 verifyFormat("MACRO(abc)::function() // wrap\n"
5103 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5106 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5110 verifyFormat(
5114 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5118 verifyFormat(
5125 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5128 verifyFormat(
5133 verifyFormat(
5136 verifyFormat(
5139 verifyFormat(
5144 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5149 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5151 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5153 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5158 verifyFormat(
5164 verifyFormat("{\n {\n {\n"
5179 verifyFormat(
5189 verifyFormat("void f() {\n"
5194 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5200 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5207 verifyFormat(
5211 verifyFormat(
5221 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5225 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5229 verifyFormat(
5236 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5239 verifyFormat("void f() {\n"
5245 verifyFormat(
5250 verifyFormat(
5256 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5261 verifyFormat("a(\"a\"\n"
5266 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5270 verifyFormat(
5276 verifyFormat(
5307 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5315 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5317 verifyFormat("aaaaaaa->aaaaaaa\n"
5321 verifyFormat(
5325 verifyFormat(
5328 verifyFormat(
5349 verifyFormat(
5351 verifyFormat("aaaaaaaaaaaaaaa()\n"
5356 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5360 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5363 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5368 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5371 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5374 verifyFormat("aaa()\n"
5379 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5382 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5387 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5391 verifyFormat(
5395 verifyFormat(
5400 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5402 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5404 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5407 verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5411 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5416 verifyFormat("test() {\n"
5422 verifyFormat("test() {\n"
5431 verifyFormat("test() {\n"
5439 verifyFormat("test() {\n"
5451 verifyFormat(
5454 verifyFormat(
5458 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5460 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5463 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5465 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5468 verifyFormat(
5471 verifyFormat(
5475 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5479 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5484 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5487 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5493 verifyFormat(
5497 verifyFormat(
5501 verifyFormat(
5504 verifyFormat("unsigned OriginalStartColumn =\n"
5512 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5517 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5523 verifyFormat(
5526 verifyFormat(
5529 verifyFormat(
5532 verifyFormat(
5535 verifyFormat(
5542 verifyFormat(
5545 verifyFormat(
5548 verifyFormat(
5551 verifyFormat(
5554 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5556 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5559 verifyFormat("return\n"
5565 verifyFormat(
5568 verifyFormat(
5571 verifyFormat(
5576 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5579 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5582 verifyFormat("SomeLongVariableName->someFunction(\n"
5585 verifyFormat(
5589 verifyFormat(
5593 verifyFormat(
5598 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
5606 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5611 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5616 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
5621 verifyFormat(
5625 verifyFormat(
5629 verifyFormat(
5635 verifyFormat(
5645 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5650 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5655 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5660 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5666 verifyFormat(
5670 verifyFormat(
5674 verifyFormat(
5677 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
5680 verifyFormat(
5683 verifyFormat(
5688 verifyFormat(
5692 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5697 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5704 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5709 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5712 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
5716 verifyFormat(
5720 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
5724 verifyFormat("return aaaa == bbbb\n"
5728 verifyFormat("unsigned Indent =\n"
5735 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
5740 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
5745 verifyFormat(
5751 verifyFormat(
5758 verifyFormat(
5767 verifyFormat(
5776 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
5783 verifyFormat("return a != b\n"
5787 verifyFormat("return a != b\n"
5794 verifyFormat("return a != b\n"
5807 verifyFormat(
5812 verifyFormat(
5817 verifyFormat(
5821 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
5825 verifyFormat(
5829 verifyFormat(
5835 verifyFormat(
5840 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5846 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5854 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5860 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5864 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
5869 verifyFormat(
5874 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
5879 verifyFormat("unsigned Indent =\n"
5886 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
5892 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
5898 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5902 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5909 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
5911 verifyFormat("bool a = true, b = false;");
5913 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5917 verifyFormat(
5921 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
5923 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
5925 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
5931 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5935 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
5938 verifyFormat("vector<int*> a, b;", Style);
5939 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
5943 verifyFormat("arr[foo ? bar : baz];");
5944 verifyFormat("f()[foo ? bar : baz];");
5945 verifyFormat("(a + b)[foo ? bar : baz];");
5946 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
5950 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
5952 verifyFormat(
5956 verifyFormat("someFunction(\"Always break between multi-line\"\n"
5972 verifyFormat("a = a + \"a\"\n"
5975 verifyFormat("f(\"a\", \"b\"\n"
5978 verifyFormat(
5983 verifyFormat("#define A(X) \\\n"
5987 verifyFormat("#define A \"def\"\n"
5991 verifyFormat("f(L\"a\"\n"
5993 verifyFormat("#define A(X) \\\n"
5998 verifyFormat("f(@\"a\"\n"
6000 verifyFormat("NSString s = @\"a\"\n"
6003 verifyFormat("NSString s = @\"a\"\n"
6012 verifyFormat("class A {\n"
6024 verifyFormat("class E {\n"
6043 verifyFormat("class B {\n"
6057 verifyFormat("class C {\n"
6072 verifyFormat("class D {\n"
6085 verifyFormat("const char *\n"
6091 verifyFormat("template <class T>\n"
6098 verifyFormat("class C {\n"
6109 verifyFormat("void\n"
6116 verifyFormat("void *operator new(std::size_t s);", // No break here.
6118 verifyFormat("void *\n"
6121 verifyFormat("void *\n"
6125 verifyFormat("const char *\n"
6132 verifyFormat("template <class T>\n"
6140 verifyFormat("int\n"
6146 verifyFormat("int\n"
6152 verifyFormat("int\n"
6158 verifyFormat("int\n"
6164 verifyFormat("int\n"
6170 verifyFormat("int\n"
6180 verifyFormat("void\n"
6186 verifyFormat("void\n"
6193 verifyFormat("void foo (int a, int b); // def\n", Style);
6194 verifyFormat("void foo (int a, int b); /* def */\n", Style);
6195 verifyFormat("void foo (int a, int b);\n", Style);
6203 verifyFormat("aaaa = \"bbbb\"\n"
6206 verifyFormat("aaaa =\n"
6210 verifyFormat("aaaa(\"bbbb\"\n"
6213 verifyFormat("aaaa(\n"
6217 verifyFormat("aaaa(qqq, \"bbbb\"\n"
6220 verifyFormat("aaaa(qqq,\n"
6224 verifyFormat("aaaa(qqq,\n"
6228 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6231 verifyFormat("string s = someFunction(\n"
6237 verifyFormat("string foo = abc ? \"x\"\n"
6243 verifyFormat("f(\"aaaa\"\n"
6272 verifyFormat("const char *hello = \"hello llvm\";", Break);
6276 verifyFormat(
6280 verifyFormat(
6283 verifyFormat(
6286 verifyFormat(
6289 verifyFormat(
6293 verifyFormat(
6297 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6301 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
6303 verifyFormat(
6306 verifyFormat(
6310 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
6312 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6316 verifyFormat("LOG_IF(aaa == //\n"
6321 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6323 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
6326 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
6328 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6331 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6336 verifyFormat(
6345 verifyFormat("void f() {\n"
6351 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
6353 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
6356 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
6358 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
6360 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
6362 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
6366 verifyFormat("return out << \"somepacket = {\\n\"\n"
6373 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
6376 verifyFormat(
6382 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
6384 verifyFormat(
6391 verifyFormat(
6398 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
6406 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
6409 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
6412 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
6415 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
6418 verifyFormat(
6425 verifyFormat(
6428 verifyFormat(
6431 verifyFormat(
6438 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6443 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
6446 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
6449 verifyFormat(
6453 verifyFormat(
6458 verifyFormat("loooooooooooooongFunction(\n"
6461 verifyFormat(
6465 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
6467 verifyFormat("void f() {\n"
6472 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
6474 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6478 verifyFormat("void f() {\n"
6482 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6487 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6494 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
6496 verifyFormat(
6501 verifyFormat(
6504 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
6506 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
6509 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6515 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
6523 verifyFormat(
6527 verifyFormat(
6530 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6533 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6539 verifyFormat("template <typename T>\n"
6541 verifyFormat("template <typename T>\n"
6544 verifyFormat(
6547 verifyFormat("template <typename T>\n"
6550 verifyFormat(
6554 verifyFormat(
6559 verifyFormat("template <typename T>\n"
6562 verifyFormat(
6566 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
6570 verifyFormat(
6574 verifyFormat("void f() {\n"
6579 verifyFormat("template <typename T> class C {};");
6580 verifyFormat("template <typename T> void f();");
6581 verifyFormat("template <typename T> void f() {}");
6582 verifyFormat(
6599 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6604 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
6605 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
6606 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
6607 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6610 verifyFormat("template <template <typename> class Fooooooo,\n"
6614 verifyFormat("template <typename T> // T can be A, B or C.\n"
6617 verifyFormat("template <enum E> class A {\n"
6624 verifyFormat("template <typename T> class C {};", NeverBreak);
6625 verifyFormat("template <typename T> void f();", NeverBreak);
6626 verifyFormat("template <typename T> void f() {}", NeverBreak);
6627 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
6630 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6634 verifyFormat("template <template <typename> class Fooooooo,\n"
6638 verifyFormat("template <typename T> // T can be A, B or C.\n"
6641 verifyFormat("template <enum E> class A {\n"
6647 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
6707 verifyFormat(
6715 verifyFormat(
6723 verifyFormat("template <typename... a> struct s {};\n"
6733 verifyFormat("template <typename... a> struct t {};\n"
6744 verifyFormat(
6747 verifyFormat(
6753 verifyFormat(
6758 verifyFormat(
6763 verifyFormat(
6767 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
6773 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
6779 verifyFormat("A<int> a;");
6780 verifyFormat("A<A<A<int>>> a;");
6781 verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
6782 verifyFormat("bool x = a < 1 || 2 > a;");
6783 verifyFormat("bool x = 5 < f<int>();");
6784 verifyFormat("bool x = f<int>() > 5;");
6785 verifyFormat("bool x = 5 < a<int>::x;");
6786 verifyFormat("bool x = a < 4 ? a > 2 : false;");
6787 verifyFormat("bool x = f() ? a < 2 : a > 2;");
6806 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
6809 verifyFormat("bool b = a<1> > 1;");
6810 verifyFormat("bool b = a<1> >= 1;");
6811 verifyFormat("int i = a<1> >> 1;");
6814 verifyFormat("bool b= a<1> == 1;", Style);
6815 verifyFormat("a<int> = 1;", Style);
6816 verifyFormat("a<int> >>= 1;", Style);
6818 verifyFormat("test >> a >> b;");
6819 verifyFormat("test << a >> b;");
6821 verifyFormat("f<int>();");
6822 verifyFormat("template <typename T> void f() {}");
6823 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
6824 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
6826 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
6827 verifyFormat("f(a.operator()<A>());");
6828 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6833 verifyFormat("return a < b && c > d;");
6834 verifyFormat("void f() {\n"
6838 verifyFormat("template <typename... Types>\n"
6841 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6844 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
6845 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
6846 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
6862 verifyFormat("COMPARE(a, ==, b);");
6863 verifyFormat("auto s = sizeof...(Ts) - 1;");
6867 verifyFormat("int A::*x;");
6868 verifyFormat("int (S::*func)(void *);");
6869 verifyFormat("void f() { int (S::*func)(void *); }");
6870 verifyFormat("typedef bool *(Class::*Member)() const;");
6871 verifyFormat("void f() {\n"
6878 verifyFormat("void f() {\n"
6882 verifyFormat(
6887 verifyFormat("typedef bool* (Class::*Member)() const;", Style);
6891 verifyFormat("int a = -2;");
6892 verifyFormat("f(-1, -2, -3);");
6893 verifyFormat("a[-1] = 5;");
6894 verifyFormat("int a = 5 + -2;");
6895 verifyFormat("if (i == -1) {\n}");
6896 verifyFormat("if (i != -1) {\n}");
6897 verifyFormat("if (i > -1) {\n}");
6898 verifyFormat("if (i < -1) {\n}");
6899 verifyFormat("++(a->f());");
6900 verifyFormat("--(a->f());");
6901 verifyFormat("(a->f())++;");
6902 verifyFormat("a[42]++;");
6903 verifyFormat("if (!(a->f())) {\n}");
6904 verifyFormat("if (!+i) {\n}");
6905 verifyFormat("~&a;");
6907 verifyFormat("a-- > b;");
6908 verifyFormat("b ? -a : c;");
6909 verifyFormat("n * sizeof char16;");
6910 verifyFormat("n * alignof char16;", getGoogleStyle());
6911 verifyFormat("sizeof(char);");
6912 verifyFormat("alignof(char);", getGoogleStyle());
6914 verifyFormat("return -1;");
6915 verifyFormat("throw -1;");
6916 verifyFormat("switch (a) {\n"
6920 verifyFormat("#define X -1");
6921 verifyFormat("#define X -kConstant");
6923 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
6924 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
6926 verifyFormat("int a = /* confusing comment */ -1;");
6928 verifyFormat("int a = i /* confusing comment */++;");
6932 verifyFormat("if (!aaaaaaaaaa( // break\n"
6935 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
6937 verifyFormat("*aaa = aaaaaaa( // break\n"
6942 verifyFormat("bool operator<();");
6943 verifyFormat("bool operator>();");
6944 verifyFormat("bool operator=();");
6945 verifyFormat("bool operator==();");
6946 verifyFormat("bool operator!=();");
6947 verifyFormat("int operator+();");
6948 verifyFormat("int operator++();");
6949 verifyFormat("int operator++(int) volatile noexcept;");
6950 verifyFormat("bool operator,();");
6951 verifyFormat("bool operator();");
6952 verifyFormat("bool operator()();");
6953 verifyFormat("bool operator[]();");
6954 verifyFormat("operator bool();");
6955 verifyFormat("operator int();");
6956 verifyFormat("operator void *();");
6957 verifyFormat("operator SomeType<int>();");
6958 verifyFormat("operator SomeType<int, int>();");
6959 verifyFormat("operator SomeType<SomeType<int>>();");
6960 verifyFormat("void *operator new(std::size_t size);");
6961 verifyFormat("void *operator new[](std::size_t size);");
6962 verifyFormat("void operator delete(void *ptr);");
6963 verifyFormat("void operator delete[](void *ptr);");
6964 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
6966 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
6969 verifyFormat(
6972 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
6976 verifyFormat("SomeType &operator=(const SomeType &S);");
6977 verifyFormat("f.template operator()<int>();");
6983 verifyFormat("using A::operator+;");
6984 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
6989 verifyFormat("Deleted &operator=(const Deleted &) & = default;");
6990 verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
6991 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
6992 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
6993 verifyFormat("Deleted &operator=(const Deleted &) &;");
6994 verifyFormat("Deleted &operator=(const Deleted &) &&;");
6995 verifyFormat("SomeType MemberFunction(const Deleted &) &;");
6996 verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
6997 verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
6998 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
6999 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7000 verifyFormat("void Fn(T const &) const &;");
7001 verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7002 verifyFormat("template <typename T>\n"
7008 verifyFormat("void A::b() && {}", AlignLeft);
7009 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7010 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7012 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7013 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7014 verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7015 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7016 verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7017 verifyFormat("auto Function(T) & -> void;", AlignLeft);
7018 verifyFormat("void Fn(T const&) const&;", AlignLeft);
7019 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7023 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7024 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7025 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7026 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7030 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7031 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7033 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7034 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7039 verifyFormat("struct f {\n"
7045 verifyFormat("struct f {\n"
7051 verifyFormat("struct f {\n"
7057 verifyFormat("struct f {\n"
7063 verifyFormat("struct f {\n"
7074 verifyFormat("struct f {\n"
7080 verifyFormat("struct f {\n"
7086 verifyFormat("struct f {\n"
7092 verifyFormat("struct f {\n"
7098 verifyFormat("struct f {\n"
7106 verifyFormat("struct f {\n"
7113 verifyFormat("struct f {\n"
7120 verifyFormat("void (*foopt)(int) = &func;");
7124 verifyFormat("void f() {\n"
7130 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7132 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7135 verifyFormat("delete[] h->p;");
7139 verifyFormat("int *f(int *a) {}");
7140 verifyFormat("int main(int argc, char **argv) {}");
7141 verifyFormat("Test::Test(int b) : a(b * b) {}");
7143 verifyFormat("void g() { f(*a); }");
7180 verifyFormat("void f(Type (*parameter)[10]) {}");
7181 verifyFormat("void f(Type (¶meter)[10]) {}");
7185 verifyFormat("auto a = [](int **&, int ***) {};");
7186 verifyFormat("auto PointerBinding = [](const char *S) {};");
7187 verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7188 verifyFormat("[](const decltype(*a) &value) {}");
7189 verifyFormat("decltype(a * b) F();");
7190 verifyFormat("#define MACRO() [](A *a) { return 1; }");
7191 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7196 verifyFormat("Constructor() : a(a), area(width * height) {}");
7197 verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7199 verifyFormat("void f() { f(a, c * d); }");
7200 verifyFormat("void f() { f(new a(), c * d); }");
7201 verifyFormat("void f(const MyOverride &override);");
7202 verifyFormat("void f(const MyFinal &final);");
7216 verifyFormat("for (char **a = b; *a; ++a) {\n}");
7217 verifyFormat("for (; a && b;) {\n}");
7218 verifyFormat("bool foo = true && [] { return false; }();");
7220 verifyFormat(
7248 verifyFormat("x = *a(x) = *a(y);", Left);
7249 verifyFormat("for (;; *a = b) {\n}", Left);
7250 verifyFormat("return *this += 1;", Left);
7251 verifyFormat("throw *x;", Left);
7252 verifyFormat("delete *x;", Left);
7253 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
7254 verifyFormat("[](const decltype(*a)* ptr) {}", Left);
7255 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
7261 verifyFormat("void f() { &(*I).first; }");
7264 verifyFormat(
7285 verifyFormat("void f() {\n"
7289 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
7290 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
7293 verifyFormat("#define A (!a * b)");
7294 verifyFormat("#define MACRO \\\n"
7308 verifyFormat("STATIC_ASSERT((a & b) == 0);");
7309 verifyFormat("STATIC_ASSERT(0 == (a & b));");
7310 verifyFormat("template <bool a, bool b> "
7312 verifyFormat("template <int *y> f() {}");
7313 verifyFormat("vector<int *> v;");
7314 verifyFormat("vector<int *const> v;");
7315 verifyFormat("vector<int *const **const *> v;");
7316 verifyFormat("vector<int *volatile> v;");
7317 verifyFormat("vector<a * b> v;");
7318 verifyFormat("foo<b && false>();");
7319 verifyFormat("foo<b & 1>();");
7320 verifyFormat("decltype(*::std::declval<const T &>()) void F();");
7321 verifyFormat(
7327 verifyFormat("template <class T,\n"
7334 verifyFormat(
7346 verifyFormat("void f() { f(float{1}, a * a); }");
7350 verifyFormat("DatumHandle const *operator->() const { return input_; }");
7351 verifyFormat("return options != nullptr && operator==(*options);");
7365 verifyFormat("foo<a<b && c> d> v;");
7369 verifyFormat("delete *x;", PointerMiddle);
7370 verifyFormat("int * x;", PointerMiddle);
7371 verifyFormat("int *[] x;", PointerMiddle);
7372 verifyFormat("template <int * y> f() {}", PointerMiddle);
7373 verifyFormat("int * f(int * a) {}", PointerMiddle);
7374 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
7375 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
7376 verifyFormat("A<int *> a;", PointerMiddle);
7377 verifyFormat("A<int **> a;", PointerMiddle);
7378 verifyFormat("A<int *, int *> a;", PointerMiddle);
7379 verifyFormat("A<int *[]> a;", PointerMiddle);
7380 verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
7381 verifyFormat("A = new SomeType *[Length];", PointerMiddle);
7382 verifyFormat("T ** t = new T *;", PointerMiddle);
7385 verifyFormat("string // break\n"
7387 verifyFormat("string // break\n"
7394 verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
7395 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
7399 verifyFormat("__attribute__((nodebug)) void\n"
7405 verifyFormat("SomeType s [[unused]] (InitValue);");
7406 verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
7407 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
7408 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
7409 verifyFormat("void f() [[deprecated(\"so sorry\")]];");
7410 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7414 verifyFormat("int a() {}\n"
7416 verifyFormat("NSArray *arr;\n"
7420 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
7424 verifyFormat("@[ [foo bar] ];");
7425 verifyFormat("@[ [NSArray class] ];");
7426 verifyFormat("@[ [foo enum] ];");
7431 verifyFormat("[[unused]] int b() {\n"
7438 verifyFormat("int printf(const char *fmt, ...);");
7439 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
7440 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
7444 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
7481 verifyFormat("int f(int &&a) {}");
7482 verifyFormat("int f(int a, char &&b) {}");
7483 verifyFormat("void f() { int &&a = b; }");
7493 verifyFormat("template <bool B, bool C> class A {\n"
7498 verifyFormat("#define A(a, b) (a && b)");
7502 verifyFormat("void f() {\n"
7510 verifyFormat("Type *A = static_cast<Type *>(P);");
7511 verifyFormat("Type *A = (Type *)P;");
7512 verifyFormat("Type *A = (vector<Type *, int *>)P;");
7513 verifyFormat("int a = (int)(2.0f);");
7514 verifyFormat("int a = (int)2.0f;");
7515 verifyFormat("x[(int32)y];");
7516 verifyFormat("x = (int32)y;");
7517 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
7518 verifyFormat("int a = (int)*b;");
7519 verifyFormat("int a = (int)2.0f;");
7520 verifyFormat("int a = (int)~0;");
7521 verifyFormat("int a = (int)++a;");
7522 verifyFormat("int a = (int)sizeof(int);");
7523 verifyFormat("int a = (int)+2;");
7524 verifyFormat("my_int a = (my_int)2.0f;");
7525 verifyFormat("my_int a = (my_int)sizeof(int);");
7526 verifyFormat("return (my_int)aaa;");
7527 verifyFormat("#define x ((int)-1)");
7528 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
7529 verifyFormat("#define p(q) ((int *)&q)");
7530 verifyFormat("fn(a)(b) + 1;");
7532 verifyFormat("void f() { my_int a = (my_int)*b; }");
7533 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
7534 verifyFormat("my_int a = (my_int)~0;");
7535 verifyFormat("my_int a = (my_int)++a;");
7536 verifyFormat("my_int a = (my_int)-2;");
7537 verifyFormat("my_int a = (my_int)1;");
7538 verifyFormat("my_int a = (my_int *)1;");
7539 verifyFormat("my_int a = (const my_int)-1;");
7540 verifyFormat("my_int a = (const my_int *)-1;");
7541 verifyFormat("my_int a = (my_int)(my_int)-1;");
7542 verifyFormat("my_int a = (ns::my_int)-2;");
7543 verifyFormat("case (my_int)ONE:");
7544 verifyFormat("auto x = (X)this;");
7546 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
7549 verifyFormat("void f(int i = (kValue)*kMask) {}");
7551 verifyFormat("{ (void)F; }");
7554 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7559 verifyFormat("void f(int *) {}");
7560 verifyFormat("f(foo)->b;");
7561 verifyFormat("f(foo).b;");
7562 verifyFormat("f(foo)(b);");
7563 verifyFormat("f(foo)[b];");
7564 verifyFormat("[](foo) { return 4; }(bar);");
7565 verifyFormat("(*funptr)(foo)[4];");
7566 verifyFormat("funptrs[4](foo)[4];");
7567 verifyFormat("void f(int *);");
7568 verifyFormat("void f(int *) = 0;");
7569 verifyFormat("void f(SmallVector<int>) {}");
7570 verifyFormat("void f(SmallVector<int>);");
7571 verifyFormat("void f(SmallVector<int>) = 0;");
7572 verifyFormat("void f(int i = (kA * kB) & kMask) {}");
7573 verifyFormat("int a = sizeof(int) * b;");
7574 verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
7575 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
7576 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
7577 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
7580 verifyFormat("virtual void foo(int *) override;");
7581 verifyFormat("virtual void foo(char &) const;");
7582 verifyFormat("virtual void foo(int *a, char *) const;");
7583 verifyFormat("int a = sizeof(int *) + b;");
7584 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
7585 verifyFormat("bool b = f(g<int>) && c;");
7586 verifyFormat("typedef void (*f)(int i) func;");
7587 verifyFormat("void operator++(int) noexcept;");
7588 verifyFormat("void operator++(int &) noexcept;");
7589 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
7591 verifyFormat(
7593 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
7594 verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
7595 verifyFormat("void operator delete(nothrow_t &) noexcept;");
7596 verifyFormat("void operator delete(foo &) noexcept;");
7597 verifyFormat("void operator delete(foo) noexcept;");
7598 verifyFormat("void operator delete(int) noexcept;");
7599 verifyFormat("void operator delete(int &) noexcept;");
7600 verifyFormat("void operator delete(int &) volatile noexcept;");
7601 verifyFormat("void operator delete(int &) const");
7602 verifyFormat("void operator delete(int &) = default");
7603 verifyFormat("void operator delete(int &) = delete");
7604 verifyFormat("void operator delete(int &) [[noreturn]]");
7605 verifyFormat("void operator delete(int &) throw();");
7606 verifyFormat("void operator delete(int &) throw(int);");
7607 verifyFormat("auto operator delete(int &) -> int;");
7608 verifyFormat("auto operator delete(int &) override");
7609 verifyFormat("auto operator delete(int &) final");
7611 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
7614 verifyFormat(
7621 verifyFormat("A<bool()> a;");
7622 verifyFormat("A<SomeType()> a;");
7623 verifyFormat("A<void (*)(int, std::string)> a;");
7624 verifyFormat("A<void *(int)>;");
7625 verifyFormat("void *(*a)(int *, SomeType *);");
7626 verifyFormat("int (*func)(void *);");
7627 verifyFormat("void f() { int (*func)(void *); }");
7628 verifyFormat("template <class CallbackClass>\n"
7638 verifyFormat("A<sizeof(*x)> a;");
7639 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
7640 verifyFormat("some_var = function(*some_pointer_var)[0];");
7641 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
7642 verifyFormat("int x = f(&h)();");
7643 verifyFormat("returnsFunction(¶m1, ¶m2)(param);");
7644 verifyFormat("std::function<\n"
7653 verifyFormat("A (*foo_)[6];");
7654 verifyFormat("vector<int> (*foo_)[6];");
7658 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7660 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
7662 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7666 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7668 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7670 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7672 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7676 verifyFormat("LooooooooooooooooongType\n"
7682 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
7684 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
7686 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7688 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
7690 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7692 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
7694 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
7696 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
7698 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7700 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7704 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7707 verifyFormat(
7711 verifyFormat(
7715 verifyFormat(
7721 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n"
7725 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
7727 verifyFormat(
7731 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
7738 verifyFormat("template <typename A>\n"
7760 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7763 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7766 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7771 verifyFormat("template <typename T> // Templates on own line.\n"
7778 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
7780 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
7782 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
7784 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7786 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7788 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7791 verifyFormat(
7795 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
7800 verifyFormat(
7804 verifyFormat("a[::b::c];");
7809 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
7813 verifyFormat("(a)->b();");
7814 verifyFormat("--a;");
7818 verifyFormat("#include <string>\n"
7834 verifyFormat("#import <string>");
7835 verifyFormat("#import <a/b/c.h>");
7836 verifyFormat("#import \"a/b/string\"");
7837 verifyFormat("#import \"string.h\"");
7838 verifyFormat("#import \"string.h\"");
7839 verifyFormat("#if __has_include(<strstream>)\n"
7843 verifyFormat("#define MY_IMPORT <a/b>");
7845 verifyFormat("#if __has_include(<a/b>)");
7846 verifyFormat("#if __has_include_next(<a/b>)");
7847 verifyFormat("#define F __has_include(<a/b>)");
7848 verifyFormat("#define F __has_include_next(<a/b>)");
7851 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
7857 verifyFormat("#import \"abc.h\"", Style);
7860 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7871 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
7882 verifyFormat("void f() { return; }\n42");
7883 verifyFormat("void f() {\n"
7888 verifyFormat("void f() { return }\n42");
7889 verifyFormat("void f() {\n"
7915 verifyFormat("int aaaaaaaa =\n"
7919 verifyFormat("function(\n"
7926 verifyFormat("public:");
7927 verifyFormat("class A {\n"
7931 verifyFormat("public\n"
7933 verifyFormat("public\n"
7935 verifyFormat("public\n"
7937 verifyFormat("public\n"
7942 verifyFormat("{");
7943 verifyFormat("#})");
7960 verifyFormat("do {\n}");
7961 verifyFormat("do {\n}\n"
7963 verifyFormat("do {\n}\n"
7965 verifyFormat("do {\n"
7971 verifyFormat("if {\n foo;\n foo();\n}");
7972 verifyFormat("switch {\n foo;\n foo();\n}");
7974 verifyFormat("while {\n foo;\n foo();\n}");
7975 verifyFormat("do {\n foo;\n foo();\n} while;");
8004 verifyFormat("int x = {\n"
8011 verifyFormat("return (a)(b){1, 2, 3};");
8015 verifyFormat("vector<int> x{1, 2, 3, 4};");
8016 verifyFormat("vector<int> x{\n"
8022 verifyFormat("vector<T> x{{}, {}, {}, {}};");
8023 verifyFormat("f({1, 2});");
8024 verifyFormat("auto v = Foo{-1};");
8025 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
8026 verifyFormat("Class::Class : member{1, 2, 3} {}");
8027 verifyFormat("new vector<int>{1, 2, 3};");
8028 verifyFormat("new int[3]{1, 2, 3};");
8029 verifyFormat("new int{1};");
8030 verifyFormat("return {arg1, arg2};");
8031 verifyFormat("return {arg1, SomeType{parameter}};");
8032 verifyFormat("int count = set<int>{f(), g(), h()}.size();");
8033 verifyFormat("new T{arg1, arg2};");
8034 verifyFormat("f(MyMap[{composite, key}]);");
8035 verifyFormat("class Class {\n"
8038 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
8039 verifyFormat("const struct A a = {.a = 1, .b = 2};");
8040 verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
8041 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
8042 verifyFormat("int a = std::is_integral<int>{} + 0;");
8044 verifyFormat("int foo(int i) { return fo1{}(i); }");
8045 verifyFormat("int foo(int i) { return fo1{}(i); }");
8046 verifyFormat("auto i = decltype(x){};");
8047 verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
8048 verifyFormat("Node n{1, Node{1000}, //\n"
8050 verifyFormat("Aaaa aaaaaaa{\n"
8055 verifyFormat("class C : public D {\n"
8058 verifyFormat("class C : public A {\n"
8063 verifyFormat("#define A {a, a},");
8068 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
8075 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
8078 verifyFormat("const Aaaaaa aaaaa = {\n"
8087 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
8088 verifyFormat("void f() {\n"
8092 verifyFormat("void f() {\n"
8102 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
8114 verifyFormat("const Aaaaaa aaaaa = {\n"
8128 verifyFormat(
8148 verifyFormat("Constructor::Constructor()\n"
8188 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
8189 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
8190 verifyFormat("f({ 1, 2 });", ExtraSpaces);
8191 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
8192 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
8193 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
8194 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
8195 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
8196 verifyFormat("return { arg1, arg2 };", ExtraSpaces);
8197 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
8198 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
8199 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
8200 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
8201 verifyFormat("class Class {\n"
8205 verifyFormat(
8211 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
8212 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
8214 verifyFormat(
8221 verifyFormat(
8225 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
8238 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
8239 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
8240 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
8244 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
8250 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
8259 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
8260 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
8266 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
8267 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
8268 verifyFormat("vector< int > x{ // comment 1\n"
8286 verifyFormat("vector< int > x{};", SpaceBetweenBraces);
8288 verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
8292 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8298 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
8303 verifyFormat(
8311 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
8314 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
8318 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
8322 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
8325 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
8328 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
8331 verifyFormat(
8335 verifyFormat("static auto fields = new vector<string>{\n"
8344 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
8345 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
8351 verifyFormat("vector<int> x = {\n"
8355 verifyFormat("vector<int> x = {\n"
8359 verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
8365 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n"
8370 verifyFormat("int aaaaa[] = {\n"
8378 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
8383 verifyFormat(
8394 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
8400 verifyFormat("void f() {\n"
8406 verifyFormat(
8416 verifyFormat("std::vector<int> a = {\n"
8425 verifyFormat("vector<int> aaaa = {\n"
8435 verifyFormat("someFunction(Param, {List1, List2,\n"
8438 verifyFormat("someFunction(Param, Param,\n"
8442 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
8450 verifyFormat("void f() { return 42; }");
8451 verifyFormat("void f() {\n"
8455 verifyFormat("void f() {\n"
8458 verifyFormat("{\n"
8462 verifyFormat("{\n"
8466 verifyFormat("void f() {} // comment");
8467 verifyFormat("void f() { int a; } // comment");
8468 verifyFormat("void f() {\n"
8471 verifyFormat("void f() {\n"
8475 verifyFormat("void f() {\n"
8479 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
8480 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22));
8482 verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
8483 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
8484 verifyFormat("class C {\n"
8517 verifyFormat("#define A \\\n"
8522 verifyFormat("#define A \\\n"
8525 verifyFormat("#define A \\\n"
8531 verifyFormat("#define A \\\n"
8540 verifyFormat("class C {\n"
8544 verifyFormat("class C {\n"
8550 verifyFormat("int f() {}", MergeEmptyOnly);
8551 verifyFormat("int f() {\n"
8559 verifyFormat("int f() {}", MergeEmptyOnly);
8560 verifyFormat("class C {\n"
8569 verifyFormat("class C {\n"
8573 verifyFormat("int f() {\n"
8579 verifyFormat("class C {\n"
8583 verifyFormat("int f() {}", MergeInlineOnly);
8588 verifyFormat("class C {\n"
8592 verifyFormat("int f()\n"
8599 verifyFormat("int f() {}", MergeInlineOnly);
8600 verifyFormat("class C {\n"
8610 verifyFormat("class C {\n"
8614 verifyFormat("int f() {\n"
8620 verifyFormat("class C {\n"
8624 verifyFormat("int f() {\n"
8631 verifyFormat("class C {\n"
8635 verifyFormat("int f()\n"
8642 verifyFormat("int f()\n"
8646 verifyFormat("class C {\n"
8660 verifyFormat("int f()\n"
8663 verifyFormat("int f()\n"
8668 verifyFormat("int f()\n"
8675 verifyFormat("int f() {}", Style);
8676 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
8679 verifyFormat("int f()\n"
8686 verifyFormat("class Foo {\n"
8690 verifyFormat("class Foo {\n"
8694 verifyFormat("class Foo {\n"
8699 verifyFormat("class Foo {\n"
8708 verifyFormat("int f() {}", Style);
8709 verifyFormat("int f() { return 0; }", Style);
8710 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
8713 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
8722 verifyFormat("#ifdef A\n"
8736 verifyFormat("class Foo\n"
8739 verifyFormat("/* something */ class Foo\n"
8742 verifyFormat("template <typename X> class Foo\n"
8745 verifyFormat("class Foo\n"
8750 verifyFormat("typedef class Foo\n"
8762 verifyFormat("struct Foo\n"
8765 verifyFormat("/* something */ struct Foo\n"
8768 verifyFormat("template <typename X> struct Foo\n"
8771 verifyFormat("struct Foo\n"
8776 verifyFormat("typedef struct Foo\n"
8789 verifyFormat("union Foo\n"
8792 verifyFormat("/* something */ union Foo\n"
8795 verifyFormat("union Foo\n"
8800 verifyFormat("typedef union Foo\n"
8812 verifyFormat("namespace Foo\n"
8815 verifyFormat("/* something */ namespace Foo\n"
8818 verifyFormat("inline namespace Foo\n"
8821 verifyFormat("/* something */ inline namespace Foo\n"
8824 verifyFormat("export namespace Foo\n"
8827 verifyFormat("namespace Foo\n"
8837 verifyFormat("class Foo {\n"
8841 verifyFormat("typedef class Foo {\n"
8845 verifyFormat("struct Foo {\n"
8849 verifyFormat("typedef struct Foo {\n"
8853 verifyFormat("union Foo {\n"
8857 verifyFormat("typedef union Foo {\n"
8861 verifyFormat("namespace Foo {\n"
8871 verifyFormat("class Foo\n"
8876 verifyFormat("typedef class Foo\n"
8881 verifyFormat("struct Foo\n"
8886 verifyFormat("typedef struct Foo\n"
8891 verifyFormat("union Foo\n"
8896 verifyFormat("typedef union Foo\n"
8901 verifyFormat("namespace Foo\n"
8910 verifyFormat("struct foo a = {bar};\nint n;");
8911 verifyFormat("class foo a = {bar};\nint n;");
8912 verifyFormat("union foo a = {bar};\nint n;");
8915 verifyFormat("struct foo f() {}\nint n;");
8916 verifyFormat("class foo f() {}\nint n;");
8917 verifyFormat("union foo f() {}\nint n;");
8920 verifyFormat("template <class X> void f() {}\nint n;");
8921 verifyFormat("template <struct X> void f() {}\nint n;");
8922 verifyFormat("template <union X> void f() {}\nint n;");
8925 verifyFormat("struct {\n} n;");
8926 verifyFormat(
8928 verifyFormat("union Z {\n int n;\n} x;");
8929 verifyFormat("class MACRO Z {\n} n;");
8930 verifyFormat("class MACRO(X) Z {\n} n;");
8931 verifyFormat("class __attribute__(X) Z {\n} n;");
8932 verifyFormat("class __declspec(X) Z {\n} n;");
8933 verifyFormat("class A##B##C {\n} n;");
8934 verifyFormat("class alignas(16) Z {\n} n;");
8935 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
8936 verifyFormat("class MACROA MACRO(X) Z {\n} n;");
8939 verifyFormat("class A::B::C {\n} n;");
8942 verifyFormat(
8950 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
8951 verifyFormat("int i = SomeFunction(a<b, a> b);");
8959 verifyFormat("if (true)\n"
8965 verifyFormat("class A:");
8979 verifyFormat("#if AAAA && BBBB");
8980 verifyFormat("#if (AAAA && BBBB)");
8981 verifyFormat("#elif (AAAA && BBBB)");
8983 verifyFormat(
8996 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
8997 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
8998 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);
9003 verifyFormat("#define A \\\n"
9006 verifyFormat("#define A \\\n"
9011 verifyFormat("#define A \\\n"
9016 verifyFormat("{\n"
9026 verifyFormat("#define A \\\n"
9029 verifyFormat("#define A \\\n"
9033 verifyFormat("#define A \\\n"
9038 verifyFormat("#define A \\\n"
9043 verifyFormat("#define A \\\n"
9048 verifyFormat("#define A \\\n"
9056 verifyFormat("void f(int *a);");
9057 verifyFormat("void f() { f(fint * b); }");
9058 verifyFormat("class A {\n void f(int *a);\n};");
9059 verifyFormat("class A {\n int *a;\n};");
9060 verifyFormat("namespace a {\n"
9071 verifyFormat("while");
9072 verifyFormat("operator");
9104 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
9123 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
9125 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
9143 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9149 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9155 verifyFormat("- (int)sum:(vector<int>)numbers;");
9161 verifyFormat("- (int (*)())foo:(int (*)())f;");
9166 verifyFormat("- foo;");
9167 verifyFormat("- foo:(int)f;");
9257 verifyFormat(
9373 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
9579 verifyFormat("string a = \"unterminated;");
9596 verifyFormat("void foo() { MACRO(a * b); }", Style);
9597 verifyFormat("void foo() { MACRO(int *b); }", Style);
9600 verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
9603 verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
9606 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
9691 verifyFormat("void f() {\n"
9694 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
9700 verifyFormat(
9705 verifyFormat("class X {\n"
9716 verifyFormat("void f() {\n"
9723 verifyFormat("class X {\n"
9728 verifyFormat("int x[] = {\n"
9735 verifyFormat("double\n"
9759 verifyFormat("class X {\n"
9766 verifyFormat("#define A \\\n"
9773 verifyFormat("int a;\t // x\n"
9779 verifyFormat("class TabWidth4Indent8 {\n"
9789 verifyFormat("class TabWidth4Indent4 {\n"
9799 verifyFormat("class TabWidth8Indent4 {\n"
9820 verifyFormat("{\n"
9829 verifyFormat("enum AA {\n"
9842 verifyFormat("class X {\n"
9849 verifyFormat("{\n"
9982 verifyFormat("class X {\n"
9989 verifyFormat("#define A \\\n"
9998 verifyFormat("class TabWidth4Indent8 {\n"
10007 verifyFormat("class TabWidth4Indent4 {\n"
10016 verifyFormat("class TabWidth8Indent4 {\n"
10034 verifyFormat("{\n"
10043 verifyFormat("enum AA {\n"
10056 verifyFormat("class X {\n"
10063 verifyFormat("{\n"
10181 verifyFormat("class Assign {\n"
10302 verifyFormat("while(true)\n"
10305 verifyFormat("for(;;)\n"
10308 verifyFormat("if(true)\n"
10313 verifyFormat("do {\n"
10317 verifyFormat("switch(x) {\n"
10322 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
10323 verifyFormat("size_t x = sizeof(x);", NoSpace);
10324 verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
10325 verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
10326 verifyFormat("alignas(128) char a[128];", NoSpace);
10327 verifyFormat("size_t x = alignof(MyType);", NoSpace);
10328 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
10329 verifyFormat("int f() throw(Deprecated);", NoSpace);
10330 verifyFormat("typedef void (*cb)(int);", NoSpace);
10331 verifyFormat("T A::operator()();", NoSpace);
10332 verifyFormat("X A::operator++(T);", NoSpace);
10333 verifyFormat("auto lambda = []() { return 0; };", NoSpace);
10338 verifyFormat("int f ();", Space);
10339 verifyFormat("void f (int a, T b) {\n"
10344 verifyFormat("if (true)\n"
10349 verifyFormat("do {\n"
10353 verifyFormat("switch (x) {\n"
10358 verifyFormat("A::A () : a (1) {}", Space);
10359 verifyFormat("void f () __attribute__ ((asdf));", Space);
10360 verifyFormat("*(&a + 1);\n"
10365 verifyFormat("#define A(x) x", Space);
10366 verifyFormat("#define A (x) x", Space);
10367 verifyFormat("#if defined(x)\n"
10370 verifyFormat("auto i = std::make_unique<int> (5);", Space);
10371 verifyFormat("size_t x = sizeof (x);", Space);
10372 verifyFormat("auto f (int x) -> decltype (x);", Space);
10373 verifyFormat("int f (T x) noexcept (x.create ());", Space);
10374 verifyFormat("alignas (128) char a[128];", Space);
10375 verifyFormat("size_t x = alignof (MyType);", Space);
10376 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
10377 verifyFormat("int f () throw (Deprecated);", Space);
10378 verifyFormat("typedef void (*cb) (int);", Space);
10379 verifyFormat("T A::operator() ();", Space);
10380 verifyFormat("X A::operator++ (T);", Space);
10381 verifyFormat("auto lambda = [] () { return 0; };", Space);
10382 verifyFormat("int x = int (y);", Space);
10387 verifyFormat("[]() -> float {}", SomeSpace);
10388 verifyFormat("[] (auto foo) {}", SomeSpace);
10389 verifyFormat("[foo]() -> int {}", SomeSpace);
10390 verifyFormat("int f();", SomeSpace);
10391 verifyFormat("void f (int a, T b) {\n"
10396 verifyFormat("if (true)\n"
10401 verifyFormat("do {\n"
10405 verifyFormat("switch (x) {\n"
10410 verifyFormat("A::A() : a (1) {}", SomeSpace);
10411 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
10412 verifyFormat("*(&a + 1);\n"
10417 verifyFormat("#define A(x) x", SomeSpace);
10418 verifyFormat("#define A (x) x", SomeSpace);
10419 verifyFormat("#if defined(x)\n"
10422 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
10423 verifyFormat("size_t x = sizeof (x);", SomeSpace);
10424 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
10425 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
10426 verifyFormat("alignas (128) char a[128];", SomeSpace);
10427 verifyFormat("size_t x = alignof (MyType);", SomeSpace);
10428 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
10430 verifyFormat("int f() throw (Deprecated);", SomeSpace);
10431 verifyFormat("typedef void (*cb) (int);", SomeSpace);
10432 verifyFormat("T A::operator()();", SomeSpace);
10433 verifyFormat("X A::operator++ (T);", SomeSpace);
10434 verifyFormat("int x = int (y);", SomeSpace);
10435 verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
10442 verifyFormat("bool x = ! y", Spaces);
10443 verifyFormat("if (! isFailure())", Spaces);
10444 verifyFormat("if (! (a && b))", Spaces);
10445 verifyFormat("\"Error!\"", Spaces);
10446 verifyFormat("! ! x", Spaces);
10453 verifyFormat("do_something( ::globalVar );", Spaces);
10454 verifyFormat("call( x, y, z );", Spaces);
10455 verifyFormat("call();", Spaces);
10456 verifyFormat("std::function<void( int, int )> callback;", Spaces);
10457 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
10459 verifyFormat("while ( (bool)1 )\n"
10462 verifyFormat("for ( ;; )\n"
10465 verifyFormat("if ( true )\n"
10470 verifyFormat("do {\n"
10474 verifyFormat("switch ( x ) {\n"
10482 verifyFormat("Type *A = ( Type * )P;", Spaces);
10483 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
10484 verifyFormat("x = ( int32 )y;", Spaces);
10485 verifyFormat("int a = ( int )(2.0f);", Spaces);
10486 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
10487 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
10488 verifyFormat("#define x (( int )-1)", Spaces);
10494 verifyFormat("call(x, y, z);", Spaces);
10495 verifyFormat("call( );", Spaces);
10496 verifyFormat("std::function<void(int, int)> callback;", Spaces);
10497 verifyFormat("while (( bool )1)\n"
10500 verifyFormat("for (;;)\n"
10503 verifyFormat("if (true)\n"
10508 verifyFormat("do {\n"
10512 verifyFormat("switch (x) {\n"
10520 verifyFormat("call(x, y, z);", Spaces);
10521 verifyFormat("call( );", Spaces);
10522 verifyFormat("std::function<void(int, int)> callback;", Spaces);
10523 verifyFormat("while (( bool ) 1)\n"
10526 verifyFormat("for (;;)\n"
10529 verifyFormat("if (true)\n"
10534 verifyFormat("do {\n"
10538 verifyFormat("switch (x) {\n"
10547 verifyFormat("while ((bool) 1)\n"
10550 verifyFormat("do {\n"
10557 verifyFormat("int a[5];");
10558 verifyFormat("a[3] += 42;");
10563 verifyFormat("int a[ 5 ];", Spaces);
10564 verifyFormat("a[ 3 ] += 42;", Spaces);
10565 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
10566 verifyFormat("double &operator[](int i) { return 0; }\n"
10569 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
10570 verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
10571 verifyFormat("int i = (*b)[ a ]->f();", Spaces);
10573 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
10574 verifyFormat("return [ i, args... ] {};", Spaces);
10578 verifyFormat("int a = 5;");
10579 verifyFormat("a += 42;");
10580 verifyFormat("a or_eq 8;");
10584 verifyFormat("int a= 5;", Spaces);
10585 verifyFormat("a+= 42;", Spaces);
10586 verifyFormat("a or_eq 8;", Spaces);
10590 verifyFormat("class Foo : public Bar {};");
10591 verifyFormat("Foo::Foo() : foo(1) {}");
10592 verifyFormat("for (auto a : b) {\n}");
10593 verifyFormat("int x = a ? b : c;");
10594 verifyFormat("{\n"
10598 verifyFormat("switch (x) {\n"
10605 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
10606 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
10607 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
10608 verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
10609 verifyFormat("{\n"
10614 verifyFormat("switch (x) {\n"
10621 verifyFormat("Fooooooooooo::Fooooooooooo():\n"
10627 verifyFormat("Fooooooooooo::Fooooooooooo()\n"
10633 verifyFormat("Fooooooooooo::Fooooooooooo()\n"
10638 verifyFormat("Fooooooooooo::Fooooooooooo()\n"
10645 verifyFormat("class Foo: public Bar {};", InheritanceStyle);
10646 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
10647 verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
10648 verifyFormat("int x = a ? b : c;", InheritanceStyle);
10649 verifyFormat("{\n"
10654 verifyFormat("switch (x) {\n"
10660 verifyFormat("class Foooooooooooooooooooooo:\n"
10666 verifyFormat("class Foooooooooooooooooooooo\n"
10672 verifyFormat("class Foooooooooooooooooooooo\n"
10678 verifyFormat("class Foooooooooooooooooooooo\n"
10685 verifyFormat("class Foo : public Bar {};", ForLoopStyle);
10686 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
10687 verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
10688 verifyFormat("int x = a ? b : c;", ForLoopStyle);
10689 verifyFormat("{\n"
10694 verifyFormat("switch (x) {\n"
10704 verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
10705 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
10706 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
10707 verifyFormat("int x = a ? b : c;", NoSpaceStyle);
10708 verifyFormat("{\n"
10713 verifyFormat("switch (x) {\n"
10726 verifyFormat("#define a 3\n"
10731 verifyFormat("#define f(x) (x * x)\n"
10736 verifyFormat("#define foo(x, y) (x + y)\n"
10740 verifyFormat("#define a 3\n"
10749 verifyFormat("#define a 3\n"
10754 verifyFormat("#define f(x) (x * x)\n"
10759 verifyFormat("#define foo(x, y) (x + y)\n"
10763 verifyFormat("#define a 3\n"
10771 verifyFormat("#define a 5\n"
10791 verifyFormat("#define a \\\n"
10803 verifyFormat("#define a \\\n"
10819 verifyFormat("int a = 5;\n"
10822 verifyFormat("int a = 5;\n"
10827 verifyFormat("int a = 5;\n"
10830 verifyFormat("int a = method();\n"
10833 verifyFormat("a &= 5;\n"
10843 verifyFormat("int i = 1, j = 10;\n"
10846 verifyFormat("something = 2000;\n"
10849 verifyFormat("something = 2000;\n"
10855 verifyFormat("int a = 5;\n"
10861 verifyFormat("int oneTwoThree = 123;\n"
10865 verifyFormat("int oneTwoThree = 123; // comment\n"
10896 verifyFormat("#define A \\\n"
10903 verifyFormat("#define A \\\n"
10910 verifyFormat("#define A "
10920 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
10927 verifyFormat("void SomeFunction(int parameter = 0) {\n"
10933 verifyFormat("class C {\n"
10939 verifyFormat("int i = 1;\n"
10945 verifyFormat("int j = 7;\n"
10953 verifyFormat("int i = 1;\n"
10959 verifyFormat("int i = 1;\n"
10965 verifyFormat("auto lambda = []() {\n"
10977 verifyFormat(
10984 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
10989 verifyFormat("int a, b = 1;\n"
10993 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
10996 verifyFormat("for (int i = 0; i < 1; i++)\n"
10999 verifyFormat("for (i = 0; i < 1; i++)\n"
11009 verifyFormat("float const a = 5;\n"
11012 verifyFormat("int a = 5;\n"
11017 verifyFormat("float const a = 5;\n"
11020 verifyFormat("int a = method();\n"
11023 verifyFormat("int i = 1, j = 10;\n"
11026 verifyFormat("something = 2000;\n"
11029 verifyFormat("float something = 2000;\n"
11035 verifyFormat("float a = 5;\n"
11041 verifyFormat("int oneTwoThree{0}; // comment\n"
11072 verifyFormat("int a();\n"
11075 verifyFormat("int a(int x);\n"
11104 verifyFormat("int function(\n"
11110 verifyFormat("int a(int x, void (*fp)(int y));\n"
11117 verifyFormat("int func(int a = 1) {\n"
11122 verifyFormat("float something = 2000;\n"
11128 verifyFormat("int oneTwoThree = {0}; // comment\n"
11132 verifyFormat("for (int i = 0; i < n; i++)\n"
11136 verifyFormat("if (int i = 0)\n"
11141 verifyFormat("struct test {\n"
11147 verifyFormat("struct test {\n"
11178 verifyFormat("#define A \\\n"
11185 verifyFormat("#define A \\\n"
11193 verifyFormat("#define A \\\n"
11200 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
11207 verifyFormat("void SomeFunction(int parameter = 0) {\n"
11213 verifyFormat("class C {\n"
11219 verifyFormat("float i = 1;\n"
11225 verifyFormat("float j = 7;\n"
11233 verifyFormat("float i = 1;\n"
11239 verifyFormat("int i = 1;\n"
11246 verifyFormat("auto lambda = []() {\n"
11261 verifyFormat(
11274 verifyFormat("float ii = 1;\n"
11284 verifyFormat(
11289 verifyFormat("float a, b = 1;\n"
11293 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
11297 verifyFormat("float a, b = 1;\n"
11301 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
11308 verifyFormat("void foo(float a,\n"
11326 verifyFormat(
11336 verifyFormat("int func() { //\n"
11353 verifyFormat("namespace a\n"
11373 verifyFormat("enum X {\n"
11377 verifyFormat("struct S {\n"
11395 verifyFormat("namespace a {\n"
11420 verifyFormat("struct S\n"
11439 verifyFormat("namespace a {\n"
11456 verifyFormat("void foo()\n"
11467 verifyFormat("#ifdef _DEBUG\n"
11477 verifyFormat("void foo() {}\n"
11489 verifyFormat("void foobar() { int i = 5; }\n"
11514 verifyFormat("namespace a\n"
11538 verifyFormat("void f()\n"
11555 verifyFormat("void f()\n"
11572 verifyFormat("void f(int a)\n"
11592 verifyFormat("enum X\n"
11597 verifyFormat("enum X\n"
11603 verifyFormat("@interface BSApplicationController ()\n"
11611 verifyFormat("#ifdef _DEBUG\n"
11621 verifyFormat("void foo() {}\n"
11633 verifyFormat("void foobar() { int i = 5; }\n"
11642 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
11647 verifyFormat("void (^block)(void) = ^{\n"
11653 verifyFormat("void f()\n"
11659 verifyFormat("void f()\n"
11665 verifyFormat("int f()\n"
11672 verifyFormat("void f() { int i; }", AllmanBraceStyle);
11674 verifyFormat("void f()\n"
11685 verifyFormat("void f(bool b)\n"
11693 verifyFormat("void f(bool b)\n"
11701 verifyFormat("void f(bool b)\n"
11709 verifyFormat("void f(bool b)\n"
11714 verifyFormat("void f(bool b)\n"
11719 verifyFormat("void f(bool b)\n"
11724 verifyFormat("void f(bool b)\n"
11768 verifyFormat("namespace a\n"
11792 verifyFormat("void f()\n"
11809 verifyFormat("void f()\n"
11866 verifyFormat("enum X\n"
11872 verifyFormat("enum X\n"
11877 verifyFormat("enum X\n"
11884 verifyFormat("@interface BSApplicationController ()\n"
11892 verifyFormat("#ifdef _DEBUG\n"
11902 verifyFormat("void foo() {}\n"
11914 verifyFormat("void foobar()\n"
11931 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
11936 verifyFormat("void (^block)(void) = ^{\n"
11942 verifyFormat("void f()\n"
11948 verifyFormat("int f()\n"
11958 verifyFormat("void f(bool b)\n"
11966 verifyFormat("void f(bool b)\n"
11971 verifyFormat("void f(bool b)\n"
11984 verifyFormat("namespace a\n"
12005 verifyFormat("void f()\n"
12022 verifyFormat("void f()\n"
12040 verifyFormat("void f(int a)\n"
12060 verifyFormat("enum X\n"
12066 verifyFormat("@interface BSApplicationController ()\n"
12074 verifyFormat("#ifdef _DEBUG\n"
12084 verifyFormat("void foo() {}\n"
12096 verifyFormat("void foobar() { int i = 5; }\n"
12109 verifyFormat("namespace a {\n"
12131 verifyFormat("struct S {\n"
12145 verifyFormat("void f() {\n"
12154 verifyFormat("#pragma omp reduction(| : var)");
12155 verifyFormat("#pragma omp reduction(+ : var)");
12164 verifyFormat("#pragma option -C -A");
12191 verifyFormat("int a; // the\n"
12215 verifyFormat("int a; // the comment", Style);
12975 verifyFormat("\"Однажды в студёную зимнюю пору...\"",
12977 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
12979 verifyFormat("// Однажды в студёную зимнюю пору...",
12981 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
12982 verifyFormat("/* Однажды в студёную зимнюю пору... */",
12984 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
13082 verifyFormat(
13089 verifyFormat(
13096 verifyFormat(
13102 verifyFormat(
13106 verifyFormat("bool smaller = 1 < "
13113 verifyFormat("SomeClass::Constructor() :\n"
13123 verifyFormat("SomeClass::Constructor()\n"
13128 verifyFormat("SomeClass::Constructor()\n"
13133 verifyFormat("SomeClass::Constructor()\n"
13136 verifyFormat("SomeClass::Constructor() noexcept\n"
13139 verifyFormat("SomeClass::Constructor()\n"
13144 verifyFormat("SomeClass::Constructor()\n"
13152 verifyFormat("SomeClass::Constructor()\n"
13157 verifyFormat("SomeClass::Constructor()\n"
13164 verifyFormat("SomeClass::Constructor()\n"
13171 verifyFormat("SomeClass::Constructor()\n"
13179 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
13180 verifyFormat(
13183 verifyFormat(
13189 verifyFormat("SomeClass::Constructor()\n"
13197 verifyFormat("void F(int &i) { i.~int(); }");
13198 verifyFormat("void F(int &i) { i->~int(); }");
13205 verifyFormat("namespace outer {\n"
13217 verifyFormat("switch (variable) {\n"
13244 verifyFormat("void f() { return; }", Style);
13257 verifyFormat("Constructor()\n"
13265 verifyFormat("SomeClass::Constructor()\n"
13275 verifyFormat("SomeClass::Constructor()\n"
13282 verifyFormat("SomeClass::Constructor()\n"
13291 verifyFormat("class C {\n"
13298 verifyFormat("int a; // Do not\n"
13321 verifyFormat("#define aNumber 10", Style);
13360 verifyFormat("[self.a b:c c:d];", Style);
13369 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
13370 verifyFormat(
13372 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
13373 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
13374 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
13375 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
13376 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
13377 verifyFormat("auto c = [a = [b = 42] {}] {};\n");
13378 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
13379 verifyFormat("int x = f(*+[] {});");
13380 verifyFormat("void f() {\n"
13383 verifyFormat("void f() {\n"
13388 verifyFormat("void f() {\n"
13394 verifyFormat(
13402 verifyFormat("SomeFunction([]() { // A cool function...\n"
13413 verifyFormat("void f() {\n"
13416 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
13418 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
13421 verifyFormat("Constructor()\n"
13425 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
13428 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
13430 verifyFormat("int i = aaaaaa ? 1 //\n"
13434 verifyFormat("llvm::errs() << \"number of twos is \"\n"
13438 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
13444 verifyFormat("SomeFunction({[&] {\n"
13450 verifyFormat("SomeFunction({[&] {\n"
13453 verifyFormat(
13459 verifyFormat("int c = []() -> int { return 2; }();\n");
13460 verifyFormat("int c = []() -> int * { return 2; }();\n");
13461 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
13462 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
13467 verifyFormat("[a, a]() -> a<1> {};");
13468 verifyFormat("[]() -> foo<5 + 2> { return {}; };");
13469 verifyFormat("[]() -> foo<5 - 2> { return {}; };");
13470 verifyFormat("[]() -> foo<5 / 2> { return {}; };");
13471 verifyFormat("[]() -> foo<5 * 2> { return {}; };");
13472 verifyFormat("[]() -> foo<5 % 2> { return {}; };");
13473 verifyFormat("[]() -> foo<5 << 2> { return {}; };");
13474 verifyFormat("[]() -> foo<!5> { return {}; };");
13475 verifyFormat("[]() -> foo<~5> { return {}; };");
13476 verifyFormat("[]() -> foo<5 | 2> { return {}; };");
13477 verifyFormat("[]() -> foo<5 || 2> { return {}; };");
13478 verifyFormat("[]() -> foo<5 & 2> { return {}; };");
13479 verifyFormat("[]() -> foo<5 && 2> { return {}; };");
13480 verifyFormat("[]() -> foo<5 == 2> { return {}; };");
13481 verifyFormat("[]() -> foo<5 != 2> { return {}; };");
13482 verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
13483 verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
13484 verifyFormat("[]() -> foo<5 < 2> { return {}; };");
13485 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
13486 verifyFormat("namespace bar {\n"
13490 verifyFormat("namespace bar {\n"
13494 verifyFormat("namespace bar {\n"
13498 verifyFormat("namespace bar {\n"
13502 verifyFormat("namespace bar {\n"
13506 verifyFormat("namespace bar {\n"
13510 verifyFormat("namespace bar {\n"
13514 verifyFormat("namespace bar {\n"
13518 verifyFormat("namespace bar {\n"
13522 verifyFormat("namespace bar {\n"
13526 verifyFormat("namespace bar {\n"
13530 verifyFormat("namespace bar {\n"
13534 verifyFormat("namespace bar {\n"
13538 verifyFormat("namespace bar {\n"
13542 verifyFormat("namespace bar {\n"
13546 verifyFormat("namespace bar {\n"
13550 verifyFormat("namespace bar {\n"
13554 verifyFormat("namespace bar {\n"
13558 verifyFormat("[]() -> a<1> {};");
13559 verifyFormat("[]() -> a<1> { ; };");
13560 verifyFormat("[]() -> a<1> { ; }();");
13561 verifyFormat("[a, a]() -> a<true> {};");
13562 verifyFormat("[]() -> a<true> {};");
13563 verifyFormat("[]() -> a<true> { ; };");
13564 verifyFormat("[]() -> a<true> { ; }();");
13565 verifyFormat("[a, a]() -> a<false> {};");
13566 verifyFormat("[]() -> a<false> {};");
13567 verifyFormat("[]() -> a<false> { ; };");
13568 verifyFormat("[]() -> a<false> { ; }();");
13569 verifyFormat("auto foo{[]() -> foo<false> { ; }};");
13570 verifyFormat("namespace bar {\n"
13573 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
13577 verifyFormat(
13583 verifyFormat("[]() //\n"
13589 verifyFormat(
13594 verifyFormat("SomeFunction(\n"
13603 verifyFormat("SomeFunction(\n"
13613 verifyFormat("SomeFunction(\n"
13620 verifyFormat("SomeFunction(\n"
13629 verifyFormat(
13640 verifyFormat("function(1, [this, that] {\n"
13643 verifyFormat("function([this, that] {\n"
13648 verifyFormat("function(a, b, c, //\n"
13654 verifyFormat("SomeFunction(\n"
13665 verifyFormat("return [i, args...] {};");
13668 verifyFormat("constexpr char hello[]{\"hello\"};");
13669 verifyFormat("double &operator[](int i) { return 0; }\n"
13671 verifyFormat("std::unique_ptr<int[]> foo() {}");
13672 verifyFormat("int i = a[a][a]->f();");
13673 verifyFormat("int i = (*b)[a]->f();");
13676 verifyFormat("void f() {\n"
13682 verifyFormat("void f() {\n"
13687 verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
13692 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
13697 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
13702 verifyFormat("auto lambda = []() {\n"
13711 verifyFormat(
13771 verifyFormat("int (^Block)(int, int);", ShortBlocks);
13772 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
13773 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
13774 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
13775 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
13776 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
13778 verifyFormat("foo(^{ bar(); });", ShortBlocks);
13779 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
13780 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
13782 verifyFormat("[operation setCompletionBlock:^{\n"
13785 verifyFormat("int i = {[operation setCompletionBlock:^{\n"
13788 verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
13791 verifyFormat("int a = [operation block:^int(int *i) {\n"
13794 verifyFormat("[myObject doSomethingWith:arg1\n"
13800 verifyFormat("[operation setCompletionBlock:^{\n"
13804 verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
13810 verifyFormat("[[SessionService sharedService]\n"
13818 verifyFormat("void (^largeBlock)(void) = ^{\n"
13822 verifyFormat("[[SessionService sharedService]\n"
13832 verifyFormat("[myObject doSomethingWith:arg1\n"
13845 verifyFormat("[myObject doSomethingWith:arg1\n"
13852 verifyFormat("f(^{\n"
13859 verifyFormat("Block b = ^int *(A *a, B *b) {}");
13860 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
13865 verifyFormat("[operation setCompletionBlock:^{\n"
13875 verifyFormat("[[SessionService sharedService] "
13901 verifyFormat("[myObject doSomethingWith:arg1\n"
13915 verifyFormat("f(^{\n"
13923 verifyFormat("void (^largeBlock)(void) = ^{\n"
13991 verifyFormat("MY_CLASS(C) {\n"
14017 verifyFormat("int Foo::getter(\n"
14023 verifyFormat("void Foo::setter(\n"
14035 verifyFormat("static_cast< int >(arg);", Spaces);
14036 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
14037 verifyFormat("f< int, float >();", Spaces);
14038 verifyFormat("template <> g() {}", Spaces);
14039 verifyFormat("template < std::vector< int > > f() {}", Spaces);
14040 verifyFormat("std::function< void(int, int) > fct;", Spaces);
14041 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
14046 verifyFormat("A< A< int > >();", Spaces);
14049 verifyFormat("A<A<int> >();", Spaces);
14053 verifyFormat("A< A< int > >();", Spaces);
14056 verifyFormat("A<A<int>>();", Spaces);
14062 verifyFormat("template<int> void foo();", Style);
14066 verifyFormat("f<<<1, 1>>>();");
14067 verifyFormat("f<<<1, 1, 1, s>>>();");
14068 verifyFormat("f<<<a, b, c, d>>>();");
14070 verifyFormat("f<param><<<1, 1>>>();");
14071 verifyFormat("f<1><<<1, 1>>>();");
14073 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
14075 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
14080 verifyFormat("<<");
14082 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
14084 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
14244 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
14267 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
14447 verifyFormat("auto [a, b] = f();");
14475 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
14476 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
14477 verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
14478 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
14479 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
14480 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
14481 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
14482 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
14483 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
14484 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
14485 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
14486 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
14509 verifyFormat("auto [ a, b ] = f();", Spaces);
14510 verifyFormat("auto &&[ a, b ] = f();", Spaces);
14511 verifyFormat("auto &[ a, b ] = f();", Spaces);
14512 verifyFormat("auto const &&[ a, b ] = f();", Spaces);
14513 verifyFormat("auto const &[ a, b ] = f();", Spaces);
14650 verifyFormat("struct foo {\n"
14659 verifyFormat("STACK_OF(int) a;", Macros);
14660 verifyFormat("STACK_OF(int) *a;", Macros);
14661 verifyFormat("STACK_OF(int const *) *a;", Macros);
14662 verifyFormat("STACK_OF(int *const) *a;", Macros);
14663 verifyFormat("STACK_OF(int, string) a;", Macros);
14664 verifyFormat("STACK_OF(LIST(int)) a;", Macros);
14665 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
14666 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
14667 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
14670 verifyFormat("STACK_OF(int)* a;", Macros);
14671 verifyFormat("STACK_OF(int*)* a;", Macros);
14678 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
14680 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
14686 verifyFormat("int a and b;");
14687 verifyFormat("int a and_eq b;");
14688 verifyFormat("int a bitand b;");
14689 verifyFormat("int a bitor b;");
14690 verifyFormat("int a compl b;");
14691 verifyFormat("int a not b;");
14692 verifyFormat("int a not_eq b;");
14693 verifyFormat("int a or b;");
14694 verifyFormat("int a xor b;");
14695 verifyFormat("int a xor_eq b;");
14696 verifyFormat("return this not_eq bitand other;");
14697 verifyFormat("bool operator not_eq(const X bitand other)");
14699 verifyFormat("int a and 5;");
14700 verifyFormat("int a and_eq 5;");
14701 verifyFormat("int a bitand 5;");
14702 verifyFormat("int a bitor 5;");
14703 verifyFormat("int a compl 5;");
14704 verifyFormat("int a not 5;");
14705 verifyFormat("int a not_eq 5;");
14706 verifyFormat("int a or 5;");
14707 verifyFormat("int a xor 5;");
14708 verifyFormat("int a xor_eq 5;");
14710 verifyFormat("int a compl(5);");
14711 verifyFormat("int a not(5);");
14726 verifyFormat("#if defined(while)\n"