1 //===- unittest/Format/FormatTestJava.cpp - Formatting tests for Java -----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "FormatTestUtils.h"
11 #include "clang/Format/Format.h"
12 #include "llvm/Support/Debug.h"
13 #include "gtest/gtest.h"
14
15 #define DEBUG_TYPE "format-test"
16
17 namespace clang {
18 namespace format {
19
20 class FormatTestJava : public ::testing::Test {
21 protected:
format(llvm::StringRef Code,unsigned Offset,unsigned Length,const FormatStyle & Style)22 static std::string format(llvm::StringRef Code, unsigned Offset,
23 unsigned Length, const FormatStyle &Style) {
24 DEBUG(llvm::errs() << "---\n");
25 DEBUG(llvm::errs() << Code << "\n\n");
26 std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
27 tooling::Replacements Replaces = reformat(Style, Code, Ranges);
28 std::string Result = applyAllReplacements(Code, Replaces);
29 EXPECT_NE("", Result);
30 DEBUG(llvm::errs() << "\n" << Result << "\n\n");
31 return Result;
32 }
33
format(llvm::StringRef Code,const FormatStyle & Style=getGoogleStyle (FormatStyle::LK_Java))34 static std::string format(
35 llvm::StringRef Code,
36 const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_Java)) {
37 return format(Code, 0, Code.size(), Style);
38 }
39
getStyleWithColumns(unsigned ColumnLimit)40 static FormatStyle getStyleWithColumns(unsigned ColumnLimit) {
41 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Java);
42 Style.ColumnLimit = ColumnLimit;
43 return Style;
44 }
45
verifyFormat(llvm::StringRef Code,const FormatStyle & Style=getGoogleStyle (FormatStyle::LK_Java))46 static void verifyFormat(
47 llvm::StringRef Code,
48 const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_Java)) {
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 }
71
TEST_F(FormatTestJava,Chromium)72 TEST_F(FormatTestJava, Chromium) {
73 verifyFormat("class SomeClass {\n"
74 " void f() {}\n"
75 " int g() {\n"
76 " return 0;\n"
77 " }\n"
78 " void h() {\n"
79 " while (true) f();\n"
80 " for (;;) f();\n"
81 " if (true) f();\n"
82 " }\n"
83 "}",
84 getChromiumStyle(FormatStyle::LK_Java));
85 }
86
TEST_F(FormatTestJava,QualifiedNames)87 TEST_F(FormatTestJava, QualifiedNames) {
88 verifyFormat("public some.package.Type someFunction( // comment\n"
89 " int parameter) {}");
90 }
91
TEST_F(FormatTestJava,ClassKeyword)92 TEST_F(FormatTestJava, ClassKeyword) {
93 verifyFormat("SomeClass.class.getName();");
94 verifyFormat("Class c = SomeClass.class;");
95 }
96
TEST_F(FormatTestJava,ClassDeclarations)97 TEST_F(FormatTestJava, ClassDeclarations) {
98 verifyFormat("public class SomeClass {\n"
99 " private int a;\n"
100 " private int b;\n"
101 "}");
102 verifyFormat("public class A {\n"
103 " class B {\n"
104 " int i;\n"
105 " }\n"
106 " class C {\n"
107 " int j;\n"
108 " }\n"
109 "}");
110 verifyFormat("public class A extends B.C {}");
111
112 verifyFormat("abstract class SomeClass\n"
113 " extends SomeOtherClass implements SomeInterface {}",
114 getStyleWithColumns(60));
115 verifyFormat("abstract class SomeClass extends SomeOtherClass\n"
116 " implements SomeInterfaceeeeeeeeeeeee {}",
117 getStyleWithColumns(60));
118 verifyFormat("abstract class SomeClass\n"
119 " extends SomeOtherClass\n"
120 " implements SomeInterface {}",
121 getStyleWithColumns(40));
122 verifyFormat("abstract class SomeClass\n"
123 " extends SomeOtherClass\n"
124 " implements SomeInterface,\n"
125 " AnotherInterface {}",
126 getStyleWithColumns(40));
127 verifyFormat("abstract class SomeClass\n"
128 " implements SomeInterface, AnotherInterface {}",
129 getStyleWithColumns(60));
130 verifyFormat("@SomeAnnotation()\n"
131 "abstract class aaaaaaaaaaaa\n"
132 " extends bbbbbbbbbbbbbbb implements cccccccccccc {}",
133 getStyleWithColumns(76));
134 verifyFormat("@SomeAnnotation()\n"
135 "abstract class aaaaaaaaa<a>\n"
136 " extends bbbbbbbbbbbb<b> implements cccccccccccc {}",
137 getStyleWithColumns(76));
138 verifyFormat("interface SomeInterface<A> extends Foo, Bar {\n"
139 " void doStuff(int theStuff);\n"
140 " void doMoreStuff(int moreStuff);\n"
141 "}");
142 verifyFormat("public interface SomeInterface {\n"
143 " void doStuff(int theStuff);\n"
144 " void doMoreStuff(int moreStuff);\n"
145 "}");
146 verifyFormat("@interface SomeInterface {\n"
147 " void doStuff(int theStuff);\n"
148 " void doMoreStuff(int moreStuff);\n"
149 "}");
150 verifyFormat("public @interface SomeInterface {\n"
151 " void doStuff(int theStuff);\n"
152 " void doMoreStuff(int moreStuff);\n"
153 "}");
154 }
155
TEST_F(FormatTestJava,EnumDeclarations)156 TEST_F(FormatTestJava, EnumDeclarations) {
157 verifyFormat("enum SomeThing { ABC, CDE }");
158 verifyFormat("enum SomeThing {\n"
159 " ABC,\n"
160 " CDE,\n"
161 "}");
162 verifyFormat("public class SomeClass {\n"
163 " enum SomeThing { ABC, CDE }\n"
164 " void f() {}\n"
165 "}");
166 verifyFormat("public class SomeClass implements SomeInterface {\n"
167 " enum SomeThing { ABC, CDE }\n"
168 " void f() {}\n"
169 "}");
170 verifyFormat("enum SomeThing {\n"
171 " ABC,\n"
172 " CDE;\n"
173 " void f() {}\n"
174 "}");
175 verifyFormat("enum SomeThing {\n"
176 " ABC(1, \"ABC\"),\n"
177 " CDE(2, \"CDE\");\n"
178 " Something(int i, String s) {}\n"
179 "}");
180 verifyFormat("enum SomeThing {\n"
181 " ABC(new int[] {1, 2}),\n"
182 " CDE(new int[] {2, 3});\n"
183 " Something(int[] i) {}\n"
184 "}");
185 verifyFormat("public enum SomeThing {\n"
186 " ABC {\n"
187 " public String toString() {\n"
188 " return \"ABC\";\n"
189 " }\n"
190 " },\n"
191 " CDE {\n"
192 " @Override\n"
193 " public String toString() {\n"
194 " return \"CDE\";\n"
195 " }\n"
196 " };\n"
197 " public void f() {}\n"
198 "}");
199 verifyFormat("private enum SomeEnum implements Foo<?, B> {\n"
200 " ABC {\n"
201 " @Override\n"
202 " public String toString() {\n"
203 " return \"ABC\";\n"
204 " }\n"
205 " },\n"
206 " CDE {\n"
207 " @Override\n"
208 " public String toString() {\n"
209 " return \"CDE\";\n"
210 " }\n"
211 " };\n"
212 "}");
213 }
214
TEST_F(FormatTestJava,ArrayInitializers)215 TEST_F(FormatTestJava, ArrayInitializers) {
216 verifyFormat("new int[] {1, 2, 3, 4};");
217 verifyFormat("new int[] {\n"
218 " 1, 2, 3, 4,\n"
219 "};");
220
221 FormatStyle Style = getStyleWithColumns(65);
222 Style.Cpp11BracedListStyle = false;
223 verifyFormat(
224 "expected = new int[] { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,\n"
225 " 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };",
226 Style);
227 }
228
TEST_F(FormatTestJava,ThrowsDeclarations)229 TEST_F(FormatTestJava, ThrowsDeclarations) {
230 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n"
231 " throws LooooooooooooooooooooooooooooongException {}");
232 verifyFormat("public void doSooooooooooooooooooooooooooomething()\n"
233 " throws LoooooooooongException, LooooooooooongException {}");
234 }
235
TEST_F(FormatTestJava,Annotations)236 TEST_F(FormatTestJava, Annotations) {
237 verifyFormat("@Override\n"
238 "public String toString() {}");
239 verifyFormat("@Override\n"
240 "@Nullable\n"
241 "public String getNameIfPresent() {}");
242 verifyFormat("@Override // comment\n"
243 "@Nullable\n"
244 "public String getNameIfPresent() {}");
245 verifyFormat("@java.lang.Override // comment\n"
246 "@Nullable\n"
247 "public String getNameIfPresent() {}");
248
249 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n"
250 "public void doSomething() {}");
251 verifyFormat("@SuppressWarnings(value = \"unchecked\")\n"
252 "@Author(name = \"abc\")\n"
253 "public void doSomething() {}");
254
255 verifyFormat("DoSomething(new A() {\n"
256 " @Override\n"
257 " public String toString() {}\n"
258 "});");
259
260 verifyFormat("void SomeFunction(@Nullable String something) {}");
261 verifyFormat("void SomeFunction(@org.llvm.Nullable String something) {}");
262
263 verifyFormat("@Partial @Mock DataLoader loader;");
264 verifyFormat("@SuppressWarnings(value = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")\n"
265 "public static int iiiiiiiiiiiiiiiiiiiiiiii;");
266
267 verifyFormat("@SomeAnnotation(\"With some really looooooooooooooong text\")\n"
268 "private static final long something = 0L;");
269 verifyFormat("@org.llvm.Qualified(\"With some really looooooooooong text\")\n"
270 "private static final long something = 0L;");
271 verifyFormat("@Mock\n"
272 "DataLoader loooooooooooooooooooooooader =\n"
273 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
274 getStyleWithColumns(60));
275 verifyFormat("@org.llvm.QualifiedMock\n"
276 "DataLoader loooooooooooooooooooooooader =\n"
277 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
278 getStyleWithColumns(60));
279 verifyFormat("@Test(a)\n"
280 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
281 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa);");
282 verifyFormat("@SomeAnnotation(\n"
283 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa)\n"
284 "int i;",
285 getStyleWithColumns(50));
286 verifyFormat("@Test\n"
287 "ReturnType doSomething(\n"
288 " String aaaaaaaaaaaaa, String bbbbbbbbbbbbbbb) {}",
289 getStyleWithColumns(60));
290 verifyFormat("{\n"
291 " boolean someFunction(\n"
292 " @Param(aaaaaaaaaaaaaaaa) String aaaaa,\n"
293 " String bbbbbbbbbbbbbbb) {}\n"
294 "}",
295 getStyleWithColumns(60));
296 }
297
TEST_F(FormatTestJava,Generics)298 TEST_F(FormatTestJava, Generics) {
299 verifyFormat("Iterable<?> a;");
300 verifyFormat("Iterable<?> a;");
301 verifyFormat("Iterable<? extends SomeObject> a;");
302
303 verifyFormat("A.<B>doSomething();");
304
305 verifyFormat("@Override\n"
306 "public Map<String, ?> getAll() {}");
307
308 verifyFormat("public <R> ArrayList<R> get() {}");
309 verifyFormat("protected <R> ArrayList<R> get() {}");
310 verifyFormat("private <R> ArrayList<R> get() {}");
311 verifyFormat("public static <R> ArrayList<R> get() {}");
312 verifyFormat("public static native <R> ArrayList<R> get();");
313 verifyFormat("public final <X> Foo foo() {}");
314 verifyFormat("public abstract <X> Foo foo();");
315 verifyFormat("<T extends B> T getInstance(Class<T> type);");
316 verifyFormat("Function<F, ? extends T> function;");
317
318 verifyFormat("private Foo<X, Y>[] foos;");
319 verifyFormat("Foo<X, Y>[] foos = this.foos;");
320 verifyFormat("return (a instanceof List<?>)\n"
321 " ? aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
322 " : aaaaaaaaaaaaaaaaaaaaaaa;",
323 getStyleWithColumns(60));
324
325 verifyFormat(
326 "SomeLoooooooooooooooooooooongType name =\n"
327 " SomeType.foo(someArgument)\n"
328 " .<X>method()\n"
329 " .aaaaaaaaaaaaaaaaaaa()\n"
330 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
331 }
332
TEST_F(FormatTestJava,StringConcatenation)333 TEST_F(FormatTestJava, StringConcatenation) {
334 verifyFormat("String someString = \"abc\"\n"
335 " + \"cde\";");
336 }
337
TEST_F(FormatTestJava,TryCatchFinally)338 TEST_F(FormatTestJava, TryCatchFinally) {
339 verifyFormat("try {\n"
340 " Something();\n"
341 "} catch (SomeException e) {\n"
342 " HandleException(e);\n"
343 "}");
344 verifyFormat("try {\n"
345 " Something();\n"
346 "} finally {\n"
347 " AlwaysDoThis();\n"
348 "}");
349 verifyFormat("try {\n"
350 " Something();\n"
351 "} catch (SomeException e) {\n"
352 " HandleException(e);\n"
353 "} finally {\n"
354 " AlwaysDoThis();\n"
355 "}");
356
357 verifyFormat("try {\n"
358 " Something();\n"
359 "} catch (SomeException | OtherException e) {\n"
360 " HandleException(e);\n"
361 "}");
362 }
363
TEST_F(FormatTestJava,TryWithResources)364 TEST_F(FormatTestJava, TryWithResources) {
365 verifyFormat("try (SomeResource rs = someFunction()) {\n"
366 " Something();\n"
367 "}");
368 verifyFormat("try (SomeResource rs = someFunction()) {\n"
369 " Something();\n"
370 "} catch (SomeException e) {\n"
371 " HandleException(e);\n"
372 "}");
373 }
374
TEST_F(FormatTestJava,SynchronizedKeyword)375 TEST_F(FormatTestJava, SynchronizedKeyword) {
376 verifyFormat("synchronized (mData) {\n"
377 " // ...\n"
378 "}");
379 }
380
TEST_F(FormatTestJava,PackageDeclarations)381 TEST_F(FormatTestJava, PackageDeclarations) {
382 verifyFormat("package some.really.loooooooooooooooooooooong.package;",
383 getStyleWithColumns(50));
384 }
385
TEST_F(FormatTestJava,ImportDeclarations)386 TEST_F(FormatTestJava, ImportDeclarations) {
387 verifyFormat("import some.really.loooooooooooooooooooooong.imported.Class;",
388 getStyleWithColumns(50));
389 verifyFormat("import static some.really.looooooooooooooooong.imported.Class;",
390 getStyleWithColumns(50));
391 }
392
TEST_F(FormatTestJava,MethodDeclarations)393 TEST_F(FormatTestJava, MethodDeclarations) {
394 verifyFormat("void methodName(Object arg1,\n"
395 " Object arg2, Object arg3) {}",
396 getStyleWithColumns(40));
397 verifyFormat("void methodName(\n"
398 " Object arg1, Object arg2) {}",
399 getStyleWithColumns(40));
400 }
401
TEST_F(FormatTestJava,CppKeywords)402 TEST_F(FormatTestJava, CppKeywords) {
403 verifyFormat("public void union(Type a, Type b);");
404 verifyFormat("public void struct(Object o);");
405 verifyFormat("public void delete(Object o);");
406 }
407
TEST_F(FormatTestJava,NeverAlignAfterReturn)408 TEST_F(FormatTestJava, NeverAlignAfterReturn) {
409 verifyFormat("return aaaaaaaaaaaaaaaaaaa\n"
410 " && bbbbbbbbbbbbbbbbbbb\n"
411 " && ccccccccccccccccccc;",
412 getStyleWithColumns(40));
413 verifyFormat("return (result == null)\n"
414 " ? aaaaaaaaaaaaaaaaa\n"
415 " : bbbbbbbbbbbbbbbbb;",
416 getStyleWithColumns(40));
417 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n"
418 " .bbbbbbbbbbbbbbbbbbb()\n"
419 " .ccccccccccccccccccc();",
420 getStyleWithColumns(40));
421 verifyFormat("return aaaaaaaaaaaaaaaaaaa()\n"
422 " .bbbbbbbbbbbbbbbbbbb(\n"
423 " ccccccccccccccc)\n"
424 " .ccccccccccccccccccc();",
425 getStyleWithColumns(40));
426 }
427
TEST_F(FormatTestJava,FormatsInnerBlocks)428 TEST_F(FormatTestJava, FormatsInnerBlocks) {
429 verifyFormat("someObject.someFunction(new Runnable() {\n"
430 " @Override\n"
431 " public void run() {\n"
432 " System.out.println(42);\n"
433 " }\n"
434 "}, someOtherParameter);");
435 verifyFormat("someFunction(new Runnable() {\n"
436 " public void run() {\n"
437 " System.out.println(42);\n"
438 " }\n"
439 "});");
440 verifyFormat("someObject.someFunction(\n"
441 " new Runnable() {\n"
442 " @Override\n"
443 " public void run() {\n"
444 " System.out.println(42);\n"
445 " }\n"
446 " },\n"
447 " new Runnable() {\n"
448 " @Override\n"
449 " public void run() {\n"
450 " System.out.println(43);\n"
451 " }\n"
452 " },\n"
453 " someOtherParameter);");
454 }
455
TEST_F(FormatTestJava,FormatsLambdas)456 TEST_F(FormatTestJava, FormatsLambdas) {
457 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb) -> aaaaaaaaaa + bbbbbbbbbb;");
458 verifyFormat("(aaaaaaaaaa, bbbbbbbbbb)\n"
459 " -> aaaaaaaaaa + bbbbbbbbbb;",
460 getStyleWithColumns(40));
461 verifyFormat("Runnable someLambda = () -> DoSomething();");
462 verifyFormat("Runnable someLambda = () -> {\n"
463 " DoSomething();\n"
464 "}");
465
466 verifyFormat("Runnable someLambda =\n"
467 " (int aaaaa) -> DoSomething(aaaaa);",
468 getStyleWithColumns(40));
469 }
470
TEST_F(FormatTestJava,BreaksStringLiterals)471 TEST_F(FormatTestJava, BreaksStringLiterals) {
472 // FIXME: String literal breaking is currently disabled for Java and JS, as it
473 // requires strings to be merged using "+" which we don't support.
474 EXPECT_EQ("\"some text other\";",
475 format("\"some text other\";", getStyleWithColumns(14)));
476 }
477
TEST_F(FormatTestJava,AlignsBlockComments)478 TEST_F(FormatTestJava, AlignsBlockComments) {
479 EXPECT_EQ("/*\n"
480 " * Really multi-line\n"
481 " * comment.\n"
482 " */\n"
483 "void f() {}",
484 format(" /*\n"
485 " * Really multi-line\n"
486 " * comment.\n"
487 " */\n"
488 " void f() {}"));
489 }
490
491 } // end namespace tooling
492 } // end namespace clang
493