blob: 9144fe17e9ecc4ef5cd272c4b3049e605108a839 [file] [log] [blame]
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00001//===- unittest/Format/FormatTestJS.cpp - Formatting unit tests for JS ----===//
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
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000010#include "FormatTestUtils.h"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000011#include "clang/Format/Format.h"
12#include "llvm/Support/Debug.h"
13#include "gtest/gtest.h"
14
Chandler Carruth10346662014-04-22 03:17:02 +000015#define DEBUG_TYPE "format-test"
16
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000017namespace clang {
18namespace format {
19
20class FormatTestJS : public ::testing::Test {
21protected:
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));
Krasimir Georgievbcda54b2017-04-21 14:35:20 +000027 FormattingAttemptStatus Status;
Daniel Jasper56691b82015-06-11 13:29:20 +000028 tooling::Replacements Replaces =
Krasimir Georgievbcda54b2017-04-21 14:35:20 +000029 reformat(Style, Code, Ranges, "<stdin>", &Status);
30 EXPECT_TRUE(Status.FormatComplete);
Eric Liu4f8d9942016-07-11 13:53:12 +000031 auto Result = applyAllReplacements(Code, Replaces);
32 EXPECT_TRUE(static_cast<bool>(Result));
33 DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
34 return *Result;
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000035 }
36
Daniel Jasper069e5f42014-05-20 11:14:57 +000037 static std::string format(
38 llvm::StringRef Code,
39 const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000040 return format(Code, 0, Code.size(), Style);
41 }
42
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000043 static FormatStyle getGoogleJSStyleWithColumns(unsigned ColumnLimit) {
Nico Weber514ecc82014-02-02 20:50:45 +000044 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000045 Style.ColumnLimit = ColumnLimit;
46 return Style;
47 }
48
Nico Weber514ecc82014-02-02 20:50:45 +000049 static void verifyFormat(
50 llvm::StringRef Code,
51 const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +000052 std::string Result = format(test::messUp(Code), Style);
53 EXPECT_EQ(Code.str(), Result) << "Formatted:\n" << Result;
54 }
55
56 static void verifyFormat(
57 llvm::StringRef Expected,
58 llvm::StringRef Code,
59 const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
60 std::string Result = format(Code, Style);
61 EXPECT_EQ(Expected.str(), Result) << "Formatted:\n" << Result;
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000062 }
63};
64
Daniel Jaspere77f19c2016-05-29 22:07:22 +000065TEST_F(FormatTestJS, BlockComments) {
66 verifyFormat("/* aaaaaaaaaaaaa */ aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
67 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
68}
69
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000070TEST_F(FormatTestJS, UnderstandsJavaScriptOperators) {
71 verifyFormat("a == = b;");
72 verifyFormat("a != = b;");
73
74 verifyFormat("a === b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000075 verifyFormat("aaaaaaa ===\n b;", getGoogleJSStyleWithColumns(10));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000076 verifyFormat("a !== b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000077 verifyFormat("aaaaaaa !==\n b;", getGoogleJSStyleWithColumns(10));
78 verifyFormat("if (a + b + c +\n"
79 " d !==\n"
80 " e + f + g)\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000081 " q();",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000082 getGoogleJSStyleWithColumns(20));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000083
84 verifyFormat("a >> >= b;");
85
86 verifyFormat("a >>> b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000087 verifyFormat("aaaaaaa >>>\n b;", getGoogleJSStyleWithColumns(10));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000088 verifyFormat("a >>>= b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000089 verifyFormat("aaaaaaa >>>=\n b;", getGoogleJSStyleWithColumns(10));
90 verifyFormat("if (a + b + c +\n"
91 " d >>>\n"
92 " e + f + g)\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000093 " q();",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000094 getGoogleJSStyleWithColumns(20));
Daniel Jaspere551bb72014-11-05 17:22:31 +000095 verifyFormat("var x = aaaaaaaaaa ?\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +000096 " bbbbbb :\n"
97 " ccc;",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000098 getGoogleJSStyleWithColumns(20));
Daniel Jasper78214392014-05-19 07:27:02 +000099
100 verifyFormat("var b = a.map((x) => x + 1);");
Daniel Jasper3549ea12014-09-19 10:48:15 +0000101 verifyFormat("return ('aaa') in bbbb;");
Daniel Jasper1ce41112016-02-01 11:20:47 +0000102 verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
103 " aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
104 FormatStyle Style = getGoogleJSStyleWithColumns(80);
105 Style.AlignOperands = true;
106 verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
107 " aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
108 Style);
109 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
110 verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa()\n"
111 " in aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
112 Style);
Daniel Jasper08051992015-05-26 07:18:56 +0000113
114 // ES6 spread operator.
115 verifyFormat("someFunction(...a);");
116 verifyFormat("var x = [1, ...a, 2];");
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000117}
118
Daniel Jasper3a038de2014-09-05 08:53:45 +0000119TEST_F(FormatTestJS, UnderstandsAmpAmp) {
120 verifyFormat("e && e.SomeFunction();");
121}
122
Daniel Jasper4db69bd2014-09-04 18:23:42 +0000123TEST_F(FormatTestJS, LiteralOperatorsCanBeKeywords) {
124 verifyFormat("not.and.or.not_eq = 1;");
125}
126
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000127TEST_F(FormatTestJS, ReservedWords) {
128 // JavaScript reserved words (aka keywords) are only illegal when used as
129 // Identifiers, but are legal as IdentifierNames.
130 verifyFormat("x.class.struct = 1;");
131 verifyFormat("x.case = 1;");
132 verifyFormat("x.interface = 1;");
Daniel Jasper997cf2f2016-05-20 06:16:01 +0000133 verifyFormat("x.for = 1;");
Daniel Jaspera4607e12016-03-17 12:17:59 +0000134 verifyFormat("x.of() = 1;");
Martin Probstc4a3d082017-04-05 10:56:07 +0000135 verifyFormat("of(null);");
136 verifyFormat("import {of} from 'x';");
Daniel Jaspera4607e12016-03-17 12:17:59 +0000137 verifyFormat("x.in() = 1;");
138 verifyFormat("x.let() = 1;");
139 verifyFormat("x.var() = 1;");
Daniel Jasper4d67dd72016-11-01 06:22:54 +0000140 verifyFormat("x.for() = 1;");
Daniel Jasperb559b432016-11-01 06:23:10 +0000141 verifyFormat("x.as() = 1;");
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000142 verifyFormat("x = {\n"
143 " a: 12,\n"
144 " interface: 1,\n"
145 " switch: 1,\n"
146 "};");
Daniel Jasper09840ef2015-11-20 15:58:50 +0000147 verifyFormat("var struct = 2;");
148 verifyFormat("var union = 2;");
Martin Probst1e8261e2016-04-19 18:18:59 +0000149 verifyFormat("var interface = 2;");
150 verifyFormat("interface = 2;");
151 verifyFormat("x = interface instanceof y;");
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000152}
153
Martin Probst4210d2f2016-09-22 07:18:00 +0000154TEST_F(FormatTestJS, ReservedWordsMethods) {
155 verifyFormat(
156 "class X {\n"
157 " delete() {\n"
158 " x();\n"
159 " }\n"
160 " interface() {\n"
161 " x();\n"
162 " }\n"
163 " let() {\n"
164 " x();\n"
165 " }\n"
166 "}\n");
167}
168
Daniel Jasper72a1b6a2015-12-22 15:47:56 +0000169TEST_F(FormatTestJS, CppKeywords) {
170 // Make sure we don't mess stuff up because of C++ keywords.
171 verifyFormat("return operator && (aa);");
Daniel Jasper72b33572017-03-31 12:04:37 +0000172 // .. or QT ones.
173 verifyFormat("slots: Slot[];");
Daniel Jasper72a1b6a2015-12-22 15:47:56 +0000174}
175
Daniel Jasper0dd52912014-05-19 07:37:07 +0000176TEST_F(FormatTestJS, ES6DestructuringAssignment) {
177 verifyFormat("var [a, b, c] = [1, 2, 3];");
Daniel Jasper5dbcd3b2016-05-19 07:18:07 +0000178 verifyFormat("const [a, b, c] = [1, 2, 3];");
Daniel Jasper9f642f72015-09-28 14:28:08 +0000179 verifyFormat("let [a, b, c] = [1, 2, 3];");
Daniel Jasper60948b12015-03-15 13:55:54 +0000180 verifyFormat("var {a, b} = {a: 1, b: 2};");
Daniel Jasper9f642f72015-09-28 14:28:08 +0000181 verifyFormat("let {a, b} = {a: 1, b: 2};");
Daniel Jasper0dd52912014-05-19 07:37:07 +0000182}
183
Daniel Jasper17062ff2014-06-10 14:44:02 +0000184TEST_F(FormatTestJS, ContainerLiterals) {
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000185 verifyFormat("var x = {\n"
186 " y: function(a) {\n"
187 " return a;\n"
188 " }\n"
189 "};");
Daniel Jasper17062ff2014-06-10 14:44:02 +0000190 verifyFormat("return {\n"
191 " link: function() {\n"
192 " f(); //\n"
193 " }\n"
194 "};");
195 verifyFormat("return {\n"
196 " a: a,\n"
197 " link: function() {\n"
198 " f(); //\n"
199 " }\n"
200 "};");
201 verifyFormat("return {\n"
202 " a: a,\n"
Daniel Jasper90ebc982014-09-05 09:27:38 +0000203 " link: function() {\n"
204 " f(); //\n"
205 " },\n"
206 " link: function() {\n"
207 " f(); //\n"
208 " }\n"
Daniel Jasper17062ff2014-06-10 14:44:02 +0000209 "};");
Daniel Jasper94e11d02014-09-04 14:58:30 +0000210 verifyFormat("var stuff = {\n"
211 " // comment for update\n"
212 " update: false,\n"
213 " // comment for modules\n"
214 " modules: false,\n"
215 " // comment for tasks\n"
216 " tasks: false\n"
217 "};");
Daniel Jasper97bfb7b2014-09-05 08:29:31 +0000218 verifyFormat("return {\n"
219 " 'finish':\n"
220 " //\n"
221 " a\n"
222 "};");
Daniel Jasper40874322014-11-27 15:24:48 +0000223 verifyFormat("var obj = {\n"
224 " fooooooooo: function(x) {\n"
225 " return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
226 " }\n"
227 "};");
Daniel Jasper60948b12015-03-15 13:55:54 +0000228 // Simple object literal, as opposed to enum style below.
229 verifyFormat("var obj = {a: 123};");
230 // Enum style top level assignment.
231 verifyFormat("X = {\n a: 123\n};");
232 verifyFormat("X.Y = {\n a: 123\n};");
Daniel Jasper11ca2632015-06-10 09:21:09 +0000233 // But only on the top level, otherwise its a plain object literal assignment.
234 verifyFormat("function x() {\n"
235 " y = {z: 1};\n"
236 "}");
Daniel Jasper60948b12015-03-15 13:55:54 +0000237 verifyFormat("x = foo && {a: 123};");
Manuel Klimek79e06082015-05-21 12:23:34 +0000238
239 // Arrow functions in object literals.
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000240 verifyFormat("var x = {\n"
241 " y: (a) => {\n"
242 " return a;\n"
243 " }\n"
244 "};");
Manuel Klimek79e06082015-05-21 12:23:34 +0000245 verifyFormat("var x = {y: (a) => a};");
Daniel Jasper8c42d442015-05-29 06:19:49 +0000246
Martin Probst8e3eba02017-02-07 16:33:13 +0000247 // Methods in object literals.
248 verifyFormat("var x = {\n"
249 " y(a: string): number {\n"
250 " return a;\n"
251 " }\n"
252 "};");
253 verifyFormat("var x = {\n"
254 " y(a: string) {\n"
255 " return a;\n"
256 " }\n"
257 "};");
258
Daniel Jasper8c42d442015-05-29 06:19:49 +0000259 // Computed keys.
Daniel Jaspercd8d4ff2015-05-31 08:40:37 +0000260 verifyFormat("var x = {[a]: 1, b: 2, [c]: 3};");
Daniel Jasper8c42d442015-05-29 06:19:49 +0000261 verifyFormat("var x = {\n"
262 " [a]: 1,\n"
Daniel Jaspercd8d4ff2015-05-31 08:40:37 +0000263 " b: 2,\n"
264 " [c]: 3,\n"
Daniel Jasper8c42d442015-05-29 06:19:49 +0000265 "};");
Daniel Jasper9f4c9d42016-02-07 22:17:13 +0000266
267 // Object literals can leave out labels.
268 verifyFormat("f({a}, () => {\n"
269 " g(); //\n"
270 "});");
Daniel Jasperb18425b2016-03-01 04:19:47 +0000271
272 // Keys can be quoted.
273 verifyFormat("var x = {\n"
274 " a: a,\n"
275 " b: b,\n"
276 " 'c': c,\n"
277 "};");
Daniel Jaspere98e5812016-11-29 09:40:36 +0000278
279 // Dict literals can skip the label names.
280 verifyFormat("var x = {\n"
281 " aaa,\n"
282 " aaa,\n"
283 " aaa,\n"
284 "};");
Daniel Jasper893b8ad2017-03-01 19:47:28 +0000285 verifyFormat("return {\n"
286 " a,\n"
287 " b: 'b',\n"
288 " c,\n"
289 "};");
Daniel Jasper17062ff2014-06-10 14:44:02 +0000290}
291
Daniel Jasperf46dec82015-03-31 14:34:15 +0000292TEST_F(FormatTestJS, MethodsInObjectLiterals) {
293 verifyFormat("var o = {\n"
294 " value: 'test',\n"
295 " get value() { // getter\n"
296 " return this.value;\n"
297 " }\n"
298 "};");
299 verifyFormat("var o = {\n"
300 " value: 'test',\n"
301 " set value(val) { // setter\n"
302 " this.value = val;\n"
303 " }\n"
304 "};");
305 verifyFormat("var o = {\n"
306 " value: 'test',\n"
307 " someMethod(val) { // method\n"
308 " doSomething(this.value + val);\n"
309 " }\n"
310 "};");
Daniel Jasper739ec532015-04-04 07:56:55 +0000311 verifyFormat("var o = {\n"
312 " someMethod(val) { // method\n"
313 " doSomething(this.value + val);\n"
314 " },\n"
315 " someOtherMethod(val) { // method\n"
316 " doSomething(this.value + val);\n"
317 " }\n"
318 "};");
Daniel Jasperf46dec82015-03-31 14:34:15 +0000319}
320
Martin Probst19c7de02017-04-26 12:34:15 +0000321TEST_F(FormatTestJS, GettersSettersVisibilityKeywords) {
322 // Don't break after "protected"
323 verifyFormat("class X {\n"
324 " protected get getter():\n"
325 " number {\n"
326 " return 1;\n"
327 " }\n"
328 "}",
329 getGoogleJSStyleWithColumns(12));
330 // Don't break after "get"
331 verifyFormat("class X {\n"
332 " protected get someReallyLongGetterName():\n"
333 " number {\n"
334 " return 1;\n"
335 " }\n"
336 "}",
337 getGoogleJSStyleWithColumns(40));
338}
339
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000340TEST_F(FormatTestJS, SpacesInContainerLiterals) {
341 verifyFormat("var arr = [1, 2, 3];");
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000342 verifyFormat("f({a: 1, b: 2, c: 3});");
Nico Weber514ecc82014-02-02 20:50:45 +0000343
Daniel Jasper2a958322014-05-21 13:26:58 +0000344 verifyFormat("var object_literal_with_long_name = {\n"
345 " a: 'aaaaaaaaaaaaaaaaaa',\n"
346 " b: 'bbbbbbbbbbbbbbbbbb'\n"
347 "};");
348
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000349 verifyFormat("f({a: 1, b: 2, c: 3});",
Nico Weber514ecc82014-02-02 20:50:45 +0000350 getChromiumStyle(FormatStyle::LK_JavaScript));
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000351 verifyFormat("f({'a': [{}]});");
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000352}
353
Daniel Jasperabd1f572016-03-02 22:44:03 +0000354TEST_F(FormatTestJS, SingleQuotedStrings) {
Daniel Jasper86fee2f2014-01-31 12:49:42 +0000355 verifyFormat("this.function('', true);");
356}
357
Daniel Jasper4a39c842014-05-06 13:54:10 +0000358TEST_F(FormatTestJS, GoogScopes) {
359 verifyFormat("goog.scope(function() {\n"
360 "var x = a.b;\n"
361 "var y = c.d;\n"
362 "}); // goog.scope");
Daniel Jasper02c7bca2015-03-30 09:56:50 +0000363 verifyFormat("goog.scope(function() {\n"
364 "// test\n"
365 "var x = 0;\n"
366 "// test\n"
367 "});");
Daniel Jasper4a39c842014-05-06 13:54:10 +0000368}
369
Daniel Jasper616de8642014-11-23 16:46:28 +0000370TEST_F(FormatTestJS, GoogModules) {
371 verifyFormat("goog.module('this.is.really.absurdly.long');",
372 getGoogleJSStyleWithColumns(40));
373 verifyFormat("goog.require('this.is.really.absurdly.long');",
374 getGoogleJSStyleWithColumns(40));
375 verifyFormat("goog.provide('this.is.really.absurdly.long');",
376 getGoogleJSStyleWithColumns(40));
377 verifyFormat("var long = goog.require('this.is.really.absurdly.long');",
378 getGoogleJSStyleWithColumns(40));
Daniel Jasperb488a742015-10-29 19:05:20 +0000379 verifyFormat("goog.setTestOnly('this.is.really.absurdly.long');",
380 getGoogleJSStyleWithColumns(40));
Daniel Jasper02cbeb22016-02-22 15:06:53 +0000381 verifyFormat("goog.forwardDeclare('this.is.really.absurdly.long');",
382 getGoogleJSStyleWithColumns(40));
Daniel Jasper53c38f42014-11-27 14:46:03 +0000383
384 // These should be wrapped normally.
385 verifyFormat(
386 "var MyLongClassName =\n"
387 " goog.module.get('my.long.module.name.followedBy.MyLongClassName');");
Daniel Jasper616de8642014-11-23 16:46:28 +0000388}
389
Martin Probstece8c0c2016-06-13 16:41:28 +0000390TEST_F(FormatTestJS, FormatsNamespaces) {
391 verifyFormat("namespace Foo {\n"
392 " export let x = 1;\n"
393 "}\n");
394 verifyFormat("declare namespace Foo {\n"
395 " export let x: number;\n"
396 "}\n");
397}
398
Martin Probst72fd75a2016-11-10 16:20:58 +0000399TEST_F(FormatTestJS, NamespacesMayNotWrap) {
400 verifyFormat("declare namespace foobarbaz {\n"
401 "}\n", getGoogleJSStyleWithColumns(18));
402 verifyFormat("declare module foobarbaz {\n"
403 "}\n", getGoogleJSStyleWithColumns(15));
404 verifyFormat("namespace foobarbaz {\n"
405 "}\n", getGoogleJSStyleWithColumns(10));
406 verifyFormat("module foobarbaz {\n"
407 "}\n", getGoogleJSStyleWithColumns(7));
408}
409
410TEST_F(FormatTestJS, AmbientDeclarations) {
411 FormatStyle NineCols = getGoogleJSStyleWithColumns(9);
412 verifyFormat(
413 "declare class\n"
414 " X {}",
415 NineCols);
416 verifyFormat(
417 "declare function\n"
418 "x();", // TODO(martinprobst): should ideally be indented.
419 NineCols);
Martin Probstaf16c502017-01-04 13:36:43 +0000420 verifyFormat("declare function foo();\n"
421 "let x = 1;\n");
422 verifyFormat("declare function foo(): string;\n"
423 "let x = 1;\n");
424 verifyFormat("declare function foo(): {x: number};\n"
425 "let x = 1;\n");
426 verifyFormat("declare class X {}\n"
427 "let x = 1;\n");
428 verifyFormat("declare interface Y {}\n"
429 "let x = 1;\n");
Martin Probst72fd75a2016-11-10 16:20:58 +0000430 verifyFormat(
431 "declare enum X {\n"
432 "}",
433 NineCols);
434 verifyFormat(
435 "declare let\n"
436 " x: number;",
437 NineCols);
438}
439
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000440TEST_F(FormatTestJS, FormatsFreestandingFunctions) {
441 verifyFormat("function outer1(a, b) {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000442 " function inner1(a, b) {\n"
443 " return a;\n"
444 " }\n"
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000445 " inner1(a, b);\n"
446 "}\n"
447 "function outer2(a, b) {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000448 " function inner2(a, b) {\n"
449 " return a;\n"
450 " }\n"
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000451 " inner2(a, b);\n"
452 "}");
Daniel Jasper20580fd2015-06-11 13:31:45 +0000453 verifyFormat("function f() {}");
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000454}
455
Martin Probst5f8445b2016-04-24 22:05:09 +0000456TEST_F(FormatTestJS, GeneratorFunctions) {
457 verifyFormat("function* f() {\n"
458 " let x = 1;\n"
459 " yield x;\n"
460 " yield* something();\n"
Daniel Jaspereb886632016-10-31 13:18:25 +0000461 " yield [1, 2];\n"
462 " yield {a: 1};\n"
Martin Probst5f8445b2016-04-24 22:05:09 +0000463 "}");
464 verifyFormat("function*\n"
465 " f() {\n"
466 "}",
467 getGoogleJSStyleWithColumns(8));
468 verifyFormat("export function* f() {\n"
469 " yield 1;\n"
470 "}\n");
471 verifyFormat("class X {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000472 " * generatorMethod() {\n"
473 " yield x;\n"
474 " }\n"
Martin Probst5f8445b2016-04-24 22:05:09 +0000475 "}");
Daniel Jasper71e50af2016-11-01 06:22:59 +0000476 verifyFormat("var x = {\n"
477 " a: function*() {\n"
478 " //\n"
479 " }\n"
480 "}\n");
Martin Probst5f8445b2016-04-24 22:05:09 +0000481}
482
483TEST_F(FormatTestJS, AsyncFunctions) {
484 verifyFormat("async function f() {\n"
485 " let x = 1;\n"
486 " return fetch(x);\n"
487 "}");
Martin Probst973ff792017-04-27 13:07:24 +0000488 verifyFormat("async function f() {\n"
489 " return 1;\n"
490 "}\n"
491 "\n"
492 "function a() {\n"
493 " return 1;\n"
494 "}\n",
495 " async function f() {\n"
496 " return 1;\n"
497 "}\n"
498 "\n"
499 " function a() {\n"
500 " return 1;\n"
501 "} \n");
Martin Probst5f8445b2016-04-24 22:05:09 +0000502 verifyFormat("async function* f() {\n"
503 " yield fetch(x);\n"
504 "}");
505 verifyFormat("export async function f() {\n"
506 " return fetch(x);\n"
507 "}");
Martin Probst20371c32017-02-27 11:15:53 +0000508 verifyFormat("let x = async () => f();");
Martin Probst973ff792017-04-27 13:07:24 +0000509 verifyFormat("let x = async function() {\n"
510 " f();\n"
511 "};");
Martin Probst20371c32017-02-27 11:15:53 +0000512 verifyFormat("let x = async();");
Martin Probst5f8445b2016-04-24 22:05:09 +0000513 verifyFormat("class X {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000514 " async asyncMethod() {\n"
515 " return fetch(1);\n"
516 " }\n"
Martin Probst5f8445b2016-04-24 22:05:09 +0000517 "}");
Martin Probst409697e2016-05-29 14:41:07 +0000518 verifyFormat("function initialize() {\n"
519 " // Comment.\n"
520 " return async.then();\n"
521 "}\n");
Martin Probst5f8445b2016-04-24 22:05:09 +0000522}
523
Daniel Jasperf841d3a2015-05-28 07:21:50 +0000524TEST_F(FormatTestJS, ArrayLiterals) {
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +0000525 verifyFormat("var aaaaa: List<SomeThing> =\n"
526 " [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];");
Daniel Jasperd492b5e2015-06-02 21:57:51 +0000527 verifyFormat("return [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000528 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasperd492b5e2015-06-02 21:57:51 +0000529 " ccccccccccccccccccccccccccc\n"
530 "];");
Daniel Jasper7bec87c2016-01-07 18:11:54 +0000531 verifyFormat("return [\n"
532 " aaaa().bbbbbbbb('A'),\n"
533 " aaaa().bbbbbbbb('B'),\n"
534 " aaaa().bbbbbbbb('C'),\n"
535 "];");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000536 verifyFormat("var someVariable = SomeFunction([\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000537 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasper5ce80de2015-06-02 13:56:43 +0000538 " ccccccccccccccccccccccccccc\n"
539 "]);");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000540 verifyFormat("var someVariable = SomeFunction([\n"
Daniel Jasper40432ce2015-06-02 15:04:29 +0000541 " [aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbb],\n"
Daniel Jasper199d0c92015-06-02 15:14:21 +0000542 "]);",
543 getGoogleJSStyleWithColumns(51));
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000544 verifyFormat("var someVariable = SomeFunction(aaaa, [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000545 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasper4284e362015-06-02 14:20:08 +0000546 " ccccccccccccccccccccccccccc\n"
547 "]);");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000548 verifyFormat("var someVariable = SomeFunction(\n"
549 " aaaa,\n"
550 " [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000551 " aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
552 " cccccccccccccccccccccccccc\n"
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000553 " ],\n"
554 " aaaa);");
Daniel Jasperebcb71f2016-01-04 13:11:41 +0000555 verifyFormat("var aaaa = aaaaa || // wrap\n"
556 " [];");
Daniel Jasper1feab0f2015-06-02 15:31:37 +0000557
558 verifyFormat("someFunction([], {a: a});");
Daniel Jasper51c868e2017-01-30 07:08:40 +0000559
560 verifyFormat("var string = [\n"
561 " 'aaaaaa',\n"
562 " 'bbbbbb',\n"
563 "].join('+');");
Daniel Jasperf841d3a2015-05-28 07:21:50 +0000564}
565
Daniel Jaspere2deb592015-12-22 15:48:15 +0000566TEST_F(FormatTestJS, ColumnLayoutForArrayLiterals) {
567 verifyFormat("var array = [\n"
568 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
569 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
570 "];");
571 verifyFormat("var array = someFunction([\n"
572 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
573 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
574 "]);");
575}
576
Daniel Jasper5217a8b2014-06-13 07:02:04 +0000577TEST_F(FormatTestJS, FunctionLiterals) {
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000578 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
579 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
Daniel Jasper3f69ba12014-09-05 08:42:27 +0000580 verifyFormat("doFoo(function() {});");
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000581 verifyFormat("doFoo(function() { return 1; });", Style);
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000582 verifyFormat("var func = function() {\n"
583 " return 1;\n"
584 "};");
Daniel Jaspered3f3952015-06-18 12:32:59 +0000585 verifyFormat("var func = //\n"
586 " function() {\n"
587 " return 1;\n"
588 "};");
Daniel Jasperc03e16a2014-05-08 09:25:39 +0000589 verifyFormat("return {\n"
590 " body: {\n"
591 " setAttribute: function(key, val) { this[key] = val; },\n"
592 " getAttribute: function(key) { return this[key]; },\n"
593 " style: {direction: ''}\n"
594 " }\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000595 "};",
596 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000597 verifyFormat("abc = xyz ? function() {\n"
598 " return 1;\n"
599 "} : function() {\n"
600 " return -1;\n"
601 "};");
Daniel Jasperb16b9692014-05-21 12:51:23 +0000602
603 verifyFormat("var closure = goog.bind(\n"
604 " function() { // comment\n"
605 " foo();\n"
606 " bar();\n"
607 " },\n"
Joerg Sonnenbergere9987a12017-01-05 17:59:44 +0000608 " this, arg1IsReallyLongAndNeedsLineBreaks,\n"
609 " arg3IsReallyLongAndNeedsLineBreaks);");
Daniel Jasperb16b9692014-05-21 12:51:23 +0000610 verifyFormat("var closure = goog.bind(function() { // comment\n"
611 " foo();\n"
612 " bar();\n"
613 "}, this);");
Daniel Jasper58cb2ed2014-06-06 13:49:04 +0000614 verifyFormat("return {\n"
615 " a: 'E',\n"
616 " b: function() {\n"
617 " return function() {\n"
618 " f(); //\n"
619 " };\n"
620 " }\n"
621 "};");
Daniel Jasper41368e92014-11-27 15:37:42 +0000622 verifyFormat("{\n"
623 " var someVariable = function(x) {\n"
624 " return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
625 " };\n"
626 "}");
Daniel Jasper7325aee2015-05-08 08:38:52 +0000627 verifyFormat("someLooooooooongFunction(\n"
628 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
629 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
630 " function(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
631 " // code\n"
632 " });");
Daniel Jasper5f3ea472014-05-22 08:36:53 +0000633
Daniel Jasper5217a8b2014-06-13 07:02:04 +0000634 verifyFormat("return {\n"
635 " a: function SomeFunction() {\n"
636 " // ...\n"
637 " return 1;\n"
638 " }\n"
639 "};");
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000640 verifyFormat("this.someObject.doSomething(aaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
641 " .then(goog.bind(function(aaaaaaaaaaa) {\n"
642 " someFunction();\n"
643 " someFunction();\n"
644 " }, this), aaaaaaaaaaaaaaaaa);");
645
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000646 verifyFormat("someFunction(goog.bind(function() {\n"
647 " doSomething();\n"
648 " doSomething();\n"
649 "}, this), goog.bind(function() {\n"
650 " doSomething();\n"
651 " doSomething();\n"
652 "}, this));");
Daniel Jasper1699eca2015-06-01 09:56:32 +0000653
Daniel Jasper51c868e2017-01-30 07:08:40 +0000654 verifyFormat("SomeFunction(function() {\n"
655 " foo();\n"
656 " bar();\n"
657 "}.bind(this));");
658
Daniel Jasper1699eca2015-06-01 09:56:32 +0000659 // FIXME: This is bad, we should be wrapping before "function() {".
660 verifyFormat("someFunction(function() {\n"
661 " doSomething(); // break\n"
662 "})\n"
663 " .doSomethingElse(\n"
664 " // break\n"
665 " );");
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000666
667 Style.ColumnLimit = 33;
668 verifyFormat("f({a: function() { return 1; }});", Style);
669 Style.ColumnLimit = 32;
670 verifyFormat("f({\n"
671 " a: function() { return 1; }\n"
672 "});",
673 Style);
674
Daniel Jasper79dffb42014-05-07 09:48:30 +0000675}
676
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000677TEST_F(FormatTestJS, InliningFunctionLiterals) {
678 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
679 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
680 verifyFormat("var func = function() {\n"
681 " return 1;\n"
682 "};",
683 Style);
684 verifyFormat("var func = doSomething(function() { return 1; });", Style);
685 verifyFormat("var outer = function() {\n"
686 " var inner = function() { return 1; }\n"
687 "};",
688 Style);
689 verifyFormat("function outer1(a, b) {\n"
690 " function inner1(a, b) { return a; }\n"
691 "}",
692 Style);
693
694 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
695 verifyFormat("var func = function() { return 1; };", Style);
696 verifyFormat("var func = doSomething(function() { return 1; });", Style);
697 verifyFormat(
698 "var outer = function() { var inner = function() { return 1; } };",
699 Style);
700 verifyFormat("function outer1(a, b) {\n"
701 " function inner1(a, b) { return a; }\n"
702 "}",
703 Style);
704
705 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
706 verifyFormat("var func = function() {\n"
707 " return 1;\n"
708 "};",
709 Style);
710 verifyFormat("var func = doSomething(function() {\n"
711 " return 1;\n"
712 "});",
713 Style);
714 verifyFormat("var outer = function() {\n"
715 " var inner = function() {\n"
716 " return 1;\n"
717 " }\n"
718 "};",
719 Style);
720 verifyFormat("function outer1(a, b) {\n"
721 " function inner1(a, b) {\n"
722 " return a;\n"
723 " }\n"
724 "}",
725 Style);
Daniel Jasper71e57452015-11-20 16:44:28 +0000726
727 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
728 verifyFormat("var func = function() {\n"
729 " return 1;\n"
730 "};",
731 Style);
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000732}
733
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000734TEST_F(FormatTestJS, MultipleFunctionLiterals) {
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000735 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
736 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000737 verifyFormat("promise.then(\n"
738 " function success() {\n"
739 " doFoo();\n"
740 " doBar();\n"
741 " },\n"
742 " function error() {\n"
743 " doFoo();\n"
744 " doBaz();\n"
745 " },\n"
746 " []);\n");
747 verifyFormat("promise.then(\n"
748 " function success() {\n"
749 " doFoo();\n"
750 " doBar();\n"
751 " },\n"
752 " [],\n"
753 " function error() {\n"
754 " doFoo();\n"
755 " doBaz();\n"
756 " });\n");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000757 verifyFormat("promise.then(\n"
758 " [],\n"
759 " function success() {\n"
760 " doFoo();\n"
761 " doBar();\n"
762 " },\n"
763 " function error() {\n"
764 " doFoo();\n"
765 " doBaz();\n"
766 " });\n");
Daniel Jasper1779d432014-09-29 07:54:54 +0000767
768 verifyFormat("getSomeLongPromise()\n"
769 " .then(function(value) { body(); })\n"
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000770 " .thenCatch(function(error) {\n"
771 " body();\n"
772 " body();\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000773 " });",
774 Style);
Daniel Jasper1779d432014-09-29 07:54:54 +0000775 verifyFormat("getSomeLongPromise()\n"
776 " .then(function(value) {\n"
777 " body();\n"
778 " body();\n"
779 " })\n"
780 " .thenCatch(function(error) {\n"
781 " body();\n"
782 " body();\n"
783 " });");
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000784
Daniel Jasperacf67e32015-04-07 08:20:35 +0000785 verifyFormat("getSomeLongPromise()\n"
786 " .then(function(value) { body(); })\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000787 " .thenCatch(function(error) { body(); });",
788 Style);
Daniel Jasper28024562016-01-11 11:00:58 +0000789
790 verifyFormat("return [aaaaaaaaaaaaaaaaaaaaaa]\n"
791 " .aaaaaaa(function() {\n"
792 " //\n"
793 " })\n"
794 " .bbbbbb();");
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000795}
796
Manuel Klimek79e06082015-05-21 12:23:34 +0000797TEST_F(FormatTestJS, ArrowFunctions) {
798 verifyFormat("var x = (a) => {\n"
799 " return a;\n"
800 "};");
801 verifyFormat("var x = (a) => {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000802 " function y() {\n"
803 " return 42;\n"
804 " }\n"
Manuel Klimek79e06082015-05-21 12:23:34 +0000805 " return a;\n"
806 "};");
807 verifyFormat("var x = (a: type): {some: type} => {\n"
808 " return a;\n"
809 "};");
810 verifyFormat("var x = (a) => a;");
Daniel Jaspere497bed2015-06-02 22:06:07 +0000811 verifyFormat("return () => [];");
Daniel Jasper3c306e82015-06-03 17:08:40 +0000812 verifyFormat("var aaaaaaaaaaaaaaaaaaaa = {\n"
813 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
814 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
815 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) =>\n"
Daniel Jasper3b0f3042015-06-05 08:25:37 +0000816 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper3c306e82015-06-03 17:08:40 +0000817 "};");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000818 verifyFormat("var a = a.aaaaaaa(\n"
819 " (a: a) => aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) &&\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000820 " aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000821 verifyFormat("var a = a.aaaaaaa(\n"
822 " (a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) ?\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000823 " aaaaaaaaaaaaaaaaaaaaa(bbbbbbb) :\n"
824 " aaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
Daniel Jasper1699eca2015-06-01 09:56:32 +0000825
826 // FIXME: This is bad, we should be wrapping before "() => {".
827 verifyFormat("someFunction(() => {\n"
828 " doSomething(); // break\n"
829 "})\n"
830 " .doSomethingElse(\n"
831 " // break\n"
832 " );");
Manuel Klimek79e06082015-05-21 12:23:34 +0000833}
834
Daniel Jasper166c19b2014-05-06 14:12:21 +0000835TEST_F(FormatTestJS, ReturnStatements) {
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000836 verifyFormat("function() {\n"
837 " return [hello, world];\n"
838 "}");
Daniel Jasper166c19b2014-05-06 14:12:21 +0000839}
840
Daniel Jasperf95b1f42015-11-20 16:18:42 +0000841TEST_F(FormatTestJS, ForLoops) {
842 verifyFormat("for (var i in [2, 3]) {\n"
843 "}");
Daniel Jasperb7fda112016-02-11 13:24:15 +0000844 verifyFormat("for (var i of [2, 3]) {\n"
845 "}");
Daniel Jasperacffeb82016-03-05 18:34:26 +0000846 verifyFormat("for (let {a, b} of x) {\n"
847 "}");
848 verifyFormat("for (let {a, b} in x) {\n"
849 "}");
Daniel Jasperf95b1f42015-11-20 16:18:42 +0000850}
851
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000852TEST_F(FormatTestJS, WrapRespectsAutomaticSemicolonInsertion) {
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000853 // The following statements must not wrap, as otherwise the program meaning
854 // would change due to automatic semicolon insertion.
855 // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1.
856 verifyFormat("return aaaaa;", getGoogleJSStyleWithColumns(10));
Martin Probst56ff7aa2016-09-06 18:39:30 +0000857 verifyFormat("return /* hello! */ aaaaa;", getGoogleJSStyleWithColumns(10));
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000858 verifyFormat("continue aaaaa;", getGoogleJSStyleWithColumns(10));
Martin Probst56ff7aa2016-09-06 18:39:30 +0000859 verifyFormat("continue /* hello! */ aaaaa;", getGoogleJSStyleWithColumns(10));
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000860 verifyFormat("break aaaaa;", getGoogleJSStyleWithColumns(10));
861 verifyFormat("throw aaaaa;", getGoogleJSStyleWithColumns(10));
862 verifyFormat("aaaaaaaaa++;", getGoogleJSStyleWithColumns(10));
863 verifyFormat("aaaaaaaaa--;", getGoogleJSStyleWithColumns(10));
Daniel Jasper11a87652016-01-14 05:37:52 +0000864 verifyFormat("return [\n"
865 " aaa\n"
866 "];",
867 getGoogleJSStyleWithColumns(12));
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000868}
869
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000870TEST_F(FormatTestJS, AutomaticSemicolonInsertionHeuristic) {
871 verifyFormat("a\n"
872 "b;",
873 " a \n"
874 " b ;");
875 verifyFormat("a()\n"
876 "b;",
877 " a ()\n"
878 " b ;");
879 verifyFormat("a[b]\n"
880 "c;",
881 "a [b]\n"
882 "c ;");
883 verifyFormat("1\n"
884 "a;",
885 "1 \n"
886 "a ;");
887 verifyFormat("a\n"
888 "1;",
889 "a \n"
890 "1 ;");
891 verifyFormat("a\n"
892 "'x';",
893 "a \n"
894 " 'x';");
895 verifyFormat("a++\n"
896 "b;",
897 "a ++\n"
898 "b ;");
899 verifyFormat("a\n"
900 "!b && c;",
901 "a \n"
902 " ! b && c;");
903 verifyFormat("a\n"
904 "if (1) f();",
905 " a\n"
906 " if (1) f();");
907 verifyFormat("a\n"
908 "class X {}",
909 " a\n"
910 " class X {}");
911 verifyFormat("var a", "var\n"
912 "a");
913 verifyFormat("x instanceof String", "x\n"
914 "instanceof\n"
915 "String");
Martin Probstbbffeac2016-04-11 07:35:57 +0000916 verifyFormat("function f(@Foo bar) {}", "function f(@Foo\n"
917 " bar) {}");
Martin Probstb9316ff2016-09-18 17:21:52 +0000918 verifyFormat("a = true\n"
919 "return 1",
920 "a = true\n"
921 " return 1");
922 verifyFormat("a = 's'\n"
923 "return 1",
924 "a = 's'\n"
925 " return 1");
926 verifyFormat("a = null\n"
927 "return 1",
928 "a = null\n"
929 " return 1");
Martin Probste6b5b342017-01-16 09:52:40 +0000930 // Below "class Y {}" should ideally be on its own line.
Martin Probstd40bca42017-01-09 08:56:36 +0000931 verifyFormat(
Martin Probstfd18ec52017-01-09 09:00:58 +0000932 "x = {\n"
933 " a: 1\n"
Martin Probste6b5b342017-01-16 09:52:40 +0000934 "} class Y {}",
Martin Probstd40bca42017-01-09 08:56:36 +0000935 " x = {a : 1}\n"
936 " class Y { }");
Martin Probste6b5b342017-01-16 09:52:40 +0000937 verifyFormat(
938 "if (x) {\n"
939 "}\n"
940 "return 1",
941 "if (x) {}\n"
942 " return 1");
943 verifyFormat(
944 "if (x) {\n"
945 "}\n"
946 "class X {}",
947 "if (x) {}\n"
948 " class X {}");
Martin Probstd40bca42017-01-09 08:56:36 +0000949}
950
951TEST_F(FormatTestJS, ImportExportASI) {
952 verifyFormat(
953 "import {x} from 'y'\n"
954 "export function z() {}",
955 "import {x} from 'y'\n"
956 " export function z() {}");
Martin Probste6b5b342017-01-16 09:52:40 +0000957 // Below "class Y {}" should ideally be on its own line.
Martin Probstd40bca42017-01-09 08:56:36 +0000958 verifyFormat(
Martin Probste6b5b342017-01-16 09:52:40 +0000959 "export {x} class Y {}",
Martin Probstd40bca42017-01-09 08:56:36 +0000960 " export {x}\n"
961 " class Y {\n}");
Martin Probste6b5b342017-01-16 09:52:40 +0000962 verifyFormat(
963 "if (x) {\n"
964 "}\n"
965 "export class Y {}",
966 "if ( x ) { }\n"
967 " export class Y {}");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000968}
969
Manuel Klimek79e06082015-05-21 12:23:34 +0000970TEST_F(FormatTestJS, ClosureStyleCasts) {
Daniel Jasper484033b2014-05-06 14:41:29 +0000971 verifyFormat("var x = /** @type {foo} */ (bar);");
972}
973
Daniel Jasper04a71a42014-05-08 11:58:24 +0000974TEST_F(FormatTestJS, TryCatch) {
975 verifyFormat("try {\n"
976 " f();\n"
977 "} catch (e) {\n"
978 " g();\n"
979 "} finally {\n"
980 " h();\n"
981 "}");
Daniel Jasper8f2e94c2014-09-04 15:03:34 +0000982
983 // But, of course, "catch" is a perfectly fine function name in JavaScript.
984 verifyFormat("someObject.catch();");
Daniel Jasper79121232014-11-27 14:55:17 +0000985 verifyFormat("someObject.new();");
986 verifyFormat("someObject.delete();");
Daniel Jasper04a71a42014-05-08 11:58:24 +0000987}
988
Daniel Jasper49802ef2014-05-22 09:10:04 +0000989TEST_F(FormatTestJS, StringLiteralConcatenation) {
990 verifyFormat("var literal = 'hello ' +\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000991 " 'world';");
Daniel Jasper49802ef2014-05-22 09:10:04 +0000992}
993
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000994TEST_F(FormatTestJS, RegexLiteralClassification) {
995 // Regex literals.
996 verifyFormat("var regex = /abc/;");
997 verifyFormat("f(/abc/);");
998 verifyFormat("f(abc, /abc/);");
999 verifyFormat("some_map[/abc/];");
1000 verifyFormat("var x = a ? /abc/ : /abc/;");
1001 verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}");
1002 verifyFormat("var x = !/abc/.test(y);");
Martin Probst16282992017-02-07 14:08:03 +00001003 verifyFormat("var x = foo()! / 10;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001004 verifyFormat("var x = a && /abc/.test(y);");
1005 verifyFormat("var x = a || /abc/.test(y);");
1006 verifyFormat("var x = a + /abc/.search(y);");
Daniel Jasperc553ae12015-07-02 13:20:45 +00001007 verifyFormat("/abc/.search(y);");
Daniel Jasperf7405c12014-05-08 07:45:18 +00001008 verifyFormat("var regexs = {/abc/, /abc/};");
1009 verifyFormat("return /abc/;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001010
1011 // Not regex literals.
1012 verifyFormat("var a = a / 2 + b / 3;");
Daniel Jasper265309e2015-10-18 07:02:28 +00001013 verifyFormat("var a = a++ / 2;");
1014 // Prefix unary can operate on regex literals, not that it makes sense.
1015 verifyFormat("var a = ++/a/;");
1016
1017 // This is a known issue, regular expressions are incorrectly detected if
1018 // directly following a closing parenthesis.
1019 verifyFormat("if (foo) / bar /.exec(baz);");
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001020}
1021
1022TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) {
Daniel Jasper69694b02015-05-08 07:55:13 +00001023 verifyFormat("var regex = /=/;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001024 verifyFormat("var regex = /a*/;");
1025 verifyFormat("var regex = /a+/;");
1026 verifyFormat("var regex = /a?/;");
1027 verifyFormat("var regex = /.a./;");
1028 verifyFormat("var regex = /a\\*/;");
1029 verifyFormat("var regex = /^a$/;");
1030 verifyFormat("var regex = /\\/a/;");
1031 verifyFormat("var regex = /(?:x)/;");
1032 verifyFormat("var regex = /x(?=y)/;");
1033 verifyFormat("var regex = /x(?!y)/;");
1034 verifyFormat("var regex = /x|y/;");
1035 verifyFormat("var regex = /a{2}/;");
1036 verifyFormat("var regex = /a{1,3}/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +00001037
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001038 verifyFormat("var regex = /[abc]/;");
1039 verifyFormat("var regex = /[^abc]/;");
1040 verifyFormat("var regex = /[\\b]/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +00001041 verifyFormat("var regex = /[/]/;");
1042 verifyFormat("var regex = /[\\/]/;");
1043 verifyFormat("var regex = /\\[/;");
1044 verifyFormat("var regex = /\\\\[/]/;");
Daniel Jasper265309e2015-10-18 07:02:28 +00001045 verifyFormat("var regex = /}[\"]/;");
1046 verifyFormat("var regex = /}[/\"]/;");
1047 verifyFormat("var regex = /}[\"/]/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +00001048
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001049 verifyFormat("var regex = /\\b/;");
1050 verifyFormat("var regex = /\\B/;");
1051 verifyFormat("var regex = /\\d/;");
1052 verifyFormat("var regex = /\\D/;");
1053 verifyFormat("var regex = /\\f/;");
1054 verifyFormat("var regex = /\\n/;");
1055 verifyFormat("var regex = /\\r/;");
1056 verifyFormat("var regex = /\\s/;");
1057 verifyFormat("var regex = /\\S/;");
1058 verifyFormat("var regex = /\\t/;");
1059 verifyFormat("var regex = /\\v/;");
1060 verifyFormat("var regex = /\\w/;");
1061 verifyFormat("var regex = /\\W/;");
1062 verifyFormat("var regex = /a(a)\\1/;");
1063 verifyFormat("var regex = /\\0/;");
Daniel Jasperfb4333b2014-05-12 11:29:50 +00001064 verifyFormat("var regex = /\\\\/g;");
1065 verifyFormat("var regex = /\\a\\\\/g;");
1066 verifyFormat("var regex = /\a\\//g;");
Daniel Jasper23376252014-09-09 14:37:39 +00001067 verifyFormat("var regex = /a\\//;\n"
1068 "var x = 0;");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001069 verifyFormat("var regex = /'/g;", "var regex = /'/g ;");
1070 verifyFormat("var regex = /'/g; //'", "var regex = /'/g ; //'");
1071 verifyFormat("var regex = /\\/*/;\n"
1072 "var x = 0;",
1073 "var regex = /\\/*/;\n"
1074 "var x=0;");
1075 verifyFormat("var x = /a\\//;", "var x = /a\\// \n;");
Daniel Jasper6b8d26c2015-06-24 16:01:02 +00001076 verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16));
1077 verifyFormat("var regex =\n"
1078 " /\"/;",
1079 getGoogleJSStyleWithColumns(15));
Daniel Jasperf7372152015-07-02 14:14:04 +00001080 verifyFormat("var regex = //\n"
1081 " /a/;");
Daniel Jasperf1446202015-07-02 15:00:44 +00001082 verifyFormat("var regexs = [\n"
1083 " /d/, //\n"
1084 " /aa/, //\n"
1085 "];");
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001086}
1087
1088TEST_F(FormatTestJS, RegexLiteralModifiers) {
1089 verifyFormat("var regex = /abc/g;");
1090 verifyFormat("var regex = /abc/i;");
1091 verifyFormat("var regex = /abc/m;");
1092 verifyFormat("var regex = /abc/y;");
1093}
1094
1095TEST_F(FormatTestJS, RegexLiteralLength) {
1096 verifyFormat("var regex = /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1097 getGoogleJSStyleWithColumns(60));
1098 verifyFormat("var regex =\n"
1099 " /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1100 getGoogleJSStyleWithColumns(60));
Daniel Jasper0580ff02014-12-17 09:11:08 +00001101 verifyFormat("var regex = /\\xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1102 getGoogleJSStyleWithColumns(50));
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001103}
1104
1105TEST_F(FormatTestJS, RegexLiteralExamples) {
1106 verifyFormat("var regex = search.match(/(?:\?|&)times=([^?&]+)/i);");
1107}
1108
Martin Probstfa37b182017-01-27 09:09:11 +00001109TEST_F(FormatTestJS, IgnoresMpegTS) {
1110 std::string MpegTS(200, ' ');
1111 MpegTS.replace(0, strlen("nearlyLooks + like + ts + code; "),
1112 "nearlyLooks + like + ts + code; ");
1113 MpegTS[0] = 0x47;
1114 MpegTS[188] = 0x47;
1115 verifyFormat(MpegTS, MpegTS);
1116}
1117
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001118TEST_F(FormatTestJS, TypeAnnotations) {
1119 verifyFormat("var x: string;");
Daniel Jasperb9a49902016-01-09 15:56:28 +00001120 verifyFormat("var x: {a: string; b: number;} = {};");
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001121 verifyFormat("function x(): string {\n return 'x';\n}");
Manuel Klimek79e06082015-05-21 12:23:34 +00001122 verifyFormat("function x(): {x: string} {\n return {x: 'x'};\n}");
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001123 verifyFormat("function x(y: string): string {\n return 'x';\n}");
1124 verifyFormat("for (var y: string in x) {\n x();\n}");
Daniel Jasperb7fda112016-02-11 13:24:15 +00001125 verifyFormat("for (var y: string of x) {\n x();\n}");
Daniel Jasperb9a49902016-01-09 15:56:28 +00001126 verifyFormat("function x(y: {a?: number;} = {}): number {\n"
1127 " return 12;\n"
1128 "}");
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001129 verifyFormat("((a: string, b: number): string => a + b);");
1130 verifyFormat("var x: (y: number) => string;");
1131 verifyFormat("var x: P<string, (a: number) => string>;");
Daniel Jasper28d8a5a2016-09-07 23:01:13 +00001132 verifyFormat("var x = {\n"
1133 " y: function(): z {\n"
1134 " return 1;\n"
1135 " }\n"
1136 "};");
1137 verifyFormat("var x = {\n"
1138 " y: function(): {a: number} {\n"
1139 " return 1;\n"
1140 " }\n"
1141 "};");
Daniel Jasperf412e262016-01-08 10:51:24 +00001142 verifyFormat("function someFunc(args: string[]):\n"
1143 " {longReturnValue: string[]} {}",
1144 getGoogleJSStyleWithColumns(60));
Daniel Jasper3d934d32017-02-20 12:43:41 +00001145 verifyFormat(
1146 "var someValue = (v as aaaaaaaaaaaaaaaaaaaa<T>[])\n"
1147 " .someFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001148}
1149
Daniel Jasper91b1d1a2016-03-21 17:57:31 +00001150TEST_F(FormatTestJS, UnionIntersectionTypes) {
1151 verifyFormat("let x: A|B = A | B;");
1152 verifyFormat("let x: A&B|C = A & B;");
1153 verifyFormat("let x: Foo<A|B> = new Foo<A|B>();");
1154 verifyFormat("function(x: A|B): C&D {}");
1155 verifyFormat("function(x: A|B = A | B): C&D {}");
Martin Probst2ec23242016-06-09 22:49:04 +00001156 verifyFormat("function x(path: number|string) {}");
1157 verifyFormat("function x(): string|number {}");
Martin Probst1b7f9802016-06-23 19:52:32 +00001158 verifyFormat("type Foo = Bar|Baz;");
1159 verifyFormat("type Foo = Bar<X>|Baz;");
1160 verifyFormat("type Foo = (Bar<X>|Baz);");
1161 verifyFormat("let x: Bar|Baz;");
1162 verifyFormat("let x: Bar<X>|Baz;");
1163 verifyFormat("let x: (Foo|Bar)[];");
Daniel Jasper91b1d1a2016-03-21 17:57:31 +00001164}
1165
Daniel Jasper83709082015-02-18 17:14:05 +00001166TEST_F(FormatTestJS, ClassDeclarations) {
1167 verifyFormat("class C {\n x: string = 12;\n}");
1168 verifyFormat("class C {\n x(): string => 12;\n}");
1169 verifyFormat("class C {\n ['x' + 2]: string = 12;\n}");
1170 verifyFormat("class C {\n private x: string = 12;\n}");
1171 verifyFormat("class C {\n private static x: string = 12;\n}");
Daniel Jasper28d8a5a2016-09-07 23:01:13 +00001172 verifyFormat("class C {\n static x(): string {\n return 'asd';\n }\n}");
Daniel Jasper83709082015-02-18 17:14:05 +00001173 verifyFormat("class C extends P implements I {}");
Daniel Jasper6a5d38d2015-04-13 14:56:54 +00001174 verifyFormat("class C extends p.P implements i.I {}");
Martin Probst1027fb82017-02-07 14:05:30 +00001175 verifyFormat(
1176 "x(class {\n"
1177 " a(): A {}\n"
1178 "});");
Daniel Jasperb9a52812015-07-10 13:39:26 +00001179 verifyFormat("class Test {\n"
1180 " aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n"
1181 " aaaaaaaaaaaaaaaaaaaaaa {}\n"
1182 "}");
Daniel Jasperd5ec65b2016-01-08 07:06:07 +00001183 verifyFormat("foo = class Name {\n"
1184 " constructor() {}\n"
1185 "};");
1186 verifyFormat("foo = class {\n"
1187 " constructor() {}\n"
1188 "};");
Daniel Jasperb9a49902016-01-09 15:56:28 +00001189 verifyFormat("class C {\n"
1190 " x: {y: Z;} = {};\n"
1191 " private y: {y: Z;} = {};\n"
1192 "}");
Daniel Jasper81dbb562015-06-03 08:43:18 +00001193
1194 // ':' is not a type declaration here.
1195 verifyFormat("class X {\n"
1196 " subs = {\n"
1197 " 'b': {\n"
1198 " 'c': 1,\n"
1199 " },\n"
1200 " };\n"
1201 "}");
Daniel Jasper64650082016-06-14 11:28:02 +00001202 verifyFormat("@Component({\n"
1203 " moduleId: module.id,\n"
1204 "})\n"
1205 "class SessionListComponent implements OnDestroy, OnInit {\n"
1206 "}");
Daniel Jasper83709082015-02-18 17:14:05 +00001207}
1208
Daniel Jasper29647492015-05-05 08:12:50 +00001209TEST_F(FormatTestJS, InterfaceDeclarations) {
1210 verifyFormat("interface I {\n"
1211 " x: string;\n"
Daniel Jasper6f5a1932015-12-29 08:54:23 +00001212 " enum: string[];\n"
Daniel Jasper87379302016-02-03 05:33:44 +00001213 " enum?: string[];\n"
Daniel Jasper259188b2015-06-12 04:56:34 +00001214 "}\n"
1215 "var y;");
Daniel Jasper5c235c02015-07-06 14:26:04 +00001216 // Ensure that state is reset after parsing the interface.
1217 verifyFormat("interface a {}\n"
1218 "export function b() {}\n"
1219 "var x;");
Daniel Jasperb542f9f2015-12-22 15:48:35 +00001220
1221 // Arrays of object type literals.
1222 verifyFormat("interface I {\n"
1223 " o: {}[];\n"
1224 "}");
Daniel Jasper29647492015-05-05 08:12:50 +00001225}
1226
Daniel Jasper90cf3802015-06-17 09:44:02 +00001227TEST_F(FormatTestJS, EnumDeclarations) {
1228 verifyFormat("enum Foo {\n"
Daniel Jasper9f4ec152015-06-17 09:44:07 +00001229 " A = 1,\n"
1230 " B\n"
1231 "}");
1232 verifyFormat("export /* somecomment*/ enum Foo {\n"
1233 " A = 1,\n"
1234 " B\n"
1235 "}");
1236 verifyFormat("enum Foo {\n"
Daniel Jasper90cf3802015-06-17 09:44:02 +00001237 " A = 1, // comment\n"
1238 " B\n"
1239 "}\n"
1240 "var x = 1;");
1241}
1242
Daniel Jasper3c42dba2015-02-18 17:17:15 +00001243TEST_F(FormatTestJS, MetadataAnnotations) {
1244 verifyFormat("@A\nclass C {\n}");
1245 verifyFormat("@A({arg: 'value'})\nclass C {\n}");
1246 verifyFormat("@A\n@B\nclass C {\n}");
1247 verifyFormat("class C {\n @A x: string;\n}");
1248 verifyFormat("class C {\n"
1249 " @A\n"
1250 " private x(): string {\n"
1251 " return 'y';\n"
1252 " }\n"
1253 "}");
Martin Probst716a5332016-04-11 09:17:57 +00001254 verifyFormat("class C {\n"
1255 " private x(@A x: string) {}\n"
1256 "}");
Daniel Jasper6fa9ec72015-02-19 16:03:16 +00001257 verifyFormat("class X {}\n"
1258 "class Y {}");
Martin Probstad063912017-04-26 12:36:49 +00001259 verifyFormat("class X {\n"
1260 " @property() private isReply = false;\n"
1261 "}\n");
Daniel Jasper3c42dba2015-02-18 17:17:15 +00001262}
1263
Martin Probst805c6162016-04-19 14:59:16 +00001264TEST_F(FormatTestJS, TypeAliases) {
1265 verifyFormat("type X = number;\n"
1266 "class C {}");
1267 verifyFormat("type X<Y> = Z<Y>;");
1268 verifyFormat("type X = {\n"
1269 " y: number\n"
1270 "};\n"
1271 "class C {}");
1272}
1273
Martin Probstb98ab892017-03-13 07:10:18 +00001274TEST_F(FormatTestJS, TypeInterfaceLineWrapping) {
1275 const FormatStyle &Style = getGoogleJSStyleWithColumns(20);
1276 verifyFormat("type LongTypeIsReallyUnreasonablyLong =\n"
1277 " string;\n",
1278 "type LongTypeIsReallyUnreasonablyLong = string;\n",
1279 Style);
1280 verifyFormat(
1281 "interface AbstractStrategyFactoryProvider {\n"
1282 " a: number\n"
1283 "}\n",
1284 "interface AbstractStrategyFactoryProvider { a: number }\n",
1285 Style);
1286}
1287
Daniel Jasper354aa512015-02-19 16:07:32 +00001288TEST_F(FormatTestJS, Modules) {
1289 verifyFormat("import SomeThing from 'some/module.js';");
1290 verifyFormat("import {X, Y} from 'some/module.js';");
Daniel Jasperefc1a832016-01-07 08:53:35 +00001291 verifyFormat("import a, {X, Y} from 'some/module.js';");
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001292 verifyFormat("import {X, Y,} from 'some/module.js';");
Daniel Jasper354aa512015-02-19 16:07:32 +00001293 verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
Martin Probst48622092016-06-01 15:22:47 +00001294 // Ensure Automatic Semicolon Insertion does not break on "as\n".
1295 verifyFormat("import {X as myX} from 'm';", "import {X as\n"
1296 " myX} from 'm';");
Daniel Jasper354aa512015-02-19 16:07:32 +00001297 verifyFormat("import * as lib from 'some/module.js';");
Daniel Jasper60948b12015-03-15 13:55:54 +00001298 verifyFormat("var x = {import: 1};\nx.import = 2;");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001299
1300 verifyFormat("export function fn() {\n"
1301 " return 'fn';\n"
1302 "}");
Daniel Jasper20580fd2015-06-11 13:31:45 +00001303 verifyFormat("export function A() {}\n"
1304 "export default function B() {}\n"
1305 "export function C() {}");
Martin Probst053f1aa2016-04-19 14:55:37 +00001306 verifyFormat("export default () => {\n"
1307 " let x = 1;\n"
1308 " return x;\n"
1309 "}");
Daniel Jasper354aa512015-02-19 16:07:32 +00001310 verifyFormat("export const x = 12;");
1311 verifyFormat("export default class X {}");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001312 verifyFormat("export {X, Y} from 'some/module.js';");
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001313 verifyFormat("export {X, Y,} from 'some/module.js';");
1314 verifyFormat("export {SomeVeryLongExport as X, "
1315 "SomeOtherVeryLongExport as Y} from 'some/module.js';");
1316 // export without 'from' is wrapped.
1317 verifyFormat("export let someRatherLongVariableName =\n"
1318 " someSurprisinglyLongVariable + someOtherRatherLongVar;");
1319 // ... but not if from is just an identifier.
Daniel Jasperfca735c2015-02-19 16:14:18 +00001320 verifyFormat("export {\n"
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001321 " from as from,\n"
Martin Probstdce8e412016-06-22 14:35:14 +00001322 " someSurprisinglyLongVariable as\n"
1323 " from\n"
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001324 "};",
1325 getGoogleJSStyleWithColumns(20));
Daniel Jasperfca735c2015-02-19 16:14:18 +00001326 verifyFormat("export class C {\n"
1327 " x: number;\n"
1328 " y: string;\n"
1329 "}");
1330 verifyFormat("export class X { y: number; }");
Daniel Jasper8620d4c2016-01-12 06:24:38 +00001331 verifyFormat("export abstract class X { y: number; }");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001332 verifyFormat("export default class X { y: number }");
1333 verifyFormat("export default function() {\n return 1;\n}");
1334 verifyFormat("export var x = 12;");
Daniel Jasper910807d2015-06-12 04:52:02 +00001335 verifyFormat("class C {}\n"
1336 "export function f() {}\n"
1337 "var v;");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001338 verifyFormat("export var x: number = 12;");
1339 verifyFormat("export const y = {\n"
1340 " a: 1,\n"
1341 " b: 2\n"
1342 "};");
Daniel Jasper216c9cd2015-06-12 05:08:18 +00001343 verifyFormat("export enum Foo {\n"
1344 " BAR,\n"
1345 " // adsdasd\n"
1346 " BAZ\n"
1347 "}");
Daniel Jasperb14f6672016-01-04 15:51:56 +00001348 verifyFormat("export default [\n"
1349 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1350 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
1351 "];");
1352 verifyFormat("export default [];");
Daniel Jasper5e271462016-01-04 16:10:36 +00001353 verifyFormat("export default () => {};");
Daniel Jasperf55e4182016-01-11 22:57:40 +00001354 verifyFormat("export interface Foo { foo: number; }\n"
1355 "export class Bar {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +00001356 " blah(): string {\n"
1357 " return this.blah;\n"
1358 " };\n"
Daniel Jasperf55e4182016-01-11 22:57:40 +00001359 "}");
Daniel Jasper354aa512015-02-19 16:07:32 +00001360}
1361
Martin Probst0cd74ee2016-06-13 16:39:50 +00001362TEST_F(FormatTestJS, ImportWrapping) {
1363 verifyFormat("import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,"
1364 " VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying"
1365 "} from 'some/module.js';");
1366 FormatStyle Style = getGoogleJSStyleWithColumns(80);
1367 Style.JavaScriptWrapImports = true;
1368 verifyFormat("import {\n"
1369 " VeryLongImportsAreAnnoying,\n"
1370 " VeryLongImportsAreAnnoying,\n"
1371 " VeryLongImportsAreAnnoying,\n"
1372 "} from 'some/module.js';",
1373 Style);
1374 verifyFormat("import {\n"
1375 " A,\n"
1376 " A,\n"
1377 "} from 'some/module.js';",
1378 Style);
1379 verifyFormat("export {\n"
1380 " A,\n"
1381 " A,\n"
1382 "} from 'some/module.js';",
1383 Style);
1384}
1385
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001386TEST_F(FormatTestJS, TemplateStrings) {
1387 // Keeps any whitespace/indentation within the template string.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001388 verifyFormat("var x = `hello\n"
Martin Probst6181da42016-08-25 10:13:21 +00001389 " ${name}\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001390 " !`;",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001391 "var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001392 " ${ name }\n"
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001393 " !`;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001394
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001395 verifyFormat("var x =\n"
1396 " `hello ${world}` >= some();",
1397 getGoogleJSStyleWithColumns(34)); // Barely doesn't fit.
1398 verifyFormat("var x = `hello ${world}` >= some();",
Daniel Jasper553a5b02015-07-02 13:08:28 +00001399 getGoogleJSStyleWithColumns(35)); // Barely fits.
Martin Probste71b4cb2016-05-17 06:29:29 +00001400 verifyFormat("var x = `hellö ${wörld}` >= söme();",
1401 getGoogleJSStyleWithColumns(35)); // Fits due to UTF-8.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001402 verifyFormat("var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001403 " ${world}` >=\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +00001404 " some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001405 "var x =\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001406 " `hello\n"
1407 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001408 getGoogleJSStyleWithColumns(21)); // Barely doesn't fit.
1409 verifyFormat("var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001410 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001411 "var x =\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001412 " `hello\n"
1413 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001414 getGoogleJSStyleWithColumns(22)); // Barely fits.
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001415
Daniel Jasper553a5b02015-07-02 13:08:28 +00001416 verifyFormat("var x =\n"
1417 " `h`;",
1418 getGoogleJSStyleWithColumns(11));
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001419 verifyFormat("var x =\n `multi\n line`;", "var x = `multi\n line`;",
1420 getGoogleJSStyleWithColumns(13));
Daniel Jasper553a5b02015-07-02 13:08:28 +00001421 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1422 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);");
Martin Probste71b4cb2016-05-17 06:29:29 +00001423 // Repro for an obscure width-miscounting issue with template strings.
1424 verifyFormat(
1425 "someLongVariable =\n"
1426 " "
1427 "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;",
1428 "someLongVariable = "
1429 "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001430
Daniel Jasperf69b9222015-05-02 08:05:38 +00001431 // Make sure template strings get a proper ColumnWidth assigned, even if they
1432 // are first token in line.
1433 verifyFormat(
1434 "var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +00001435 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;");
Daniel Jasperf69b9222015-05-02 08:05:38 +00001436
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001437 // Two template strings.
1438 verifyFormat("var x = `hello` == `hello`;");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001439
1440 // Comments in template strings.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001441 verifyFormat("var x = `//a`;\n"
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001442 "var y;",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001443 "var x =\n `//a`;\n"
1444 "var y ;");
1445 verifyFormat("var x = `/*a`;\n"
1446 "var y;",
1447 "var x =\n `/*a`;\n"
1448 "var y;");
Daniel Jasper2ebb0c52015-06-14 07:16:57 +00001449 // Unterminated string literals in a template string.
1450 verifyFormat("var x = `'`; // comment with matching quote '\n"
1451 "var y;");
1452 verifyFormat("var x = `\"`; // comment with matching quote \"\n"
1453 "var y;");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001454 verifyFormat("it(`'aaaaaaaaaaaaaaa `, aaaaaaaaa);",
1455 "it(`'aaaaaaaaaaaaaaa `, aaaaaaaaa) ;",
1456 getGoogleJSStyleWithColumns(40));
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001457 // Backticks in a comment - not a template string.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001458 verifyFormat("var x = 1 // `/*a`;\n"
1459 " ;",
1460 "var x =\n 1 // `/*a`;\n"
1461 " ;");
1462 verifyFormat("/* ` */ var x = 1; /* ` */", "/* ` */ var x\n= 1; /* ` */");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001463 // Comment spans multiple template strings.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001464 verifyFormat("var x = `/*a`;\n"
1465 "var y = ` */ `;",
1466 "var x =\n `/*a`;\n"
1467 "var y =\n ` */ `;");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001468 // Escaped backtick.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001469 verifyFormat("var x = ` \\` a`;\n"
1470 "var y;",
1471 "var x = ` \\` a`;\n"
1472 "var y;");
Martin Probst6181da42016-08-25 10:13:21 +00001473 // Escaped dollar.
1474 verifyFormat("var x = ` \\${foo}`;\n");
Daniel Jasperf2019292017-01-31 12:07:35 +00001475
1476 // The token stream can contain two string_literals in sequence, but that
1477 // doesn't mean that they are implicitly concatenated in JavaScript.
1478 verifyFormat("var f = `aaaa ${a ? 'a' : 'b'}`;");
Daniel Jasper24de6fb2017-01-31 13:03:07 +00001479
1480 // Ensure that scopes are appropriately set around evaluated expressions in
1481 // template strings.
1482 verifyFormat("var f = `aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa\n"
1483 " aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa`;",
1484 "var f = `aaaaaaaaaaaaa:${aaaaaaa. aaaaa} aaaaaaaa\n"
1485 " aaaaaaaaaaaaa:${ aaaaaaa. aaaaa} aaaaaaaa`;");
Daniel Jasperc06f6da2017-02-03 14:32:38 +00001486 verifyFormat("var x = someFunction(`${})`) //\n"
1487 " .oooooooooooooooooon();");
Daniel Jasper98e0b122017-02-20 14:51:16 +00001488 verifyFormat("var x = someFunction(`${aaaa}${\n"
1489 " aaaaa( //\n"
1490 " aaaaa)\n"
1491 " })`);");
Martin Probst6181da42016-08-25 10:13:21 +00001492}
1493
Daniel Jasper3f119412017-01-31 14:39:33 +00001494TEST_F(FormatTestJS, TemplateStringMultiLineExpression) {
Daniel Jasper98e0b122017-02-20 14:51:16 +00001495 verifyFormat("var f = `aaaaaaaaaaaaaaaaaa: ${\n"
1496 " aaaaa + //\n"
1497 " bbbb\n"
1498 " }`;",
Daniel Jasper3f119412017-01-31 14:39:33 +00001499 "var f = `aaaaaaaaaaaaaaaaaa: ${aaaaa + //\n"
1500 " bbbb}`;");
Daniel Jasper3f119412017-01-31 14:39:33 +00001501 verifyFormat("var f = `\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001502 " aaaaaaaaaaaaaaaaaa: ${\n"
1503 " aaaaa + //\n"
1504 " bbbb\n"
1505 " }`;",
Daniel Jasper3f119412017-01-31 14:39:33 +00001506 "var f = `\n"
1507 " aaaaaaaaaaaaaaaaaa: ${ aaaaa + //\n"
1508 " bbbb }`;");
1509 verifyFormat("var f = `\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001510 " aaaaaaaaaaaaaaaaaa: ${\n"
Daniel Jasper3f119412017-01-31 14:39:33 +00001511 " someFunction(\n"
1512 " aaaaa + //\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001513 " bbbb)\n"
1514 " }`;",
Daniel Jasper3f119412017-01-31 14:39:33 +00001515 "var f = `\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001516 " aaaaaaaaaaaaaaaaaa: ${someFunction (\n"
Daniel Jasper3f119412017-01-31 14:39:33 +00001517 " aaaaa + //\n"
1518 " bbbb)}`;");
Daniel Jasper98e0b122017-02-20 14:51:16 +00001519
1520 // It might be preferable to wrap before "someFunction".
Daniel Jasper3f119412017-01-31 14:39:33 +00001521 verifyFormat("var f = `\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001522 " aaaaaaaaaaaaaaaaaa: ${someFunction({\n"
Daniel Jasper3f119412017-01-31 14:39:33 +00001523 " aaaa: aaaaa,\n"
1524 " bbbb: bbbbb,\n"
1525 " })}`;",
1526 "var f = `\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001527 " aaaaaaaaaaaaaaaaaa: ${someFunction ({\n"
Daniel Jasper3f119412017-01-31 14:39:33 +00001528 " aaaa: aaaaa,\n"
1529 " bbbb: bbbbb,\n"
1530 " })}`;");
1531}
1532
Martin Probst717f6dc2016-10-21 05:11:38 +00001533TEST_F(FormatTestJS, TemplateStringASI) {
1534 verifyFormat("var x = `hello${world}`;", "var x = `hello${\n"
1535 " world\n"
1536 "}`;");
1537}
1538
Martin Probst6181da42016-08-25 10:13:21 +00001539TEST_F(FormatTestJS, NestedTemplateStrings) {
1540 verifyFormat(
1541 "var x = `<ul>${xs.map(x => `<li>${x}</li>`).join('\\n')}</ul>`;");
1542 verifyFormat("var x = `he${({text: 'll'}.text)}o`;");
Daniel Jasper58209dd2016-09-17 07:20:36 +00001543
1544 // Crashed at some point.
1545 verifyFormat("}");
Martin Probst6181da42016-08-25 10:13:21 +00001546}
1547
1548TEST_F(FormatTestJS, TaggedTemplateStrings) {
1549 verifyFormat("var x = html`<ul>`;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001550}
1551
Martin Probst805c6162016-04-19 14:59:16 +00001552TEST_F(FormatTestJS, CastSyntax) {
1553 verifyFormat("var x = <type>foo;");
1554 verifyFormat("var x = foo as type;");
Martin Probstdce8e412016-06-22 14:35:14 +00001555 verifyFormat("let x = (a + b) as\n"
1556 " LongTypeIsLong;",
1557 getGoogleJSStyleWithColumns(20));
Daniel Jasper887a3992016-06-14 13:54:38 +00001558 verifyFormat("foo = <Bar[]>[\n"
1559 " 1, //\n"
1560 " 2\n"
1561 "];");
Martin Probste1e12a72016-08-19 14:35:01 +00001562 verifyFormat("var x = [{x: 1} as type];");
Martin Probsted87d782016-08-22 14:23:30 +00001563 verifyFormat("x = x as [a, b];");
1564 verifyFormat("x = x as {a: string};");
1565 verifyFormat("x = x as (string);");
Martin Probst34ecf422016-09-06 18:55:34 +00001566 verifyFormat("x = x! as (string);");
Daniel Jasper01b87832017-03-01 19:26:12 +00001567 verifyFormat("var x = something.someFunction() as\n"
1568 " something;",
1569 getGoogleJSStyleWithColumns(40));
Martin Probst805c6162016-04-19 14:59:16 +00001570}
Daniel Jasperbc46b932015-03-15 13:59:51 +00001571
1572TEST_F(FormatTestJS, TypeArguments) {
1573 verifyFormat("class X<Y> {}");
1574 verifyFormat("new X<Y>();");
1575 verifyFormat("foo<Y>(a);");
1576 verifyFormat("var x: X<Y>[];");
1577 verifyFormat("class C extends D<E> implements F<G>, H<I> {}");
Daniel Jasper20580fd2015-06-11 13:31:45 +00001578 verifyFormat("function f(a: List<any> = null) {}");
1579 verifyFormat("function f(): List<any> {}");
Daniel Jasper5a3de1d2015-07-03 10:37:23 +00001580 verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n"
1581 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}");
Daniel Jasper6501f7e2015-10-27 12:38:37 +00001582 verifyFormat("function aaaaaaaaaa(\n"
1583 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa,\n"
1584 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa):\n"
Daniel Jasperb2328b12015-07-06 14:07:51 +00001585 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {}");
Daniel Jasperbc46b932015-03-15 13:59:51 +00001586}
1587
Daniel Jasper779c66f2015-12-30 08:00:58 +00001588TEST_F(FormatTestJS, UserDefinedTypeGuards) {
1589 verifyFormat(
1590 "function foo(check: Object):\n"
1591 " check is {foo: string, bar: string, baz: string, foobar: string} {\n"
1592 " return 'bar' in check;\n"
1593 "}\n");
1594}
1595
Daniel Jaspera74f5072015-04-13 15:01:40 +00001596TEST_F(FormatTestJS, OptionalTypes) {
Daniel Jasper20580fd2015-06-11 13:31:45 +00001597 verifyFormat("function x(a?: b, c?, d?) {}");
Daniel Jaspera74f5072015-04-13 15:01:40 +00001598 verifyFormat("class X {\n"
1599 " y?: z;\n"
1600 " z?;\n"
1601 "}");
Daniel Jasper9326f912015-05-05 08:40:32 +00001602 verifyFormat("interface X {\n"
1603 " y?(): z;\n"
1604 "}");
Daniel Jasper3e0dcc22015-05-27 05:37:40 +00001605 verifyFormat("constructor({aa}: {\n"
1606 " aa?: string,\n"
1607 " aaaaaaaa?: string,\n"
1608 " aaaaaaaaaaaaaaa?: boolean,\n"
1609 " aaaaaa?: List<string>\n"
Daniel Jasper20580fd2015-06-11 13:31:45 +00001610 "}) {}");
Daniel Jaspera74f5072015-04-13 15:01:40 +00001611}
1612
Daniel Jasperd9309772015-04-13 15:03:30 +00001613TEST_F(FormatTestJS, IndexSignature) {
1614 verifyFormat("var x: {[k: string]: v};");
1615}
1616
Daniel Jasper6501f7e2015-10-27 12:38:37 +00001617TEST_F(FormatTestJS, WrapAfterParen) {
1618 verifyFormat("xxxxxxxxxxx(\n"
1619 " aaa, aaa);",
1620 getGoogleJSStyleWithColumns(20));
1621 verifyFormat("xxxxxxxxxxx(\n"
1622 " aaa, aaa, aaa,\n"
1623 " aaa, aaa, aaa);",
1624 getGoogleJSStyleWithColumns(20));
1625 verifyFormat("xxxxxxxxxxx(\n"
1626 " aaaaaaaaaaaaaaaaaaaaaaaa,\n"
1627 " function(x) {\n"
1628 " y(); //\n"
1629 " });",
1630 getGoogleJSStyleWithColumns(40));
1631 verifyFormat("while (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
1632 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
1633}
1634
Daniel Jasperd196abb2016-01-08 08:14:58 +00001635TEST_F(FormatTestJS, JSDocAnnotations) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001636 verifyFormat("/**\n"
1637 " * @export {this.is.a.long.path.to.a.Type}\n"
1638 " */",
1639 "/**\n"
1640 " * @export {this.is.a.long.path.to.a.Type}\n"
1641 " */",
1642 getGoogleJSStyleWithColumns(20));
Martin Probstbb46a7d2017-02-28 11:08:24 +00001643 verifyFormat("/**\n"
1644 " * @mods {this.is.a.long.path.to.a.Type}\n"
1645 " */",
1646 "/**\n"
1647 " * @mods {this.is.a.long.path.to.a.Type}\n"
1648 " */",
1649 getGoogleJSStyleWithColumns(20));
1650 verifyFormat("/**\n"
1651 " * @param {this.is.a.long.path.to.a.Type}\n"
1652 " */",
1653 "/**\n"
1654 " * @param {this.is.a.long.path.to.a.Type}\n"
1655 " */",
1656 getGoogleJSStyleWithColumns(20));
Martin Probstb4cdb652017-03-13 09:39:23 +00001657 verifyFormat("/**\n"
1658 " * @see http://very/very/long/url/is/long\n"
1659 " */",
1660 "/**\n"
1661 " * @see http://very/very/long/url/is/long\n"
1662 " */",
1663 getGoogleJSStyleWithColumns(20));
Martin Probstbb46a7d2017-02-28 11:08:24 +00001664 verifyFormat(
1665 "/**\n"
1666 " * @param This is a\n"
1667 " * long comment but\n"
1668 " * no type\n"
1669 " */",
1670 "/**\n"
1671 " * @param This is a long comment but no type\n"
1672 " */",
1673 getGoogleJSStyleWithColumns(20));
Krasimir Georgiev17725d82017-03-08 08:55:12 +00001674 // Don't break @param line, but reindent it and reflow unrelated lines.
1675 verifyFormat("{\n"
1676 " /**\n"
1677 " * long long long\n"
1678 " * long\n"
1679 " * @param {this.is.a.long.path.to.a.Type} a\n"
1680 " * long long long\n"
1681 " * long long\n"
1682 " */\n"
1683 " function f(a) {}\n"
1684 "}",
1685 "{\n"
1686 "/**\n"
1687 " * long long long long\n"
1688 " * @param {this.is.a.long.path.to.a.Type} a\n"
1689 " * long long long long\n"
1690 " * long\n"
1691 " */\n"
1692 " function f(a) {}\n"
1693 "}",
1694 getGoogleJSStyleWithColumns(20));
Daniel Jasperd196abb2016-01-08 08:14:58 +00001695}
1696
Daniel Jasperabd1f572016-03-02 22:44:03 +00001697TEST_F(FormatTestJS, RequoteStringsSingle) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001698 verifyFormat("var x = 'foo';", "var x = \"foo\";");
1699 verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo'o'\";");
1700 verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo\\'o'\";");
1701 verifyFormat(
1702 "var x =\n"
1703 " 'foo\\'';",
1704 // Code below is 15 chars wide, doesn't fit into the line with the
1705 // \ escape added.
1706 "var x = \"foo'\";", getGoogleJSStyleWithColumns(15));
Daniel Jasperabd1f572016-03-02 22:44:03 +00001707 // Removes no-longer needed \ escape from ".
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001708 verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";");
Daniel Jasperabd1f572016-03-02 22:44:03 +00001709 // Code below fits into 15 chars *after* removing the \ escape.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001710 verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";",
1711 getGoogleJSStyleWithColumns(15));
Martin Probsta1669792016-05-12 11:20:32 +00001712 verifyFormat("// clang-format off\n"
1713 "let x = \"double\";\n"
1714 "// clang-format on\n"
1715 "let x = 'single';\n",
1716 "// clang-format off\n"
1717 "let x = \"double\";\n"
1718 "// clang-format on\n"
1719 "let x = \"single\";\n");
Daniel Jasperabd1f572016-03-02 22:44:03 +00001720}
1721
Martin Probsta9855af2016-09-02 14:29:48 +00001722TEST_F(FormatTestJS, RequoteAndIndent) {
1723 verifyFormat("let x = someVeryLongFunctionThatGoesOnAndOn(\n"
1724 " 'double quoted string that needs wrapping');",
1725 "let x = someVeryLongFunctionThatGoesOnAndOn("
1726 "\"double quoted string that needs wrapping\");");
Daniel Jasper496c1992016-09-07 22:48:53 +00001727
1728 verifyFormat("let x =\n"
1729 " 'foo\\'oo';\n"
1730 "let x =\n"
1731 " 'foo\\'oo';",
1732 "let x=\"foo'oo\";\n"
1733 "let x=\"foo'oo\";",
1734 getGoogleJSStyleWithColumns(15));
Martin Probsta9855af2016-09-02 14:29:48 +00001735}
1736
Daniel Jasperabd1f572016-03-02 22:44:03 +00001737TEST_F(FormatTestJS, RequoteStringsDouble) {
1738 FormatStyle DoubleQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
1739 DoubleQuotes.JavaScriptQuotes = FormatStyle::JSQS_Double;
1740 verifyFormat("var x = \"foo\";", DoubleQuotes);
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001741 verifyFormat("var x = \"foo\";", "var x = 'foo';", DoubleQuotes);
1742 verifyFormat("var x = \"fo'o\";", "var x = 'fo\\'o';", DoubleQuotes);
Daniel Jasperabd1f572016-03-02 22:44:03 +00001743}
1744
1745TEST_F(FormatTestJS, RequoteStringsLeave) {
1746 FormatStyle LeaveQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
1747 LeaveQuotes.JavaScriptQuotes = FormatStyle::JSQS_Leave;
1748 verifyFormat("var x = \"foo\";", LeaveQuotes);
1749 verifyFormat("var x = 'foo';", LeaveQuotes);
1750}
1751
Martin Probst7ea9b6d2016-05-29 14:41:36 +00001752TEST_F(FormatTestJS, SupportShebangLines) {
1753 verifyFormat("#!/usr/bin/env node\n"
1754 "var x = hello();",
1755 "#!/usr/bin/env node\n"
1756 "var x = hello();");
1757}
1758
Martin Probst0eb40cf2016-06-13 00:49:54 +00001759TEST_F(FormatTestJS, NonNullAssertionOperator) {
1760 verifyFormat("let x = foo!.bar();\n");
1761 verifyFormat("let x = foo ? bar! : baz;\n");
1762 verifyFormat("let x = !foo;\n");
1763 verifyFormat("let x = foo[0]!;\n");
1764 verifyFormat("let x = (foo)!;\n");
Daniel Jasper8315ea12016-11-09 14:12:55 +00001765 verifyFormat("let x = foo! - 1;\n");
Martin Probst0eb40cf2016-06-13 00:49:54 +00001766 verifyFormat("let x = {foo: 1}!;\n");
Martin Probst22b8d2692017-03-13 09:14:23 +00001767 verifyFormat(
1768 "let x = hello.foo()!\n"
1769 " .foo()!\n"
1770 " .foo()!\n"
1771 " .foo()!;\n",
1772 getGoogleJSStyleWithColumns(20));
Martin Probst0eb40cf2016-06-13 00:49:54 +00001773}
1774
Martin Probst31d6da72016-06-23 21:51:49 +00001775TEST_F(FormatTestJS, Conditional) {
1776 verifyFormat("y = x ? 1 : 2;");
Daniel Jasperd9d8da22016-07-12 15:45:53 +00001777 verifyFormat("x ? 1 : 2;");
Martin Probst31d6da72016-06-23 21:51:49 +00001778 verifyFormat("class Foo {\n"
1779 " field = true ? 1 : 2;\n"
1780 " method(a = true ? 1 : 2) {}\n"
1781 "}");
1782}
1783
Martin Probstfbbe75b2016-09-18 17:33:51 +00001784TEST_F(FormatTestJS, ImportComments) {
1785 verifyFormat("import {x} from 'x'; // from some location",
1786 getGoogleJSStyleWithColumns(25));
1787 verifyFormat("// taze: x from 'location'", getGoogleJSStyleWithColumns(10));
1788}
Martin Probst4ef03702017-05-04 15:04:04 +00001789
1790TEST_F(FormatTestJS, Exponentiation) {
1791 verifyFormat("squared = x ** 2;");
1792 verifyFormat("squared **= 2;");
1793}
1794
Alexander Kornienkoab9db512015-06-22 23:07:51 +00001795} // end namespace tooling
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00001796} // end namespace clang