Cross Reference: /external/clang/unittests/Format/FormatTest.cpp

Lines Matching refs:verifyFormat
63   void verifyFormat(llvm::StringRef Code,
75     verifyFormat(Code, getGoogleStyle());
79     verifyFormat(text);
80     verifyFormat(llvm::Twine("void f() { " + text + " }").str());
124   verifyFormat("Method(f1, f2(f3));");
125   verifyFormat("Method(f1(f2, f3()));");
126   verifyFormat("Method(f1(f2, (f3())));");
130   verifyFormat("vector<::Type> v;");
131   verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
132   verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
133   verifyFormat("bool a = 2 < ::SomeFunction();");
189   verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
274   verifyFormat("x = (a) and (b);");
275   verifyFormat("x = (a) or (b);");
276   verifyFormat("x = (a) bitand (b);");
277   verifyFormat("x = (a) bitor (b);");
278   verifyFormat("x = (a) not_eq (b);");
279   verifyFormat("x = (a) and_eq (b);");
280   verifyFormat("x = (a) or_eq (b);");
281   verifyFormat("x = (a) xor (b);");
289   verifyFormat("if (true)\n  f();\ng();");
290   verifyFormat("if (a)\n  if (b)\n    if (c)\n      g();\nh();");
291   verifyFormat("if (a)\n  if (b) {\n    f();\n  }\ng();");
295   verifyFormat("if (a)\n"
299   verifyFormat("if (a)\n"
302   verifyFormat("if (a)\n"
306   verifyFormat("if (a) // Can't merge this\n"
309   verifyFormat("if (a) /* still don't merge */\n"
312   verifyFormat("if (a) { // Never merge this\n"
316   verifyFormat("if (a) { /* Never merge this */\n"
322   verifyFormat("if (a) return;", AllowsMergedIf);
323   verifyFormat("if (aaaaaaaaa)\n"
328   verifyFormat("if (a)\n  return;", AllowsMergedIf);
334   verifyFormat("while (true) continue;", AllowsMergedLoops);
335   verifyFormat("for (;;) continue;", AllowsMergedLoops);
336   verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
337   verifyFormat("while (true)\n"
340   verifyFormat("for (;;)\n"
343   verifyFormat("for (;;)\n"
346   verifyFormat("for (;;) // Can't merge this\n"
349   verifyFormat("for (;;) /* still don't merge */\n"
361   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
362   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
363   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
364   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
365   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
366   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
367   verifyFormat("if (true) { //\n"
371   verifyFormat("if (true) {\n"
376   verifyFormat("if (true) {\n"
383   verifyFormat("template <int> struct A2 {\n"
389   verifyFormat("if (true) {\n"
393   verifyFormat("if (true) {\n"
401   verifyFormat("while (true) {\n"
405   verifyFormat("for (;;) {\n"
412   verifyFormat("if (true)\n"
422   verifyFormat("if (true)\n"
435   verifyFormat("void f() {\n"
443   verifyFormat("if (a) {\n} else if (b) {\n}");
444   verifyFormat("if (a)\n"
450   verifyFormat("if (a) {\n"
458   verifyFormat("if (a) {\n"
462   verifyFormat("if (a) {\n"
470   verifyFormat(
474   verifyFormat("for (;;)\n"
476   verifyFormat("for (;;) {\n}");
477   verifyFormat("for (;;) {\n"
480   verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
482   verifyFormat(
487   verifyFormat(
490   verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
493   verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
497   verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
503   verifyFormat(
509 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
512   verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
515   verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
519   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
526   verifyFormat("for (int aaaaaaaaaaa = 1;\n"
534   verifyFormat(
543   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
545   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
547   verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
549   verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
554   verifyFormat("void f() {\n"
562   verifyFormat("#define foreach(x, y)\n"
568   verifyFormat("#define foreach (x, y)\n"
575   verifyFormat("while (true) {\n}");
576   verifyFormat("while (true)\n"
578   verifyFormat("while () {\n}");
579   verifyFormat("while () {\n"
585   verifyFormat("do {\n"
588   verifyFormat("do\n"
594   verifyFormat("switch (x) {\n"
606   verifyFormat("switch (x) {\n"
615   verifyFormat("switch (x) {\n"
625   verifyFormat("switch (x) {\n"
635   verifyFormat("switch (x) {\n"
641   verifyFormat("switch (test)\n"
643   verifyFormat("switch (x) {\n"
648   verifyFormat("switch (x) {\n"
654   verifyFormat("switch (x) {\n"
663   verifyFormat("#define A          \\\n"
669   verifyFormat("#define OPERATION_CASE(name)           \\\n"
673   verifyFormat("switch (x) {\n"
713   verifyFormat("DEBUG({\n"
724   verifyFormat("switch (a) {\n"
729   verifyFormat("switch (a) {\n"
738   verifyFormat("switch (x) {\n"
748   verifyFormat("switch (a) {\n"
765   verifyFormat("switch (a) {\n"
771   verifyFormat("switch (a) {\n"
787   verifyFormat("switch (a) {\n"
801   verifyFormat("void f() {\n"
811   verifyFormat("{\n"
816   verifyFormat("{\n"
828   verifyFormat("//* */");
829   verifyFormat("// line 1\n"
833   verifyFormat("void f() {\n"
836   verifyFormat("SomeObject\n"
839   verifyFormat("auto result = SomeObject\n"
842   verifyFormat("void f(int i,  // some comment (probably for i)\n"
845   verifyFormat("void f(int i,\n"
851   verifyFormat("int i    // This is a fancy variable\n"
854   verifyFormat("// Leading comment.\n"
856   verifyFormat("int a; // Trailing comment\n"
860   verifyFormat("int a; // Trailing comment\n"
864   verifyFormat("int a;    // Comment.\n"
867   verifyFormat(
876   verifyFormat("#include \"a\"     // comment\n"
878   verifyFormat("#include <a>     // comment\n"
886   verifyFormat("enum E {\n"
892   verifyFormat(
895   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
898   verifyFormat("SomeFunction(a,\n"
901   verifyFormat("SomeFunction(a, a,\n"
904   verifyFormat(
909   verifyFormat("int aaaa; // aaaaa\n"
936   verifyFormat("someFunction(anotherFunction( // Force break.\n"
941   verifyFormat("const char *test[] = {\n"
997   verifyFormat("f(); // comment\n"
1026   verifyFormat("#define A                                                  \\\n"
1030   verifyFormat(
1036   verifyFormat("if ( // This is some comment\n"
1090   verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);");
1091   verifyFormat("void f() { g(/*aaa=*/x, /*bbb=*/!y); }");
1114   verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n"
1203   verifyFormat("// aaaaaaaaa aaaaaaaaaa aaaaaaaaaa", Style);
1204   verifyFormat("/* aaaaaaaaa aaaaaaaaaa aaaaaaaaaa */", Style);
1662   verifyFormat("static SomeType type = {aaaaaaaaaaa, // comment for aa...\n"
1664   verifyFormat("static SomeType type = {aaaaaaaaaaa,\n"
1674   verifyFormat("S s = {{a, b, c},  // Group #1\n"
1677   verifyFormat("S s = {{// Group #1\n"
1710   verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n"
1858   verifyFormat("class A {};");
1862   verifyFormat("class A {\n"
1875   verifyFormat("class A {\n"
1895   verifyFormat("signals.set();");
1896   verifyFormat("for (Signals signals : f()) {\n}");
1897   verifyFormat("{\n"
1961   verifyFormat("class A : public B {};");
1962   verifyFormat("class A : public ::B {};");
1964   verifyFormat(
1967   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1970   verifyFormat(
1972   verifyFormat("class AAAAAAAAAAAA : public B,\n"
1979   verifyFormat("class\n"
1984   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1986   verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1989   verifyFormat("template <class R, class C>\n"
1992   verifyFormat("class ::A::B {};");
1996   verifyFormat("class A {\n} a, b;");
1997   verifyFormat("struct A {\n} a, b;");
1998   verifyFormat("union A {\n} a;");
2002   verifyFormat("enum {\n"
2018   verifyFormat("enum Enum {};");
2019   verifyFormat("enum {};");
2020   verifyFormat("enum X E {} d;");
2021   verifyFormat("enum __attribute__((...)) E {} d;");
2022   verifyFormat("enum __declspec__((...)) E {} d;");
2023   verifyFormat("enum {\n"
2028   verifyFormat("enum ShortEnum { A, B, C };");
2046   verifyFormat("enum E { // comment\n"
2052   verifyFormat("enum X f() {\n"
2056   verifyFormat("enum X Type::f() {\n"
2060   verifyFormat("enum ::X f() {\n"
2064   verifyFormat("enum ns::X f() {\n"
2071   verifyFormat("enum Type {\n"
2075   verifyFormat("namespace n {\n"
2085   verifyFormat("enum struct {\n"
2093   verifyFormat("enum struct Enum {};");
2094   verifyFormat("enum struct {};");
2095   verifyFormat("enum struct X E {} d;");
2096   verifyFormat("enum struct __attribute__((...)) E {} d;");
2097   verifyFormat("enum struct __declspec__((...)) E {} d;");
2098   verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
2102   verifyFormat("enum class {\n"
2110   verifyFormat("enum class Enum {};");
2111   verifyFormat("enum class {};");
2112   verifyFormat("enum class X E {} d;");
2113   verifyFormat("enum class __attribute__((...)) E {} d;");
2114   verifyFormat("enum class __declspec__((...)) E {} d;");
2115   verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
2119   verifyFormat("enum X : int {\n"
2123   verifyFormat("enum X : int { A, B };");
2124   verifyFormat("enum X : std::uint32_t { A, B };");
2155   verifyFormat("struct Bitfields {\n"
2159   verifyFormat("struct A {\n"
2163   verifyFormat("struct MyStruct {\n"
2172   verifyFormat("namespace some_namespace {\n"
2176   verifyFormat("namespace {\n"
2180   verifyFormat("inline namespace X {\n"
2184   verifyFormat("using namespace some_namespace;\n"
2191   verifyFormat("namespace {};");
2192   verifyFormat("namespace {\n"
2196   verifyFormat("namespace {\n"
2251 TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); }
2254   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2255   verifyFormat("asm(\"nop\" ::: \"memory\");");
2256   verifyFormat(
2285   verifyFormat("void function() {\n"
2298   verifyFormat("try {\n"
2307   verifyFormat("int f() try { return 4; } catch (...) {\n"
2310   verifyFormat("class A {\n"
2323   verifyFormat("__try {\n"
2329   verifyFormat("__try {\n"
2335   verifyFormat("DEBUG({\n"
2343   verifyFormat
2348   verifyFormat("try {\n"
2362     verifyFormat("try {\n"
2370   verifyFormat("try {\n"
2377   verifyFormat("__try {\n"
2384   verifyFormat("@try {\n"
2392   verifyFormat("try\n"
2402   verifyFormat("try\n"
2413   verifyFormat("try {\n"
2423   verifyFormat("@try {\n"
2430   verifyFormat("DEBUG({\n"
2439   verifyFormat("@autoreleasepool {\n"
2447   verifyFormat("@autoreleasepool\n"
2459   verifyFormat("static SomeClass SC = {1, 'a'};");
2461   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2466   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2480   verifyFormat("static int Variable[1] = {\n"
2486   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2487   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2492   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2503   verifyFormat("static A x = {{{}}};\n");
2504   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2508   verifyFormat("somes Status::global_reps[3] = {\n"
2517   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2521   verifyFormat(
2529   verifyFormat(
2538   verifyFormat("struct {\n"
2545   verifyFormat("struct {\n"
2557   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2563   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2567   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2570   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2576   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2578   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2594   verifyFormat("#\n;\n;\n;");
2611   verifyFormat("#define A \\x20");
2612   verifyFormat("#define A \\ x20");
2614   verifyFormat("#define A ''");
2615   verifyFormat("#define A ''qqq");
2616   verifyFormat("#define A `qqq");
2617   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
2623   verifyFormat("a\r\\");
2624   verifyFormat("a\v\\");
2625   verifyFormat("a\f\\");
2629   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2630   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
2631   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
2633   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
2635   verifyFormat("#define A A\n#define A A");
2636   verifyFormat("#define A(X) A\n#define A A");
2638   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2639   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
2681   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
2682   verifyFormat("#define A  \\\n"
2688   verifyFormat("#define A(X)         \\\n"
2692   verifyFormat("#define A(a, b, c)   \\\n"
2696   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
2731   verifyFormat("#define SOMECASES  \\\n"
2735   verifyFormat("#define A template <typename T>");
2738   verifyFormat("#pragma omp threadprivate( \\\n"
2741   verifyFormat("#d, = };");
2742   verifyFormat("#if \"a");
2749   verifyFormat("#define A     \\\n"
2763   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2803   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
2948   verifyFormat("MACRO(>)");
2952   verifyFormat("#define A \\\n"
2964   verifyFormat("{\n  { a #c; }\n}");
2996   verifyFormat("#define A \\\n"
3024   verifyFormat("functionCallTo(\n"
3034   verifyFormat("Foo::Foo()\n"
3040   verifyFormat("void f() {\n"
3050   verifyFormat("void f(param1, param2,\n"
3072   verifyFormat("#if 1\n"
3074   verifyFormat("#if 1\n"
3079   verifyFormat("DEBUG({\n"
3095   verifyFormat("#endif\n"
3102   verifyFormat("#if 0\n"
3112   verifyFormat("functionCall({ int i; });");
3113   verifyFormat("functionCall({\n"
3117   verifyFormat("functionCall(\n"
3123   verifyFormat("functionA(functionB({\n"
3128   verifyFormat("functionCall(\n"
3135   verifyFormat("functionA(functionB({\n"
3141   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
3142   verifyFormat("functionCall(aaaa, bbbb, {\n"
3146   verifyFormat(
3153   verifyFormat("DEBUG({\n"
3166   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
3174   verifyFormat("call(parameter, {\n"
3180   verifyFormat("DEBUG( //\n"
3182   verifyFormat("DEBUG( //\n"
3220   verifyFormat("DEBUG({\n"
3229   verifyFormat("Debug(aaaaa,\n"
3236   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
3264   verifyFormat("enum E {};");
3265   verifyFormat("enum E {}");
3272   verifyFormat("FOO_BEGIN\n"
3275   verifyFormat("FOO_BEGIN\n"
3280   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
3291   verifyFormat(
3297   verifyFormat(
3302   verifyFormat(
3307   verifyFormat(
3312   verifyFormat("int a = bbbb && ccc && fffff(\n"
3318   verifyFormat(
3322   verifyFormat(
3327   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3330   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3333   verifyFormat(
3338   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3341   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3344   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
3349   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3352   verifyFormat("b = a &&\n"
3358   verifyFormat(
3362   verifyFormat(
3366   verifyFormat(
3372   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3376   verifyFormat(
3385   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3392   verifyFormat(
3400   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3409   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
3413   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3417   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
3421   verifyFormat("if () {\n"
3428   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
3443   verifyFormat(
3454   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3459   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3464   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3469   verifyFormat("if () {\n"
3475   verifyFormat("return (a)\n"
3479   verifyFormat(
3485   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3490   verifyFormat(
3497   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
3502   verifyFormat("zzzzzzzzzz\n"
3512   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3523   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3527   verifyFormat("int a = aa\n"
3533   verifyFormat("return (a > b\n"
3543   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
3550   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
3551   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
3553   verifyFormat("Constructor()\n"
3556   verifyFormat("Constructor()\n"
3560   verifyFormat("template <typename T>\n"
3564   verifyFormat(
3568   verifyFormat(
3572   verifyFormat(
3576   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
3580   verifyFormat("Constructor()\n"
3586   verifyFormat("Constructor()\n"
3590   verifyFormat("Constructor(int Parameter = 0)\n"
3593   verifyFormat("Constructor()\n"
3597   verifyFormat("Constructor()\n"
3603   verifyFormat("Constructor()\n"
3610   verifyFormat("SomeClass::Constructor()\n"
3615   verifyFormat("SomeClass::Constructor()\n"
3620   verifyFormat("MyClass::MyClass(int var)\n"
3625   verifyFormat("Constructor()\n"
3632 verifyFormat("Constructor()\n"
3637   verifyFormat("Constructor()\n"
3653   verifyFormat(
3661   verifyFormat(
3668   verifyFormat(
3695   verifyFormat(
3726   verifyFormat(input, OnePerLine);
3730   verifyFormat(
3736   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
3743   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
3745   verifyFormat("template <class TemplateIt>\n"
3750   verifyFormat(
3756   verifyFormat(
3762   verifyFormat(
3772   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
3777   verifyFormat(
3783   verifyFormat(
3791   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
3798   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3802   verifyFormat("void SomeLoooooooooooongFunction(\n"
3808   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3810   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3812   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
3820   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3822   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
3831   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3834   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
3840   verifyFormat("auto foo() -> int;\n");
3841   verifyFormat("struct S {\n"
3844   verifyFormat("template <size_t Order, typename T>\n"
3847   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
3849   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
3850   verifyFormat("template <typename T>\n"
3855   verifyFormat("void f() { auto a = b->c(); }");
3863   verifyFormat("void someLongFunction(\n"
3866   verifyFormat("LoooooongReturnType\n"
3869   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
3872   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3874   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3876   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
3878   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
3885   verifyFormat("void someLongFunction(\n"
3888   verifyFormat("void someLongFunction(\n"
3891   verifyFormat("void someLongFunction(\n"
3894   verifyFormat("void someLongFunction(\n"
3897   verifyFormat("void someLongFunction(\n"
3900   verifyFormat("void someLongFunction(\n"
3903   verifyFormat("void someLongFunction(\n"
3908   verifyFormat("void someLongFunction(\n"
3915   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
3921   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
3923   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3925   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
3929   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
3931   verifyFormat(
3935   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3952   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
3954   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
3956   verifyFormat("template <typename T>\n"
3961   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3963   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
3968   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
3971   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3975   verifyFormat(
3979   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3983   verifyFormat(
3989   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3992   verifyFormat(
3997   verifyFormat(
4000   verifyFormat(
4003   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4008   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
4010   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
4012   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
4017   verifyFormat(
4023   verifyFormat("{\n  {\n    {\n"
4038   verifyFormat(
4048   verifyFormat("void f() {\n"
4053   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
4063   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
4067   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
4071   verifyFormat(
4078   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
4081   verifyFormat("void f() {\n"
4087   verifyFormat(
4092   verifyFormat(
4098   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
4103   verifyFormat("a(\"a\"\n"
4108   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
4112   verifyFormat(
4118   verifyFormat(
4149   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
4157   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
4159   verifyFormat(
4163   verifyFormat(
4167   verifyFormat(
4170   verifyFormat(
4191   verifyFormat(
4193   verifyFormat("aaaaaaaaaaaaaaa()\n"
4198   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4202   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
4205   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
4210   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4213   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
4216   verifyFormat("aaa()\n"
4221   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
4224   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
4229   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
4233   verifyFormat(
4240   verifyFormat(
4243   verifyFormat(
4247   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
4249   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
4252   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
4254   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
4257   verifyFormat(
4260   verifyFormat(
4264   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
4268   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
4273   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
4276   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
4282   verifyFormat(
4286   verifyFormat(
4290   verifyFormat(
4293   verifyFormat("unsigned OriginalStartColumn =\n"
4300   verifyFormat(
4303   verifyFormat(
4306   verifyFormat(
4309   verifyFormat(
4312   verifyFormat(
4319   verifyFormat(
4322   verifyFormat(
4325   verifyFormat(
4328   verifyFormat(
4331   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4333   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4336   verifyFormat("return\n"
4342   verifyFormat(
4345   verifyFormat(
4348   verifyFormat(
4353   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4356   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4359   verifyFormat("SomeLongVariableName->someFunction(\n"
4362   verifyFormat(
4366   verifyFormat(
4370   verifyFormat(
4378   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4383   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
4388   verifyFormat("SomeLongVariableName->someFunction(\n"
4398   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4403   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4408   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4413   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
4419   verifyFormat(
4423   verifyFormat(
4426   verifyFormat(
4429   verifyFormat(
4434   verifyFormat(
4438   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4443   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4450   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4455   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4458   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
4462   verifyFormat(
4466   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
4470   verifyFormat("return aaaa == bbbb\n"
4474   verifyFormat("unsigned Indent =\n"
4480   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4485   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
4490   verifyFormat(
4496   verifyFormat(
4504   verifyFormat(
4513   verifyFormat(
4522   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
4529   verifyFormat("return a != b\n"
4533   verifyFormat("return a != b\n"
4540   verifyFormat("return a != b\n"
4553   verifyFormat(
4558   verifyFormat(
4562   verifyFormat(
4566   verifyFormat(
4572   verifyFormat(
4577   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4583   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4591   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4597   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
4601   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
4606   verifyFormat(
4611   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
4616   verifyFormat(
4623   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4629   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
4638   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
4640   verifyFormat("bool a = true, b = false;");
4642   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4646   verifyFormat(
4650   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
4652   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4654   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
4660   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4664   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
4670   verifyFormat("arr[foo ? bar : baz];");
4671   verifyFormat("f()[foo ? bar : baz];");
4672   verifyFormat("(a + b)[foo ? bar : baz];");
4673   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
4677   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
4679   verifyFormat(
4683   verifyFormat("someFunction(\"Always break between multi-line\"\n"
4699   verifyFormat("a = a + \"a\"\n"
4702   verifyFormat("f(\"a\", \"b\"\n"
4705   verifyFormat(
4710   verifyFormat("#define A(X)          \\\n"
4714   verifyFormat("#define A \"def\"\n"
4718   verifyFormat("f(L\"a\"\n"
4720   verifyFormat("#define A(X)            \\\n"
4725   verifyFormat("f(@\"a\"\n"
4727   verifyFormat("NSString s = @\"a\"\n"
4730   verifyFormat("NSString s = @\"a\"\n"
4739   verifyFormat("class A {\n"
4751   verifyFormat("class E {\n"
4770   verifyFormat("class B {\n"
4784   verifyFormat("class C {\n"
4799   verifyFormat("class D {\n"
4812   verifyFormat("const char *\n"
4818   verifyFormat("template <class T>\n"
4825   verifyFormat("class C {\n"
4836   verifyFormat("void\n"
4843   verifyFormat("void *operator new(std::size_t s);", // No break here.
4845   verifyFormat("void *\n"
4848   verifyFormat("void *\n"
4852   verifyFormat("const char *\n"
4859   verifyFormat("template <class T>\n"
4874   verifyFormat("aaaa = \"bbbb\"\n"
4877   verifyFormat("aaaa =\n"
4881   verifyFormat("aaaa(\"bbbb\"\n"
4884   verifyFormat("aaaa(\n"
4888   verifyFormat("aaaa(qqq, \"bbbb\"\n"
4891   verifyFormat("aaaa(qqq,\n"
4895   verifyFormat("aaaa(qqq,\n"
4899   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
4902   verifyFormat("string s = someFunction(\n"
4908   verifyFormat("string foo = abc ? \"x\"\n"
4914   verifyFormat("f(\"aaaa\"\n"
4943   verifyFormat("const char *hello = \"hello llvm\";", Break);
4947   verifyFormat(
4951   verifyFormat(
4954   verifyFormat(
4957   verifyFormat(
4961   verifyFormat(
4965   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4969   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
4971   verifyFormat(
4975   verifyFormat("return out << \"somepacket = {\\n\"\n"
4982   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
4985   verifyFormat(
4991   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
4993   verifyFormat(
4998   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
5000   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5004   verifyFormat("LOG_IF(aaa == //\n"
5009   verifyFormat(
5016   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
5025   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
5027   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
5030   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
5033   verifyFormat(
5042   verifyFormat("void f() {\n"
5048   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
5050   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
5054   verifyFormat(
5057   verifyFormat(
5060   verifyFormat(
5067   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5072   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
5075   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
5078   verifyFormat(
5082   verifyFormat(
5087   verifyFormat("loooooooooooooongFunction(\n"
5090   verifyFormat(
5094   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
5096   verifyFormat("void f() {\n"
5101   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
5103   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5107   verifyFormat("void f() {\n"
5111   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5116   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5123   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
5125   verifyFormat(
5130   verifyFormat(
5133   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
5135   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
5138   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5144   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
5152   verifyFormat(
5156   verifyFormat(
5159   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5162   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5168   verifyFormat("template <typename T>\n"
5170   verifyFormat("template <typename T>\n"
5173   verifyFormat(
5176   verifyFormat("template <typename T>\n"
5179   verifyFormat(
5183   verifyFormat(
5188   verifyFormat("template <typename T>\n"
5191   verifyFormat(
5195   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
5199   verifyFormat(
5203   verifyFormat("void f() {\n"
5208   verifyFormat("template <typename T> class C {};");
5209   verifyFormat("template <typename T> void f();");
5210   verifyFormat("template <typename T> void f() {}");
5211   verifyFormat(
5228   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5233   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
5234   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
5235   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
5236   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5239   verifyFormat("template <template <typename> class Fooooooo,\n"
5243   verifyFormat("template <typename T> // T can be A, B or C.\n"
5249   verifyFormat(
5252   verifyFormat(
5258   verifyFormat(
5263   verifyFormat(
5268   verifyFormat(
5272   verifyFormat(
5278   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
5284   verifyFormat("A<int> a;");
5285   verifyFormat("A<A<A<int>>> a;");
5286   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
5287   verifyFormat("bool x = a < 1 || 2 > a;");
5288   verifyFormat("bool x = 5 < f<int>();");
5289   verifyFormat("bool x = f<int>() > 5;");
5290   verifyFormat("bool x = 5 < a<int>::x;");
5291   verifyFormat("bool x = a < 4 ? a > 2 : false;");
5292   verifyFormat("bool x = f() ? a < 2 : a > 2;");
5311   verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
5313   verifyFormat("test >> a >> b;");
5314   verifyFormat("test << a >> b;");
5316   verifyFormat("f<int>();");
5317   verifyFormat("template <typename T> void f() {}");
5318   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
5319   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
5321   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
5324   verifyFormat("return a < b && c > d;");
5325   verifyFormat("void f() {\n"
5329   verifyFormat("template <typename... Types>\n"
5332   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5335   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
5336   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
5337   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
5341   verifyFormat("COMPARE(a, ==, b);");
5345   verifyFormat("int A::*x;");
5346   verifyFormat("int (S::*func)(void *);");
5347   verifyFormat("void f() { int (S::*func)(void *); }");
5348   verifyFormat("typedef bool *(Class::*Member)() const;");
5349   verifyFormat("void f() {\n"
5356   verifyFormat("void f() {\n"
5360   verifyFormat(
5365   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
5369   verifyFormat("int a = -2;");
5370   verifyFormat("f(-1, -2, -3);");
5371   verifyFormat("a[-1] = 5;");
5372   verifyFormat("int a = 5 + -2;");
5373   verifyFormat("if (i == -1) {\n}");
5374   verifyFormat("if (i != -1) {\n}");
5375   verifyFormat("if (i > -1) {\n}");
5376   verifyFormat("if (i < -1) {\n}");
5377   verifyFormat("++(a->f());");
5378   verifyFormat("--(a->f());");
5379   verifyFormat("(a->f())++;");
5380   verifyFormat("a[42]++;");
5381   verifyFormat("if (!(a->f())) {\n}");
5383   verifyFormat("a-- > b;");
5384   verifyFormat("b ? -a : c;");
5385   verifyFormat("n * sizeof char16;");
5386   verifyFormat("n * alignof char16;", getGoogleStyle());
5387   verifyFormat("sizeof(char);");
5388   verifyFormat("alignof(char);", getGoogleStyle());
5390   verifyFormat("return -1;");
5391   verifyFormat("switch (a) {\n"
5395   verifyFormat("#define X -1");
5396   verifyFormat("#define X -kConstant");
5398   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
5399   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
5401   verifyFormat("int a = /* confusing comment */ -1;");
5403   verifyFormat("int a = i /* confusing comment */++;");
5407   verifyFormat("if (!aaaaaaaaaa( // break\n"
5410   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
5412   verifyFormat("*aaa = aaaaaaa( // break\n"
5417   verifyFormat("bool operator<();");
5418   verifyFormat("bool operator>();");
5419   verifyFormat("bool operator=();");
5420   verifyFormat("bool operator==();");
5421   verifyFormat("bool operator!=();");
5422   verifyFormat("int operator+();");
5423   verifyFormat("int operator++();");
5424   verifyFormat("bool operator();");
5425   verifyFormat("bool operator()();");
5426   verifyFormat("bool operator[]();");
5427   verifyFormat("operator bool();");
5428   verifyFormat("operator int();");
5429   verifyFormat("operator void *();");
5430   verifyFormat("operator SomeType<int>();");
5431   verifyFormat("operator SomeType<int, int>();");
5432   verifyFormat("operator SomeType<SomeType<int>>();");
5433   verifyFormat("void *operator new(std::size_t size);");
5434   verifyFormat("void *operator new[](std::size_t size);");
5435   verifyFormat("void operator delete(void *ptr);");
5436   verifyFormat("void operator delete[](void *ptr);");
5437   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
5440   verifyFormat(
5443   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
5447   verifyFormat("SomeType &operator=(const SomeType &S);");
5448   verifyFormat("f.template operator()<int>();");
5454   verifyFormat("using A::operator+;");
5455   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
5460   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
5461   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
5462   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
5463   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
5464   verifyFormat("Deleted &operator=(const Deleted &) &;");
5465   verifyFormat("Deleted &operator=(const Deleted &) &&;");
5466   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
5467   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
5468   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
5469   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
5470   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
5474 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
5475   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
5477   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
5478   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
5482   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
5483   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
5484   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
5485   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
5489   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
5490   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces);
5491   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
5492   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
5496   verifyFormat("void f() {\n"
5502   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
5504   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5507   verifyFormat("delete[] h->p;");
5511   verifyFormat("int *f(int *a) {}");
5512   verifyFormat("int main(int argc, char **argv) {}");
5513   verifyFormat("Test::Test(int b) : a(b * b) {}");
5515   verifyFormat("void g() { f(*a); }");
5552   verifyFormat("void f(Type (*parameter)[10]) {}");
5553   verifyFormat("void f(Type (&parameter)[10]) {}");
5557   verifyFormat("auto a = [](int **&, int ***) {};");
5558   verifyFormat("auto PointerBinding = [](const char *S) {};");
5559   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
5560   verifyFormat("[](const decltype(*a) &value) {}");
5561   verifyFormat("decltype(a * b) F();");
5562   verifyFormat("#define MACRO() [](A *a) { return 1; }");
5567   verifyFormat("Constructor() : a(a), area(width * height) {}");
5568   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
5570   verifyFormat("void f() { f(a, c * d); }");
5571   verifyFormat("void f() { f(new a(), c * d); }");
5583   verifyFormat("for (char **a = b; *a; ++a) {\n}");
5584   verifyFormat("for (; a && b;) {\n}");
5585   verifyFormat("bool foo = true && [] { return false; }();");
5587   verifyFormat(
5614   verifyFormat("x = *a(x) = *a(y);", Left);
5615   verifyFormat("for (;; * = b) {\n}", Left);
5621   verifyFormat("void f() { &(*I).first; }");
5624   verifyFormat(
5639   verifyFormat("void f() {\n"
5643   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
5644   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
5647   verifyFormat("#define A (!a * b)");
5648   verifyFormat("#define MACRO     \\\n"
5664   verifyFormat("delete *x;", PointerLeft);
5665   verifyFormat("STATIC_ASSERT((a & b) == 0);");
5666   verifyFormat("STATIC_ASSERT(0 == (a & b));");
5667   verifyFormat("template <bool a, bool b> "
5669   verifyFormat("template <int *y> f() {}");
5670   verifyFormat("vector<int *> v;");
5671   verifyFormat("vector<int *const> v;");
5672   verifyFormat("vector<int *const **const *> v;");
5673   verifyFormat("vector<int *volatile> v;");
5674   verifyFormat("vector<a * b> v;");
5675   verifyFormat("foo<b && false>();");
5676   verifyFormat("foo<b & 1>();");
5677   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
5678   verifyFormat(
5684   verifyFormat(
5698   verifyFormat("DatumHandle const *operator->() const { return input_; }");
5699   verifyFormat("return options != nullptr && operator==(*options);");
5713   verifyFormat("foo<a<b && c> d> v;");
5717   verifyFormat("delete *x;", PointerMiddle);
5718   verifyFormat("int * x;", PointerMiddle);
5719   verifyFormat("template <int * y> f() {}", PointerMiddle);
5720   verifyFormat("int * f(int * a) {}", PointerMiddle);
5721   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
5722   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
5723   verifyFormat("A<int *> a;", PointerMiddle);
5724   verifyFormat("A<int **> a;", PointerMiddle);
5725   verifyFormat("A<int *, int *> a;", PointerMiddle);
5726   verifyFormat("A<int * []> a;", PointerMiddle);
5727   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
5728   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
5729   verifyFormat("T ** t = new T *;", PointerMiddle);
5732   verifyFormat("string // break\n"
5734   verifyFormat("string // break\n"
5741   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
5742   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
5746   verifyFormat("__attribute__((nodebug)) void\n"
5752   verifyFormat("int printf(const char *fmt, ...);");
5753   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
5754   verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
5758   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
5795   verifyFormat("int f(int &&a) {}");
5796   verifyFormat("int f(int a, char &&b) {}");
5797   verifyFormat("void f() { int &&a = b; }");
5807   verifyFormat("template <bool B, bool C> class A {\n"
5812   verifyFormat("#define A(a, b) (a && b)");
5816   verifyFormat("void f() {\n"
5824   verifyFormat("Type *A = static_cast<Type *>(P);");
5825   verifyFormat("Type *A = (Type *)P;");
5826   verifyFormat("Type *A = (vector<Type *, int *>)P;");
5827   verifyFormat("int a = (int)(2.0f);");
5828   verifyFormat("int a = (int)2.0f;");
5829   verifyFormat("x[(int32)y];");
5830   verifyFormat("x = (int32)y;");
5831   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
5832   verifyFormat("int a = (int)*b;");
5833   verifyFormat("int a = (int)2.0f;");
5834   verifyFormat("int a = (int)~0;");
5835   verifyFormat("int a = (int)++a;");
5836   verifyFormat("int a = (int)sizeof(int);");
5837   verifyFormat("int a = (int)+2;");
5838   verifyFormat("my_int a = (my_int)2.0f;");
5839   verifyFormat("my_int a = (my_int)sizeof(int);");
5840   verifyFormat("return (my_int)aaa;");
5841   verifyFormat("#define x ((int)-1)");
5842   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
5843   verifyFormat("#define p(q) ((int *)&q)");
5844   verifyFormat("fn(a)(b) + 1;");
5846   verifyFormat("void f() { my_int a = (my_int)*b; }");
5847   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
5848   verifyFormat("my_int a = (my_int)~0;");
5849   verifyFormat("my_int a = (my_int)++a;");
5850   verifyFormat("my_int a = (my_int)-2;");
5851   verifyFormat("my_int a = (my_int)1;");
5852   verifyFormat("my_int a = (my_int *)1;");
5853   verifyFormat("my_int a = (const my_int)-1;");
5854   verifyFormat("my_int a = (const my_int *)-1;");
5855   verifyFormat("my_int a = (my_int)(my_int)-1;");
5856   verifyFormat
5857   verifyFormat("case (my_int)ONE:");
5860   verifyFormat("void f(int i = (kValue)*kMask) {}");
5862   verifyFormat("{ (void)F; }");
5865   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5870   verifyFormat("void f(int *) {}");
5871   verifyFormat("f(foo)->b;");
5872   verifyFormat("f(foo).b;");
5873   verifyFormat("f(foo)(b);");
5874   verifyFormat("f(foo)[b];");
5875   verifyFormat("[](foo) { return 4; }(bar);");
5876   verifyFormat("(*funptr)(foo)[4];");
5877   verifyFormat("funptrs[4](foo)[4];");
5878   verifyFormat("void f(int *);");
5879   verifyFormat("void f(int *) = 0;");
5880   verifyFormat("void f(SmallVector<int>) {}");
5881   verifyFormat("void f(SmallVector<int>);");
5882   verifyFormat("void f(SmallVector<int>) = 0;");
5883   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
5884   verifyFormat("int a = sizeof(int) * b;");
5885   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
5886   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
5887   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
5888   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
5891   verifyFormat("virtual void foo(int *) override;");
5892   verifyFormat("virtual void foo(char &) const;");
5893   verifyFormat("virtual void foo(int *a, char *) const;");
5894   verifyFormat("int a = sizeof(int *) + b;");
5895   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
5896   verifyFormat("bool b = f(g<int>) && c;");
5897   verifyFormat("typedef void (*f)(int i) func;");
5899   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
5902   verifyFormat(
5909   verifyFormat("A<bool()> a;");
5910   verifyFormat("A<SomeType()> a;");
5911   verifyFormat("A<void (*)(int, std::string)> a;");
5912   verifyFormat("A<void *(int)>;");
5913   verifyFormat("void *(*a)(int *, SomeType *);");
5914   verifyFormat("int (*func)(void *);");
5915   verifyFormat("void f() { int (*func)(void *); }");
5916   verifyFormat("template <class CallbackClass>\n"
5926   verifyFormat("A<sizeof(*x)> a;");
5927   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
5928   verifyFormat("some_var = function(*some_pointer_var)[0];");
5929   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
5933   verifyFormat("A (*foo_)[6];");
5934   verifyFormat("vector<int> (*foo_)[6];");
5938   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5940   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
5942   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5946   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5948   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5950   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5952   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
5957   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
5959   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
5961   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5963   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
5965   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5967   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
5969   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
5971   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
5975   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
5978   verifyFormat(
5982   verifyFormat(
5986   verifyFormat(
5992   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
5996   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
5998   verifyFormat(
6002   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
6009   verifyFormat("template <typename A>\n"
6031   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
6034   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6037   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6044   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
6046   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6048   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6050   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6053   verifyFormat(
6060   verifyFormat(
6069   verifyFormat("(a)->b();");
6070   verifyFormat("--a;");
6074   verifyFormat("#include <string>\n"
6089   verifyFormat("#import <string>");
6090   verifyFormat("#import <a/b/c.h>");
6091   verifyFormat("#import \"a/b/string\"");
6092   verifyFormat("#import \"string.h\"");
6093   verifyFormat("#import \"string.h\"");
6094   verifyFormat("#if __has_include(<strstream>)\n"
6098   verifyFormat("#define MY_IMPORT <a/b>");
6101   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
6107   verifyFormat("#import \"abc.h\"", Style);
6110   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6121   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
6132   verifyFormat("void f() { return; }\n42");
6133   verifyFormat("void f() {\n"
6138   verifyFormat("void f() { return }\n42");
6139   verifyFormat("void f() {\n"
6165   verifyFormat("int aaaaaaaa =\n"
6169   verifyFormat("function(\n"
6176   verifyFormat("public:");
6177   verifyFormat("class A {\n"
6181   verifyFormat("public\n"
6183   verifyFormat("public\n"
6185   verifyFormat("public\n"
6187   verifyFormat("public\n"
6192   verifyFormat("{");
6193   verifyFormat("#})");
6198   verifyFormat("do {\n}");
6199   verifyFormat("do {\n}\n"
6201   verifyFormat("do {\n}\n"
6203   verifyFormat("do {\n"
6209   verifyFormat("if {\n  foo;\n  foo();\n}");
6210   verifyFormat("switch {\n  foo;\n  foo();\n}");
6212   verifyFormat("while {\n  foo;\n  foo();\n}");
6213   verifyFormat("do {\n  foo;\n  foo();\n} while;");
6242   verifyFormat("int x = {\n"
6249   verifyFormat("return (a)(b){1, 2, 3};");
6253   verifyFormat("vector<int> x{1, 2, 3, 4};");
6254   verifyFormat("vector<int> x{\n"
6257   verifyFormat("vector<T> x{{}, {}, {}, {}};");
6258   verifyFormat("f({1, 2});");
6259   verifyFormat("auto v = Foo{-1};");
6260   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
6261   verifyFormat("Class::Class : member{1, 2, 3} {}");
6262   verifyFormat("new vector<int>{1, 2, 3};");
6263   verifyFormat("new int[3]{1, 2, 3};");
6264   verifyFormat("new int{1};");
6265   verifyFormat("return {arg1, arg2};");
6266   verifyFormat("return {arg1, SomeType{parameter}};");
6267   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
6268   verifyFormat("new T{arg1, arg2};");
6269   verifyFormat("f(MyMap[{composite, key}]);");
6270   verifyFormat("class Class {\n"
6273   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
6274   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
6275   verifyFormat("int a = std::is_integral<int>{} + 0;");
6277   verifyFormat("int foo(int i) { return fo1{}(i); }");
6278   verifyFormat("int foo(int i) { return fo1{}(i); }");
6279   verifyFormat("auto i = decltype(x){};");
6280   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
6281   verifyFormat("Node n{1, Node{1000}, //\n"
6283   verifyFormat("Aaaa aaaaaaa{\n"
6288   verifyFormat("class C : public D {\n"
6291   verifyFormat("class C : public A {\n"
6296   verifyFormat("#define A {a, a},");
6301   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
6313   verifyFormat("const Aaaaaa aaaaa = {\n"
6327   verifyFormat(
6337   verifyFormat("Constructor::Constructor()\n"
6375   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
6376   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
6377   verifyFormat("f({ 1, 2 });", ExtraSpaces);
6378   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
6379   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
6380   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
6381   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
6382   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
6383   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
6384   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
6385   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
6386   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
6387   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
6388   verifyFormat("class Class {\n"
6392   verifyFormat(
6398   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
6399   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
6401   verifyFormat(
6408   verifyFormat(
6412   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaa{\n"
6425   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
6429   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
6435   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
6440   verifyFormat(
6448   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6451   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6455   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
6459   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6462   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6465   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
6468   verifyFormat(
6472   verifyFormat("static auto fields = new vector<string>{\n"
6481   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
6482   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
6488   verifyFormat("vector<int> x = {\n"
6492   verifyFormat("vector<int> x = {\n"
6496   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
6502   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
6507   verifyFormat("int aaaaa[] = {\n"
6515   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
6520   verifyFormat(
6531   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
6537   verifyFormat("void f() {\n"
6547   verifyFormat("void f() { return 42; }");
6548   verifyFormat("void f() {\n"
6552   verifyFormat("void f() {\n"
6555   verifyFormat("{\n"
6559   verifyFormat("{\n"
6563   verifyFormat("void f() {} // comment");
6564   verifyFormat("void f() { int a; } // comment");
6565   verifyFormat("void f() {\n"
6568   verifyFormat("void f() {\n"
6572   verifyFormat("void f() {\n"
6576   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
6577   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
6579   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
6580   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
6581   verifyFormat("class C {\n"
6614   verifyFormat("#define A          \\\n"
6619   verifyFormat("#define A           \\\n"
6622   verifyFormat("#define A            \\\n"
6628   verifyFormat("#define A             \\\n"
6637   verifyFormat("class C {\n"
6641   verifyFormat("int f() {\n"
6649   verifyFormat("struct foo a = {bar};\nint n;");
6650   verifyFormat("class foo a = {bar};\nint n;");
6651   verifyFormat("union foo a = {bar};\nint n;");
6654   verifyFormat("struct foo f() {}\nint n;");
6655   verifyFormat("class foo f() {}\nint n;");
6656   verifyFormat("union foo f() {}\nint n;");
6659   verifyFormat("template <class X> void f() {}\nint n;");
6660   verifyFormat("template <struct X> void f() {}\nint n;");
6661   verifyFormat("template <union X> void f() {}\nint n;");
6664   verifyFormat("struct {\n} n;");
6665   verifyFormat(
6667   verifyFormat("union Z {\n  int n;\n} x;");
6668   verifyFormat("class MACRO Z {\n} n;");
6669   verifyFormat("class MACRO(X) Z {\n} n;");
6670   verifyFormat("class __attribute__(X) Z {\n} n;");
6671   verifyFormat("class __declspec(X) Z {\n} n;");
6672   verifyFormat("class A##B##C {\n} n;");
6673   verifyFormat("class alignas(16) Z {\n} n;");
6674   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
6675   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
6678   verifyFormat("class A::B::C {\n} n;");
6681   verifyFormat(
6689   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
6690   verifyFormat("int i = SomeFunction(a<b, a> b);");
6694   // verifyFormat("class A<int> f() {\n}\nint n;");
6698   verifyFormat("if (true)\n"
6704   verifyFormat("class A:");
6718   verifyFormat("#if AAAA && BBBB");
6719   verifyFormat("#if (AAAA && BBBB)");
6720   verifyFormat("#elif (AAAA && BBBB)");
6722   verifyFormat(
6734   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
6735   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
6736   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
6741   verifyFormat("#define A \\\n"
6744   verifyFormat("#define A \\\n"
6749   verifyFormat("#define A \\\n"
6754   verifyFormat("{\n"
6764   verifyFormat("#define A                   \\\n"
6769   verifyFormat("#define A         \\\n"
6777   verifyFormat("if (0) /* a comment in a strange place */ {\n"
6780   verifyFormat("if (0) /* a comment in a strange place */ {\n"
6785   verifyFormat("while (0) /* a comment in a strange place */ {\n"
6788   verifyFormat("for (;;) /* a comment in a strange place */ {\n"
6791   verifyFormat("do /* a comment in a strange place */ {\n"
6850   verifyFormat(
6869   verifyFormat("void f(int * /* unused */) {}");
6946   verifyFormat("{\n"
6952   verifyFormat("void f(int *a);");
6953   verifyFormat("void f() { f(fint * b); }");
6954   verifyFormat("class A {\n  void f(int *a);\n};");
6955   verifyFormat("class A {\n  int *a;\n};");
6956   verifyFormat("namespace a {\n"
6967   verifyFormat("while");
6968   verifyFormat("operator");
6976   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
6995   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
6997   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
7013   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
7019   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
7025   verifyFormat("- (int)sum:(vector<int>)numbers;");
7029   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
7031   verifyFormat("- (int (*)())foo:(int (*)())f;");
7036   verifyFormat("- foo;");
7037   verifyFormat("- foo:(int)f;");
7042   verifyFormat("@interface Foo : NSObject <NSSomeDelegate> {\n"
7068   verifyFormat("@interface /* wait for it */ Foo\n"
7074   verifyFormat("@interface Foo\n"
7079   verifyFormat("@interface Foo : Bar\n"
7083   verifyFormat("@interface Foo : /**/ Bar /**/ <Baz, /**/ Quux>\n"
7091   verifyFormat("@interface Foo (HackStuff)\n"
7095   verifyFormat("@interface Foo ()\n"
7099   verifyFormat("@interface Foo (HackStuff) <MyProtocol>\n"
7107   verifyFormat("@interface Foo {\n"
7113   verifyFormat("@interface Foo : Bar {\n"
7119   verifyFormat("@interface Foo : Bar <Baz, Quux> {\n"
7125   verifyFormat("@interface Foo (HackStuff) {\n"
7131   verifyFormat("@interface Foo () {\n"
7137   verifyFormat("@interface Foo (HackStuff) <MyProtocol> {\n"
7145   verifyFormat("@interface aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ()<\n"
7155   verifyFormat("@implementation Foo : NSObject {\n"
7181   verifyFormat("@implementation Foo\n"
7195   verifyFormat("@implementation Foo\n"
7209   verifyFormat("@implementation Foo {\n"
7215   verifyFormat("@implementation Foo : Bar {\n"
7221   verifyFormat("@implementation Foo (HackStuff)\n"
7224   verifyFormat("@implementation ObjcClass\n"
7231   verifyFormat("@protocol Foo\n"
7236   verifyFormat("@protocol MyProtocol <NSObject>\n"
7244   verifyFormat("@protocol Foo;\n"
7247   verifyFormat("@protocol Foo\n"
7252   verifyFormat("@protocol myProtocol\n"
7262   verifyFormat("@property(nonatomic, assign, readonly)\n"
7267   verifyFormat("@implementation PR18406\n"
7273   verifyFormat("- (void)doSomethingWith:(GTMFoo *)theFoo\n"
7277   verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n"
7282   verifyFormat("- (instancetype)initXxxxxx:(id<x>)x\n"
7292   verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n"
7298   verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n"
7305   verifyFormat("[foo bar:baz];");
7306   verifyFormat("return [foo bar:baz];");
7307   verifyFormat("return (a)[foo bar:baz];");
7308   verifyFormat("f([foo bar:baz]);");
7309   verifyFormat("f(2, [foo bar:baz]);");
7310   verifyFormat("f(2, a ? b : c);");
7311   verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];");
7314   verifyFormat("int a = +[foo bar:baz];");
7315   verifyFormat("int a = -[foo bar:baz];");
7316   verifyFormat("int a = ![foo bar:baz];");
7317   verifyFormat("int a = ~[foo bar:baz];");
7318   verifyFormat("int a = ++[foo bar:baz];");
7319   verifyFormat("int a = --[foo bar:baz];");
7320   verifyFormat("int a = sizeof [foo bar:baz];");
7321   verifyFormat("int a = alignof [foo bar:baz];", getGoogleStyle());
7322   verifyFormat("int a = &[foo bar:baz];");
7323   verifyFormat("int a = *[foo bar:baz];");
7325   // verifyFormat("int a = (int)[foo bar:baz];");
7326   // verifyFormat("return (int)[foo bar:baz];");
7327   // verifyFormat("(void)[foo bar:baz];");
7328   verifyFormat("return (MyType *)[self.tableView cellForRowAtIndexPath:cell];");
7331   verifyFormat("[foo bar:baz], [foo bar:baz];");
7332   verifyFormat("[foo bar:baz] = [foo bar:baz];");
7333   verifyFormat("[foo bar:baz] *= [foo bar:baz];");
7334   verifyFormat("[foo bar:baz] /= [foo bar:baz];");
7335   verifyFormat("[foo bar:baz] %= [foo bar:baz];");
7336   verifyFormat("[foo bar:baz] += [foo bar:baz];");
7337   verifyFormat("[foo bar:baz] -= [foo bar:baz];");
7338   verifyFormat("[foo bar:baz] <<= [foo bar:baz];");
7339   verifyFormat("[foo bar:baz] >>= [foo bar:baz];");
7340   verifyFormat("[foo bar:baz] &= [foo bar:baz];");
7341   verifyFormat("[foo bar:baz] ^= [foo bar:baz];");
7342   verifyFormat("[foo bar:baz] |= [foo bar:baz];");
7343   verifyFormat("[foo bar:baz] ? [foo bar:baz] : [foo bar:baz];");
7344   verifyFormat("[foo bar:baz] || [foo bar:baz];");
7345   verifyFormat("[foo bar:baz] && [foo bar:baz];");
7346   verifyFormat("[foo bar:baz] | [foo bar:baz];");
7347   verifyFormat("[foo bar:baz] ^ [foo bar:baz];");
7348   verifyFormat("[foo bar:baz] & [foo bar:baz];");
7349   verifyFormat("[foo bar:baz] == [foo bar:baz];");
7350   verifyFormat("[foo bar:baz] != [foo bar:baz];");
7351   verifyFormat("[foo bar:baz] >= [foo bar:baz];");
7352   verifyFormat("[foo bar:baz] <= [foo bar:baz];");
7353   verifyFormat("[foo bar:baz] > [foo bar:baz];");
7354   verifyFormat("[foo bar:baz] < [foo bar:baz];");
7355   verifyFormat("[foo bar:baz] >> [foo bar:baz];");
7356   verifyFormat("[foo bar:baz] << [foo bar:baz];");
7357   verifyFormat("[foo bar:baz] - [foo bar:baz];");
7358   verifyFormat("[foo bar:baz] + [foo bar:baz];");
7359   verifyFormat("[foo bar:baz] * [foo bar:baz];");
7360   verifyFormat("[foo bar:baz] / [foo bar:baz];");
7361   verifyFormat("[foo bar:baz] % [foo bar:baz];");
7364   verifyFormat("return in[42];");
7365   verifyFormat("for (auto v : in[1]) {\n}");
7366   verifyFormat("for (int i = 0; i < in[a]; ++i) {\n}");
7367   verifyFormat("for (int i = 0; in[a] < i; ++i) {\n}");
7368   verifyFormat("for (int i = 0; i < n; ++i, ++in[a]) {\n}");
7369   verifyFormat("for (int i = 0; i < n; ++i, in[a]++) {\n}");
7370   verifyFormat("for (int i = 0; i < f(in[a]); ++i, in[a]++) {\n}");
7371   verifyFormat("for (id foo in [self getStuffFor:bla]) {\n"
7373   verifyFormat("[self aaaaa:MACRO(a, b:, c:)];");
7374   verifyFormat("[self aaaaa:(1 + 2) bbbbb:3];");
7375   verifyFormat("[self aaaaa:(Type)a bbbbb:3];");
7377   verifyFormat("[self stuffWithInt:(4 + 2) float:4.5];");
7378   verifyFormat("[self stuffWithInt:a ? b : c float:4.5];");
7379   verifyFormat("[self stuffWithInt:a ? [self foo:bar] : c];");
7380   verifyFormat("[self stuffWithInt:a ? (e ? f : g) : c];");
7381   verifyFormat("[cond ? obj1 : obj2 methodWithParam:param]");
7382   verifyFormat("[button setAction:@selector(zoomOut:)];");
7383   verifyFormat("[color getRed:&r green:&g blue:&b alpha:&a];");
7385   verifyFormat("arr[[self indexForFoo:a]];");
7386   verifyFormat("throw [self errorFor:a];");
7387   verifyFormat("@throw [self errorFor:a];");
7389   verifyFormat("[(id)foo bar:(id)baz quux:(id)snorf];");
7390   verifyFormat("[(id)foo bar:(id) ? baz : quux];");
7391   verifyFormat("4 > 4 ? (id)a : (id)baz;");
7395   verifyFormat(
7402   verifyFormat(
7406   verifyFormat("[myObj short:arg1 // Force line break\n"
7410   verifyFormat(
7419   verifyFormat(
7429   verifyFormat(
7439   verifyFormat("[contentsContainer replaceSubview:[subviews objectAtIndex:0]\n"
7442   verifyFormat(
7446   verifyFormat(
7450   verifyFormat("[defaultCenter addObserver:self\n"
7454   verifyFormat("[image_rep drawInRect:drawRect\n"
7460   verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7462   verifyFormat("[aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7464   verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaa[aaaaaaaaaaaaaaaaaaaaa]\n"
7466   verifyFormat("[call aaaaaaaa.aaaaaa.aaaaaaaa.aaaaaaaa.aaaaaaaa\n"
7470   verifyFormat(
7474   verifyFormat("[self aaaaaa:bbbbbbbbbbbbb\n"
7478   verifyFormat("[self param:function( //\n"
7480   verifyFormat(
7486   verifyFormat(
7493   verifyFormat(
7495   verifyFormat(
7499   verifyFormat("[self // break\n"
7502   verifyFormat("bool a = ([aaaaaaaa aaaaa] == aaaaaaaaaaaaaaaaa ||\n"
7507   verifyFormat("@autoreleasepool");
7508   verifyFormat("@catch");
7509   verifyFormat("@class");
7510   verifyFormat("@compatibility_alias");
7511   verifyFormat("@defs");
7512   verifyFormat("@dynamic");
7513   verifyFormat("@encode");
7514   verifyFormat("@end");
7515   verifyFormat("@finally");
7516   verifyFormat("@implementation");
7517   verifyFormat("@import");
7518   verifyFormat("@interface");
7519   verifyFormat("@optional");
7520   verifyFormat("@package");
7521   verifyFormat("@private");
7522   verifyFormat("@property");
7523   verifyFormat("@protected");
7524   verifyFormat("@protocol");
7525   verifyFormat("@public");
7526   verifyFormat("@required");
7527   verifyFormat("@selector");
7528   verifyFormat("@synchronized");
7529   verifyFormat("@synthesize");
7530   verifyFormat("@throw");
7531   verifyFormat("@try");
7537   verifyFormat("@ /*foo*/ interface");
7541   verifyFormat("@autoreleasepool {\n"
7544   verifyFormat("@class Foo, Bar;");
7545   verifyFormat("@compatibility_alias AliasName ExistingClass;");
7546   verifyFormat("@dynamic textColor;");
7547   verifyFormat("char *buf1 = @encode(int *);");
7548   verifyFormat("char *buf1 = @encode(typeof(4 * 5));");
7549   verifyFormat("char *buf1 = @encode(int **);");
7550   verifyFormat("Protocol *proto = @protocol(p1);");
7551   verifyFormat("SEL s = @selector(foo:);");
7552   verifyFormat("@synchronized(self) {\n"
7556   verifyFormat("@synthesize dropArrowPosition = dropArrowPosition_;");
7559   verifyFormat("@property(assign, nonatomic) CGFloat hoverAlpha;");
7560   verifyFormat("@property(assign, getter=isEditable) BOOL editable;");
7562   verifyFormat("@property (assign, getter=isEditable) BOOL editable;",
7564   verifyFormat("@property BOOL editable;", getMozillaStyle());
7565   verifyFormat("@property (assign, getter=isEditable) BOOL editable;",
7567   verifyFormat("@property BOOL editable;", getWebKitStyle());
7569   verifyFormat("@import foo.bar;\n"
7574   verifyFormat("- (void)test {\n"
7579   verifyFormat("- (void)test {\n"
7587   verifyFormat("@\"String\"");
7588   verifyFormat("@1");
7589   verifyFormat("@+4.8");
7590   verifyFormat("@-4");
7591   verifyFormat("@1LL");
7592   verifyFormat("@.5");
7593   verifyFormat("@'c'");
7594   verifyFormat("@true");
7596   verifyFormat("NSNumber *smallestInt = @(-INT_MAX - 1);");
7597   verifyFormat("NSNumber *piOverTwo = @(M_PI / 2);");
7598   verifyFormat("NSNumber *favoriteColor = @(Green);");
7599   verifyFormat("NSString *path = @(getenv(\"PATH\"));");
7601   verifyFormat("[dictionary setObject:@(1) forKey:@\"number\"];");
7605   verifyFormat("@{");
7606   verifyFormat("@{}");
7607   verifyFormat("@{@\"one\" : @1}");
7608   verifyFormat("return @{@\"one\" : @1;");
7609   verifyFormat("@{@\"one\" : @1}");
7611   verifyFormat("@{@\"one\" : @{@2 : @1}}");
7612   verifyFormat("@{\n"
7616   verifyFormat("@{1 > 2 ? @\"one\" : @\"two\" : 1 > 2 ? @1 : @2}");
7619   verifyFormat("NSLog(@\"%@\", @{@1 : @2, @2 : @3}[@1]);");
7620   verifyFormat(
7622   verifyFormat(
7625   verifyFormat("NSDictionary *d = @{\n"
7630   verifyFormat(
7640   verifyFormat(
7647   verifyFormat("NSDictionary *d = {\n"
7652   verifyFormat("NSMutableDictionary *dictionary =\n"
7660   verifyFormat(
7669   verifyFormat("@[]");
7670   verifyFormat(
7672   verifyFormat("return @[ @3, @[], @[ @4, @5 ] ];");
7673   verifyFormat("NSArray *array = @[ [foo description] ];");
7675   verifyFormat(
7682   verifyFormat("NSArray *some_variable = @[\n"
7694   verifyFormat("NSArray *array = @[\n"
7700   verifyFormat("NSArray *some_variable = [\n"
7706   verifyFormat(
7711   verifyFormat("[someFunction someLooooooooooooongParameter:@[\n"
7802   verifyFormat(
8027   verifyFormat("string a = \"unterminated;");
8041 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
8127   verifyFormat("void f() {\n"
8130   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
8136   verifyFormat(
8141   verifyFormat("class X {\n"
8152   verifyFormat("void f() {\n"
8159   verifyFormat("class X {\n"
8164   verifyFormat("int x[] = {\n"
8171   verifyFormat("double\n"
8195   verifyFormat("class X {\n"
8202   verifyFormat("#define A                        \\\n"
8212   verifyFormat("class TabWidth4Indent8 {\n"
8222   verifyFormat("class TabWidth4Indent4 {\n"
8232   verifyFormat("class TabWidth8Indent4 {\n"
8253   verifyFormat("{\n"
8262   verifyFormat("enum A {\n"
8275   verifyFormat("class X {\n"
8282   verifyFormat("{\n"
8438   verifyFormat("while(true)\n"
8441   verifyFormat("for(;;)\n"
8444   verifyFormat("if(true)\n"
8449   verifyFormat("do {\n"
8453   verifyFormat("switch(x) {\n"
8458   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
8459   verifyFormat("size_t x = sizeof(x);", NoSpace);
8460   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
8461   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
8462   verifyFormat("alignas(128) char a[128];", NoSpace);
8463   verifyFormat("size_t x = alignof(MyType);", NoSpace);
8464   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
8465   verifyFormat("int f() throw(Deprecated);", NoSpace);
8466   verifyFormat("typedef void (*cb)(int);", NoSpace);
8467   verifyFormat("T A::operator()();", NoSpace);
8468   verifyFormat("X A::operator++(T);", NoSpace);
8473   verifyFormat("int f ();", Space);
8474   verifyFormat("void f (int a, T b) {\n"
8479   verifyFormat("if (true)\n"
8484   verifyFormat("do {\n"
8488   verifyFormat("switch (x) {\n"
8493   verifyFormat("A::A () : a (1) {}", Space);
8494   verifyFormat("void f () __attribute__ ((asdf));", Space);
8495   verifyFormat("*(&a + 1);\n"
8500   verifyFormat("#define A(x) x", Space);
8501   verifyFormat("#define A (x) x", Space);
8502   verifyFormat("#if defined(x)\n"
8505   verifyFormat("auto i = std::make_unique<int> (5);", Space);
8506   verifyFormat("size_t x = sizeof (x);", Space);
8507   verifyFormat("auto f (int x) -> decltype (x);", Space);
8508   verifyFormat("int f (T x) noexcept (x.create ());", Space);
8509   verifyFormat("alignas (128) char a[128];", Space);
8510   verifyFormat("size_t x = alignof (MyType);", Space);
8511   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
8512   verifyFormat("int f () throw (Deprecated);", Space);
8513   verifyFormat("typedef void (*cb) (int);", Space);
8514   verifyFormat("T A::operator() ();", Space);
8515   verifyFormat("X A::operator++ (T);", Space);
8522   verifyFormat("call( x, y, z );", Spaces);
8523   verifyFormat("call();", Spaces);
8524   verifyFormat("std::function<void( int, int )> callback;", Spaces);
8525   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
8527   verifyFormat("while ( (bool)1 )\n"
8530   verifyFormat("for ( ;; )\n"
8533   verifyFormat("if ( true )\n"
8538   verifyFormat("do {\n"
8542   verifyFormat("switch ( x ) {\n"
8550   verifyFormat("Type *A = ( Type * )P;", Spaces);
8551   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
8552   verifyFormat("x = ( int32 )y;", Spaces);
8553   verifyFormat("int a = ( int )(2.0f);", Spaces);
8554   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
8555   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
8556   verifyFormat("#define x (( int )-1)", Spaces);
8561   verifyFormat("call(x, y, z);", Spaces);
8562   verifyFormat("call( );", Spaces);
8563   verifyFormat("std::function<void(int, int)> callback;", Spaces);
8564   verifyFormat("while (( bool )1)\n"
8567   verifyFormat("for (;;)\n"
8570   verifyFormat("if (true)\n"
8575   verifyFormat("do {\n"
8579   verifyFormat("switch (x) {\n"
8587   verifyFormat("call(x, y, z);", Spaces);
8588   verifyFormat("call( );", Spaces);
8589   verifyFormat("std::function<void(int, int)> callback;", Spaces);
8590   verifyFormat("while (( bool ) 1)\n"
8593   verifyFormat("for (;;)\n"
8596   verifyFormat("if (true)\n"
8601   verifyFormat("do {\n"
8605   verifyFormat("switch (x) {\n"
8614   verifyFormat("while ((bool) 1)\n"
8617   verifyFormat("do {\n"
8624   verifyFormat("int a[5];");
8625   verifyFormat("a[3] += 42;");
8630   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
8631   verifyFormat("return [i, args...] {};", Spaces);
8634   verifyFormat("int a[ 5 ];", Spaces);
8635   verifyFormat("a[ 3 ] += 42;", Spaces);
8636   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
8637   verifyFormat("double &operator[](int i) { return 0; }\n"
8640   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
8641   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
8642   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
8646   verifyFormat("int a = 5;");
8647   verifyFormat("a += 42;");
8648   verifyFormat("a or_eq 8;");
8652   verifyFormat("int a= 5;", Spaces);
8653   verifyFormat("a+= 42;", Spaces);
8654   verifyFormat("a or_eq 8;", Spaces);
8660   verifyFormat("int a = 5;\n"
8663   verifyFormat("int a = 5;\n"
8668   verifyFormat("int a           = 5;\n"
8671   verifyFormat("int a           = method();\n"
8674   verifyFormat("a &= 5;\n"
8684   verifyFormat("int i = 1, j = 10;\n"
8687   verifyFormat("something = 2000;\n"
8690   verifyFormat("something = 2000;\n"
8696   verifyFormat("int a   = 5;\n"
8702   verifyFormat("int oneTwoThree = 123;\n"
8706   verifyFormat("int oneTwoThree = 123; // comment\n"
8737   verifyFormat("#define A               \\\n"
8744   verifyFormat("#define A                                                      "
8754   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
8761   verifyFormat("void SomeFunction(int parameter = 0) {\n"
8767   verifyFormat("class C {\n"
8773   verifyFormat("int i = 1;\n"
8779   verifyFormat("int j = 7;\n"
8787   verifyFormat("int i = 1;\n"
8793   verifyFormat("int i = 1;\n"
8799   verifyFormat("auto lambda = []() {\n"
8812   verifyFormat(
8819   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
8824   verifyFormat("int a, b = 1;\n"
8828   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
8836   verifyFormat("float const a = 5;\n"
8839   verifyFormat("int a = 5;\n"
8844   verifyFormat("float const a = 5;\n"
8847   verifyFormat("int         a = method();\n"
8850   verifyFormat("int i = 1, j = 10;\n"
8853   verifyFormat("something = 2000;\n"
8856   verifyFormat("float      something = 2000;\n"
8862   verifyFormat("float a = 5;\n"
8868   verifyFormat("int      oneTwoThree{0}; // comment\n"
8899   verifyFormat("float      something = 2000;\n"
8905   verifyFormat("int      oneTwoThree = {0}; // comment\n"
8933   verifyFormat("#define A              \\\n"
8941   verifyFormat("#define A                    \\\n"
8948   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
8955   verifyFormat("void SomeFunction(int parameter = 0) {\n"
8961   verifyFormat("class C {\n"
8967   verifyFormat("float i = 1;\n"
8973   verifyFormat("float j = 7;\n"
8981   verifyFormat("float              i = 1;\n"
8987   verifyFormat("int                i = 1;\n"
8994   verifyFormat("auto lambda = []() {\n"
9010   verifyFormat(
9023   verifyFormat("float    ii              = 1;\n"
9033   verifyFormat(
9038   verifyFormat("float a, b = 1;\n"
9042   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
9046   verifyFormat("float a, b = 1;\n"
9050   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
9057   verifyFormat("void foo(float     a,\n"
9077   verifyFormat("namespace a\n"
9097   verifyFormat("enum X {\n"
9101   verifyFormat("struct S {\n"
9118   verifyFormat("namespace a {\n"
9143   verifyFormat("struct S\n"
9162   verifyFormat("namespace a {\n"
9179   verifyFormat("void foo()\n"
9190   verifyFormat("#ifdef _DEBUG\n"
9200   verifyFormat("void foo() {}\n"
9212   verifyFormat("void foobar() { int i = 5; }\n"
9224   verifyFormat("namespace a\n"
9245   verifyFormat("void f()\n"
9262   verifyFormat("void f()\n"
9279   verifyFormat("void f(int a)\n"
9299   verifyFormat("enum X\n"
9304   verifyFormat("enum X\n"
9310   verifyFormat("@interface BSApplicationController ()\n"
9318   verifyFormat("#ifdef _DEBUG\n"
9328   verifyFormat("void foo() {}\n"
9340   verifyFormat("void foobar() { int i = 5; }\n"
9349   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
9354   verifyFormat("void (^block)(void) = ^{\n"
9360   verifyFormat("void f()\n"
9365   verifyFormat("int f()\n"
9372   verifyFormat("void f() { int i; }", AllmanBraceStyle);
9374   verifyFormat("void f()\n"
9384 verifyFormat("void f(bool b)\n"
9392   verifyFormat("void f(bool b)\n"
9397   verifyFormat("void f(bool b)\n"
9410   verifyFormat("namespace a\n"
9431   verifyFormat("void f()\n"
9448   verifyFormat("void f()\n"
9466   verifyFormat("void f(int a)\n"
9486   verifyFormat("enum X\n"
9492   verifyFormat("@interface BSApplicationController ()\n"
9500   verifyFormat("#ifdef _DEBUG\n"
9510   verifyFormat("void foo() {}\n"
9522   verifyFormat("void foobar() { int i = 5; }\n"
9534   verifyFormat("namespace a {\n"
9556   verifyFormat("struct S {\n"
9570   verifyFormat("void f() {\n"
9579   verifyFormat("#pragma omp reduction(| : var)");
9580   verifyFormat("#pragma omp reduction(+ : var)");
9589   verifyFormat("#pragma option -C -A");
10100   verifyFormat("\"??????? ? ???????? ?????? ????...\"",
10102   verifyFormat("\"? ? ? ? ? ? ? ? ? ?\"",
10104   verifyFormat("// ??????? ? ???????? ?????? ????...",
10106   verifyFormat("// ? ? ? ? ? ? ? ? ? ?", getLLVMStyleWithColumns(32));
10107   verifyFormat("/* ??????? ? ???????? ?????? ????... */",
10109   verifyFormat("/* ? ? ? ? ? ? ? ? ? ? */",
10205   verifyFormat(
10212   verifyFormat(
10219   verifyFormat(
10230   verifyFormat("SomeClass::Constructor()\n"
10235   verifyFormat("SomeClass::Constructor()\n"
10240   verifyFormat("SomeClass::Constructor()\n"
10243   verifyFormat("SomeClass::Constructor()\n"
10248   verifyFormat("SomeClass::Constructor()\n"
10256   verifyFormat("SomeClass::Constructor()\n"
10261   verifyFormat("SomeClass::Constructor()\n"
10268   verifyFormat("SomeClass::Constructor()\n"
10275   verifyFormat("SomeClass::Constructor()\n"
10283   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
10284   verifyFormat(
10287   verifyFormat(
10293   verifyFormat("SomeClass::Constructor()\n"
10301   verifyFormat("void F(int &i) { i.~int(); }");
10302   verifyFormat("void F(int &i) { i->~int(); }");
10309   verifyFormat("namespace outer {\n"
10321   verifyFormat("switch (variable) {\n"
10348   verifyFormat("void f() { return; }", Style);
10352   verifyFormat("Constructor()\n"
10360   verifyFormat("SomeClass::Constructor()\n"
10370   verifyFormat("SomeClass::Constructor()\n"
10377   verifyFormat("SomeClass::Constructor()\n"
10386   verifyFormat("class C {\n"
10393   verifyFormat("int a; // Do not\n"
10416   verifyFormat("#define aNumber 10", Style);
10455   verifyFormat("[self.a b:c c:d];", Style);
10464   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
10465   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
10466   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
10467   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
10468   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
10469   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
10470   verifyFormat("void f() {\n"
10473   verifyFormat("void f() {\n"
10478   verifyFormat("SomeFunction([]() { // A cool function...\n"
10489   verifyFormat("void f() {\n"
10492   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10494   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
10497   verifyFormat("Constructor()\n"
10501   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
10504   verifyFormat("int i = aaaaaa ? 1 //\n"
10508   verifyFormat("llvm::errs() << \"number of twos is \"\n"
10512   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa([=](\n"
10517   verifyFormat("SomeFunction({[&] {\n"
10523   verifyFormat("SomeFunction({[&] {\n"
10526   verifyFormat("virtual aaaaaaaaaaaaaaaa(std::function<bool()> bbbbbbbbbbbb =\n"
10531   verifyFormat("int c = []() -> int { return 2; }();\n");
10532   verifyFormat("int c = []() -> int * { return 2; }();\n");
10533   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
10534   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
10539   verifyFormat("[a, a]() -> a<1> {};");
10540   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
10544   verifyFormat(
10552   verifyFormat("SomeFunction(\n"
10563   verifyFormat("return [i, args...] {};");
10566   verifyFormat("constexpr char hello[]{\"hello\"};");
10567   verifyFormat("double &operator[](int i) { return 0; }\n"
10569   verifyFormat("std::unique_ptr<int[]> foo() {}");
10570   verifyFormat("int i = a[a][a]->f();");
10571   verifyFormat("int i = (*b)[a]->f();");
10574   verifyFormat("void f() {\n"
10580   verifyFormat("void f() {\n"
10584   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
10589   verifyFormat("auto lambda = []() {\n"
10601   verifyFormat("int (^Block)(int, int);", ShortBlocks);
10602   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
10603   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
10604   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
10605   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
10606   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
10608   verifyFormat("foo(^{ bar(); });", ShortBlocks);
10609   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
10610   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
10612   verifyFormat("[operation setCompletionBlock:^{\n"
10615   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
10618   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
10621   verifyFormat("int a = [operation block:^int(int *i) {\n"
10624   verifyFormat("[myObject doSomethingWith:arg1\n"
10630   verifyFormat("[operation setCompletionBlock:^{\n"
10634   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
10640   verifyFormat("[[SessionService sharedService]\n"
10648   verifyFormat("void (^largeBlock)(void) = ^{\n"
10652   verifyFormat("[[SessionService sharedService]\n"
10662   verifyFormat("[myObject doSomethingWith:arg1\n"
10675   verifyFormat("[myObject doSomethingWith:arg1\n"
10682   verifyFormat("f(^{\n"
10689   verifyFormat("Block b = ^int *(A *a, B *b) {}");
10693   verifyFormat("[operation setCompletionBlock:^{\n"
10703   verifyFormat("[[SessionService sharedService] "
10729   verifyFormat("[myObject doSomethingWith:arg1\n"
10743   verifyFormat("f(^{\n"
10751   verifyFormat("void (^largeBlock)(void) = ^{\n"
10813   verifyFormat("MY_CLASS(C) {\n"
10841   verifyFormat("static_cast< int >(arg);", Spaces);
10842   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
10843   verifyFormat("f< int, float >();", Spaces);
10844   verifyFormat("template <> g() {}", Spaces);
10845   verifyFormat("template < std::vector< int > > f() {}", Spaces);
10846   verifyFormat("std::function< void(int, int) > fct;", Spaces);
10847   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
10852   verifyFormat("A< A< int > >();", Spaces);
10855   verifyFormat("A<A<int> >();", Spaces);
10859   verifyFormat("A< A< int > >();", Spaces);
10862   verifyFormat("A<A<int>>();", Spaces);
10866   verifyFormat("f<<<1, 1>>>();");
10867   verifyFormat("f<<<1, 1, 1, s>>>();");
10868   verifyFormat("f<<<a, b, c, d>>>();");
10870   verifyFormat("f<param><<<1, 1>>>();");
10871   verifyFormat("f<1><<<1, 1>>>();");
10873   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10878   verifyFormat("<<");
10880   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10882   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
OpenGrok
