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