FormatTestJava.cpp 17 KB

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