1 //===- unittest/Format/FormatTestJava.cpp - Formatting tests for Java -----===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "FormatTestBase.h" 10 11 #define DEBUG_TYPE "format-test" 12 13 namespace clang { 14 namespace format { 15 namespace test { 16 namespace { 17 18 class FormatTestJava : public test::FormatTestBase { 19 protected: 20 FormatStyle getDefaultStyle() const override { 21 return getGoogleStyle(FormatStyle::LK_Java); 22 } 23 24 static FormatStyle getStyleWithColumns(unsigned ColumnLimit) { 25 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Java); 26 Style.ColumnLimit = ColumnLimit; 27 return Style; 28 } 29 }; 30 31 TEST_F(FormatTestJava, NoAlternativeOperatorNames) { 32 verifyFormat("someObject.and();"); 33 } 34 35 TEST_F(FormatTestJava, UnderstandsCasts) { 36 verifyFormat("a[b >> 1] = (byte) (c() << 4);"); 37 } 38 39 TEST_F(FormatTestJava, FormatsInstanceOfLikeOperators) { 40 FormatStyle Style = getStyleWithColumns(50); 41 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 42 " instanceof bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 43 Style); 44 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 45 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaa instanceof\n" 46 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 47 Style); 48 verifyFormat("return aaaaaaaaaaaaaaaaaaa instanceof bbbbbbbbbbbbbbbbbbbbbbb\n" 49 " && ccccccccccccccccccc instanceof dddddddddddddddddddddd;"); 50 } 51 52 TEST_F(FormatTestJava, Chromium) { 53 verifyFormat("class SomeClass {\n" 54 " void f() {}\n" 55 " int g() {\n" 56 " return 0;\n" 57 " }\n" 58 " void h() {\n" 59 " while (true) f();\n" 60 " for (;;) f();\n" 61 " if (true) f();\n" 62 " }\n" 63 "}", 64 getChromiumStyle(FormatStyle::LK_Java)); 65 } 66 67 TEST_F(FormatTestJava, QualifiedNames) { 68 verifyFormat("public some.package.Type someFunction( // comment\n" 69 " int parameter) {}"); 70 } 71 72 TEST_F(FormatTestJava, ClassKeyword) { 73 verifyFormat("SomeClass.class.getName();"); 74 verifyFormat("Class c = SomeClass.class;"); 75 } 76 77 TEST_F(FormatTestJava, ClassDeclarations) { 78 verifyFormat("public class SomeClass {\n" 79 " private int a;\n" 80 " private int b;\n" 81 "}"); 82 verifyFormat("public class A {\n" 83 " class B {\n" 84 " int i;\n" 85 " }\n" 86 " class C {\n" 87 " int j;\n" 88 " }\n" 89 "}"); 90 verifyFormat("public class A extends B.C {}"); 91 92 verifyFormat("abstract class SomeClass\n" 93 " extends SomeOtherClass implements SomeInterface {}", 94 getStyleWithColumns(60)); 95 verifyFormat("abstract class SomeClass extends SomeOtherClass\n" 96 " implements SomeInterfaceeeeeeeeeeeee {}", 97 getStyleWithColumns(60)); 98 verifyFormat("abstract class SomeClass\n" 99 " extends SomeOtherClass\n" 100 " implements SomeInterface {}", 101 getStyleWithColumns(40)); 102 verifyFormat("abstract class SomeClass\n" 103 " extends SomeOtherClass\n" 104 " implements SomeInterface,\n" 105 " AnotherInterface {}", 106 getStyleWithColumns(40)); 107 verifyFormat("abstract class SomeClass\n" 108 " implements SomeInterface, AnotherInterface {}", 109 getStyleWithColumns(60)); 110 verifyFormat("@SomeAnnotation()\n" 111 "abstract class aaaaaaaaaaaa\n" 112 " extends bbbbbbbbbbbbbbb implements cccccccccccc {}", 113 getStyleWithColumns(76)); 114 verifyFormat("@SomeAnnotation()\n" 115 "abstract class aaaaaaaaa<a>\n" 116 " extends bbbbbbbbbbbb<b> implements cccccccccccc {}", 117 getStyleWithColumns(76)); 118 verifyFormat("interface SomeInterface<A> extends Foo, Bar {\n" 119 " void doStuff(int theStuff);\n" 120 " void doMoreStuff(int moreStuff);\n" 121 "}"); 122 verifyFormat("public interface SomeInterface {\n" 123 " void doStuff(int theStuff);\n" 124 " void doMoreStuff(int moreStuff);\n" 125 " default void doStuffWithDefault() {}\n" 126 "}"); 127 verifyFormat("@interface SomeInterface {\n" 128 " void doStuff(int theStuff);\n" 129 " void doMoreStuff(int moreStuff);\n" 130 "}"); 131 verifyFormat("public @interface SomeInterface {\n" 132 " void doStuff(int theStuff);\n" 133 " void doMoreStuff(int moreStuff);\n" 134 "}"); 135 verifyFormat("class A {\n" 136 " public @interface SomeInterface {\n" 137 " int stuff;\n" 138 " void doMoreStuff(int moreStuff);\n" 139 " }\n" 140 "}"); 141 verifyFormat("class A {\n" 142 " public @interface SomeInterface {}\n" 143 "}"); 144 } 145 146 TEST_F(FormatTestJava, AnonymousClasses) { 147 verifyFormat("return new A() {\n" 148 " public String toString() {\n" 149 " return \"NotReallyA\";\n" 150 " }\n" 151 "};"); 152 verifyFormat("A a = new A() {\n" 153 " public String toString() {\n" 154 " return \"NotReallyA\";\n" 155 " }\n" 156 "};"); 157 } 158 159 TEST_F(FormatTestJava, EnumDeclarations) { 160 verifyFormat("enum SomeThing { ABC, CDE }"); 161 verifyFormat("enum SomeThing {\n" 162 " ABC,\n" 163 " CDE,\n" 164 "}"); 165 verifyFormat("public class SomeClass {\n" 166 " enum SomeThing { ABC, CDE }\n" 167 " void f() {}\n" 168 "}"); 169 verifyFormat("public class SomeClass implements SomeInterface {\n" 170 " enum SomeThing { ABC, CDE }\n" 171 " void f() {}\n" 172 "}"); 173 verifyFormat("enum SomeThing {\n" 174 " ABC,\n" 175 " CDE;\n" 176 " void f() {}\n" 177 "}"); 178 verifyFormat("enum SomeThing {\n" 179 " void f() {}"); 180 verifyFormat("enum SomeThing {\n" 181 " ABC(1, \"ABC\"),\n" 182 " CDE(2, \"CDE\");\n" 183 " Something(int i, String s) {}\n" 184 "}"); 185 verifyFormat("enum SomeThing {\n" 186 " ABC(new int[] {1, 2}),\n" 187 " CDE(new int[] {2, 3});\n" 188 " Something(int[] i) {}\n" 189 "}"); 190 verifyFormat("public enum SomeThing {\n" 191 " ABC {\n" 192 " public String toString() {\n" 193 " return \"ABC\";\n" 194 " }\n" 195 " },\n" 196 " CDE {\n" 197 " @Override\n" 198 " public String toString() {\n" 199 " return \"CDE\";\n" 200 " }\n" 201 " };\n" 202 " public void f() {}\n" 203 "}"); 204 verifyFormat("private enum SomeEnum implements Foo<?, B> {\n" 205 " ABC {\n" 206 " @Override\n" 207 " public String toString() {\n" 208 " return \"ABC\";\n" 209 " }\n" 210 " },\n" 211 " CDE {\n" 212 " @Override\n" 213 " public String toString() {\n" 214 " return \"CDE\";\n" 215 " }\n" 216 " };\n" 217 "}"); 218 verifyFormat("public enum VeryLongEnum {\n" 219 " ENUM_WITH_MANY_PARAMETERS(\n" 220 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\", \"bbbbbbbbbbbbbbbb\", " 221 "\"cccccccccccccccccccccccc\"),\n" 222 " SECOND_ENUM(\"a\", \"b\", \"c\");\n" 223 " private VeryLongEnum(String a, String b, String c) {}\n" 224 "}"); 225 } 226 227 TEST_F(FormatTestJava, ArrayInitializers) { 228 verifyFormat("new int[] {1, 2, 3, 4};"); 229 verifyFormat("new int[] {\n" 230 " 1,\n" 231 " 2,\n" 232 " 3,\n" 233 " 4,\n" 234 "};"); 235 236 FormatStyle Style = getStyleWithColumns(65); 237 Style.Cpp11BracedListStyle = false; 238 verifyFormat( 239 "expected = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,\n" 240 " 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };", 241 Style); 242 } 243 244 TEST_F(FormatTestJava, ThrowsDeclarations) { 245 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n" 246 " throws LooooooooooooooooooooooooooooongException {}"); 247 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n" 248 " throws LoooooooooongException, LooooooooooongException {}"); 249 } 250 251 TEST_F(FormatTestJava, Annotations) { 252 verifyFormat("@Override\n" 253 "public String toString() {}"); 254 verifyFormat("@Override\n" 255 "@Nullable\n" 256 "public String getNameIfPresent() {}"); 257 verifyFormat("@Override // comment\n" 258 "@Nullable\n" 259 "public String getNameIfPresent() {}"); 260 verifyFormat("@java.lang.Override // comment\n" 261 "@Nullable\n" 262 "public String getNameIfPresent() {}"); 263 264 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n" 265 "public void doSomething() {}"); 266 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n" 267 "@Author(name = \"abc\")\n" 268 "public void doSomething() {}"); 269 270 verifyFormat("DoSomething(new A() {\n" 271 " @Override\n" 272 " public String toString() {}\n" 273 "});"); 274 275 verifyFormat("void SomeFunction(@Nullable String something) {}"); 276 verifyFormat("void SomeFunction(@org.llvm.Nullable String something) {}"); 277 278 verifyFormat("@Partial @Mock DataLoader loader;"); 279 verifyFormat("@Partial\n" 280 "@Mock\n" 281 "DataLoader loader;", 282 getChromiumStyle(FormatStyle::LK_Java)); 283 verifyFormat("@SuppressWarnings(value = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")\n" 284 "public static int iiiiiiiiiiiiiiiiiiiiiiii;"); 285 286 verifyFormat("@SomeAnnotation(\"With some really looooooooooooooong text\")\n" 287 "private static final long something = 0L;"); 288 verifyFormat("@org.llvm.Qualified(\"With some really looooooooooong text\")\n" 289 "private static final long something = 0L;"); 290 verifyFormat("@Mock\n" 291 "DataLoader loooooooooooooooooooooooader =\n" 292 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 293 getStyleWithColumns(60)); 294 verifyFormat("@org.llvm.QualifiedMock\n" 295 "DataLoader loooooooooooooooooooooooader =\n" 296 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 297 getStyleWithColumns(60)); 298 verifyFormat("@Test(a)\n" 299 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 300 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa);"); 301 verifyFormat("@SomeAnnotation(\n" 302 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa)\n" 303 "int i;", 304 getStyleWithColumns(50)); 305 verifyFormat("@Test\n" 306 "ReturnType doSomething(\n" 307 " String aaaaaaaaaaaaa, String bbbbbbbbbbbbbbb) {}", 308 getStyleWithColumns(60)); 309 verifyFormat("{\n" 310 " boolean someFunction(\n" 311 " @Param(aaaaaaaaaaaaaaaa) String aaaaa,\n" 312 " String bbbbbbbbbbbbbbb) {}\n" 313 "}", 314 getStyleWithColumns(60)); 315 verifyFormat("@Annotation(\"Some\"\n" 316 " + \" text\")\n" 317 "List<Integer> list;"); 318 319 verifyFormat( 320 "@Test\n" 321 "@Feature({\"Android-TabSwitcher\"})\n" 322 "@CommandLineFlags.Add({ChromeSwitches.DISABLE_FIRST_RUN_EXPERIENCE})\n" 323 "@Features.EnableFeatures({FEATURE})\n" 324 "public void test(@Foo.bar(\"baz\") @Quux.Qoob int theFirstParaaaaam,\n" 325 " @Foo.bar(\"baz\") @Quux.Qoob int theSecondParaaaaaaaaaaaaaaaam) {}"); 326 } 327 328 TEST_F(FormatTestJava, Generics) { 329 verifyFormat("Iterable<?> a;"); 330 verifyFormat("Iterable<?> a;"); 331 verifyFormat("Iterable<? extends SomeObject> a;"); 332 333 verifyFormat("A.<B>doSomething();"); 334 verifyFormat("A.<B<C>>doSomething();"); 335 verifyFormat("A.<B<C<D>>>doSomething();"); 336 verifyFormat("A.<B<C<D<E>>>>doSomething();"); 337 338 verifyFormat("OrderedPair<String, List<Box<Integer>>> p = null;"); 339 340 verifyFormat("@Override\n" 341 "public Map<String, ?> getAll() {}"); 342 343 verifyFormat("public <R> ArrayList<R> get() {}"); 344 verifyFormat("protected <R> ArrayList<R> get() {}"); 345 verifyFormat("private <R> ArrayList<R> get() {}"); 346 verifyFormat("public static <R> ArrayList<R> get() {}"); 347 verifyFormat("public static native <R> ArrayList<R> get();"); 348 verifyFormat("public final <X> Foo foo() {}"); 349 verifyFormat("public abstract <X> Foo foo();"); 350 verifyFormat("<T extends B> T getInstance(Class<T> type);"); 351 verifyFormat("Function<F, ? extends T> function;"); 352 353 verifyFormat("private Foo<X, Y>[] foos;"); 354 verifyFormat("Foo<X, Y>[] foos = this.foos;"); 355 verifyFormat("return (a instanceof List<?>)\n" 356 " ? aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 357 " : aaaaaaaaaaaaaaaaaaaaaaa;", 358 getStyleWithColumns(60)); 359 360 verifyFormat( 361 "SomeLoooooooooooooooooooooongType name =\n" 362 " SomeType.foo(someArgument)\n" 363 " .<X>method()\n" 364 " .aaaaaaaaaaaaaaaaaaa()\n" 365 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 366 } 367 368 TEST_F(FormatTestJava, StringConcatenation) { 369 verifyFormat("String someString = \"abc\"\n" 370 " + \"cde\";"); 371 } 372 373 TEST_F(FormatTestJava, TryCatchFinally) { 374 verifyFormat("try {\n" 375 " Something();\n" 376 "} catch (SomeException e) {\n" 377 " HandleException(e);\n" 378 "}"); 379 verifyFormat("try {\n" 380 " Something();\n" 381 "} finally {\n" 382 " AlwaysDoThis();\n" 383 "}"); 384 verifyFormat("try {\n" 385 " Something();\n" 386 "} catch (SomeException e) {\n" 387 " HandleException(e);\n" 388 "} finally {\n" 389 " AlwaysDoThis();\n" 390 "}"); 391 392 verifyFormat("try {\n" 393 " Something();\n" 394 "} catch (SomeException | OtherException e) {\n" 395 " HandleException(e);\n" 396 "}"); 397 } 398 399 TEST_F(FormatTestJava, TryWithResources) { 400 verifyFormat("try (SomeResource rs = someFunction()) {\n" 401 " Something();\n" 402 "}"); 403 verifyFormat("try (SomeResource rs = someFunction()) {\n" 404 " Something();\n" 405 "} catch (SomeException e) {\n" 406 " HandleException(e);\n" 407 "}"); 408 } 409 410 TEST_F(FormatTestJava, SynchronizedKeyword) { 411 verifyFormat("synchronized (mData) {\n" 412 " // ...\n" 413 "}"); 414 415 FormatStyle Style = getLLVMStyle(FormatStyle::LK_Java); 416 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 417 418 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 419 Style.BraceWrapping.AfterFunction = false; 420 verifyFormat("synchronized (mData)\n" 421 "{\n" 422 " // ...\n" 423 "}", 424 Style); 425 426 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 427 Style.BraceWrapping.AfterFunction = true; 428 verifyFormat("synchronized (mData) {\n" 429 " // ...\n" 430 "}", 431 Style); 432 } 433 434 TEST_F(FormatTestJava, AssertKeyword) { 435 verifyFormat("assert a && b;"); 436 verifyFormat("assert (a && b);"); 437 } 438 439 TEST_F(FormatTestJava, PackageDeclarations) { 440 verifyFormat("package some.really.loooooooooooooooooooooong.package;", 441 getStyleWithColumns(50)); 442 } 443 444 TEST_F(FormatTestJava, ImportDeclarations) { 445 verifyFormat("import some.really.loooooooooooooooooooooong.imported.Class;", 446 getStyleWithColumns(50)); 447 verifyFormat("import static some.really.looooooooooooooooong.imported.Class;", 448 getStyleWithColumns(50)); 449 } 450 451 TEST_F(FormatTestJava, MethodDeclarations) { 452 verifyFormat("void methodName(Object arg1,\n" 453 " Object arg2, Object arg3) {}", 454 getStyleWithColumns(40)); 455 verifyFormat("void methodName(\n" 456 " Object arg1, Object arg2) {}", 457 getStyleWithColumns(40)); 458 } 459 460 TEST_F(FormatTestJava, MethodReference) { 461 EXPECT_EQ("private void foo() {\n" 462 " f(this::methodReference);\n" 463 " f(C.super::methodReference);\n" 464 " Consumer<String> c = System.out::println;\n" 465 " Iface<Integer> mRef = Ty::<Integer>meth;\n" 466 "}", 467 format("private void foo() {\n" 468 " f(this ::methodReference);\n" 469 " f(C.super ::methodReference);\n" 470 " Consumer<String> c = System.out ::println;\n" 471 " Iface<Integer> mRef = Ty :: <Integer> meth;\n" 472 "}")); 473 } 474 475 TEST_F(FormatTestJava, CppKeywords) { 476 verifyFormat("public void union(Type a, Type b);"); 477 verifyFormat("public void struct(Object o);"); 478 verifyFormat("public void delete(Object o);"); 479 verifyFormat("return operator && (aa);"); 480 } 481 482 TEST_F(FormatTestJava, NeverAlignAfterReturn) { 483 verifyFormat("return aaaaaaaaaaaaaaaaaaa\n" 484 " && bbbbbbbbbbbbbbbbbbb\n" 485 " && ccccccccccccccccccc;", 486 getStyleWithColumns(40)); 487 verifyFormat("return (result == null)\n" 488 " ? aaaaaaaaaaaaaaaaa\n" 489 " : bbbbbbbbbbbbbbbbb;", 490 getStyleWithColumns(40)); 491 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n" 492 " .bbbbbbbbbbbbbbbbbbb()\n" 493 " .ccccccccccccccccccc();", 494 getStyleWithColumns(40)); 495 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n" 496 " .bbbbbbbbbbbbbbbbbbb(\n" 497 " ccccccccccccccc)\n" 498 " .ccccccccccccccccccc();", 499 getStyleWithColumns(40)); 500 } 501 502 TEST_F(FormatTestJava, FormatsInnerBlocks) { 503 verifyFormat("someObject.someFunction(new Runnable() {\n" 504 " @Override\n" 505 " public void run() {\n" 506 " System.out.println(42);\n" 507 " }\n" 508 "}, someOtherParameter);"); 509 verifyFormat("someFunction(new Runnable() {\n" 510 " public void run() {\n" 511 " System.out.println(42);\n" 512 " }\n" 513 "});"); 514 verifyFormat("someObject.someFunction(\n" 515 " new Runnable() {\n" 516 " @Override\n" 517 " public void run() {\n" 518 " System.out.println(42);\n" 519 " }\n" 520 " },\n" 521 " new Runnable() {\n" 522 " @Override\n" 523 " public void run() {\n" 524 " System.out.println(43);\n" 525 " }\n" 526 " },\n" 527 " someOtherParameter);"); 528 } 529 530 TEST_F(FormatTestJava, FormatsLambdas) { 531 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb) -> aaaaaaaaaa + bbbbbbbbbb;"); 532 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb)\n" 533 " -> aaaaaaaaaa + bbbbbbbbbb;", 534 getStyleWithColumns(40)); 535 verifyFormat("Runnable someLambda = () -> DoSomething();"); 536 verifyFormat("Runnable someLambda = () -> {\n" 537 " DoSomething();\n" 538 "}"); 539 540 verifyFormat("Runnable someLambda =\n" 541 " (int aaaaa) -> DoSomething(aaaaa);", 542 getStyleWithColumns(40)); 543 } 544 545 TEST_F(FormatTestJava, BreaksStringLiterals) { 546 verifyFormat("x = \"some text \"\n" 547 " + \"other\";", 548 "x = \"some text other\";", getStyleWithColumns(18)); 549 } 550 551 TEST_F(FormatTestJava, AlignsBlockComments) { 552 EXPECT_EQ("/*\n" 553 " * Really multi-line\n" 554 " * comment.\n" 555 " */\n" 556 "void f() {}", 557 format(" /*\n" 558 " * Really multi-line\n" 559 " * comment.\n" 560 " */\n" 561 " void f() {}")); 562 } 563 564 TEST_F(FormatTestJava, AlignDeclarations) { 565 FormatStyle Style = getLLVMStyle(FormatStyle::LK_Java); 566 Style.AlignConsecutiveDeclarations.Enabled = true; 567 verifyFormat("private final String[] args;\n" 568 "private final A_ParserHelper parserHelper;\n" 569 "private final int numOfCmdArgs;\n" 570 "private int numOfCmdArgs;\n" 571 "private String[] args;", 572 Style); 573 } 574 575 TEST_F(FormatTestJava, KeepsDelimitersOnOwnLineInJavaDocComments) { 576 EXPECT_EQ("/**\n" 577 " * javadoc line 1\n" 578 " * javadoc line 2\n" 579 " */", 580 format("/** javadoc line 1\n" 581 " * javadoc line 2 */")); 582 } 583 584 TEST_F(FormatTestJava, RetainsLogicalShifts) { 585 verifyFormat("void f() {\n" 586 " int a = 1;\n" 587 " a >>>= 1;\n" 588 "}"); 589 verifyFormat("void f() {\n" 590 " int a = 1;\n" 591 " a = a >>> 1;\n" 592 "}"); 593 } 594 595 TEST_F(FormatTestJava, ShortFunctions) { 596 FormatStyle Style = getLLVMStyle(FormatStyle::LK_Java); 597 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 598 verifyFormat("enum Enum {\n" 599 " E1,\n" 600 " E2;\n" 601 " void f() { return; }\n" 602 "}", 603 Style); 604 } 605 606 } // namespace 607 } // namespace test 608 } // namespace format 609 } // namespace clang 610