text: /**
   * @fileoverview This option sets a specific tab width for your code
   * @author Dmitriy Shekhovtsov
   * @author Gyandeep Singh
   */
  "use strict";
  
  //------------------------------------------------------------------------------
  // Requirements
  //------------------------------------------------------------------------------
  
  const rule = require("../../../lib/rules/indent"),
      RuleTester = require("../../../lib/testers/rule-tester");
  const fs = require("fs");
  const path = require("path");
  
  //------------------------------------------------------------------------------
  // Tests
  //------------------------------------------------------------------------------
  
  const fixture = fs.readFileSync(path.join(__dirname, "../../fixtures/rules/indent/indent-invalid-fixture-1.js"), "utf8");
  const fixedFixture = fs.readFileSync(path.join(__dirname, "../../fixtures/rules/indent/indent-valid-fixture-1.js"), "utf8");
  const parser = require("../../fixtures/fixture-parser");
  
  /**
   * Create error message object for failure cases with a single 'found' indentation type
   * @param {string} indentType indent type of string or tab
   * @param {array} errors error info
   * @returns {Object} returns the error messages collection
   * @private
   */
  function expectedErrors(indentType, errors) {
      if (Array.isArray(indentType)) {
          errors = indentType;
          indentType = "space";
      }
  
      if (!errors[0].length) {
          errors = [errors];
      }
  
      return errors.map(err => {
          let message;
  
          if (typeof err[1] === "string" && typeof err[2] === "string") {
              message = `Expected indentation of ${err[1]} but found ${err[2]}.`;
          } else {
              const chars = indentType + (err[1] === 1 ? "" : "s");
  
              message = `Expected indentation of ${err[1]} ${chars} but found ${err[2]}.`;
          }
          return { message, type: err[3], line: err[0], endLine: err[0], column: 1, endColumn: parseInt(err[2], 10) + 1 };
      });
  }
  
  /**
   * Prevents leading spaces in a multiline template literal from appearing in the resulting string
   * @param {string[]} strings The strings in the template literal
   * @returns {string} The template literal, with spaces removed from all lines
   */
  function unIndent(strings) {
      const templateValue = strings[0];
      const lines = templateValue.replace(/^\n/, "").replace(/\n\s*$/, "").split("\n");
      const lineIndents = lines.filter(line => line.trim()).map(line => line.match(/ */)[0].length);
      const minLineIndent = Math.min.apply(null, lineIndents);
  
      return lines.map(line => line.slice(minLineIndent)).join("\n");
  }
  
  const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 8, ecmaFeatures: { jsx: true } } });
  
  ruleTester.run("indent", rule, {
      valid: [
          {
              code: unIndent`
                  bridge.callHandler(
                    'getAppVersion', 'test23', function(responseData) {
                      window.ah.mobileAppVersion = responseData;
                    }
                  );
              `,
              options: [2]
          },
          {
              code: unIndent`
                  bridge.callHandler(
                    'getAppVersion', 'test23', function(responseData) {
                      window.ah.mobileAppVersion = responseData;
                    });
              `,
              options: [2]
          },
          {
              code: unIndent`
                  bridge.callHandler(
                    'getAppVersion',
                    null,
                    function responseCallback(responseData) {
                      window.ah.mobileAppVersion = responseData;
                    }
                  );
              `,
              options: [2]
          },
          {
              code: unIndent`
                  bridge.callHandler(
                    'getAppVersion',
                    null,
                    function responseCallback(responseData) {
                      window.ah.mobileAppVersion = responseData;
                    });
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function doStuff(keys) {
                      _.forEach(
                          keys,
                          key => {
                              doSomething(key);
                          }
                      );
                  }
              `,
              options: [4]
          },
          {
              code: unIndent`
                  example(
                      function () {
                          console.log('example');
                      }
                  );
              `,
              options: [4]
          },
          {
              code: unIndent`
                  let foo = somethingList
                      .filter(x => {
                          return x;
                      })
                      .map(x => {
                          return 100 * x;
                      });
              `,
              options: [4]
          },
          {
              code: unIndent`
                  var x = 0 &&
                      {
                          a: 1,
                          b: 2
                      };
              `,
              options: [4]
          },
          {
              code: unIndent`
                  var x = 0 &&
                  \t{
                  \t\ta: 1,
                  \t\tb: 2
                  \t};
              `,
              options: ["tab"]
          },
          {
              code: unIndent`
                  var x = 0 &&
                      {
                          a: 1,
                          b: 2
                      }||
                      {
                          c: 3,
                          d: 4
                      };
              `,
              options: [4]
          },
          {
              code: unIndent`
                  var x = [
                      'a',
                      'b',
                      'c'
                  ];
              `,
              options: [4]
          },
          {
              code: unIndent`
                  var x = ['a',
                      'b',
                      'c',
                  ];
              `,
              options: [4]
          },
          {
              code: "var x = 0 && 1;",
              options: [4]
          },
          {
              code: "var x = 0 && { a: 1, b: 2 };",
              options: [4]
          },
          {
              code: unIndent`
                  var x = 0 &&
                      (
                          1
                      );
              `,
              options: [4]
          },
          {
              code: unIndent`
                  require('http').request({hostname: 'localhost',
                    port: 80}, function(res) {
                    res.end();
                  });
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function test() {
                    return client.signUp(email, PASSWORD, { preVerified: true })
                      .then(function (result) {
                        // hi
                      })
                      .then(function () {
                        return FunctionalHelpers.clearBrowserState(self, {
                          contentServer: true,
                          contentServer1: true
                        });
                      });
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  it('should... some lengthy test description that is forced to be' +
                    'wrapped into two lines since the line length limit is set', () => {
                    expect(true).toBe(true);
                  });
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function test() {
                      return client.signUp(email, PASSWORD, { preVerified: true })
                          .then(function (result) {
                              var x = 1;
                              var y = 1;
                          }, function(err){
                              var o = 1 - 2;
                              var y = 1 - 2;
                              return true;
                          })
                  }
              `,
              options: [4]
          },
          {
              code: unIndent`
                  function test() {
                      return client.signUp(email, PASSWORD, { preVerified: true })
                      .then(function (result) {
                          var x = 1;
                          var y = 1;
                      }, function(err){
                          var o = 1 - 2;
                          var y = 1 - 2;
                          return true;
                      });
                  }
              `,
              options: [4, { MemberExpression: 0 }]
          },
  
          {
              code: "// hi",
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var Command = function() {
                    var fileList = [],
                        files = []
  
                    files.concat(fileList)
                  };
              `,
              options: [2, { VariableDeclarator: { var: 2, let: 2, const: 3 } }]
          },
          {
              code: "  ",
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  if(data) {
                    console.log('hi');
                    b = true;};
              `,
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  foo = () => {
                    console.log('hi');
                    return true;};
              `,
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  function test(data) {
                    console.log('hi');
                    return true;};
              `,
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var test = function(data) {
                    console.log('hi');
                  };
              `,
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  arr.forEach(function(data) {
                    otherdata.forEach(function(zero) {
                      console.log('hi');
                    }) });
              `,
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  a = [
                      ,3
                  ]
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  [
                    ['gzip', 'gunzip'],
                    ['gzip', 'unzip'],
                    ['deflate', 'inflate'],
                    ['deflateRaw', 'inflateRaw'],
                  ].forEach(function(method) {
                    console.log(method);
                  });
              `,
              options: [2, { SwitchCase: 1, VariableDeclarator: 2 }]
          },
          {
              code: unIndent`
                  test(123, {
                      bye: {
                          hi: [1,
                              {
                                  b: 2
                              }
                          ]
                      }
                  });
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var xyz = 2,
                      lmn = [
                          {
                              a: 1
                          }
                      ];
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  lmnn = [{
                      a: 1
                  },
                  {
                      b: 2
                  }, {
                      x: 2
                  }];
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          unIndent`
              [{
                  foo: 1
              }, {
                  foo: 2
              }, {
                  foo: 3
              }]
          `,
          unIndent`
              foo([
                  bar
              ], [
                  baz
              ], [
                  qux
              ]);
          `,
          {
              code: unIndent`
                  abc({
                      test: [
                          [
                              c,
                              xyz,
                              2
                          ].join(',')
                      ]
                  });
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  abc = {
                    test: [
                      [
                        c,
                        xyz,
                        2
                      ]
                    ]
                  };
              `,
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  abc(
                    {
                      a: 1,
                      b: 2
                    }
                  );
              `,
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  abc({
                      a: 1,
                      b: 2
                  });
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var abc =
                    [
                      c,
                      xyz,
                      {
                        a: 1,
                        b: 2
                      }
                    ];
              `,
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var abc = [
                    c,
                    xyz,
                    {
                      a: 1,
                      b: 2
                    }
                  ];
              `,
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var abc = 5,
                      c = 2,
                      xyz =
                      {
                        a: 1,
                        b: 2
                      };
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          unIndent`
              var
                  x = {
                      a: 1,
                  },
                  y = {
                      b: 2
                  }
          `,
          unIndent`
              const
                  x = {
                      a: 1,
                  },
                  y = {
                      b: 2
                  }
          `,
          unIndent`
              let
                  x = {
                      a: 1,
                  },
                  y = {
                      b: 2
                  }
          `,
          unIndent`
              var foo = { a: 1 }, bar = {
                  b: 2
              };
          `,
          unIndent`
              var foo = { a: 1 }, bar = {
                      b: 2
                  },
                  baz = {
                      c: 3
                  }
          `,
          unIndent`
              const {
                      foo
                  } = 1,
                  bar = 2
          `,
          {
              code: unIndent`
                  var foo = 1,
                    bar =
                      2
              `,
              options: [2, { VariableDeclarator: 1 }]
          },
          {
              code: unIndent`
                  var foo = 1,
                    bar
                      = 2
              `,
              options: [2, { VariableDeclarator: 1 }]
          },
          {
              code: unIndent`
                  var foo
                    = 1,
                    bar
                      = 2
              `,
              options: [2, { VariableDeclarator: 1 }]
          },
          {
              code: unIndent`
                  var foo
                    =
                    1,
                    bar
                      =
                      2
              `,
              options: [2, { VariableDeclarator: 1 }]
          },
          {
              code: unIndent`
                  var foo
                    = (1),
                    bar
                      = (2)
              `,
              options: [2, { VariableDeclarator: 1 }]
          },
          {
              code: unIndent`
                  var foo = 1,
                      bar = 2,
                      baz = 3
                  ;
              `,
              options: [2, { VariableDeclarator: { var: 2 } }]
          },
          {
              code: unIndent`
                  var foo = 1,
                      bar = 2,
                      baz = 3
                      ;
              `,
              options: [2, { VariableDeclarator: { var: 2 } }]
          },
          {
              code: unIndent`
                  var abc =
                      {
                        a: 1,
                        b: 2
                      };
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var a = new abc({
                          a: 1,
                          b: 2
                      }),
                      b = 2;
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var a = 2,
                    c = {
                      a: 1,
                      b: 2
                    },
                    b = 2;
              `,
              options: [2, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var x = 2,
                      y = {
                        a: 1,
                        b: 2
                      },
                      b = 2;
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var e = {
                        a: 1,
                        b: 2
                      },
                      b = 2;
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var a = {
                    a: 1,
                    b: 2
                  };
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  function test() {
                    if (true ||
                              false){
                      console.log(val);
                    }
                  }
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          unIndent`
              var foo = bar ||
                  !(
                      baz
                  );
          `,
          unIndent`
              for (var foo = 1;
                  foo < 10;
                  foo++) {}
          `,
          unIndent`
              for (
                  var foo = 1;
                  foo < 10;
                  foo++
              ) {}
          `,
          {
              code: unIndent`
                  for (var val in obj)
                    if (true)
                      console.log(val);
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  if(true)
                    if (true)
                      if (true)
                        console.log(val);
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  function hi(){     var a = 1;
                    y++;                   x++;
                  }
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  for(;length > index; index++)if(NO_HOLES || index in self){
                    x++;
                  }
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  function test(){
                    switch(length){
                      case 1: return function(a){
                        return fn.call(that, a);
                      };
                    }
                  }
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var geometry = 2,
                  rotate = 2;
              `,
              options: [2, { VariableDeclarator: 0 }]
          },
          {
              code: unIndent`
                  var geometry,
                      rotate;
              `,
              options: [4, { VariableDeclarator: 1 }]
          },
          {
              code: unIndent`
                  var geometry,
                  \trotate;
              `,
              options: ["tab", { VariableDeclarator: 1 }]
          },
          {
              code: unIndent`
                  var geometry,
                    rotate;
              `,
              options: [2, { VariableDeclarator: 1 }]
          },
          {
              code: unIndent`
                  var geometry,
                      rotate;
              `,
              options: [2, { VariableDeclarator: 2 }]
          },
          {
              code: unIndent`
                  let geometry,
                      rotate;
              `,
              options: [2, { VariableDeclarator: 2 }]
          },
          {
              code: unIndent`
                  const geometry = 2,
                      rotate = 3;
              `,
              options: [2, { VariableDeclarator: 2 }]
          },
          {
              code: unIndent`
                  var geometry, box, face1, face2, colorT, colorB, sprite, padding, maxWidth,
                    height, rotate;
              `,
              options: [2, { SwitchCase: 1 }]
          },
          {
              code: "var geometry, box, face1, face2, colorT, colorB, sprite, padding, maxWidth;",
              options: [2, { SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  if (1 < 2){
                  //hi sd
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  while (1 < 2){
                    //hi sd
                  }
              `,
              options: [2]
          },
          {
              code: "while (1 < 2) console.log('hi');",
              options: [2]
          },
  
          {
              code: unIndent`
                  [a, boop,
                      c].forEach((index) => {
                      index;
                  });
              `,
              options: [4]
          },
          {
              code: unIndent`
                  [a, b,
                      c].forEach(function(index){
                      return index;
                  });
              `,
              options: [4]
          },
          {
              code: unIndent`
                  [a, b, c].forEach((index) => {
                      index;
                  });
              `,
              options: [4]
          },
          {
              code: unIndent`
                  [a, b, c].forEach(function(index){
                      return index;
                  });
              `,
              options: [4]
          },
          {
              code: unIndent`
                  (foo)
                      .bar([
                          baz
                      ]);
              `,
              options: [4, { MemberExpression: 1 }]
          },
          {
              code: unIndent`
                  switch (x) {
                      case "foo":
                          a();
                          break;
                      case "bar":
                          switch (y) {
                              case "1":
                                  break;
                              case "2":
                                  a = 6;
                                  break;
                          }
                      case "test":
                          break;
                  }
              `,
              options: [4, { SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  switch (x) {
                          case "foo":
                              a();
                              break;
                          case "bar":
                              switch (y) {
                                      case "1":
                                          break;
                                      case "2":
                                          a = 6;
                                          break;
                              }
                          case "test":
                              break;
                  }
              `,
              options: [4, { SwitchCase: 2 }]
          },
          unIndent`
              switch (a) {
              case "foo":
                  a();
                  break;
              case "bar":
                  switch(x){
                  case '1':
                      break;
                  case '2':
                      a = 6;
                      break;
                  }
              }
          `,
          unIndent`
              switch (a) {
              case "foo":
                  a();
                  break;
              case "bar":
                  if(x){
                      a = 2;
                  }
                  else{
                      a = 6;
                  }
              }
          `,
          unIndent`
              switch (a) {
              case "foo":
                  a();
                  break;
              case "bar":
                  if(x){
                      a = 2;
                  }
                  else
                      a = 6;
              }
          `,
          unIndent`
              switch (a) {
              case "foo":
                  a();
                  break;
              case "bar":
                  a(); break;
              case "baz":
                  a(); break;
              }
          `,
          unIndent`
              switch (0) {
              }
          `,
          unIndent`
              function foo() {
                  var a = "a";
                  switch(a) {
                  case "a":
                      return "A";
                  case "b":
                      return "B";
                  }
              }
              foo();
          `,
          {
              code: unIndent`
                  switch(value){
                      case "1":
                      case "2":
                          a();
                          break;
                      default:
                          a();
                          break;
                  }
                  switch(value){
                      case "1":
                          a();
                          break;
                      case "2":
                          break;
                      default:
                          break;
                  }
              `,
              options: [4, { SwitchCase: 1 }]
          },
          unIndent`
              var obj = {foo: 1, bar: 2};
              with (obj) {
                  console.log(foo + bar);
              }
          `,
          unIndent`
              if (a) {
                  (1 + 2 + 3); // no error on this line
              }
          `,
          "switch(value){ default: a(); break; }",
          {
              code: unIndent`
                  import {addons} from 'react/addons'
                  import React from 'react'
              `,
              options: [2],
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  import {
                      foo,
                      bar,
                      baz
                  } from 'qux';
              `,
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  export {
                      foo,
                      bar,
                      baz
                  } from 'qux';
              `,
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  var a = 1,
                      b = 2,
                      c = 3;
              `,
              options: [4]
          },
          {
              code: unIndent`
                  var a = 1
                      ,b = 2
                      ,c = 3;
              `,
              options: [4]
          },
          {
              code: "while (1 < 2) console.log('hi')",
              options: [2]
          },
          {
              code: unIndent`
                  function salutation () {
                    switch (1) {
                      case 0: return console.log('hi')
                      case 1: return console.log('hey')
                    }
                  }
              `,
              options: [2, { SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var items = [
                    {
                      foo: 'bar'
                    }
                  ];
              `,
              options: [2, { VariableDeclarator: 2 }]
          },
          {
              code: unIndent`
                  const a = 1,
                        b = 2;
                  const items1 = [
                    {
                      foo: 'bar'
                    }
                  ];
                  const items2 = Items(
                    {
                      foo: 'bar'
                    }
                  );
              `,
              options: [2, { VariableDeclarator: 3 }]
  
          },
          {
              code: unIndent`
                  const geometry = 2,
                        rotate = 3;
                  var a = 1,
                    b = 2;
                  let light = true,
                      shadow = false;
              `,
              options: [2, { VariableDeclarator: { const: 3, let: 2 } }]
          },
          {
              code: unIndent`
                  const abc = 5,
                        c = 2,
                        xyz =
                        {
                          a: 1,
                          b: 2
                        };
                  let abc2 = 5,
                    c2 = 2,
                    xyz2 =
                    {
                      a: 1,
                      b: 2
                    };
                  var abc3 = 5,
                      c3 = 2,
                      xyz3 =
                      {
                        a: 1,
                        b: 2
                      };
              `,
              options: [2, { VariableDeclarator: { var: 2, const: 3 }, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  module.exports = {
                    'Unit tests':
                    {
                      rootPath: './',
                      environment: 'node',
                      tests:
                      [
                        'test/test-*.js'
                      ],
                      sources:
                      [
                        '*.js',
                        'test/**.js'
                      ]
                    }
                  };
              `,
              options: [2]
          },
          {
              code: unIndent`
                  foo =
                    bar;
              `,
              options: [2]
          },
          {
              code: unIndent`
                  foo = (
                    bar
                  );
              `,
              options: [2]
          },
          {
              code: unIndent`
                  var path     = require('path')
                    , crypto    = require('crypto')
                    ;
              `,
              options: [2]
          },
          unIndent`
              var a = 1
                  ,b = 2
                  ;
          `,
          {
              code: unIndent`
                  export function create (some,
                                          argument) {
                    return Object.create({
                      a: some,
                      b: argument
                    });
                  };
              `,
              options: [2, { FunctionDeclaration: { parameters: "first" } }],
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  export function create (id, xfilter, rawType,
                                          width=defaultWidth, height=defaultHeight,
                                          footerHeight=defaultFooterHeight,
                                          padding=defaultPadding) {
                    // ... function body, indented two spaces
                  }
              `,
              options: [2, { FunctionDeclaration: { parameters: "first" } }],
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  var obj = {
                    foo: function () {
                      return new p()
                        .then(function (ok) {
                          return ok;
                        }, function () {
                          // ignore things
                        });
                    }
                  };
              `,
              options: [2]
          },
          {
              code: unIndent`
                  a.b()
                    .c(function(){
                      var a;
                    }).d.e;
              `,
              options: [2]
          },
          {
              code: unIndent`
                  const YO = 'bah',
                        TE = 'mah'
  
                  var res,
                      a = 5,
                      b = 4
              `,
              options: [2, { VariableDeclarator: { var: 2, let: 2, const: 3 } }]
          },
          {
              code: unIndent`
                  const YO = 'bah',
                        TE = 'mah'
  
                  var res,
                      a = 5,
                      b = 4
  
                  if (YO) console.log(TE)
              `,
              options: [2, { VariableDeclarator: { var: 2, let: 2, const: 3 } }]
          },
          {
              code: unIndent`
                  var foo = 'foo',
                    bar = 'bar',
                    baz = function() {
  
                    }
  
                  function hello () {
  
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  var obj = {
                    send: function () {
                      return P.resolve({
                        type: 'POST'
                      })
                        .then(function () {
                          return true;
                        }, function () {
                          return false;
                        });
                    }
                  };
              `,
              options: [2]
          },
          {
              code: unIndent`
                  var obj = {
                    send: function () {
                      return P.resolve({
                        type: 'POST'
                      })
                      .then(function () {
                        return true;
                      }, function () {
                        return false;
                      });
                    }
                  };
              `,
              options: [2, { MemberExpression: 0 }]
          },
          unIndent`
              const someOtherFunction = argument => {
                      console.log(argument);
                  },
                  someOtherValue = 'someOtherValue';
          `,
          {
              code: unIndent`
                  [
                    'a',
                    'b'
                  ].sort().should.deepEqual([
                    'x',
                    'y'
                  ]);
              `,
              options: [2]
          },
          {
              code: unIndent`
                  var a = 1,
                      B = class {
                        constructor(){}
                        a(){}
                        get b(){}
                      };
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var a = 1,
                      B =
                      class {
                        constructor(){}
                        a(){}
                        get b(){}
                      },
                      c = 3;
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  class A{
                      constructor(){}
                      a(){}
                      get b(){}
                  }
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var A = class {
                      constructor(){}
                      a(){}
                      get b(){}
                  }
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var a = {
                    some: 1
                    , name: 2
                  };
              `,
              options: [2]
          },
          {
              code: unIndent`
                  a.c = {
                      aa: function() {
                          'test1';
                          return 'aa';
                      }
                      , bb: function() {
                          return this.bb();
                      }
                  };
              `,
              options: [4]
          },
          {
              code: unIndent`
                  var a =
                  {
                      actions:
                      [
                          {
                              name: 'compile'
                          }
                      ]
                  };
              `,
              options: [4, { VariableDeclarator: 0, SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  var a =
                  [
                      {
                          name: 'compile'
                      }
                  ];
              `,
              options: [4, { VariableDeclarator: 0, SwitchCase: 1 }]
          },
          unIndent`
              [[
              ], function(
                  foo
              ) {}
              ]
          `,
          unIndent`
              define([
                  'foo'
              ], function(
                  bar
              ) {
                  baz;
              }
              )
          `,
          {
              code: unIndent`
                  const func = function (opts) {
                      return Promise.resolve()
                      .then(() => {
                          [
                              'ONE', 'TWO'
                          ].forEach(command => { doSomething(); });
                      });
                  };
              `,
              options: [4, { MemberExpression: 0 }]
          },
          {
              code: unIndent`
                  const func = function (opts) {
                      return Promise.resolve()
                          .then(() => {
                              [
                                  'ONE', 'TWO'
                              ].forEach(command => { doSomething(); });
                          });
                  };
              `,
              options: [4]
          },
          {
              code: unIndent`
                  var haveFun = function () {
                      SillyFunction(
                          {
                              value: true,
                          },
                          {
                              _id: true,
                          }
                      );
                  };
              `,
              options: [4]
          },
          {
              code: unIndent`
                  var haveFun = function () {
                      new SillyFunction(
                          {
                              value: true,
                          },
                          {
                              _id: true,
                          }
                      );
                  };
              `,
              options: [4]
          },
          {
              code: unIndent`
                  let object1 = {
                    doThing() {
                      return _.chain([])
                        .map(v => (
                          {
                            value: true,
                          }
                        ))
                        .value();
                    }
                  };
              `,
              options: [2]
          },
          {
              code: unIndent`
                  var foo = {
                      bar: 1,
                      baz: {
                        qux: 2
                      }
                    },
                    bar = 1;
              `,
              options: [2]
          },
          {
              code: unIndent`
                  class Foo
                    extends Bar {
                    baz() {}
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  class Foo extends
                    Bar {
                    baz() {}
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  class Foo extends
                    (
                      Bar
                    ) {
                    baz() {}
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  fs.readdirSync(path.join(__dirname, '../rules')).forEach(name => {
                    files[name] = foo;
                  });
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  (function(){
                  function foo(x) {
                    return x + 1;
                  }
                  })();
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  (function(){
                          function foo(x) {
                              return x + 1;
                          }
                  })();
              `,
              options: [4, { outerIIFEBody: 2 }]
          },
          {
              code: unIndent`
                  (function(x, y){
                  function foo(x) {
                    return x + 1;
                  }
                  })(1, 2);
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  (function(){
                  function foo(x) {
                    return x + 1;
                  }
                  }());
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  !function(){
                  function foo(x) {
                    return x + 1;
                  }
                  }();
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  !function(){
                  \t\t\tfunction foo(x) {
                  \t\t\t\treturn x + 1;
                  \t\t\t}
                  }();
              `,
              options: ["tab", { outerIIFEBody: 3 }]
          },
          {
              code: unIndent`
                  var out = function(){
                    function fooVar(x) {
                      return x + 1;
                    }
                  };
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  var ns = function(){
                  function fooVar(x) {
                    return x + 1;
                  }
                  }();
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  ns = function(){
                  function fooVar(x) {
                    return x + 1;
                  }
                  }();
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  var ns = (function(){
                  function fooVar(x) {
                    return x + 1;
                  }
                  }(x));
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  var ns = (function(){
                          function fooVar(x) {
                              return x + 1;
                          }
                  }(x));
              `,
              options: [4, { outerIIFEBody: 2 }]
          },
          {
              code: unIndent`
                  var obj = {
                    foo: function() {
                      return true;
                    }
                  };
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  while (
                    function() {
                      return true;
                    }()) {
  
                    x = x + 1;
                  };
              `,
              options: [2, { outerIIFEBody: 20 }]
          },
          {
              code: unIndent`
                  (() => {
                  function foo(x) {
                    return x + 1;
                  }
                  })();
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  function foo() {
                  }
              `,
              options: ["tab", { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  ;(() => {
                  function foo(x) {
                    return x + 1;
                  }
                  })();
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: unIndent`
                  if(data) {
                    console.log('hi');
                  }
              `,
              options: [2, { outerIIFEBody: 0 }]
          },
          {
              code: "Buffer.length",
              options: [4, { MemberExpression: 1 }]
          },
          {
              code: unIndent`
                  Buffer
                      .indexOf('a')
                      .toString()
              `,
              options: [4, { MemberExpression: 1 }]
          },
          {
              code: unIndent`
                  Buffer.
                      length
              `,
              options: [4, { MemberExpression: 1 }]
          },
          {
              code: unIndent`
                  Buffer
                      .foo
                      .bar
              `,
              options: [4, { MemberExpression: 1 }]
          },
          {
              code: unIndent`
                  Buffer
                  \t.foo
                  \t.bar
              `,
              options: ["tab", { MemberExpression: 1 }]
          },
          {
              code: unIndent`
                  Buffer
                      .foo
                      .bar
              `,
              options: [2, { MemberExpression: 2 }]
          },
          unIndent`
              (
                  foo
                      .bar
              )
          `,
          unIndent`
              (
                  (
                      foo
                          .bar
                  )
              )
          `,
          unIndent`
              (
                  foo
              )
                  .bar
          `,
          unIndent`
              (
                  (
                      foo
                  )
                      .bar
              )
          `,
          unIndent`
              (
                  (
                      foo
                  )
                      [
                          (
                              bar
                          )
                      ]
              )
          `,
          unIndent`
              (
                  foo[bar]
              )
                  .baz
          `,
          unIndent`
              (
                  (foo.bar)
              )
                  .baz
          `,
          {
              code: unIndent`
                  MemberExpression
                  .can
                    .be
                      .turned
                   .off();
              `,
              options: [4, { MemberExpression: "off" }]
          },
          {
              code: unIndent`
                  foo = bar.baz()
                      .bip();
              `,
              options: [4, { MemberExpression: 1 }]
          },
          unIndent`
              function foo() {
                  new
                      .target
              }
          `,
          unIndent`
              function foo() {
                  new.
                      target
              }
          `,
          {
              code: unIndent`
                  if (foo) {
                    bar();
                  } else if (baz) {
                    foobar();
                  } else if (qux) {
                    qux();
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function foo(aaa,
                    bbb, ccc, ddd) {
                      bar();
                  }
              `,
              options: [2, { FunctionDeclaration: { parameters: 1, body: 2 } }]
          },
          {
              code: unIndent`
                  function foo(aaa, bbb,
                        ccc, ddd) {
                    bar();
                  }
              `,
              options: [2, { FunctionDeclaration: { parameters: 3, body: 1 } }]
          },
          {
              code: unIndent`
                  function foo(aaa,
                      bbb,
                      ccc) {
                              bar();
                  }
              `,
              options: [4, { FunctionDeclaration: { parameters: 1, body: 3 } }]
          },
          {
              code: unIndent`
                  function foo(aaa,
                               bbb, ccc,
                               ddd, eee, fff) {
                    bar();
                  }
              `,
              options: [2, { FunctionDeclaration: { parameters: "first", body: 1 } }]
          },
          {
              code: unIndent`
                  function foo(aaa, bbb)
                  {
                        bar();
                  }
              `,
              options: [2, { FunctionDeclaration: { body: 3 } }]
          },
          {
              code: unIndent`
                  function foo(
                    aaa,
                    bbb) {
                      bar();
                  }
              `,
              options: [2, { FunctionDeclaration: { parameters: "first", body: 2 } }]
          },
          {
              code: unIndent`
                  var foo = function(aaa,
                      bbb,
                      ccc,
                      ddd) {
                  bar();
                  }
              `,
              options: [2, { FunctionExpression: { parameters: 2, body: 0 } }]
          },
          {
              code: unIndent`
                  var foo = function(aaa,
                    bbb,
                    ccc) {
                                      bar();
                  }
              `,
              options: [2, { FunctionExpression: { parameters: 1, body: 10 } }]
          },
          {
              code: unIndent`
                  var foo = function(aaa,
                                     bbb, ccc, ddd,
                                     eee, fff) {
                      bar();
                  }
              `,
              options: [4, { FunctionExpression: { parameters: "first", body: 1 } }]
          },
          {
              code: unIndent`
                  var foo = function(
                    aaa, bbb, ccc,
                    ddd, eee) {
                        bar();
                  }
              `,
              options: [2, { FunctionExpression: { parameters: "first", body: 3 } }]
          },
          {
              code: unIndent`
                  foo.bar(
                        baz, qux, function() {
                              qux;
                        }
                  );
              `,
              options: [2, { FunctionExpression: { body: 3 }, CallExpression: { arguments: 3 } }]
          },
          {
              code: unIndent`
                  function foo() {
                    bar();
                    \tbaz();
                  \t   \t\t\t  \t\t\t  \t   \tqux();
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function foo() {
                    function bar() {
                      baz();
                    }
                  }
              `,
              options: [2, { FunctionDeclaration: { body: 1 } }]
          },
          {
              code: unIndent`
                  function foo() {
                    bar();
                     \t\t}
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function foo() {
                    function bar(baz,
                        qux) {
                      foobar();
                    }
                  }
              `,
              options: [2, { FunctionDeclaration: { body: 1, parameters: 2 } }]
          },
          {
              code: unIndent`
                  ((
                      foo
                  ))
              `,
              options: [4]
          },
  
          // ternary expressions (https://github.com/eslint/eslint/issues/7420)
          {
              code: unIndent`
                  foo
                    ? bar
                    : baz
              `,
              options: [2]
          },
          {
              code: unIndent`
                  foo = (bar ?
                    baz :
                    qux
                  );
              `,
              options: [2]
          },
          unIndent`
              [
                  foo ?
                      bar :
                      baz,
                  qux
              ];
          `,
          {
  
              /*
               * Checking comments:
               * https://github.com/eslint/eslint/issues/3845, https://github.com/eslint/eslint/issues/6571
               */
              code: unIndent`
                  foo();
                  // Line
                  /* multiline
                    Line */
                  bar();
                  // trailing comment
              `,
              options: [2]
          },
          {
              code: unIndent`
                  switch (foo) {
                    case bar:
                      baz();
                      // call the baz function
                  }
              `,
              options: [2, { SwitchCase: 1 }]
          },
          {
              code: unIndent`
                  switch (foo) {
                    case bar:
                      baz();
                    // no default
                  }
              `,
              options: [2, { SwitchCase: 1 }]
          },
          unIndent`
              [
                  // no elements
              ]
          `,
          {
  
              /*
               * Destructuring assignments:
               * https://github.com/eslint/eslint/issues/6813
               */
              code: unIndent`
                  var {
                    foo,
                    bar,
                    baz: qux,
                    foobar: baz = foobar
                  } = qux;
              `,
              options: [2]
          },
          {
              code: unIndent`
                  var [
                    foo,
                    bar,
                    baz,
                    foobar = baz
                  ] = qux;
              `,
              options: [2]
          },
          {
              code: unIndent`
                  const {
                    a
                  }
                  =
                  {
                    a: 1
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  const {
                    a
                  } = {
                    a: 1
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  const
                    {
                      a
                    } = {
                      a: 1
                    };
              `,
              options: [2]
          },
          {
              code: unIndent`
                  const
                    foo = {
                      bar: 1
                    }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  const [
                    a
                  ] = [
                    1
                  ]
              `,
              options: [2]
          },
          {
  
              // https://github.com/eslint/eslint/issues/7233
              code: unIndent`
                  var folder = filePath
                      .foo()
                      .bar;
              `,
              options: [2, { MemberExpression: 2 }]
          },
          {
              code: unIndent`
                  for (const foo of bar)
                    baz();
              `,
              options: [2]
          },
          {
              code: unIndent`
                  var x = () =>
                    5;
              `,
              options: [2]
          },
          unIndent`
              (
                  foo
              )(
                  bar
              )
          `,
          unIndent`
              (() =>
                  foo
              )(
                  bar
              )
          `,
          unIndent`
              (() => {
                  foo();
              })(
                  bar
              )
          `,
          {
  
              // Don't lint the indentation of the first token after a :
              code: unIndent`
                  ({code:
                    "foo.bar();"})
              `,
              options: [2]
          },
          {
  
              // Don't lint the indentation of the first token after a :
              code: unIndent`
                  ({code:
                  "foo.bar();"})
              `,
              options: [2]
          },
          unIndent`
              ({
                  foo:
                      bar
              })
          `,
          unIndent`
              ({
                  [foo]:
                      bar
              })
          `,
          {
  
              // Comments in switch cases
              code: unIndent`
                  switch (foo) {
                    // comment
                    case study:
                      // comment
                      bar();
                    case closed:
                      /* multiline comment
                      */
                  }
              `,
              options: [2, { SwitchCase: 1 }]
          },
          {
  
              // Comments in switch cases
              code: unIndent`
                  switch (foo) {
                    // comment
                    case study:
                    // the comment can also be here
                    case closed:
                  }
              `,
              options: [2, { SwitchCase: 1 }]
          },
          {
  
              // BinaryExpressions with parens
              code: unIndent`
                  foo && (
                      bar
                  )
              `,
              options: [4]
          },
          {
  
              // BinaryExpressions with parens
              code: unIndent`
                  foo && ((
                      bar
                  ))
              `,
              options: [4]
          },
          {
              code: unIndent`
                  foo &&
                      (
                          bar
                      )
              `,
              options: [4]
          },
          {
              code: unIndent`
                  foo =
                      bar;
              `,
              options: [4]
          },
          {
              code: unIndent`
                  function foo() {
                    var bar = function(baz,
                          qux) {
                      foobar();
                    };
                  }
              `,
              options: [2, { FunctionExpression: { parameters: 3 } }]
          },
          unIndent`
              function foo() {
                  return (bar === 1 || bar === 2 &&
                      (/Function/.test(grandparent.type))) &&
                      directives(parent).indexOf(node) >= 0;
              }
          `,
          {
              code: unIndent`
                  function foo() {
                      return (foo === bar || (
                          baz === qux && (
                              foo === foo ||
                              bar === bar ||
                              baz === baz
                          )
                      ))
                  }
              `,
              options: [4]
          },
          unIndent`
              if (
                  foo === 1 ||
                  bar === 1 ||
                  // comment
                  (baz === 1 && qux === 1)
              ) {}
          `,
          {
              code: unIndent`
                  foo =
                    (bar + baz);
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function foo() {
                    return (bar === 1 || bar === 2) &&
                      (z === 3 || z === 4);
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  /* comment */ if (foo) {
                    bar();
                  }
              `,
              options: [2]
          },
          {
  
              // Comments at the end of if blocks that have `else` blocks can either refer to the lines above or below them
              code: unIndent`
                  if (foo) {
                    bar();
                  // Otherwise, if foo is false, do baz.
                  // baz is very important.
                  } else {
                    baz();
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function foo() {
                    return ((bar === 1 || bar === 2) &&
                      (z === 3 || z === 4));
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  foo(
                    bar,
                    baz,
                    qux
                  );
              `,
              options: [2, { CallExpression: { arguments: 1 } }]
          },
          {
              code: unIndent`
                  foo(
                  \tbar,
                  \tbaz,
                  \tqux
                  );
              `,
              options: ["tab", { CallExpression: { arguments: 1 } }]
          },
          {
              code: unIndent`
                  foo(bar,
                          baz,
                          qux);
              `,
              options: [4, { CallExpression: { arguments: 2 } }]
          },
          {
              code: unIndent`
                  foo(
                  bar,
                  baz,
                  qux
                  );
              `,
              options: [2, { CallExpression: { arguments: 0 } }]
          },
          {
              code: unIndent`
                  foo(bar,
                      baz,
                      qux
                  );
              `,
              options: [2, { CallExpression: { arguments: "first" } }]
          },
          {
              code: unIndent`
                  foo(bar, baz,
                      qux, barbaz,
                      barqux, bazqux);
              `,
              options: [2, { CallExpression: { arguments: "first" } }]
          },
          {
              code: unIndent`
                  foo(bar,
                          1 + 2,
                          !baz,
                          new Car('!')
                  );
              `,
              options: [2, { CallExpression: { arguments: 4 } }]
          },
          unIndent`
              foo(
                  (bar)
              );
          `,
          {
              code: unIndent`
                  foo(
                      (bar)
                  );
              `,
              options: [4, { CallExpression: { arguments: 1 } }]
          },
  
          // https://github.com/eslint/eslint/issues/7484
          {
              code: unIndent`
                  var foo = function() {
                    return bar(
                      [{
                      }].concat(baz)
                    );
                  };
              `,
              options: [2]
          },
  
          // https://github.com/eslint/eslint/issues/7573
          {
              code: unIndent`
                  return (
                      foo
                  );
              `,
              parserOptions: { ecmaFeatures: { globalReturn: true } }
          },
          {
              code: unIndent`
                  return (
                      foo
                  )
              `,
              parserOptions: { ecmaFeatures: { globalReturn: true } }
          },
          unIndent`
              var foo = [
                  bar,
                  baz
              ]
          `,
          unIndent`
              var foo = [bar,
                  baz,
                  qux
              ]
          `,
          {
              code: unIndent`
                  var foo = [bar,
                  baz,
                  qux
                  ]
              `,
              options: [2, { ArrayExpression: 0 }]
          },
          {
              code: unIndent`
                  var foo = [bar,
                                  baz,
                                  qux
                  ]
              `,
              options: [2, { ArrayExpression: 8 }]
          },
          {
              code: unIndent`
                  var foo = [bar,
                             baz,
                             qux
                  ]
              `,
              options: [2, { ArrayExpression: "first" }]
          },
          {
              code: unIndent`
                  var foo = [bar,
                             baz, qux
                  ]
              `,
              options: [2, { ArrayExpression: "first" }]
          },
          {
              code: unIndent`
                  var foo = [
                          { bar: 1,
                            baz: 2 },
                          { bar: 3,
                            baz: 4 }
                  ]
              `,
              options: [4, { ArrayExpression: 2, ObjectExpression: "first" }]
          },
          {
              code: unIndent`
                  var foo = {
                  bar: 1,
                  baz: 2
                  };
              `,
              options: [2, { ObjectExpression: 0 }]
          },
          {
              code: unIndent`
                  var foo = { foo: 1, bar: 2,
                              baz: 3 }
              `,
              options: [2, { ObjectExpression: "first" }]
          },
          {
              code: unIndent`
                  var foo = [
                          {
                              foo: 1
                          }
                  ]
              `,
              options: [4, { ArrayExpression: 2 }]
          },
          {
              code: unIndent`
                  function foo() {
                    [
                            foo
                    ]
                  }
              `,
              options: [2, { ArrayExpression: 4 }]
          },
          {
              code: "[\n]",
              options: [2, { ArrayExpression: "first" }]
          },
          {
              code: "[\n]",
              options: [2, { ArrayExpression: 1 }]
          },
          {
              code: "{\n}",
              options: [2, { ObjectExpression: "first" }]
          },
          {
              code: "{\n}",
              options: [2, { ObjectExpression: 1 }]
          },
          {
              code: unIndent`
                  var foo = [
                    [
                      1
                    ]
                  ]
              `,
              options: [2, { ArrayExpression: "first" }]
          },
          {
              code: unIndent`
                  var foo = [ 1,
                              [
                                2
                              ]
                  ];
              `,
              options: [2, { ArrayExpression: "first" }]
          },
          {
              code: unIndent`
                  var foo = bar(1,
                                [ 2,
                                  3
                                ]
                  );
              `,
              options: [4, { ArrayExpression: "first", CallExpression: { arguments: "first" } }]
          },
          {
              code: unIndent`
                  var foo =
                      [
                      ]()
              `,
              options: [4, { CallExpression: { arguments: "first" }, ArrayExpression: "first" }]
          },
  
          // https://github.com/eslint/eslint/issues/7732
          {
              code: unIndent`
                  const lambda = foo => {
                    Object.assign({},
                      filterName,
                      {
                        display
                      }
                    );
                  }
              `,
              options: [2, { ObjectExpression: 1 }]
          },
          {
              code: unIndent`
                  const lambda = foo => {
                    Object.assign({},
                      filterName,
                      {
                        display
                      }
                    );
                  }
              `,
              options: [2, { ObjectExpression: "first" }]
          },
  
          // https://github.com/eslint/eslint/issues/7733
          {
              code: unIndent`
                  var foo = function() {
                  \twindow.foo('foo',
                  \t\t{
                  \t\t\tfoo: 'bar',
                  \t\t\tbar: {
                  \t\t\t\tfoo: 'bar'
                  \t\t\t}
                  \t\t}
                  \t);
                  }
              `,
              options: ["tab"]
          },
          {
              code: unIndent`
                  echo = spawn('cmd.exe',
                               ['foo', 'bar',
                                'baz']);
              `,
              options: [2, { ArrayExpression: "first", CallExpression: { arguments: "first" } }]
          },
          {
              code: unIndent`
                  if (foo)
                    bar();
                  // Otherwise, if foo is false, do baz.
                  // baz is very important.
                  else {
                    baz();
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  if (
                      foo && bar ||
                      baz && qux // This line is ignored because BinaryExpressions are not checked.
                  ) {
                      qux();
                  }
              `,
              options: [4]
          },
          unIndent`
              [
              ] || [
              ]
          `,
          unIndent`
              (
                  [
                  ] || [
                  ]
              )
          `,
          unIndent`
              1
              + (
                  1
              )
          `,
          unIndent`
              (
                  foo && (
                      bar ||
                      baz
                  )
              )
          `,
          unIndent`
              foo
                  || (
                      bar
                  )
          `,
          unIndent`
              foo
                              || (
                                  bar
                              )
          `,
          {
              code: unIndent`
                  var foo =
                          1;
              `,
              options: [4, { VariableDeclarator: 2 }]
          },
          {
              code: unIndent`
                  var foo = 1,
                      bar =
                      2;
              `,
              options: [4]
          },
          {
              code: unIndent`
                  switch (foo) {
                    case bar:
                    {
                      baz();
                    }
                  }
              `,
              options: [2, { SwitchCase: 1 }]
          },
  
          // Template curlies
          {
              code: unIndent`
                  \`foo\${
                    bar}\`
              `,
              options: [2]
          },
          {
              code: unIndent`
                  \`foo\${
                    \`bar\${
                      baz}\`}\`
              `,
              options: [2]
          },
          {
              code: unIndent`
                  \`foo\${
                    \`bar\${
                      baz
                    }\`
                  }\`
              `,
              options: [2]
          },
          {
              code: unIndent`
                  \`foo\${
                    (
                      bar
                    )
                  }\`
              `,
              options: [2]
          },
          unIndent`
              foo(\`
                  bar
              \`, {
                  baz: 1
              });
          `,
          unIndent`
              function foo() {
                  \`foo\${bar}baz\${
                      qux}foo\${
                      bar}baz\`
              }
          `,
          unIndent`
              JSON
                  .stringify(
                      {
                          ok: true
                      }
                  );
          `,
  
          // Don't check AssignmentExpression assignments
          unIndent`
              foo =
                  bar =
                  baz;
          `,
          unIndent`
              foo =
              bar =
                  baz;
          `,
          unIndent`
              function foo() {
                  const template = \`this indentation is not checked
              because it's part of a template literal.\`;
              }
          `,
          unIndent`
                  function foo() {
                      const template = \`the indentation of a \${
                          node.type
                      } node is checked.\`;
                  }
              `,
          {
  
              // https://github.com/eslint/eslint/issues/7320
              code: unIndent`
                  JSON
                      .stringify(
                          {
                              test: 'test'
                          }
                      );
              `,
              options: [4, { CallExpression: { arguments: 1 } }]
          },
          unIndent`
              [
                  foo,
                  // comment
                  // another comment
                  bar
              ]
          `,
          unIndent`
              if (foo) {
                  /* comment */ bar();
              }
          `,
          unIndent`
              function foo() {
                  return (
                      1
                  );
              }
          `,
          unIndent`
              function foo() {
                  return (
                      1
                  )
              }
          `,
          unIndent`
              if (
                  foo &&
                  !(
                      bar
                  )
              ) {}
          `,
          {
  
              // https://github.com/eslint/eslint/issues/6007
              code: unIndent`
                  var abc = [
                    (
                      ''
                    ),
                    def,
                  ]
              `,
              options: [2]
          },
          {
              code: unIndent`
                  var abc = [
                    (
                      ''
                    ),
                    (
                      'bar'
                    )
                  ]
              `,
              options: [2]
          },
          unIndent`
              function f() {
                  return asyncCall()
                      .then(
                          'some string',
                          [
                              1,
                              2,
                              3
                          ]
                      );
              }
          `,
          {
  
              // https://github.com/eslint/eslint/issues/6670
              code: unIndent`
                  function f() {
                      return asyncCall()
                          .then(
                              'some string',
                              [
                                  1,
                                  2,
                                  3
                              ]
                          );
                  }
              `,
              options: [4, { MemberExpression: 1 }]
          },
  
          // https://github.com/eslint/eslint/issues/7242
          unIndent`
              var x = [
                  [1],
                  [2]
              ]
          `,
          unIndent`
              var y = [
                  {a: 1},
                  {b: 2}
              ]
          `,
          unIndent`
              foo(
              )
          `,
          {
  
              // https://github.com/eslint/eslint/issues/7616
              code: unIndent`
                  foo(
                      bar,
                      {
                          baz: 1
                      }
                  )
              `,
              options: [4, { CallExpression: { arguments: "first" } }]
          },
          "new Foo",
          "new (Foo)",
          unIndent`
              if (Foo) {
                  new Foo
              }
          `,
          {
              code: unIndent`
                  export {
                      foo,
                      bar,
                      baz
                  }
              `,
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  foo
                      ? bar
                      : baz
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  foo ?
                      bar :
                      baz
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  foo ?
                      bar
                      : baz
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  foo
                      ? bar :
                      baz
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  foo
                      ? bar
                      : baz
                          ? qux
                          : foobar
                              ? boop
                              : beep
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  foo ?
                      bar :
                      baz ?
                          qux :
                          foobar ?
                              boop :
                              beep
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  var a =
                      foo ? bar :
                      baz ? qux :
                      foobar ? boop :
                      /*else*/ beep
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  var a = foo
                      ? bar
                      : baz
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  var a =
                      foo
                          ? bar
                          : baz
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  a =
                      foo ? bar :
                      baz ? qux :
                      foobar ? boop :
                      /*else*/ beep
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  a = foo
                      ? bar
                      : baz
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  a =
                      foo
                          ? bar
                          : baz
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  foo(
                      foo ? bar :
                      baz ? qux :
                      foobar ? boop :
                      /*else*/ beep
                  )
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  function wrap() {
                      return (
                          foo ? bar :
                          baz ? qux :
                          foobar ? boop :
                          /*else*/ beep
                      )
                  }
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  function wrap() {
                      return foo
                          ? bar
                          : baz
                  }
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  function wrap() {
                      return (
                          foo
                              ? bar
                              : baz
                      )
                  }
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  foo(
                      foo
                          ? bar
                          : baz
                  )
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  foo(foo
                      ? bar
                      : baz
                  )
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  foo
                      ? bar
                      : baz
                          ? qux
                          : foobar
                              ? boop
                              : beep
              `,
              options: [4, { flatTernaryExpressions: false }]
          },
          {
              code: unIndent`
                  foo ?
                      bar :
                      baz ?
                          qux :
                          foobar ?
                              boop :
                              beep
              `,
              options: [4, { flatTernaryExpressions: false }]
          },
          {
              code: "[,]",
              options: [2, { ArrayExpression: "first" }]
          },
          {
              code: "[,]",
              options: [2, { ArrayExpression: "off" }]
          },
          {
              code: unIndent`
                  [
                      ,
                      foo
                  ]
              `,
              options: [4, { ArrayExpression: "first" }]
          },
          {
              code: "[sparse, , array];",
              options: [2, { ArrayExpression: "first" }]
          },
          {
              code: unIndent`
                  foo.bar('baz', function(err) {
                    qux;
                  });
              `,
              options: [2, { CallExpression: { arguments: "first" } }]
          },
          {
              code: unIndent`
                  foo.bar(function() {
                    cookies;
                  }).baz(function() {
                    cookies;
                  });
              `,
              options: [2, { MemberExpression: 1 }]
          },
          {
              code: unIndent`
                  foo.bar().baz(function() {
                    cookies;
                  }).qux(function() {
                    cookies;
                  });
              `,
              options: [2, { MemberExpression: 1 }]
          },
          {
              code: unIndent`
                  (
                    {
                      foo: 1,
                      baz: 2
                    }
                  );
              `,
              options: [2, { ObjectExpression: "first" }]
          },
          {
              code: unIndent`
                  foo(() => {
                      bar;
                  }, () => {
                      baz;
                  })
              `,
              options: [4, { CallExpression: { arguments: "first" } }]
          },
          {
              code: unIndent`
                  [ foo,
                    bar ].forEach(function() {
                    baz;
                  })
              `,
              options: [2, { ArrayExpression: "first", MemberExpression: 1 }]
          },
          unIndent`
              foo = bar[
                  baz
              ];
          `,
          {
              code: unIndent`
                  foo[
                      bar
                  ];
              `,
              options: [4, { MemberExpression: 1 }]
          },
          {
              code: unIndent`
                  foo[
                      (
                          bar
                      )
                  ];
              `,
              options: [4, { MemberExpression: 1 }]
          },
          unIndent`
              if (foo)
                  bar;
              else if (baz)
                  qux;
          `,
          unIndent`
              if (foo) bar()
  
              ; [1, 2, 3].map(baz)
          `,
          unIndent`
              if (foo)
                  ;
          `,
          "x => {}",
          {
              code: unIndent`
                  import {foo}
                      from 'bar';
              `,
              parserOptions: { sourceType: "module" }
          },
          {
              code: "import 'foo'",
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  import { foo,
                      bar,
                      baz,
                  } from 'qux';
              `,
              options: [4, { ImportDeclaration: 1 }],
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  import {
                      foo,
                      bar,
                      baz,
                  } from 'qux';
              `,
              options: [4, { ImportDeclaration: 1 }],
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  import { apple as a,
                           banana as b } from 'fruits';
                  import { cat } from 'animals';
              `,
              options: [4, { ImportDeclaration: "first" }],
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  import { declaration,
                                   can,
                                    be,
                                turned } from 'off';
              `,
              options: [4, { ImportDeclaration: "off" }],
              parserOptions: { sourceType: "module" }
          },
  
          // https://github.com/eslint/eslint/issues/8455
          unIndent`
              (
                  a
              ) => b => {
                  c
              }
          `,
          unIndent`
              (
                  a
              ) => b => c => d => {
                  e
              }
          `,
          unIndent`
              (
                  a
              ) =>
                  (
                      b
                  ) => {
                      c
                  }
          `,
          unIndent`
              if (
                  foo
              ) bar(
                  baz
              );
          `,
          unIndent`
              if (foo)
              {
                  bar();
              }
          `,
          unIndent`
              function foo(bar)
              {
                  baz();
              }
          `,
          unIndent`
              () =>
                  ({})
          `,
          unIndent`
              () =>
                  (({}))
          `,
          unIndent`
              (
                  () =>
                      ({})
              )
          `,
          unIndent`
              var x = function foop(bar)
              {
                  baz();
              }
          `,
          unIndent`
              var x = (bar) =>
              {
                  baz();
              }
          `,
          unIndent`
              class Foo
              {
                  constructor()
                  {
                      foo();
                  }
  
                  bar()
                  {
                      baz();
                  }
              }
          `,
          unIndent`
              class Foo
                  extends Bar
              {
                  constructor()
                  {
                      foo();
                  }
  
                  bar()
                  {
                      baz();
                  }
              }
          `,
          unIndent`
              (
                  class Foo
                  {
                      constructor()
                      {
                          foo();
                      }
  
                      bar()
                      {
                          baz();
                      }
                  }
              )
          `,
          {
              code: unIndent`
                  switch (foo)
                  {
                      case 1:
                          bar();
                  }
              `,
              options: [4, { SwitchCase: 1 }]
          },
          unIndent`
              foo
                  .bar(function() {
                      baz
                  })
          `,
          {
              code: unIndent`
                  foo
                          .bar(function() {
                              baz
                          })
              `,
              options: [4, { MemberExpression: 2 }]
          },
          unIndent`
              foo
                  [bar](function() {
                      baz
                  })
          `,
          unIndent`
              foo.
                  bar.
                  baz
          `,
          {
              code: unIndent`
                  foo
                      .bar(function() {
                          baz
                      })
              `,
              options: [4, { MemberExpression: "off" }]
          },
          {
              code: unIndent`
                  foo
                                  .bar(function() {
                                      baz
                                  })
              `,
              options: [4, { MemberExpression: "off" }]
          },
          {
              code: unIndent`
                  foo
                                  [bar](function() {
                                      baz
                                  })
              `,
              options: [4, { MemberExpression: "off" }]
          },
          {
              code: unIndent`
                    foo.
                            bar.
                                        baz
              `,
              options: [4, { MemberExpression: "off" }]
          },
          {
              code: unIndent`
                    foo = bar(
                    ).baz(
                    )
              `,
              options: [4, { MemberExpression: "off" }]
          },
          {
              code: unIndent`
                  foo[
                      bar ? baz :
                      qux
                  ]
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  function foo() {
                      return foo ? bar :
                          baz
                  }
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  throw foo ? bar :
                      baz
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          {
              code: unIndent`
                  foo(
                      bar
                  ) ? baz :
                      qux
              `,
              options: [4, { flatTernaryExpressions: true }]
          },
          unIndent`
                  foo
                      [
                          bar
                      ]
                      .baz(function() {
                          quz();
                      })
          `,
          unIndent`
                  [
                      foo
                  ][
                      "map"](function() {
                      qux();
                  })
          `,
          unIndent`
              (
                  a.b(function() {
                      c;
                  })
              )
          `,
          unIndent`
              (
                  foo
              ).bar(function() {
                  baz();
              })
          `,
          unIndent`
              new Foo(
                  bar
                      .baz
                      .qux
              )
          `,
          unIndent`
              const foo = a.b(),
                  longName =
                      (baz(
                          'bar',
                          'bar'
                      ));
          `,
          unIndent`
              const foo = a.b(),
                  longName =
                  (baz(
                      'bar',
                      'bar'
                  ));
          `,
          unIndent`
              const foo = a.b(),
                  longName =
                      baz(
                          'bar',
                          'bar'
                      );
          `,
          unIndent`
              const foo = a.b(),
                  longName =
                  baz(
                      'bar',
                      'bar'
                  );
          `,
          unIndent`
              const foo = a.b(),
                  longName
                      = baz(
                          'bar',
                          'bar'
                      );
          `,
          unIndent`
              const foo = a.b(),
                  longName
                  = baz(
                      'bar',
                      'bar'
                  );
          `,
          unIndent`
              const foo = a.b(),
                  longName =
                      ('fff');
          `,
          unIndent`
              const foo = a.b(),
                  longName =
                  ('fff');
          `,
          unIndent`
              const foo = a.b(),
                  longName
                      = ('fff');
  
          `,
          unIndent`
              const foo = a.b(),
                  longName
                  = ('fff');
  
          `,
          unIndent`
              const foo = a.b(),
                  longName =
                      (
                          'fff'
                      );
          `,
          unIndent`
              const foo = a.b(),
                  longName =
                  (
                      'fff'
                  );
          `,
          unIndent`
              const foo = a.b(),
                  longName
                      =(
                          'fff'
                      );
          `,
          unIndent`
              const foo = a.b(),
                  longName
                  =(
                      'fff'
                  );
          `,
  
  
          //----------------------------------------------------------------------
          // Ignore Unknown Nodes
          //----------------------------------------------------------------------
  
          {
              code: unIndent`
                  interface Foo {
                      bar: string;
                      baz: number;
                  }
              `,
              parser: parser("unknown-nodes/interface")
          },
          {
              code: unIndent`
                  namespace Foo {
                      const bar = 3,
                          baz = 2;
  
                      if (true) {
                          const bax = 3;
                      }
                  }
              `,
              parser: parser("unknown-nodes/namespace-valid")
          },
          {
              code: unIndent`
                  abstract class Foo {
                      public bar() {
                          let aaa = 4,
                              boo;
  
                          if (true) {
                              boo = 3;
                          }
  
                          boo = 3 + 2;
                      }
                  }
              `,
              parser: parser("unknown-nodes/abstract-class-valid")
          },
          {
              code: unIndent`
                  function foo() {
                      function bar() {
                          abstract class X {
                              public baz() {
                                  if (true) {
                                      qux();
                                  }
                              }
                          }
                      }
                  }
              `,
              parser: parser("unknown-nodes/functions-with-abstract-class-valid")
          },
          {
              code: unIndent`
                  namespace Unknown {
                      function foo() {
                          function bar() {
                              abstract class X {
                                  public baz() {
                                      if (true) {
                                          qux();
                                      }
                                  }
                              }
                          }
                      }
                  }
              `,
              parser: parser("unknown-nodes/namespace-with-functions-with-abstract-class-valid")
          },
          {
              code: unIndent`
                  type httpMethod = 'GET'
                    | 'POST'
                    | 'PUT';
              `,
              options: [2, { VariableDeclarator: 0 }],
              parser: parser("unknown-nodes/variable-declarator-type-indent-two-spaces")
          },
          {
              code: unIndent`
                  type httpMethod = 'GET'
                  | 'POST'
                  | 'PUT';
              `,
              options: [2, { VariableDeclarator: 1 }],
              parser: parser("unknown-nodes/variable-declarator-type-no-indent")
          },
          unIndent`
              foo(\`foo
                      \`, {
                  ok: true
              },
              {
                  ok: false
              })
          `,
          unIndent`
              foo(tag\`foo
                      \`, {
                  ok: true
              },
              {
                  ok: false
              }
              )
          `,
  
          // https://github.com/eslint/eslint/issues/8815
          unIndent`
              async function test() {
                  const {
                      foo,
                      bar,
                  } = await doSomethingAsync(
                      1,
                      2,
                      3,
                  );
              }
          `,
          unIndent`
              function* test() {
                  const {
                      foo,
                      bar,
                  } = yield doSomethingAsync(
                      1,
                      2,
                      3,
                  );
              }
          `,
          unIndent`
              ({
                  a: b
              } = +foo(
                  bar
              ));
          `,
          unIndent`
              const {
                  foo,
                  bar,
              } = typeof foo(
                  1,
                  2,
                  3,
              );
          `,
          unIndent`
              const {
                  foo,
                  bar,
              } = +(
                  foo
              );
          `,
  
          //----------------------------------------------------------------------
          // JSX tests
          // https://github.com/eslint/eslint/issues/8425
          // Some of the following tests are adapted from the the tests in eslint-plugin-react.
          // License: https://github.com/yannickcr/eslint-plugin-react/blob/7ca9841f22d599f447a27ef5b2a97def9229d6c8/LICENSE
          //----------------------------------------------------------------------
  
          "<Foo a=\"b\" c=\"d\"/>;",
          unIndent`
              <Foo
                  a="b"
                  c="d"
              />;
          `,
          "var foo = <Bar a=\"b\" c=\"d\"/>;",
          unIndent`
              var foo = <Bar
                  a="b"
                  c="d"
              />;
          `,
          unIndent`
              var foo = (<Bar
                  a="b"
                  c="d"
              />);
          `,
          unIndent`
              var foo = (
                  <Bar
                      a="b"
                      c="d"
                  />
              );
          `,
          unIndent`
              <
                  Foo
                  a="b"
                  c="d"
              />;
          `,
          unIndent`
              <Foo
                  a="b"
                  c="d"/>;
          `,
          unIndent`
              <
                  Foo
                  a="b"
                  c="d"/>;
          `,
          "<a href=\"foo\">bar</a>;",
          unIndent`
              <a href="foo">
                  bar
              </a>;
          `,
          unIndent`
              <a
                  href="foo"
              >
                  bar
              </a>;
          `,
          unIndent`
              <a
                  href="foo">
                  bar
              </a>;
          `,
          unIndent`
              <
                  a
                  href="foo">
                  bar
              </a>;
          `,
          unIndent`
              <a
                  href="foo">
                  bar
              </
                  a>;
          `,
          unIndent`
              <a
                  href="foo">
                  bar
              </a
              >;
          `,
          unIndent`
                  var foo = <a href="bar">
                      baz
                  </a>;
              `,
          unIndent`
              var foo = <a
                  href="bar"
              >
                  baz
              </a>;
          `,
          unIndent`
              var foo = <a
                  href="bar">
                  baz
              </a>;
          `,
          unIndent`
              var foo = <
                  a
                  href="bar">
                  baz
              </a>;
          `,
          unIndent`
              var foo = <a
                  href="bar">
                  baz
              </
                  a>;
          `,
          unIndent`
              var foo = <a
                  href="bar">
                  baz
              </a
              >
          `,
          unIndent`
              var foo = (<a
                  href="bar">
                  baz
              </a>);
          `,
          unIndent`
              var foo = (
                  <a href="bar">baz</a>
              );
          `,
          unIndent`
              var foo = (
                  <a href="bar">
                      baz
                  </a>
              );
          `,
          unIndent`
              var foo = (
                  <a
                      href="bar">
                      baz
                  </a>
              );
          `,
          "var foo = <a href=\"bar\">baz</a>;",
          unIndent`
              <a>
                  {
                  }
              </a>
          `,
          unIndent`
              <a>
                  {
                      foo
                  }
              </a>
          `,
          unIndent`
              function foo() {
                  return (
                      <a>
                          {
                              b.forEach(() => {
                                  // comment
                                  a = c
                                      .d()
                                      .e();
                              })
                          }
                      </a>
                  );
              }
          `,
          "<App></App>",
          unIndent`
              <App>
              </App>
          `,
          {
              code: unIndent`
                  <App>
                    <Foo />
                  </App>
              `,
              options: [2]
          },
          {
              code: unIndent`
                  <App>
                  <Foo />
                  </App>
              `,
              options: [0]
          },
          {
              code: unIndent`
                  <App>
                  \t<Foo />
                  </App>
              `,
              options: ["tab"]
          },
          {
              code: unIndent`
                  function App() {
                    return <App>
                      <Foo />
                    </App>;
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function App() {
                    return (<App>
                      <Foo />
                    </App>);
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function App() {
                    return (
                      <App>
                        <Foo />
                      </App>
                    );
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  it(
                    (
                      <div>
                        <span />
                      </div>
                    )
                  )
              `,
              options: [2]
          },
          {
              code: unIndent`
                  it(
                    (<div>
                      <span />
                      <span />
                      <span />
                    </div>)
                  )
              `,
              options: [2]
          },
          {
              code: unIndent`
                  (
                    <div>
                      <span />
                    </div>
                  )
              `,
              options: [2]
          },
          {
              code: unIndent`
                  {
                    head.title &&
                    <h1>
                      {head.title}
                    </h1>
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  {
                    head.title &&
                      <h1>
                        {head.title}
                      </h1>
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  {
                    head.title && (
                      <h1>
                        {head.title}
                      </h1>)
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  {
                    head.title && (
                      <h1>
                        {head.title}
                      </h1>
                    )
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  [
                    <div />,
                    <div />
                  ]
              `,
              options: [2]
          },
          unIndent`
              <div>
                  {
                      [
                          <Foo />,
                          <Bar />
                      ]
                  }
              </div>
          `,
          unIndent`
              <div>
                  {foo &&
                      [
                          <Foo />,
                          <Bar />
                      ]
                  }
              </div>
          `,
          unIndent`
              <div>
              bar <div>
                  bar
                  bar {foo}
              bar </div>
              </div>
          `,
          unIndent`
              foo ?
                  <Foo /> :
                  <Bar />
          `,
          unIndent`
              foo ?
                  <Foo />
                  : <Bar />
          `,
          unIndent`
              foo ?
                  <Foo />
                  :
                  <Bar />
          `,
          unIndent`
              <div>
                  {!foo ?
                      <Foo
                          onClick={this.onClick}
                      />
                      :
                      <Bar
                          onClick={this.onClick}
                      />
                  }
              </div>
          `,
          {
              code: unIndent`
                  <span>
                    {condition ?
                      <Thing
                        foo={\`bar\`}
                      /> :
                      <Thing/>
                    }
                  </span>
              `,
              options: [2]
          },
          {
              code: unIndent`
                  <span>
                    {condition ?
                      <Thing
                        foo={"bar"}
                      /> :
                      <Thing/>
                    }
                  </span>
              `,
              options: [2]
          },
          {
              code: unIndent`
                  function foo() {
                    <span>
                      {condition ?
                        <Thing
                          foo={bar}
                        /> :
                        <Thing/>
                      }
                    </span>
                  }
              `,
              options: [2]
          },
          unIndent`
                <App foo
                />
              `,
          {
              code: unIndent`
                <App
                  foo
                />
              `,
              options: [2]
          },
          {
              code: unIndent`
                <App
                foo
                />
              `,
              options: [0]
          },
          {
              code: unIndent`
                <App
                \tfoo
                />
              `,
              options: ["tab"]
          },
          unIndent`
                  <App
                      foo
                  />
              `,
          unIndent`
                  <App
                      foo
                  ></App>
              `,
          {
              code: unIndent`
                  <App
                    foo={function() {
                      console.log('bar');
                    }}
                  />
              `,
              options: [2]
          },
          {
              code: unIndent`
                  <App foo={function() {
                    console.log('bar');
                  }}
                  />
              `,
              options: [2]
          },
          {
              code: unIndent`
                  var x = function() {
                    return <App
                      foo={function() {
                        console.log('bar');
                      }}
                    />
                  }
              `,
              options: [2]
          },
          {
              code: unIndent`
                  var x = <App
                    foo={function() {
                      console.log('bar');
                    }}
                  />
              `,
              options: [2]
          },
          {
              code: unIndent`
                  <Provider
                    store
                  >
                    <App
                      foo={function() {
                        console.log('bar');
                      }}
                    />
                  </Provider>
              `,
              options: [2]
          },
          {
              code: unIndent`
                  <Provider
                    store
                  >
                    {baz && <App
                      foo={function() {
                        console.log('bar');
                      }}
                    />}
                  </Provider>
              `,
              options: [2]
          },
          {
              code: unIndent`
                  <App
                  \tfoo
                  />
              `,
              options: ["tab"]
          },
          {
              code: unIndent`
                  <App
                  \tfoo
                  ></App>
              `,
              options: ["tab"]
          },
          {
              code: unIndent`
                  <App foo={function() {
                  \tconsole.log('bar');
                  }}
                  />
              `,
              options: ["tab"]
          },
          {
              code: unIndent`
                  var x = <App
                  \tfoo={function() {
                  \t\tconsole.log('bar');
                  \t}}
                  />
              `,
              options: ["tab"]
          },
          unIndent`
                  <App
                      foo />
              `,
          unIndent`
                  <div>
                     unrelated{
                          foo
                      }
                  </div>
              `,
          unIndent`
                  <div>unrelated{
                      foo
                  }
                  </div>
              `,
          unIndent`
                  <
                      foo
                          .bar
                          .baz
                  >
                      foo
                  </
                      foo.
                          bar.
                          baz
                  >
              `,
          unIndent`
                  <
                      input
                      type=
                          "number"
                  />
              `,
          unIndent`
                  <
                      input
                      type=
                          {'number'}
                  />
              `,
          unIndent`
                  <
                      input
                      type
                          ="number"
                  />
              `,
          unIndent`
                  foo ? (
                      bar
                  ) : (
                      baz
                  )
              `,
          unIndent`
                  foo ? (
                      <div>
                      </div>
                  ) : (
                      <span>
                      </span>
                  )
              `,
          unIndent`
                  <div>
                      {
                          /* foo */
                      }
                  </div>
              `,
  
          // https://github.com/eslint/eslint/issues/8832
          unIndent`
                  <div>
                      {
                          (
                              1
                          )
                      }
                  </div>
              `,
          unIndent`
                  function A() {
                      return (
                          <div>
                              {
                                  b && (
                                      <div>
                                      </div>
                                  )
                              }
                          </div>
                      );
                  }
              `,
          {
              code: unIndent`
                  a(b
                    , c
                  )
              `,
              options: [2, { CallExpression: { arguments: "off" } }]
          },
          {
              code: unIndent`
                  a(
                    new B({
                      c,
                    })
                  );
              `,
              options: [2, { CallExpression: { arguments: "off" } }]
          },
          {
              code: unIndent`
                  foo
                  ? bar
                              : baz
              `,
              options: [4, { ignoredNodes: ["ConditionalExpression"] }]
          },
          {
              code: unIndent`
                  class Foo {
                  foo() {
                      bar();
                  }
                  }
              `,
              options: [4, { ignoredNodes: ["ClassBody"] }]
          },
          {
              code: unIndent`
                  class Foo {
                  foo() {
                  bar();
                  }
                  }
              `,
              options: [4, { ignoredNodes: ["ClassBody", "BlockStatement"] }]
          },
          {
              code: unIndent`
                  foo({
                          bar: 1
                      },
                      {
                          baz: 2
                      },
                      {
                          qux: 3
                  })
              `,
              options: [4, { ignoredNodes: ["CallExpression > ObjectExpression"] }]
          },
          {
              code: unIndent`
                  foo
                                              .bar
              `,
              options: [4, { ignoredNodes: ["MemberExpression"] }]
          },
          {
              code: unIndent`
                  $(function() {
  
                  foo();
                  bar();
  
                  });
              `,
              options: [4, {
                  ignoredNodes: ["Program > ExpressionStatement > CallExpression[callee.name='$'] > FunctionExpression > BlockStatement"]
              }]
          },
          {
              code: unIndent`
                  <Foo
                              bar="1" />
              `,
              options: [4, { ignoredNodes: ["JSXOpeningElement"] }]
          },
          {
              code: unIndent`
                  foo &&
                  <Bar
                  >
                  </Bar>
              `,
              options: [4, { ignoredNodes: ["JSXElement", "JSXOpeningElement"] }]
          },
          {
              code: unIndent`
                  (function($) {
                  $(function() {
                      foo;
                  });
                  }())
              `,
              options: [4, { ignoredNodes: ["ExpressionStatement > CallExpression > FunctionExpression.callee > BlockStatement"] }]
          },
          {
              code: unIndent`
                  const value = (
                      condition ?
                      valueIfTrue :
                      valueIfFalse
                  );
              `,
              options: [4, { ignoredNodes: ["ConditionalExpression"] }]
          },
          {
              code: unIndent`
                  export default foo(
                      a,
                      b, {
                      c
                      }
                  )
              `,
              options: [4, { ignoredNodes: ["ExportDefaultDeclaration > CallExpression > ObjectExpression"] }],
              parserOptions: { sourceType: "module" }
          },
          {
              code: unIndent`
                  foobar = baz
                         ? qux
                         : boop
              `,
              options: [4, { ignoredNodes: ["ConditionalExpression"] }]
          },
          {
              code: unIndent`
                  \`
                      SELECT
                          \${
                              foo
                          } FROM THE_DATABASE
                  \`
              `,
              options: [4, { ignoredNodes: ["TemplateLiteral"] }]
          },
          {
              code: unIndent`
                  <foo
                      prop='bar'
                      >
                      Text
                  </foo>
              `,
              options: [4, { ignoredNodes: ["JSXOpeningElement"] }]
          },
          {
              code: unIndent`
                  {
                  \tvar x = 1,
                  \t    y = 2;
                  }
              `,
              options: ["tab"]
          },
          {
              code: unIndent`
                  var x = 1,
                      y = 2;
                  var z;
              `,
              options: ["tab", { ignoredNodes: ["VariableDeclarator"] }]
          },
          {
              code: unIndent`
                  [
                      foo(),
                      bar
                  ]
              `,
              options: ["tab", { ArrayExpression: "first", ignoredNodes: ["CallExpression"] }]
          },
          {
              code: unIndent`
                  if (foo) {
                      doSomething();
  
                  // Intentionally unindented comment
                      doSomethingElse();
                  }
              `,
              options: [4, { ignoreComments: true }]
          },
          {
              code: unIndent`
                  if (foo) {
                      doSomething();
  
                  /* Intentionally unindented comment */
                      doSomethingElse();
                  }
              `,
              options: [4, { ignoreComments: true }]
          },
          unIndent`
              const obj = {
                  foo () {
                      return condition ? // comment
                          1 :
                          2
                  }
              }
          `
      ],
  
      invalid: [
          {
              code: unIndent`
                  var a = b;
                  if (a) {
                  b();
                  }
              `,
              output: unIndent`
                  var a = b;
                  if (a) {
                    b();
                  }
              `,
              options: [2],
              errors: expectedErrors([[3, 2, 0, "Identifier"]])
          },
          {
              code: unIndent`
                  require('http').request({hostname: 'localhost',
                                    port: 80}, function(res) {
                      res.end();
                    });
              `,
              output: unIndent`
                  require('http').request({hostname: 'localhost',
                    port: 80}, function(res) {
                    res.end();
                  });
              `,
              options: [2],
              errors: expectedErrors([[2, 2, 18, "Identifier"], [3, 2, 4, "Identifier"], [4, 0, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  if (array.some(function(){
                    return true;
                  })) {
                  a++; // ->
                    b++;
                      c++; // <-
                  }
              `,
              output: unIndent`
                  if (array.some(function(){
                    return true;
                  })) {
                    a++; // ->
                    b++;
                    c++; // <-
                  }
              `,
              options: [2],
              errors: expectedErrors([[4, 2, 0, "Identifier"], [6, 2, 4, "Identifier"]])
          },
          {
              code: unIndent`
                  if (a){
                  \tb=c;
                  \t\tc=d;
                  e=f;
                  }
              `,
              output: unIndent`
                  if (a){
                  \tb=c;
                  \tc=d;
                  \te=f;
                  }
              `,
              options: ["tab"],
              errors: expectedErrors("tab", [[3, 1, 2, "Identifier"], [4, 1, 0, "Identifier"]])
          },
          {
              code: unIndent`
                  if (a){
                      b=c;
                        c=d;
                   e=f;
                  }
              `,
              output: unIndent`
                  if (a){
                      b=c;
                      c=d;
                      e=f;
                  }
              `,
              options: [4],
              errors: expectedErrors([[3, 4, 6, "Identifier"], [4, 4, 1, "Identifier"]])
          },
          {
              code: fixture,
              output: fixedFixture,
              options: [2, { SwitchCase: 1, MemberExpression: 1, CallExpression: { arguments: "off" } }],
              errors: expectedErrors([
                  [5, 2, 4, "Keyword"],
                  [6, 2, 0, "Line"],
                  [10, 4, 6, "Punctuator"],
                  [11, 2, 4, "Punctuator"],
  
                  [15, 4, 2, "Identifier"],
                  [16, 2, 4, "Punctuator"],
                  [23, 2, 4, "Punctuator"],
                  [29, 2, 4, "Keyword"],
                  [30, 4, 6, "Identifier"],
                  [36, 4, 6, "Identifier"],
                  [38, 2, 4, "Punctuator"],
                  [39, 4, 2, "Identifier"],
                  [40, 2, 0, "Punctuator"],
                  [54, 2, 4, "Punctuator"],
                  [114, 4, 2, "Keyword"],
                  [120, 4, 6, "Keyword"],
                  [124, 4, 2, "Keyword"],
                  [134, 4, 6, "Keyword"],
                  [138, 2, 3, "Punctuator"],
                  [139, 2, 3, "Punctuator"],
                  [143, 4, 0, "Identifier"],
                  [144, 6, 2, "Punctuator"],
                  [145, 6, 2, "Punctuator"],
                  [151, 4, 6, "Identifier"],
                  [152, 6, 8, "Punctuator"],
                  [153, 6, 8, "Punctuator"],
                  [159, 4, 2, "Identifier"],
                  [161, 4, 6, "Identifier"],
                  [175, 2, 0, "Identifier"],
                  [177, 2, 4, "Identifier"],
                  [189, 2, 0, "Keyword"],
                  [192, 6, 18, "Identifier"],
                  [193, 6, 4, "Identifier"],
                  [195, 6, 8, "Identifier"],
                  [228, 5, 4, "Identifier"],
                  [231, 3, 2, "Punctuator"],
                  [245, 0, 2, "Punctuator"],
                  [248, 0, 2, "Punctuator"],
                  [304, 4, 6, "Identifier"],
                  [306, 4, 8, "Identifier"],
                  [307, 2, 4, "Punctuator"],
                  [308, 2, 4, "Identifier"],
                  [311, 4, 6, "Identifier"],
                  [312, 4, 6, "Identifier"],
                  [313, 4, 6, "Identifier"],
                  [314, 2, 4, "Punctuator"],
                  [315, 2, 4, "Identifier"],
                  [318, 4, 6, "Identifier"],
                  [319, 4, 6, "Identifier"],
                  [320, 4, 6, "Identifier"],
                  [321, 2, 4, "Punctuator"],
                  [322, 2, 4, "Identifier"],
                  [326, 2, 1, "Numeric"],
                  [327, 2, 1, "Numeric"],
                  [328, 2, 1, "Numeric"],
                  [329, 2, 1, "Numeric"],
                  [330, 2, 1, "Numeric"],
                  [331, 2, 1, "Numeric"],
                  [332, 2, 1, "Numeric"],
                  [333, 2, 1, "Numeric"],
                  [334, 2, 1, "Numeric"],
                  [335, 2, 1, "Numeric"],
                  [340, 2, 4, "Identifier"],
                  [341, 2, 0, "Identifier"],
                  [344, 2, 4, "Identifier"],
                  [345, 2, 0, "Identifier"],
                  [348, 2, 4, "Identifier"],
                  [349, 2, 0, "Identifier"],
                  [355, 2, 0, "Identifier"],
                  [357, 2, 4, "Identifier"],
                  [361, 4, 6, "Identifier"],
                  [362, 2, 4, "Punctuator"],
                  [363, 2, 4, "Identifier"],
                  [368, 2, 0, "Keyword"],
                  [370, 2, 4, "Keyword"],
                  [374, 4, 6, "Keyword"],
                  [376, 4, 2, "Keyword"],
                  [383, 2, 0, "Identifier"],
                  [385, 2, 4, "Identifier"],
                  [390, 2, 0, "Identifier"],
                  [392, 2, 4, "Identifier"],
                  [409, 2, 0, "Identifier"],
                  [410, 2, 4, "Identifier"],
                  [416, 2, 0, "Identifier"],
                  [417, 2, 4, "Identifier"],
                  [418, 0, 4, "Punctuator"],
                  [422, 2, 4, "Identifier"],
                  [423, 2, 0, "Identifier"],
                  [427, 2, 6, "Identifier"],
                  [428, 2, 8, "Identifier"],
                  [429, 2, 4, "Identifier"],
                  [430, 0, 4, "Punctuator"],
                  [433, 2, 4, "Identifier"],
                  [434, 0, 4, "Punctuator"],
                  [437, 2, 0, "Identifier"],
                  [438, 0, 4, "Punctuator"],
                  [442, 2, 4, "Identifier"],
                  [443, 2, 4, "Identifier"],
                  [444, 0, 2, "Punctuator"],
                  [451, 2, 0, "Identifier"],
                  [453, 2, 4, "Identifier"],
                  [499, 6, 8, "Punctuator"],
                  [500, 8, 6, "Identifier"],
                  [504, 4, 6, "Punctuator"],
                  [505, 6, 8, "Identifier"],
                  [506, 4, 8, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  switch(value){
                      case "1":
                          a();
                      break;
                      case "2":
                          a();
                      break;
                      default:
                          a();
                          break;
                  }
              `,
              output: unIndent`
                  switch(value){
                      case "1":
                          a();
                          break;
                      case "2":
                          a();
                          break;
                      default:
                          a();
                          break;
                  }
              `,
              options: [4, { SwitchCase: 1 }],
              errors: expectedErrors([[4, 8, 4, "Keyword"], [7, 8, 4, "Keyword"]])
          },
          {
              code: unIndent`
                  var x = 0 &&
                      {
                         a: 1,
                            b: 2
                      };
              `,
              output: unIndent`
                  var x = 0 &&
                      {
                          a: 1,
                          b: 2
                      };
              `,
              options: [4],
              errors: expectedErrors([[3, 8, 7, "Identifier"], [4, 8, 10, "Identifier"]])
          },
          {
              code: unIndent`
                  switch(value){
                      case "1":
                          a();
                          break;
                      case "2":
                          a();
                          break;
                      default:
                      break;
                  }
              `,
              output: unIndent`
                  switch(value){
                      case "1":
                          a();
                          break;
                      case "2":
                          a();
                          break;
                      default:
                          break;
                  }
              `,
              options: [4, { SwitchCase: 1 }],
              errors: expectedErrors([9, 8, 4, "Keyword"])
          },
          {
              code: unIndent`
                  switch(value){
                      case "1":
                      case "2":
                          a();
                          break;
                      default:
                          break;
                  }
                  switch(value){
                      case "1":
                      break;
                      case "2":
                          a();
                      break;
                      default:
                          a();
                      break;
                  }
              `,
              output: unIndent`
                  switch(value){
                      case "1":
                      case "2":
                          a();
                          break;
                      default:
                          break;
                  }
                  switch(value){
                      case "1":
                          break;
                      case "2":
                          a();
                          break;
                      default:
                          a();
                          break;
                  }
              `,
              options: [4, { SwitchCase: 1 }],
              errors: expectedErrors([[11, 8, 4, "Keyword"], [14, 8, 4, "Keyword"], [17, 8, 4, "Keyword"]])
          },
          {
              code: unIndent`
                  switch(value){
                  case "1":
                          a();
                          break;
                      case "2":
                          break;
                      default:
                          break;
                  }
              `,
              output: unIndent`
                  switch(value){
                  case "1":
                      a();
                      break;
                  case "2":
                      break;
                  default:
                      break;
                  }
              `,
              options: [4],
              errors: expectedErrors([
                  [3, 4, 8, "Identifier"],
                  [4, 4, 8, "Keyword"],
                  [5, 0, 4, "Keyword"],
                  [6, 4, 8, "Keyword"],
                  [7, 0, 4, "Keyword"],
                  [8, 4, 8, "Keyword"]
              ])
          },
          {
              code: unIndent`
                  var obj = {foo: 1, bar: 2};
                  with (obj) {
                  console.log(foo + bar);
                  }
              `,
              output: unIndent`
                  var obj = {foo: 1, bar: 2};
                  with (obj) {
                      console.log(foo + bar);
                  }
              `,
              errors: expectedErrors([3, 4, 0, "Identifier"])
          },
          {
              code: unIndent`
                  switch (a) {
                  case '1':
                  b();
                  break;
                  default:
                  c();
                  break;
                  }
              `,
              output: unIndent`
                  switch (a) {
                      case '1':
                          b();
                          break;
                      default:
                          c();
                          break;
                  }
              `,
              options: [4, { SwitchCase: 1 }],
              errors: expectedErrors([
                  [2, 4, 0, "Keyword"],
                  [3, 8, 0, "Identifier"],
                  [4, 8, 0, "Keyword"],
                  [5, 4, 0, "Keyword"],
                  [6, 8, 0, "Identifier"],
                  [7, 8, 0, "Keyword"]
              ])
          },
          {
              code: unIndent`
                  var foo = function(){
                      foo
                            .bar
                  }
              `,
              output: unIndent`
                  var foo = function(){
                      foo
                          .bar
                  }
              `,
              options: [4, { MemberExpression: 1 }],
              errors: expectedErrors(
                  [3, 8, 10, "Punctuator"]
              )
          },
          {
              code: unIndent`
                  (
                      foo
                      .bar
                  )
              `,
              output: unIndent`
                  (
                      foo
                          .bar
                  )
              `,
              errors: expectedErrors([3, 8, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  var foo = function(){
                      foo
                               .bar
                  }
              `,
              output: unIndent`
                  var foo = function(){
                      foo
                              .bar
                  }
              `,
              options: [4, { MemberExpression: 2 }],
              errors: expectedErrors(
                  [3, 12, 13, "Punctuator"]
              )
          },
          {
              code: unIndent`
                  var foo = () => {
                      foo
                               .bar
                  }
              `,
              output: unIndent`
                  var foo = () => {
                      foo
                              .bar
                  }
              `,
              options: [4, { MemberExpression: 2 }],
              errors: expectedErrors(
                  [3, 12, 13, "Punctuator"]
              )
          },
          {
              code: unIndent`
                  TestClass.prototype.method = function () {
                    return Promise.resolve(3)
                        .then(function (x) {
                        return x;
                      });
                  };
              `,
              output: unIndent`
                  TestClass.prototype.method = function () {
                    return Promise.resolve(3)
                      .then(function (x) {
                        return x;
                      });
                  };
              `,
              options: [2, { MemberExpression: 1 }],
              errors: expectedErrors([3, 4, 6, "Punctuator"])
          },
          {
              code: unIndent`
                  while (a)
                  b();
              `,
              output: unIndent`
                  while (a)
                      b();
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 0, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  lmn = [{
                          a: 1
                      },
                      {
                          b: 2
                      },
                      {
                          x: 2
                  }];
              `,
              output: unIndent`
                  lmn = [{
                      a: 1
                  },
                  {
                      b: 2
                  },
                  {
                      x: 2
                  }];
              `,
              errors: expectedErrors([
                  [2, 4, 8, "Identifier"],
                  [3, 0, 4, "Punctuator"],
                  [4, 0, 4, "Punctuator"],
                  [5, 4, 8, "Identifier"],
                  [6, 0, 4, "Punctuator"],
                  [7, 0, 4, "Punctuator"],
                  [8, 4, 8, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  for (var foo = 1;
                  foo < 10;
                  foo++) {}
              `,
              output: unIndent`
                  for (var foo = 1;
                      foo < 10;
                      foo++) {}
              `,
              errors: expectedErrors([[2, 4, 0, "Identifier"], [3, 4, 0, "Identifier"]])
          },
          {
              code: unIndent`
                  for (
                  var foo = 1;
                  foo < 10;
                  foo++
                      ) {}
              `,
              output: unIndent`
                  for (
                      var foo = 1;
                      foo < 10;
                      foo++
                  ) {}
              `,
              errors: expectedErrors([[2, 4, 0, "Keyword"], [3, 4, 0, "Identifier"], [4, 4, 0, "Identifier"], [5, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  for (;;)
                  b();
              `,
              output: unIndent`
                  for (;;)
                      b();
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 0, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  for (a in x)
                  b();
              `,
              output: unIndent`
                  for (a in x)
                      b();
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 0, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  do
                  b();
                  while(true)
              `,
              output: unIndent`
                  do
                      b();
                  while(true)
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 0, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  if(true)
                  b();
              `,
              output: unIndent`
                  if(true)
                      b();
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 0, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  var test = {
                        a: 1,
                      b: 2
                      };
              `,
              output: unIndent`
                  var test = {
                    a: 1,
                    b: 2
                  };
              `,
              options: [2],
              errors: expectedErrors([
                  [2, 2, 6, "Identifier"],
                  [3, 2, 4, "Identifier"],
                  [4, 0, 4, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  var a = function() {
                        a++;
                      b++;
                            c++;
                      },
                      b;
              `,
              output: unIndent`
                  var a = function() {
                          a++;
                          b++;
                          c++;
                      },
                      b;
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 8, 6, "Identifier"],
                  [3, 8, 4, "Identifier"],
                  [4, 8, 10, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  var a = 1,
                  b = 2,
                  c = 3;
              `,
              output: unIndent`
                  var a = 1,
                      b = 2,
                      c = 3;
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 0, "Identifier"],
                  [3, 4, 0, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  [a, b,
                      c].forEach((index) => {
                          index;
                      });
              `,
              output: unIndent`
                  [a, b,
                      c].forEach((index) => {
                      index;
                  });
              `,
              options: [4],
              errors: expectedErrors([
                  [3, 4, 8, "Identifier"],
                  [4, 0, 4, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  [a, b,
                  c].forEach(function(index){
                    return index;
                  });
              `,
              output: unIndent`
                  [a, b,
                      c].forEach(function(index){
                      return index;
                  });
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 0, "Identifier"],
                  [3, 4, 2, "Keyword"]
              ])
          },
          {
              code: unIndent`
                  [a, b, c].forEach(function(index){
                    return index;
                  });
              `,
              output: unIndent`
                  [a, b, c].forEach(function(index){
                      return index;
                  });
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 2, "Keyword"]
              ])
          },
          {
              code: unIndent`
                  (foo)
                      .bar([
                      baz
                  ]);
              `,
              output: unIndent`
                  (foo)
                      .bar([
                          baz
                      ]);
              `,
              options: [4, { MemberExpression: 1 }],
              errors: expectedErrors([[3, 8, 4, "Identifier"], [4, 4, 0, "Punctuator"]])
          },
          {
              code: unIndent`
                  var x = ['a',
                           'b',
                           'c'
                  ];
              `,
              output: unIndent`
                  var x = ['a',
                      'b',
                      'c'
                  ];
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 9, "String"],
                  [3, 4, 9, "String"]
              ])
          },
          {
              code: unIndent`
                  var x = [
                           'a',
                           'b',
                           'c'
                  ];
              `,
              output: unIndent`
                  var x = [
                      'a',
                      'b',
                      'c'
                  ];
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 9, "String"],
                  [3, 4, 9, "String"],
                  [4, 4, 9, "String"]
              ])
          },
          {
              code: unIndent`
                  var x = [
                           'a',
                           'b',
                           'c',
                  'd'];
              `,
              output: unIndent`
                  var x = [
                      'a',
                      'b',
                      'c',
                      'd'];
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 9, "String"],
                  [3, 4, 9, "String"],
                  [4, 4, 9, "String"],
                  [5, 4, 0, "String"]
              ])
          },
          {
              code: unIndent`
                  var x = [
                           'a',
                           'b',
                           'c'
                    ];
              `,
              output: unIndent`
                  var x = [
                      'a',
                      'b',
                      'c'
                  ];
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 4, 9, "String"],
                  [3, 4, 9, "String"],
                  [4, 4, 9, "String"],
                  [5, 0, 2, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  [[
                  ], function(
                          foo
                      ) {}
                  ]
              `,
              output: unIndent`
                  [[
                  ], function(
                      foo
                  ) {}
                  ]
              `,
              errors: expectedErrors([[3, 4, 8, "Identifier"], [4, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  define([
                      'foo'
                  ], function(
                          bar
                      ) {
                      baz;
                  }
                  )
              `,
              output: unIndent`
                  define([
                      'foo'
                  ], function(
                      bar
                  ) {
                      baz;
                  }
                  )
              `,
              errors: expectedErrors([[4, 4, 8, "Identifier"], [5, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  while (1 < 2)
                  console.log('foo')
                    console.log('bar')
              `,
              output: unIndent`
                  while (1 < 2)
                    console.log('foo')
                  console.log('bar')
              `,
              options: [2],
              errors: expectedErrors([
                  [2, 2, 0, "Identifier"],
                  [3, 0, 2, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  function salutation () {
                    switch (1) {
                    case 0: return console.log('hi')
                      case 1: return console.log('hey')
                    }
                  }
              `,
              output: unIndent`
                  function salutation () {
                    switch (1) {
                      case 0: return console.log('hi')
                      case 1: return console.log('hey')
                    }
                  }
              `,
              options: [2, { SwitchCase: 1 }],
              errors: expectedErrors([
                  [3, 4, 2, "Keyword"]
              ])
          },
          {
              code: unIndent`
                  var geometry, box, face1, face2, colorT, colorB, sprite, padding, maxWidth,
                  height, rotate;
              `,
              output: unIndent`
                  var geometry, box, face1, face2, colorT, colorB, sprite, padding, maxWidth,
                    height, rotate;
              `,
              options: [2, { SwitchCase: 1 }],
              errors: expectedErrors([
                  [2, 2, 0, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  switch (a) {
                  case '1':
                  b();
                  break;
                  default:
                  c();
                  break;
                  }
              `,
              output: unIndent`
                  switch (a) {
                          case '1':
                              b();
                              break;
                          default:
                              c();
                              break;
                  }
              `,
              options: [4, { SwitchCase: 2 }],
              errors: expectedErrors([
                  [2, 8, 0, "Keyword"],
                  [3, 12, 0, "Identifier"],
                  [4, 12, 0, "Keyword"],
                  [5, 8, 0, "Keyword"],
                  [6, 12, 0, "Identifier"],
                  [7, 12, 0, "Keyword"]
              ])
          },
          {
              code: unIndent`
                  var geometry,
                  rotate;
              `,
              output: unIndent`
                  var geometry,
                    rotate;
              `,
              options: [2, { VariableDeclarator: 1 }],
              errors: expectedErrors([
                  [2, 2, 0, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  var geometry,
                    rotate;
              `,
              output: unIndent`
                  var geometry,
                      rotate;
              `,
              options: [2, { VariableDeclarator: 2 }],
              errors: expectedErrors([
                  [2, 4, 2, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  var geometry,
                  \trotate;
              `,
              output: unIndent`
                  var geometry,
                  \t\trotate;
              `,
              options: ["tab", { VariableDeclarator: 2 }],
              errors: expectedErrors("tab", [
                  [2, 2, 1, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  let geometry,
                    rotate;
              `,
              output: unIndent`
                  let geometry,
                      rotate;
              `,
              options: [2, { VariableDeclarator: 2 }],
              errors: expectedErrors([
                  [2, 4, 2, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  if(true)
                    if (true)
                      if (true)
                      console.log(val);
              `,
              output: unIndent`
                  if(true)
                    if (true)
                      if (true)
                        console.log(val);
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }],
              errors: expectedErrors([
                  [4, 6, 4, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  var a = {
                      a: 1,
                      b: 2
                  }
              `,
              output: unIndent`
                  var a = {
                    a: 1,
                    b: 2
                  }
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }],
              errors: expectedErrors([
                  [2, 2, 4, "Identifier"],
                  [3, 2, 4, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  var a = [
                      a,
                      b
                  ]
              `,
              output: unIndent`
                  var a = [
                    a,
                    b
                  ]
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }],
              errors: expectedErrors([
                  [2, 2, 4, "Identifier"],
                  [3, 2, 4, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  let a = [
                      a,
                      b
                  ]
              `,
              output: unIndent`
                  let a = [
                    a,
                    b
                  ]
              `,
              options: [2, { VariableDeclarator: { let: 2 }, SwitchCase: 1 }],
              errors: expectedErrors([
                  [2, 2, 4, "Identifier"],
                  [3, 2, 4, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  var a = new Test({
                        a: 1
                    }),
                      b = 4;
              `,
              output: unIndent`
                  var a = new Test({
                          a: 1
                      }),
                      b = 4;
              `,
              options: [4],
              errors: expectedErrors([
                  [2, 8, 6, "Identifier"],
                  [3, 4, 2, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  var a = new Test({
                        a: 1
                      }),
                      b = 4;
                  const c = new Test({
                        a: 1
                      }),
                      d = 4;
              `,
              output: unIndent`
                  var a = new Test({
                        a: 1
                      }),
                      b = 4;
                  const c = new Test({
                      a: 1
                    }),
                    d = 4;
              `,
              options: [2, { VariableDeclarator: { var: 2 } }],
              errors: expectedErrors([
                  [6, 4, 6, "Identifier"],
                  [7, 2, 4, "Punctuator"],
                  [8, 2, 4, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  var abc = 5,
                      c = 2,
                      xyz =
                      {
                        a: 1,
                         b: 2
                      };
              `,
              output: unIndent`
                  var abc = 5,
                      c = 2,
                      xyz =
                      {
                        a: 1,
                        b: 2
                      };
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }],
              errors: expectedErrors([6, 6, 7, "Identifier"])
          },
          {
              code: unIndent`
                  var abc =
                       {
                         a: 1,
                          b: 2
                       };
              `,
              output: unIndent`
                  var abc =
                       {
                         a: 1,
                         b: 2
                       };
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }],
              errors: expectedErrors([4, 7, 8, "Identifier"])
          },
          {
              code: unIndent`
                  var foo = {
                      bar: 1,
                      baz: {
                          qux: 2
                        }
                    },
                    bar = 1;
              `,
              output: unIndent`
                  var foo = {
                      bar: 1,
                      baz: {
                        qux: 2
                      }
                    },
                    bar = 1;
              `,
              options: [2],
              errors: expectedErrors([[4, 6, 8, "Identifier"], [5, 4, 6, "Punctuator"]])
          },
          {
              code: unIndent`
                  var path     = require('path')
                   , crypto    = require('crypto')
                  ;
              `,
              output: unIndent`
                  var path     = require('path')
                    , crypto    = require('crypto')
                  ;
              `,
              options: [2],
              errors: expectedErrors([
                  [2, 2, 1, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  var a = 1
                     ,b = 2
                  ;
              `,
              output: unIndent`
                  var a = 1
                      ,b = 2
                  ;
              `,
              errors: expectedErrors([
                  [2, 4, 3, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  class A{
                    constructor(){}
                      a(){}
                      get b(){}
                  }
              `,
              output: unIndent`
                  class A{
                      constructor(){}
                      a(){}
                      get b(){}
                  }
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }],
              errors: expectedErrors([[2, 4, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  var A = class {
                    constructor(){}
                      a(){}
                    get b(){}
                  };
              `,
              output: unIndent`
                  var A = class {
                      constructor(){}
                      a(){}
                      get b(){}
                  };
              `,
              options: [4, { VariableDeclarator: 1, SwitchCase: 1 }],
              errors: expectedErrors([[2, 4, 2, "Identifier"], [4, 4, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  var a = 1,
                      B = class {
                      constructor(){}
                        a(){}
                        get b(){}
                      };
              `,
              output: unIndent`
                  var a = 1,
                      B = class {
                        constructor(){}
                        a(){}
                        get b(){}
                      };
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }],
              errors: expectedErrors([[3, 6, 4, "Identifier"]])
          },
          {
              code: unIndent`
                  {
                      if(a){
                          foo();
                      }
                    else{
                          bar();
                      }
                  }
              `,
              output: unIndent`
                  {
                      if(a){
                          foo();
                      }
                      else{
                          bar();
                      }
                  }
              `,
              options: [4],
              errors: expectedErrors([[5, 4, 2, "Keyword"]])
          },
          {
              code: unIndent`
                  {
                      if(a){
                          foo();
                      }
                    else
                          bar();
  
                  }
              `,
              output: unIndent`
                  {
                      if(a){
                          foo();
                      }
                      else
                          bar();
  
                  }
              `,
              options: [4],
              errors: expectedErrors([[5, 4, 2, "Keyword"]])
          },
          {
              code: unIndent`
                  {
                      if(a)
                          foo();
                    else
                          bar();
                  }
              `,
              output: unIndent`
                  {
                      if(a)
                          foo();
                      else
                          bar();
                  }
              `,
              options: [4],
              errors: expectedErrors([[4, 4, 2, "Keyword"]])
          },
          {
              code: unIndent`
                  (function(){
                    function foo(x) {
                      return x + 1;
                    }
                  })();
              `,
              output: unIndent`
                  (function(){
                  function foo(x) {
                    return x + 1;
                  }
                  })();
              `,
              options: [2, { outerIIFEBody: 0 }],
              errors: expectedErrors([[2, 0, 2, "Keyword"], [3, 2, 4, "Keyword"], [4, 0, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  (function(){
                      function foo(x) {
                          return x + 1;
                      }
                  })();
              `,
              output: unIndent`
                  (function(){
                          function foo(x) {
                              return x + 1;
                          }
                  })();
              `,
              options: [4, { outerIIFEBody: 2 }],
              errors: expectedErrors([[2, 8, 4, "Keyword"], [3, 12, 8, "Keyword"], [4, 8, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  if(data) {
                  console.log('hi');
                  }
              `,
              output: unIndent`
                  if(data) {
                    console.log('hi');
                  }
              `,
              options: [2, { outerIIFEBody: 0 }],
              errors: expectedErrors([[2, 2, 0, "Identifier"]])
          },
          {
              code: unIndent`
                  var ns = function(){
                      function fooVar(x) {
                          return x + 1;
                      }
                  }(x);
              `,
              output: unIndent`
                  var ns = function(){
                          function fooVar(x) {
                              return x + 1;
                          }
                  }(x);
              `,
              options: [4, { outerIIFEBody: 2 }],
              errors: expectedErrors([[2, 8, 4, "Keyword"], [3, 12, 8, "Keyword"], [4, 8, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  var obj = {
                    foo: function() {
                    return true;
                    }()
                  };
              `,
              output: unIndent`
                  var obj = {
                    foo: function() {
                      return true;
                    }()
                  };
              `,
              options: [2, { outerIIFEBody: 0 }],
              errors: expectedErrors([[3, 4, 2, "Keyword"]])
          },
          {
              code: unIndent`
                  typeof function() {
                      function fooVar(x) {
                        return x + 1;
                      }
                  }();
              `,
              output: unIndent`
                  typeof function() {
                    function fooVar(x) {
                      return x + 1;
                    }
                  }();
              `,
              options: [2, { outerIIFEBody: 2 }],
              errors: expectedErrors([[2, 2, 4, "Keyword"], [3, 4, 6, "Keyword"], [4, 2, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  {
                  \t!function(x) {
                  \t\t\t\treturn x + 1;
                  \t}()
                  };
              `,
              output: unIndent`
                  {
                  \t!function(x) {
                  \t\treturn x + 1;
                  \t}()
                  };
              `,
              options: ["tab", { outerIIFEBody: 3 }],
              errors: expectedErrors("tab", [[3, 2, 4, "Keyword"]])
          },
          {
              code: unIndent`
                  Buffer
                  .toString()
              `,
              output: unIndent`
                  Buffer
                      .toString()
              `,
              options: [4, { MemberExpression: 1 }],
              errors: expectedErrors([[2, 4, 0, "Punctuator"]])
          },
          {
              code: unIndent`
                  Buffer
                      .indexOf('a')
                  .toString()
              `,
              output: unIndent`
                  Buffer
                      .indexOf('a')
                      .toString()
              `,
              options: [4, { MemberExpression: 1 }],
              errors: expectedErrors([[3, 4, 0, "Punctuator"]])
          },
          {
              code: unIndent`
                  Buffer.
                  length
              `,
              output: unIndent`
                  Buffer.
                      length
              `,
              options: [4, { MemberExpression: 1 }],
              errors: expectedErrors([[2, 4, 0, "Identifier"]])
          },
          {
              code: unIndent`
                  Buffer.
                  \t\tlength
              `,
              output: unIndent`
                  Buffer.
                  \tlength
              `,
              options: ["tab", { MemberExpression: 1 }],
              errors: expectedErrors("tab", [[2, 1, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  Buffer
                    .foo
                    .bar
              `,
              output: unIndent`
                  Buffer
                      .foo
                      .bar
              `,
              options: [2, { MemberExpression: 2 }],
              errors: expectedErrors([[2, 4, 2, "Punctuator"], [3, 4, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  function foo() {
                      new
                      .target
                  }
              `,
              output: unIndent`
                  function foo() {
                      new
                          .target
                  }
              `,
              errors: expectedErrors([3, 8, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  function foo() {
                      new.
                      target
                  }
              `,
              output: unIndent`
                  function foo() {
                      new.
                          target
                  }
              `,
              errors: expectedErrors([3, 8, 4, "Identifier"])
          },
          {
  
              // Indentation with multiple else statements: https://github.com/eslint/eslint/issues/6956
  
              code: unIndent`
                  if (foo) bar();
                  else if (baz) foobar();
                    else if (qux) qux();
              `,
              output: unIndent`
                  if (foo) bar();
                  else if (baz) foobar();
                  else if (qux) qux();
              `,
              options: [2],
              errors: expectedErrors([3, 0, 2, "Keyword"])
          },
          {
              code: unIndent`
                  if (foo) bar();
                  else if (baz) foobar();
                    else qux();
              `,
              output: unIndent`
                  if (foo) bar();
                  else if (baz) foobar();
                  else qux();
              `,
              options: [2],
              errors: expectedErrors([3, 0, 2, "Keyword"])
          },
          {
              code: unIndent`
                  foo();
                    if (baz) foobar();
                    else qux();
              `,
              output: unIndent`
                  foo();
                  if (baz) foobar();
                  else qux();
              `,
              options: [2],
              errors: expectedErrors([[2, 0, 2, "Keyword"], [3, 0, 2, "Keyword"]])
          },
          {
              code: unIndent`
                  if (foo) bar();
                  else if (baz) foobar();
                       else if (bip) {
                         qux();
                       }
              `,
              output: unIndent`
                  if (foo) bar();
                  else if (baz) foobar();
                  else if (bip) {
                    qux();
                  }
              `,
              options: [2],
              errors: expectedErrors([[3, 0, 5, "Keyword"], [4, 2, 7, "Identifier"], [5, 0, 5, "Punctuator"]])
          },
          {
              code: unIndent`
                  if (foo) bar();
                  else if (baz) {
                      foobar();
                       } else if (boop) {
                         qux();
                       }
              `,
              output: unIndent`
                  if (foo) bar();
                  else if (baz) {
                    foobar();
                  } else if (boop) {
                    qux();
                  }
              `,
              options: [2],
              errors: expectedErrors([[3, 2, 4, "Identifier"], [4, 0, 5, "Punctuator"], [5, 2, 7, "Identifier"], [6, 0, 5, "Punctuator"]])
          },
          {
              code: unIndent`
                  function foo(aaa,
                      bbb, ccc, ddd) {
                        bar();
                  }
              `,
              output: unIndent`
                  function foo(aaa,
                    bbb, ccc, ddd) {
                      bar();
                  }
              `,
              options: [2, { FunctionDeclaration: { parameters: 1, body: 2 } }],
              errors: expectedErrors([[2, 2, 4, "Identifier"], [3, 4, 6, "Identifier"]])
          },
          {
              code: unIndent`
                  function foo(aaa, bbb,
                    ccc, ddd) {
                  bar();
                  }
              `,
              output: unIndent`
                  function foo(aaa, bbb,
                        ccc, ddd) {
                    bar();
                  }
              `,
              options: [2, { FunctionDeclaration: { parameters: 3, body: 1 } }],
              errors: expectedErrors([[2, 6, 2, "Identifier"], [3, 2, 0, "Identifier"]])
          },
          {
              code: unIndent`
                  function foo(aaa,
                          bbb,
                    ccc) {
                        bar();
                  }
              `,
              output: unIndent`
                  function foo(aaa,
                      bbb,
                      ccc) {
                              bar();
                  }
              `,
              options: [4, { FunctionDeclaration: { parameters: 1, body: 3 } }],
              errors: expectedErrors([[2, 4, 8, "Identifier"], [3, 4, 2, "Identifier"], [4, 12, 6, "Identifier"]])
          },
          {
              code: unIndent`
                  function foo(aaa,
                    bbb, ccc,
                                     ddd, eee, fff) {
                     bar();
                  }
              `,
              output: unIndent`
                  function foo(aaa,
                               bbb, ccc,
                               ddd, eee, fff) {
                    bar();
                  }
              `,
              options: [2, { FunctionDeclaration: { parameters: "first", body: 1 } }],
              errors: expectedErrors([[2, 13, 2, "Identifier"], [3, 13, 19, "Identifier"], [4, 2, 3, "Identifier"]])
          },
          {
              code: unIndent`
                  function foo(aaa, bbb)
                  {
                  bar();
                  }
              `,
              output: unIndent`
                  function foo(aaa, bbb)
                  {
                        bar();
                  }
              `,
              options: [2, { FunctionDeclaration: { body: 3 } }],
              errors: expectedErrors([3, 6, 0, "Identifier"])
          },
          {
              code: unIndent`
                  function foo(
                  aaa,
                      bbb) {
                  bar();
                  }
              `,
              output: unIndent`
                  function foo(
                    aaa,
                    bbb) {
                      bar();
                  }
              `,
              options: [2, { FunctionDeclaration: { parameters: "first", body: 2 } }],
              errors: expectedErrors([[2, 2, 0, "Identifier"], [3, 2, 4, "Identifier"], [4, 4, 0, "Identifier"]])
          },
          {
              code: unIndent`
                  var foo = function(aaa,
                    bbb,
                      ccc,
                        ddd) {
                    bar();
                  }
              `,
              output: unIndent`
                  var foo = function(aaa,
                      bbb,
                      ccc,
                      ddd) {
                  bar();
                  }
              `,
              options: [2, { FunctionExpression: { parameters: 2, body: 0 } }],
              errors: expectedErrors([[2, 4, 2, "Identifier"], [4, 4, 6, "Identifier"], [5, 0, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  var foo = function(aaa,
                     bbb,
                   ccc) {
                    bar();
                  }
              `,
              output: unIndent`
                  var foo = function(aaa,
                    bbb,
                    ccc) {
                                      bar();
                  }
              `,
              options: [2, { FunctionExpression: { parameters: 1, body: 10 } }],
              errors: expectedErrors([[2, 2, 3, "Identifier"], [3, 2, 1, "Identifier"], [4, 20, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  var foo = function(aaa,
                    bbb, ccc, ddd,
                                          eee, fff) {
                          bar();
                  }
              `,
              output: unIndent`
                  var foo = function(aaa,
                                     bbb, ccc, ddd,
                                     eee, fff) {
                      bar();
                  }
              `,
              options: [4, { FunctionExpression: { parameters: "first", body: 1 } }],
              errors: expectedErrors([[2, 19, 2, "Identifier"], [3, 19, 24, "Identifier"], [4, 4, 8, "Identifier"]])
          },
          {
              code: unIndent`
                  var foo = function(
                  aaa, bbb, ccc,
                      ddd, eee) {
                    bar();
                  }
              `,
              output: unIndent`
                  var foo = function(
                    aaa, bbb, ccc,
                    ddd, eee) {
                        bar();
                  }
              `,
              options: [2, { FunctionExpression: { parameters: "first", body: 3 } }],
              errors: expectedErrors([[2, 2, 0, "Identifier"], [3, 2, 4, "Identifier"], [4, 6, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  var foo = bar;
                  \t\t\tvar baz = qux;
              `,
              output: unIndent`
                  var foo = bar;
                  var baz = qux;
              `,
              options: [2],
              errors: expectedErrors([2, "0 spaces", "3 tabs", "Keyword"])
          },
          {
              code: unIndent`
                  function foo() {
                  \tbar();
                    baz();
                                qux();
                  }
              `,
              output: unIndent`
                  function foo() {
                  \tbar();
                  \tbaz();
                  \tqux();
                  }
              `,
              options: ["tab"],
              errors: expectedErrors("tab", [[3, "1 tab", "2 spaces", "Identifier"], [4, "1 tab", "14 spaces", "Identifier"]])
          },
          {
              code: unIndent`
                  function foo() {
                    bar();
                  \t\t}
              `,
              output: unIndent`
                  function foo() {
                    bar();
                  }
              `,
              options: [2],
              errors: expectedErrors([[3, "0 spaces", "2 tabs", "Punctuator"]])
          },
          {
              code: unIndent`
                  function foo() {
                    function bar() {
                          baz();
                    }
                  }
              `,
              output: unIndent`
                  function foo() {
                    function bar() {
                      baz();
                    }
                  }
              `,
              options: [2, { FunctionDeclaration: { body: 1 } }],
              errors: expectedErrors([3, 4, 8, "Identifier"])
          },
          {
              code: unIndent`
                  function foo() {
                    function bar(baz,
                      qux) {
                      foobar();
                    }
                  }
              `,
              output: unIndent`
                  function foo() {
                    function bar(baz,
                        qux) {
                      foobar();
                    }
                  }
              `,
              options: [2, { FunctionDeclaration: { body: 1, parameters: 2 } }],
              errors: expectedErrors([3, 6, 4, "Identifier"])
          },
          {
              code: unIndent`
                  function foo() {
                    var bar = function(baz,
                            qux) {
                      foobar();
                    };
                  }
              `,
              output: unIndent`
                  function foo() {
                    var bar = function(baz,
                          qux) {
                      foobar();
                    };
                  }
              `,
              options: [2, { FunctionExpression: { parameters: 3 } }],
              errors: expectedErrors([3, 8, 10, "Identifier"])
          },
          {
              code: unIndent`
                  foo.bar(
                        baz, qux, function() {
                          qux;
                        }
                  );
              `,
              output: unIndent`
                  foo.bar(
                        baz, qux, function() {
                              qux;
                        }
                  );
              `,
              options: [2, { FunctionExpression: { body: 3 }, CallExpression: { arguments: 3 } }],
              errors: expectedErrors([3, 12, 8, "Identifier"])
          },
          {
              code: unIndent`
                  {
                      try {
                      }
                  catch (err) {
                      }
                  finally {
                      }
                  }
              `,
              output: unIndent`
                  {
                      try {
                      }
                      catch (err) {
                      }
                      finally {
                      }
                  }
              `,
              errors: expectedErrors([
                  [4, 4, 0, "Keyword"],
                  [6, 4, 0, "Keyword"]
              ])
          },
          {
              code: unIndent`
                  {
                      do {
                      }
                  while (true)
                  }
              `,
              output: unIndent`
                  {
                      do {
                      }
                      while (true)
                  }
              `,
              errors: expectedErrors([4, 4, 0, "Keyword"])
          },
          {
              code: unIndent`
                  function foo() {
                    return (
                      1
                      )
                  }
              `,
              output: unIndent`
                  function foo() {
                    return (
                      1
                    )
                  }
              `,
              options: [2],
              errors: expectedErrors([[4, 2, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  function foo() {
                    return (
                      1
                      );
                  }
              `,
              output: unIndent`
                  function foo() {
                    return (
                      1
                    );
                  }
              `,
              options: [2],
              errors: expectedErrors([[4, 2, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  function test(){
                    switch(length){
                      case 1: return function(a){
                      return fn.call(that, a);
                      };
                    }
                  }
              `,
              output: unIndent`
                  function test(){
                    switch(length){
                      case 1: return function(a){
                        return fn.call(that, a);
                      };
                    }
                  }
              `,
              options: [2, { VariableDeclarator: 2, SwitchCase: 1 }],
              errors: expectedErrors([[4, 6, 4, "Keyword"]])
          },
          {
              code: unIndent`
                  function foo() {
                     return 1
                  }
              `,
              output: unIndent`
                  function foo() {
                    return 1
                  }
              `,
              options: [2],
              errors: expectedErrors([[2, 2, 3, "Keyword"]])
          },
          {
              code: unIndent`
                  foo(
                  bar,
                    baz,
                      qux);
              `,
              output: unIndent`
                  foo(
                    bar,
                    baz,
                    qux);
              `,
              options: [2, { CallExpression: { arguments: 1 } }],
              errors: expectedErrors([[2, 2, 0, "Identifier"], [4, 2, 4, "Identifier"]])
          },
          {
              code: unIndent`
                  foo(
                  \tbar,
                  \tbaz);
              `,
              output: unIndent`
                  foo(
                      bar,
                      baz);
              `,
              options: [2, { CallExpression: { arguments: 2 } }],
              errors: expectedErrors([[2, "4 spaces", "1 tab", "Identifier"], [3, "4 spaces", "1 tab", "Identifier"]])
          },
          {
              code: unIndent`
                  foo(bar,
                  \t\tbaz,
                  \t\tqux);
              `,
              output: unIndent`
                  foo(bar,
                  \tbaz,
                  \tqux);
              `,
              options: ["tab", { CallExpression: { arguments: 1 } }],
              errors: expectedErrors("tab", [[2, 1, 2, "Identifier"], [3, 1, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  foo(bar, baz,
                           qux);
              `,
              output: unIndent`
                  foo(bar, baz,
                      qux);
              `,
              options: [2, { CallExpression: { arguments: "first" } }],
              errors: expectedErrors([2, 4, 9, "Identifier"])
          },
          {
              code: unIndent`
                  foo(
                            bar,
                      baz);
              `,
              output: unIndent`
                  foo(
                    bar,
                    baz);
              `,
              options: [2, { CallExpression: { arguments: "first" } }],
              errors: expectedErrors([[2, 2, 10, "Identifier"], [3, 2, 4, "Identifier"]])
          },
          {
              code: unIndent`
                  foo(bar,
                    1 + 2,
                                !baz,
                          new Car('!')
                  );
              `,
              output: unIndent`
                  foo(bar,
                        1 + 2,
                        !baz,
                        new Car('!')
                  );
              `,
              options: [2, { CallExpression: { arguments: 3 } }],
              errors: expectedErrors([[2, 6, 2, "Numeric"], [3, 6, 14, "Punctuator"], [4, 6, 8, "Keyword"]])
          },
  
          // https://github.com/eslint/eslint/issues/7573
          {
              code: unIndent`
                  return (
                      foo
                      );
              `,
              output: unIndent`
                  return (
                      foo
                  );
              `,
              parserOptions: { ecmaFeatures: { globalReturn: true } },
              errors: expectedErrors([3, 0, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  return (
                      foo
                      )
              `,
              output: unIndent`
                  return (
                      foo
                  )
              `,
              parserOptions: { ecmaFeatures: { globalReturn: true } },
              errors: expectedErrors([3, 0, 4, "Punctuator"])
          },
  
          // https://github.com/eslint/eslint/issues/7604
          {
              code: unIndent`
                  if (foo) {
                          /* comment */bar();
                  }
              `,
              output: unIndent`
                  if (foo) {
                      /* comment */bar();
                  }
              `,
              errors: expectedErrors([2, 4, 8, "Block"])
          },
          {
              code: unIndent`
                  foo('bar',
                          /** comment */{
                          ok: true
                      });
              `,
              output: unIndent`
                  foo('bar',
                      /** comment */{
                          ok: true
                      });
              `,
              errors: expectedErrors([2, 4, 8, "Block"])
          },
          {
              code: unIndent`
                  foo(
                  (bar)
                  );
              `,
              output: unIndent`
                  foo(
                      (bar)
                  );
              `,
              options: [4, { CallExpression: { arguments: 1 } }],
              errors: expectedErrors([2, 4, 0, "Punctuator"])
          },
          {
              code: unIndent`
                  ((
                  foo
                  ))
              `,
              output: unIndent`
                  ((
                      foo
                  ))
              `,
              options: [4],
              errors: expectedErrors([2, 4, 0, "Identifier"])
          },
  
          // ternary expressions (https://github.com/eslint/eslint/issues/7420)
          {
              code: unIndent`
                  foo
                  ? bar
                      : baz
              `,
              output: unIndent`
                  foo
                    ? bar
                    : baz
              `,
              options: [2],
              errors: expectedErrors([[2, 2, 0, "Punctuator"], [3, 2, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  [
                      foo ?
                          bar :
                          baz,
                          qux
                  ]
              `,
              output: unIndent`
                  [
                      foo ?
                          bar :
                          baz,
                      qux
                  ]
              `,
              errors: expectedErrors([5, 4, 8, "Identifier"])
          },
          {
  
              /*
               * Checking comments:
               * https://github.com/eslint/eslint/issues/6571
               */
              code: unIndent`
                  foo();
                    // comment
                      /* multiline
                    comment */
                  bar();
                   // trailing comment
              `,
              output: unIndent`
                  foo();
                  // comment
                  /* multiline
                    comment */
                  bar();
                  // trailing comment
              `,
              options: [2],
              errors: expectedErrors([[2, 0, 2, "Line"], [3, 0, 4, "Block"], [6, 0, 1, "Line"]])
          },
          {
              code: "  // comment",
              output: "// comment",
              errors: expectedErrors([1, 0, 2, "Line"])
          },
          {
              code: unIndent`
                  foo
                    // comment
              `,
              output: unIndent`
                  foo
                  // comment
              `,
              errors: expectedErrors([2, 0, 2, "Line"])
          },
          {
              code: unIndent`
                    // comment
                  foo
              `,
              output: unIndent`
                  // comment
                  foo
              `,
              errors: expectedErrors([1, 0, 2, "Line"])
          },
          {
              code: unIndent`
                  [
                          // no elements
                  ]
              `,
              output: unIndent`
                  [
                      // no elements
                  ]
              `,
              errors: expectedErrors([2, 4, 8, "Line"])
          },
          {
  
              /*
               * Destructuring assignments:
               * https://github.com/eslint/eslint/issues/6813
               */
              code: unIndent`
                  var {
                  foo,
                    bar,
                      baz: qux,
                        foobar: baz = foobar
                    } = qux;
              `,
              output: unIndent`
                  var {
                    foo,
                    bar,
                    baz: qux,
                    foobar: baz = foobar
                  } = qux;
              `,
              options: [2],
              errors: expectedErrors([[2, 2, 0, "Identifier"], [4, 2, 4, "Identifier"], [5, 2, 6, "Identifier"], [6, 0, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  const {
                    a
                  } = {
                      a: 1
                    }
              `,
              output: unIndent`
                  const {
                    a
                  } = {
                    a: 1
                  }
              `,
              options: [2],
              errors: expectedErrors([[4, 2, 4, "Identifier"], [5, 0, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  var foo = [
                             bar,
                    baz
                            ]
              `,
              output: unIndent`
                  var foo = [
                      bar,
                      baz
                  ]
              `,
              errors: expectedErrors([[2, 4, 11, "Identifier"], [3, 4, 2, "Identifier"], [4, 0, 10, "Punctuator"]])
          },
          {
              code: unIndent`
                  var foo = [bar,
                  baz,
                      qux
                  ]
              `,
              output: unIndent`
                  var foo = [bar,
                      baz,
                      qux
                  ]
              `,
              errors: expectedErrors([2, 4, 0, "Identifier"])
          },
          {
              code: unIndent`
                  var foo = [bar,
                    baz,
                    qux
                  ]
              `,
              output: unIndent`
                  var foo = [bar,
                  baz,
                  qux
                  ]
              `,
              options: [2, { ArrayExpression: 0 }],
              errors: expectedErrors([[2, 0, 2, "Identifier"], [3, 0, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  var foo = [bar,
                    baz,
                    qux
                  ]
              `,
              output: unIndent`
                  var foo = [bar,
                                  baz,
                                  qux
                  ]
              `,
              options: [2, { ArrayExpression: 8 }],
              errors: expectedErrors([[2, 16, 2, "Identifier"], [3, 16, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  var foo = [bar,
                      baz,
                      qux
                  ]
              `,
              output: unIndent`
                  var foo = [bar,
                             baz,
                             qux
                  ]
              `,
              options: [2, { ArrayExpression: "first" }],
              errors: expectedErrors([[2, 11, 4, "Identifier"], [3, 11, 4, "Identifier"]])
          },
          {
              code: unIndent`
                  var foo = [bar,
                      baz, qux
                  ]
              `,
              output: unIndent`
                  var foo = [bar,
                             baz, qux
                  ]
              `,
              options: [2, { ArrayExpression: "first" }],
              errors: expectedErrors([2, 11, 4, "Identifier"])
          },
          {
              code: unIndent`
                  var foo = [
                          { bar: 1,
                              baz: 2 },
                          { bar: 3,
                              qux: 4 }
                  ]
              `,
              output: unIndent`
                  var foo = [
                          { bar: 1,
                            baz: 2 },
                          { bar: 3,
                            qux: 4 }
                  ]
              `,
              options: [4, { ArrayExpression: 2, ObjectExpression: "first" }],
              errors: expectedErrors([[3, 10, 12, "Identifier"], [5, 10, 12, "Identifier"]])
          },
          {
              code: unIndent`
                  var foo = {
                    bar: 1,
                    baz: 2
                  };
              `,
              output: unIndent`
                  var foo = {
                  bar: 1,
                  baz: 2
                  };
              `,
              options: [2, { ObjectExpression: 0 }],
              errors: expectedErrors([[2, 0, 2, "Identifier"], [3, 0, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  var quux = { foo: 1, bar: 2,
                  baz: 3 }
              `,
              output: unIndent`
                  var quux = { foo: 1, bar: 2,
                               baz: 3 }
              `,
              options: [2, { ObjectExpression: "first" }],
              errors: expectedErrors([2, 13, 0, "Identifier"])
          },
          {
              code: unIndent`
                  function foo() {
                      [
                              foo
                      ]
                  }
              `,
              output: unIndent`
                  function foo() {
                    [
                            foo
                    ]
                  }
              `,
              options: [2, { ArrayExpression: 4 }],
              errors: expectedErrors([[2, 2, 4, "Punctuator"], [3, 10, 12, "Identifier"], [4, 2, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  var [
                  foo,
                    bar,
                      baz,
                        foobar = baz
                    ] = qux;
              `,
              output: unIndent`
                  var [
                    foo,
                    bar,
                    baz,
                    foobar = baz
                  ] = qux;
              `,
              options: [2],
              errors: expectedErrors([[2, 2, 0, "Identifier"], [4, 2, 4, "Identifier"], [5, 2, 6, "Identifier"], [6, 0, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  import {
                  foo,
                    bar,
                      baz
                  } from 'qux';
              `,
              output: unIndent`
                  import {
                      foo,
                      bar,
                      baz
                  } from 'qux';
              `,
              parserOptions: { sourceType: "module" },
              errors: expectedErrors([[2, 4, 0, "Identifier"], [3, 4, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  import { foo,
                           bar,
                            baz,
                  } from 'qux';
              `,
              output: unIndent`
                  import { foo,
                           bar,
                           baz,
                  } from 'qux';
              `,
              options: [4, { ImportDeclaration: "first" }],
              parserOptions: { sourceType: "module" },
              errors: expectedErrors([[3, 9, 10, "Identifier"]])
          },
          {
              code: unIndent`
                  import { foo,
                      bar,
                       baz,
                  } from 'qux';
              `,
              output: unIndent`
                  import { foo,
                      bar,
                      baz,
                  } from 'qux';
              `,
              options: [2, { ImportDeclaration: 2 }],
              parserOptions: { sourceType: "module" },
              errors: expectedErrors([[3, 4, 5, "Identifier"]])
          },
          {
              code: unIndent`
                  export {
                  foo,
                    bar,
                      baz
                  };
              `,
              output: unIndent`
                  export {
                      foo,
                      bar,
                      baz
                  };
              `,
              parserOptions: { sourceType: "module" },
              errors: expectedErrors([[2, 4, 0, "Identifier"], [3, 4, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  export {
                  foo,
                    bar,
                      baz
                  } from 'qux';
              `,
              output: unIndent`
                  export {
                      foo,
                      bar,
                      baz
                  } from 'qux';
              `,
              parserOptions: { sourceType: "module" },
              errors: expectedErrors([[2, 4, 0, "Identifier"], [3, 4, 2, "Identifier"]])
          },
          {
  
              // https://github.com/eslint/eslint/issues/7233
              code: unIndent`
                  var folder = filePath
                    .foo()
                        .bar;
              `,
              output: unIndent`
                  var folder = filePath
                      .foo()
                      .bar;
              `,
              options: [2, { MemberExpression: 2 }],
              errors: expectedErrors([[2, 4, 2, "Punctuator"], [3, 4, 6, "Punctuator"]])
          },
          {
              code: unIndent`
                  for (const foo of bar)
                      baz();
              `,
              output: unIndent`
                  for (const foo of bar)
                    baz();
              `,
              options: [2],
              errors: expectedErrors([2, 2, 4, "Identifier"])
          },
          {
              code: unIndent`
                  var x = () =>
                      5;
              `,
              output: unIndent`
                  var x = () =>
                    5;
              `,
              options: [2],
              errors: expectedErrors([2, 2, 4, "Numeric"])
          },
          {
  
              // BinaryExpressions with parens
              code: unIndent`
                  foo && (
                          bar
                  )
              `,
              output: unIndent`
                  foo && (
                      bar
                  )
              `,
              options: [4],
              errors: expectedErrors([2, 4, 8, "Identifier"])
          },
          {
              code: unIndent`
                  [
                  ] || [
                      ]
              `,
              output: unIndent`
                  [
                  ] || [
                  ]
              `,
              errors: expectedErrors([3, 0, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  foo
                          || (
                                  bar
                              )
              `,
              output: unIndent`
                  foo
                          || (
                              bar
                          )
              `,
              errors: expectedErrors([[3, 12, 16, "Identifier"], [4, 8, 12, "Punctuator"]])
          },
          {
              code: unIndent`
                  1
                  + (
                          1
                      )
              `,
              output: unIndent`
                  1
                  + (
                      1
                  )
              `,
              errors: expectedErrors([[3, 4, 8, "Numeric"], [4, 0, 4, "Punctuator"]])
          },
  
          // Template curlies
          {
              code: unIndent`
                  \`foo\${
                  bar}\`
              `,
              output: unIndent`
                  \`foo\${
                    bar}\`
              `,
              options: [2],
              errors: expectedErrors([2, 2, 0, "Identifier"])
          },
          {
              code: unIndent`
                  \`foo\${
                      \`bar\${
                  baz}\`}\`
              `,
              output: unIndent`
                  \`foo\${
                    \`bar\${
                      baz}\`}\`
              `,
              options: [2],
              errors: expectedErrors([[2, 2, 4, "Template"], [3, 4, 0, "Identifier"]])
          },
          {
              code: unIndent`
                  \`foo\${
                      \`bar\${
                    baz
                      }\`
                    }\`
              `,
              output: unIndent`
                  \`foo\${
                    \`bar\${
                      baz
                    }\`
                  }\`
              `,
              options: [2],
              errors: expectedErrors([[2, 2, 4, "Template"], [3, 4, 2, "Identifier"], [4, 2, 4, "Template"], [5, 0, 2, "Template"]])
          },
          {
              code: unIndent`
                  \`foo\${
                  (
                    bar
                  )
                  }\`
              `,
              output: unIndent`
                  \`foo\${
                    (
                      bar
                    )
                  }\`
              `,
              options: [2],
              errors: expectedErrors([[2, 2, 0, "Punctuator"], [3, 4, 2, "Identifier"], [4, 2, 0, "Punctuator"]])
          },
          {
              code: unIndent`
                  function foo() {
                      \`foo\${bar}baz\${
                  qux}foo\${
                    bar}baz\`
                  }
              `,
              output: unIndent`
                  function foo() {
                      \`foo\${bar}baz\${
                          qux}foo\${
                          bar}baz\`
                  }
              `,
              errors: expectedErrors([[3, 8, 0, "Identifier"], [4, 8, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  function foo() {
                      const template = \`the indentation of
                  a curly element in a \${
                          node.type
                      } node is checked.\`;
                  }
              `,
              output: unIndent`
                  function foo() {
                      const template = \`the indentation of
                  a curly element in a \${
                      node.type
                  } node is checked.\`;
                  }
              `,
              errors: expectedErrors([[4, 4, 8, "Identifier"], [5, 0, 4, "Template"]])
          },
          {
              code: unIndent`
                  function foo() {
                      const template = \`this time the
                  closing curly is at the end of the line \${
                              foo}
                          so the spaces before this line aren't removed.\`;
                  }
              `,
              output: unIndent`
                  function foo() {
                      const template = \`this time the
                  closing curly is at the end of the line \${
                      foo}
                          so the spaces before this line aren't removed.\`;
                  }
              `,
              errors: expectedErrors([4, 4, 12, "Identifier"])
          },
          {
  
              /*
               * https://github.com/eslint/eslint/issues/1801
               * Note: This issue also mentioned checking the indentation for the 2 below. However,
               * this is intentionally ignored because everyone seems to have a different idea of how
               * BinaryExpressions should be indented.
               */
              code: unIndent`
                  if (true) {
                      a = (
                  1 +
                          2);
                  }
              `,
              output: unIndent`
                  if (true) {
                      a = (
                          1 +
                          2);
                  }
              `,
              errors: expectedErrors([3, 8, 0, "Numeric"])
          },
          {
  
              // https://github.com/eslint/eslint/issues/3737
              code: unIndent`
                  if (true) {
                      for (;;) {
                        b();
                    }
                  }
              `,
              output: unIndent`
                  if (true) {
                    for (;;) {
                      b();
                    }
                  }
              `,
              options: [2],
              errors: expectedErrors([[2, 2, 4, "Keyword"], [3, 4, 6, "Identifier"]])
          },
          {
  
              // https://github.com/eslint/eslint/issues/6670
              code: unIndent`
                  function f() {
                      return asyncCall()
                      .then(
                                 'some string',
                                [
                                1,
                           2,
                                                     3
                                        ]
                  );
                   }
              `,
              output: unIndent`
                  function f() {
                      return asyncCall()
                          .then(
                              'some string',
                              [
                                  1,
                                  2,
                                  3
                              ]
                          );
                  }
              `,
              options: [4, { MemberExpression: 1, CallExpression: { arguments: 1 } }],
              errors: expectedErrors([
                  [3, 8, 4, "Punctuator"],
                  [4, 12, 15, "String"],
                  [5, 12, 14, "Punctuator"],
                  [6, 16, 14, "Numeric"],
                  [7, 16, 9, "Numeric"],
                  [8, 16, 35, "Numeric"],
                  [9, 12, 22, "Punctuator"],
                  [10, 8, 0, "Punctuator"],
                  [11, 0, 1, "Punctuator"]
              ])
          },
  
          // https://github.com/eslint/eslint/issues/7242
          {
              code: unIndent`
                  var x = [
                        [1],
                    [2]
                  ]
              `,
              output: unIndent`
                  var x = [
                      [1],
                      [2]
                  ]
              `,
              errors: expectedErrors([[2, 4, 6, "Punctuator"], [3, 4, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  var y = [
                        {a: 1},
                    {b: 2}
                  ]
              `,
              output: unIndent`
                  var y = [
                      {a: 1},
                      {b: 2}
                  ]
              `,
              errors: expectedErrors([[2, 4, 6, "Punctuator"], [3, 4, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  echo = spawn('cmd.exe',
                              ['foo', 'bar',
                               'baz']);
              `,
              output: unIndent`
                  echo = spawn('cmd.exe',
                               ['foo', 'bar',
                                'baz']);
              `,
              options: [2, { ArrayExpression: "first", CallExpression: { arguments: "first" } }],
              errors: expectedErrors([[2, 13, 12, "Punctuator"], [3, 14, 13, "String"]])
          },
          {
  
              // https://github.com/eslint/eslint/issues/7522
              code: unIndent`
                  foo(
                    )
              `,
              output: unIndent`
                  foo(
                  )
              `,
              errors: expectedErrors([2, 0, 2, "Punctuator"])
          },
          {
  
              // https://github.com/eslint/eslint/issues/7616
              code: unIndent`
                  foo(
                          bar,
                      {
                          baz: 1
                      }
                  )
              `,
              output: unIndent`
                  foo(
                      bar,
                      {
                          baz: 1
                      }
                  )
              `,
              options: [4, { CallExpression: { arguments: "first" } }],
              errors: expectedErrors([[2, 4, 8, "Identifier"]])
          },
          {
              code: "  new Foo",
              output: "new Foo",
              errors: expectedErrors([1, 0, 2, "Keyword"])
          },
          {
              code: unIndent`
                  export {
                  foo,
                          bar,
                    baz
                  }
              `,
              output: unIndent`
                  export {
                      foo,
                      bar,
                      baz
                  }
              `,
              parserOptions: { sourceType: "module" },
              errors: expectedErrors([[2, 4, 0, "Identifier"], [3, 4, 8, "Identifier"], [4, 4, 2, "Identifier"]])
          },
          {
              code: unIndent`
                  foo
                      ? bar
                  : baz
              `,
              output: unIndent`
                  foo
                      ? bar
                      : baz
              `,
              options: [4, { flatTernaryExpressions: true }],
              errors: expectedErrors([3, 4, 0, "Punctuator"])
          },
          {
              code: unIndent`
                  foo ?
                      bar :
                  baz
              `,
              output: unIndent`
                  foo ?
                      bar :
                      baz
              `,
              options: [4, { flatTernaryExpressions: true }],
              errors: expectedErrors([3, 4, 0, "Identifier"])
          },
          {
              code: unIndent`
                  foo ?
                      bar
                    : baz
              `,
              output: unIndent`
                  foo ?
                      bar
                      : baz
              `,
              options: [4, { flatTernaryExpressions: true }],
              errors: expectedErrors([3, 4, 2, "Punctuator"])
          },
          {
              code: unIndent`
                  foo
                      ? bar :
                  baz
              `,
              output: unIndent`
                  foo
                      ? bar :
                      baz
              `,
              options: [4, { flatTernaryExpressions: true }],
              errors: expectedErrors([3, 4, 0, "Identifier"])
          },
          {
              code: unIndent`
                  foo ? bar
                      : baz ? qux
                          : foobar ? boop
                              : beep
              `,
              output: unIndent`
                  foo ? bar
                      : baz ? qux
                      : foobar ? boop
                      : beep
              `,
              options: [4, { flatTernaryExpressions: true }],
              errors: expectedErrors([
                  [3, 4, 8, "Punctuator"],
                  [4, 4, 12, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  foo ? bar :
                      baz ? qux :
                          foobar ? boop :
                              beep
              `,
              output: unIndent`
                  foo ? bar :
                      baz ? qux :
                      foobar ? boop :
                      beep
              `,
              options: [4, { flatTernaryExpressions: true }],
              errors: expectedErrors([
                  [3, 4, 8, "Identifier"],
                  [4, 4, 12, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  var a =
                      foo ? bar :
                        baz ? qux :
                    foobar ? boop :
                      /*else*/ beep
              `,
              output: unIndent`
                  var a =
                      foo ? bar :
                      baz ? qux :
                      foobar ? boop :
                      /*else*/ beep
              `,
              options: [4, { flatTernaryExpressions: true }],
              errors: expectedErrors([
                  [3, 4, 6, "Identifier"],
                  [4, 4, 2, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  var a =
                      foo
                      ? bar
                      : baz
              `,
              output: unIndent`
                  var a =
                      foo
                          ? bar
                          : baz
              `,
              options: [4, { flatTernaryExpressions: true }],
              errors: expectedErrors([
                  [3, 8, 4, "Punctuator"],
                  [4, 8, 4, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  foo ? bar
                      : baz ? qux
                      : foobar ? boop
                      : beep
              `,
              output: unIndent`
                  foo ? bar
                      : baz ? qux
                          : foobar ? boop
                              : beep
              `,
              options: [4, { flatTernaryExpressions: false }],
              errors: expectedErrors([
                  [3, 8, 4, "Punctuator"],
                  [4, 12, 4, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  foo ? bar :
                      baz ? qux :
                      foobar ? boop :
                      beep
              `,
              output: unIndent`
                  foo ? bar :
                      baz ? qux :
                          foobar ? boop :
                              beep
              `,
              options: [4, { flatTernaryExpressions: false }],
              errors: expectedErrors([
                  [3, 8, 4, "Identifier"],
                  [4, 12, 4, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  foo
                      ? bar
                      : baz
                      ? qux
                      : foobar
                      ? boop
                      : beep
              `,
              output: unIndent`
                  foo
                      ? bar
                      : baz
                          ? qux
                          : foobar
                              ? boop
                              : beep
              `,
              options: [4, { flatTernaryExpressions: false }],
              errors: expectedErrors([
                  [4, 8, 4, "Punctuator"],
                  [5, 8, 4, "Punctuator"],
                  [6, 12, 4, "Punctuator"],
                  [7, 12, 4, "Punctuator"]
              ])
          },
          {
              code: unIndent`
                  foo ?
                      bar :
                      baz ?
                      qux :
                      foobar ?
                      boop :
                      beep
              `,
              output: unIndent`
                  foo ?
                      bar :
                      baz ?
                          qux :
                          foobar ?
                              boop :
                              beep
              `,
              options: [4, { flatTernaryExpressions: false }],
              errors: expectedErrors([
                  [4, 8, 4, "Identifier"],
                  [5, 8, 4, "Identifier"],
                  [6, 12, 4, "Identifier"],
                  [7, 12, 4, "Identifier"]
              ])
          },
          {
              code: unIndent`
                  foo.bar('baz', function(err) {
                            qux;
                  });
              `,
              output: unIndent`
                  foo.bar('baz', function(err) {
                    qux;
                  });
              `,
              options: [2, { CallExpression: { arguments: "first" } }],
              errors: expectedErrors([2, 2, 10, "Identifier"])
          },
          {
              code: unIndent`
                  foo.bar(function() {
                    cookies;
                  }).baz(function() {
                      cookies;
                    });
              `,
              output: unIndent`
                  foo.bar(function() {
                    cookies;
                  }).baz(function() {
                    cookies;
                  });
              `,
              options: [2, { MemberExpression: 1 }],
              errors: expectedErrors([[4, 2, 4, "Identifier"], [5, 0, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  foo.bar().baz(function() {
                    cookies;
                  }).qux(function() {
                      cookies;
                    });
              `,
              output: unIndent`
                  foo.bar().baz(function() {
                    cookies;
                  }).qux(function() {
                    cookies;
                  });
              `,
              options: [2, { MemberExpression: 1 }],
              errors: expectedErrors([[4, 2, 4, "Identifier"], [5, 0, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  [ foo,
                    bar ].forEach(function() {
                      baz;
                    })
              `,
              output: unIndent`
                  [ foo,
                    bar ].forEach(function() {
                    baz;
                  })
              `,
              options: [2, { ArrayExpression: "first", MemberExpression: 1 }],
              errors: expectedErrors([[3, 2, 4, "Identifier"], [4, 0, 2, "Punctuator"]])
          },
          {
              code: unIndent`
                  foo[
                      bar
                      ];
              `,
              output: unIndent`
                  foo[
                      bar
                  ];
              `,
              options: [4, { MemberExpression: 1 }],
              errors: expectedErrors([3, 0, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  foo({
                  bar: 1,
                  baz: 2
                  })
              `,
              output: unIndent`
                  foo({
                      bar: 1,
                      baz: 2
                  })
              `,
              options: [4, { ObjectExpression: "first" }],
              errors: expectedErrors([[2, 4, 0, "Identifier"], [3, 4, 0, "Identifier"]])
          },
          {
              code: unIndent`
                  foo(
                                          bar, baz,
                                          qux);
              `,
              output: unIndent`
                  foo(
                    bar, baz,
                    qux);
              `,
              options: [2, { CallExpression: { arguments: "first" } }],
              errors: expectedErrors([[2, 2, 24, "Identifier"], [3, 2, 24, "Identifier"]])
          },
          {
              code: unIndent`
                  if (foo) bar()
  
                      ; [1, 2, 3].map(baz)
              `,
              output: unIndent`
                  if (foo) bar()
  
                  ; [1, 2, 3].map(baz)
              `,
              errors: expectedErrors([3, 0, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  if (foo)
                  ;
              `,
              output: unIndent`
                  if (foo)
                      ;
              `,
              errors: expectedErrors([2, 4, 0, "Punctuator"])
          },
          {
              code: unIndent`
                  import {foo}
                  from 'bar';
              `,
              output: unIndent`
                  import {foo}
                      from 'bar';
              `,
              parserOptions: { sourceType: "module" },
              errors: expectedErrors([2, 4, 0, "Identifier"])
          },
          {
              code: unIndent`
                  export {foo}
                  from 'bar';
              `,
              output: unIndent`
                  export {foo}
                      from 'bar';
              `,
              parserOptions: { sourceType: "module" },
              errors: expectedErrors([2, 4, 0, "Identifier"])
          },
          {
              code: unIndent`
                  (
                      a
                  ) => b => {
                          c
                      }
              `,
              output: unIndent`
                  (
                      a
                  ) => b => {
                      c
                  }
              `,
              errors: expectedErrors([[4, 4, 8, "Identifier"], [5, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  (
                      a
                  ) => b => c => d => {
                          e
                      }
              `,
              output: unIndent`
                  (
                      a
                  ) => b => c => d => {
                      e
                  }
              `,
              errors: expectedErrors([[4, 4, 8, "Identifier"], [5, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  if (
                      foo
                  ) bar(
                          baz
                      );
              `,
              output: unIndent`
                  if (
                      foo
                  ) bar(
                      baz
                  );
              `,
              errors: expectedErrors([[4, 4, 8, "Identifier"], [5, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  (
                      foo
                  )(
                          bar
                      )
              `,
              output: unIndent`
                  (
                      foo
                  )(
                      bar
                  )
              `,
              errors: expectedErrors([[4, 4, 8, "Identifier"], [5, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  (() =>
                      foo
                  )(
                          bar
                      )
              `,
              output: unIndent`
                  (() =>
                      foo
                  )(
                      bar
                  )
              `,
              errors: expectedErrors([[4, 4, 8, "Identifier"], [5, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  (() => {
                      foo();
                  })(
                          bar
                      )
              `,
              output: unIndent`
                  (() => {
                      foo();
                  })(
                      bar
                  )
              `,
              errors: expectedErrors([[4, 4, 8, "Identifier"], [5, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  foo.
                    bar.
                        baz
              `,
              output: unIndent`
                  foo.
                      bar.
                      baz
              `,
              errors: expectedErrors([[2, 4, 2, "Identifier"], [3, 4, 6, "Identifier"]])
          },
          {
              code: unIndent`
                  const foo = a.b(),
                      longName
                      = (baz(
                              'bar',
                              'bar'
                          ));
              `,
              output: unIndent`
                  const foo = a.b(),
                      longName
                      = (baz(
                          'bar',
                          'bar'
                      ));
              `,
              errors: expectedErrors([[4, 8, 12, "String"], [5, 8, 12, "String"], [6, 4, 8, "Punctuator"]])
          },
          {
              code: unIndent`
                  const foo = a.b(),
                      longName =
                      (baz(
                              'bar',
                              'bar'
                          ));
              `,
              output: unIndent`
                  const foo = a.b(),
                      longName =
                      (baz(
                          'bar',
                          'bar'
                      ));
              `,
              errors: expectedErrors([[4, 8, 12, "String"], [5, 8, 12, "String"], [6, 4, 8, "Punctuator"]])
          },
          {
              code: unIndent`
                  const foo = a.b(),
                      longName
                          =baz(
                              'bar',
                              'bar'
                      );
              `,
              output: unIndent`
                  const foo = a.b(),
                      longName
                          =baz(
                              'bar',
                              'bar'
                          );
              `,
              errors: expectedErrors([[6, 8, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  const foo = a.b(),
                      longName
                          =(
                          'fff'
                          );
              `,
              output: unIndent`
                  const foo = a.b(),
                      longName
                          =(
                              'fff'
                          );
              `,
              errors: expectedErrors([[4, 12, 8, "String"]])
          },
  
          //----------------------------------------------------------------------
          // Ignore Unknown Nodes
          //----------------------------------------------------------------------
  
          {
              code: unIndent`
                  namespace Foo {
                      const bar = 3,
                      baz = 2;
  
                      if (true) {
                      const bax = 3;
                      }
                  }
              `,
              output: unIndent`
                  namespace Foo {
                      const bar = 3,
                          baz = 2;
  
                      if (true) {
                          const bax = 3;
                      }
                  }
              `,
              errors: expectedErrors([[3, 8, 4, "Identifier"], [6, 8, 4, "Keyword"]]),
              parser: parser("unknown-nodes/namespace-invalid")
          },
          {
              code: unIndent`
                  abstract class Foo {
                      public bar() {
                          let aaa = 4,
                          boo;
  
                          if (true) {
                          boo = 3;
                          }
  
                      boo = 3 + 2;
                      }
                  }
              `,
              output: unIndent`
                  abstract class Foo {
                      public bar() {
                          let aaa = 4,
                              boo;
  
                          if (true) {
                              boo = 3;
                          }
  
                          boo = 3 + 2;
                      }
                  }
              `,
              errors: expectedErrors([[4, 12, 8, "Identifier"], [7, 12, 8, "Identifier"], [10, 8, 4, "Identifier"]]),
              parser: parser("unknown-nodes/abstract-class-invalid")
          },
          {
              code: unIndent`
                  function foo() {
                      function bar() {
                          abstract class X {
                          public baz() {
                          if (true) {
                          qux();
                          }
                          }
                          }
                      }
                  }
              `,
              output: unIndent`
                  function foo() {
                      function bar() {
                          abstract class X {
                              public baz() {
                                  if (true) {
                                      qux();
                                  }
                              }
                          }
                      }
                  }
              `,
              errors: expectedErrors([
                  [4, 12, 8, "Keyword"],
                  [5, 16, 8, "Keyword"],
                  [6, 20, 8, "Identifier"],
                  [7, 16, 8, "Punctuator"],
                  [8, 12, 8, "Punctuator"]
              ]),
              parser: parser("unknown-nodes/functions-with-abstract-class-invalid")
          },
          {
              code: unIndent`
                  namespace Unknown {
                      function foo() {
                      function bar() {
                              abstract class X {
                                  public baz() {
                                      if (true) {
                                      qux();
                                      }
                                  }
                              }
                          }
                      }
                  }
              `,
              output: unIndent`
                  namespace Unknown {
                      function foo() {
                          function bar() {
                              abstract class X {
                                  public baz() {
                                      if (true) {
                                          qux();
                                      }
                                  }
                              }
                          }
                      }
                  }
              `,
              errors: expectedErrors([
                  [3, 8, 4, "Keyword"],
                  [7, 24, 20, "Identifier"]
              ]),
              parser: parser("unknown-nodes/namespace-with-functions-with-abstract-class-invalid")
          },
  
          //----------------------------------------------------------------------
          // JSX tests
          // Some of the following tests are adapted from the the tests in eslint-plugin-react.
          // License: https://github.com/yannickcr/eslint-plugin-react/blob/7ca9841f22d599f447a27ef5b2a97def9229d6c8/LICENSE
          //----------------------------------------------------------------------
  
          {
              code: unIndent`
                  <App>
                    <Foo />
                  </App>
              `,
              output: unIndent`
                  <App>
                      <Foo />
                  </App>
              `,
              errors: expectedErrors([2, 4, 2, "Punctuator"])
          },
          {
              code: unIndent`
                  <App>
                      <Foo />
                  </App>
              `,
              output: unIndent`
                  <App>
                    <Foo />
                  </App>
              `,
              options: [2],
              errors: expectedErrors([2, 2, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  <App>
                      <Foo />
                  </App>
              `,
              output: unIndent`
                  <App>
                  \t<Foo />
                  </App>
              `,
              options: ["tab"],
              errors: expectedErrors([2, "1 tab", "4 spaces", "Punctuator"])
          },
          {
              code: unIndent`
                  function App() {
                    return <App>
                      <Foo />
                           </App>;
                  }
              `,
              output: unIndent`
                  function App() {
                    return <App>
                      <Foo />
                    </App>;
                  }
              `,
              options: [2],
              errors: expectedErrors([4, 2, 9, "Punctuator"])
          },
          {
              code: unIndent`
                  function App() {
                    return (<App>
                      <Foo />
                      </App>);
                  }
              `,
              output: unIndent`
                  function App() {
                    return (<App>
                      <Foo />
                    </App>);
                  }
              `,
              options: [2],
              errors: expectedErrors([4, 2, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  function App() {
                    return (
                  <App>
                    <Foo />
                  </App>
                    );
                  }
              `,
              output: unIndent`
                  function App() {
                    return (
                      <App>
                        <Foo />
                      </App>
                    );
                  }
              `,
              options: [2],
              errors: expectedErrors([[3, 4, 0, "Punctuator"], [4, 6, 2, "Punctuator"], [5, 4, 0, "Punctuator"]])
          },
          {
              code: unIndent`
                  <App>
                   {test}
                  </App>
              `,
              output: unIndent`
                  <App>
                      {test}
                  </App>
              `,
              errors: expectedErrors([2, 4, 1, "Punctuator"])
          },
          {
              code: unIndent`
                  <App>
                      {options.map((option, index) => (
                          <option key={index} value={option.key}>
                             {option.name}
                          </option>
                      ))}
                  </App>
              `,
              output: unIndent`
                  <App>
                      {options.map((option, index) => (
                          <option key={index} value={option.key}>
                              {option.name}
                          </option>
                      ))}
                  </App>
              `,
              errors: expectedErrors([4, 12, 11, "Punctuator"])
          },
          {
              code: unIndent`
                  [
                    <div />,
                      <div />
                  ]
              `,
              output: unIndent`
                  [
                    <div />,
                    <div />
                  ]
              `,
              options: [2],
              errors: expectedErrors([3, 2, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  <App>
  
                   <Foo />
  
                  </App>
              `,
              output: unIndent`
                  <App>
  
                  \t<Foo />
  
                  </App>
              `,
              options: ["tab"],
              errors: expectedErrors([3, "1 tab", "1 space", "Punctuator"])
          },
          {
  
              /*
               * Multiline ternary
               * (colon at the end of the first expression)
               */
              code: unIndent`
                  foo ?
                      <Foo /> :
                  <Bar />
              `,
              output: unIndent`
                  foo ?
                      <Foo /> :
                      <Bar />
              `,
              errors: expectedErrors([3, 4, 0, "Punctuator"])
          },
          {
  
              /*
               * Multiline ternary
               * (colon on its own line)
               */
              code: unIndent`
                  foo ?
                      <Foo />
                  :
                  <Bar />
              `,
              output: unIndent`
                  foo ?
                      <Foo />
                      :
                      <Bar />
              `,
              errors: expectedErrors([[3, 4, 0, "Punctuator"], [4, 4, 0, "Punctuator"]])
          },
          {
  
              /*
               * Multiline ternary
               * (colon at the end of the first expression, parenthesized first expression)
               */
              code: unIndent`
                  foo ? (
                      <Foo />
                  ) :
                  <Bar />
              `,
              output: unIndent`
                  foo ? (
                      <Foo />
                  ) :
                      <Bar />
              `,
              errors: expectedErrors([4, 4, 0, "Punctuator"])
          },
          {
              code: unIndent`
                  <App
                    foo
                  />
              `,
              output: unIndent`
                  <App
                      foo
                  />
              `,
              errors: expectedErrors([2, 4, 2, "JSXIdentifier"])
          },
          {
              code: unIndent`
                  <App
                    foo
                    />
              `,
              output: unIndent`
                  <App
                    foo
                  />
              `,
              options: [2],
              errors: expectedErrors([3, 0, 2, "Punctuator"])
          },
          {
              code: unIndent`
                  <App
                    foo
                    ></App>
              `,
              output: unIndent`
                  <App
                    foo
                  ></App>
              `,
              options: [2],
              errors: expectedErrors([3, 0, 2, "Punctuator"])
          },
          {
              code: unIndent`
                  const Button = function(props) {
                    return (
                      <Button
                        size={size}
                        onClick={onClick}
                                                      >
                        Button Text
                      </Button>
                    );
                  };
              `,
              output: unIndent`
                  const Button = function(props) {
                    return (
                      <Button
                        size={size}
                        onClick={onClick}
                      >
                        Button Text
                      </Button>
                    );
                  };
              `,
              options: [2],
              errors: expectedErrors([6, 4, 36, "Punctuator"])
          },
          {
              code: unIndent`
                  var x = function() {
                    return <App
                      foo
                           />
                  }
              `,
              output: unIndent`
                  var x = function() {
                    return <App
                      foo
                    />
                  }
              `,
              options: [2],
              errors: expectedErrors([4, 2, 9, "Punctuator"])
          },
          {
              code: unIndent`
                  var x = <App
                    foo
                          />
              `,
              output: unIndent`
                  var x = <App
                    foo
                  />
              `,
              options: [2],
              errors: expectedErrors([3, 0, 8, "Punctuator"])
          },
          {
              code: unIndent`
                  var x = (
                    <Something
                      />
                  )
              `,
              output: unIndent`
                  var x = (
                    <Something
                    />
                  )
              `,
              options: [2],
              errors: expectedErrors([3, 2, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  <App
                  \tfoo
                  \t/>
              `,
              output: unIndent`
                  <App
                  \tfoo
                  />
              `,
              options: ["tab"],
              errors: expectedErrors("tab", [3, 0, 1, "Punctuator"])
          },
          {
              code: unIndent`
                  <App
                  \tfoo
                  \t></App>
              `,
              output: unIndent`
                  <App
                  \tfoo
                  ></App>
              `,
              options: ["tab"],
              errors: expectedErrors("tab", [3, 0, 1, "Punctuator"])
          },
          {
              code: unIndent`
                  <
                      foo
                      .bar
                      .baz
                  >
                      foo
                  </
                      foo.
                      bar.
                      baz
                  >
              `,
              output: unIndent`
                  <
                      foo
                          .bar
                          .baz
                  >
                      foo
                  </
                      foo.
                          bar.
                          baz
                  >
              `,
              errors: expectedErrors([
                  [3, 8, 4, "Punctuator"],
                  [4, 8, 4, "Punctuator"],
                  [9, 8, 4, "JSXIdentifier"],
                  [10, 8, 4, "JSXIdentifier"]
              ])
          },
          {
              code: unIndent`
                  <
                      input
                      type=
                      "number"
                  />
              `,
              output: unIndent`
                  <
                      input
                      type=
                          "number"
                  />
              `,
              errors: expectedErrors([4, 8, 4, "JSXText"])
          },
          {
              code: unIndent`
                  <
                      input
                      type=
                      {'number'}
                  />
              `,
              output: unIndent`
                  <
                      input
                      type=
                          {'number'}
                  />
              `,
              errors: expectedErrors([4, 8, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  <
                      input
                      type
                      ="number"
                  />
              `,
              output: unIndent`
                  <
                      input
                      type
                          ="number"
                  />
              `,
              errors: expectedErrors([4, 8, 4, "Punctuator"])
          },
          {
              code: unIndent`
                  foo ? (
                      bar
                  ) : (
                          baz
                      )
              `,
              output: unIndent`
                  foo ? (
                      bar
                  ) : (
                      baz
                  )
              `,
              errors: expectedErrors([[4, 4, 8, "Identifier"], [5, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  foo ? (
                      <div>
                      </div>
                  ) : (
                          <span>
                          </span>
                      )
              `,
              output: unIndent`
                  foo ? (
                      <div>
                      </div>
                  ) : (
                      <span>
                      </span>
                  )
              `,
              errors: expectedErrors([[5, 4, 8, "Punctuator"], [6, 4, 8, "Punctuator"], [7, 0, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  <div>
                      {
                      (
                          1
                      )
                      }
                  </div>
              `,
              output: unIndent`
                  <div>
                      {
                          (
                              1
                          )
                      }
                  </div>
              `,
              errors: expectedErrors([[3, 8, 4, "Punctuator"], [4, 12, 8, "Numeric"], [5, 8, 4, "Punctuator"]])
          },
          {
              code: unIndent`
                  <div>
                      {
                        /* foo */
                      }
                  </div>
              `,
              output: unIndent`
                  <div>
                      {
                          /* foo */
                      }
                  </div>
              `,
              errors: expectedErrors([3, 8, 6, "Block"])
          },
          {
              code: unIndent`
                  ({
                      foo
                      }: bar) => baz
              `,
              output: unIndent`
                  ({
                      foo
                  }: bar) => baz
              `,
              errors: expectedErrors([3, 0, 4, "Punctuator"]),
              parser: require.resolve("../../fixtures/parsers/babel-eslint7/object-pattern-with-annotation")
          },
          {
              code: unIndent`
                  ([
                      foo
                      ]: bar) => baz
              `,
              output: unIndent`
                  ([
                      foo
                  ]: bar) => baz
              `,
              errors: expectedErrors([3, 0, 4, "Punctuator"]),
              parser: require.resolve("../../fixtures/parsers/babel-eslint7/array-pattern-with-annotation")
          },
          {
              code: unIndent`
                  ({
                      foo
                      }: {}) => baz
              `,
              output: unIndent`
                  ({
                      foo
                  }: {}) => baz
              `,
              errors: expectedErrors([3, 0, 4, "Punctuator"]),
              parser: require.resolve("../../fixtures/parsers/babel-eslint7/object-pattern-with-object-annotation")
          },
          {
              code: unIndent`
                  class Foo {
                  foo() {
                  bar();
                  }
                  }
              `,
              output: unIndent`
                  class Foo {
                  foo() {
                      bar();
                  }
                  }
              `,
              options: [4, { ignoredNodes: ["ClassBody"] }],
              errors: expectedErrors([3, 4, 0, "Identifier"])
          },
          {
              code: unIndent`
                  $(function() {
  
                  foo();
                  bar();
  
                  foo(function() {
                  baz();
                  });
  
                  });
              `,
              output: unIndent`
                  $(function() {
  
                  foo();
                  bar();
  
                  foo(function() {
                      baz();
                  });
  
                  });
              `,
              options: [4, {
                  ignoredNodes: ["ExpressionStatement > CallExpression[callee.name='$'] > FunctionExpression > BlockStatement"]
              }],
              errors: expectedErrors([7, 4, 0, "Identifier"])
          },
          {
              code: unIndent`
                  (function($) {
                  $(function() {
                  foo;
                  });
                  })()
              `,
              output: unIndent`
                  (function($) {
                  $(function() {
                      foo;
                  });
                  })()
              `,
              options: [4, {
                  ignoredNodes: ["ExpressionStatement > CallExpression > FunctionExpression.callee > BlockStatement"]
              }],
              errors: expectedErrors([3, 4, 0, "Identifier"])
          },
          {
              code: unIndent`
                  if (foo) {
                      doSomething();
  
                  // Intentionally unindented comment
                      doSomethingElse();
                  }
              `,
              output: unIndent`
                  if (foo) {
                      doSomething();
  
                      // Intentionally unindented comment
                      doSomethingElse();
                  }
              `,
              options: [4, { ignoreComments: false }],
              errors: expectedErrors([4, 4, 0, "Line"])
          },
          {
              code: unIndent`
                  if (foo) {
                      doSomething();
  
                  /* Intentionally unindented comment */
                      doSomethingElse();
                  }
              `,
              output: unIndent`
                  if (foo) {
                      doSomething();
  
                      /* Intentionally unindented comment */
                      doSomethingElse();
                  }
              `,
              options: [4, { ignoreComments: false }],
              errors: expectedErrors([4, 4, 0, "Block"])
          },
          {
              code: unIndent`
                  const obj = {
                      foo () {
                          return condition ? // comment
                          1 :
                              2
                      }
                  }
              `,
              output: unIndent`
                  const obj = {
                      foo () {
                          return condition ? // comment
                              1 :
                              2
                      }
                  }
              `,
              errors: expectedErrors([4, 12, 8, "Numeric"])
          }
      ]
  });
  