eslint/tests/lib/rules/space-before-blocks.js

   1 /**
   2  * @fileoverview Tests for space-before-block rule.
   3  * @author Mathias Schreck <https://github.com/lo1tuma>
   4  */
   5
   6 "use strict";
   7
   8 //------------------------------------------------------------------------------
   9 // Requirements
  10 //------------------------------------------------------------------------------
  11
  12 const rule = require("../../../lib/rules/space-before-blocks"),
  13     { RuleTester } = require("../../../lib/rule-tester"),
  14     fixtureParser = require("../../fixtures/fixture-parser");
  15
  16 //------------------------------------------------------------------------------
  17 // Tests
  18 //------------------------------------------------------------------------------
  19
  20 const ruleTester = new RuleTester(),
  21     alwaysArgs = ["always"],
  22     neverArgs = ["never"],
  23     functionsOnlyArgs = [{ functions: "always", keywords: "never", classes: "never" }],
  24     keywordOnlyArgs = [{ functions: "never", keywords: "always", classes: "never" }],
  25     classesOnlyArgs = [{ functions: "never", keywords: "never", classes: "always" }],
  26     functionsAlwaysOthersOffArgs = [{ functions: "always", keywords: "off", classes: "off" }],
  27     keywordAlwaysOthersOffArgs = [{ functions: "off", keywords: "always", classes: "off" }],
  28     classesAlwaysOthersOffArgs = [{ functions: "off", keywords: "off", classes: "always" }],
  29     functionsNeverOthersOffArgs = [{ functions: "never", keywords: "off", classes: "off" }],
  30     keywordNeverOthersOffArgs = [{ functions: "off", keywords: "never", classes: "off" }],
  31     classesNeverOthersOffArgs = [{ functions: "off", keywords: "off", classes: "never" }],
  32     expectedSpacingError = { messageId: "missingSpace" },
  33     expectedNoSpacingError = { messageId: "unexpectedSpace" };
  34
  35 ruleTester.run("space-before-blocks", rule, {
  36     valid: [
  37         "if(a) {}",
  38         "if(a)  {}",
  39         { code: "if(a){}", options: neverArgs },
  40         { code: "if(a){}", options: functionsOnlyArgs },
  41         { code: "if(a) {}", options: keywordOnlyArgs },
  42         { code: "if(a){ function b() {} }", options: functionsOnlyArgs },
  43         { code: "if(a) { function b(){} }", options: keywordOnlyArgs },
  44         "if(a)\n{}",
  45         { code: "if(a)\n{}", options: neverArgs },
  46         "if(a) {}else {}",
  47         { code: "if(a){}else{}", options: neverArgs },
  48         { code: "if(a){}else{}", options: functionsOnlyArgs },
  49         { code: "if(a) {} else {}", options: keywordOnlyArgs },
  50         { code: "if(a){ function b() {} }else{}", options: functionsOnlyArgs },
  51         { code: "if(a) { function b(){} } else {}", options: keywordOnlyArgs },
  52         "function a() {}",
  53         { code: "function a(){}", options: neverArgs },
  54         {
  55             code: "export default class{}",
  56             options: functionsOnlyArgs,
  57             parserOptions: { ecmaVersion: 6, sourceType: "module" }
  58         },
  59         {
  60             code: "export default class {}",
  61             options: classesOnlyArgs,
  62             parserOptions: { ecmaVersion: 6, sourceType: "module" }
  63         },
  64         {
  65             code: "export default function a() {}",
  66             options: functionsOnlyArgs,
  67             parserOptions: { ecmaVersion: 6, sourceType: "module" }
  68         },
  69         {
  70             code: "export default function a(){}",
  71             options: keywordOnlyArgs,
  72             parserOptions: { ecmaVersion: 6, sourceType: "module" }
  73         },
  74         { code: "export function a(){}", options: keywordOnlyArgs, parserOptions: { ecmaVersion: 6, sourceType: "module" } },
  75         { code: "export function a() {}", options: functionsOnlyArgs, parserOptions: { ecmaVersion: 6, sourceType: "module" } },
  76         { code: "function a(){}", options: keywordOnlyArgs },
  77         { code: "function a() {}", options: functionsOnlyArgs },
  78         { code: "function a(){ if(b) {} }", options: keywordOnlyArgs },
  79         { code: "function a() { if(b){} }", options: functionsOnlyArgs },
  80         "switch(a.b(c < d)) { case 'foo': foo(); break; default: if (a) { bar(); } }",
  81         "switch(a) { }",
  82         "switch(a)  {}",
  83         { code: "switch(a.b(c < d)){ case 'foo': foo(); break; default: if (a){ bar(); } }", options: neverArgs },
  84         { code: "switch(a.b(c < d)){ case 'foo': foo(); break; default: if (a){ bar(); } }", options: functionsOnlyArgs },
  85         { code: "switch(a){}", options: neverArgs },
  86         { code: "switch(a){}", options: functionsOnlyArgs },
  87         { code: "switch(a) {}", options: keywordOnlyArgs },
  88         "try {}catch(a) {}",
  89         { code: "try{}catch(a){}", options: neverArgs },
  90         { code: "try{}catch(a){}", options: functionsOnlyArgs },
  91         { code: "try {} catch(a) {}", options: keywordOnlyArgs },
  92         { code: "try{ function b() {} }catch(a){}", options: functionsOnlyArgs },
  93         { code: "try { function b(){} } catch(a) {}", options: keywordOnlyArgs },
  94         "for(;;) {}",
  95         { code: "for(;;){}", options: neverArgs },
  96         { code: "for(;;){}", options: functionsOnlyArgs },
  97         { code: "for(;;) {}", options: keywordOnlyArgs },
  98         { code: "for(;;){ function a() {} }", options: functionsOnlyArgs },
  99         { code: "for(;;) { function a(){} }", options: keywordOnlyArgs },
 100         "while(a) {}",
 101         { code: "while(a){}", options: neverArgs },
 102         { code: "while(a){}", options: functionsOnlyArgs },
 103         { code: "while(a) {}", options: keywordOnlyArgs },
 104         { code: "while(a){ function b() {} }", options: functionsOnlyArgs },
 105         { code: "while(a) { function b(){} }", options: keywordOnlyArgs },
 106         {
 107             code: "class test { constructor() {} }",
 108             options: [{ functions: "always", keywords: "never" }],
 109             parserOptions: { ecmaVersion: 6 }
 110         },
 111         {
 112             code: "class test { constructor(){} }",
 113             options: classesOnlyArgs,
 114             parserOptions: { ecmaVersion: 6 }
 115         },
 116         {
 117             code: "class test{ constructor() {} }",
 118             options: functionsOnlyArgs,
 119             parserOptions: { ecmaVersion: 6 }
 120         },
 121         {
 122             code: "class test {}",
 123             options: classesOnlyArgs,
 124             parserOptions: { ecmaVersion: 6 }
 125         },
 126         {
 127             code: "class test{}",
 128             options: functionsOnlyArgs,
 129             parserOptions: { ecmaVersion: 6 }
 130         },
 131         {
 132             code: "class test{}",
 133             options: neverArgs,
 134             parserOptions: { ecmaVersion: 6 }
 135         },
 136         {
 137             code: "class test {}",
 138             parserOptions: { ecmaVersion: 6 }
 139         },
 140         { code: "function a(){if(b) {}}", options: keywordAlwaysOthersOffArgs },
 141         { code: "function a() {if(b) {}}", options: keywordAlwaysOthersOffArgs },
 142         { code: "function a() {if(b){}}", options: functionsAlwaysOthersOffArgs },
 143         { code: "function a() {if(b) {}}", options: functionsAlwaysOthersOffArgs },
 144         {
 145             code: "class test { constructor(){if(a){}} }",
 146             options: classesAlwaysOthersOffArgs,
 147             parserOptions: { ecmaVersion: 6 }
 148         },
 149         {
 150             code: "class test { constructor() {if(a){}} }",
 151             options: classesAlwaysOthersOffArgs,
 152             parserOptions: { ecmaVersion: 6 }
 153         },
 154         {
 155             code: "class test { constructor(){if(a) {}} }",
 156             options: classesAlwaysOthersOffArgs,
 157             parserOptions: { ecmaVersion: 6 }
 158         },
 159         {
 160             code: "class test { constructor() {if(a) {}} }",
 161             options: classesAlwaysOthersOffArgs,
 162             parserOptions: { ecmaVersion: 6 }
 163         },
 164         { code: "function a(){if(b){}}", options: keywordNeverOthersOffArgs },
 165         { code: "function a() {if(b){}}", options: keywordNeverOthersOffArgs },
 166         { code: "function a(){if(b){}}", options: functionsNeverOthersOffArgs },
 167         { code: "function a(){if(b) {}}", options: functionsNeverOthersOffArgs },
 168         {
 169             code: "class test{ constructor(){if(a){}} }",
 170             options: classesNeverOthersOffArgs,
 171             parserOptions: { ecmaVersion: 6 }
 172         },
 173         {
 174             code: "class test{ constructor() {if(a){}} }",
 175             options: classesNeverOthersOffArgs,
 176             parserOptions: { ecmaVersion: 6 }
 177         },
 178         {
 179             code: "class test{ constructor(){if(a) {}} }",
 180             options: classesNeverOthersOffArgs,
 181             parserOptions: { ecmaVersion: 6 }
 182         },
 183         {
 184             code: "class test{ constructor() {if(a) {}} }",
 185             options: classesNeverOthersOffArgs,
 186             parserOptions: { ecmaVersion: 6 }
 187         },
 188
 189         // https://github.com/eslint/eslint/issues/3769
 190         { code: "()=>{};", options: ["always"], parserOptions: { ecmaVersion: 6 } },
 191         { code: "() => {};", options: ["never"], parserOptions: { ecmaVersion: 6 } },
 192
 193         // https://github.com/eslint/eslint/issues/1338
 194         "if(a) {}else{}",
 195         { code: "if(a){}else {}", options: neverArgs },
 196         { code: "try {}catch(a){}", options: functionsOnlyArgs },
 197         { code: "export default class{}", options: classesOnlyArgs, parserOptions: { ecmaVersion: 6, sourceType: "module" } },
 198
 199         // https://github.com/eslint/eslint/issues/15082
 200         { code: "switch(x) { case 9:{ break; } }", options: alwaysArgs },
 201         { code: "switch(x){ case 9: { break; } }", options: neverArgs },
 202         { code: "switch(x) { case (9):{ break; } }", options: alwaysArgs },
 203         { code: "switch(x){ case (9): { break; } }", options: neverArgs },
 204         { code: "switch(x) { default:{ break; } }", options: alwaysArgs },
 205         { code: "switch(x){ default: { break; } }", options: neverArgs },
 206
 207         // not conflict with `keyword-spacing`
 208         {
 209             code: "(class{ static{} })",
 210             options: ["always"],
 211             parserOptions: { ecmaVersion: 2022 }
 212         },
 213         {
 214             code: "(class { static {} })",
 215             options: ["never"],
 216             parserOptions: { ecmaVersion: 2022 }
 217         }
 218     ],
 219     invalid: [
 220         {
 221             code: "if(a){}",
 222             output: "if(a) {}",
 223             errors: [{ messageId: "missingSpace", line: 1, column: 6 }]
 224         },
 225         {
 226             code: "if(a){}",
 227             output: "if(a) {}",
 228             options: keywordOnlyArgs,
 229             errors: [expectedSpacingError]
 230         },
 231         {
 232             code: "if(a) {}",
 233             output: "if(a){}",
 234             options: functionsOnlyArgs,
 235             errors: [expectedNoSpacingError]
 236         },
 237         {
 238             code: "if(a) { function a() {} }",
 239             output: "if(a){ function a() {} }",
 240             options: functionsOnlyArgs,
 241             errors: [{ messageId: "unexpectedSpace", line: 1, column: 7 }]
 242         },
 243         {
 244             code: "if(a) { function a() {} }",
 245             output: "if(a) { function a(){} }",
 246             options: keywordOnlyArgs,
 247             errors: [{ messageId: "unexpectedSpace", line: 1, column: 22 }]
 248         },
 249         {
 250             code: "if(a) {}",
 251             output: "if(a){}",
 252             options: neverArgs,
 253             errors: [expectedNoSpacingError]
 254         },
 255         {
 256             code: "function a(){}",
 257             output: "function a() {}",
 258             errors: [expectedSpacingError]
 259         },
 260         {
 261             code: "function a() {}",
 262             output: "function a(){}",
 263             options: neverArgs,
 264             errors: [expectedNoSpacingError]
 265         },
 266         {
 267             code: "function a()    {}",
 268             output: "function a(){}",
 269             options: neverArgs,
 270             errors: [expectedNoSpacingError]
 271         },
 272         {
 273             code: "function a(){ if (a){} }",
 274             output: "function a() { if (a){} }",
 275             options: functionsOnlyArgs,
 276             errors: [{ messageId: "missingSpace", line: 1, column: 13 }]
 277         },
 278         {
 279             code: "function a() { if (a) {} }",
 280             output: "function a(){ if (a) {} }",
 281             options: keywordOnlyArgs,
 282             errors: [{ messageId: "unexpectedSpace", line: 1, column: 14 }]
 283         },
 284         {
 285             code: "function a(){}",
 286             output: "function a() {}",
 287             options: functionsOnlyArgs,
 288             errors: [expectedSpacingError]
 289         },
 290         {
 291             code: "function a() {}",
 292             output: "function a(){}",
 293             options: keywordOnlyArgs,
 294             errors: [expectedNoSpacingError]
 295         },
 296         {
 297             code: "switch(a){}",
 298             output: "switch(a) {}",
 299             errors: [expectedSpacingError]
 300         },
 301         {
 302             code: "switch(a) {}",
 303             output: "switch(a){}",
 304             options: neverArgs,
 305             errors: [expectedNoSpacingError]
 306         },
 307         {
 308             code: "switch(a){}",
 309             output: "switch(a) {}",
 310             options: keywordOnlyArgs,
 311             errors: [expectedSpacingError]
 312         },
 313         {
 314             code: "switch(a) {}",
 315             output: "switch(a){}",
 316             options: functionsOnlyArgs,
 317             errors: [expectedNoSpacingError]
 318         },
 319         {
 320             code: "switch(a.b()){ case 'foo': foo(); break; default: if (a) { bar(); } }",
 321             output: "switch(a.b()) { case 'foo': foo(); break; default: if (a) { bar(); } }",
 322             errors: [expectedSpacingError]
 323         },
 324         {
 325             code: "switch(a.b()) { case 'foo': foo(); break; default: if (a){ bar(); } }",
 326             output: "switch(a.b()){ case 'foo': foo(); break; default: if (a){ bar(); } }",
 327             options: neverArgs,
 328             errors: [expectedNoSpacingError]
 329         },
 330         {
 331             code: "try{}catch(a){}",
 332             output: "try{}catch(a) {}",
 333             errors: [expectedSpacingError]
 334         },
 335         {
 336             code: "try {}catch(a) {}",
 337             output: "try {}catch(a){}",
 338             options: neverArgs,
 339             errors: [expectedNoSpacingError]
 340         },
 341         {
 342             code: "try {} catch(a){}",
 343             output: "try {} catch(a) {}",
 344             options: keywordOnlyArgs,
 345             errors: [expectedSpacingError]
 346         },
 347         {
 348             code: "try { function b() {} } catch(a) {}",
 349             output: "try { function b(){} } catch(a) {}",
 350             options: keywordOnlyArgs,
 351             errors: [{ messageId: "unexpectedSpace", line: 1, column: 20 }]
 352         },
 353         {
 354             code: "try{ function b(){} }catch(a){}",
 355             output: "try{ function b() {} }catch(a){}",
 356             options: functionsOnlyArgs,
 357             errors: [{ messageId: "missingSpace", line: 1, column: 18 }]
 358         },
 359         {
 360             code: "for(;;){}",
 361             output: "for(;;) {}",
 362             errors: [expectedSpacingError]
 363         },
 364         {
 365             code: "for(;;) {}",
 366             output: "for(;;){}",
 367             options: neverArgs,
 368             errors: [expectedNoSpacingError]
 369         },
 370         {
 371             code: "for(;;){}",
 372             output: "for(;;) {}",
 373             options: keywordOnlyArgs,
 374             errors: [expectedSpacingError]
 375         },
 376         {
 377             code: "for(;;) {}",
 378             output: "for(;;){}",
 379             options: functionsOnlyArgs,
 380             errors: [expectedNoSpacingError]
 381         },
 382         {
 383             code: "for(;;){ function a(){} }",
 384             output: "for(;;){ function a() {} }",
 385             options: functionsOnlyArgs,
 386             errors: [expectedSpacingError]
 387         },
 388         {
 389             code: "for(;;) { function a() {} }",
 390             output: "for(;;) { function a(){} }",
 391             options: keywordOnlyArgs,
 392             errors: [expectedNoSpacingError]
 393         },
 394         {
 395             code: "while(a){}",
 396             output: "while(a) {}",
 397             errors: [expectedSpacingError]
 398         },
 399         {
 400             code: "while(a) {}",
 401             output: "while(a){}",
 402             options: neverArgs,
 403             errors: [expectedNoSpacingError]
 404         },
 405         {
 406             code: "while(a){}",
 407             output: "while(a) {}",
 408             options: keywordOnlyArgs,
 409             errors: [expectedSpacingError]
 410         },
 411         {
 412             code: "while(a) {}",
 413             output: "while(a){}",
 414             options: functionsOnlyArgs,
 415             errors: [expectedNoSpacingError]
 416         },
 417         {
 418             code: "while(a){ function a(){} }",
 419             output: "while(a){ function a() {} }",
 420             options: functionsOnlyArgs,
 421             errors: [expectedSpacingError]
 422         },
 423         {
 424             code: "while(a) { function a() {} }",
 425             output: "while(a) { function a(){} }",
 426             options: keywordOnlyArgs,
 427             errors: [expectedNoSpacingError]
 428         },
 429         {
 430             code: "export function a() { if(b) {} }",
 431             output: "export function a() { if(b){} }",
 432             options: functionsOnlyArgs,
 433             parserOptions: { ecmaVersion: 6, sourceType: "module" },
 434             errors: [expectedNoSpacingError]
 435         },
 436         {
 437             code: "export function a(){ if(b){} }",
 438             output: "export function a(){ if(b) {} }",
 439             options: keywordOnlyArgs,
 440             parserOptions: { ecmaVersion: 6, sourceType: "module" },
 441             errors: [expectedSpacingError]
 442         },
 443         {
 444             code: "export function a(){}",
 445             output: "export function a() {}",
 446             options: functionsOnlyArgs,
 447             parserOptions: { ecmaVersion: 6, sourceType: "module" },
 448             errors: [expectedSpacingError]
 449         },
 450         {
 451             code: "export default function (a) {}",
 452             output: "export default function (a){}",
 453             options: keywordOnlyArgs,
 454             parserOptions: { ecmaVersion: 6, sourceType: "module" },
 455             errors: [expectedNoSpacingError]
 456         },
 457         {
 458             code: "export function a() {}",
 459             output: "export function a(){}",
 460             options: keywordOnlyArgs,
 461             parserOptions: { ecmaVersion: 6, sourceType: "module" },
 462             errors: [expectedNoSpacingError]
 463         },
 464         {
 465             code: "class test{}",
 466             output: "class test {}",
 467             parserOptions: { ecmaVersion: 6 },
 468             errors: [expectedSpacingError]
 469         },
 470         {
 471             code: "class test{}",
 472             output: "class test {}",
 473             options: classesOnlyArgs,
 474             parserOptions: { ecmaVersion: 6 },
 475             errors: [expectedSpacingError]
 476         },
 477         {
 478             code: "class test{ constructor(){} }",
 479             output: "class test{ constructor() {} }",
 480             options: functionsOnlyArgs,
 481             parserOptions: { ecmaVersion: 6 },
 482             errors: [expectedSpacingError]
 483         },
 484         {
 485             code: "class test { constructor() {} }",
 486             output: "class test { constructor(){} }",
 487             options: classesOnlyArgs,
 488             parserOptions: { ecmaVersion: 6 },
 489             errors: [expectedNoSpacingError]
 490         },
 491         {
 492             code: "class test {}",
 493             output: "class test{}",
 494             options: functionsOnlyArgs,
 495             parserOptions: { ecmaVersion: 6 },
 496             errors: [expectedNoSpacingError]
 497         },
 498         {
 499             code: "class test {}",
 500             output: "class test{}",
 501             options: neverArgs,
 502             parserOptions: { ecmaVersion: 6 },
 503             errors: [expectedNoSpacingError]
 504         },
 505         {
 506             code: "if(a){ function a(){} }",
 507             output: "if(a){ function a() {} }",
 508             options: functionsAlwaysOthersOffArgs,
 509             errors: [expectedSpacingError]
 510         },
 511         {
 512             code: "if(a) { function a(){} }",
 513             output: "if(a) { function a() {} }",
 514             options: functionsAlwaysOthersOffArgs,
 515             errors: [expectedSpacingError]
 516         },
 517         {
 518             code: "if(a){ function a(){} }",
 519             output: "if(a) { function a(){} }",
 520             options: keywordAlwaysOthersOffArgs,
 521             errors: [expectedSpacingError]
 522         },
 523         {
 524             code: "if(a){ function a() {} }",
 525             output: "if(a) { function a() {} }",
 526             options: keywordAlwaysOthersOffArgs,
 527             errors: [expectedSpacingError]
 528         },
 529         {
 530             code: "class test{ constructor(){} }",
 531             output: "class test { constructor(){} }",
 532             options: classesAlwaysOthersOffArgs,
 533             parserOptions: { ecmaVersion: 6 },
 534             errors: [expectedSpacingError]
 535         },
 536         {
 537             code: "class test{ constructor() {} }",
 538             output: "class test { constructor() {} }",
 539             options: classesAlwaysOthersOffArgs,
 540             parserOptions: { ecmaVersion: 6 },
 541             errors: [expectedSpacingError]
 542         },
 543         {
 544             code: "if(a){ function a() {} }",
 545             output: "if(a){ function a(){} }",
 546             options: functionsNeverOthersOffArgs,
 547             errors: [expectedNoSpacingError]
 548         },
 549         {
 550             code: "if(a) { function a() {} }",
 551             output: "if(a) { function a(){} }",
 552             options: functionsNeverOthersOffArgs,
 553             errors: [expectedNoSpacingError]
 554         },
 555         {
 556             code: "if(a) { function a(){} }",
 557             output: "if(a){ function a(){} }",
 558             options: keywordNeverOthersOffArgs,
 559             errors: [expectedNoSpacingError]
 560         },
 561         {
 562             code: "if(a) { function a() {} }",
 563             output: "if(a){ function a() {} }",
 564             options: keywordNeverOthersOffArgs,
 565             errors: [expectedNoSpacingError]
 566         },
 567         {
 568             code: "class test { constructor(){} }",
 569             output: "class test{ constructor(){} }",
 570             options: classesNeverOthersOffArgs,
 571             parserOptions: { ecmaVersion: 6 },
 572             errors: [expectedNoSpacingError]
 573         },
 574         {
 575             code: "class test { constructor() {} }",
 576             output: "class test{ constructor() {} }",
 577             options: classesNeverOthersOffArgs,
 578             parserOptions: { ecmaVersion: 6 },
 579             errors: [expectedNoSpacingError]
 580         },
 581
 582         // https://github.com/eslint/eslint/issues/13553
 583         {
 584             code: "class A { foo(bar: string): void{} }",
 585             output: "class A { foo(bar: string): void {} }",
 586             parser: fixtureParser("space-before-blocks", "return-type-keyword-1"),
 587             errors: [expectedSpacingError]
 588         },
 589         {
 590             code: "function foo(): null {}",
 591             output: "function foo(): null{}",
 592             options: neverArgs,
 593             parser: fixtureParser("space-before-blocks", "return-type-keyword-2"),
 594             errors: [expectedNoSpacingError]
 595         },
 596
 597         // https://github.com/eslint/eslint/issues/15082 regression tests (only blocks after switch case colons should be excluded)
 598         {
 599             code: "label:{}",
 600             output: "label: {}",
 601             options: alwaysArgs,
 602             errors: [expectedSpacingError]
 603         },
 604         {
 605             code: "label: {}",
 606             output: "label:{}",
 607             options: neverArgs,
 608             errors: [expectedNoSpacingError]
 609         },
 610         {
 611             code: "switch(x) { case 9: label:{ break; } }",
 612             output: "switch(x) { case 9: label: { break; } }",
 613             options: alwaysArgs,
 614             errors: [expectedSpacingError]
 615         },
 616         {
 617             code: "switch(x){ case 9: label: { break; } }",
 618             output: "switch(x){ case 9: label:{ break; } }",
 619             options: neverArgs,
 620             errors: [expectedNoSpacingError]
 621         },
 622         {
 623             code: "switch(x) { case 9: if(y){ break; } }",
 624             output: "switch(x) { case 9: if(y) { break; } }",
 625             options: alwaysArgs,
 626             errors: [expectedSpacingError]
 627         },
 628         {
 629             code: "switch(x){ case 9: if(y) { break; } }",
 630             output: "switch(x){ case 9: if(y){ break; } }",
 631             options: neverArgs,
 632             errors: [expectedNoSpacingError]
 633         },
 634         {
 635             code: "switch(x) { case 9: y;{ break; } }",
 636             output: "switch(x) { case 9: y; { break; } }",
 637             options: alwaysArgs,
 638             errors: [expectedSpacingError]
 639         },
 640         {
 641             code: "switch(x){ case 9: y; { break; } }",
 642             output: "switch(x){ case 9: y;{ break; } }",
 643             options: neverArgs,
 644             errors: [expectedNoSpacingError]
 645         },
 646         {
 647             code: "switch(x) { case 9: switch(y){} }",
 648             output: "switch(x) { case 9: switch(y) {} }",
 649             options: alwaysArgs,
 650             errors: [expectedSpacingError]
 651         },
 652         {
 653             code: "switch(x){ case 9: switch(y) {} }",
 654             output: "switch(x){ case 9: switch(y){} }",
 655             options: neverArgs,
 656             errors: [expectedNoSpacingError]
 657         }
 658     ]
 659 });