xref: /llvm-project/clang/unittests/Format/FormatTestJS.cpp (revision bbffeac569e89a61201ce159790f68b8493042b6)
1 //===- 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 
10 #include "FormatTestUtils.h"
11 #include "clang/Format/Format.h"
12 #include "llvm/Support/Debug.h"
13 #include "gtest/gtest.h"
14 
15 #define DEBUG_TYPE "format-test"
16 
17 namespace clang {
18 namespace format {
19 
20 class FormatTestJS : public ::testing::Test {
21 protected:
22   static std::string format(llvm::StringRef Code, unsigned Offset,
23                             unsigned Length, const FormatStyle &Style) {
24     DEBUG(llvm::errs() << "---\n");
25     DEBUG(llvm::errs() << Code << "\n\n");
26     std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
27     bool IncompleteFormat = false;
28     tooling::Replacements Replaces =
29         reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
30     EXPECT_FALSE(IncompleteFormat);
31     std::string Result = applyAllReplacements(Code, Replaces);
32     EXPECT_NE("", Result);
33     DEBUG(llvm::errs() << "\n" << Result << "\n\n");
34     return Result;
35   }
36 
37   static std::string format(
38       llvm::StringRef Code,
39       const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
40     return format(Code, 0, Code.size(), Style);
41   }
42 
43   static FormatStyle getGoogleJSStyleWithColumns(unsigned ColumnLimit) {
44     FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
45     Style.ColumnLimit = ColumnLimit;
46     return Style;
47   }
48 
49   static void verifyFormat(
50       llvm::StringRef Code,
51       const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
52     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;
62   }
63 };
64 
65 TEST_F(FormatTestJS, UnderstandsJavaScriptOperators) {
66   verifyFormat("a == = b;");
67   verifyFormat("a != = b;");
68 
69   verifyFormat("a === b;");
70   verifyFormat("aaaaaaa ===\n    b;", getGoogleJSStyleWithColumns(10));
71   verifyFormat("a !== b;");
72   verifyFormat("aaaaaaa !==\n    b;", getGoogleJSStyleWithColumns(10));
73   verifyFormat("if (a + b + c +\n"
74                "        d !==\n"
75                "    e + f + g)\n"
76                "  q();",
77                getGoogleJSStyleWithColumns(20));
78 
79   verifyFormat("a >> >= b;");
80 
81   verifyFormat("a >>> b;");
82   verifyFormat("aaaaaaa >>>\n    b;", getGoogleJSStyleWithColumns(10));
83   verifyFormat("a >>>= b;");
84   verifyFormat("aaaaaaa >>>=\n    b;", getGoogleJSStyleWithColumns(10));
85   verifyFormat("if (a + b + c +\n"
86                "        d >>>\n"
87                "    e + f + g)\n"
88                "  q();",
89                getGoogleJSStyleWithColumns(20));
90   verifyFormat("var x = aaaaaaaaaa ?\n"
91                "    bbbbbb :\n"
92                "    ccc;",
93                getGoogleJSStyleWithColumns(20));
94 
95   verifyFormat("var b = a.map((x) => x + 1);");
96   verifyFormat("return ('aaa') in bbbb;");
97   verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
98                "    aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
99   FormatStyle Style = getGoogleJSStyleWithColumns(80);
100   Style.AlignOperands = true;
101   verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
102                "        aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
103                Style);
104   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
105   verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa()\n"
106                "            in aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
107                Style);
108 
109   // ES6 spread operator.
110   verifyFormat("someFunction(...a);");
111   verifyFormat("var x = [1, ...a, 2];");
112 }
113 
114 TEST_F(FormatTestJS, UnderstandsAmpAmp) {
115   verifyFormat("e && e.SomeFunction();");
116 }
117 
118 TEST_F(FormatTestJS, LiteralOperatorsCanBeKeywords) {
119   verifyFormat("not.and.or.not_eq = 1;");
120 }
121 
122 TEST_F(FormatTestJS, ReservedWords) {
123   // JavaScript reserved words (aka keywords) are only illegal when used as
124   // Identifiers, but are legal as IdentifierNames.
125   verifyFormat("x.class.struct = 1;");
126   verifyFormat("x.case = 1;");
127   verifyFormat("x.interface = 1;");
128   verifyFormat("x.of() = 1;");
129   verifyFormat("x.in() = 1;");
130   verifyFormat("x.let() = 1;");
131   verifyFormat("x.var() = 1;");
132   verifyFormat("x = {\n"
133                "  a: 12,\n"
134                "  interface: 1,\n"
135                "  switch: 1,\n"
136                "};");
137   verifyFormat("var struct = 2;");
138   verifyFormat("var union = 2;");
139 }
140 
141 TEST_F(FormatTestJS, CppKeywords) {
142   // Make sure we don't mess stuff up because of C++ keywords.
143   verifyFormat("return operator && (aa);");
144 }
145 
146 TEST_F(FormatTestJS, ES6DestructuringAssignment) {
147   verifyFormat("var [a, b, c] = [1, 2, 3];");
148   verifyFormat("let [a, b, c] = [1, 2, 3];");
149   verifyFormat("var {a, b} = {a: 1, b: 2};");
150   verifyFormat("let {a, b} = {a: 1, b: 2};");
151 }
152 
153 TEST_F(FormatTestJS, ContainerLiterals) {
154   verifyFormat("var x = {y: function(a) { return a; }};");
155   verifyFormat("return {\n"
156                "  link: function() {\n"
157                "    f();  //\n"
158                "  }\n"
159                "};");
160   verifyFormat("return {\n"
161                "  a: a,\n"
162                "  link: function() {\n"
163                "    f();  //\n"
164                "  }\n"
165                "};");
166   verifyFormat("return {\n"
167                "  a: a,\n"
168                "  link: function() {\n"
169                "    f();  //\n"
170                "  },\n"
171                "  link: function() {\n"
172                "    f();  //\n"
173                "  }\n"
174                "};");
175   verifyFormat("var stuff = {\n"
176                "  // comment for update\n"
177                "  update: false,\n"
178                "  // comment for modules\n"
179                "  modules: false,\n"
180                "  // comment for tasks\n"
181                "  tasks: false\n"
182                "};");
183   verifyFormat("return {\n"
184                "  'finish':\n"
185                "      //\n"
186                "      a\n"
187                "};");
188   verifyFormat("var obj = {\n"
189                "  fooooooooo: function(x) {\n"
190                "    return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
191                "  }\n"
192                "};");
193   // Simple object literal, as opposed to enum style below.
194   verifyFormat("var obj = {a: 123};");
195   // Enum style top level assignment.
196   verifyFormat("X = {\n  a: 123\n};");
197   verifyFormat("X.Y = {\n  a: 123\n};");
198   // But only on the top level, otherwise its a plain object literal assignment.
199   verifyFormat("function x() {\n"
200                "  y = {z: 1};\n"
201                "}");
202   verifyFormat("x = foo && {a: 123};");
203 
204   // Arrow functions in object literals.
205   verifyFormat("var x = {y: (a) => { return a; }};");
206   verifyFormat("var x = {y: (a) => a};");
207 
208   // Computed keys.
209   verifyFormat("var x = {[a]: 1, b: 2, [c]: 3};");
210   verifyFormat("var x = {\n"
211                "  [a]: 1,\n"
212                "  b: 2,\n"
213                "  [c]: 3,\n"
214                "};");
215 
216   // Object literals can leave out labels.
217   verifyFormat("f({a}, () => {\n"
218                "  g();  //\n"
219                "});");
220 
221   // Keys can be quoted.
222   verifyFormat("var x = {\n"
223                "  a: a,\n"
224                "  b: b,\n"
225                "  'c': c,\n"
226                "};");
227 }
228 
229 TEST_F(FormatTestJS, MethodsInObjectLiterals) {
230   verifyFormat("var o = {\n"
231                "  value: 'test',\n"
232                "  get value() {  // getter\n"
233                "    return this.value;\n"
234                "  }\n"
235                "};");
236   verifyFormat("var o = {\n"
237                "  value: 'test',\n"
238                "  set value(val) {  // setter\n"
239                "    this.value = val;\n"
240                "  }\n"
241                "};");
242   verifyFormat("var o = {\n"
243                "  value: 'test',\n"
244                "  someMethod(val) {  // method\n"
245                "    doSomething(this.value + val);\n"
246                "  }\n"
247                "};");
248   verifyFormat("var o = {\n"
249                "  someMethod(val) {  // method\n"
250                "    doSomething(this.value + val);\n"
251                "  },\n"
252                "  someOtherMethod(val) {  // method\n"
253                "    doSomething(this.value + val);\n"
254                "  }\n"
255                "};");
256 }
257 
258 TEST_F(FormatTestJS, SpacesInContainerLiterals) {
259   verifyFormat("var arr = [1, 2, 3];");
260   verifyFormat("f({a: 1, b: 2, c: 3});");
261 
262   verifyFormat("var object_literal_with_long_name = {\n"
263                "  a: 'aaaaaaaaaaaaaaaaaa',\n"
264                "  b: 'bbbbbbbbbbbbbbbbbb'\n"
265                "};");
266 
267   verifyFormat("f({a: 1, b: 2, c: 3});",
268                getChromiumStyle(FormatStyle::LK_JavaScript));
269   verifyFormat("f({'a': [{}]});");
270 }
271 
272 TEST_F(FormatTestJS, SingleQuotedStrings) {
273   verifyFormat("this.function('', true);");
274 }
275 
276 TEST_F(FormatTestJS, GoogScopes) {
277   verifyFormat("goog.scope(function() {\n"
278                "var x = a.b;\n"
279                "var y = c.d;\n"
280                "});  // goog.scope");
281   verifyFormat("goog.scope(function() {\n"
282                "// test\n"
283                "var x = 0;\n"
284                "// test\n"
285                "});");
286 }
287 
288 TEST_F(FormatTestJS, GoogModules) {
289   verifyFormat("goog.module('this.is.really.absurdly.long');",
290                getGoogleJSStyleWithColumns(40));
291   verifyFormat("goog.require('this.is.really.absurdly.long');",
292                getGoogleJSStyleWithColumns(40));
293   verifyFormat("goog.provide('this.is.really.absurdly.long');",
294                getGoogleJSStyleWithColumns(40));
295   verifyFormat("var long = goog.require('this.is.really.absurdly.long');",
296                getGoogleJSStyleWithColumns(40));
297   verifyFormat("goog.setTestOnly('this.is.really.absurdly.long');",
298                getGoogleJSStyleWithColumns(40));
299   verifyFormat("goog.forwardDeclare('this.is.really.absurdly.long');",
300                getGoogleJSStyleWithColumns(40));
301 
302   // These should be wrapped normally.
303   verifyFormat(
304       "var MyLongClassName =\n"
305       "    goog.module.get('my.long.module.name.followedBy.MyLongClassName');");
306 }
307 
308 TEST_F(FormatTestJS, FormatsFreestandingFunctions) {
309   verifyFormat("function outer1(a, b) {\n"
310                "  function inner1(a, b) { return a; }\n"
311                "  inner1(a, b);\n"
312                "}\n"
313                "function outer2(a, b) {\n"
314                "  function inner2(a, b) { return a; }\n"
315                "  inner2(a, b);\n"
316                "}");
317   verifyFormat("function f() {}");
318 }
319 
320 TEST_F(FormatTestJS, ArrayLiterals) {
321   verifyFormat("var aaaaa: List<SomeThing> =\n"
322                "    [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];");
323   verifyFormat("return [\n"
324                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
325                "  ccccccccccccccccccccccccccc\n"
326                "];");
327   verifyFormat("return [\n"
328                "  aaaa().bbbbbbbb('A'),\n"
329                "  aaaa().bbbbbbbb('B'),\n"
330                "  aaaa().bbbbbbbb('C'),\n"
331                "];");
332   verifyFormat("var someVariable = SomeFunction([\n"
333                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
334                "  ccccccccccccccccccccccccccc\n"
335                "]);");
336   verifyFormat("var someVariable = SomeFunction([\n"
337                "  [aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbb],\n"
338                "]);",
339                getGoogleJSStyleWithColumns(51));
340   verifyFormat("var someVariable = SomeFunction(aaaa, [\n"
341                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
342                "  ccccccccccccccccccccccccccc\n"
343                "]);");
344   verifyFormat("var someVariable = SomeFunction(\n"
345                "    aaaa,\n"
346                "    [\n"
347                "      aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
348                "      cccccccccccccccccccccccccc\n"
349                "    ],\n"
350                "    aaaa);");
351   verifyFormat("var aaaa = aaaaa ||  // wrap\n"
352                "    [];");
353 
354   verifyFormat("someFunction([], {a: a});");
355 }
356 
357 TEST_F(FormatTestJS, ColumnLayoutForArrayLiterals) {
358   verifyFormat("var array = [\n"
359                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
360                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
361                "];");
362   verifyFormat("var array = someFunction([\n"
363                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
364                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
365                "]);");
366 }
367 
368 TEST_F(FormatTestJS, FunctionLiterals) {
369   verifyFormat("doFoo(function() {});");
370   verifyFormat("doFoo(function() { return 1; });");
371   verifyFormat("var func = function() {\n"
372                "  return 1;\n"
373                "};");
374   verifyFormat("var func =  //\n"
375                "    function() {\n"
376                "  return 1;\n"
377                "};");
378   verifyFormat("return {\n"
379                "  body: {\n"
380                "    setAttribute: function(key, val) { this[key] = val; },\n"
381                "    getAttribute: function(key) { return this[key]; },\n"
382                "    style: {direction: ''}\n"
383                "  }\n"
384                "};");
385   verifyFormat("abc = xyz ? function() {\n"
386                "  return 1;\n"
387                "} : function() {\n"
388                "  return -1;\n"
389                "};");
390 
391   verifyFormat("var closure = goog.bind(\n"
392                "    function() {  // comment\n"
393                "      foo();\n"
394                "      bar();\n"
395                "    },\n"
396                "    this, arg1IsReallyLongAndNeeedsLineBreaks,\n"
397                "    arg3IsReallyLongAndNeeedsLineBreaks);");
398   verifyFormat("var closure = goog.bind(function() {  // comment\n"
399                "  foo();\n"
400                "  bar();\n"
401                "}, this);");
402   verifyFormat("return {\n"
403                "  a: 'E',\n"
404                "  b: function() {\n"
405                "    return function() {\n"
406                "      f();  //\n"
407                "    };\n"
408                "  }\n"
409                "};");
410   verifyFormat("{\n"
411                "  var someVariable = function(x) {\n"
412                "    return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
413                "  };\n"
414                "}");
415   verifyFormat("someLooooooooongFunction(\n"
416                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
417                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
418                "    function(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
419                "      // code\n"
420                "    });");
421 
422   verifyFormat("f({a: function() { return 1; }});",
423                getGoogleJSStyleWithColumns(33));
424   verifyFormat("f({\n"
425                "  a: function() { return 1; }\n"
426                "});",
427                getGoogleJSStyleWithColumns(32));
428 
429   verifyFormat("return {\n"
430                "  a: function SomeFunction() {\n"
431                "    // ...\n"
432                "    return 1;\n"
433                "  }\n"
434                "};");
435   verifyFormat("this.someObject.doSomething(aaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
436                "    .then(goog.bind(function(aaaaaaaaaaa) {\n"
437                "      someFunction();\n"
438                "      someFunction();\n"
439                "    }, this), aaaaaaaaaaaaaaaaa);");
440 
441   verifyFormat("someFunction(goog.bind(function() {\n"
442                "  doSomething();\n"
443                "  doSomething();\n"
444                "}, this), goog.bind(function() {\n"
445                "  doSomething();\n"
446                "  doSomething();\n"
447                "}, this));");
448 
449   // FIXME: This is bad, we should be wrapping before "function() {".
450   verifyFormat("someFunction(function() {\n"
451                "  doSomething();  // break\n"
452                "})\n"
453                "    .doSomethingElse(\n"
454                "        // break\n"
455                "        );");
456 }
457 
458 TEST_F(FormatTestJS, InliningFunctionLiterals) {
459   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
460   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
461   verifyFormat("var func = function() {\n"
462                "  return 1;\n"
463                "};",
464                Style);
465   verifyFormat("var func = doSomething(function() { return 1; });", Style);
466   verifyFormat("var outer = function() {\n"
467                "  var inner = function() { return 1; }\n"
468                "};",
469                Style);
470   verifyFormat("function outer1(a, b) {\n"
471                "  function inner1(a, b) { return a; }\n"
472                "}",
473                Style);
474 
475   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
476   verifyFormat("var func = function() { return 1; };", Style);
477   verifyFormat("var func = doSomething(function() { return 1; });", Style);
478   verifyFormat(
479       "var outer = function() { var inner = function() { return 1; } };",
480       Style);
481   verifyFormat("function outer1(a, b) {\n"
482                "  function inner1(a, b) { return a; }\n"
483                "}",
484                Style);
485 
486   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
487   verifyFormat("var func = function() {\n"
488                "  return 1;\n"
489                "};",
490                Style);
491   verifyFormat("var func = doSomething(function() {\n"
492                "  return 1;\n"
493                "});",
494                Style);
495   verifyFormat("var outer = function() {\n"
496                "  var inner = function() {\n"
497                "    return 1;\n"
498                "  }\n"
499                "};",
500                Style);
501   verifyFormat("function outer1(a, b) {\n"
502                "  function inner1(a, b) {\n"
503                "    return a;\n"
504                "  }\n"
505                "}",
506                Style);
507 
508   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
509   verifyFormat("var func = function() {\n"
510                "  return 1;\n"
511                "};",
512                Style);
513 }
514 
515 TEST_F(FormatTestJS, MultipleFunctionLiterals) {
516   verifyFormat("promise.then(\n"
517                "    function success() {\n"
518                "      doFoo();\n"
519                "      doBar();\n"
520                "    },\n"
521                "    function error() {\n"
522                "      doFoo();\n"
523                "      doBaz();\n"
524                "    },\n"
525                "    []);\n");
526   verifyFormat("promise.then(\n"
527                "    function success() {\n"
528                "      doFoo();\n"
529                "      doBar();\n"
530                "    },\n"
531                "    [],\n"
532                "    function error() {\n"
533                "      doFoo();\n"
534                "      doBaz();\n"
535                "    });\n");
536   verifyFormat("promise.then(\n"
537                "    [],\n"
538                "    function success() {\n"
539                "      doFoo();\n"
540                "      doBar();\n"
541                "    },\n"
542                "    function error() {\n"
543                "      doFoo();\n"
544                "      doBaz();\n"
545                "    });\n");
546 
547   verifyFormat("getSomeLongPromise()\n"
548                "    .then(function(value) { body(); })\n"
549                "    .thenCatch(function(error) {\n"
550                "      body();\n"
551                "      body();\n"
552                "    });");
553   verifyFormat("getSomeLongPromise()\n"
554                "    .then(function(value) {\n"
555                "      body();\n"
556                "      body();\n"
557                "    })\n"
558                "    .thenCatch(function(error) {\n"
559                "      body();\n"
560                "      body();\n"
561                "    });");
562 
563   verifyFormat("getSomeLongPromise()\n"
564                "    .then(function(value) { body(); })\n"
565                "    .thenCatch(function(error) { body(); });");
566 
567   verifyFormat("return [aaaaaaaaaaaaaaaaaaaaaa]\n"
568                "    .aaaaaaa(function() {\n"
569                "      //\n"
570                "    })\n"
571                "    .bbbbbb();");
572 }
573 
574 TEST_F(FormatTestJS, ArrowFunctions) {
575   verifyFormat("var x = (a) => {\n"
576                "  return a;\n"
577                "};");
578   verifyFormat("var x = (a) => {\n"
579                "  function y() { return 42; }\n"
580                "  return a;\n"
581                "};");
582   verifyFormat("var x = (a: type): {some: type} => {\n"
583                "  return a;\n"
584                "};");
585   verifyFormat("var x = (a) => a;");
586   verifyFormat("return () => [];");
587   verifyFormat("var aaaaaaaaaaaaaaaaaaaa = {\n"
588                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
589                "      (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
590                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) =>\n"
591                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
592                "};");
593   verifyFormat("var a = a.aaaaaaa(\n"
594                "    (a: a) => aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) &&\n"
595                "        aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
596   verifyFormat("var a = a.aaaaaaa(\n"
597                "    (a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) ?\n"
598                "        aaaaaaaaaaaaaaaaaaaaa(bbbbbbb) :\n"
599                "        aaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
600 
601   // FIXME: This is bad, we should be wrapping before "() => {".
602   verifyFormat("someFunction(() => {\n"
603                "  doSomething();  // break\n"
604                "})\n"
605                "    .doSomethingElse(\n"
606                "        // break\n"
607                "        );");
608 }
609 
610 TEST_F(FormatTestJS, ReturnStatements) {
611   verifyFormat("function() {\n"
612                "  return [hello, world];\n"
613                "}");
614 }
615 
616 TEST_F(FormatTestJS, ForLoops) {
617   verifyFormat("for (var i in [2, 3]) {\n"
618                "}");
619   verifyFormat("for (var i of [2, 3]) {\n"
620                "}");
621   verifyFormat("for (let {a, b} of x) {\n"
622                "}");
623   verifyFormat("for (let {a, b} in x) {\n"
624                "}");
625 }
626 
627 TEST_F(FormatTestJS, WrapRespectsAutomaticSemicolonInsertion) {
628   // The following statements must not wrap, as otherwise the program meaning
629   // would change due to automatic semicolon insertion.
630   // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1.
631   verifyFormat("return aaaaa;", getGoogleJSStyleWithColumns(10));
632   verifyFormat("continue aaaaa;", getGoogleJSStyleWithColumns(10));
633   verifyFormat("break aaaaa;", getGoogleJSStyleWithColumns(10));
634   verifyFormat("throw aaaaa;", getGoogleJSStyleWithColumns(10));
635   verifyFormat("aaaaaaaaa++;", getGoogleJSStyleWithColumns(10));
636   verifyFormat("aaaaaaaaa--;", getGoogleJSStyleWithColumns(10));
637   verifyFormat("return [\n"
638                "  aaa\n"
639                "];",
640                getGoogleJSStyleWithColumns(12));
641 }
642 
643 TEST_F(FormatTestJS, AutomaticSemicolonInsertionHeuristic) {
644   verifyFormat("a\n"
645                "b;",
646                " a \n"
647                " b ;");
648   verifyFormat("a()\n"
649                "b;",
650                " a ()\n"
651                " b ;");
652   verifyFormat("a[b]\n"
653                "c;",
654                "a [b]\n"
655                "c ;");
656   verifyFormat("1\n"
657                "a;",
658                "1 \n"
659                "a ;");
660   verifyFormat("a\n"
661                "1;",
662                "a \n"
663                "1 ;");
664   verifyFormat("a\n"
665                "'x';",
666                "a \n"
667                " 'x';");
668   verifyFormat("a++\n"
669                "b;",
670                "a ++\n"
671                "b ;");
672   verifyFormat("a\n"
673                "!b && c;",
674                "a \n"
675                " ! b && c;");
676   verifyFormat("a\n"
677                "if (1) f();",
678                " a\n"
679                " if (1) f();");
680   verifyFormat("a\n"
681                "class X {}",
682                " a\n"
683                " class X {}");
684   verifyFormat("var a", "var\n"
685                         "a");
686   verifyFormat("x instanceof String", "x\n"
687                                       "instanceof\n"
688                                       "String");
689   verifyFormat("function f(@Foo bar) {}", "function f(@Foo\n"
690                                           "  bar) {}");
691 }
692 
693 TEST_F(FormatTestJS, ClosureStyleCasts) {
694   verifyFormat("var x = /** @type {foo} */ (bar);");
695 }
696 
697 TEST_F(FormatTestJS, TryCatch) {
698   verifyFormat("try {\n"
699                "  f();\n"
700                "} catch (e) {\n"
701                "  g();\n"
702                "} finally {\n"
703                "  h();\n"
704                "}");
705 
706   // But, of course, "catch" is a perfectly fine function name in JavaScript.
707   verifyFormat("someObject.catch();");
708   verifyFormat("someObject.new();");
709   verifyFormat("someObject.delete();");
710 }
711 
712 TEST_F(FormatTestJS, StringLiteralConcatenation) {
713   verifyFormat("var literal = 'hello ' +\n"
714                "    'world';");
715 }
716 
717 TEST_F(FormatTestJS, RegexLiteralClassification) {
718   // Regex literals.
719   verifyFormat("var regex = /abc/;");
720   verifyFormat("f(/abc/);");
721   verifyFormat("f(abc, /abc/);");
722   verifyFormat("some_map[/abc/];");
723   verifyFormat("var x = a ? /abc/ : /abc/;");
724   verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}");
725   verifyFormat("var x = !/abc/.test(y);");
726   verifyFormat("var x = a && /abc/.test(y);");
727   verifyFormat("var x = a || /abc/.test(y);");
728   verifyFormat("var x = a + /abc/.search(y);");
729   verifyFormat("/abc/.search(y);");
730   verifyFormat("var regexs = {/abc/, /abc/};");
731   verifyFormat("return /abc/;");
732 
733   // Not regex literals.
734   verifyFormat("var a = a / 2 + b / 3;");
735   verifyFormat("var a = a++ / 2;");
736   // Prefix unary can operate on regex literals, not that it makes sense.
737   verifyFormat("var a = ++/a/;");
738 
739   // This is a known issue, regular expressions are incorrectly detected if
740   // directly following a closing parenthesis.
741   verifyFormat("if (foo) / bar /.exec(baz);");
742 }
743 
744 TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) {
745   verifyFormat("var regex = /=/;");
746   verifyFormat("var regex = /a*/;");
747   verifyFormat("var regex = /a+/;");
748   verifyFormat("var regex = /a?/;");
749   verifyFormat("var regex = /.a./;");
750   verifyFormat("var regex = /a\\*/;");
751   verifyFormat("var regex = /^a$/;");
752   verifyFormat("var regex = /\\/a/;");
753   verifyFormat("var regex = /(?:x)/;");
754   verifyFormat("var regex = /x(?=y)/;");
755   verifyFormat("var regex = /x(?!y)/;");
756   verifyFormat("var regex = /x|y/;");
757   verifyFormat("var regex = /a{2}/;");
758   verifyFormat("var regex = /a{1,3}/;");
759 
760   verifyFormat("var regex = /[abc]/;");
761   verifyFormat("var regex = /[^abc]/;");
762   verifyFormat("var regex = /[\\b]/;");
763   verifyFormat("var regex = /[/]/;");
764   verifyFormat("var regex = /[\\/]/;");
765   verifyFormat("var regex = /\\[/;");
766   verifyFormat("var regex = /\\\\[/]/;");
767   verifyFormat("var regex = /}[\"]/;");
768   verifyFormat("var regex = /}[/\"]/;");
769   verifyFormat("var regex = /}[\"/]/;");
770 
771   verifyFormat("var regex = /\\b/;");
772   verifyFormat("var regex = /\\B/;");
773   verifyFormat("var regex = /\\d/;");
774   verifyFormat("var regex = /\\D/;");
775   verifyFormat("var regex = /\\f/;");
776   verifyFormat("var regex = /\\n/;");
777   verifyFormat("var regex = /\\r/;");
778   verifyFormat("var regex = /\\s/;");
779   verifyFormat("var regex = /\\S/;");
780   verifyFormat("var regex = /\\t/;");
781   verifyFormat("var regex = /\\v/;");
782   verifyFormat("var regex = /\\w/;");
783   verifyFormat("var regex = /\\W/;");
784   verifyFormat("var regex = /a(a)\\1/;");
785   verifyFormat("var regex = /\\0/;");
786   verifyFormat("var regex = /\\\\/g;");
787   verifyFormat("var regex = /\\a\\\\/g;");
788   verifyFormat("var regex = /\a\\//g;");
789   verifyFormat("var regex = /a\\//;\n"
790                "var x = 0;");
791   verifyFormat("var regex = /'/g;", "var regex = /'/g ;");
792   verifyFormat("var regex = /'/g;  //'", "var regex = /'/g ; //'");
793   verifyFormat("var regex = /\\/*/;\n"
794                "var x = 0;",
795                "var regex = /\\/*/;\n"
796                "var x=0;");
797   verifyFormat("var x = /a\\//;", "var x = /a\\//  \n;");
798   verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16));
799   verifyFormat("var regex =\n"
800                "    /\"/;",
801                getGoogleJSStyleWithColumns(15));
802   verifyFormat("var regex =  //\n"
803                "    /a/;");
804   verifyFormat("var regexs = [\n"
805                "  /d/,   //\n"
806                "  /aa/,  //\n"
807                "];");
808 }
809 
810 TEST_F(FormatTestJS, RegexLiteralModifiers) {
811   verifyFormat("var regex = /abc/g;");
812   verifyFormat("var regex = /abc/i;");
813   verifyFormat("var regex = /abc/m;");
814   verifyFormat("var regex = /abc/y;");
815 }
816 
817 TEST_F(FormatTestJS, RegexLiteralLength) {
818   verifyFormat("var regex = /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
819                getGoogleJSStyleWithColumns(60));
820   verifyFormat("var regex =\n"
821                "    /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
822                getGoogleJSStyleWithColumns(60));
823   verifyFormat("var regex = /\\xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
824                getGoogleJSStyleWithColumns(50));
825 }
826 
827 TEST_F(FormatTestJS, RegexLiteralExamples) {
828   verifyFormat("var regex = search.match(/(?:\?|&)times=([^?&]+)/i);");
829 }
830 
831 TEST_F(FormatTestJS, TypeAnnotations) {
832   verifyFormat("var x: string;");
833   verifyFormat("var x: {a: string; b: number;} = {};");
834   verifyFormat("function x(): string {\n  return 'x';\n}");
835   verifyFormat("function x(): {x: string} {\n  return {x: 'x'};\n}");
836   verifyFormat("function x(y: string): string {\n  return 'x';\n}");
837   verifyFormat("for (var y: string in x) {\n  x();\n}");
838   verifyFormat("for (var y: string of x) {\n  x();\n}");
839   verifyFormat("function x(y: {a?: number;} = {}): number {\n"
840                "  return 12;\n"
841                "}");
842   verifyFormat("((a: string, b: number): string => a + b);");
843   verifyFormat("var x: (y: number) => string;");
844   verifyFormat("var x: P<string, (a: number) => string>;");
845   verifyFormat("var x = {y: function(): z { return 1; }};");
846   verifyFormat("var x = {y: function(): {a: number} { return 1; }};");
847   verifyFormat("function someFunc(args: string[]):\n"
848                "    {longReturnValue: string[]} {}",
849                getGoogleJSStyleWithColumns(60));
850 }
851 
852 TEST_F(FormatTestJS, UnionIntersectionTypes) {
853   verifyFormat("let x: A|B = A | B;");
854   verifyFormat("let x: A&B|C = A & B;");
855   verifyFormat("let x: Foo<A|B> = new Foo<A|B>();");
856   verifyFormat("function(x: A|B): C&D {}");
857   verifyFormat("function(x: A|B = A | B): C&D {}");
858 }
859 
860 TEST_F(FormatTestJS, ClassDeclarations) {
861   verifyFormat("class C {\n  x: string = 12;\n}");
862   verifyFormat("class C {\n  x(): string => 12;\n}");
863   verifyFormat("class C {\n  ['x' + 2]: string = 12;\n}");
864   verifyFormat("class C {\n  private x: string = 12;\n}");
865   verifyFormat("class C {\n  private static x: string = 12;\n}");
866   verifyFormat("class C {\n  static x(): string { return 'asd'; }\n}");
867   verifyFormat("class C extends P implements I {}");
868   verifyFormat("class C extends p.P implements i.I {}");
869   verifyFormat("class Test {\n"
870                "  aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n"
871                "      aaaaaaaaaaaaaaaaaaaaaa {}\n"
872                "}");
873   verifyFormat("foo = class Name {\n"
874                "  constructor() {}\n"
875                "};");
876   verifyFormat("foo = class {\n"
877                "  constructor() {}\n"
878                "};");
879   verifyFormat("class C {\n"
880                "  x: {y: Z;} = {};\n"
881                "  private y: {y: Z;} = {};\n"
882                "}");
883 
884   // ':' is not a type declaration here.
885   verifyFormat("class X {\n"
886                "  subs = {\n"
887                "    'b': {\n"
888                "      'c': 1,\n"
889                "    },\n"
890                "  };\n"
891                "}");
892 }
893 
894 TEST_F(FormatTestJS, InterfaceDeclarations) {
895   verifyFormat("interface I {\n"
896                "  x: string;\n"
897                "  enum: string[];\n"
898                "  enum?: string[];\n"
899                "}\n"
900                "var y;");
901   // Ensure that state is reset after parsing the interface.
902   verifyFormat("interface a {}\n"
903                "export function b() {}\n"
904                "var x;");
905 
906   // Arrays of object type literals.
907   verifyFormat("interface I {\n"
908                "  o: {}[];\n"
909                "}");
910 }
911 
912 TEST_F(FormatTestJS, EnumDeclarations) {
913   verifyFormat("enum Foo {\n"
914                "  A = 1,\n"
915                "  B\n"
916                "}");
917   verifyFormat("export /* somecomment*/ enum Foo {\n"
918                "  A = 1,\n"
919                "  B\n"
920                "}");
921   verifyFormat("enum Foo {\n"
922                "  A = 1,  // comment\n"
923                "  B\n"
924                "}\n"
925                "var x = 1;");
926 }
927 
928 TEST_F(FormatTestJS, MetadataAnnotations) {
929   verifyFormat("@A\nclass C {\n}");
930   verifyFormat("@A({arg: 'value'})\nclass C {\n}");
931   verifyFormat("@A\n@B\nclass C {\n}");
932   verifyFormat("class C {\n  @A x: string;\n}");
933   verifyFormat("class C {\n"
934                "  @A\n"
935                "  private x(): string {\n"
936                "    return 'y';\n"
937                "  }\n"
938                "}");
939   verifyFormat("class X {}\n"
940                "class Y {}");
941 }
942 
943 TEST_F(FormatTestJS, Modules) {
944   verifyFormat("import SomeThing from 'some/module.js';");
945   verifyFormat("import {X, Y} from 'some/module.js';");
946   verifyFormat("import a, {X, Y} from 'some/module.js';");
947   verifyFormat("import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,"
948                " VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying"
949                "} from 'some/module.js';");
950   verifyFormat("import {X, Y,} from 'some/module.js';");
951   verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
952   verifyFormat("import * as lib from 'some/module.js';");
953   verifyFormat("var x = {import: 1};\nx.import = 2;");
954 
955   verifyFormat("export function fn() {\n"
956                "  return 'fn';\n"
957                "}");
958   verifyFormat("export function A() {}\n"
959                "export default function B() {}\n"
960                "export function C() {}");
961   verifyFormat("export const x = 12;");
962   verifyFormat("export default class X {}");
963   verifyFormat("export {X, Y} from 'some/module.js';");
964   verifyFormat("export {X, Y,} from 'some/module.js';");
965   verifyFormat("export {SomeVeryLongExport as X, "
966                "SomeOtherVeryLongExport as Y} from 'some/module.js';");
967   // export without 'from' is wrapped.
968   verifyFormat("export let someRatherLongVariableName =\n"
969                "    someSurprisinglyLongVariable + someOtherRatherLongVar;");
970   // ... but not if from is just an identifier.
971   verifyFormat("export {\n"
972                "  from as from,\n"
973                "  someSurprisinglyLongVariable\n"
974                "      as from\n"
975                "};",
976                getGoogleJSStyleWithColumns(20));
977   verifyFormat("export class C {\n"
978                "  x: number;\n"
979                "  y: string;\n"
980                "}");
981   verifyFormat("export class X { y: number; }");
982   verifyFormat("export abstract class X { y: number; }");
983   verifyFormat("export default class X { y: number }");
984   verifyFormat("export default function() {\n  return 1;\n}");
985   verifyFormat("export var x = 12;");
986   verifyFormat("class C {}\n"
987                "export function f() {}\n"
988                "var v;");
989   verifyFormat("export var x: number = 12;");
990   verifyFormat("export const y = {\n"
991                "  a: 1,\n"
992                "  b: 2\n"
993                "};");
994   verifyFormat("export enum Foo {\n"
995                "  BAR,\n"
996                "  // adsdasd\n"
997                "  BAZ\n"
998                "}");
999   verifyFormat("export default [\n"
1000                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1001                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
1002                "];");
1003   verifyFormat("export default [];");
1004   verifyFormat("export default () => {};");
1005   verifyFormat("export interface Foo { foo: number; }\n"
1006                "export class Bar {\n"
1007                "  blah(): string { return this.blah; };\n"
1008                "}");
1009 }
1010 
1011 TEST_F(FormatTestJS, TemplateStrings) {
1012   // Keeps any whitespace/indentation within the template string.
1013   verifyFormat("var x = `hello\n"
1014             "     ${  name    }\n"
1015             "  !`;",
1016             "var x    =    `hello\n"
1017                    "     ${  name    }\n"
1018                    "  !`;");
1019 
1020   verifyFormat("var x =\n"
1021                "    `hello ${world}` >= some();",
1022                getGoogleJSStyleWithColumns(34)); // Barely doesn't fit.
1023   verifyFormat("var x = `hello ${world}` >= some();",
1024                getGoogleJSStyleWithColumns(35)); // Barely fits.
1025   verifyFormat("var x = `hello\n"
1026             "  ${world}` >=\n"
1027             "    some();",
1028             "var x =\n"
1029                    "    `hello\n"
1030                    "  ${world}` >= some();",
1031                    getGoogleJSStyleWithColumns(21)); // Barely doesn't fit.
1032   verifyFormat("var x = `hello\n"
1033             "  ${world}` >= some();",
1034             "var x =\n"
1035                    "    `hello\n"
1036                    "  ${world}` >= some();",
1037                    getGoogleJSStyleWithColumns(22)); // Barely fits.
1038 
1039   verifyFormat("var x =\n"
1040                "    `h`;",
1041                getGoogleJSStyleWithColumns(11));
1042   verifyFormat("var x =\n    `multi\n  line`;", "var x = `multi\n  line`;",
1043                getGoogleJSStyleWithColumns(13));
1044   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1045                "    `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);");
1046 
1047   // Make sure template strings get a proper ColumnWidth assigned, even if they
1048   // are first token in line.
1049   verifyFormat(
1050       "var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
1051       "    `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;");
1052 
1053   // Two template strings.
1054   verifyFormat("var x = `hello` == `hello`;");
1055 
1056   // Comments in template strings.
1057   verifyFormat("var x = `//a`;\n"
1058             "var y;",
1059             "var x =\n `//a`;\n"
1060                    "var y  ;");
1061   verifyFormat("var x = `/*a`;\n"
1062                "var y;",
1063                "var x =\n `/*a`;\n"
1064                "var y;");
1065   // Unterminated string literals in a template string.
1066   verifyFormat("var x = `'`;  // comment with matching quote '\n"
1067                "var y;");
1068   verifyFormat("var x = `\"`;  // comment with matching quote \"\n"
1069                "var y;");
1070   verifyFormat("it(`'aaaaaaaaaaaaaaa   `, aaaaaaaaa);",
1071                "it(`'aaaaaaaaaaaaaaa   `,   aaaaaaaaa) ;",
1072                getGoogleJSStyleWithColumns(40));
1073   // Backticks in a comment - not a template string.
1074   verifyFormat("var x = 1  // `/*a`;\n"
1075                "    ;",
1076                "var x =\n 1  // `/*a`;\n"
1077                "    ;");
1078   verifyFormat("/* ` */ var x = 1; /* ` */", "/* ` */ var x\n= 1; /* ` */");
1079   // Comment spans multiple template strings.
1080   verifyFormat("var x = `/*a`;\n"
1081                "var y = ` */ `;",
1082                "var x =\n `/*a`;\n"
1083                "var y =\n ` */ `;");
1084   // Escaped backtick.
1085   verifyFormat("var x = ` \\` a`;\n"
1086                "var y;",
1087                "var x = ` \\` a`;\n"
1088                "var y;");
1089 }
1090 
1091 TEST_F(FormatTestJS, CastSyntax) { verifyFormat("var x = <type>foo;"); }
1092 
1093 TEST_F(FormatTestJS, TypeArguments) {
1094   verifyFormat("class X<Y> {}");
1095   verifyFormat("new X<Y>();");
1096   verifyFormat("foo<Y>(a);");
1097   verifyFormat("var x: X<Y>[];");
1098   verifyFormat("class C extends D<E> implements F<G>, H<I> {}");
1099   verifyFormat("function f(a: List<any> = null) {}");
1100   verifyFormat("function f(): List<any> {}");
1101   verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n"
1102                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}");
1103   verifyFormat("function aaaaaaaaaa(\n"
1104                "    aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa,\n"
1105                "    aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa):\n"
1106                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {}");
1107 }
1108 
1109 TEST_F(FormatTestJS, UserDefinedTypeGuards) {
1110   verifyFormat(
1111       "function foo(check: Object):\n"
1112       "    check is {foo: string, bar: string, baz: string, foobar: string} {\n"
1113       "  return 'bar' in check;\n"
1114       "}\n");
1115 }
1116 
1117 TEST_F(FormatTestJS, OptionalTypes) {
1118   verifyFormat("function x(a?: b, c?, d?) {}");
1119   verifyFormat("class X {\n"
1120                "  y?: z;\n"
1121                "  z?;\n"
1122                "}");
1123   verifyFormat("interface X {\n"
1124                "  y?(): z;\n"
1125                "}");
1126   verifyFormat("x ? 1 : 2;");
1127   verifyFormat("constructor({aa}: {\n"
1128                "  aa?: string,\n"
1129                "  aaaaaaaa?: string,\n"
1130                "  aaaaaaaaaaaaaaa?: boolean,\n"
1131                "  aaaaaa?: List<string>\n"
1132                "}) {}");
1133 }
1134 
1135 TEST_F(FormatTestJS, IndexSignature) {
1136   verifyFormat("var x: {[k: string]: v};");
1137 }
1138 
1139 TEST_F(FormatTestJS, WrapAfterParen) {
1140   verifyFormat("xxxxxxxxxxx(\n"
1141                "    aaa, aaa);",
1142                getGoogleJSStyleWithColumns(20));
1143   verifyFormat("xxxxxxxxxxx(\n"
1144                "    aaa, aaa, aaa,\n"
1145                "    aaa, aaa, aaa);",
1146                getGoogleJSStyleWithColumns(20));
1147   verifyFormat("xxxxxxxxxxx(\n"
1148                "    aaaaaaaaaaaaaaaaaaaaaaaa,\n"
1149                "    function(x) {\n"
1150                "      y();  //\n"
1151                "    });",
1152                getGoogleJSStyleWithColumns(40));
1153   verifyFormat("while (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
1154                "       bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
1155 }
1156 
1157 TEST_F(FormatTestJS, JSDocAnnotations) {
1158   verifyFormat("/**\n"
1159                " * @export {this.is.a.long.path.to.a.Type}\n"
1160                " */",
1161                "/**\n"
1162                " * @export {this.is.a.long.path.to.a.Type}\n"
1163                " */",
1164                getGoogleJSStyleWithColumns(20));
1165 }
1166 
1167 TEST_F(FormatTestJS, RequoteStringsSingle) {
1168   verifyFormat("var x = 'foo';", "var x = \"foo\";");
1169   verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo'o'\";");
1170   verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo\\'o'\";");
1171   verifyFormat(
1172       "var x =\n"
1173       "    'foo\\'';",
1174       // Code below is 15 chars wide, doesn't fit into the line with the
1175       // \ escape added.
1176       "var x = \"foo'\";", getGoogleJSStyleWithColumns(15));
1177   // Removes no-longer needed \ escape from ".
1178   verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";");
1179   // Code below fits into 15 chars *after* removing the \ escape.
1180   verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";",
1181                getGoogleJSStyleWithColumns(15));
1182 }
1183 
1184 TEST_F(FormatTestJS, RequoteStringsDouble) {
1185   FormatStyle DoubleQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
1186   DoubleQuotes.JavaScriptQuotes = FormatStyle::JSQS_Double;
1187   verifyFormat("var x = \"foo\";", DoubleQuotes);
1188   verifyFormat("var x = \"foo\";", "var x = 'foo';", DoubleQuotes);
1189   verifyFormat("var x = \"fo'o\";", "var x = 'fo\\'o';", DoubleQuotes);
1190 }
1191 
1192 TEST_F(FormatTestJS, RequoteStringsLeave) {
1193   FormatStyle LeaveQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
1194   LeaveQuotes.JavaScriptQuotes = FormatStyle::JSQS_Leave;
1195   verifyFormat("var x = \"foo\";", LeaveQuotes);
1196   verifyFormat("var x = 'foo';", LeaveQuotes);
1197 }
1198 
1199 } // end namespace tooling
1200 } // end namespace clang
1201