blob: 22ed04f6304db56d655921af47bfb8d9885aa81c [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));
Daniel Jasper56691b82015-06-11 13:29:20 +000027 bool IncompleteFormat = false;
28 tooling::Replacements Replaces =
29 reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
30 EXPECT_FALSE(IncompleteFormat);
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;");
135 verifyFormat("x.in() = 1;");
136 verifyFormat("x.let() = 1;");
137 verifyFormat("x.var() = 1;");
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000138 verifyFormat("x = {\n"
139 " a: 12,\n"
140 " interface: 1,\n"
141 " switch: 1,\n"
142 "};");
Daniel Jasper09840ef2015-11-20 15:58:50 +0000143 verifyFormat("var struct = 2;");
144 verifyFormat("var union = 2;");
Martin Probst1e8261e2016-04-19 18:18:59 +0000145 verifyFormat("var interface = 2;");
146 verifyFormat("interface = 2;");
147 verifyFormat("x = interface instanceof y;");
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000148}
149
Daniel Jasper72a1b6a2015-12-22 15:47:56 +0000150TEST_F(FormatTestJS, CppKeywords) {
151 // Make sure we don't mess stuff up because of C++ keywords.
152 verifyFormat("return operator && (aa);");
153}
154
Daniel Jasper0dd52912014-05-19 07:37:07 +0000155TEST_F(FormatTestJS, ES6DestructuringAssignment) {
156 verifyFormat("var [a, b, c] = [1, 2, 3];");
Daniel Jasper5dbcd3b2016-05-19 07:18:07 +0000157 verifyFormat("const [a, b, c] = [1, 2, 3];");
Daniel Jasper9f642f72015-09-28 14:28:08 +0000158 verifyFormat("let [a, b, c] = [1, 2, 3];");
Daniel Jasper60948b12015-03-15 13:55:54 +0000159 verifyFormat("var {a, b} = {a: 1, b: 2};");
Daniel Jasper9f642f72015-09-28 14:28:08 +0000160 verifyFormat("let {a, b} = {a: 1, b: 2};");
Daniel Jasper0dd52912014-05-19 07:37:07 +0000161}
162
Daniel Jasper17062ff2014-06-10 14:44:02 +0000163TEST_F(FormatTestJS, ContainerLiterals) {
Manuel Klimek79e06082015-05-21 12:23:34 +0000164 verifyFormat("var x = {y: function(a) { return a; }};");
Daniel Jasper17062ff2014-06-10 14:44:02 +0000165 verifyFormat("return {\n"
166 " link: function() {\n"
167 " f(); //\n"
168 " }\n"
169 "};");
170 verifyFormat("return {\n"
171 " a: a,\n"
172 " link: function() {\n"
173 " f(); //\n"
174 " }\n"
175 "};");
176 verifyFormat("return {\n"
177 " a: a,\n"
Daniel Jasper90ebc982014-09-05 09:27:38 +0000178 " link: function() {\n"
179 " f(); //\n"
180 " },\n"
181 " link: function() {\n"
182 " f(); //\n"
183 " }\n"
Daniel Jasper17062ff2014-06-10 14:44:02 +0000184 "};");
Daniel Jasper94e11d02014-09-04 14:58:30 +0000185 verifyFormat("var stuff = {\n"
186 " // comment for update\n"
187 " update: false,\n"
188 " // comment for modules\n"
189 " modules: false,\n"
190 " // comment for tasks\n"
191 " tasks: false\n"
192 "};");
Daniel Jasper97bfb7b2014-09-05 08:29:31 +0000193 verifyFormat("return {\n"
194 " 'finish':\n"
195 " //\n"
196 " a\n"
197 "};");
Daniel Jasper40874322014-11-27 15:24:48 +0000198 verifyFormat("var obj = {\n"
199 " fooooooooo: function(x) {\n"
200 " return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
201 " }\n"
202 "};");
Daniel Jasper60948b12015-03-15 13:55:54 +0000203 // Simple object literal, as opposed to enum style below.
204 verifyFormat("var obj = {a: 123};");
205 // Enum style top level assignment.
206 verifyFormat("X = {\n a: 123\n};");
207 verifyFormat("X.Y = {\n a: 123\n};");
Daniel Jasper11ca2632015-06-10 09:21:09 +0000208 // But only on the top level, otherwise its a plain object literal assignment.
209 verifyFormat("function x() {\n"
210 " y = {z: 1};\n"
211 "}");
Daniel Jasper60948b12015-03-15 13:55:54 +0000212 verifyFormat("x = foo && {a: 123};");
Manuel Klimek79e06082015-05-21 12:23:34 +0000213
214 // Arrow functions in object literals.
215 verifyFormat("var x = {y: (a) => { return a; }};");
216 verifyFormat("var x = {y: (a) => a};");
Daniel Jasper8c42d442015-05-29 06:19:49 +0000217
218 // Computed keys.
Daniel Jaspercd8d4ff2015-05-31 08:40:37 +0000219 verifyFormat("var x = {[a]: 1, b: 2, [c]: 3};");
Daniel Jasper8c42d442015-05-29 06:19:49 +0000220 verifyFormat("var x = {\n"
221 " [a]: 1,\n"
Daniel Jaspercd8d4ff2015-05-31 08:40:37 +0000222 " b: 2,\n"
223 " [c]: 3,\n"
Daniel Jasper8c42d442015-05-29 06:19:49 +0000224 "};");
Daniel Jasper9f4c9d42016-02-07 22:17:13 +0000225
226 // Object literals can leave out labels.
227 verifyFormat("f({a}, () => {\n"
228 " g(); //\n"
229 "});");
Daniel Jasperb18425b2016-03-01 04:19:47 +0000230
231 // Keys can be quoted.
232 verifyFormat("var x = {\n"
233 " a: a,\n"
234 " b: b,\n"
235 " 'c': c,\n"
236 "};");
Daniel Jasper17062ff2014-06-10 14:44:02 +0000237}
238
Daniel Jasperf46dec82015-03-31 14:34:15 +0000239TEST_F(FormatTestJS, MethodsInObjectLiterals) {
240 verifyFormat("var o = {\n"
241 " value: 'test',\n"
242 " get value() { // getter\n"
243 " return this.value;\n"
244 " }\n"
245 "};");
246 verifyFormat("var o = {\n"
247 " value: 'test',\n"
248 " set value(val) { // setter\n"
249 " this.value = val;\n"
250 " }\n"
251 "};");
252 verifyFormat("var o = {\n"
253 " value: 'test',\n"
254 " someMethod(val) { // method\n"
255 " doSomething(this.value + val);\n"
256 " }\n"
257 "};");
Daniel Jasper739ec532015-04-04 07:56:55 +0000258 verifyFormat("var o = {\n"
259 " someMethod(val) { // method\n"
260 " doSomething(this.value + val);\n"
261 " },\n"
262 " someOtherMethod(val) { // method\n"
263 " doSomething(this.value + val);\n"
264 " }\n"
265 "};");
Daniel Jasperf46dec82015-03-31 14:34:15 +0000266}
267
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000268TEST_F(FormatTestJS, SpacesInContainerLiterals) {
269 verifyFormat("var arr = [1, 2, 3];");
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000270 verifyFormat("f({a: 1, b: 2, c: 3});");
Nico Weber514ecc82014-02-02 20:50:45 +0000271
Daniel Jasper2a958322014-05-21 13:26:58 +0000272 verifyFormat("var object_literal_with_long_name = {\n"
273 " a: 'aaaaaaaaaaaaaaaaaa',\n"
274 " b: 'bbbbbbbbbbbbbbbbbb'\n"
275 "};");
276
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000277 verifyFormat("f({a: 1, b: 2, c: 3});",
Nico Weber514ecc82014-02-02 20:50:45 +0000278 getChromiumStyle(FormatStyle::LK_JavaScript));
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000279 verifyFormat("f({'a': [{}]});");
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000280}
281
Daniel Jasperabd1f572016-03-02 22:44:03 +0000282TEST_F(FormatTestJS, SingleQuotedStrings) {
Daniel Jasper86fee2f2014-01-31 12:49:42 +0000283 verifyFormat("this.function('', true);");
284}
285
Daniel Jasper4a39c842014-05-06 13:54:10 +0000286TEST_F(FormatTestJS, GoogScopes) {
287 verifyFormat("goog.scope(function() {\n"
288 "var x = a.b;\n"
289 "var y = c.d;\n"
290 "}); // goog.scope");
Daniel Jasper02c7bca2015-03-30 09:56:50 +0000291 verifyFormat("goog.scope(function() {\n"
292 "// test\n"
293 "var x = 0;\n"
294 "// test\n"
295 "});");
Daniel Jasper4a39c842014-05-06 13:54:10 +0000296}
297
Daniel Jasper616de8642014-11-23 16:46:28 +0000298TEST_F(FormatTestJS, GoogModules) {
299 verifyFormat("goog.module('this.is.really.absurdly.long');",
300 getGoogleJSStyleWithColumns(40));
301 verifyFormat("goog.require('this.is.really.absurdly.long');",
302 getGoogleJSStyleWithColumns(40));
303 verifyFormat("goog.provide('this.is.really.absurdly.long');",
304 getGoogleJSStyleWithColumns(40));
305 verifyFormat("var long = goog.require('this.is.really.absurdly.long');",
306 getGoogleJSStyleWithColumns(40));
Daniel Jasperb488a742015-10-29 19:05:20 +0000307 verifyFormat("goog.setTestOnly('this.is.really.absurdly.long');",
308 getGoogleJSStyleWithColumns(40));
Daniel Jasper02cbeb22016-02-22 15:06:53 +0000309 verifyFormat("goog.forwardDeclare('this.is.really.absurdly.long');",
310 getGoogleJSStyleWithColumns(40));
Daniel Jasper53c38f42014-11-27 14:46:03 +0000311
312 // These should be wrapped normally.
313 verifyFormat(
314 "var MyLongClassName =\n"
315 " goog.module.get('my.long.module.name.followedBy.MyLongClassName');");
Daniel Jasper616de8642014-11-23 16:46:28 +0000316}
317
Martin Probstece8c0c2016-06-13 16:41:28 +0000318TEST_F(FormatTestJS, FormatsNamespaces) {
319 verifyFormat("namespace Foo {\n"
320 " export let x = 1;\n"
321 "}\n");
322 verifyFormat("declare namespace Foo {\n"
323 " export let x: number;\n"
324 "}\n");
325}
326
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000327TEST_F(FormatTestJS, FormatsFreestandingFunctions) {
328 verifyFormat("function outer1(a, b) {\n"
329 " function inner1(a, b) { return a; }\n"
330 " inner1(a, b);\n"
331 "}\n"
332 "function outer2(a, b) {\n"
333 " function inner2(a, b) { return a; }\n"
334 " inner2(a, b);\n"
335 "}");
Daniel Jasper20580fd2015-06-11 13:31:45 +0000336 verifyFormat("function f() {}");
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000337}
338
Martin Probst5f8445b2016-04-24 22:05:09 +0000339TEST_F(FormatTestJS, GeneratorFunctions) {
340 verifyFormat("function* f() {\n"
341 " let x = 1;\n"
342 " yield x;\n"
343 " yield* something();\n"
344 "}");
345 verifyFormat("function*\n"
346 " f() {\n"
347 "}",
348 getGoogleJSStyleWithColumns(8));
349 verifyFormat("export function* f() {\n"
350 " yield 1;\n"
351 "}\n");
352 verifyFormat("class X {\n"
353 " * generatorMethod() { yield x; }\n"
354 "}");
355}
356
357TEST_F(FormatTestJS, AsyncFunctions) {
358 verifyFormat("async function f() {\n"
359 " let x = 1;\n"
360 " return fetch(x);\n"
361 "}");
362 verifyFormat("async function* f() {\n"
363 " yield fetch(x);\n"
364 "}");
365 verifyFormat("export async function f() {\n"
366 " return fetch(x);\n"
367 "}");
368 verifyFormat("class X {\n"
369 " async asyncMethod() { return fetch(1); }\n"
370 "}");
Martin Probst409697e2016-05-29 14:41:07 +0000371 verifyFormat("function initialize() {\n"
372 " // Comment.\n"
373 " return async.then();\n"
374 "}\n");
Martin Probst5f8445b2016-04-24 22:05:09 +0000375}
376
Daniel Jasperf841d3a2015-05-28 07:21:50 +0000377TEST_F(FormatTestJS, ArrayLiterals) {
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +0000378 verifyFormat("var aaaaa: List<SomeThing> =\n"
379 " [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];");
Daniel Jasperd492b5e2015-06-02 21:57:51 +0000380 verifyFormat("return [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000381 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasperd492b5e2015-06-02 21:57:51 +0000382 " ccccccccccccccccccccccccccc\n"
383 "];");
Daniel Jasper7bec87c2016-01-07 18:11:54 +0000384 verifyFormat("return [\n"
385 " aaaa().bbbbbbbb('A'),\n"
386 " aaaa().bbbbbbbb('B'),\n"
387 " aaaa().bbbbbbbb('C'),\n"
388 "];");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000389 verifyFormat("var someVariable = SomeFunction([\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000390 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasper5ce80de2015-06-02 13:56:43 +0000391 " ccccccccccccccccccccccccccc\n"
392 "]);");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000393 verifyFormat("var someVariable = SomeFunction([\n"
Daniel Jasper40432ce2015-06-02 15:04:29 +0000394 " [aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbb],\n"
Daniel Jasper199d0c92015-06-02 15:14:21 +0000395 "]);",
396 getGoogleJSStyleWithColumns(51));
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000397 verifyFormat("var someVariable = SomeFunction(aaaa, [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000398 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasper4284e362015-06-02 14:20:08 +0000399 " ccccccccccccccccccccccccccc\n"
400 "]);");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000401 verifyFormat("var someVariable = SomeFunction(\n"
402 " aaaa,\n"
403 " [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000404 " aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
405 " cccccccccccccccccccccccccc\n"
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000406 " ],\n"
407 " aaaa);");
Daniel Jasperebcb71f2016-01-04 13:11:41 +0000408 verifyFormat("var aaaa = aaaaa || // wrap\n"
409 " [];");
Daniel Jasper1feab0f2015-06-02 15:31:37 +0000410
411 verifyFormat("someFunction([], {a: a});");
Daniel Jasperf841d3a2015-05-28 07:21:50 +0000412}
413
Daniel Jaspere2deb592015-12-22 15:48:15 +0000414TEST_F(FormatTestJS, ColumnLayoutForArrayLiterals) {
415 verifyFormat("var array = [\n"
416 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
417 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
418 "];");
419 verifyFormat("var array = someFunction([\n"
420 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
421 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
422 "]);");
423}
424
Daniel Jasper5217a8b2014-06-13 07:02:04 +0000425TEST_F(FormatTestJS, FunctionLiterals) {
Daniel Jasper3f69ba12014-09-05 08:42:27 +0000426 verifyFormat("doFoo(function() {});");
Daniel Jasper79dffb42014-05-07 09:48:30 +0000427 verifyFormat("doFoo(function() { return 1; });");
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000428 verifyFormat("var func = function() {\n"
429 " return 1;\n"
430 "};");
Daniel Jaspered3f3952015-06-18 12:32:59 +0000431 verifyFormat("var func = //\n"
432 " function() {\n"
433 " return 1;\n"
434 "};");
Daniel Jasperc03e16a2014-05-08 09:25:39 +0000435 verifyFormat("return {\n"
436 " body: {\n"
437 " setAttribute: function(key, val) { this[key] = val; },\n"
438 " getAttribute: function(key) { return this[key]; },\n"
439 " style: {direction: ''}\n"
440 " }\n"
441 "};");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000442 verifyFormat("abc = xyz ? function() {\n"
443 " return 1;\n"
444 "} : function() {\n"
445 " return -1;\n"
446 "};");
Daniel Jasperb16b9692014-05-21 12:51:23 +0000447
448 verifyFormat("var closure = goog.bind(\n"
449 " function() { // comment\n"
450 " foo();\n"
451 " bar();\n"
452 " },\n"
453 " this, arg1IsReallyLongAndNeeedsLineBreaks,\n"
454 " arg3IsReallyLongAndNeeedsLineBreaks);");
455 verifyFormat("var closure = goog.bind(function() { // comment\n"
456 " foo();\n"
457 " bar();\n"
458 "}, this);");
Daniel Jasper58cb2ed2014-06-06 13:49:04 +0000459 verifyFormat("return {\n"
460 " a: 'E',\n"
461 " b: function() {\n"
462 " return function() {\n"
463 " f(); //\n"
464 " };\n"
465 " }\n"
466 "};");
Daniel Jasper41368e92014-11-27 15:37:42 +0000467 verifyFormat("{\n"
468 " var someVariable = function(x) {\n"
469 " return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
470 " };\n"
471 "}");
Daniel Jasper7325aee2015-05-08 08:38:52 +0000472 verifyFormat("someLooooooooongFunction(\n"
473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
474 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
475 " function(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
476 " // code\n"
477 " });");
Daniel Jasper5f3ea472014-05-22 08:36:53 +0000478
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000479 verifyFormat("f({a: function() { return 1; }});",
480 getGoogleJSStyleWithColumns(33));
481 verifyFormat("f({\n"
Daniel Jasper5f3ea472014-05-22 08:36:53 +0000482 " a: function() { return 1; }\n"
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000483 "});",
484 getGoogleJSStyleWithColumns(32));
Daniel Jasper5217a8b2014-06-13 07:02:04 +0000485
486 verifyFormat("return {\n"
487 " a: function SomeFunction() {\n"
488 " // ...\n"
489 " return 1;\n"
490 " }\n"
491 "};");
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000492 verifyFormat("this.someObject.doSomething(aaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
493 " .then(goog.bind(function(aaaaaaaaaaa) {\n"
494 " someFunction();\n"
495 " someFunction();\n"
496 " }, this), aaaaaaaaaaaaaaaaa);");
497
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000498 verifyFormat("someFunction(goog.bind(function() {\n"
499 " doSomething();\n"
500 " doSomething();\n"
501 "}, this), goog.bind(function() {\n"
502 " doSomething();\n"
503 " doSomething();\n"
504 "}, this));");
Daniel Jasper1699eca2015-06-01 09:56:32 +0000505
506 // FIXME: This is bad, we should be wrapping before "function() {".
507 verifyFormat("someFunction(function() {\n"
508 " doSomething(); // break\n"
509 "})\n"
510 " .doSomethingElse(\n"
511 " // break\n"
512 " );");
Daniel Jasper79dffb42014-05-07 09:48:30 +0000513}
514
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000515TEST_F(FormatTestJS, InliningFunctionLiterals) {
516 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
517 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
518 verifyFormat("var func = function() {\n"
519 " return 1;\n"
520 "};",
521 Style);
522 verifyFormat("var func = doSomething(function() { return 1; });", Style);
523 verifyFormat("var outer = function() {\n"
524 " var inner = function() { return 1; }\n"
525 "};",
526 Style);
527 verifyFormat("function outer1(a, b) {\n"
528 " function inner1(a, b) { return a; }\n"
529 "}",
530 Style);
531
532 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
533 verifyFormat("var func = function() { return 1; };", Style);
534 verifyFormat("var func = doSomething(function() { return 1; });", Style);
535 verifyFormat(
536 "var outer = function() { var inner = function() { return 1; } };",
537 Style);
538 verifyFormat("function outer1(a, b) {\n"
539 " function inner1(a, b) { return a; }\n"
540 "}",
541 Style);
542
543 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
544 verifyFormat("var func = function() {\n"
545 " return 1;\n"
546 "};",
547 Style);
548 verifyFormat("var func = doSomething(function() {\n"
549 " return 1;\n"
550 "});",
551 Style);
552 verifyFormat("var outer = function() {\n"
553 " var inner = function() {\n"
554 " return 1;\n"
555 " }\n"
556 "};",
557 Style);
558 verifyFormat("function outer1(a, b) {\n"
559 " function inner1(a, b) {\n"
560 " return a;\n"
561 " }\n"
562 "}",
563 Style);
Daniel Jasper71e57452015-11-20 16:44:28 +0000564
565 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
566 verifyFormat("var func = function() {\n"
567 " return 1;\n"
568 "};",
569 Style);
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000570}
571
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000572TEST_F(FormatTestJS, MultipleFunctionLiterals) {
573 verifyFormat("promise.then(\n"
574 " function success() {\n"
575 " doFoo();\n"
576 " doBar();\n"
577 " },\n"
578 " function error() {\n"
579 " doFoo();\n"
580 " doBaz();\n"
581 " },\n"
582 " []);\n");
583 verifyFormat("promise.then(\n"
584 " function success() {\n"
585 " doFoo();\n"
586 " doBar();\n"
587 " },\n"
588 " [],\n"
589 " function error() {\n"
590 " doFoo();\n"
591 " doBaz();\n"
592 " });\n");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000593 verifyFormat("promise.then(\n"
594 " [],\n"
595 " function success() {\n"
596 " doFoo();\n"
597 " doBar();\n"
598 " },\n"
599 " function error() {\n"
600 " doFoo();\n"
601 " doBaz();\n"
602 " });\n");
Daniel Jasper1779d432014-09-29 07:54:54 +0000603
604 verifyFormat("getSomeLongPromise()\n"
605 " .then(function(value) { body(); })\n"
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000606 " .thenCatch(function(error) {\n"
607 " body();\n"
608 " body();\n"
609 " });");
Daniel Jasper1779d432014-09-29 07:54:54 +0000610 verifyFormat("getSomeLongPromise()\n"
611 " .then(function(value) {\n"
612 " body();\n"
613 " body();\n"
614 " })\n"
615 " .thenCatch(function(error) {\n"
616 " body();\n"
617 " body();\n"
618 " });");
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000619
Daniel Jasperacf67e32015-04-07 08:20:35 +0000620 verifyFormat("getSomeLongPromise()\n"
621 " .then(function(value) { body(); })\n"
622 " .thenCatch(function(error) { body(); });");
Daniel Jasper28024562016-01-11 11:00:58 +0000623
624 verifyFormat("return [aaaaaaaaaaaaaaaaaaaaaa]\n"
625 " .aaaaaaa(function() {\n"
626 " //\n"
627 " })\n"
628 " .bbbbbb();");
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000629}
630
Manuel Klimek79e06082015-05-21 12:23:34 +0000631TEST_F(FormatTestJS, ArrowFunctions) {
632 verifyFormat("var x = (a) => {\n"
633 " return a;\n"
634 "};");
635 verifyFormat("var x = (a) => {\n"
636 " function y() { return 42; }\n"
637 " return a;\n"
638 "};");
639 verifyFormat("var x = (a: type): {some: type} => {\n"
640 " return a;\n"
641 "};");
642 verifyFormat("var x = (a) => a;");
Daniel Jaspere497bed2015-06-02 22:06:07 +0000643 verifyFormat("return () => [];");
Daniel Jasper3c306e82015-06-03 17:08:40 +0000644 verifyFormat("var aaaaaaaaaaaaaaaaaaaa = {\n"
645 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
646 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
647 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) =>\n"
Daniel Jasper3b0f3042015-06-05 08:25:37 +0000648 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper3c306e82015-06-03 17:08:40 +0000649 "};");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000650 verifyFormat("var a = a.aaaaaaa(\n"
651 " (a: a) => aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) &&\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000652 " aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000653 verifyFormat("var a = a.aaaaaaa(\n"
654 " (a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) ?\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000655 " aaaaaaaaaaaaaaaaaaaaa(bbbbbbb) :\n"
656 " aaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
Daniel Jasper1699eca2015-06-01 09:56:32 +0000657
658 // FIXME: This is bad, we should be wrapping before "() => {".
659 verifyFormat("someFunction(() => {\n"
660 " doSomething(); // break\n"
661 "})\n"
662 " .doSomethingElse(\n"
663 " // break\n"
664 " );");
Manuel Klimek79e06082015-05-21 12:23:34 +0000665}
666
Daniel Jasper166c19b2014-05-06 14:12:21 +0000667TEST_F(FormatTestJS, ReturnStatements) {
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000668 verifyFormat("function() {\n"
669 " return [hello, world];\n"
670 "}");
Daniel Jasper166c19b2014-05-06 14:12:21 +0000671}
672
Daniel Jasperf95b1f42015-11-20 16:18:42 +0000673TEST_F(FormatTestJS, ForLoops) {
674 verifyFormat("for (var i in [2, 3]) {\n"
675 "}");
Daniel Jasperb7fda112016-02-11 13:24:15 +0000676 verifyFormat("for (var i of [2, 3]) {\n"
677 "}");
Daniel Jasperacffeb82016-03-05 18:34:26 +0000678 verifyFormat("for (let {a, b} of x) {\n"
679 "}");
680 verifyFormat("for (let {a, b} in x) {\n"
681 "}");
Daniel Jasperf95b1f42015-11-20 16:18:42 +0000682}
683
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000684TEST_F(FormatTestJS, WrapRespectsAutomaticSemicolonInsertion) {
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000685 // The following statements must not wrap, as otherwise the program meaning
686 // would change due to automatic semicolon insertion.
687 // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1.
688 verifyFormat("return aaaaa;", getGoogleJSStyleWithColumns(10));
Martin Probst56ff7aa2016-09-06 18:39:30 +0000689 verifyFormat("return /* hello! */ aaaaa;", getGoogleJSStyleWithColumns(10));
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000690 verifyFormat("continue aaaaa;", getGoogleJSStyleWithColumns(10));
Martin Probst56ff7aa2016-09-06 18:39:30 +0000691 verifyFormat("continue /* hello! */ aaaaa;", getGoogleJSStyleWithColumns(10));
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000692 verifyFormat("break aaaaa;", getGoogleJSStyleWithColumns(10));
693 verifyFormat("throw aaaaa;", getGoogleJSStyleWithColumns(10));
694 verifyFormat("aaaaaaaaa++;", getGoogleJSStyleWithColumns(10));
695 verifyFormat("aaaaaaaaa--;", getGoogleJSStyleWithColumns(10));
Daniel Jasper11a87652016-01-14 05:37:52 +0000696 verifyFormat("return [\n"
697 " aaa\n"
698 "];",
699 getGoogleJSStyleWithColumns(12));
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000700}
701
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000702TEST_F(FormatTestJS, AutomaticSemicolonInsertionHeuristic) {
703 verifyFormat("a\n"
704 "b;",
705 " a \n"
706 " b ;");
707 verifyFormat("a()\n"
708 "b;",
709 " a ()\n"
710 " b ;");
711 verifyFormat("a[b]\n"
712 "c;",
713 "a [b]\n"
714 "c ;");
715 verifyFormat("1\n"
716 "a;",
717 "1 \n"
718 "a ;");
719 verifyFormat("a\n"
720 "1;",
721 "a \n"
722 "1 ;");
723 verifyFormat("a\n"
724 "'x';",
725 "a \n"
726 " 'x';");
727 verifyFormat("a++\n"
728 "b;",
729 "a ++\n"
730 "b ;");
731 verifyFormat("a\n"
732 "!b && c;",
733 "a \n"
734 " ! b && c;");
735 verifyFormat("a\n"
736 "if (1) f();",
737 " a\n"
738 " if (1) f();");
739 verifyFormat("a\n"
740 "class X {}",
741 " a\n"
742 " class X {}");
743 verifyFormat("var a", "var\n"
744 "a");
745 verifyFormat("x instanceof String", "x\n"
746 "instanceof\n"
747 "String");
Martin Probstbbffeac2016-04-11 07:35:57 +0000748 verifyFormat("function f(@Foo bar) {}", "function f(@Foo\n"
749 " bar) {}");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000750}
751
Manuel Klimek79e06082015-05-21 12:23:34 +0000752TEST_F(FormatTestJS, ClosureStyleCasts) {
Daniel Jasper484033b2014-05-06 14:41:29 +0000753 verifyFormat("var x = /** @type {foo} */ (bar);");
754}
755
Daniel Jasper04a71a42014-05-08 11:58:24 +0000756TEST_F(FormatTestJS, TryCatch) {
757 verifyFormat("try {\n"
758 " f();\n"
759 "} catch (e) {\n"
760 " g();\n"
761 "} finally {\n"
762 " h();\n"
763 "}");
Daniel Jasper8f2e94c2014-09-04 15:03:34 +0000764
765 // But, of course, "catch" is a perfectly fine function name in JavaScript.
766 verifyFormat("someObject.catch();");
Daniel Jasper79121232014-11-27 14:55:17 +0000767 verifyFormat("someObject.new();");
768 verifyFormat("someObject.delete();");
Daniel Jasper04a71a42014-05-08 11:58:24 +0000769}
770
Daniel Jasper49802ef2014-05-22 09:10:04 +0000771TEST_F(FormatTestJS, StringLiteralConcatenation) {
772 verifyFormat("var literal = 'hello ' +\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000773 " 'world';");
Daniel Jasper49802ef2014-05-22 09:10:04 +0000774}
775
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000776TEST_F(FormatTestJS, RegexLiteralClassification) {
777 // Regex literals.
778 verifyFormat("var regex = /abc/;");
779 verifyFormat("f(/abc/);");
780 verifyFormat("f(abc, /abc/);");
781 verifyFormat("some_map[/abc/];");
782 verifyFormat("var x = a ? /abc/ : /abc/;");
783 verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}");
784 verifyFormat("var x = !/abc/.test(y);");
785 verifyFormat("var x = a && /abc/.test(y);");
786 verifyFormat("var x = a || /abc/.test(y);");
787 verifyFormat("var x = a + /abc/.search(y);");
Daniel Jasperc553ae12015-07-02 13:20:45 +0000788 verifyFormat("/abc/.search(y);");
Daniel Jasperf7405c12014-05-08 07:45:18 +0000789 verifyFormat("var regexs = {/abc/, /abc/};");
790 verifyFormat("return /abc/;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000791
792 // Not regex literals.
793 verifyFormat("var a = a / 2 + b / 3;");
Daniel Jasper265309e2015-10-18 07:02:28 +0000794 verifyFormat("var a = a++ / 2;");
795 // Prefix unary can operate on regex literals, not that it makes sense.
796 verifyFormat("var a = ++/a/;");
797
798 // This is a known issue, regular expressions are incorrectly detected if
799 // directly following a closing parenthesis.
800 verifyFormat("if (foo) / bar /.exec(baz);");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000801}
802
803TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) {
Daniel Jasper69694b02015-05-08 07:55:13 +0000804 verifyFormat("var regex = /=/;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000805 verifyFormat("var regex = /a*/;");
806 verifyFormat("var regex = /a+/;");
807 verifyFormat("var regex = /a?/;");
808 verifyFormat("var regex = /.a./;");
809 verifyFormat("var regex = /a\\*/;");
810 verifyFormat("var regex = /^a$/;");
811 verifyFormat("var regex = /\\/a/;");
812 verifyFormat("var regex = /(?:x)/;");
813 verifyFormat("var regex = /x(?=y)/;");
814 verifyFormat("var regex = /x(?!y)/;");
815 verifyFormat("var regex = /x|y/;");
816 verifyFormat("var regex = /a{2}/;");
817 verifyFormat("var regex = /a{1,3}/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +0000818
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000819 verifyFormat("var regex = /[abc]/;");
820 verifyFormat("var regex = /[^abc]/;");
821 verifyFormat("var regex = /[\\b]/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +0000822 verifyFormat("var regex = /[/]/;");
823 verifyFormat("var regex = /[\\/]/;");
824 verifyFormat("var regex = /\\[/;");
825 verifyFormat("var regex = /\\\\[/]/;");
Daniel Jasper265309e2015-10-18 07:02:28 +0000826 verifyFormat("var regex = /}[\"]/;");
827 verifyFormat("var regex = /}[/\"]/;");
828 verifyFormat("var regex = /}[\"/]/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +0000829
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000830 verifyFormat("var regex = /\\b/;");
831 verifyFormat("var regex = /\\B/;");
832 verifyFormat("var regex = /\\d/;");
833 verifyFormat("var regex = /\\D/;");
834 verifyFormat("var regex = /\\f/;");
835 verifyFormat("var regex = /\\n/;");
836 verifyFormat("var regex = /\\r/;");
837 verifyFormat("var regex = /\\s/;");
838 verifyFormat("var regex = /\\S/;");
839 verifyFormat("var regex = /\\t/;");
840 verifyFormat("var regex = /\\v/;");
841 verifyFormat("var regex = /\\w/;");
842 verifyFormat("var regex = /\\W/;");
843 verifyFormat("var regex = /a(a)\\1/;");
844 verifyFormat("var regex = /\\0/;");
Daniel Jasperfb4333b2014-05-12 11:29:50 +0000845 verifyFormat("var regex = /\\\\/g;");
846 verifyFormat("var regex = /\\a\\\\/g;");
847 verifyFormat("var regex = /\a\\//g;");
Daniel Jasper23376252014-09-09 14:37:39 +0000848 verifyFormat("var regex = /a\\//;\n"
849 "var x = 0;");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000850 verifyFormat("var regex = /'/g;", "var regex = /'/g ;");
851 verifyFormat("var regex = /'/g; //'", "var regex = /'/g ; //'");
852 verifyFormat("var regex = /\\/*/;\n"
853 "var x = 0;",
854 "var regex = /\\/*/;\n"
855 "var x=0;");
856 verifyFormat("var x = /a\\//;", "var x = /a\\// \n;");
Daniel Jasper6b8d26c2015-06-24 16:01:02 +0000857 verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16));
858 verifyFormat("var regex =\n"
859 " /\"/;",
860 getGoogleJSStyleWithColumns(15));
Daniel Jasperf7372152015-07-02 14:14:04 +0000861 verifyFormat("var regex = //\n"
862 " /a/;");
Daniel Jasperf1446202015-07-02 15:00:44 +0000863 verifyFormat("var regexs = [\n"
864 " /d/, //\n"
865 " /aa/, //\n"
866 "];");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000867}
868
869TEST_F(FormatTestJS, RegexLiteralModifiers) {
870 verifyFormat("var regex = /abc/g;");
871 verifyFormat("var regex = /abc/i;");
872 verifyFormat("var regex = /abc/m;");
873 verifyFormat("var regex = /abc/y;");
874}
875
876TEST_F(FormatTestJS, RegexLiteralLength) {
877 verifyFormat("var regex = /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
878 getGoogleJSStyleWithColumns(60));
879 verifyFormat("var regex =\n"
880 " /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
881 getGoogleJSStyleWithColumns(60));
Daniel Jasper0580ff02014-12-17 09:11:08 +0000882 verifyFormat("var regex = /\\xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
883 getGoogleJSStyleWithColumns(50));
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000884}
885
886TEST_F(FormatTestJS, RegexLiteralExamples) {
887 verifyFormat("var regex = search.match(/(?:\?|&)times=([^?&]+)/i);");
888}
889
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000890TEST_F(FormatTestJS, TypeAnnotations) {
891 verifyFormat("var x: string;");
Daniel Jasperb9a49902016-01-09 15:56:28 +0000892 verifyFormat("var x: {a: string; b: number;} = {};");
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000893 verifyFormat("function x(): string {\n return 'x';\n}");
Manuel Klimek79e06082015-05-21 12:23:34 +0000894 verifyFormat("function x(): {x: string} {\n return {x: 'x'};\n}");
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000895 verifyFormat("function x(y: string): string {\n return 'x';\n}");
896 verifyFormat("for (var y: string in x) {\n x();\n}");
Daniel Jasperb7fda112016-02-11 13:24:15 +0000897 verifyFormat("for (var y: string of x) {\n x();\n}");
Daniel Jasperb9a49902016-01-09 15:56:28 +0000898 verifyFormat("function x(y: {a?: number;} = {}): number {\n"
899 " return 12;\n"
900 "}");
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000901 verifyFormat("((a: string, b: number): string => a + b);");
902 verifyFormat("var x: (y: number) => string;");
903 verifyFormat("var x: P<string, (a: number) => string>;");
Manuel Klimek79e06082015-05-21 12:23:34 +0000904 verifyFormat("var x = {y: function(): z { return 1; }};");
905 verifyFormat("var x = {y: function(): {a: number} { return 1; }};");
Daniel Jasperf412e262016-01-08 10:51:24 +0000906 verifyFormat("function someFunc(args: string[]):\n"
907 " {longReturnValue: string[]} {}",
908 getGoogleJSStyleWithColumns(60));
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000909}
910
Daniel Jasper91b1d1a2016-03-21 17:57:31 +0000911TEST_F(FormatTestJS, UnionIntersectionTypes) {
912 verifyFormat("let x: A|B = A | B;");
913 verifyFormat("let x: A&B|C = A & B;");
914 verifyFormat("let x: Foo<A|B> = new Foo<A|B>();");
915 verifyFormat("function(x: A|B): C&D {}");
916 verifyFormat("function(x: A|B = A | B): C&D {}");
Martin Probst2ec23242016-06-09 22:49:04 +0000917 verifyFormat("function x(path: number|string) {}");
918 verifyFormat("function x(): string|number {}");
Martin Probst1b7f9802016-06-23 19:52:32 +0000919 verifyFormat("type Foo = Bar|Baz;");
920 verifyFormat("type Foo = Bar<X>|Baz;");
921 verifyFormat("type Foo = (Bar<X>|Baz);");
922 verifyFormat("let x: Bar|Baz;");
923 verifyFormat("let x: Bar<X>|Baz;");
924 verifyFormat("let x: (Foo|Bar)[];");
Daniel Jasper91b1d1a2016-03-21 17:57:31 +0000925}
926
Daniel Jasper83709082015-02-18 17:14:05 +0000927TEST_F(FormatTestJS, ClassDeclarations) {
928 verifyFormat("class C {\n x: string = 12;\n}");
929 verifyFormat("class C {\n x(): string => 12;\n}");
930 verifyFormat("class C {\n ['x' + 2]: string = 12;\n}");
931 verifyFormat("class C {\n private x: string = 12;\n}");
932 verifyFormat("class C {\n private static x: string = 12;\n}");
933 verifyFormat("class C {\n static x(): string { return 'asd'; }\n}");
934 verifyFormat("class C extends P implements I {}");
Daniel Jasper6a5d38d2015-04-13 14:56:54 +0000935 verifyFormat("class C extends p.P implements i.I {}");
Daniel Jasperb9a52812015-07-10 13:39:26 +0000936 verifyFormat("class Test {\n"
937 " aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n"
938 " aaaaaaaaaaaaaaaaaaaaaa {}\n"
939 "}");
Daniel Jasperd5ec65b2016-01-08 07:06:07 +0000940 verifyFormat("foo = class Name {\n"
941 " constructor() {}\n"
942 "};");
943 verifyFormat("foo = class {\n"
944 " constructor() {}\n"
945 "};");
Daniel Jasperb9a49902016-01-09 15:56:28 +0000946 verifyFormat("class C {\n"
947 " x: {y: Z;} = {};\n"
948 " private y: {y: Z;} = {};\n"
949 "}");
Daniel Jasper81dbb562015-06-03 08:43:18 +0000950
951 // ':' is not a type declaration here.
952 verifyFormat("class X {\n"
953 " subs = {\n"
954 " 'b': {\n"
955 " 'c': 1,\n"
956 " },\n"
957 " };\n"
958 "}");
Daniel Jasper64650082016-06-14 11:28:02 +0000959 verifyFormat("@Component({\n"
960 " moduleId: module.id,\n"
961 "})\n"
962 "class SessionListComponent implements OnDestroy, OnInit {\n"
963 "}");
Daniel Jasper83709082015-02-18 17:14:05 +0000964}
965
Daniel Jasper29647492015-05-05 08:12:50 +0000966TEST_F(FormatTestJS, InterfaceDeclarations) {
967 verifyFormat("interface I {\n"
968 " x: string;\n"
Daniel Jasper6f5a1932015-12-29 08:54:23 +0000969 " enum: string[];\n"
Daniel Jasper87379302016-02-03 05:33:44 +0000970 " enum?: string[];\n"
Daniel Jasper259188b2015-06-12 04:56:34 +0000971 "}\n"
972 "var y;");
Daniel Jasper5c235c02015-07-06 14:26:04 +0000973 // Ensure that state is reset after parsing the interface.
974 verifyFormat("interface a {}\n"
975 "export function b() {}\n"
976 "var x;");
Daniel Jasperb542f9f2015-12-22 15:48:35 +0000977
978 // Arrays of object type literals.
979 verifyFormat("interface I {\n"
980 " o: {}[];\n"
981 "}");
Daniel Jasper29647492015-05-05 08:12:50 +0000982}
983
Daniel Jasper90cf3802015-06-17 09:44:02 +0000984TEST_F(FormatTestJS, EnumDeclarations) {
985 verifyFormat("enum Foo {\n"
Daniel Jasper9f4ec152015-06-17 09:44:07 +0000986 " A = 1,\n"
987 " B\n"
988 "}");
989 verifyFormat("export /* somecomment*/ enum Foo {\n"
990 " A = 1,\n"
991 " B\n"
992 "}");
993 verifyFormat("enum Foo {\n"
Daniel Jasper90cf3802015-06-17 09:44:02 +0000994 " A = 1, // comment\n"
995 " B\n"
996 "}\n"
997 "var x = 1;");
998}
999
Daniel Jasper3c42dba2015-02-18 17:17:15 +00001000TEST_F(FormatTestJS, MetadataAnnotations) {
1001 verifyFormat("@A\nclass C {\n}");
1002 verifyFormat("@A({arg: 'value'})\nclass C {\n}");
1003 verifyFormat("@A\n@B\nclass C {\n}");
1004 verifyFormat("class C {\n @A x: string;\n}");
1005 verifyFormat("class C {\n"
1006 " @A\n"
1007 " private x(): string {\n"
1008 " return 'y';\n"
1009 " }\n"
1010 "}");
Martin Probst716a5332016-04-11 09:17:57 +00001011 verifyFormat("class C {\n"
1012 " private x(@A x: string) {}\n"
1013 "}");
Daniel Jasper6fa9ec72015-02-19 16:03:16 +00001014 verifyFormat("class X {}\n"
1015 "class Y {}");
Daniel Jasper3c42dba2015-02-18 17:17:15 +00001016}
1017
Martin Probst805c6162016-04-19 14:59:16 +00001018TEST_F(FormatTestJS, TypeAliases) {
1019 verifyFormat("type X = number;\n"
1020 "class C {}");
1021 verifyFormat("type X<Y> = Z<Y>;");
1022 verifyFormat("type X = {\n"
1023 " y: number\n"
1024 "};\n"
1025 "class C {}");
1026}
1027
Daniel Jasper354aa512015-02-19 16:07:32 +00001028TEST_F(FormatTestJS, Modules) {
1029 verifyFormat("import SomeThing from 'some/module.js';");
1030 verifyFormat("import {X, Y} from 'some/module.js';");
Daniel Jasperefc1a832016-01-07 08:53:35 +00001031 verifyFormat("import a, {X, Y} from 'some/module.js';");
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001032 verifyFormat("import {X, Y,} from 'some/module.js';");
Daniel Jasper354aa512015-02-19 16:07:32 +00001033 verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
Martin Probst48622092016-06-01 15:22:47 +00001034 // Ensure Automatic Semicolon Insertion does not break on "as\n".
1035 verifyFormat("import {X as myX} from 'm';", "import {X as\n"
1036 " myX} from 'm';");
Daniel Jasper354aa512015-02-19 16:07:32 +00001037 verifyFormat("import * as lib from 'some/module.js';");
Daniel Jasper60948b12015-03-15 13:55:54 +00001038 verifyFormat("var x = {import: 1};\nx.import = 2;");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001039
1040 verifyFormat("export function fn() {\n"
1041 " return 'fn';\n"
1042 "}");
Daniel Jasper20580fd2015-06-11 13:31:45 +00001043 verifyFormat("export function A() {}\n"
1044 "export default function B() {}\n"
1045 "export function C() {}");
Martin Probst053f1aa2016-04-19 14:55:37 +00001046 verifyFormat("export default () => {\n"
1047 " let x = 1;\n"
1048 " return x;\n"
1049 "}");
Daniel Jasper354aa512015-02-19 16:07:32 +00001050 verifyFormat("export const x = 12;");
1051 verifyFormat("export default class X {}");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001052 verifyFormat("export {X, Y} from 'some/module.js';");
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001053 verifyFormat("export {X, Y,} from 'some/module.js';");
1054 verifyFormat("export {SomeVeryLongExport as X, "
1055 "SomeOtherVeryLongExport as Y} from 'some/module.js';");
1056 // export without 'from' is wrapped.
1057 verifyFormat("export let someRatherLongVariableName =\n"
1058 " someSurprisinglyLongVariable + someOtherRatherLongVar;");
1059 // ... but not if from is just an identifier.
Daniel Jasperfca735c2015-02-19 16:14:18 +00001060 verifyFormat("export {\n"
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001061 " from as from,\n"
Martin Probstdce8e412016-06-22 14:35:14 +00001062 " someSurprisinglyLongVariable as\n"
1063 " from\n"
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001064 "};",
1065 getGoogleJSStyleWithColumns(20));
Daniel Jasperfca735c2015-02-19 16:14:18 +00001066 verifyFormat("export class C {\n"
1067 " x: number;\n"
1068 " y: string;\n"
1069 "}");
1070 verifyFormat("export class X { y: number; }");
Daniel Jasper8620d4c2016-01-12 06:24:38 +00001071 verifyFormat("export abstract class X { y: number; }");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001072 verifyFormat("export default class X { y: number }");
1073 verifyFormat("export default function() {\n return 1;\n}");
1074 verifyFormat("export var x = 12;");
Daniel Jasper910807d2015-06-12 04:52:02 +00001075 verifyFormat("class C {}\n"
1076 "export function f() {}\n"
1077 "var v;");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001078 verifyFormat("export var x: number = 12;");
1079 verifyFormat("export const y = {\n"
1080 " a: 1,\n"
1081 " b: 2\n"
1082 "};");
Daniel Jasper216c9cd2015-06-12 05:08:18 +00001083 verifyFormat("export enum Foo {\n"
1084 " BAR,\n"
1085 " // adsdasd\n"
1086 " BAZ\n"
1087 "}");
Daniel Jasperb14f6672016-01-04 15:51:56 +00001088 verifyFormat("export default [\n"
1089 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1090 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
1091 "];");
1092 verifyFormat("export default [];");
Daniel Jasper5e271462016-01-04 16:10:36 +00001093 verifyFormat("export default () => {};");
Daniel Jasperf55e4182016-01-11 22:57:40 +00001094 verifyFormat("export interface Foo { foo: number; }\n"
1095 "export class Bar {\n"
1096 " blah(): string { return this.blah; };\n"
1097 "}");
Daniel Jasper354aa512015-02-19 16:07:32 +00001098}
1099
Martin Probst0cd74ee2016-06-13 16:39:50 +00001100TEST_F(FormatTestJS, ImportWrapping) {
1101 verifyFormat("import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,"
1102 " VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying"
1103 "} from 'some/module.js';");
1104 FormatStyle Style = getGoogleJSStyleWithColumns(80);
1105 Style.JavaScriptWrapImports = true;
1106 verifyFormat("import {\n"
1107 " VeryLongImportsAreAnnoying,\n"
1108 " VeryLongImportsAreAnnoying,\n"
1109 " VeryLongImportsAreAnnoying,\n"
1110 "} from 'some/module.js';",
1111 Style);
1112 verifyFormat("import {\n"
1113 " A,\n"
1114 " A,\n"
1115 "} from 'some/module.js';",
1116 Style);
1117 verifyFormat("export {\n"
1118 " A,\n"
1119 " A,\n"
1120 "} from 'some/module.js';",
1121 Style);
1122}
1123
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001124TEST_F(FormatTestJS, TemplateStrings) {
1125 // Keeps any whitespace/indentation within the template string.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001126 verifyFormat("var x = `hello\n"
Martin Probst6181da42016-08-25 10:13:21 +00001127 " ${name}\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001128 " !`;",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001129 "var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001130 " ${ name }\n"
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001131 " !`;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001132
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001133 verifyFormat("var x =\n"
1134 " `hello ${world}` >= some();",
1135 getGoogleJSStyleWithColumns(34)); // Barely doesn't fit.
1136 verifyFormat("var x = `hello ${world}` >= some();",
Daniel Jasper553a5b02015-07-02 13:08:28 +00001137 getGoogleJSStyleWithColumns(35)); // Barely fits.
Martin Probste71b4cb2016-05-17 06:29:29 +00001138 verifyFormat("var x = `hellö ${wörld}` >= söme();",
1139 getGoogleJSStyleWithColumns(35)); // Fits due to UTF-8.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001140 verifyFormat("var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001141 " ${world}` >=\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +00001142 " some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001143 "var x =\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001144 " `hello\n"
1145 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001146 getGoogleJSStyleWithColumns(21)); // Barely doesn't fit.
1147 verifyFormat("var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001148 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001149 "var x =\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001150 " `hello\n"
1151 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001152 getGoogleJSStyleWithColumns(22)); // Barely fits.
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001153
Daniel Jasper553a5b02015-07-02 13:08:28 +00001154 verifyFormat("var x =\n"
1155 " `h`;",
1156 getGoogleJSStyleWithColumns(11));
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001157 verifyFormat("var x =\n `multi\n line`;", "var x = `multi\n line`;",
1158 getGoogleJSStyleWithColumns(13));
Daniel Jasper553a5b02015-07-02 13:08:28 +00001159 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1160 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);");
Martin Probste71b4cb2016-05-17 06:29:29 +00001161 // Repro for an obscure width-miscounting issue with template strings.
1162 verifyFormat(
1163 "someLongVariable =\n"
1164 " "
1165 "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;",
1166 "someLongVariable = "
1167 "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001168
Daniel Jasperf69b9222015-05-02 08:05:38 +00001169 // Make sure template strings get a proper ColumnWidth assigned, even if they
1170 // are first token in line.
1171 verifyFormat(
1172 "var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +00001173 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;");
Daniel Jasperf69b9222015-05-02 08:05:38 +00001174
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001175 // Two template strings.
1176 verifyFormat("var x = `hello` == `hello`;");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001177
1178 // Comments in template strings.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001179 verifyFormat("var x = `//a`;\n"
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001180 "var y;",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001181 "var x =\n `//a`;\n"
1182 "var y ;");
1183 verifyFormat("var x = `/*a`;\n"
1184 "var y;",
1185 "var x =\n `/*a`;\n"
1186 "var y;");
Daniel Jasper2ebb0c52015-06-14 07:16:57 +00001187 // Unterminated string literals in a template string.
1188 verifyFormat("var x = `'`; // comment with matching quote '\n"
1189 "var y;");
1190 verifyFormat("var x = `\"`; // comment with matching quote \"\n"
1191 "var y;");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001192 verifyFormat("it(`'aaaaaaaaaaaaaaa `, aaaaaaaaa);",
1193 "it(`'aaaaaaaaaaaaaaa `, aaaaaaaaa) ;",
1194 getGoogleJSStyleWithColumns(40));
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001195 // Backticks in a comment - not a template string.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001196 verifyFormat("var x = 1 // `/*a`;\n"
1197 " ;",
1198 "var x =\n 1 // `/*a`;\n"
1199 " ;");
1200 verifyFormat("/* ` */ var x = 1; /* ` */", "/* ` */ var x\n= 1; /* ` */");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001201 // Comment spans multiple template strings.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001202 verifyFormat("var x = `/*a`;\n"
1203 "var y = ` */ `;",
1204 "var x =\n `/*a`;\n"
1205 "var y =\n ` */ `;");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001206 // Escaped backtick.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001207 verifyFormat("var x = ` \\` a`;\n"
1208 "var y;",
1209 "var x = ` \\` a`;\n"
1210 "var y;");
Martin Probst6181da42016-08-25 10:13:21 +00001211 // Escaped dollar.
1212 verifyFormat("var x = ` \\${foo}`;\n");
1213}
1214
1215TEST_F(FormatTestJS, NestedTemplateStrings) {
1216 verifyFormat(
1217 "var x = `<ul>${xs.map(x => `<li>${x}</li>`).join('\\n')}</ul>`;");
1218 verifyFormat("var x = `he${({text: 'll'}.text)}o`;");
1219}
1220
1221TEST_F(FormatTestJS, TaggedTemplateStrings) {
1222 verifyFormat("var x = html`<ul>`;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001223}
1224
Martin Probst805c6162016-04-19 14:59:16 +00001225TEST_F(FormatTestJS, CastSyntax) {
1226 verifyFormat("var x = <type>foo;");
1227 verifyFormat("var x = foo as type;");
Martin Probstdce8e412016-06-22 14:35:14 +00001228 verifyFormat("let x = (a + b) as\n"
1229 " LongTypeIsLong;",
1230 getGoogleJSStyleWithColumns(20));
Daniel Jasper887a3992016-06-14 13:54:38 +00001231 verifyFormat("foo = <Bar[]>[\n"
1232 " 1, //\n"
1233 " 2\n"
1234 "];");
Martin Probste1e12a72016-08-19 14:35:01 +00001235 verifyFormat("var x = [{x: 1} as type];");
Martin Probsted87d782016-08-22 14:23:30 +00001236 verifyFormat("x = x as [a, b];");
1237 verifyFormat("x = x as {a: string};");
1238 verifyFormat("x = x as (string);");
Martin Probst34ecf422016-09-06 18:55:34 +00001239 verifyFormat("x = x! as (string);");
Martin Probst805c6162016-04-19 14:59:16 +00001240}
Daniel Jasperbc46b932015-03-15 13:59:51 +00001241
1242TEST_F(FormatTestJS, TypeArguments) {
1243 verifyFormat("class X<Y> {}");
1244 verifyFormat("new X<Y>();");
1245 verifyFormat("foo<Y>(a);");
1246 verifyFormat("var x: X<Y>[];");
1247 verifyFormat("class C extends D<E> implements F<G>, H<I> {}");
Daniel Jasper20580fd2015-06-11 13:31:45 +00001248 verifyFormat("function f(a: List<any> = null) {}");
1249 verifyFormat("function f(): List<any> {}");
Daniel Jasper5a3de1d2015-07-03 10:37:23 +00001250 verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n"
1251 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}");
Daniel Jasper6501f7e2015-10-27 12:38:37 +00001252 verifyFormat("function aaaaaaaaaa(\n"
1253 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa,\n"
1254 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa):\n"
Daniel Jasperb2328b12015-07-06 14:07:51 +00001255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {}");
Daniel Jasperbc46b932015-03-15 13:59:51 +00001256}
1257
Daniel Jasper779c66f2015-12-30 08:00:58 +00001258TEST_F(FormatTestJS, UserDefinedTypeGuards) {
1259 verifyFormat(
1260 "function foo(check: Object):\n"
1261 " check is {foo: string, bar: string, baz: string, foobar: string} {\n"
1262 " return 'bar' in check;\n"
1263 "}\n");
1264}
1265
Daniel Jaspera74f5072015-04-13 15:01:40 +00001266TEST_F(FormatTestJS, OptionalTypes) {
Daniel Jasper20580fd2015-06-11 13:31:45 +00001267 verifyFormat("function x(a?: b, c?, d?) {}");
Daniel Jaspera74f5072015-04-13 15:01:40 +00001268 verifyFormat("class X {\n"
1269 " y?: z;\n"
1270 " z?;\n"
1271 "}");
Daniel Jasper9326f912015-05-05 08:40:32 +00001272 verifyFormat("interface X {\n"
1273 " y?(): z;\n"
1274 "}");
Daniel Jasper3e0dcc22015-05-27 05:37:40 +00001275 verifyFormat("constructor({aa}: {\n"
1276 " aa?: string,\n"
1277 " aaaaaaaa?: string,\n"
1278 " aaaaaaaaaaaaaaa?: boolean,\n"
1279 " aaaaaa?: List<string>\n"
Daniel Jasper20580fd2015-06-11 13:31:45 +00001280 "}) {}");
Daniel Jaspera74f5072015-04-13 15:01:40 +00001281}
1282
Daniel Jasperd9309772015-04-13 15:03:30 +00001283TEST_F(FormatTestJS, IndexSignature) {
1284 verifyFormat("var x: {[k: string]: v};");
1285}
1286
Daniel Jasper6501f7e2015-10-27 12:38:37 +00001287TEST_F(FormatTestJS, WrapAfterParen) {
1288 verifyFormat("xxxxxxxxxxx(\n"
1289 " aaa, aaa);",
1290 getGoogleJSStyleWithColumns(20));
1291 verifyFormat("xxxxxxxxxxx(\n"
1292 " aaa, aaa, aaa,\n"
1293 " aaa, aaa, aaa);",
1294 getGoogleJSStyleWithColumns(20));
1295 verifyFormat("xxxxxxxxxxx(\n"
1296 " aaaaaaaaaaaaaaaaaaaaaaaa,\n"
1297 " function(x) {\n"
1298 " y(); //\n"
1299 " });",
1300 getGoogleJSStyleWithColumns(40));
1301 verifyFormat("while (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
1302 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
1303}
1304
Daniel Jasperd196abb2016-01-08 08:14:58 +00001305TEST_F(FormatTestJS, JSDocAnnotations) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001306 verifyFormat("/**\n"
1307 " * @export {this.is.a.long.path.to.a.Type}\n"
1308 " */",
1309 "/**\n"
1310 " * @export {this.is.a.long.path.to.a.Type}\n"
1311 " */",
1312 getGoogleJSStyleWithColumns(20));
Daniel Jasperd196abb2016-01-08 08:14:58 +00001313}
1314
Daniel Jasperabd1f572016-03-02 22:44:03 +00001315TEST_F(FormatTestJS, RequoteStringsSingle) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001316 verifyFormat("var x = 'foo';", "var x = \"foo\";");
1317 verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo'o'\";");
1318 verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo\\'o'\";");
1319 verifyFormat(
1320 "var x =\n"
1321 " 'foo\\'';",
1322 // Code below is 15 chars wide, doesn't fit into the line with the
1323 // \ escape added.
1324 "var x = \"foo'\";", getGoogleJSStyleWithColumns(15));
Daniel Jasperabd1f572016-03-02 22:44:03 +00001325 // Removes no-longer needed \ escape from ".
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001326 verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";");
Daniel Jasperabd1f572016-03-02 22:44:03 +00001327 // Code below fits into 15 chars *after* removing the \ escape.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001328 verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";",
1329 getGoogleJSStyleWithColumns(15));
Martin Probsta1669792016-05-12 11:20:32 +00001330 verifyFormat("// clang-format off\n"
1331 "let x = \"double\";\n"
1332 "// clang-format on\n"
1333 "let x = 'single';\n",
1334 "// clang-format off\n"
1335 "let x = \"double\";\n"
1336 "// clang-format on\n"
1337 "let x = \"single\";\n");
Daniel Jasperabd1f572016-03-02 22:44:03 +00001338}
1339
Martin Probsta9855af2016-09-02 14:29:48 +00001340TEST_F(FormatTestJS, RequoteAndIndent) {
1341 verifyFormat("let x = someVeryLongFunctionThatGoesOnAndOn(\n"
1342 " 'double quoted string that needs wrapping');",
1343 "let x = someVeryLongFunctionThatGoesOnAndOn("
1344 "\"double quoted string that needs wrapping\");");
Daniel Jasper496c1992016-09-07 22:48:53 +00001345
1346 verifyFormat("let x =\n"
1347 " 'foo\\'oo';\n"
1348 "let x =\n"
1349 " 'foo\\'oo';",
1350 "let x=\"foo'oo\";\n"
1351 "let x=\"foo'oo\";",
1352 getGoogleJSStyleWithColumns(15));
Martin Probsta9855af2016-09-02 14:29:48 +00001353}
1354
Daniel Jasperabd1f572016-03-02 22:44:03 +00001355TEST_F(FormatTestJS, RequoteStringsDouble) {
1356 FormatStyle DoubleQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
1357 DoubleQuotes.JavaScriptQuotes = FormatStyle::JSQS_Double;
1358 verifyFormat("var x = \"foo\";", DoubleQuotes);
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001359 verifyFormat("var x = \"foo\";", "var x = 'foo';", DoubleQuotes);
1360 verifyFormat("var x = \"fo'o\";", "var x = 'fo\\'o';", DoubleQuotes);
Daniel Jasperabd1f572016-03-02 22:44:03 +00001361}
1362
1363TEST_F(FormatTestJS, RequoteStringsLeave) {
1364 FormatStyle LeaveQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
1365 LeaveQuotes.JavaScriptQuotes = FormatStyle::JSQS_Leave;
1366 verifyFormat("var x = \"foo\";", LeaveQuotes);
1367 verifyFormat("var x = 'foo';", LeaveQuotes);
1368}
1369
Martin Probst7ea9b6d2016-05-29 14:41:36 +00001370TEST_F(FormatTestJS, SupportShebangLines) {
1371 verifyFormat("#!/usr/bin/env node\n"
1372 "var x = hello();",
1373 "#!/usr/bin/env node\n"
1374 "var x = hello();");
1375}
1376
Martin Probst0eb40cf2016-06-13 00:49:54 +00001377TEST_F(FormatTestJS, NonNullAssertionOperator) {
1378 verifyFormat("let x = foo!.bar();\n");
1379 verifyFormat("let x = foo ? bar! : baz;\n");
1380 verifyFormat("let x = !foo;\n");
1381 verifyFormat("let x = foo[0]!;\n");
1382 verifyFormat("let x = (foo)!;\n");
1383 verifyFormat("let x = {foo: 1}!;\n");
1384}
1385
Martin Probst31d6da72016-06-23 21:51:49 +00001386TEST_F(FormatTestJS, Conditional) {
1387 verifyFormat("y = x ? 1 : 2;");
Daniel Jasperd9d8da22016-07-12 15:45:53 +00001388 verifyFormat("x ? 1 : 2;");
Martin Probst31d6da72016-06-23 21:51:49 +00001389 verifyFormat("class Foo {\n"
1390 " field = true ? 1 : 2;\n"
1391 " method(a = true ? 1 : 2) {}\n"
1392 "}");
1393}
1394
Alexander Kornienkoab9db512015-06-22 23:07:51 +00001395} // end namespace tooling
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00001396} // end namespace clang