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