Repository: eslint/eslint
Pull request #9094 (2017-08-09 06:26:08)

Update: Include files with no messages in junit results (#9093)
**What is the purpose of this pull request? (put an "X" next to item)**
[X] Bug fix https://github.com/eslint/eslint/issues/9093

**What changes did you make? (Give an overview)**
Currently when a file has no errors there isn't an entry in the junit results. This breaks some junit parsers as they expect at least one result. It also provides more data since now you know how many files have actually been parsed.

**Is there anything you'd like reviewers to focus on?**

eslintbot: LGTM
eslintbot: LGTM
platinumazure: As an aside, it would be so nice if we supported a `--formatter-options` CLI option where the option could just get passed into the formatter, and then the formatter could actually follow either behavior and the user could decide.
Sean-Der: Thanks for the review @not-an-aardvark !

@platinumazure I would be more then happy to write that feature! I could see the junit change being controversial, so happy to do whatever makes everyone happy.
platinumazure: Thanks, don't jump too quickly on that, the team has discussed it in the
past and vetoed it and I've been the lone dissenter for a while. :-)

On Aug 9, 2017 10:56 AM, "Sean DuBois" <notifications@github.com> wrote:

> Thanks for the review @not-an-aardvark
> <https://github.com/not-an-aardvark> !
>
> @platinumazure <https://github.com/platinumazure> I would be more then
> happy to write that feature! I could see the junit change being
> controversial, so happy to do whatever makes everyone happy.
>
> —
> You are receiving this because you were mentioned.
> Reply to this email directly, view it on GitHub
> <https://github.com/eslint/eslint/pull/9094#issuecomment-321299162>, or mute
> the thread
> <https://github.com/notifications/unsubscribe-auth/AARWejBIzas6kzSzYW17EznGWQCaukUEks5sWdaVgaJpZM4Oxpaa>
> .
>


Patch:
diff --git a/.eslintrc.yml b/.eslintrc.yml
index 19d4c6c3a..d7b0e414b 100644
--- a/.eslintrc.yml
+++ b/.eslintrc.yml
@@ -14,3 +14,4 @@ rules:
     eslint-plugin/prefer-placeholders: "error"
     eslint-plugin/report-message-format: ["error", '[^a-z].*\.$']
     eslint-plugin/test-case-property-ordering: "error"
+    eslint-plugin/test-case-shorthand-strings: "error"
diff --git a/docs/maintainer-guide/governance.md b/docs/maintainer-guide/governance.md
index 098f11598..8fde31c16 100644
--- a/docs/maintainer-guide/governance.md
+++ b/docs/maintainer-guide/governance.md
@@ -92,13 +92,14 @@ A Committer is invited to become a TSC member by existing TSC members. A nominat
 #### Process for Adding TSC Members
 
 1. Add the GitHub user to the "ESLint TSC" team
-2. Set the GitHub user to be have the "Owner" role for the ESLint organization
-3. Send welcome email with link to maintainer guide
-4. Add TSC member to the README
-5. Invite to Gitter TSC chatroom
-6. Make TSC member an admin on the ESLint team mailing list
-7. Add TSC member as an admin to ESLint Twitter Account on Tweetdeck
-8. Tweet congratulations to the new TSC member from the ESLint Twitter account
+1. Set the GitHub user to be have the "Owner" role for the ESLint organization
+1. Send welcome email with link to maintainer guide
+1. Add the TSC member to the README
+1. Invite to the Gitter TSC chatroom
+1. Make the TSC member an admin on the ESLint team mailing list
+1. Add the TSC member to the recurring TSC meeting event on Google Calendar
+1. Add the TSC member as an admin to ESLint Twitter Account on Tweetdeck
+1. Tweet congratulations to the new TSC member from the ESLint Twitter account
 
 #### TSC Meetings
 
diff --git a/lib/formatters/junit.js b/lib/formatters/junit.js
index c41a2a4dd..069ed5ff8 100644
--- a/lib/formatters/junit.js
+++ b/lib/formatters/junit.js
@@ -39,10 +39,7 @@ module.exports = function(results) {
 
         const messages = result.messages;
 
-        if (messages.length) {
-            output += `<testsuite package="org.eslint" time="0" tests="${messages.length}" errors="${messages.length}" name="${result.filePath}">\n`;
-        }
-
+        output += `<testsuite package="org.eslint" time="0" tests="${messages.length}" errors="${messages.length}" name="${result.filePath}">\n`;
         messages.forEach(message => {
             const type = message.fatal ? "error" : "failure";
 
@@ -57,10 +54,7 @@ module.exports = function(results) {
             output += `</${type}>`;
             output += "</testcase>\n";
         });
-
-        if (messages.length) {
-            output += "</testsuite>\n";
-        }
+        output += "</testsuite>\n";
 
     });
 
diff --git a/lib/linter.js b/lib/linter.js
index bb17ac216..a000a69a1 100755
--- a/lib/linter.js
+++ b/lib/linter.js
@@ -1210,7 +1210,7 @@ class Linter extends EventEmitter {
             fixed = false,
             passNumber = 0;
         const debugTextDescription = options && options.filename || `${text.slice(0, 10)}...`;
-        const shouldFix = options && options.fix || true;
+        const shouldFix = options && typeof options.fix !== "undefined" ? options.fix : true;
 
         /**
          * This loop continues until one of the following is true:
diff --git a/lib/rules/indent.js b/lib/rules/indent.js
index 45332f447..429567ee5 100644
--- a/lib/rules/indent.js
+++ b/lib/rules/indent.js
@@ -783,7 +783,7 @@ module.exports = {
             offsets.setDesiredOffsets(
                 [startToken.range[1], endToken.range[0]],
                 startToken,
-                offset === "first" ? 1 : offset
+                typeof offset === "number" ? offset : 1
             );
             offsets.setDesiredOffset(endToken, startToken, 0);
 


Test patch:
diff --git a/tests/lib/formatters/junit.js b/tests/lib/formatters/junit.js
index 81a5e06c5..cddff54d7 100644
--- a/tests/lib/formatters/junit.js
+++ b/tests/lib/formatters/junit.js
@@ -177,7 +177,7 @@ describe("formatter:junit", () => {
         });
     });
 
-    describe("when passed multiple files with total 1 failure", () => {
+    describe("when passed multiple files should print even if no errors", () => {
         const code = [{
             filePath: "foo.js",
             messages: [{
@@ -192,10 +192,10 @@ describe("formatter:junit", () => {
             messages: []
         }];
 
-        it("should return 1 <testsuite>", () => {
+        it("should return 2 <testsuite>", () => {
             const result = formatter(code);
 
-            assert.equal(result.replace(/\n/g, ""), "<?xml version=\"1.0\" encoding=\"utf-8\"?><testsuites><testsuite package=\"org.eslint\" time=\"0\" tests=\"1\" errors=\"1\" name=\"foo.js\"><testcase time=\"0\" name=\"org.eslint.foo\"><failure message=\"Unexpected foo.\"><![CDATA[line 5, col 10, Warning - Unexpected foo. (foo)]]></failure></testcase></testsuite></testsuites>");
+            assert.equal(result.replace(/\n/g, ""), "<?xml version=\"1.0\" encoding=\"utf-8\"?><testsuites><testsuite package=\"org.eslint\" time=\"0\" tests=\"1\" errors=\"1\" name=\"foo.js\"><testcase time=\"0\" name=\"org.eslint.foo\"><failure message=\"Unexpected foo.\"><![CDATA[line 5, col 10, Warning - Unexpected foo. (foo)]]></failure></testcase></testsuite><testsuite package=\"org.eslint\" time=\"0\" tests=\"0\" errors=\"0\" name=\"bar.js\"></testsuite></testsuites>");
         });
     });
 });
diff --git a/tests/lib/linter.js b/tests/lib/linter.js
index ba98b0a1f..b0f423ccd 100644
--- a/tests/lib/linter.js
+++ b/tests/lib/linter.js
@@ -3819,6 +3819,16 @@ describe("Linter", () => {
                 output: "var a;"
             });
         });
+
+        it("does not apply autofixes when fix argument is `false`", () => {
+            const fixResult = linter.verifyAndFix("var a", {
+                rules: {
+                    semi: 2
+                }
+            }, { fix: false });
+
+            assert.strictEqual(fixResult.fixed, false);
+        });
     });
 
     describe("Edge cases", () => {
diff --git a/tests/lib/rules/accessor-pairs.js b/tests/lib/rules/accessor-pairs.js
index 4fccdc05a..f694707fd 100644
--- a/tests/lib/rules/accessor-pairs.js
+++ b/tests/lib/rules/accessor-pairs.js
@@ -36,9 +36,9 @@ ruleTester.run("accessor-pairs", rule, {
         },
 
         // https://github.com/eslint/eslint/issues/3262
-        { code: "var o = {set: function() {}}" },
-        { code: "Object.defineProperties(obj, {set: {value: function() {}}});" },
-        { code: "Object.create(null, {set: {value: function() {}}});" },
+        "var o = {set: function() {}}",
+        "Object.defineProperties(obj, {set: {value: function() {}}});",
+        "Object.create(null, {set: {value: function() {}}});",
         { code: "var o = {get: function() {}}", options: [{ getWithoutSet: true }] },
         { code: "var o = {[set]: function() {}}", parserOptions: { ecmaVersion: 6 } },
         { code: "var set = 'value'; Object.defineProperty(obj, 'foo', {[set]: function(value) {}});", parserOptions: { ecmaVersion: 6 } }
diff --git a/tests/lib/rules/block-scoped-var.js b/tests/lib/rules/block-scoped-var.js
index def5716f6..75f02f0a4 100644
--- a/tests/lib/rules/block-scoped-var.js
+++ b/tests/lib/rules/block-scoped-var.js
@@ -83,22 +83,22 @@ ruleTester.run("block-scoped-var", rule, {
         { code: "function foo({x: y}) { return y; }", parserOptions: { ecmaVersion: 6 } },
 
         // those are the same as `no-undef`.
-        { code: "!function f(){}; f" },
-        { code: "var f = function foo() { }; foo(); var exports = { f: foo };" },
+        "!function f(){}; f",
+        "var f = function foo() { }; foo(); var exports = { f: foo };",
         { code: "var f = () => { x; }", parserOptions: { ecmaVersion: 6 } },
-        { code: "function f(){ x; }" },
-        { code: "var eslint = require('eslint');" },
-        { code: "function f(a) { return a[b]; }" },
-        { code: "function f() { return b.a; }" },
-        { code: "var a = { foo: bar };" },
-        { code: "var a = { foo: foo };" },
-        { code: "var a = { bar: 7, foo: bar };" },
-        { code: "var a = arguments;" },
-        { code: "function x(){}; var a = arguments;" },
-        { code: "function z(b){}; var a = b;" },
-        { code: "function z(){var b;}; var a = b;" },
-        { code: "function f(){ try{}catch(e){} e }" },
-        { code: "a:b;" },
+        "function f(){ x; }",
+        "var eslint = require('eslint');",
+        "function f(a) { return a[b]; }",
+        "function f() { return b.a; }",
+        "var a = { foo: bar };",
+        "var a = { foo: foo };",
+        "var a = { bar: 7, foo: bar };",
+        "var a = arguments;",
+        "function x(){}; var a = arguments;",
+        "function z(b){}; var a = b;",
+        "function z(){var b;}; var a = b;",
+        "function f(){ try{}catch(e){} e }",
+        "a:b;",
 
         // https://github.com/eslint/eslint/issues/2253
         { code: "/*global React*/ let {PropTypes, addons: {PureRenderMixin}} = React; let Test = React.createClass({mixins: [PureRenderMixin]});", parserOptions: { ecmaVersion: 6 } },
@@ -106,10 +106,10 @@ ruleTester.run("block-scoped-var", rule, {
         { code: "const { dummy: { data, isLoading }, auth: { isLoggedIn } } = this.props;", parserOptions: { ecmaVersion: 6 } },
 
         // https://github.com/eslint/eslint/issues/2747
-        { code: "function a(n) { return n > 0 ? b(n - 1) : \"a\"; } function b(n) { return n > 0 ? a(n - 1) : \"b\"; }" },
+        "function a(n) { return n > 0 ? b(n - 1) : \"a\"; } function b(n) { return n > 0 ? a(n - 1) : \"b\"; }",
 
         // https://github.com/eslint/eslint/issues/2967
-        { code: "(function () { foo(); })(); function foo() {}" },
+        "(function () { foo(); })(); function foo() {}",
         { code: "(function () { foo(); })(); function foo() {}", parserOptions: { sourceType: "module" } }
     ],
     invalid: [
diff --git a/tests/lib/rules/block-spacing.js b/tests/lib/rules/block-spacing.js
index 6f4459a0e..4b09af6b9 100644
--- a/tests/lib/rules/block-spacing.js
+++ b/tests/lib/rules/block-spacing.js
@@ -23,25 +23,25 @@ ruleTester.run("block-spacing", rule, {
 
         // default/always
         { code: "{ foo(); }", options: ["always"] },
-        { code: "{ foo(); }" },
-        { code: "{ foo();\n}" },
-        { code: "{\nfoo(); }" },
-        { code: "{\r\nfoo();\r\n}" },
-        { code: "if (a) { foo(); }" },
-        { code: "if (a) {} else { foo(); }" },
-        { code: "switch (a) {}" },
-        { code: "switch (a) { case 0: foo(); }" },
-        { code: "while (a) { foo(); }" },
-        { code: "do { foo(); } while (a);" },
-        { code: "for (;;) { foo(); }" },
-        { code: "for (var a in b) { foo(); }" },
+        "{ foo(); }",
+        "{ foo();\n}",
+        "{\nfoo(); }",
+        "{\r\nfoo();\r\n}",
+        "if (a) { foo(); }",
+        "if (a) {} else { foo(); }",
+        "switch (a) {}",
+        "switch (a) { case 0: foo(); }",
+        "while (a) { foo(); }",
+        "do { foo(); } while (a);",
+        "for (;;) { foo(); }",
+        "for (var a in b) { foo(); }",
         { code: "for (var a of b) { foo(); }", parserOptions: { ecmaVersion: 6 } },
-        { code: "try { foo(); } catch (e) { foo(); }" },
-        { code: "function foo() { bar(); }" },
-        { code: "(function() { bar(); });" },
+        "try { foo(); } catch (e) { foo(); }",
+        "function foo() { bar(); }",
+        "(function() { bar(); });",
         { code: "(() => { bar(); });", parserOptions: { ecmaVersion: 6 } },
-        { code: "if (a) { /* comment */ foo(); /* comment */ }" },
-        { code: "if (a) { //comment\n foo(); }" },
+        "if (a) { /* comment */ foo(); /* comment */ }",
+        "if (a) { //comment\n foo(); }",
 
         // never
         { code: "{foo();}", options: ["never"] },
diff --git a/tests/lib/rules/comma-style.js b/tests/lib/rules/comma-style.js
index 6fe8946ec..6ccb11fd0 100644
--- a/tests/lib/rules/comma-style.js
+++ b/tests/lib/rules/comma-style.js
@@ -33,15 +33,15 @@ ruleTester.run("comma-style", rule, {
         "var foo = {'a': 1, \n 'b': 2, \n'c': 3};",
         "var foo = {'a': 1, \n 'b': 2, 'c':\n 3};",
         "var foo = {'a': 1, \n 'b': 2, 'c': [{'d': 1}, \n {'e': 2}, \n {'f': 3}]};",
-        { code: "var foo = [1, \n2, \n3];" },
-        { code: "function foo(){var a=[1,\n 2]}" },
-        { code: "function foo(){return {'a': 1,\n'b': 2}}" },
-        { code: "var foo = \n1, \nbar = \n2;" },
-        { code: "var foo = [\n(bar),\nbaz\n];" },
-        { code: "var foo = [\n(bar\n),\nbaz\n];" },
-        { code: "var foo = [\n(\nbar\n),\nbaz\n];" },
+        "var foo = [1, \n2, \n3];",
+        "function foo(){var a=[1,\n 2]}",
+        "function foo(){return {'a': 1,\n'b': 2}}",
+        "var foo = \n1, \nbar = \n2;",
+        "var foo = [\n(bar),\nbaz\n];",
+        "var foo = [\n(bar\n),\nbaz\n];",
+        "var foo = [\n(\nbar\n),\nbaz\n];",
         { code: "var foo = [\n(bar\n)\n,baz\n];", options: ["first"] },
-        { code: "var foo = \n1, \nbar = [1,\n2,\n3]" },
+        "var foo = \n1, \nbar = [1,\n2,\n3]",
         { code: "var foo = ['apples'\n,'oranges'];", options: ["first"] },
         { code: "var foo = 1, bar = 2;", options: ["first"] },
         { code: "var foo = 1 \n ,bar = 2;", options: ["first"] },
@@ -49,8 +49,8 @@ ruleTester.run("comma-style", rule, {
         { code: "var foo = [1 \n ,2 \n, 3];", options: ["first"] },
         { code: "function foo(){return {'a': 1\n,'b': 2}}", options: ["first"] },
         { code: "function foo(){var a=[1\n, 2]}", options: ["first"] },
-        { code: "f(1\n, 2);" },
-        { code: "function foo(a\n, b) { return a + b; }" },
+        "f(1\n, 2);",
+        "function foo(a\n, b) { return a + b; }",
         {
             code: "var a = 'a',\no = 'o';",
             options: ["first", { exceptions: { VariableDeclaration: true } }]
diff --git a/tests/lib/rules/complexity.js b/tests/lib/rules/complexity.js
index 4c099dbeb..b1b031173 100644
--- a/tests/lib/rules/complexity.js
+++ b/tests/lib/rules/complexity.js
@@ -38,7 +38,7 @@ const ruleTester = new RuleTester();
 
 ruleTester.run("complexity", rule, {
     valid: [
-        { code: "function a(x) {}" },
+        "function a(x) {}",
         { code: "function b(x) {}", options: [1] },
         { code: "function a(x) {if (true) {return x;}}", options: [2] },
         { code: "function a(x) {if (true) {return x;} else {return x+1;}}", options: [2] },
diff --git a/tests/lib/rules/computed-property-spacing.js b/tests/lib/rules/computed-property-spacing.js
index 69fbb4a67..eadc7eabe 100644
--- a/tests/lib/rules/computed-property-spacing.js
+++ b/tests/lib/rules/computed-property-spacing.js
@@ -22,8 +22,8 @@ ruleTester.run("computed-property-spacing", rule, {
     valid: [
 
         // default - never
-        { code: "obj[foo]" },
-        { code: "obj['foo']" },
+        "obj[foo]",
+        "obj['foo']",
         { code: "var x = {[b]: a}", parserOptions: { ecmaVersion: 6 } },
 
         // always
diff --git a/tests/lib/rules/consistent-this.js b/tests/lib/rules/consistent-this.js
index d692f2dc4..782e302d2 100644
--- a/tests/lib/rules/consistent-this.js
+++ b/tests/lib/rules/consistent-this.js
@@ -38,7 +38,7 @@ const ruleTester = new RuleTester();
 
 ruleTester.run("consistent-this", rule, {
     valid: [
-        { code: "var foo = 42, that = this" },
+        "var foo = 42, that = this",
         { code: "var foo = 42, self = this", options: ["self"] },
         { code: "var self = 42", options: ["that"] },
         { code: "var self", options: ["that"] },
diff --git a/tests/lib/rules/for-direction.js b/tests/lib/rules/for-direction.js
index d3a39f40c..c19c5fdfc 100644
--- a/tests/lib/rules/for-direction.js
+++ b/tests/lib/rules/for-direction.js
@@ -22,32 +22,32 @@ ruleTester.run("for-direction", rule, {
     valid: [
 
         // test if '++', '--'
-        { code: "for(var i = 0; i < 10; i++){}" },
-        { code: "for(var i = 0; i <= 10; i++){}" },
-        { code: "for(var i = 10; i > 0; i--){}" },
-        { code: "for(var i = 10; i >= 0; i--){}" },
+        "for(var i = 0; i < 10; i++){}",
+        "for(var i = 0; i <= 10; i++){}",
+        "for(var i = 10; i > 0; i--){}",
+        "for(var i = 10; i >= 0; i--){}",
 
         // test if '+=', '-=',
-        { code: "for(var i = 0; i < 10; i+=1){}" },
-        { code: "for(var i = 0; i <= 10; i+=1){}" },
-        { code: "for(var i = 10; i > 0; i-=1){}" },
-        { code: "for(var i = 10; i >= 0; i-=1){}" },
-        { code: "for (var i = 0; i < MAX; i += STEP_SIZE);" },
-        { code: "for (var i = MAX; i > MIN; i -= STEP_SIZE);" },
+        "for(var i = 0; i < 10; i+=1){}",
+        "for(var i = 0; i <= 10; i+=1){}",
+        "for(var i = 10; i > 0; i-=1){}",
+        "for(var i = 10; i >= 0; i-=1){}",
+        "for (var i = 0; i < MAX; i += STEP_SIZE);",
+        "for (var i = MAX; i > MIN; i -= STEP_SIZE);",
 
         // test if no update.
-        { code: "for(var i = 10; i > 0;){}" },
-        { code: "for(var i = 10; i >= 0;){}" },
-        { code: "for(var i = 10; i < 0;){}" },
-        { code: "for(var i = 10; i <= 0;){}" },
-        { code: "for(var i = 10; i <= 0; j++){}" },
-        { code: "for(var i = 10; i <= 0; j--){}" },
-        { code: "for(var i = 10; i >= 0; j++){}" },
-        { code: "for(var i = 10; i >= 0; j--){}" },
-        { code: "for(var i = 10; i >= 0; j += 2){}" },
-        { code: "for(var i = 10; i >= 0; j -= 2){}" },
-        { code: "for(var i = 10; i >= 0; i |= 2){}" },
-        { code: "for(var i = 10; i >= 0; i %= 2){}" }
+        "for(var i = 10; i > 0;){}",
+        "for(var i = 10; i >= 0;){}",
+        "for(var i = 10; i < 0;){}",
+        "for(var i = 10; i <= 0;){}",
+        "for(var i = 10; i <= 0; j++){}",
+        "for(var i = 10; i <= 0; j--){}",
+        "for(var i = 10; i >= 0; j++){}",
+        "for(var i = 10; i >= 0; j--){}",
+        "for(var i = 10; i >= 0; j += 2){}",
+        "for(var i = 10; i >= 0; j -= 2){}",
+        "for(var i = 10; i >= 0; i |= 2){}",
+        "for(var i = 10; i >= 0; i %= 2){}"
     ],
     invalid: [
 
diff --git a/tests/lib/rules/func-name-matching.js b/tests/lib/rules/func-name-matching.js
index 80880dae6..6f33fbe9a 100644
--- a/tests/lib/rules/func-name-matching.js
+++ b/tests/lib/rules/func-name-matching.js
@@ -20,52 +20,52 @@ const ruleTester = new RuleTester();
 
 ruleTester.run("func-name-matching", rule, {
     valid: [
-        { code: "var foo;" },
-        { code: "var foo = function foo() {};" },
+        "var foo;",
+        "var foo = function foo() {};",
         { code: "var foo = function foo() {};", options: ["always"] },
         { code: "var foo = function bar() {};", options: ["never"] },
-        { code: "var foo = function() {}" },
+        "var foo = function() {}",
         { code: "var foo = () => {}", parserOptions: { ecmaVersion: 6 } },
-        { code: "foo = function foo() {};" },
+        "foo = function foo() {};",
         { code: "foo = function foo() {};", options: ["always"] },
         { code: "foo = function bar() {};", options: ["never"] },
-        { code: "obj.foo = function foo() {};" },
+        "obj.foo = function foo() {};",
         { code: "obj.foo = function foo() {};", options: ["always"] },
         { code: "obj.foo = function bar() {};", options: ["never"] },
-        { code: "obj.foo = function() {};" },
+        "obj.foo = function() {};",
         { code: "obj.foo = function() {};", options: ["always"] },
         { code: "obj.foo = function() {};", options: ["never"] },
-        { code: "obj.bar.foo = function foo() {};" },
+        "obj.bar.foo = function foo() {};",
         { code: "obj.bar.foo = function foo() {};", options: ["always"] },
         { code: "obj.bar.foo = function baz() {};", options: ["never"] },
-        { code: "obj['foo'] = function foo() {};" },
+        "obj['foo'] = function foo() {};",
         { code: "obj['foo'] = function foo() {};", options: ["always"] },
         { code: "obj['foo'] = function bar() {};", options: ["never"] },
-        { code: "obj['foo//bar'] = function foo() {};" },
+        "obj['foo//bar'] = function foo() {};",
         { code: "obj['foo//bar'] = function foo() {};", options: ["always"] },
         { code: "obj['foo//bar'] = function foo() {};", options: ["never"] },
-        { code: "obj[foo] = function bar() {};" },
+        "obj[foo] = function bar() {};",
         { code: "obj[foo] = function bar() {};", options: ["always"] },
         { code: "obj[foo] = function bar() {};", options: ["never"] },
-        { code: "var obj = {foo: function foo() {}};" },
+        "var obj = {foo: function foo() {}};",
         { code: "var obj = {foo: function foo() {}};", options: ["always"] },
         { code: "var obj = {foo: function bar() {}};", options: ["never"] },
-        { code: "var obj = {'foo': function foo() {}};" },
+        "var obj = {'foo': function foo() {}};",
         { code: "var obj = {'foo': function foo() {}};", options: ["always"] },
         { code: "var obj = {'foo': function bar() {}};", options: ["never"] },
-        { code: "var obj = {'foo//bar': function foo() {}};" },
+        "var obj = {'foo//bar': function foo() {}};",
         { code: "var obj = {'foo//bar': function foo() {}};", options: ["always"] },
         { code: "var obj = {'foo//bar': function foo() {}};", options: ["never"] },
-        { code: "var obj = {foo: function() {}};" },
+        "var obj = {foo: function() {}};",
         { code: "var obj = {foo: function() {}};", options: ["always"] },
         { code: "var obj = {foo: function() {}};", options: ["never"] },
         { code: "var obj = {[foo]: function bar() {}} ", parserOptions: { ecmaVersion: 6 } },
         { code: "var obj = {['x' + 2]: function bar(){}};", parserOptions: { ecmaVersion: 6 } },
-        { code: "obj['x' + 2] = function bar(){};" },
+        "obj['x' + 2] = function bar(){};",
         { code: "var [ bar ] = [ function bar(){} ];", parserOptions: { ecmaVersion: 6 } },
         { code: "function a(foo = function bar() {}) {}", parserOptions: { ecmaVersion: 6 } },
-        { code: "module.exports = function foo(name) {};" },
-        { code: "module['exports'] = function foo(name) {};" },
+        "module.exports = function foo(name) {};",
+        "module['exports'] = function foo(name) {};",
         {
             code: "module.exports = function foo(name) {};",
             options: [{ includeCommonJSModuleExports: false }],
diff --git a/tests/lib/rules/getter-return.js b/tests/lib/rules/getter-return.js
index 14d678492..e605c388a 100644
--- a/tests/lib/rules/getter-return.js
+++ b/tests/lib/rules/getter-return.js
@@ -30,7 +30,7 @@ ruleTester.run("getter-return", rule, {
 
         // test obj: get
         // option: {allowImplicit: false}
-        { code: "var foo = { get bar(){return true;} };" },
+        "var foo = { get bar(){return true;} };",
 
         // option: {allowImplicit: true}
         { code: "var foo = { get bar() {return;} };", options },
@@ -39,9 +39,9 @@ ruleTester.run("getter-return", rule, {
 
         // test class: get
         // option: {allowImplicit: false}
-        { code: "class foo { get bar(){return true;} }" },
-        { code: "class foo { get bar(){if(baz){return true;} else {return false;} } }" },
-        { code: "class foo { get(){return true;} }" },
+        "class foo { get bar(){return true;} }",
+        "class foo { get bar(){if(baz){return true;} else {return false;} } }",
+        "class foo { get(){return true;} }",
 
         // option: {allowImplicit: true}
         { code: "class foo { get bar(){return true;} }", options },
@@ -49,10 +49,10 @@ ruleTester.run("getter-return", rule, {
 
         // test object.defineProperty(s)
         // option: {allowImplicit: false}
-        { code: "Object.defineProperty(foo, \"bar\", { get: function () {return true;}});" },
-        { code: "Object.defineProperty(foo, \"bar\", { get: function () { ~function (){ return true; }();return true;}});" },
-        { code: "Object.defineProperties(foo, { bar: { get: function () {return true;}} });" },
-        { code: "Object.defineProperties(foo, { bar: { get: function () { ~function (){ return true; }(); return true;}} });" },
+        "Object.defineProperty(foo, \"bar\", { get: function () {return true;}});",
+        "Object.defineProperty(foo, \"bar\", { get: function () { ~function (){ return true; }();return true;}});",
+        "Object.defineProperties(foo, { bar: { get: function () {return true;}} });",
+        "Object.defineProperties(foo, { bar: { get: function () { ~function (){ return true; }(); return true;}} });",
 
         // option: {allowImplicit: true}
         { code: "Object.defineProperty(foo, \"bar\", { get: function () {return true;}});", options },
@@ -61,15 +61,15 @@ ruleTester.run("getter-return", rule, {
         { code: "Object.defineProperties(foo, { bar: { get: function () {return;}} });", options },
 
         // not getter.
-        { code: "var get = function(){};" },
-        { code: "var get = function(){ return true; };" },
-        { code: "var foo = { bar(){} };" },
-        { code: "var foo = { bar(){ return true; } };" },
-        { code: "var foo = { bar: function(){} };" },
-        { code: "var foo = { bar: function(){return;} };" },
-        { code: "var foo = { bar: function(){return true;} };" },
-        { code: "var foo = { get: function () {} }" },
-        { code: "var foo = { get: () => {}};" }
+        "var get = function(){};",
+        "var get = function(){ return true; };",
+        "var foo = { bar(){} };",
+        "var foo = { bar(){ return true; } };",
+        "var foo = { bar: function(){} };",
+        "var foo = { bar: function(){return;} };",
+        "var foo = { bar: function(){return true;} };",
+        "var foo = { get: function () {} }",
+        "var foo = { get: () => {}};"
     ],
 
     invalid: [
diff --git a/tests/lib/rules/indent-legacy.js b/tests/lib/rules/indent-legacy.js
index 901f0b820..d748a44a3 100644
--- a/tests/lib/rules/indent-legacy.js
+++ b/tests/lib/rules/indent-legacy.js
@@ -703,9 +703,7 @@ ruleTester.run("indent-legacy", rule, {
             "}",
             options: [4, { SwitchCase: 2 }]
         },
-        {
-            code:
-            "switch (a) {\n" +
+        "switch (a) {\n" +
             "case \"foo\":\n" +
             "    a();\n" +
             "    break;\n" +
@@ -717,11 +715,8 @@ ruleTester.run("indent-legacy", rule, {
             "        a = 6;\n" +
             "        break;\n" +
             "    }\n" +
-            "}"
-        },
-        {
-            code:
-            "switch (a) {\n" +
+            "}",
+        "switch (a) {\n" +
             "case \"foo\":\n" +
             "    a();\n" +
             "    break;\n" +
@@ -732,11 +727,8 @@ ruleTester.run("indent-legacy", rule, {
             "    else{\n" +
             "        a = 6;\n" +
             "    }\n" +
-            "}"
-        },
-        {
-            code:
-            "switch (a) {\n" +
+            "}",
+        "switch (a) {\n" +
             "case \"foo\":\n" +
             "    a();\n" +
             "    break;\n" +
@@ -746,11 +738,8 @@ ruleTester.run("indent-legacy", rule, {
             "    }\n" +
             "    else\n" +
             "        a = 6;\n" +
-            "}"
-        },
-        {
-            code:
-            "switch (a) {\n" +
+            "}",
+        "switch (a) {\n" +
             "case \"foo\":\n" +
             "    a();\n" +
             "    break;\n" +
@@ -758,14 +747,9 @@ ruleTester.run("indent-legacy", rule, {
             "    a(); break;\n" +
             "case \"baz\":\n" +
             "    a(); break;\n" +
-            "}"
-        },
-        {
-            code: "switch (0) {\n}"
-        },
-        {
-            code:
-            "function foo() {\n" +
+            "}",
+        "switch (0) {\n}",
+        "function foo() {\n" +
             "    var a = \"a\";\n" +
             "    switch(a) {\n" +
             "    case \"a\":\n" +
@@ -774,8 +758,7 @@ ruleTester.run("indent-legacy", rule, {
             "        return \"B\";\n" +
             "    }\n" +
             "}\n" +
-            "foo();"
-        },
+            "foo();",
         {
             code:
             "switch(value){\n" +
@@ -798,23 +781,14 @@ ruleTester.run("indent-legacy", rule, {
             "}",
             options: [4, { SwitchCase: 1 }]
         },
-        {
-            code:
-                "var obj = {foo: 1, bar: 2};\n" +
+        "var obj = {foo: 1, bar: 2};\n" +
                 "with (obj) {\n" +
                 "    console.log(foo + bar);\n" +
-                "}\n"
-        },
-        {
-            code:
-                "if (a) {\n" +
+                "}\n",
+        "if (a) {\n" +
                 "    (1 + 2 + 3);\n" + // no error on this line
-                "}"
-        },
-        {
-            code:
-                "switch(value){ default: a(); break; }\n"
-        },
+                "}",
+        "switch(value){ default: a(); break; }\n",
         {
             code: "import {addons} from 'react/addons'\nimport React from 'react'",
             options: [2],
@@ -940,12 +914,9 @@ ruleTester.run("indent-legacy", rule, {
                 "  ;\n",
             options: [2]
         },
-        {
-            code:
-                "var a = 1\n" +
+        "var a = 1\n" +
                 "   ,b = 2\n" +
-                "   ;"
-        },
+                "   ;",
         {
             code:
                 "export function create (some,\n" +
@@ -1732,20 +1703,14 @@ ruleTester.run("indent-legacy", rule, {
             ")",
             parserOptions: { ecmaFeatures: { globalReturn: true } }
         },
-        {
-            code:
-            "var foo = [\n" +
+        "var foo = [\n" +
             "    bar,\n" +
             "    baz\n" +
-            "]"
-        },
-        {
-            code:
-            "var foo = [bar,\n" +
+            "]",
+        "var foo = [bar,\n" +
             "    baz,\n" +
             "    qux\n" +
-            "]"
-        },
+            "]",
         {
             code:
             "var foo = [bar,\n" +
diff --git a/tests/lib/rules/indent.js b/tests/lib/rules/indent.js
index e2e843bce..63aa710b0 100644
--- a/tests/lib/rules/indent.js
+++ b/tests/lib/rules/indent.js
@@ -405,28 +405,24 @@ ruleTester.run("indent", rule, {
             `,
             options: [4, { VariableDeclarator: 1, SwitchCase: 1 }]
         },
-        {
-            code: unIndent`
-                [{
-                    foo: 1
-                }, {
-                    foo: 2
-                }, {
-                    foo: 3
-                }]
-            `
-        },
-        {
-            code: unIndent`
-                foo([
-                    bar
-                ], [
-                    baz
-                ], [
-                    qux
-                ]);
-            `
-        },
+        unIndent`
+            [{
+                foo: 1
+            }, {
+                foo: 2
+            }, {
+                foo: 3
+            }]
+        `,
+        unIndent`
+            foo([
+                bar
+            ], [
+                baz
+            ], [
+                qux
+            ]);
+        `,
         {
             code: unIndent`
                 abc({
@@ -514,64 +510,52 @@ ruleTester.run("indent", rule, {
             `,
             options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
         },
-        {
-            code: unIndent`
-                var
-                    x = {
-                        a: 1,
-                    },
-                    y = {
-                        b: 2
-                    }
-            `
-        },
-        {
-            code: unIndent`
-                const
-                    x = {
-                        a: 1,
-                    },
-                    y = {
-                        b: 2
-                    }
-            `
-        },
-        {
-            code: unIndent`
-                let
-                    x = {
-                        a: 1,
-                    },
-                    y = {
-                        b: 2
-                    }
-            `
-        },
-        {
-            code: unIndent`
-                var foo = { a: 1 }, bar = {
+        unIndent`
+            var
+                x = {
+                    a: 1,
+                },
+                y = {
                     b: 2
-                };
-            `
-        },
-        {
-            code: unIndent`
-                var foo = { a: 1 }, bar = {
-                        b: 2
-                    },
-                    baz = {
-                        c: 3
-                    }
-            `
-        },
-        {
-            code: unIndent`
-                const {
-                        foo
-                    } = 1,
-                    bar = 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,
@@ -707,30 +691,24 @@ ruleTester.run("indent", rule, {
             `,
             options: [2, { VariableDeclarator: 2, SwitchCase: 1 }]
         },
-        {
-            code: unIndent`
-                var foo = bar ||
-                    !(
-                        baz
-                    );
-            `
-        },
-        {
-            code: unIndent`
-                for (var foo = 1;
-                    foo < 10;
-                    foo++) {}
-            `
-        },
-        {
-            code: unIndent`
-                for (
-                    var foo = 1;
-                    foo < 10;
-                    foo++
-                ) {}
-            `
-        },
+        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)
@@ -940,87 +918,75 @@ ruleTester.run("indent", rule, {
             `,
             options: [4, { SwitchCase: 2 }]
         },
-        {
-            code: unIndent`
-                switch (a) {
-                case "foo":
-                    a();
-                    break;
-                case "bar":
-                    switch(x){
-                    case '1':
-                        break;
-                    case '2':
-                        a = 6;
-                        break;
-                    }
-                }
-            `
-        },
-        {
-            code: unIndent`
-                switch (a) {
-                case "foo":
-                    a();
-                    break;
-                case "bar":
-                    if(x){
-                        a = 2;
-                    }
-                    else{
-                        a = 6;
-                    }
-                }
-            `
-        },
-        {
-            code: unIndent`
-                switch (a) {
-                case "foo":
-                    a();
+        unIndent`
+            switch (a) {
+            case "foo":
+                a();
+                break;
+            case "bar":
+                switch(x){
+                case '1':
                     break;
-                case "bar":
-                    if(x){
-                        a = 2;
-                    }
-                    else
-                        a = 6;
-                }
-            `
-        },
-        {
-            code: unIndent`
-                switch (a) {
-                case "foo":
-                    a();
+                case '2':
+                    a = 6;
                     break;
-                case "bar":
-                    a(); break;
-                case "baz":
-                    a(); break;
-                }
-            `
-        },
-        {
-            code: unIndent`
-                switch (0) {
-                }
-            `
-        },
-        {
-            code: unIndent`
-                function foo() {
-                    var a = "a";
-                    switch(a) {
-                    case "a":
-                        return "A";
-                    case "b":
-                        return "B";
-                    }
                 }
-                foo();
-            `
-        },
+            }
+        `,
+        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){
@@ -1044,24 +1010,18 @@ ruleTester.run("indent", rule, {
             `,
             options: [4, { SwitchCase: 1 }]
         },
-        {
-            code: unIndent`
-                var obj = {foo: 1, bar: 2};
-                with (obj) {
-                    console.log(foo + bar);
-                }
-            `
-        },
-        {
-            code: unIndent`
-                if (a) {
-                    (1 + 2 + 3); // no error on this line
-                }
-            `
-        },
-        {
-            code: "switch(value){ default: a(); break; }"
-        },
+        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'
@@ -1230,13 +1190,11 @@ ruleTester.run("indent", rule, {
             `,
             options: [2]
         },
-        {
-            code: unIndent`
-                var a = 1
-                    ,b = 2
-                    ;
-            `
-        },
+        unIndent`
+            var a = 1
+                ,b = 2
+                ;
+        `,
         {
             code: unIndent`
                 export function create (some,
@@ -1358,14 +1316,12 @@ ruleTester.run("indent", rule, {
             `,
             options: [2, { MemberExpression: 0 }]
         },
-        {
-            code: unIndent`
-                const someOtherFunction = argument => {
-                        console.log(argument);
-                    },
-                    someOtherValue = 'someOtherValue';
-            `
-        },
+        unIndent`
+            const someOtherFunction = argument => {
+                    console.log(argument);
+                },
+                someOtherValue = 'someOtherValue';
+        `,
         {
             code: unIndent`
                 [
@@ -1470,27 +1426,23 @@ ruleTester.run("indent", rule, {
             `,
             options: [4, { VariableDeclarator: 0, SwitchCase: 1 }]
         },
-        {
-            code: unIndent`
-                [[
-                ], function(
-                    foo
-                ) {}
-                ]
-            `
-        },
-        {
-            code: unIndent`
-                define([
-                    'foo'
-                ], function(
-                    bar
-                ) {
-                    baz;
-                }
-                )
-            `
-        },
+        unIndent`
+            [[
+            ], function(
+                foo
+            ) {}
+            ]
+        `,
+        unIndent`
+            define([
+                'foo'
+            ], function(
+                bar
+            ) {
+                baz;
+            }
+            )
+        `,
         {
             code: unIndent`
                 const func = function (opts) {
@@ -1822,72 +1774,58 @@ ruleTester.run("indent", rule, {
             `,
             options: [2, { MemberExpression: 2 }]
         },
-        {
-            code: unIndent`
+        unIndent`
+            (
+                foo
+                    .bar
+            )
+        `,
+        unIndent`
+            (
                 (
                     foo
                         .bar
                 )
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    (
-                        foo
-                            .bar
-                    )
-                )
-            `
-        },
-        {
-            code: unIndent`
+            )
+        `,
+        unIndent`
+            (
+                foo
+            )
+                .bar
+        `,
+        unIndent`
+            (
                 (
                     foo
                 )
                     .bar
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    (
-                        foo
-                    )
-                        .bar
-                )
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    (
-                        foo
-                    )
-                        [
-                            (
-                                bar
-                            )
-                        ]
-                )
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    foo[bar]
-                )
-                    .baz
-            `
-        },
-        {
-            code: unIndent`
+            )
+        `,
+        unIndent`
+            (
                 (
-                    (foo.bar)
+                    foo
                 )
-                    .baz
-            `
-        },
+                    [
+                        (
+                            bar
+                        )
+                    ]
+            )
+        `,
+        unIndent`
+            (
+                foo[bar]
+            )
+                .baz
+        `,
+        unIndent`
+            (
+                (foo.bar)
+            )
+                .baz
+        `,
         {
             code: unIndent`
                 MemberExpression
@@ -2091,16 +2029,14 @@ ruleTester.run("indent", rule, {
             `,
             options: [2]
         },
-        {
-            code: unIndent`
-                [
-                    foo ?
-                        bar :
-                        baz,
-                    qux
-                ];
-            `
-        },
+        unIndent`
+            [
+                foo ?
+                    bar :
+                    baz,
+                qux
+            ];
+        `,
         {
 
             // Checking comments:
@@ -2135,13 +2071,11 @@ ruleTester.run("indent", rule, {
             `,
             options: [2, { SwitchCase: 1 }]
         },
-        {
-            code: unIndent`
-                [
-                    // no elements
-                ]
-            `
-        },
+        unIndent`
+            [
+                // no elements
+            ]
+        `,
         {
 
             // Destructuring assignments:
@@ -2243,33 +2177,27 @@ ruleTester.run("indent", rule, {
             `,
             options: [2]
         },
-        {
-            code: unIndent`
-                (
-                    foo
-                )(
-                    bar
-                )
-            `
-        },
-        {
-            code: unIndent`
-                (() =>
-                    foo
-                )(
-                    bar
-                )
-            `
-        },
-        {
-            code: unIndent`
-                (() => {
-                    foo();
-                })(
-                    bar
-                )
-            `
-        },
+        unIndent`
+            (
+                foo
+            )(
+                bar
+            )
+        `,
+        unIndent`
+            (() =>
+                foo
+            )(
+                bar
+            )
+        `,
+        unIndent`
+            (() => {
+                foo();
+            })(
+                bar
+            )
+        `,
         {
 
             // Don't lint the indentation of the first token after a :
@@ -2288,22 +2216,18 @@ ruleTester.run("indent", rule, {
             `,
             options: [2]
         },
-        {
-            code: unIndent`
-                ({
-                    foo:
-                        bar
-                })
-            `
-        },
-        {
-            code: unIndent`
-                ({
-                    [foo]:
-                        bar
-                })
-            `
-        },
+        unIndent`
+            ({
+                foo:
+                    bar
+            })
+        `,
+        unIndent`
+            ({
+                [foo]:
+                    bar
+            })
+        `,
         {
 
             // Comments in switch cases
@@ -2380,15 +2304,13 @@ ruleTester.run("indent", rule, {
             `,
             options: [2, { FunctionExpression: { parameters: 3 } }]
         },
-        {
-            code: unIndent`
-                function foo() {
-                    return (bar === 1 || bar === 2 &&
-                        (/Function/.test(grandparent.type))) &&
-                        directives(parent).indexOf(node) >= 0;
-                }
-            `
-        },
+        unIndent`
+            function foo() {
+                return (bar === 1 || bar === 2 &&
+                    (/Function/.test(grandparent.type))) &&
+                    directives(parent).indexOf(node) >= 0;
+            }
+        `,
         {
             code: unIndent`
                 function foo() {
@@ -2403,16 +2325,14 @@ ruleTester.run("indent", rule, {
             `,
             options: [4]
         },
-        {
-            code: unIndent`
-                if (
-                    foo === 1 ||
-                    bar === 1 ||
-                    // comment
-                    (baz === 1 && qux === 1)
-                ) {}
-            `
-        },
+        unIndent`
+            if (
+                foo === 1 ||
+                bar === 1 ||
+                // comment
+                (baz === 1 && qux === 1)
+            ) {}
+        `,
         {
             code: unIndent`
                 foo =
@@ -2525,13 +2445,11 @@ ruleTester.run("indent", rule, {
             `,
             options: [2, { CallExpression: { arguments: 4 } }]
         },
-        {
-            code: unIndent`
-                foo(
-                    (bar)
-                );
-            `
-        },
+        unIndent`
+            foo(
+                (bar)
+            );
+        `,
         {
             code: unIndent`
                 foo(
@@ -2571,22 +2489,18 @@ ruleTester.run("indent", rule, {
             `,
             parserOptions: { ecmaFeatures: { globalReturn: true } }
         },
-        {
-            code: unIndent`
-                var foo = [
-                    bar,
-                    baz
-                ]
-            `
-        },
-        {
-            code: unIndent`
-                var foo = [bar,
-                    baz,
-                    qux
-                ]
-            `
-        },
+        unIndent`
+            var foo = [
+                bar,
+                baz
+            ]
+        `,
+        unIndent`
+            var foo = [bar,
+                baz,
+                qux
+            ]
+        `,
         {
             code: unIndent`
                 var foo = [bar,
@@ -2799,56 +2713,44 @@ ruleTester.run("indent", rule, {
             `,
             options: [4]
         },
-        {
-            code: unIndent`
+        unIndent`
+            [
+            ] || [
+            ]
+        `,
+        unIndent`
+            (
                 [
                 ] || [
                 ]
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    [
-                    ] || [
-                    ]
-                )
-            `
-        },
-        {
-            code: unIndent`
+            )
+        `,
+        unIndent`
+            1
+            + (
                 1
-                + (
-                    1
+            )
+        `,
+        unIndent`
+            (
+                foo && (
+                    bar ||
+                    baz
                 )
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    foo && (
-                        bar ||
-                        baz
-                    )
+            )
+        `,
+        unIndent`
+            foo
+                || (
+                    bar
                 )
-            `
-        },
-        {
-            code: unIndent`
-                foo
-                    || (
-                        bar
-                    )
-            `
-        },
-        {
-            code: unIndent`
-                foo
-                                || (
-                                    bar
-                                )
-            `
-        },
+        `,
+        unIndent`
+            foo
+                            || (
+                                bar
+                            )
+        `,
         {
             code: unIndent`
                 var foo =
@@ -2912,61 +2814,46 @@ ruleTester.run("indent", rule, {
             `,
             options: [2]
         },
-        {
-
-            code: unIndent`
-                function foo() {
-                    \`foo\${bar}baz\${
-                        qux}foo\${
-                        bar}baz\`
-                }
-            `
-        },
-        {
-
-            // https://github.com/eslint/eslint/issues/7320
-            code: unIndent`
-                JSON
-                    .stringify(
-                        {
-                            ok: true
-                        }
-                    );
-            `
-        },
+        unIndent`
+            function foo() {
+                \`foo\${bar}baz\${
+                    qux}foo\${
+                    bar}baz\`
+            }
+        `,
+        unIndent`
+            JSON
+                .stringify(
+                    {
+                        ok: true
+                    }
+                );
+        `,
 
         // Don't check AssignmentExpression assignments
-        {
-            code: unIndent`
-                foo =
-                    bar =
-                    baz;
-            `
-        },
-        {
-            code: unIndent`
-                foo =
+        unIndent`
+            foo =
                 bar =
-                    baz;
-            `
-        },
-        {
-            code: unIndent`
-                function foo() {
-                    const template = \`this indentation is not checked
-                because it's part of a template literal.\`;
-                }
-            `
-        },
-        {
-            code: unIndent`
+                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
@@ -2980,51 +2867,41 @@ ruleTester.run("indent", rule, {
             `,
             options: [4, { CallExpression: { arguments: 1 } }]
         },
-        {
-            code: unIndent`
-                [
-                    foo,
-                    // comment
-                    // another comment
+        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
-                ]
-            `
-        },
-        {
-            code: unIndent`
-                if (foo) {
-                    /* comment */ bar();
-                }
-            `
-        },
-        {
-            code: unIndent`
-                function foo() {
-                    return (
-                        1
-                    );
-                }
-            `
-        },
-        {
-            code: unIndent`
-                function foo() {
-                    return (
-                        1
-                    )
-                }
-            `
-        },
-        {
-            code: unIndent`
-                if (
-                    foo &&
-                    !(
-                        bar
-                    )
-                ) {}
-            `
-        },
+                )
+            ) {}
+        `,
         {
 
             // https://github.com/eslint/eslint/issues/6007
@@ -3051,23 +2928,19 @@ ruleTester.run("indent", rule, {
             `,
             options: [2]
         },
-        {
-
-            // https://github.com/eslint/eslint/issues/6670
-            code: unIndent`
-                function f() {
-                    return asyncCall()
-                        .then(
-                            'some string',
-                            [
-                                1,
-                                2,
-                                3
-                            ]
-                        );
-                }
-            `
-        },
+        unIndent`
+            function f() {
+                return asyncCall()
+                    .then(
+                        'some string',
+                        [
+                            1,
+                            2,
+                            3
+                        ]
+                    );
+            }
+        `,
         {
 
             // https://github.com/eslint/eslint/issues/6670
@@ -3088,33 +2961,25 @@ ruleTester.run("indent", rule, {
         },
 
         // https://github.com/eslint/eslint/issues/7242
+        unIndent`
+            var x = [
+                [1],
+                [2]
+            ]
+        `,
+        unIndent`
+            var y = [
+                {a: 1},
+                {b: 2}
+            ]
+        `,
+        unIndent`
+            foo(
+            )
+        `,
         {
-            code: unIndent`
-                var x = [
-                    [1],
-                    [2]
-                ]
-            `
-        },
-        {
-            code: unIndent`
-                var y = [
-                    {a: 1},
-                    {b: 2}
-                ]
-            `
-        },
-        {
-
-            // https://github.com/eslint/eslint/issues/7522
-            code: unIndent`
-                foo(
-                )
-            `
-        },
-        {
-
-            // https://github.com/eslint/eslint/issues/7616
+
+            // https://github.com/eslint/eslint/issues/7616
             code: unIndent`
                 foo(
                     bar,
@@ -3125,19 +2990,13 @@ ruleTester.run("indent", rule, {
             `,
             options: [4, { CallExpression: { arguments: "first" } }]
         },
-        {
-            code: "new Foo"
-        },
-        {
-            code: "new (Foo)"
-        },
-        {
-            code: unIndent`
-                if (Foo) {
-                    new Foo
-                }
-            `
-        },
+        "new Foo",
+        "new (Foo)",
+        unIndent`
+            if (Foo) {
+                new Foo
+            }
+        `,
         {
             code: unIndent`
                 export {
@@ -3422,13 +3281,11 @@ ruleTester.run("indent", rule, {
             `,
             options: [2, { ArrayExpression: "first", MemberExpression: 1 }]
         },
-        {
-            code: unIndent`
-                foo = bar[
-                    baz
-                ];
-            `
-        },
+        unIndent`
+            foo = bar[
+                baz
+            ];
+        `,
         {
             code: unIndent`
                 foo[
@@ -3447,30 +3304,22 @@ ruleTester.run("indent", rule, {
             `,
             options: [4, { MemberExpression: 1 }]
         },
-        {
-            code: unIndent`
-                if (foo)
-                    bar;
-                else if (baz)
-                    qux;
-            `
-        },
-        {
-            code: unIndent`
-                if (foo) bar()
+        unIndent`
+            if (foo)
+                bar;
+            else if (baz)
+                qux;
+        `,
+        unIndent`
+            if (foo) bar()
 
-                ; [1, 2, 3].map(baz)
-            `
-        },
-        {
-            code: unIndent`
-                if (foo)
-                    ;
-            `
-        },
-        {
-            code: "x => {}"
-        },
+            ; [1, 2, 3].map(baz)
+        `,
+        unIndent`
+            if (foo)
+                ;
+        `,
+        "x => {}",
         {
             code: unIndent`
                 import {foo}
@@ -3524,117 +3373,107 @@ ruleTester.run("indent", rule, {
         },
 
         // https://github.com/eslint/eslint/issues/8455
-        {
-            code: unIndent`
+        unIndent`
+            (
+                a
+            ) => b => {
+                c
+            }
+        `,
+        unIndent`
+            (
+                a
+            ) => b => c => d => {
+                e
+            }
+        `,
+        unIndent`
+            (
+                a
+            ) =>
                 (
-                    a
-                ) => b => {
+                    b
+                ) => {
                     c
                 }
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    a
-                ) => b => c => d => {
-                    e
-                }
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    a
-                ) =>
-                    (
-                        b
-                    ) => {
-                        c
-                    }
-            `
-        },
-        {
-            code: unIndent`
-                if (
-                    foo
-                ) bar(
-                    baz
-                );
-            `
-        },
-        {
-            code: unIndent`
-                if (foo)
-                {
-                    bar();
-                }
-            `
-        },
-        {
-            code: unIndent`
-                function foo(bar)
-                {
-                    baz();
-                }
-            `
-        },
-        {
-            code: unIndent`
+        `,
+        unIndent`
+            if (
+                foo
+            ) bar(
+                baz
+            );
+        `,
+        unIndent`
+            if (foo)
+            {
+                bar();
+            }
+        `,
+        unIndent`
+            function foo(bar)
+            {
+                baz();
+            }
+        `,
+        unIndent`
+            () =>
+                ({})
+        `,
+        unIndent`
+            () =>
+                (({}))
+        `,
+        unIndent`
+            (
                 () =>
                     ({})
-            `
-        },
-        {
-            code: unIndent`
-                () =>
-                    (({}))
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    () =>
-                        ({})
-                )
-            `
-        },
-        {
-            code: unIndent`
-                var x = function foop(bar)
+            )
+        `,
+        unIndent`
+            var x = function foop(bar)
+            {
+                baz();
+            }
+        `,
+        unIndent`
+            var x = (bar) =>
+            {
+                baz();
+            }
+        `,
+        unIndent`
+            class Foo
+            {
+                constructor()
                 {
-                    baz();
+                    foo();
                 }
-            `
-        },
-        {
-            code: unIndent`
-                var x = (bar) =>
+
+                bar()
                 {
                     baz();
                 }
-            `
-        },
-        {
-            code: unIndent`
-                class Foo
+            }
+        `,
+        unIndent`
+            class Foo
+                extends Bar
+            {
+                constructor()
                 {
-                    constructor()
-                    {
-                        foo();
-                    }
+                    foo();
+                }
 
-                    bar()
-                    {
-                        baz();
-                    }
+                bar()
+                {
+                    baz();
                 }
-            `
-        },
-        {
-            code: unIndent`
+            }
+        `,
+        unIndent`
+            (
                 class Foo
-                    extends Bar
                 {
                     constructor()
                     {
@@ -3646,26 +3485,8 @@ ruleTester.run("indent", rule, {
                         baz();
                     }
                 }
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    class Foo
-                    {
-                        constructor()
-                        {
-                            foo();
-                        }
-
-                        bar()
-                        {
-                            baz();
-                        }
-                    }
-                )
-            `
-        },
+            )
+        `,
         {
             code: unIndent`
                 switch (foo)
@@ -3676,14 +3497,12 @@ ruleTester.run("indent", rule, {
             `,
             options: [4, { SwitchCase: 1 }]
         },
-        {
-            code: unIndent`
-                foo
-                    .bar(function() {
-                        baz
-                    })
-            `
-        },
+        unIndent`
+            foo
+                .bar(function() {
+                    baz
+                })
+        `,
         {
             code: unIndent`
                 foo
@@ -3693,21 +3512,17 @@ ruleTester.run("indent", rule, {
             `,
             options: [4, { MemberExpression: 2 }]
         },
-        {
-            code: unIndent`
-                foo
-                    [bar](function() {
-                        baz
-                    })
-            `
-        },
-        {
-            code: unIndent`
-                foo.
-                    bar.
+        unIndent`
+            foo
+                [bar](function() {
                     baz
-            `
-        },
+                })
+        `,
+        unIndent`
+            foo.
+                bar.
+                baz
+        `,
         {
             code: unIndent`
                 foo
@@ -3760,180 +3575,142 @@ ruleTester.run("indent", rule, {
             `,
             options: [4, { flatTernaryExpressions: true }]
         },
-        {
-            code: unIndent`
-                  foo
-                      [
-                          bar
-                      ]
-                      .baz(function() {
-                          quz();
-                      })
-            `
-        },
-        {
-            code: unIndent`
-                  [
-                      foo
-                  ][
-                      "map"](function() {
-                      qux();
-                  })
-            `
-        },
-        {
-            code: unIndent`
-                (
-                    a.b(function() {
-                        c;
+        unIndent`
+                foo
+                    [
+                        bar
+                    ]
+                    .baz(function() {
+                        quz();
                     })
-                )
-            `
-        },
-        {
-            code: unIndent`
-                (
+        `,
+        unIndent`
+                [
                     foo
-                ).bar(function() {
-                    baz();
+                ][
+                    "map"](function() {
+                    qux();
                 })
-            `
-        },
-        {
-            code: unIndent`
-                new Foo(
-                    bar
-                        .baz
-                        .qux
-                )
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName =
-                        (baz(
-                            'bar',
-                            'bar'
-                        ));
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName =
+        `,
+        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'
                     ));
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName =
-                        baz(
-                            'bar',
-                            'bar'
-                        );
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName =
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName =
+                (baz(
+                    'bar',
+                    'bar'
+                ));
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName =
                     baz(
                         'bar',
                         'bar'
                     );
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName
-                        = baz(
-                            'bar',
-                            'bar'
-                        );
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName =
+                baz(
+                    'bar',
+                    'bar'
+                );
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName
                     = baz(
                         'bar',
                         'bar'
                     );
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName =
-                        ('fff');
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName =
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName
+                = baz(
+                    'bar',
+                    'bar'
+                );
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName =
                     ('fff');
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName
-                        = ('fff');
-
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName =
+                ('fff');
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName
                     = ('fff');
 
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName =
-                        (
-                            'fff'
-                        );
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName =
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName
+                = ('fff');
+
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName =
                     (
                         'fff'
                     );
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName
-                        =(
-                            'fff'
-                        );
-            `
-        },
-        {
-            code: unIndent`
-                const foo = a.b(),
-                    longName
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName =
+                (
+                    'fff'
+                );
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName
                     =(
                         'fff'
                     );
-            `
-        },
+        `,
+        unIndent`
+            const foo = a.b(),
+                longName
+                =(
+                    'fff'
+                );
+        `,
 
 
         //----------------------------------------------------------------------
@@ -4031,91 +3808,77 @@ ruleTester.run("indent", rule, {
             options: [2, { VariableDeclarator: 1 }],
             parser: parser("unknown-nodes/variable-declarator-type-no-indent")
         },
-        {
-            code: unIndent`
-                foo(\`foo
-                        \`, {
-                        ok: true
-                    },
-                    {
-                        ok: false
-                    }
-                )
-            `
-        },
-        {
-            code: unIndent`
-                foo(tag\`foo
-                        \`, {
-                        ok: true
-                    },
-                    {
-                        ok: false
-                    }
-                )
-            `
-        },
-
-        // https://github.com/eslint/eslint/issues/8815
-        {
-            code: unIndent`
-                async function test() {
-                    const {
-                        foo,
-                        bar,
-                    } = await doSomethingAsync(
-                        1,
-                        2,
-                        3,
-                    );
+        unIndent`
+            foo(\`foo
+                    \`, {
+                    ok: true
+                },
+                {
+                    ok: false
                 }
-            `
-        },
-        {
-            code: unIndent`
-                function* test() {
-                    const {
-                        foo,
-                        bar,
-                    } = yield doSomethingAsync(
-                        1,
-                        2,
-                        3,
-                    );
+            )
+        `,
+        unIndent`
+            foo(tag\`foo
+                    \`, {
+                    ok: true
+                },
+                {
+                    ok: false
                 }
-            `
-        },
-        {
-            code: unIndent`
-                ({
-                    a: b
-                } = +foo(
-                    bar
-                ));
-            `
-        },
-        {
-            code: unIndent`
+            )
+        `,
+
+        // https://github.com/eslint/eslint/issues/8815
+        unIndent`
+            async function test() {
                 const {
                     foo,
                     bar,
-                } = typeof foo(
+                } = await doSomethingAsync(
                     1,
                     2,
                     3,
                 );
-            `
-        },
-        {
-            code: unIndent`
+            }
+        `,
+        unIndent`
+            function* test() {
                 const {
                     foo,
                     bar,
-                } = +(
-                    foo
+                } = 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
@@ -4124,257 +3887,192 @@ ruleTester.run("indent", rule, {
         // License: https://github.com/yannickcr/eslint-plugin-react/blob/7ca9841f22d599f447a27ef5b2a97def9229d6c8/LICENSE
         //----------------------------------------------------------------------
 
-        {
-            code: "<Foo a=\"b\" c=\"d\"/>;"
-        },
-        {
-            code: unIndent`
-                <Foo
-                    a="b"
-                    c="d"
-                />;
-            `
-        },
-        {
-            code: "var foo = <Bar a=\"b\" c=\"d\"/>;"
-        },
-        {
-            code: unIndent`
-                var foo = <Bar
+        "<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"
-                />;
-            `
-        },
-        {
-            code: unIndent`
-                var foo = (<Bar
-                    a="b"
-                    c="d"
-                />);
-            `
-        },
-        {
-            code: unIndent`
-                var foo = (
-                    <Bar
-                        a="b"
-                        c="d"
-                    />
-                );
-            `
-        },
-        {
-            code: unIndent`
-                <
-                    Foo
-                    a="b"
-                    c="d"
-                />;
-            `
-        },
-        {
-            code: unIndent`
-                <Foo
-                    a="b"
-                    c="d"/>;
-            `
-        },
-        {
-            code: unIndent`
-                <
-                    Foo
-                    a="b"
-                    c="d"/>;
-            `
-        },
-        {
-            code: "<a href=\"foo\">bar</a>;"
-
-        },
-        {
-            code: unIndent`
-                <a href="foo">
-                    bar
-                </a>;
-            `
-        },
-        {
-            code: unIndent`
-                <a
-                    href="foo"
-                >
-                    bar
-                </a>;
-            `
-        },
-        {
-            code: unIndent`
-                <a
-                    href="foo">
-                    bar
-                </a>;
-            `
-        },
-        {
-            code: unIndent`
-                <
-                    a
-                    href="foo">
-                    bar
-                </a>;
-            `
-        },
-        {
-            code: unIndent`
-                <a
-                    href="foo">
-                    bar
-                </
-                    a>;
-            `
-        },
-        {
-            code: unIndent`
-                <a
-                    href="foo">
-                    bar
-                </a
-                >;
-            `
-        },
-        {
-            code: unIndent`
+                />
+            );
+        `,
+        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>;
-            `
-        },
-        {
-            code: unIndent`
-                var foo = <a
-                    href="bar"
-                >
-                    baz
-                </a>;
-            `
-        },
-        {
-            code: unIndent`
-                var foo = <a
-                    href="bar">
-                    baz
-                </a>;
-            `
-        },
-        {
-            code: unIndent`
-                var foo = <
-                    a
-                    href="bar">
-                    baz
-                </a>;
-            `
-        },
-        {
-            code: unIndent`
-                var foo = <a
-                    href="bar">
-                    baz
-                </
-                    a>;
-            `
-        },
-        {
-            code: unIndent`
-                var foo = <a
-                    href="bar">
+            `,
+        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
-                >
-            `
-        },
-        {
-            code: unIndent`
-                var foo = (<a
+                </a>
+            );
+        `,
+        unIndent`
+            var foo = (
+                <a
                     href="bar">
                     baz
-                </a>);
-            `
-        },
-        {
-            code: unIndent`
-                var foo = (
-                    <a href="bar">baz</a>
-                );
-            `
-        },
-        {
-            code: unIndent`
-                var foo = (
-                    <a href="bar">
-                        baz
-                    </a>
-                );
-            `
-        },
-        {
-            code: unIndent`
-                var foo = (
-                    <a
-                        href="bar">
-                        baz
-                    </a>
-                );
-            `
-        },
-        {
-            code: "var foo = <a href=\"bar\">baz</a>;"
-        },
-        {
-            code: unIndent`
-                <a>
-                    {
-                    }
                 </a>
-            `
-        },
-        {
-            code: unIndent`
-                <a>
-                    {
-                        foo
-                    }
-                </a>
-            `
-        },
-        {
-            code: unIndent`
-                function foo() {
-                    return (
-                        <a>
-                            {
-                                b.forEach(() => {
-                                    // comment
-                                    a = c
-                                        .d()
-                                        .e();
-                                })
-                            }
-                        </a>
-                    );
+            );
+        `,
+        "var foo = <a href=\"bar\">baz</a>;",
+        unIndent`
+            <a>
+                {
                 }
-            `
-        },
-        {
-            code: "<App></App>"
-        },
-        {
-            code: unIndent`
-                <App>
-                </App>
-            `
-        },
+            </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>
@@ -4519,91 +4217,63 @@ ruleTester.run("indent", rule, {
             `,
             options: [2]
         },
-        {
-            code: unIndent`
-                <div>
-                    {
-                        [
-                            <Foo />,
-                            <Bar />
-                        ]
-                    }
-                </div>
-            `
-        },
-        {
-            code: unIndent`
-                <div>
-                    {foo &&
-                        [
-                            <Foo />,
-                            <Bar />
-                        ]
-                    }
-                </div>
-            `
-        },
-        {
-
-            // Literals indentation is not touched
-            code: unIndent`
-                <div>
-                bar <div>
-                   bar
-                   bar {foo}
-                bar </div>
-                </div>
-            `
-        },
-        {
-
-            // Multiline ternary
-            // (colon at the end of the first expression)
-            code: unIndent`
-                foo ?
-                    <Foo /> :
-                    <Bar />
-            `
-        },
-        {
-
-            // Multiline ternary
-            // (colon at the start of the second expression)
-            code: unIndent`
-                foo ?
-                    <Foo />
-                    : <Bar />
-            `
-        },
-        {
-
-            // Multiline ternary
-            // (colon on its own line)
-            code: unIndent`
-                foo ?
-                    <Foo />
+        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 />
-            `
-        },
-        {
-
-            // Multiline ternary
-            // (multiline JSX, colon on its own line)
-            code: unIndent`
-                <div>
-                    {!foo ?
-                        <Foo
-                            onClick={this.onClick}
-                        />
-                        :
-                        <Bar
-                            onClick={this.onClick}
-                        />
-                    }
-                </div>
-            `
-        },
+                    <Bar
+                        onClick={this.onClick}
+                    />
+                }
+            </div>
+        `,
         {
             code: unIndent`
                 <span>
@@ -4645,12 +4315,10 @@ ruleTester.run("indent", rule, {
             `,
             options: [2]
         },
-        {
-            code: unIndent`
+        unIndent`
               <App foo
               />
-            `
-        },
+            `,
         {
             code: unIndent`
               <App
@@ -4675,20 +4343,16 @@ ruleTester.run("indent", rule, {
             `,
             options: ["tab"]
         },
-        {
-            code: unIndent`
+        unIndent`
                 <App
                     foo
                 />
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 <App
                     foo
                 ></App>
-            `
-        },
+            `,
         {
             code: unIndent`
                 <App
@@ -4793,31 +4457,24 @@ ruleTester.run("indent", rule, {
             `,
             options: ["tab"]
         },
-        {
-            code: unIndent`
+        unIndent`
                 <App
                     foo />
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 <div>
                    unrelated{
                         foo
                     }
                 </div>
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 <div>unrelated{
                     foo
                 }
                 </div>
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 <
                     foo
                         .bar
@@ -4829,46 +4486,36 @@ ruleTester.run("indent", rule, {
                         bar.
                         baz
                 >
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 <
                     input
                     type=
                         "number"
                 />
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 <
                     input
                     type=
                         {'number'}
                 />
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 <
                     input
                     type
                         ="number"
                 />
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 foo ? (
                     bar
                 ) : (
                     baz
                 )
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 foo ? (
                     <div>
                     </div>
@@ -4876,21 +4523,17 @@ ruleTester.run("indent", rule, {
                     <span>
                     </span>
                 )
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 <div>
                     {
                         /* foo */
                     }
                 </div>
-            `
-        },
+            `,
 
         // https://github.com/eslint/eslint/issues/8832
-        {
-            code: unIndent`
+        unIndent`
                 <div>
                     {
                         (
@@ -4898,10 +4541,8 @@ ruleTester.run("indent", rule, {
                         )
                     }
                 </div>
-            `
-        },
-        {
-            code: unIndent`
+            `,
+        unIndent`
                 function A() {
                     return (
                         <div>
@@ -4914,7 +4555,24 @@ ruleTester.run("indent", rule, {
                         </div>
                     );
                 }
-            `
+            `,
+        {
+            code: unIndent`
+                a(b
+                  , c
+                )
+            `,
+            options: [2, { CallExpression: { arguments: "off" } }]
+        },
+        {
+            code: unIndent`
+                a(
+                  new B({
+                    c,
+                  })
+                );
+            `,
+            options: [2, { CallExpression: { arguments: "off" } }]
         }
     ],
 
diff --git a/tests/lib/rules/key-spacing.js b/tests/lib/rules/key-spacing.js
index ff552967c..5fa42b999 100644
--- a/tests/lib/rules/key-spacing.js
+++ b/tests/lib/rules/key-spacing.js
@@ -16,11 +16,7 @@ const ruleTester = new RuleTester();
 
 ruleTester.run("key-spacing", rule, {
 
-    valid: [{
-        code: "({\n})"
-    }, {
-        code: "({\na: b\n})"
-    }, {
+    valid: ["({\n})", "({\na: b\n})", {
         code: "({\n})",
         options: [{ align: "colon" }]
     }, {
diff --git a/tests/lib/rules/keyword-spacing.js b/tests/lib/rules/keyword-spacing.js
index a1f10e121..0f6a6fed8 100644
--- a/tests/lib/rules/keyword-spacing.js
+++ b/tests/lib/rules/keyword-spacing.js
@@ -275,47 +275,47 @@ ruleTester.run("keyword-spacing", rule, {
         // break
         //----------------------------------------------------------------------
 
-        { code: "A: for (;;) { {} break A; }" },
+        "A: for (;;) { {} break A; }",
         { code: "A: for(;;) { {}break A; }", options: [NEITHER] },
         { code: "A: for(;;) { {} break A; }", options: [override("break", BOTH)] },
         { code: "A: for (;;) { {}break A; }", options: [override("break", NEITHER)] },
 
         // not conflict with `block-spacing`
-        { code: "for (;;) {break}" },
+        "for (;;) {break}",
         { code: "for(;;) { break }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: "for (;;) { ;break; }" },
+        "for (;;) { ;break; }",
         { code: "for(;;) { ; break ; }", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // case
         //----------------------------------------------------------------------
 
-        { code: "switch (a) { case 0: {} case +1: }" },
-        { code: "switch (a) { case 0: {} case (1): }" },
+        "switch (a) { case 0: {} case +1: }",
+        "switch (a) { case 0: {} case (1): }",
         { code: "switch(a) { case 0: {}case+1: }", options: [NEITHER] },
         { code: "switch(a) { case 0: {}case(1): }", options: [NEITHER] },
         { code: "switch(a) { case 0: {} case +1: }", options: [override("case", BOTH)] },
         { code: "switch (a) { case 0: {}case+1: }", options: [override("case", NEITHER)] },
 
         // not conflict with `block-spacing`
-        { code: "switch (a) {case 0: }" },
+        "switch (a) {case 0: }",
         { code: "switch(a) { case 0: }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: "switch (a) { case 0: ;case 1: }" },
+        "switch (a) { case 0: ;case 1: }",
         { code: "switch(a) { case 0: ; case 1: }", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // catch
         //----------------------------------------------------------------------
 
-        { code: "try {} catch (e) {}" },
+        "try {} catch (e) {}",
         { code: "try{}catch(e) {}", options: [NEITHER] },
         { code: "try{} catch (e) {}", options: [override("catch", BOTH)] },
         { code: "try {}catch(e) {}", options: [override("catch", NEITHER)] },
-        { code: "try {}\ncatch (e) {}" },
+        "try {}\ncatch (e) {}",
         { code: "try{}\ncatch(e) {}", options: [NEITHER] },
 
         //----------------------------------------------------------------------
@@ -403,64 +403,64 @@ ruleTester.run("keyword-spacing", rule, {
         // continue
         //----------------------------------------------------------------------
 
-        { code: "A: for (;;) { {} continue A; }" },
+        "A: for (;;) { {} continue A; }",
         { code: "A: for(;;) { {}continue A; }", options: [NEITHER] },
         { code: "A: for(;;) { {} continue A; }", options: [override("continue", BOTH)] },
         { code: "A: for (;;) { {}continue A; }", options: [override("continue", NEITHER)] },
 
         // not conflict with `block-spacing`
-        { code: "for (;;) {continue}" },
+        "for (;;) {continue}",
         { code: "for(;;) { continue }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: "for (;;) { ;continue; }" },
+        "for (;;) { ;continue; }",
         { code: "for(;;) { ; continue ; }", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // debugger
         //----------------------------------------------------------------------
 
-        { code: "{} debugger" },
+        "{} debugger",
         { code: "{}debugger", options: [NEITHER] },
         { code: "{} debugger", options: [override("debugger", BOTH)] },
         { code: "{}debugger", options: [override("debugger", NEITHER)] },
 
         // not conflict with `block-spacing`
-        { code: "{debugger}" },
+        "{debugger}",
         { code: "{ debugger }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";debugger;" },
+        ";debugger;",
         { code: "; debugger ;", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // default
         //----------------------------------------------------------------------
 
-        { code: "switch (a) { case 0: {} default: }" },
+        "switch (a) { case 0: {} default: }",
         { code: "switch(a) { case 0: {}default: }", options: [NEITHER] },
         { code: "switch(a) { case 0: {} default: }", options: [override("default", BOTH)] },
         { code: "switch (a) { case 0: {}default: }", options: [override("default", NEITHER)] },
 
         // not conflict with `block-spacing`
-        { code: "switch (a) {default:}" },
+        "switch (a) {default:}",
         { code: "switch(a) { default: }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: "switch (a) { case 0: ;default: }" },
+        "switch (a) { case 0: ;default: }",
         { code: "switch(a) { case 0: ; default: }", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // delete
         //----------------------------------------------------------------------
 
-        { code: "{} delete foo.a" },
+        "{} delete foo.a",
         { code: "{}delete foo.a", options: [NEITHER] },
         { code: "{} delete foo.a", options: [override("delete", BOTH)] },
         { code: "{}delete foo.a", options: [override("delete", NEITHER)] },
 
         // not conflict with `array-bracket-spacing`
-        { code: "[delete foo.a]" },
+        "[delete foo.a]",
         { code: "[ delete foo.a]", options: [NEITHER] },
 
         // not conflict with `arrow-spacing`
@@ -468,37 +468,37 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "(() => delete foo.a)", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `block-spacing`
-        { code: "{delete foo.a }" },
+        "{delete foo.a }",
         { code: "{ delete foo.a }", options: [NEITHER] },
 
         // not conflict with `comma-spacing`
-        { code: "(0,delete foo.a)" },
+        "(0,delete foo.a)",
         { code: "(0, delete foo.a)", options: [NEITHER] },
 
         // not conflict with `computed-property-spacing`
-        { code: "a[delete foo.a]" },
+        "a[delete foo.a]",
         { code: "({[delete foo.a]: 0})", parserOptions: { ecmaVersion: 6 } },
         { code: "a[ delete foo.a]", options: [NEITHER] },
         { code: "({[ delete foo.a]: 0})", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `key-spacing`
-        { code: "({a:delete foo.a })" },
+        "({a:delete foo.a })",
         { code: "({a: delete foo.a })", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";delete foo.a" },
+        ";delete foo.a",
         { code: "; delete foo.a", options: [NEITHER] },
 
         // not conflict with `space-in-parens`
-        { code: "(delete foo.a)" },
+        "(delete foo.a)",
         { code: "( delete foo.a)", options: [NEITHER] },
 
         // not conflict with `space-infix-ops`
-        { code: "a =delete foo.a" },
+        "a =delete foo.a",
         { code: "a = delete foo.a", options: [NEITHER] },
 
         // not conflict with `space-unary-ops`
-        { code: "!delete(foo.a)" },
+        "!delete(foo.a)",
         { code: "! delete (foo.a)", options: [NEITHER] },
 
         // not conflict with `template-curly-spacing`
@@ -513,31 +513,31 @@ ruleTester.run("keyword-spacing", rule, {
         // do
         //----------------------------------------------------------------------
 
-        { code: "{} do {} while (true)" },
+        "{} do {} while (true)",
         { code: "{}do{}while(true)", options: [NEITHER] },
         { code: "{} do {}while(true)", options: [override("do", BOTH)] },
         { code: "{}do{} while (true)", options: [override("do", NEITHER)] },
-        { code: "{}\ndo\n{} while (true)" },
+        "{}\ndo\n{} while (true)",
         { code: "{}\ndo\n{}while(true)", options: [NEITHER] },
 
         // not conflict with `block-spacing`
-        { code: "{do {} while (true)}" },
+        "{do {} while (true)}",
         { code: "{ do{}while(true) }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";do; while (true)" },
+        ";do; while (true)",
         { code: "; do ;while(true)", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // else
         //----------------------------------------------------------------------
 
-        { code: "if (a) {} else {}" },
-        { code: "if (a) {} else if (b) {}" },
-        { code: "if (a) {} else (0)" },
-        { code: "if (a) {} else []" },
-        { code: "if (a) {} else +1" },
-        { code: "if (a) {} else \"a\"" },
+        "if (a) {} else {}",
+        "if (a) {} else if (b) {}",
+        "if (a) {} else (0)",
+        "if (a) {} else []",
+        "if (a) {} else +1",
+        "if (a) {} else \"a\"",
         { code: "if(a){}else{}", options: [NEITHER] },
         { code: "if(a){}else if(b) {}", options: [NEITHER] },
         { code: "if(a) {}else(0)", options: [NEITHER] },
@@ -546,11 +546,11 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "if(a) {}else\"a\"", options: [NEITHER] },
         { code: "if(a) {} else {}", options: [override("else", BOTH)] },
         { code: "if (a) {}else{}", options: [override("else", NEITHER)] },
-        { code: "if (a) {}\nelse\n{}" },
+        "if (a) {}\nelse\n{}",
         { code: "if(a) {}\nelse\n{}", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: "if (a);else;" },
+        "if (a);else;",
         { code: "if(a); else ;", options: [NEITHER] },
 
         //----------------------------------------------------------------------
@@ -581,19 +581,19 @@ ruleTester.run("keyword-spacing", rule, {
         // finally
         //----------------------------------------------------------------------
 
-        { code: "try {} finally {}" },
+        "try {} finally {}",
         { code: "try{}finally{}", options: [NEITHER] },
         { code: "try{} finally {}", options: [override("finally", BOTH)] },
         { code: "try {}finally{}", options: [override("finally", NEITHER)] },
-        { code: "try {}\nfinally\n{}" },
+        "try {}\nfinally\n{}",
         { code: "try{}\nfinally\n{}", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // for
         //----------------------------------------------------------------------
 
-        { code: "{} for (;;) {}" },
-        { code: "{} for (var foo in obj) {}" },
+        "{} for (;;) {}",
+        "{} for (var foo in obj) {}",
         { code: "{} for (var foo of list) {}", parserOptions: { ecmaVersion: 6 } },
         { code: "{}for(;;) {}", options: [NEITHER] },
         { code: "{}for(var foo in obj) {}", options: [NEITHER] },
@@ -606,16 +606,16 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "{}for(var foo of list) {}", options: [override("for", NEITHER)], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `block-spacing`
-        { code: "{for (;;) {} }" },
-        { code: "{for (var foo in obj) {} }" },
+        "{for (;;) {} }",
+        "{for (var foo in obj) {} }",
         { code: "{for (var foo of list) {} }", parserOptions: { ecmaVersion: 6 } },
         { code: "{ for(;;) {} }", options: [NEITHER] },
         { code: "{ for(var foo in obj) {} }", options: [NEITHER] },
         { code: "{ for(var foo of list) {} }", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `semi-spacing`
-        { code: ";for (;;) {}" },
-        { code: ";for (var foo in obj) {}" },
+        ";for (;;) {}",
+        ";for (var foo in obj) {}",
         { code: ";for (var foo of list) {}", parserOptions: { ecmaVersion: 6 } },
         { code: "; for(;;) {}", options: [NEITHER] },
         { code: "; for(var foo in obj) {}", options: [NEITHER] },
@@ -642,13 +642,13 @@ ruleTester.run("keyword-spacing", rule, {
         // function
         //----------------------------------------------------------------------
 
-        { code: "{} function foo() {}" },
+        "{} function foo() {}",
         { code: "{}function foo() {}", options: [NEITHER] },
         { code: "{} function foo() {}", options: [override("function", BOTH)] },
         { code: "{}function foo() {}", options: [override("function", NEITHER)] },
 
         // not conflict with `array-bracket-spacing`
-        { code: "[function() {}]" },
+        "[function() {}]",
         { code: "[ function() {}]", options: [NEITHER] },
 
         // not conflict with `arrow-spacing`
@@ -656,15 +656,15 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "(() => function() {})", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `block-spacing`
-        { code: "{function foo() {} }" },
+        "{function foo() {} }",
         { code: "{ function foo() {} }", options: [NEITHER] },
 
         // not conflict with `comma-spacing`
-        { code: "(0,function() {})" },
+        "(0,function() {})",
         { code: "(0, function() {})", options: [NEITHER] },
 
         // not conflict with `computed-property-spacing`
-        { code: "a[function() {}]" },
+        "a[function() {}]",
         { code: "({[function() {}]: 0})", parserOptions: { ecmaVersion: 6 } },
         { code: "a[ function() {}]", options: [NEITHER] },
         { code: "({[ function(){}]: 0})", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
@@ -674,24 +674,24 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "function *foo() {}", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `key-spacing`
-        { code: "({a:function() {} })" },
+        "({a:function() {} })",
         { code: "({a: function() {} })", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";function foo() {};" },
+        ";function foo() {};",
         { code: "; function foo() {} ;", options: [NEITHER] },
 
         // not conflict with `space-before-function-paren`
         // not conflict with `space-in-parens`
-        { code: "(function() {})" },
+        "(function() {})",
         { code: "( function () {})", options: [NEITHER] },
 
         // not conflict with `space-infix-ops`
-        { code: "a =function() {}" },
+        "a =function() {}",
         { code: "a = function() {}", options: [NEITHER] },
 
         // not conflict with `space-unary-ops`
-        { code: "!function() {}" },
+        "!function() {}",
         { code: "! function() {}", options: [NEITHER] },
 
         // not conflict with `template-curly-spacing`
@@ -725,8 +725,8 @@ ruleTester.run("keyword-spacing", rule, {
         // if
         //----------------------------------------------------------------------
 
-        { code: "{} if (a) {}" },
-        { code: "if (a) {} else if (a) {}" },
+        "{} if (a) {}",
+        "if (a) {} else if (a) {}",
         { code: "{}if(a) {}", options: [NEITHER] },
         { code: "if(a) {}else if(a) {}", options: [NEITHER] },
         { code: "{} if (a) {}", options: [override("if", BOTH)] },
@@ -735,11 +735,11 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "if(a) {} else if(a) {}", options: [override("if", NEITHER)] },
 
         // not conflict with `block-spacing`
-        { code: "{if (a) {} }" },
+        "{if (a) {} }",
         { code: "{ if(a) {} }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";if (a) {}" },
+        ";if (a) {}",
         { code: "; if(a) {}", options: [NEITHER] },
 
         //----------------------------------------------------------------------
@@ -771,7 +771,7 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "for ([foo] in ({foo: 0})) {}", parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `space-infix-ops`
-        { code: "if (\"foo\"in{foo: 0}) {}" },
+        "if (\"foo\"in{foo: 0}) {}",
         { code: "if(\"foo\" in {foo: 0}) {}", options: [NEITHER] },
 
         //----------------------------------------------------------------------
@@ -779,7 +779,7 @@ ruleTester.run("keyword-spacing", rule, {
         //----------------------------------------------------------------------
 
         // not conflict with `space-infix-ops`
-        { code: "if (\"foo\"instanceof{foo: 0}) {}" },
+        "if (\"foo\"instanceof{foo: 0}) {}",
         { code: "if(\"foo\" instanceof {foo: 0}) {}", options: [NEITHER] },
 
         //----------------------------------------------------------------------
@@ -803,13 +803,13 @@ ruleTester.run("keyword-spacing", rule, {
         // new
         //----------------------------------------------------------------------
 
-        { code: "{} new foo()" },
+        "{} new foo()",
         { code: "{}new foo()", options: [NEITHER] },
         { code: "{} new foo()", options: [override("new", BOTH)] },
         { code: "{}new foo()", options: [override("new", NEITHER)] },
 
         // not conflict with `array-bracket-spacing`
-        { code: "[new foo()]" },
+        "[new foo()]",
         { code: "[ new foo()]", options: [NEITHER] },
 
         // not conflict with `arrow-spacing`
@@ -817,37 +817,37 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "(() => new foo())", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `block-spacing`
-        { code: "{new foo() }" },
+        "{new foo() }",
         { code: "{ new foo() }", options: [NEITHER] },
 
         // not conflict with `comma-spacing`
-        { code: "(0,new foo())" },
+        "(0,new foo())",
         { code: "(0, new foo())", options: [NEITHER] },
 
         // not conflict with `computed-property-spacing`
-        { code: "a[new foo()]" },
+        "a[new foo()]",
         { code: "({[new foo()]: 0})", parserOptions: { ecmaVersion: 6 } },
         { code: "a[ new foo()]", options: [NEITHER] },
         { code: "({[ new foo()]: 0})", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `key-spacing`
-        { code: "({a:new foo() })" },
+        "({a:new foo() })",
         { code: "({a: new foo() })", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";new foo()" },
+        ";new foo()",
         { code: "; new foo()", options: [NEITHER] },
 
         // not conflict with `space-in-parens`
-        { code: "(new foo())" },
+        "(new foo())",
         { code: "( new foo())", options: [NEITHER] },
 
         // not conflict with `space-infix-ops`
-        { code: "a =new foo()" },
+        "a =new foo()",
         { code: "a = new foo()", options: [NEITHER] },
 
         // not conflict with `space-unary-ops`
-        { code: "!new(foo)()" },
+        "!new(foo)()",
         { code: "! new (foo)()", options: [NEITHER] },
 
         // not conflict with `template-curly-spacing`
@@ -872,19 +872,19 @@ ruleTester.run("keyword-spacing", rule, {
         // return
         //----------------------------------------------------------------------
 
-        { code: "function foo() { {} return +a }" },
+        "function foo() { {} return +a }",
         { code: "function foo() { {}return+a }", options: [NEITHER] },
         { code: "function foo() { {} return +a }", options: [override("return", BOTH)] },
         { code: "function foo() { {}return+a }", options: [override("return", NEITHER)] },
-        { code: "function foo() {\nreturn\n}" },
+        "function foo() {\nreturn\n}",
         { code: "function foo() {\nreturn\n}", options: [NEITHER] },
 
         // not conflict with `block-spacing`
-        { code: "function foo() {return}" },
+        "function foo() {return}",
         { code: "function foo() { return }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: "function foo() { ;return; }" },
+        "function foo() { ;return; }",
         { code: "function foo() { ; return ; }", options: [NEITHER] },
 
         //----------------------------------------------------------------------
@@ -987,30 +987,30 @@ ruleTester.run("keyword-spacing", rule, {
         // switch
         //----------------------------------------------------------------------
 
-        { code: "{} switch (a) {}" },
+        "{} switch (a) {}",
         { code: "{}switch(a) {}", options: [NEITHER] },
         { code: "{} switch (a) {}", options: [override("switch", BOTH)] },
         { code: "{}switch(a) {}", options: [override("switch", NEITHER)] },
 
         // not conflict with `block-spacing`
-        { code: "{switch (a) {} }" },
+        "{switch (a) {} }",
         { code: "{ switch(a) {} }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";switch (a) {}" },
+        ";switch (a) {}",
         { code: "; switch(a) {}", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // this
         //----------------------------------------------------------------------
 
-        { code: "{} this[a]" },
+        "{} this[a]",
         { code: "{}this[a]", options: [NEITHER] },
         { code: "{} this[a]", options: [override("this", BOTH)] },
         { code: "{}this[a]", options: [override("this", NEITHER)] },
 
         // not conflict with `array-bracket-spacing`
-        { code: "[this]" },
+        "[this]",
         { code: "[ this ]", options: [NEITHER] },
 
         // not conflict with `arrow-spacing`
@@ -1018,37 +1018,37 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "(() => this)", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `block-spacing`
-        { code: "{this}" },
+        "{this}",
         { code: "{ this }", options: [NEITHER] },
 
         // not conflict with `comma-spacing`
-        { code: "(0,this)" },
+        "(0,this)",
         { code: "(0, this)", options: [NEITHER] },
 
         // not conflict with `computed-property-spacing`
-        { code: "a[this]" },
+        "a[this]",
         { code: "({[this]: 0})", parserOptions: { ecmaVersion: 6 } },
         { code: "a[ this ]", options: [NEITHER] },
         { code: "({[ this ]: 0})", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `key-spacing`
-        { code: "({a:this })" },
+        "({a:this })",
         { code: "({a: this })", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";this" },
+        ";this",
         { code: "; this", options: [NEITHER] },
 
         // not conflict with `space-in-parens`
-        { code: "(this)" },
+        "(this)",
         { code: "( this )", options: [NEITHER] },
 
         // not conflict with `space-infix-ops`
-        { code: "a =this" },
+        "a =this",
         { code: "a = this", options: [NEITHER] },
 
         // not conflict with `space-unary-ops`
-        { code: "!this" },
+        "!this",
         { code: "! this", options: [NEITHER] },
 
         // not conflict with `template-curly-spacing`
@@ -1063,49 +1063,49 @@ ruleTester.run("keyword-spacing", rule, {
         // throw
         //----------------------------------------------------------------------
 
-        { code: "function foo() { {} throw +a }" },
+        "function foo() { {} throw +a }",
         { code: "function foo() { {}throw+a }", options: [NEITHER] },
         { code: "function foo() { {} throw +a }", options: [override("throw", BOTH)] },
         { code: "function foo() { {}throw+a }", options: [override("throw", NEITHER)] },
-        { code: "function foo() {\nthrow a\n}" },
+        "function foo() {\nthrow a\n}",
         { code: "function foo() {\nthrow a\n}", options: [NEITHER] },
 
         // not conflict with `block-spacing`
-        { code: "function foo() {throw a }" },
+        "function foo() {throw a }",
         { code: "function foo() { throw a }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: "function foo() { ;throw a }" },
+        "function foo() { ;throw a }",
         { code: "function foo() { ; throw a }", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // try
         //----------------------------------------------------------------------
 
-        { code: "{} try {} finally {}" },
+        "{} try {} finally {}",
         { code: "{}try{}finally{}", options: [NEITHER] },
         { code: "{} try {}finally{}", options: [override("try", BOTH)] },
         { code: "{}try{} finally {}", options: [override("try", NEITHER)] },
 
         // not conflict with `block-spacing`
-        { code: "{try {} finally {}}" },
+        "{try {} finally {}}",
         { code: "{ try{}finally{}}", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";try {} finally {}" },
+        ";try {} finally {}",
         { code: "; try{}finally{}", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // typeof
         //----------------------------------------------------------------------
 
-        { code: "{} typeof foo" },
+        "{} typeof foo",
         { code: "{}typeof foo", options: [NEITHER] },
         { code: "{} typeof foo", options: [override("typeof", BOTH)] },
         { code: "{}typeof foo", options: [override("typeof", NEITHER)] },
 
         // not conflict with `array-bracket-spacing`
-        { code: "[typeof foo]" },
+        "[typeof foo]",
         { code: "[ typeof foo]", options: [NEITHER] },
 
         // not conflict with `arrow-spacing`
@@ -1113,37 +1113,37 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "(() => typeof foo)", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `block-spacing`
-        { code: "{typeof foo }" },
+        "{typeof foo }",
         { code: "{ typeof foo }", options: [NEITHER] },
 
         // not conflict with `comma-spacing`
-        { code: "(0,typeof foo)" },
+        "(0,typeof foo)",
         { code: "(0, typeof foo)", options: [NEITHER] },
 
         // not conflict with `computed-property-spacing`
-        { code: "a[typeof foo]" },
+        "a[typeof foo]",
         { code: "({[typeof foo]: 0})", parserOptions: { ecmaVersion: 6 } },
         { code: "a[ typeof foo]", options: [NEITHER] },
         { code: "({[ typeof foo]: 0})", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `key-spacing`
-        { code: "({a:typeof foo })" },
+        "({a:typeof foo })",
         { code: "({a: typeof foo })", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";typeof foo" },
+        ";typeof foo",
         { code: "; typeof foo", options: [NEITHER] },
 
         // not conflict with `space-in-parens`
-        { code: "(typeof foo)" },
+        "(typeof foo)",
         { code: "( typeof foo)", options: [NEITHER] },
 
         // not conflict with `space-infix-ops`
-        { code: "a =typeof foo" },
+        "a =typeof foo",
         { code: "a = typeof foo", options: [NEITHER] },
 
         // not conflict with `space-unary-ops`
-        { code: "!typeof+foo" },
+        "!typeof+foo",
         { code: "! typeof +foo", options: [NEITHER] },
 
         // not conflict with `template-curly-spacing`
@@ -1162,27 +1162,27 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "{}var[a] = b", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
         { code: "{} var [a] = b", options: [override("var", BOTH)], parserOptions: { ecmaVersion: 6 } },
         { code: "{}var[a] = b", options: [override("var", NEITHER)], parserOptions: { ecmaVersion: 6 } },
-        { code: "for (var foo in [1, 2, 3]) {}" },
+        "for (var foo in [1, 2, 3]) {}",
 
         // not conflict with `block-spacing`
-        { code: "{var a = b }" },
+        "{var a = b }",
         { code: "{ var a = b }", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";var a = b" },
+        ";var a = b",
         { code: "; var a = b", options: [NEITHER] },
 
         //----------------------------------------------------------------------
         // void
         //----------------------------------------------------------------------
 
-        { code: "{} void foo" },
+        "{} void foo",
         { code: "{}void foo", options: [NEITHER] },
         { code: "{} void foo", options: [override("void", BOTH)] },
         { code: "{}void foo", options: [override("void", NEITHER)] },
 
         // not conflict with `array-bracket-spacing`
-        { code: "[void foo]" },
+        "[void foo]",
         { code: "[ void foo]", options: [NEITHER] },
 
         // not conflict with `arrow-spacing`
@@ -1190,37 +1190,37 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "(() => void foo)", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `block-spacing`
-        { code: "{void foo }" },
+        "{void foo }",
         { code: "{ void foo }", options: [NEITHER] },
 
         // not conflict with `comma-spacing`
-        { code: "(0,void foo)" },
+        "(0,void foo)",
         { code: "(0, void foo)", options: [NEITHER] },
 
         // not conflict with `computed-property-spacing`
-        { code: "a[void foo]" },
+        "a[void foo]",
         { code: "({[void foo]: 0})", parserOptions: { ecmaVersion: 6 } },
         { code: "a[ void foo]", options: [NEITHER] },
         { code: "({[ void foo]: 0})", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
 
         // not conflict with `key-spacing`
-        { code: "({a:void foo })" },
+        "({a:void foo })",
         { code: "({a: void foo })", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";void foo" },
+        ";void foo",
         { code: "; void foo", options: [NEITHER] },
 
         // not conflict with `space-in-parens`
-        { code: "(void foo)" },
+        "(void foo)",
         { code: "( void foo)", options: [NEITHER] },
 
         // not conflict with `space-infix-ops`
-        { code: "a =void foo" },
+        "a =void foo",
         { code: "a = void foo", options: [NEITHER] },
 
         // not conflict with `space-unary-ops`
-        { code: "!void+foo" },
+        "!void+foo",
         { code: "! void +foo", options: [NEITHER] },
 
         // not conflict with `template-curly-spacing`
@@ -1235,24 +1235,24 @@ ruleTester.run("keyword-spacing", rule, {
         // while
         //----------------------------------------------------------------------
 
-        { code: "{} while (a) {}" },
-        { code: "do {} while (a)" },
+        "{} while (a) {}",
+        "do {} while (a)",
         { code: "{}while(a) {}", options: [NEITHER] },
         { code: "do{}while(a)", options: [NEITHER] },
         { code: "{} while (a) {}", options: [override("while", BOTH)] },
         { code: "do{} while (a)", options: [override("while", BOTH)] },
         { code: "{}while(a) {}", options: [override("while", NEITHER)] },
         { code: "do {}while(a)", options: [override("while", NEITHER)] },
-        { code: "do {}\nwhile (a)" },
+        "do {}\nwhile (a)",
         { code: "do{}\nwhile(a)", options: [NEITHER] },
 
         // not conflict with `block-spacing`
-        { code: "{while (a) {}}" },
+        "{while (a) {}}",
         { code: "{ while(a) {}}", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";while (a);" },
-        { code: "do;while (a);" },
+        ";while (a);",
+        "do;while (a);",
         { code: "; while(a) ;", options: [NEITHER] },
         { code: "do ; while(a) ;", options: [NEITHER] },
 
@@ -1260,17 +1260,17 @@ ruleTester.run("keyword-spacing", rule, {
         // with
         //----------------------------------------------------------------------
 
-        { code: "{} with (obj) {}" },
+        "{} with (obj) {}",
         { code: "{}with(obj) {}", options: [NEITHER] },
         { code: "{} with (obj) {}", options: [override("with", BOTH)] },
         { code: "{}with(obj) {}", options: [override("with", NEITHER)] },
 
         // not conflict with `block-spacing`
-        { code: "{with (obj) {}}" },
+        "{with (obj) {}}",
         { code: "{ with(obj) {}}", options: [NEITHER] },
 
         // not conflict with `semi-spacing`
-        { code: ";with (obj) {}" },
+        ";with (obj) {}",
         { code: "; with(obj) {}", options: [NEITHER] },
 
         //----------------------------------------------------------------------
diff --git a/tests/lib/rules/linebreak-style.js b/tests/lib/rules/linebreak-style.js
index 1e94051bf..bc9283735 100644
--- a/tests/lib/rules/linebreak-style.js
+++ b/tests/lib/rules/linebreak-style.js
@@ -23,9 +23,7 @@ const ruleTester = new RuleTester();
 ruleTester.run("linebreak-style", rule, {
 
     valid: [
-        {
-            code: "var a = 'a',\n b = 'b';\n\n function foo(params) {\n /* do stuff */ \n }\n"
-        },
+        "var a = 'a',\n b = 'b';\n\n function foo(params) {\n /* do stuff */ \n }\n",
         {
             code: "var a = 'a',\n b = 'b';\n\n function foo(params) {\n /* do stuff */ \n }\n",
             options: ["unix"]
diff --git a/tests/lib/rules/lines-around-comment.js b/tests/lib/rules/lines-around-comment.js
index 9b2aac00e..b47f74401 100644
--- a/tests/lib/rules/lines-around-comment.js
+++ b/tests/lib/rules/lines-around-comment.js
@@ -25,11 +25,11 @@ ruleTester.run("lines-around-comment", rule, {
     valid: [
 
         // default rules
-        { code: "bar()\n\n/** block block block\n * block \n */\n\nvar a = 1;" },
-        { code: "bar()\n\n/** block block block\n * block \n */\nvar a = 1;" },
-        { code: "bar()\n// line line line \nvar a = 1;" },
-        { code: "bar()\n\n// line line line\nvar a = 1;" },
-        { code: "bar()\n// line line line\n\nvar a = 1;" },
+        "bar()\n\n/** block block block\n * block \n */\n\nvar a = 1;",
+        "bar()\n\n/** block block block\n * block \n */\nvar a = 1;",
+        "bar()\n// line line line \nvar a = 1;",
+        "bar()\n\n// line line line\nvar a = 1;",
+        "bar()\n// line line line\n\nvar a = 1;",
 
         // line comments
         {
diff --git a/tests/lib/rules/max-depth.js b/tests/lib/rules/max-depth.js
index 1ab2674ca..f9899cbad 100644
--- a/tests/lib/rules/max-depth.js
+++ b/tests/lib/rules/max-depth.js
@@ -23,7 +23,7 @@ ruleTester.run("max-depth", rule, {
         { code: "function foo() { if (true) { if (false) { if (true) { } } } }", options: [3] },
         { code: "function foo() { if (true) { } else if (false) { } else if (true) { } else if (false) {} }", options: [3] },
         { code: "var foo = () => { if (true) { if (false) { if (true) { } } } }", options: [3], parserOptions: { ecmaVersion: 6 } },
-        { code: "function foo() { if (true) { if (false) { if (true) { } } } }" },
+        "function foo() { if (true) { if (false) { if (true) { } } } }",
 
         // object property options
         { code: "function foo() { if (true) { if (false) { if (true) { } } } }", options: [{ max: 3 }] }
diff --git a/tests/lib/rules/max-lines.js b/tests/lib/rules/max-lines.js
index 354a59c25..199a6bfd4 100644
--- a/tests/lib/rules/max-lines.js
+++ b/tests/lib/rules/max-lines.js
@@ -31,8 +31,8 @@ function errorMessage(limitLines, actualLines) {
 
 ruleTester.run("max-lines", rule, {
     valid: [
-        { code: "var x;" },
-        { code: "var xy;\nvar xy;" },
+        "var x;",
+        "var xy;\nvar xy;",
         { code: "var xy;\nvar xy;", options: [2] },
         { code: "var xy;\nvar xy;", options: [{ max: 2 }] },
         {
diff --git a/tests/lib/rules/max-nested-callbacks.js b/tests/lib/rules/max-nested-callbacks.js
index 899398dbf..752051ef6 100644
--- a/tests/lib/rules/max-nested-callbacks.js
+++ b/tests/lib/rules/max-nested-callbacks.js
@@ -43,7 +43,7 @@ ruleTester.run("max-nested-callbacks", rule, {
         { code: "var foo = function() {}; bar(function(){ baz(function() { qux(foo); }) });", options: [2] },
         { code: "fn(function(){}, function(){}, function(){});", options: [2] },
         { code: "fn(() => {}, function(){}, function(){});", options: [2], parserOptions: { ecmaVersion: 6 } },
-        { code: nestFunctions(10) },
+        nestFunctions(10),
 
         // object property options
         { code: "foo(function() { bar(thing, function(data) {}); });", options: [{ max: 3 }] }
diff --git a/tests/lib/rules/max-params.js b/tests/lib/rules/max-params.js
index d5ae0d1fb..3cb47044f 100644
--- a/tests/lib/rules/max-params.js
+++ b/tests/lib/rules/max-params.js
@@ -20,7 +20,7 @@ const ruleTester = new RuleTester();
 
 ruleTester.run("max-params", rule, {
     valid: [
-        { code: "function test(d, e, f) {}" },
+        "function test(d, e, f) {}",
         { code: "var test = function(a, b, c) {};", options: [3] },
         { code: "var test = (a, b, c) => {};", options: [3], parserOptions: { ecmaVersion: 6 } },
         { code: "var test = function test(a, b, c) {};", options: [3] },
diff --git a/tests/lib/rules/max-statements-per-line.js b/tests/lib/rules/max-statements-per-line.js
index bb1c31ea3..dd70ec679 100644
--- a/tests/lib/rules/max-statements-per-line.js
+++ b/tests/lib/rules/max-statements-per-line.js
@@ -21,10 +21,10 @@ const ruleTester = new RuleTester();
 ruleTester.run("max-statements-per-line", rule, {
     valid: [
         { code: "{ }", options: [{ max: 1 }] },
-        { code: "var bar = 1;" },
+        "var bar = 1;",
         { code: "var bar = 1;", options: [{ max: 1 }] },
-        { code: "var bar = 1;;" },
-        { code: ";(function foo() {\n})()" },
+        "var bar = 1;;",
+        ";(function foo() {\n})()",
         { code: "if (condition) var bar = 1;", options: [{ max: 1 }] },
         { code: "if (condition) { }", options: [{ max: 1 }] },
         { code: "if (condition) { } else { }", options: [{ max: 1 }] },
@@ -78,14 +78,12 @@ ruleTester.run("max-statements-per-line", rule, {
             options: [{ max: 1 }],
             parserOptions: { ecmaVersion: 6 }
         },
-        {
-            code: [
-                "if (foo > 1)",
-                "    foo--;",
-                "else",
-                "    foo++;"
-            ].join("\n")
-        },
+        [
+            "if (foo > 1)",
+            "    foo--;",
+            "else",
+            "    foo++;"
+        ].join("\n"),
         {
             code: "export default foo = 0;",
             options: [{ max: 1 }],
diff --git a/tests/lib/rules/max-statements.js b/tests/lib/rules/max-statements.js
index 0d5933106..2b030a7e0 100644
--- a/tests/lib/rules/max-statements.js
+++ b/tests/lib/rules/max-statements.js
@@ -23,7 +23,7 @@ ruleTester.run("max-statements", rule, {
         { code: "function foo() { var bar = 1; function qux () { var noCount = 2; } return 3; }", options: [3] },
         { code: "function foo() { var bar = 1; if (true) { for (;;) { var qux = null; } } else { quxx(); } return 3; }", options: [6] },
         { code: "function foo() { var x = 5; function bar() { var y = 6; } bar(); z = 10; baz(); }", options: [5] },
-        { code: "function foo() { var a; var b; var c; var x; var y; var z; bar(); baz(); qux(); quxx(); }" },
+        "function foo() { var a; var b; var c; var x; var y; var z; bar(); baz(); qux(); quxx(); }",
         { code: "(function() { var bar = 1; return function () { return 42; }; })()", options: [1, { ignoreTopLevelFunctions: true }] },
         { code: "function foo() { var bar = 1; var baz = 2; }", options: [1, { ignoreTopLevelFunctions: true }] },
         { code: "define(['foo', 'qux'], function(foo, qux) { var bar = 1; var baz = 2; })", options: [1, { ignoreTopLevelFunctions: true }] },
diff --git a/tests/lib/rules/newline-per-chained-call.js b/tests/lib/rules/newline-per-chained-call.js
index 8bea0a04b..232aafed6 100644
--- a/tests/lib/rules/newline-per-chained-call.js
+++ b/tests/lib/rules/newline-per-chained-call.js
@@ -15,31 +15,7 @@ const rule = require("../../../lib/rules/newline-per-chained-call"),
 const ruleTester = new RuleTester();
 
 ruleTester.run("newline-per-chained-call", rule, {
-    valid: [{
-        code: "_\n.chain({})\n.map(foo)\n.filter(bar)\n.value();"
-    }, {
-        code: "a.b.c.d.e.f"
-    }, {
-        code: "a()\n.b()\n.c\n.e"
-    }, {
-        code: "var a = m1.m2(); var b = m1.m2();\nvar c = m1.m2()"
-    }, {
-        code: "var a = m1()\n.m2();"
-    }, {
-        code: "var a = m1();"
-    }, {
-        code: "a()\n.b().c.e.d()"
-    }, {
-        code: "a().b().c.e.d()"
-    }, {
-        code: "a.b.c.e.d()"
-    }, {
-        code: "var a = window\n.location\n.href\n.match(/(^[^#]*)/)[0];"
-    }, {
-        code: "var a = window['location']\n.href\n.match(/(^[^#]*)/)[0];"
-    }, {
-        code: "var a = window['location'].href.match(/(^[^#]*)/)[0];"
-    }, {
+    valid: ["_\n.chain({})\n.map(foo)\n.filter(bar)\n.value();", "a.b.c.d.e.f", "a()\n.b()\n.c\n.e", "var a = m1.m2(); var b = m1.m2();\nvar c = m1.m2()", "var a = m1()\n.m2();", "var a = m1();", "a()\n.b().c.e.d()", "a().b().c.e.d()", "a.b.c.e.d()", "var a = window\n.location\n.href\n.match(/(^[^#]*)/)[0];", "var a = window['location']\n.href\n.match(/(^[^#]*)/)[0];", "var a = window['location'].href.match(/(^[^#]*)/)[0];", {
         code: "var a = m1().m2.m3();",
         options: [{
             ignoreChainWithDepth: 3
diff --git a/tests/lib/rules/no-compare-neg-zero.js b/tests/lib/rules/no-compare-neg-zero.js
index 3ad996b0a..d8f4812f3 100644
--- a/tests/lib/rules/no-compare-neg-zero.js
+++ b/tests/lib/rules/no-compare-neg-zero.js
@@ -22,33 +22,33 @@ const ruleTester = new RuleTester();
 ruleTester.run("no-compare-neg-zero", rule, {
 
     valid: [
-        { code: "x === 0" },
-        { code: "0 === x" },
-        { code: "x == 0" },
-        { code: "0 == x" },
-        { code: "x === '0'" },
-        { code: "'0' === x" },
-        { code: "x == '0'" },
-        { code: "'0' == x" },
-        { code: "x === '-0'" },
-        { code: "'-0' === x" },
-        { code: "x == '-0'" },
-        { code: "'-0' == x" },
-        { code: "x === -1" },
-        { code: "-1 === x" },
-        { code: "x < 0" },
-        { code: "0 < x" },
-        { code: "x <= 0" },
-        { code: "0 <= x" },
-        { code: "x > 0" },
-        { code: "0 > x" },
-        { code: "x >= 0" },
-        { code: "0 >= x" },
-        { code: "x != 0" },
-        { code: "0 != x" },
-        { code: "x !== 0" },
-        { code: "0 !== x" },
-        { code: "Object.is(x, -0)" }
+        "x === 0",
+        "0 === x",
+        "x == 0",
+        "0 == x",
+        "x === '0'",
+        "'0' === x",
+        "x == '0'",
+        "'0' == x",
+        "x === '-0'",
+        "'-0' === x",
+        "x == '-0'",
+        "'-0' == x",
+        "x === -1",
+        "-1 === x",
+        "x < 0",
+        "0 < x",
+        "x <= 0",
+        "0 <= x",
+        "x > 0",
+        "0 > x",
+        "x >= 0",
+        "0 >= x",
+        "x != 0",
+        "0 != x",
+        "x !== 0",
+        "0 !== x",
+        "Object.is(x, -0)"
     ],
 
     invalid: [
diff --git a/tests/lib/rules/no-confusing-arrow.js b/tests/lib/rules/no-confusing-arrow.js
index ebce23132..e79461bee 100644
--- a/tests/lib/rules/no-confusing-arrow.js
+++ b/tests/lib/rules/no-confusing-arrow.js
@@ -20,9 +20,9 @@ const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 ruleTester.run("no-confusing-arrow", rule, {
     valid: [
-        { code: "a => { return 1 ? 2 : 3; }" },
-        { code: "var x = a => { return 1 ? 2 : 3; }" },
-        { code: "var x = (a) => { return 1 ? 2 : 3; }" },
+        "a => { return 1 ? 2 : 3; }",
+        "var x = a => { return 1 ? 2 : 3; }",
+        "var x = (a) => { return 1 ? 2 : 3; }",
         { code: "var x = a => (1 ? 2 : 3)", options: [{ allowParens: true }] }
     ],
     invalid: [
diff --git a/tests/lib/rules/no-constant-condition.js b/tests/lib/rules/no-constant-condition.js
index 41f3d4bc3..b113ebb09 100644
--- a/tests/lib/rules/no-constant-condition.js
+++ b/tests/lib/rules/no-constant-condition.js
@@ -60,15 +60,15 @@ ruleTester.run("no-constant-condition", rule, {
         { code: "for(;true;);", options: [{ checkLoops: false }] },
         { code: "do{}while(true)", options: [{ checkLoops: false }] },
 
-        { code: "function* foo(){while(true){yield 'foo';}}" },
-        { code: "function* foo(){for(;true;){yield 'foo';}}" },
-        { code: "function* foo(){do{yield 'foo';}while(true)}" },
-        { code: "function* foo(){while (true) { while(true) {yield;}}}" },
-        { code: "function* foo() {for (; yield; ) {}}" },
-        { code: "function* foo() {for (; ; yield) {}}" },
-        { code: "function* foo() {while (true) {function* foo() {yield;}yield;}}" },
-        { code: "function* foo() { for (let x = yield; x < 10; x++) {yield;}yield;}" },
-        { code: "function* foo() { for (let x = yield; ; x++) { yield; }}" }
+        "function* foo(){while(true){yield 'foo';}}",
+        "function* foo(){for(;true;){yield 'foo';}}",
+        "function* foo(){do{yield 'foo';}while(true)}",
+        "function* foo(){while (true) { while(true) {yield;}}}",
+        "function* foo() {for (; yield; ) {}}",
+        "function* foo() {for (; ; yield) {}}",
+        "function* foo() {while (true) {function* foo() {yield;}yield;}}",
+        "function* foo() { for (let x = yield; x < 10; x++) {yield;}yield;}",
+        "function* foo() { for (let x = yield; ; x++) { yield; }}"
     ],
     invalid: [
         { code: "for(;true;);", errors: [{ message: "Unexpected constant condition.", type: "ForStatement" }] },
diff --git a/tests/lib/rules/no-extra-parens.js b/tests/lib/rules/no-extra-parens.js
index f601e1751..d9345960e 100644
--- a/tests/lib/rules/no-extra-parens.js
+++ b/tests/lib/rules/no-extra-parens.js
@@ -92,8 +92,8 @@ ruleTester.run("no-extra-parens", rule, {
         "new A()()",
         "(new A)()",
         "(new (Foo || Bar))()",
-        { code: "(2 + 3) ** 4" },
-        { code: "2 ** (2 + 3)" },
+        "(2 + 3) ** 4",
+        "2 ** (2 + 3)",
 
         // same precedence
         "a, b, c",
@@ -125,21 +125,21 @@ ruleTester.run("no-extra-parens", rule, {
         "a(b)(c)",
         "a((b, c))",
         "new new A",
-        { code: "2 ** 3 ** 4" },
-        { code: "(2 ** 3) ** 4" },
+        "2 ** 3 ** 4",
+        "(2 ** 3) ** 4",
 
         // constructs that contain expressions
         "if(a);",
         "with(a){}",
         "switch(a){ case 0: break; }",
         "function a(){ return b; }",
-        { code: "var a = () => { return b; }" },
+        "var a = () => { return b; }",
         "throw a;",
         "while(a);",
         "do; while(a);",
         "for(;;);",
         "for(a in b);",
-        { code: "for(a of b);" },
+        "for(a of b);",
         "var a = (b, c);",
         "[]",
         "[a, b]",
@@ -149,8 +149,8 @@ ruleTester.run("no-extra-parens", rule, {
         "({});",
         "(function(){});",
         "(let[a] = b);",
-        { code: "(function*(){});" },
-        { code: "(class{});" },
+        "(function*(){});",
+        "(class{});",
 
         // special cases
         "(0).a",
@@ -165,7 +165,6 @@ ruleTester.run("no-extra-parens", rule, {
         "function a(){ return (/^a$/).test('a'); }",
 
         // IIFE is allowed to have parens in any position (#655)
-        { code: "var foo = (function() { return bar(); }())" },
         "var foo = (function() { return bar(); }())",
         "var o = { foo: (function() { return bar(); }()) };",
         "o.foo = (function(){ return bar(); }());",
@@ -178,32 +177,32 @@ ruleTester.run("no-extra-parens", rule, {
         "(function(){ return bar(); })(), (function(){ return bar(); })()",
 
         // parens are required around yield
-        { code: "var foo = (function*() { if ((yield foo()) + 1) { return; } }())" },
+        "var foo = (function*() { if ((yield foo()) + 1) { return; } }())",
 
         // arrow functions have the precedence of an assignment expression
-        { code: "(() => 0)()" },
-        { code: "(_ => 0)()" },
-        { code: "_ => 0, _ => 1" },
-        { code: "a = () => b = 0" },
-        { code: "0 ? _ => 0 : _ => 0" },
-        { code: "(_ => 0) || (_ => 0)" },
+        "(() => 0)()",
+        "(_ => 0)()",
+        "_ => 0, _ => 1",
+        "a = () => b = 0",
+        "0 ? _ => 0 : _ => 0",
+        "(_ => 0) || (_ => 0)",
 
         // Object literals as arrow function bodies need parentheses
-        { code: "x => ({foo: 1})" },
+        "x => ({foo: 1})",
 
 
         // Exponentiation operator `**`
-        { code: "1 + 2 ** 3" },
-        { code: "1 - 2 ** 3" },
-        { code: "2 ** -3" },
-        { code: "(-2) ** 3" },
-        { code: "(+2) ** 3" },
-        { code: "+ (2 ** 3)" },
+        "1 + 2 ** 3",
+        "1 - 2 ** 3",
+        "2 ** -3",
+        "(-2) ** 3",
+        "(+2) ** 3",
+        "+ (2 ** 3)",
 
         // https://github.com/eslint/eslint/issues/5789
-        { code: "a => ({b: c}[d])" },
-        { code: "a => ({b: c}.d())" },
-        { code: "a => ({b: c}.d.e)" },
+        "a => ({b: c}[d])",
+        "a => ({b: c}.d())",
+        "a => ({b: c}.d.e)",
 
         // "functions" enables reports for function nodes only
         { code: "(0)", options: ["functions"] },
@@ -251,22 +250,22 @@ ruleTester.run("no-extra-parens", rule, {
         "(function(){}.foo());",
         "(function(){}.foo.bar);",
 
-        { code: "(class{}).foo(), 1, 2;" },
-        { code: "(class{}).foo++;" },
-        { code: "(class{}).foo() || bar;" },
-        { code: "(class{}).foo() + 1;" },
-        { code: "(class{}).foo() ? bar : baz;" },
-        { code: "(class{}).foo.bar();" },
-        { code: "(class{}.foo());" },
-        { code: "(class{}.foo.bar);" },
+        "(class{}).foo(), 1, 2;",
+        "(class{}).foo++;",
+        "(class{}).foo() || bar;",
+        "(class{}).foo() + 1;",
+        "(class{}).foo() ? bar : baz;",
+        "(class{}).foo.bar();",
+        "(class{}.foo());",
+        "(class{}.foo.bar);",
 
         // https://github.com/eslint/eslint/issues/4608
-        { code: "function *a() { yield b; }" },
-        { code: "function *a() { yield yield; }" },
-        { code: "function *a() { yield b, c; }" },
-        { code: "function *a() { yield (b, c); }" },
-        { code: "function *a() { yield b + c; }" },
-        { code: "function *a() { (yield b) + c; }" },
+        "function *a() { yield b; }",
+        "function *a() { yield yield; }",
+        "function *a() { yield b, c; }",
+        "function *a() { yield (b, c); }",
+        "function *a() { yield b + c; }",
+        "function *a() { (yield b) + c; }",
 
         // https://github.com/eslint/eslint/issues/4229
         [
@@ -276,36 +275,31 @@ ruleTester.run("no-extra-parens", rule, {
             "    );",
             "}"
         ].join("\n"),
-        {
-            code: [
-                "function a() {",
-                "    return (",
-                "        <JSX />",
-                "    );",
-                "}"
-            ].join("\n")
-        },
+        [
+            "function a() {",
+            "    return (",
+            "        <JSX />",
+            "    );",
+            "}"
+        ].join("\n"),
         [
             "throw (",
             "    a",
             ");"
         ].join("\n"),
-        {
-            code: [
-                "function *a() {",
-                "    yield (",
-                "        b",
-                "    );",
-                "}"
-            ].join("\n")
-
-        },
+        [
+            "function *a() {",
+            "    yield (",
+            "        b",
+            "    );",
+            "}"
+        ].join("\n"),
 
         // async/await
-        { code: "async function a() { await (a + b) }" },
-        { code: "async function a() { await (a + await b) }" },
-        { code: "async function a() { (await a)() }" },
-        { code: "async function a() { new (await a) }" },
+        "async function a() { await (a + b) }",
+        "async function a() { await (a + await b) }",
+        "async function a() { (await a)() }",
+        "async function a() { new (await a) }",
         { code: "(foo instanceof bar) instanceof baz", options: ["all", { nestedBinaryExpressions: false }] },
         { code: "(foo in bar) in baz", options: ["all", { nestedBinaryExpressions: false }] },
         { code: "(foo + bar) + baz", options: ["all", { nestedBinaryExpressions: false }] },
@@ -316,8 +310,8 @@ ruleTester.run("no-extra-parens", rule, {
         { code: "foo && (bar && baz)", options: ["all", { nestedBinaryExpressions: false }] },
 
         // https://github.com/eslint/eslint/issues/9019
-        { code: "(async function() {});" },
-        { code: "(async function () { }());" },
+        "(async function() {});",
+        "(async function () { }());",
 
         // ["all", { ignoreJSX: "all" }]
         { code: "const Component = (<div />)", options: ["all", { ignoreJSX: "all" }] },
@@ -404,56 +398,19 @@ ruleTester.run("no-extra-parens", rule, {
         { code: "var a = b => 1 ? 2 : 3", options: ["all", { enforceForArrowConditionals: false }] },
         { code: "var a = (b) => (1 ? 2 : 3)", options: ["all", { enforceForArrowConditionals: false }] },
 
-        {
-            code: "let a = [ ...b ]"
-
-        },
-        {
-            code: "let a = { ...b }"
-        },
-        {
-            code: "let a = [ ...(b, c) ]"
-
-        },
-        {
-            code: "let a = { ...(b, c) }"
-        },
-        {
-            code: "var [x = (1, foo)] = bar"
-
-        },
-        {
-            code: "class A extends B {}"
-
-        },
-        {
-            code: "const A = class extends B {}"
-
-        },
-        {
-            code: "class A extends (B=C) {}"
-
-        },
-        {
-            code: "const A = class extends (B=C) {}"
-
-        },
-        {
-            code: "() => ({ foo: 1 })"
-
-        },
-        {
-            code: "() => ({ foo: 1 }).foo"
-
-        },
-        {
-            code: "() => ({ foo: 1 }.foo().bar).baz.qux()"
-
-        },
-        {
-            code: "() => ({ foo: 1 }.foo().bar + baz)"
-
-        },
+        "let a = [ ...b ]",
+        "let a = { ...b }",
+        "let a = [ ...(b, c) ]",
+        "let a = { ...(b, c) }",
+        "var [x = (1, foo)] = bar",
+        "class A extends B {}",
+        "const A = class extends B {}",
+        "class A extends (B=C) {}",
+        "const A = class extends (B=C) {}",
+        "() => ({ foo: 1 })",
+        "() => ({ foo: 1 }).foo",
+        "() => ({ foo: 1 }.foo().bar).baz.qux()",
+        "() => ({ foo: 1 }.foo().bar + baz)",
         {
             code: "export default (function(){}).foo",
             parserOptions: { sourceType: "module" }
diff --git a/tests/lib/rules/no-global-assign.js b/tests/lib/rules/no-global-assign.js
index 735becceb..3cd792637 100644
--- a/tests/lib/rules/no-global-assign.js
+++ b/tests/lib/rules/no-global-assign.js
@@ -23,9 +23,9 @@ ruleTester.run("no-global-assign", rule, {
         "string = 'hello world';",
         "var string;",
         { code: "Object = 0;", options: [{ exceptions: ["Object"] }] },
-        { code: "top = 0;" },
+        "top = 0;",
         { code: "onload = 0;", env: { browser: true } },
-        { code: "require = 0;" },
+        "require = 0;",
         { code: "a = 1", globals: { a: true } },
         "/*global a:true*/ a = 1"
     ],
diff --git a/tests/lib/rules/no-implicit-coercion.js b/tests/lib/rules/no-implicit-coercion.js
index cdc541b50..b5bee12fa 100644
--- a/tests/lib/rules/no-implicit-coercion.js
+++ b/tests/lib/rules/no-implicit-coercion.js
@@ -20,50 +20,50 @@ const ruleTester = new RuleTester();
 
 ruleTester.run("no-implicit-coercion", rule, {
     valid: [
-        { code: "Boolean(foo)" },
-        { code: "foo.indexOf(1) !== -1" },
-        { code: "Number(foo)" },
-        { code: "parseInt(foo)" },
-        { code: "parseFloat(foo)" },
-        { code: "String(foo)" },
-        { code: "!foo" },
-        { code: "~foo" },
-        { code: "-foo" },
-        { code: "+1234" },
-        { code: "-1234" },
-        { code: "+Number(lol)" },
-        { code: "-parseFloat(lol)" },
-        { code: "2 * foo" },
-        { code: "1 * 1234" },
-        { code: "1 * Number(foo)" },
-        { code: "1 * parseInt(foo)" },
-        { code: "1 * parseFloat(foo)" },
-        { code: "Number(foo) * 1" },
-        { code: "parseInt(foo) * 1" },
-        { code: "parseFloat(foo) * 1" },
-        { code: "1 * 1234 * 678 * Number(foo)" },
-        { code: "1 * 1234 * 678 * parseInt(foo)" },
-        { code: "1234 * 1 * 678 * Number(foo)" },
-        { code: "1234 * 1 * Number(foo) * Number(bar)" },
-        { code: "1234 * 1 * Number(foo) * parseInt(bar)" },
-        { code: "1234 * 1 * Number(foo) * parseFloat(bar)" },
-        { code: "1234 * 1 * parseInt(foo) * parseFloat(bar)" },
-        { code: "1234 * 1 * parseInt(foo) * Number(bar)" },
-        { code: "1234 * 1 * parseFloat(foo) * Number(bar)" },
-        { code: "1234 * Number(foo) * 1 * Number(bar)" },
-        { code: "1234 * parseInt(foo) * 1 * Number(bar)" },
-        { code: "1234 * parseFloat(foo) * 1 * parseInt(bar)" },
-        { code: "1234 * parseFloat(foo) * 1 * Number(bar)" },
-        { code: "1234*foo*1" },
-        { code: "1234*1*foo" },
-        { code: "1234*bar*1*foo" },
-        { code: "1234*1*foo*bar" },
-        { code: "1234*1*foo*Number(bar)" },
-        { code: "1234*1*Number(foo)*bar" },
-        { code: "1234*1*parseInt(foo)*bar" },
-        { code: "0 + foo" },
-        { code: "~foo.bar()" },
-        { code: "foo + 'bar'" },
+        "Boolean(foo)",
+        "foo.indexOf(1) !== -1",
+        "Number(foo)",
+        "parseInt(foo)",
+        "parseFloat(foo)",
+        "String(foo)",
+        "!foo",
+        "~foo",
+        "-foo",
+        "+1234",
+        "-1234",
+        "+Number(lol)",
+        "-parseFloat(lol)",
+        "2 * foo",
+        "1 * 1234",
+        "1 * Number(foo)",
+        "1 * parseInt(foo)",
+        "1 * parseFloat(foo)",
+        "Number(foo) * 1",
+        "parseInt(foo) * 1",
+        "parseFloat(foo) * 1",
+        "1 * 1234 * 678 * Number(foo)",
+        "1 * 1234 * 678 * parseInt(foo)",
+        "1234 * 1 * 678 * Number(foo)",
+        "1234 * 1 * Number(foo) * Number(bar)",
+        "1234 * 1 * Number(foo) * parseInt(bar)",
+        "1234 * 1 * Number(foo) * parseFloat(bar)",
+        "1234 * 1 * parseInt(foo) * parseFloat(bar)",
+        "1234 * 1 * parseInt(foo) * Number(bar)",
+        "1234 * 1 * parseFloat(foo) * Number(bar)",
+        "1234 * Number(foo) * 1 * Number(bar)",
+        "1234 * parseInt(foo) * 1 * Number(bar)",
+        "1234 * parseFloat(foo) * 1 * parseInt(bar)",
+        "1234 * parseFloat(foo) * 1 * Number(bar)",
+        "1234*foo*1",
+        "1234*1*foo",
+        "1234*bar*1*foo",
+        "1234*1*foo*bar",
+        "1234*1*foo*Number(bar)",
+        "1234*1*Number(foo)*bar",
+        "1234*1*parseInt(foo)*bar",
+        "0 + foo",
+        "~foo.bar()",
+        "foo + 'bar'",
         { code: "foo + `${bar}`", parserOptions: { ecmaVersion: 6 } },
 
         { code: "!!foo", options: [{ boolean: false }] },
@@ -80,15 +80,15 @@ ruleTester.run("no-implicit-coercion", rule, {
         { code: "var a = \"\" + foo", options: [{ boolean: true, string: true, allow: ["+"] }] },
 
         // https://github.com/eslint/eslint/issues/7057
-        { code: "'' + 'foo'" },
+        "'' + 'foo'",
         { code: "`` + 'foo'", parserOptions: { ecmaVersion: 6 } },
         { code: "'' + `${foo}`", parserOptions: { ecmaVersion: 6 } },
-        { code: "'foo' + ''" },
+        "'foo' + ''",
         { code: "'foo' + ``", parserOptions: { ecmaVersion: 6 } },
         { code: "`${foo}` + ''", parserOptions: { ecmaVersion: 6 } },
-        { code: "foo += 'bar'" },
+        "foo += 'bar'",
         { code: "foo += `${bar}`", parserOptions: { ecmaVersion: 6 } },
-        { code: "+42" }
+        "+42"
     ],
     invalid: [
         {
diff --git a/tests/lib/rules/no-implicit-globals.js b/tests/lib/rules/no-implicit-globals.js
index 21fc50cb8..7798d2f4a 100644
--- a/tests/lib/rules/no-implicit-globals.js
+++ b/tests/lib/rules/no-implicit-globals.js
@@ -40,40 +40,20 @@ ruleTester.run("no-implicit-globals", rule, {
             code: "class Foo {}",
             parserOptions: { ecmaVersion: 6 }
         },
-        {
-            code: "window.foo = 1;"
-        },
-        {
-            code: "window.foo = function() {};"
-        },
-        {
-            code: "window.foo = function foo() {};"
-        },
+        "window.foo = 1;",
+        "window.foo = function() {};",
+        "window.foo = function foo() {};",
         {
             code: "window.foo = function*() {};",
             parserOptions: { ecmaVersion: 6 }
         },
-        {
-            code: "self.foo = 1;"
-        },
-        {
-            code: "self.foo = function() {};"
-        },
-        {
-            code: "this.foo = 1;"
-        },
-        {
-            code: "this.foo = function() {};"
-        },
-        {
-            code: "Utils.foo = 1;"
-        },
-        {
-            code: "Utils.foo = function() {};"
-        },
-        {
-            code: "(function() { var foo = 1; })();"
-        },
+        "self.foo = 1;",
+        "self.foo = function() {};",
+        "this.foo = 1;",
+        "this.foo = function() {};",
+        "Utils.foo = 1;",
+        "Utils.foo = function() {};",
+        "(function() { var foo = 1; })();",
         {
             code: "(function() { let foo = 1; })();",
             parserOptions: { ecmaVersion: 6 }
@@ -82,9 +62,7 @@ ruleTester.run("no-implicit-globals", rule, {
             code: "(function() { const foo = 1; })();",
             parserOptions: { ecmaVersion: 6 }
         },
-        {
-            code: "(function() { function foo() {} })();"
-        },
+        "(function() { function foo() {} })();",
         {
             code: "(function() { function *foo() {} })();",
             parserOptions: { ecmaVersion: 6 }
@@ -125,15 +103,9 @@ ruleTester.run("no-implicit-globals", rule, {
             code: "function foo() {}",
             parserOptions: { ecmaFeatures: { globalReturn: true } }
         },
-        {
-            code: "/*global foo:true*/ var foo = 1;"
-        },
-        {
-            code: "/*global foo:true*/ foo = 1;"
-        },
-        {
-            code: "/*global foo:true*/ function foo() {}"
-        }
+        "/*global foo:true*/ var foo = 1;",
+        "/*global foo:true*/ foo = 1;",
+        "/*global foo:true*/ function foo() {}"
     ],
 
     invalid: [
diff --git a/tests/lib/rules/no-inline-comments.js b/tests/lib/rules/no-inline-comments.js
index 656b9d9ce..d84c42824 100644
--- a/tests/lib/rules/no-inline-comments.js
+++ b/tests/lib/rules/no-inline-comments.js
@@ -28,21 +28,11 @@ const ruleTester = new RuleTester(),
 ruleTester.run("no-inline-comments", rule, {
 
     valid: [
-        {
-            code: "// A valid comment before code\nvar a = 1;"
-        },
-        {
-            code: "var a = 2;\n// A valid comment after code"
-        },
-        {
-            code: "// A solitary comment"
-        },
-        {
-            code: "var a = 1; // eslint-disable-line some-rule"
-        },
-        {
-            code: "var a = 1; /* eslint-disable-line some-rule */"
-        }
+        "// A valid comment before code\nvar a = 1;",
+        "var a = 2;\n// A valid comment after code",
+        "// A solitary comment",
+        "var a = 1; // eslint-disable-line some-rule",
+        "var a = 1; /* eslint-disable-line some-rule */"
     ],
 
     invalid: [
diff --git a/tests/lib/rules/no-loop-func.js b/tests/lib/rules/no-loop-func.js
index dcb640d31..08ccd1c5d 100644
--- a/tests/lib/rules/no-loop-func.js
+++ b/tests/lib/rules/no-loop-func.js
@@ -31,12 +31,8 @@ ruleTester.run("no-loop-func", rule, {
         },
 
         // no refers to variables that declared on upper scope.
-        {
-            code: "for (var i=0; i<l; i++) { (function() {}) }"
-        },
-        {
-            code: "for (var i in {}) { (function() {}) }"
-        },
+        "for (var i=0; i<l; i++) { (function() {}) }",
+        "for (var i in {}) { (function() {}) }",
         {
             code: "for (var i of {}) { (function() {}) }",
             parserOptions: { ecmaVersion: 6 }
diff --git a/tests/lib/rules/no-magic-numbers.js b/tests/lib/rules/no-magic-numbers.js
index f93c7176f..f6c4f0e01 100644
--- a/tests/lib/rules/no-magic-numbers.js
+++ b/tests/lib/rules/no-magic-numbers.js
@@ -20,15 +20,9 @@ const ruleTester = new RuleTester();
 
 ruleTester.run("no-magic-numbers", rule, {
     valid: [
-        {
-            code: "var x = parseInt(y, 10);"
-        },
-        {
-            code: "var x = parseInt(y, -10);"
-        },
-        {
-            code: "var x = Number.parseInt(y, 10);"
-        },
+        "var x = parseInt(y, 10);",
+        "var x = parseInt(y, -10);",
+        "var x = Number.parseInt(y, 10);",
         {
             code: "const foo = 42;",
             env: { es6: true }
@@ -40,9 +34,7 @@ ruleTester.run("no-magic-numbers", rule, {
             }],
             env: { es6: true }
         },
-        {
-            code: "var foo = -42;"
-        },
+        "var foo = -42;",
         {
             code: "var foo = 0 + 1 - 2 + -2;",
             options: [{
@@ -55,9 +47,7 @@ ruleTester.run("no-magic-numbers", rule, {
                 ignore: [0, 1, 2, 3, 4]
             }]
         },
-        {
-            code: "var foo = { bar:10 }"
-        },
+        "var foo = { bar:10 }",
         {
             code: "setTimeout(function() {return 1;}, 0);",
             options: [{
diff --git a/tests/lib/rules/no-mixed-spaces-and-tabs.js b/tests/lib/rules/no-mixed-spaces-and-tabs.js
index 717b2cc5a..f427a6f1c 100644
--- a/tests/lib/rules/no-mixed-spaces-and-tabs.js
+++ b/tests/lib/rules/no-mixed-spaces-and-tabs.js
@@ -20,21 +20,11 @@ const ruleTester = new RuleTester();
 ruleTester.run("no-mixed-spaces-and-tabs", rule, {
 
     valid: [
-        {
-            code: "\tvar x = 5;"
-        },
-        {
-            code: "    var x = 5;"
-        },
-        {
-            code: "\t/*\n\t * Hello\n\t */"
-        },
-        {
-            code: "// foo\n\t/**\n\t * Hello\n\t */"
-        },
-        {
-            code: "/*\n\n \t \n*/"
-        },
+        "\tvar x = 5;",
+        "    var x = 5;",
+        "\t/*\n\t * Hello\n\t */",
+        "// foo\n\t/**\n\t * Hello\n\t */",
+        "/*\n\n \t \n*/",
         {
             code: "\tvar x = 5,\n\t    y = 2;",
             options: [true]
diff --git a/tests/lib/rules/no-multi-assign.js b/tests/lib/rules/no-multi-assign.js
index c75a58682..9a726600a 100644
--- a/tests/lib/rules/no-multi-assign.js
+++ b/tests/lib/rules/no-multi-assign.js
@@ -42,12 +42,12 @@ const ruleTester = new RuleTester();
 
 ruleTester.run("no-mutli-assign", rule, {
     valid: [
-        { code: "var a, b, c,\nd = 0;" },
-        { code: "var a = 1; var b = 2; var c = 3;\nvar d = 0;" },
-        { code: "var a = 1 + (b === 10 ? 5 : 4);" },
+        "var a, b, c,\nd = 0;",
+        "var a = 1; var b = 2; var c = 3;\nvar d = 0;",
+        "var a = 1 + (b === 10 ? 5 : 4);",
         { code: "const a = 1, b = 2, c = 3;", parserOptions: { ecmaVersion: 6 } },
         { code: "const a = 1;\nconst b = 2;\n const c = 3;", parserOptions: { ecmaVersion: 6 } },
-        { code: "for(var a = 0, b = 0;;){}" },
+        "for(var a = 0, b = 0;;){}",
         { code: "for(let a = 0, b = 0;;){}", parserOptions: { ecmaVersion: 6 } },
         { code: "for(const a = 0, b = 0;;){}", parserOptions: { ecmaVersion: 6 } },
         { code: "export let a, b;", parserOptions: { sourceType: "module" } },
diff --git a/tests/lib/rules/no-native-reassign.js b/tests/lib/rules/no-native-reassign.js
index 464363ee4..ce6f4756f 100644
--- a/tests/lib/rules/no-native-reassign.js
+++ b/tests/lib/rules/no-native-reassign.js
@@ -24,9 +24,9 @@ ruleTester.run("no-native-reassign", rule, {
         "string = 'hello world';",
         "var string;",
         { code: "Object = 0;", options: [{ exceptions: ["Object"] }] },
-        { code: "top = 0;" },
+        "top = 0;",
         { code: "onload = 0;", env: { browser: true } },
-        { code: "require = 0;" },
+        "require = 0;",
         { code: "a = 1", globals: { a: true } },
         "/*global a:true*/ a = 1"
     ],
diff --git a/tests/lib/rules/no-param-reassign.js b/tests/lib/rules/no-param-reassign.js
index dad4576ac..f894e1142 100644
--- a/tests/lib/rules/no-param-reassign.js
+++ b/tests/lib/rules/no-param-reassign.js
@@ -23,7 +23,7 @@ ruleTester.run("no-param-reassign", rule, {
         "function foo(a) { var b = a; }",
         "function foo(a) { a.prop = 'value'; }",
         "function foo(a) { (function() { var a = 12; a++; })(); }",
-        { code: "function foo() { someGlobal = 13; }" },
+        "function foo() { someGlobal = 13; }",
         { code: "function foo() { someGlobal = 13; }", globals: { someGlobal: false } },
         "function foo(a) { a.b = 0; }",
         "function foo(a) { delete a.b; }",
diff --git a/tests/lib/rules/no-redeclare.js b/tests/lib/rules/no-redeclare.js
index 7fc820a53..3d67961ed 100644
--- a/tests/lib/rules/no-redeclare.js
+++ b/tests/lib/rules/no-redeclare.js
@@ -28,7 +28,7 @@ ruleTester.run("no-redeclare", rule, {
                 ecmaVersion: 6
             }
         },
-        { code: "var Object = 0;" },
+        "var Object = 0;",
         { code: "var Object = 0;", options: [{ builtinGlobals: false }] },
         { code: "var Object = 0;", options: [{ builtinGlobals: true }], parserOptions: { sourceType: "module" } },
         { code: "var Object = 0;", options: [{ builtinGlobals: true }], parserOptions: { ecmaFeatures: { globalReturn: true } } },
diff --git a/tests/lib/rules/no-restricted-globals.js b/tests/lib/rules/no-restricted-globals.js
index b094a05dd..a7ce1166a 100644
--- a/tests/lib/rules/no-restricted-globals.js
+++ b/tests/lib/rules/no-restricted-globals.js
@@ -20,9 +20,7 @@ const ruleTester = new RuleTester();
 
 ruleTester.run("no-restricted-globals", rule, {
     valid: [
-        {
-            code: "foo"
-        },
+        "foo",
         {
             code: "foo",
             options: ["bar"]
diff --git a/tests/lib/rules/no-restricted-modules.js b/tests/lib/rules/no-restricted-modules.js
index 86ee56d96..26fa3e922 100644
--- a/tests/lib/rules/no-restricted-modules.js
+++ b/tests/lib/rules/no-restricted-modules.js
@@ -22,7 +22,7 @@ ruleTester.run("no-restricted-modules", rule, {
     valid: [
         { code: "require(\"fs\")", options: ["crypto"] },
         { code: "require(\"path\")", options: ["crypto", "stream", "os"] },
-        { code: "require(\"fs \")" },
+        "require(\"fs \")",
         { code: "require(2)", options: ["crypto"] },
         { code: "require(foo)", options: ["crypto"] },
         { code: "var foo = bar('crypto');", options: ["crypto"] },
diff --git a/tests/lib/rules/no-restricted-syntax.js b/tests/lib/rules/no-restricted-syntax.js
index 38ee72d76..96c5c4bf5 100644
--- a/tests/lib/rules/no-restricted-syntax.js
+++ b/tests/lib/rules/no-restricted-syntax.js
@@ -21,7 +21,7 @@ ruleTester.run("no-restricted-syntax", rule, {
     valid: [
 
         // string format
-        { code: "doSomething();" },
+        "doSomething();",
         { code: "var foo = 42;", options: ["ConditionalExpression"] },
         { code: "foo += 42;", options: ["VariableDeclaration", "FunctionExpression"] },
         { code: "foo;", options: ["Identifier[name=\"bar\"]"] },
diff --git a/tests/lib/rules/no-self-assign.js b/tests/lib/rules/no-self-assign.js
index e4b14fdb8..76bd8b4c9 100644
--- a/tests/lib/rules/no-self-assign.js
+++ b/tests/lib/rules/no-self-assign.js
@@ -47,11 +47,11 @@ ruleTester.run("no-self-assign", rule, {
         { code: "a.b().c = a.b().c", options: [{ props: true }] },
         { code: "b().c = b().c", options: [{ props: true }] },
         { code: "a[b + 1] = a[b + 1]", options: [{ props: true }] }, // it ignores non-simple computed properties.
-        { code: "a.b = a.b" },
-        { code: "a.b.c = a.b.c" },
-        { code: "a[b] = a[b]" },
-        { code: "a['b'] = a['b']" },
-        { code: "a[\n    'b'\n] = a[\n    'b'\n]" }
+        "a.b = a.b",
+        "a.b.c = a.b.c",
+        "a[b] = a[b]",
+        "a['b'] = a['b']",
+        "a[\n    'b'\n] = a[\n    'b'\n]"
     ],
     invalid: [
         { code: "a = a", errors: ["'a' is assigned to itself."] },
diff --git a/tests/lib/rules/no-shadow.js b/tests/lib/rules/no-shadow.js
index 28499bcd3..071eadd15 100644
--- a/tests/lib/rules/no-shadow.js
+++ b/tests/lib/rules/no-shadow.js
@@ -53,7 +53,7 @@ ruleTester.run("no-shadow", rule, {
         { code: "function foo() { var a; } var a;", parserOptions: { ecmaVersion: 6 } },
         { code: "function foo(a) { } let a;", parserOptions: { ecmaVersion: 6 } },
         { code: "function foo(a) { } var a;", parserOptions: { ecmaVersion: 6 } },
-        { code: "function foo() { var Object = 0; }" },
+        "function foo() { var Object = 0; }",
         { code: "function foo() { var top = 0; }", env: { browser: true } },
         { code: "var Object = 0;", options: [{ builtinGlobals: true }] },
         { code: "var top = 0;", options: [{ builtinGlobals: true }], env: { browser: true } },
diff --git a/tests/lib/rules/no-this-before-super.js b/tests/lib/rules/no-this-before-super.js
index c1dc55bc9..67964bd14 100644
--- a/tests/lib/rules/no-this-before-super.js
+++ b/tests/lib/rules/no-this-before-super.js
@@ -65,17 +65,15 @@ ruleTester.run("no-this-before-super", rule, {
         "class A extends B { constructor(a) { super(); this.a = a && function(){} && this.foo; } }",
 
         // https://github.com/eslint/eslint/issues/5394
-        {
-            code: [
-                "class A extends Object {",
-                "    constructor() {",
-                "        super();",
-                "        for (let i = 0; i < 0; i++);",
-                "        this;",
-                "    }",
-                "}"
-            ].join("\n")
-        },
+        [
+            "class A extends Object {",
+            "    constructor() {",
+            "        super();",
+            "        for (let i = 0; i < 0; i++);",
+            "        this;",
+            "    }",
+            "}"
+        ].join("\n"),
 
         // https://github.com/eslint/eslint/issues/5894
         "class A { constructor() { return; this; } }",
diff --git a/tests/lib/rules/no-trailing-spaces.js b/tests/lib/rules/no-trailing-spaces.js
index e34d1c6c0..d33af0c25 100644
--- a/tests/lib/rules/no-trailing-spaces.js
+++ b/tests/lib/rules/no-trailing-spaces.js
@@ -28,12 +28,8 @@ ruleTester.run("no-trailing-spaces", rule, {
             code: "var a = 5,\n    b = 3;",
             options: [{}]
         },
-        {
-            code: "var a = 5;"
-        },
-        {
-            code: "var a = 5,\n    b = 3;"
-        },
+        "var a = 5;",
+        "var a = 5,\n    b = 3;",
         {
             code: "var a = 5,\n    b = 3;",
             options: [{ skipBlankLines: true }]
diff --git a/tests/lib/rules/no-undef.js b/tests/lib/rules/no-undef.js
index d02c94bee..150e7ecbc 100644
--- a/tests/lib/rules/no-undef.js
+++ b/tests/lib/rules/no-undef.js
@@ -61,12 +61,12 @@ ruleTester.run("no-undef", rule, {
         { code: "PromiseRejectionEvent;", env: { browser: true } },
 
         // Notifications of readonly are removed: https://github.com/eslint/eslint/issues/4504
-        { code: "/*global b:false*/ function f() { b = 1; }" },
+        "/*global b:false*/ function f() { b = 1; }",
         { code: "function f() { b = 1; }", globals: { b: false } },
-        { code: "/*global b:false*/ function f() { b++; }" },
-        { code: "/*global b*/ b = 1;" },
-        { code: "/*global b:false*/ var b = 1;" },
-        { code: "Array = 1;" },
+        "/*global b:false*/ function f() { b++; }",
+        "/*global b*/ b = 1;",
+        "/*global b:false*/ var b = 1;",
+        "Array = 1;",
 
         // new.target: https://github.com/eslint/eslint/issues/5420
         { code: "class A { constructor() { new.target; } }", parserOptions: { ecmaVersion: 6 } },
diff --git a/tests/lib/rules/no-unused-vars.js b/tests/lib/rules/no-unused-vars.js
index 7ad7038f9..4e2849fe1 100644
--- a/tests/lib/rules/no-unused-vars.js
+++ b/tests/lib/rules/no-unused-vars.js
@@ -144,15 +144,15 @@ ruleTester.run("no-unused-vars", rule, {
         { code: "var x = 1; function foo(y = function() { bar(x); }) { y(); } foo();", parserOptions: { ecmaVersion: 6 } },
 
         // exported variables should work
-        { code: "/*exported toaster*/ var toaster = 'great'" },
-        { code: "/*exported toaster, poster*/ var toaster = 1; poster = 0;" },
+        "/*exported toaster*/ var toaster = 'great'",
+        "/*exported toaster, poster*/ var toaster = 1; poster = 0;",
         { code: "/*exported x*/ var { x } = y", parserOptions: { ecmaVersion: 6 } },
         { code: "/*exported x, y*/  var { x, y } = z", parserOptions: { ecmaVersion: 6 } },
 
         // Can mark variables as used via context.markVariableAsUsed()
-        { code: "/*eslint use-every-a:1*/ var a;" },
-        { code: "/*eslint use-every-a:1*/ !function(a) { return 1; }" },
-        { code: "/*eslint use-every-a:1*/ !function() { var a; return 1 }" },
+        "/*eslint use-every-a:1*/ var a;",
+        "/*eslint use-every-a:1*/ !function(a) { return 1; }",
+        "/*eslint use-every-a:1*/ !function() { var a; return 1 }",
 
         // ignore pattern
         { code: "var _a;", options: [{ vars: "all", varsIgnorePattern: "^_" }] },
@@ -202,59 +202,51 @@ ruleTester.run("no-unused-vars", rule, {
         }),
 
         // https://github.com/eslint/eslint/issues/6348
-        { code: "var a = 0, b; b = a = a + 1; foo(b);" },
-        { code: "var a = 0, b; b = a += a + 1; foo(b);" },
-        { code: "var a = 0, b; b = a++; foo(b);" },
-        { code: "function foo(a) { var b = a = a + 1; bar(b) } foo();" },
-        { code: "function foo(a) { var b = a += a + 1; bar(b) } foo();" },
-        { code: "function foo(a) { var b = a++; bar(b) } foo();" },
+        "var a = 0, b; b = a = a + 1; foo(b);",
+        "var a = 0, b; b = a += a + 1; foo(b);",
+        "var a = 0, b; b = a++; foo(b);",
+        "function foo(a) { var b = a = a + 1; bar(b) } foo();",
+        "function foo(a) { var b = a += a + 1; bar(b) } foo();",
+        "function foo(a) { var b = a++; bar(b) } foo();",
 
         // https://github.com/eslint/eslint/issues/6576
-        {
-            code: [
-                "var unregisterFooWatcher;",
-                "// ...",
-                "unregisterFooWatcher = $scope.$watch( \"foo\", function() {",
-                "    // ...some code..",
-                "    unregisterFooWatcher();",
-                "});"
-            ].join("\n")
-        },
-        {
-            code: [
-                "var ref;",
-                "ref = setInterval(",
-                "    function(){",
-                "        clearInterval(ref);",
-                "    }, 10);"
-            ].join("\n")
-        },
-        {
-            code: [
-                "var _timer;",
-                "function f() {",
-                "    _timer = setTimeout(function () {}, _timer ? 100 : 0);",
-                "}",
-                "f();"
-            ].join("\n")
-        },
-        { code: "function foo(cb) { cb = function() { function something(a) { cb(1 + a); } register(something); }(); } foo();" },
+        [
+            "var unregisterFooWatcher;",
+            "// ...",
+            "unregisterFooWatcher = $scope.$watch( \"foo\", function() {",
+            "    // ...some code..",
+            "    unregisterFooWatcher();",
+            "});"
+        ].join("\n"),
+        [
+            "var ref;",
+            "ref = setInterval(",
+            "    function(){",
+            "        clearInterval(ref);",
+            "    }, 10);"
+        ].join("\n"),
+        [
+            "var _timer;",
+            "function f() {",
+            "    _timer = setTimeout(function () {}, _timer ? 100 : 0);",
+            "}",
+            "f();"
+        ].join("\n"),
+        "function foo(cb) { cb = function() { function something(a) { cb(1 + a); } register(something); }(); } foo();",
         { code: "function* foo(cb) { cb = yield function(a) { cb(1 + a); }; } foo();", parserOptions: { ecmaVersion: 6 } },
         { code: "function foo(cb) { cb = tag`hello${function(a) { cb(1 + a); }}`; } foo();", parserOptions: { ecmaVersion: 6 } },
-        { code: "function foo(cb) { var b; cb = b = function(a) { cb(1 + a); }; b(); } foo();" },
+        "function foo(cb) { var b; cb = b = function(a) { cb(1 + a); }; b(); } foo();",
 
         // https://github.com/eslint/eslint/issues/6646
-        {
-            code: [
-                "function someFunction() {",
-                "    var a = 0, i;",
-                "    for (i = 0; i < 2; i++) {",
-                "        a = myFunction(a);",
-                "    }",
-                "}",
-                "someFunction();"
-            ].join("\n")
-        },
+        [
+            "function someFunction() {",
+            "    var a = 0, i;",
+            "    for (i = 0; i < 2; i++) {",
+            "        a = myFunction(a);",
+            "    }",
+            "}",
+            "someFunction();"
+        ].join("\n"),
 
         // https://github.com/eslint/eslint/issues/7124
         {
diff --git a/tests/lib/rules/no-use-before-define.js b/tests/lib/rules/no-use-before-define.js
index 1ccee8164..f7f9382bb 100644
--- a/tests/lib/rules/no-use-before-define.js
+++ b/tests/lib/rules/no-use-before-define.js
@@ -26,14 +26,14 @@ ruleTester.run("no-use-before-define", rule, {
         "function a() { alert(arguments);}",
         { code: "a(); function a() { alert(arguments); }", options: ["nofunc"] },
         { code: "(() => { var a = 42; alert(a); })();", parserOptions: { ecmaVersion: 6 } },
-        { code: "a(); try { throw new Error() } catch (a) {}" },
+        "a(); try { throw new Error() } catch (a) {}",
         { code: "class A {} new A();", parserOptions: { ecmaVersion: 6 } },
         "var a = 0, b = a;",
         { code: "var {a = 0, b = a} = {};", parserOptions: { ecmaVersion: 6 } },
         { code: "var [a = 0, b = a] = {};", parserOptions: { ecmaVersion: 6 } },
         "function foo() { foo(); }",
         "var foo = function() { foo(); };",
-        { code: "var a; for (a in a) {}" },
+        "var a; for (a in a) {}",
         { code: "var a; for (a of a) {}", parserOptions: { ecmaVersion: 6 } },
 
         // Block-level bindings
diff --git a/tests/lib/rules/no-useless-call.js b/tests/lib/rules/no-useless-call.js
index 204aa457f..15bdc88f2 100644
--- a/tests/lib/rules/no-useless-call.js
+++ b/tests/lib/rules/no-useless-call.js
@@ -22,29 +22,29 @@ ruleTester.run("no-useless-call", rule, {
     valid: [
 
         // `this` binding is different.
-        { code: "foo.apply(obj, 1, 2);" },
-        { code: "obj.foo.apply(null, 1, 2);" },
-        { code: "obj.foo.apply(otherObj, 1, 2);" },
-        { code: "a.b(x, y).c.foo.apply(a.b(x, z).c, 1, 2);" },
-        { code: "foo.apply(obj, [1, 2]);" },
-        { code: "obj.foo.apply(null, [1, 2]);" },
-        { code: "obj.foo.apply(otherObj, [1, 2]);" },
-        { code: "a.b(x, y).c.foo.apply(a.b(x, z).c, [1, 2]);" },
-        { code: "a.b.foo.apply(a.b.c, [1, 2]);" },
+        "foo.apply(obj, 1, 2);",
+        "obj.foo.apply(null, 1, 2);",
+        "obj.foo.apply(otherObj, 1, 2);",
+        "a.b(x, y).c.foo.apply(a.b(x, z).c, 1, 2);",
+        "foo.apply(obj, [1, 2]);",
+        "obj.foo.apply(null, [1, 2]);",
+        "obj.foo.apply(otherObj, [1, 2]);",
+        "a.b(x, y).c.foo.apply(a.b(x, z).c, [1, 2]);",
+        "a.b.foo.apply(a.b.c, [1, 2]);",
 
         // ignores variadic.
-        { code: "foo.apply(null, args);" },
-        { code: "obj.foo.apply(obj, args);" },
+        "foo.apply(null, args);",
+        "obj.foo.apply(obj, args);",
 
         // ignores computed property.
-        { code: "var call; foo[call](null, 1, 2);" },
-        { code: "var apply; foo[apply](null, [1, 2]);" },
+        "var call; foo[call](null, 1, 2);",
+        "var apply; foo[apply](null, [1, 2]);",
 
         // ignores incomplete things.
-        { code: "foo.call();" },
-        { code: "obj.foo.call();" },
-        { code: "foo.apply();" },
-        { code: "obj.foo.apply();" }
+        "foo.call();",
+        "obj.foo.call();",
+        "foo.apply();",
+        "obj.foo.apply();"
     ],
     invalid: [
 
diff --git a/tests/lib/rules/no-useless-concat.js b/tests/lib/rules/no-useless-concat.js
index 45e01ec5a..4f96ec3f0 100644
--- a/tests/lib/rules/no-useless-concat.js
+++ b/tests/lib/rules/no-useless-concat.js
@@ -22,17 +22,17 @@ const ruleTester = new RuleTester();
 ruleTester.run("no-useless-concat", rule, {
 
     valid: [
-        { code: "var a = 1 + 1;" },
-        { code: "var a = 1 * '2';" },
-        { code: "var a = 1 - 2;" },
-        { code: "var a = foo + bar;" },
-        { code: "var a = 'foo' + bar;" },
-        { code: "var foo = 'foo' +\n 'bar';" },
+        "var a = 1 + 1;",
+        "var a = 1 * '2';",
+        "var a = 1 - 2;",
+        "var a = foo + bar;",
+        "var a = 'foo' + bar;",
+        "var foo = 'foo' +\n 'bar';",
 
         // https://github.com/eslint/eslint/issues/3575
-        { code: "var string = (number + 1) + 'px';" },
-        { code: "'a' + 1" },
-        { code: "1 + '1'" },
+        "var string = (number + 1) + 'px';",
+        "'a' + 1",
+        "1 + '1'",
         { code: "1 + `1`", parserOptions: { ecmaVersion: 6 } },
         { code: "`1` + 1", parserOptions: { ecmaVersion: 6 } },
         { code: "(1 + +2) + `b`", parserOptions: { ecmaVersion: 6 } }
diff --git a/tests/lib/rules/no-warning-comments.js b/tests/lib/rules/no-warning-comments.js
index fd9f0ceff..ba9f654e1 100644
--- a/tests/lib/rules/no-warning-comments.js
+++ b/tests/lib/rules/no-warning-comments.js
@@ -22,20 +22,20 @@ ruleTester.run("no-warning-comments", rule, {
     valid: [
         { code: "// any comment", options: [{ terms: ["fixme"] }] },
         { code: "// any comment", options: [{ terms: ["fixme", "todo"] }] },
-        { code: "// any comment" },
+        "// any comment",
         { code: "// any comment", options: [{ location: "anywhere" }] },
         { code: "// any comment with TODO, FIXME or XXX", options: [{ location: "start" }] },
-        { code: "// any comment with TODO, FIXME or XXX" },
+        "// any comment with TODO, FIXME or XXX",
         { code: "/* any block comment */", options: [{ terms: ["fixme"] }] },
         { code: "/* any block comment */", options: [{ terms: ["fixme", "todo"] }] },
-        { code: "/* any block comment */" },
+        "/* any block comment */",
         { code: "/* any block comment */", options: [{ location: "anywhere" }] },
         { code: "/* any block comment with TODO, FIXME or XXX */", options: [{ location: "start" }] },
-        { code: "/* any block comment with TODO, FIXME or XXX */" },
-        { code: "/* any block comment with (TODO, FIXME's or XXX!) */" },
+        "/* any block comment with TODO, FIXME or XXX */",
+        "/* any block comment with (TODO, FIXME's or XXX!) */",
         { code: "// comments containing terms as substrings like TodoMVC", options: [{ terms: ["todo"], location: "anywhere" }] },
         { code: "// special regex characters don't cause problems", options: [{ terms: ["[aeiou]"], location: "anywhere" }] },
-        { code: "/*eslint no-warning-comments: [2, { \"terms\": [\"todo\", \"fixme\", \"any other term\"], \"location\": \"anywhere\" }]*/\n\nvar x = 10;\n" },
+        "/*eslint no-warning-comments: [2, { \"terms\": [\"todo\", \"fixme\", \"any other term\"], \"location\": \"anywhere\" }]*/\n\nvar x = 10;\n",
         { code: "/*eslint no-warning-comments: [2, { \"terms\": [\"todo\", \"fixme\", \"any other term\"], \"location\": \"anywhere\" }]*/\n\nvar x = 10;\n", options: [{ location: "anywhere" }] }
     ],
     invalid: [
diff --git a/tests/lib/rules/object-property-newline.js b/tests/lib/rules/object-property-newline.js
index 426bf4698..dea82a26a 100644
--- a/tests/lib/rules/object-property-newline.js
+++ b/tests/lib/rules/object-property-newline.js
@@ -23,17 +23,17 @@ ruleTester.run("object-property-newline", rule, {
     valid: [
 
         // default-case
-        { code: "var obj = {\nk1: 'val1',\nk2: 'val2',\nk3: 'val3',\nk4: 'val4'\n};" },
-        { code: "var obj = { k1: 'val1',\nk2: 'val2',\nk3: 'val3',\nk4: 'val4' };" },
-        { code: "var obj = { k1: 'val1' };" },
-        { code: "var obj = {\nk1: 'val1'\n};" },
-        { code: "var obj = {};" },
+        "var obj = {\nk1: 'val1',\nk2: 'val2',\nk3: 'val3',\nk4: 'val4'\n};",
+        "var obj = { k1: 'val1',\nk2: 'val2',\nk3: 'val3',\nk4: 'val4' };",
+        "var obj = { k1: 'val1' };",
+        "var obj = {\nk1: 'val1'\n};",
+        "var obj = {};",
         { code: "var obj = {\n[bar]: 'baz',\nbaz\n};", parserOptions: { ecmaVersion: 6 } },
         { code: "var obj = {\nk1: 'val1',\nk2: 'val2',\n...{}\n};", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "var obj = { k1: 'val1',\nk2: 'val2',\n...{} };", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
         { code: "var obj = { ...{} };", parserOptions: { ecmaVersion: 6, ecmaFeatures: { experimentalObjectRestSpread: true } } },
-        { code: "foo({ k1: 'val1',\nk2: 'val2' });" },
-        { code: "foo({\nk1: 'val1',\nk2: 'val2'\n});" },
+        "foo({ k1: 'val1',\nk2: 'val2' });",
+        "foo({\nk1: 'val1',\nk2: 'val2'\n});",
         { code: "foo({\na,\nb\n});", parserOptions: { ecmaVersion: 6 } },
         { code: "foo({\na,\nb,\n});", parserOptions: { ecmaVersion: 6 } },
         { code: "foo({\nbar() {},\nbaz\n});", parserOptions: { ecmaVersion: 6 } },
diff --git a/tests/lib/rules/one-var-declaration-per-line.js b/tests/lib/rules/one-var-declaration-per-line.js
index 5a63c1492..d627b84d1 100644
--- a/tests/lib/rules/one-var-declaration-per-line.js
+++ b/tests/lib/rules/one-var-declaration-per-line.js
@@ -46,7 +46,7 @@ ruleTester.run("one-var-declaration-per-line", rule, {
         { code: "var a, b,\nc=0\nd = 0;", options: ["initializations"] },
         { code: "let a, b;", options: ["initializations"], parserOptions: { ecmaVersion: 6 } },
         { code: "var a = 0; var b = 0;", options: ["initializations"] },
-        { code: "var a, b,\nc=0\nd = 0;" },
+        "var a, b,\nc=0\nd = 0;",
 
         { code: "var a,\nb,\nc,\nd = 0;", options: ["always"] },
         { code: "var a = 0,\nb;", options: ["always"] },
diff --git a/tests/lib/rules/padded-blocks.js b/tests/lib/rules/padded-blocks.js
index bfaf9b616..fb363cdf3 100644
--- a/tests/lib/rules/padded-blocks.js
+++ b/tests/lib/rules/padded-blocks.js
@@ -22,19 +22,19 @@ const ruleTester = new RuleTester(),
 
 ruleTester.run("padded-blocks", rule, {
     valid: [
-        { code: "{\n\na();\n\n}" },
-        { code: "{\n\n\na();\n\n\n}" },
-        { code: "{\n\n//comment\na();\n\n}" },
-        { code: "{\n\na();\n//comment\n\n}" },
-        { code: "{\n\na()\n//comment\n\n}" },
-        { code: "{\n\na = 1\n\n}" },
-        { code: "{//comment\n\na();\n\n}" },
-        { code: "{ /* comment */\n\na();\n\n}" },
-        { code: "{ /* comment \n */\n\na();\n\n}" },
-        { code: "{ /* comment \n */ /* another comment \n */\n\na();\n\n}" },
-        { code: "{ /* comment \n */ /* another comment \n */\n\na();\n\n/* comment \n */ /* another comment \n */}" },
+        "{\n\na();\n\n}",
+        "{\n\n\na();\n\n\n}",
+        "{\n\n//comment\na();\n\n}",
+        "{\n\na();\n//comment\n\n}",
+        "{\n\na()\n//comment\n\n}",
+        "{\n\na = 1\n\n}",
+        "{//comment\n\na();\n\n}",
+        "{ /* comment */\n\na();\n\n}",
+        "{ /* comment \n */\n\na();\n\n}",
+        "{ /* comment \n */ /* another comment \n */\n\na();\n\n}",
+        "{ /* comment \n */ /* another comment \n */\n\na();\n\n/* comment \n */ /* another comment \n */}",
 
-        { code: "{\n\na();\n\n/* comment */ }" },
+        "{\n\na();\n\n/* comment */ }",
         { code: "{\n\na();\n\n/* comment */ }", options: ["always"] },
         { code: "{\n\na();\n\n/* comment */ }", options: [{ blocks: "always" }] },
 
diff --git a/tests/lib/rules/prefer-const.js b/tests/lib/rules/prefer-const.js
index eb2718e5a..f389dcd30 100644
--- a/tests/lib/rules/prefer-const.js
+++ b/tests/lib/rules/prefer-const.js
@@ -56,18 +56,16 @@ ruleTester.run("prefer-const", rule, {
         "let a; function foo() { if (a) {} a = bar(); }",
         "let a; function foo() { a = a || bar(); baz(a); }",
         "let a; function foo() { bar(++a); }",
-        {
-            code: [
-                "let id;",
-                "function foo() {",
-                "    if (typeof id !== 'undefined') {",
-                "        return;",
-                "    }",
-                "    id = setInterval(() => {}, 250);",
-                "}",
-                "foo();"
-            ].join("\n")
-        },
+        [
+            "let id;",
+            "function foo() {",
+            "    if (typeof id !== 'undefined') {",
+            "        return;",
+            "    }",
+            "    id = setInterval(() => {}, 250);",
+            "}",
+            "foo();"
+        ].join("\n"),
         "/*exported a*/ let a; function init() { a = foo(); }",
         "/*exported a*/ let a = 1",
         "let a; if (true) a = 0; foo(a);",
diff --git a/tests/lib/rules/prefer-destructuring.js b/tests/lib/rules/prefer-destructuring.js
index 4ac2ba3e8..93cf62a3e 100644
--- a/tests/lib/rules/prefer-destructuring.js
+++ b/tests/lib/rules/prefer-destructuring.js
@@ -20,17 +20,9 @@ const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 
 ruleTester.run("prefer-destructuring", rule, {
     valid: [
-        {
-            code: "var [foo] = array;"
-        },
-        {
-            code: "var { foo } = object;"
-        },
-        {
-
-            // Ensure that this doesn't break variable declarating without assignment
-            code: "var foo;"
-        },
+        "var [foo] = array;",
+        "var { foo } = object;",
+        "var foo;",
         {
 
             // Ensure that the default behavior does not require desturcturing when renaming
@@ -91,9 +83,7 @@ ruleTester.run("prefer-destructuring", rule, {
             code: "var foo = object['foo'];",
             options: [{ VariableDeclarator: { object: false } }]
         },
-        {
-            code: "({ foo } = object);"
-        },
+        "({ foo } = object);",
         {
 
             // Fix #8654
diff --git a/tests/lib/rules/prefer-reflect.js b/tests/lib/rules/prefer-reflect.js
index 7ccdcd7d1..62d9de38e 100644
--- a/tests/lib/rules/prefer-reflect.js
+++ b/tests/lib/rules/prefer-reflect.js
@@ -22,50 +22,50 @@ ruleTester.run("prefer-reflect", rule, {
     valid: [
 
         // Reflect.apply
-        { code: "Reflect.apply(function(){}, null, 1, 2);" },
+        "Reflect.apply(function(){}, null, 1, 2);",
         { code: "Reflect.apply(function(){}, null, 1, 2);", options: [{ exceptions: ["apply"] }] },
         { code: "(function(){}).apply(null, [1, 2]);", options: [{ exceptions: ["apply"] }] },
         { code: "(function(){}).call(null, 1, 2);", options: [{ exceptions: ["call"] }] },
 
         // Reflect.defineProperty
-        { code: "Reflect.defineProperty({}, 'foo', {value: 1})" },
+        "Reflect.defineProperty({}, 'foo', {value: 1})",
         { code: "Reflect.defineProperty({}, 'foo', {value: 1})", options: [{ exceptions: ["defineProperty"] }] },
         { code: "Object.defineProperty({}, 'foo', {value: 1})", options: [{ exceptions: ["defineProperty"] }] },
 
         // Reflect.getOwnPropertyDescriptor
-        { code: "Reflect.getOwnPropertyDescriptor({}, 'foo');" },
+        "Reflect.getOwnPropertyDescriptor({}, 'foo');",
         { code: "Reflect.getOwnPropertyDescriptor({}, 'foo');", options: [{ exceptions: ["getOwnPropertyDescriptor"] }] },
         { code: "Object.getOwnPropertyDescriptor({}, 'foo');", options: [{ exceptions: ["getOwnPropertyDescriptor"] }] },
 
         // Reflect.getPrototypeOf
-        { code: "Reflect.getPrototypeOf({});" },
+        "Reflect.getPrototypeOf({});",
         { code: "Reflect.getPrototypeOf({});", options: [{ exceptions: ["getPrototypeOf"] }] },
         { code: "Object.getPrototypeOf({});", options: [{ exceptions: ["getPrototypeOf"] }] },
 
         // Reflect.setPrototypeOf
-        { code: "Reflect.setPrototypeOf({}, Object.prototype);" },
+        "Reflect.setPrototypeOf({}, Object.prototype);",
         { code: "Reflect.setPrototypeOf({}, Object.prototype);", options: [{ exceptions: ["setPrototypeOf"] }] },
         { code: "Object.setPrototypeOf({}, Object.prototype);", options: [{ exceptions: ["setPrototypeOf"] }] },
 
         // Reflect.isExtensible
-        { code: "Reflect.isExtensible({});" },
+        "Reflect.isExtensible({});",
         { code: "Reflect.isExtensible({});", options: [{ exceptions: ["isExtensible"] }] },
         { code: "Object.isExtensible({});", options: [{ exceptions: ["isExtensible"] }] },
 
         // Reflect.getOwnPropertyNames
-        { code: "Reflect.getOwnPropertyNames({});" },
+        "Reflect.getOwnPropertyNames({});",
         { code: "Reflect.getOwnPropertyNames({});", options: [{ exceptions: ["getOwnPropertyNames"] }] },
         { code: "Object.getOwnPropertyNames({});", options: [{ exceptions: ["getOwnPropertyNames"] }] },
 
         // Reflect.getOwnPropertyNames
-        { code: "Reflect.preventExtensions({});" },
+        "Reflect.preventExtensions({});",
         { code: "Reflect.preventExtensions({});", options: [{ exceptions: ["preventExtensions"] }] },
         { code: "Object.preventExtensions({});", options: [{ exceptions: ["preventExtensions"] }] },
 
         // Reflect.getOwnPropertyNames
-        { code: "Reflect.deleteProperty({}, 'foo');" },
+        "Reflect.deleteProperty({}, 'foo');",
         { code: "Reflect.deleteProperty({}, 'foo');", options: [{ exceptions: ["delete"] }] },
-        { code: "delete foo;" },
+        "delete foo;",
         { code: "delete ({}).foo", options: [{ exceptions: ["delete"] }] }
     ],
     invalid: [
diff --git a/tests/lib/rules/prefer-template.js b/tests/lib/rules/prefer-template.js
index eba2f73e4..d7fa457ab 100644
--- a/tests/lib/rules/prefer-template.js
+++ b/tests/lib/rules/prefer-template.js
@@ -33,8 +33,8 @@ ruleTester.run("prefer-template", rule, {
         "var foo = `hello, ${name}!`;",
 
         // https://github.com/eslint/eslint/issues/3507
-        { code: "var foo = `foo` + `bar` + \"hoge\";" },
-        { code: "var foo = `foo` +\n    `bar` +\n    \"hoge\";" }
+        "var foo = `foo` + `bar` + \"hoge\";",
+        "var foo = `foo` +\n    `bar` +\n    \"hoge\";"
     ],
     invalid: [
         {
diff --git a/tests/lib/rules/quotes.js b/tests/lib/rules/quotes.js
index 3201e594c..b6ea51362 100644
--- a/tests/lib/rules/quotes.js
+++ b/tests/lib/rules/quotes.js
@@ -17,7 +17,6 @@ const ruleTester = new RuleTester();
 ruleTester.run("quotes", rule, {
     valid: [
         "var foo = \"bar\";",
-        { code: "var foo = \"bar\";" },
         { code: "var foo = 'bar';", options: ["single"] },
         { code: "var foo = \"bar\";", options: ["double"] },
         { code: "var foo = 1;", options: ["single"] },
diff --git a/tests/lib/rules/radix.js b/tests/lib/rules/radix.js
index f523edc84..1844a3234 100644
--- a/tests/lib/rules/radix.js
+++ b/tests/lib/rules/radix.js
@@ -41,10 +41,10 @@ ruleTester.run("radix", rule, {
         "Number[parseInt]();",
 
         // Ignores if it's shadowed.
-        { code: "var parseInt; parseInt();" },
+        "var parseInt; parseInt();",
         { code: "var parseInt; parseInt(foo);", options: ["always"] },
         { code: "var parseInt; parseInt(foo, 10);", options: ["as-needed"] },
-        { code: "var Number; Number.parseInt();" },
+        "var Number; Number.parseInt();",
         { code: "var Number; Number.parseInt(foo);", options: ["always"] },
         { code: "var Number; Number.parseInt(foo, 10);", options: ["as-needed"] }
     ],
diff --git a/tests/lib/rules/sort-imports.js b/tests/lib/rules/sort-imports.js
index 2e08c42c3..4cee0a2c5 100644
--- a/tests/lib/rules/sort-imports.js
+++ b/tests/lib/rules/sort-imports.js
@@ -25,27 +25,15 @@ const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6, sourceType:
 
 ruleTester.run("sort-imports", rule, {
     valid: [
-        {
-            code:
-                "import a from 'foo.js';\n" +
+        "import a from 'foo.js';\n" +
                 "import b from 'bar.js';\n" +
-                "import c from 'baz.js';\n"
-        },
-        {
-            code:
-                "import * as B from 'foo.js';\n" +
-                "import A from 'bar.js';"
-        },
-        {
-            code:
-                "import * as B from 'foo.js';\n" +
-                "import {a, b} from 'bar.js';"
-        },
-        {
-            code:
-                "import {b, c} from 'bar.js';\n" +
-                "import A from 'foo.js';"
-        },
+                "import c from 'baz.js';\n",
+        "import * as B from 'foo.js';\n" +
+                "import A from 'bar.js';",
+        "import * as B from 'foo.js';\n" +
+                "import {a, b} from 'bar.js';",
+        "import {b, c} from 'bar.js';\n" +
+                "import A from 'foo.js';",
         {
             code:
                 "import A from 'bar.js';\n" +
@@ -54,36 +42,18 @@ ruleTester.run("sort-imports", rule, {
                 memberSyntaxSortOrder: ["single", "multiple", "none", "all"]
             }]
         },
-        {
-            code:
-                "import {a, b} from 'bar.js';\n" +
-                "import {c, d} from 'foo.js';"
-        },
-        {
-            code:
-                "import A from 'foo.js';\n" +
-                "import B from 'bar.js';"
-        },
-        {
-            code:
-                "import A from 'foo.js';\n" +
-                "import a from 'bar.js';"
-        },
-        {
-            code:
-                "import a, * as b from 'foo.js';\n" +
-                "import c from 'bar.js';"
-        },
-        {
-            code:
-                "import 'foo.js';\n" +
-                " import a from 'bar.js';"
-        },
-        {
-            code:
-                "import B from 'foo.js';\n" +
-                "import a from 'bar.js';"
-        },
+        "import {a, b} from 'bar.js';\n" +
+                "import {c, d} from 'foo.js';",
+        "import A from 'foo.js';\n" +
+                "import B from 'bar.js';",
+        "import A from 'foo.js';\n" +
+                "import a from 'bar.js';",
+        "import a, * as b from 'foo.js';\n" +
+                "import c from 'bar.js';",
+        "import 'foo.js';\n" +
+                " import a from 'bar.js';",
+        "import B from 'foo.js';\n" +
+                "import a from 'bar.js';",
         {
             code:
                 "import a from 'foo.js';\n" +
@@ -108,17 +78,11 @@ ruleTester.run("sort-imports", rule, {
             options: ignoreCaseArgs
         },
         "import a, * as b from 'foo.js';",
-        {
-            code:
-                "import * as a from 'foo.js';\n" +
+        "import * as a from 'foo.js';\n" +
                 "\n" +
-                "import b from 'bar.js';"
-        },
-        {
-            code:
-                "import * as bar from 'bar.js';\n" +
-                "import * as foo from 'foo.js';"
-        },
+                "import b from 'bar.js';",
+        "import * as bar from 'bar.js';\n" +
+                "import * as foo from 'foo.js';",
 
         // https://github.com/eslint/eslint/issues/5130
         {
diff --git a/tests/lib/rules/space-before-blocks.js b/tests/lib/rules/space-before-blocks.js
index 9a9426f8c..e0ccb67ad 100644
--- a/tests/lib/rules/space-before-blocks.js
+++ b/tests/lib/rules/space-before-blocks.js
@@ -28,22 +28,22 @@ const ruleTester = new RuleTester(),
 
 ruleTester.run("space-before-blocks", rule, {
     valid: [
-        { code: "if(a) {}" },
-        { code: "if(a)  {}" },
+        "if(a) {}",
+        "if(a)  {}",
         { code: "if(a){}", options: neverArgs },
         { code: "if(a){}", options: functionsOnlyArgs },
         { code: "if(a) {}", options: keywordOnlyArgs },
         { code: "if(a){ function b() {} }", options: functionsOnlyArgs },
         { code: "if(a) { function b(){} }", options: keywordOnlyArgs },
-        { code: "if(a)\n{}" },
+        "if(a)\n{}",
         { code: "if(a)\n{}", options: neverArgs },
-        { code: "if(a) {}else {}" },
+        "if(a) {}else {}",
         { code: "if(a){}else{}", options: neverArgs },
         { code: "if(a){}else{}", options: functionsOnlyArgs },
         { code: "if(a) {} else {}", options: keywordOnlyArgs },
         { code: "if(a){ function b() {} }else{}", options: functionsOnlyArgs },
         { code: "if(a) { function b(){} } else {}", options: keywordOnlyArgs },
-        { code: "function a() {}" },
+        "function a() {}",
         { code: "function a(){}", options: neverArgs },
         {
             code: "export default class{}",
@@ -71,27 +71,27 @@ ruleTester.run("space-before-blocks", rule, {
         { code: "function a() {}", options: functionsOnlyArgs },
         { code: "function a(){ if(b) {} }", options: keywordOnlyArgs },
         { code: "function a() { if(b){} }", options: functionsOnlyArgs },
-        { code: "switch(a.b(c < d)) { case 'foo': foo(); break; default: if (a) { bar(); } }" },
-        { code: "switch(a) { }" },
-        { code: "switch(a)  {}" },
+        "switch(a.b(c < d)) { case 'foo': foo(); break; default: if (a) { bar(); } }",
+        "switch(a) { }",
+        "switch(a)  {}",
         { code: "switch(a.b(c < d)){ case 'foo': foo(); break; default: if (a){ bar(); } }", options: neverArgs },
         { code: "switch(a.b(c < d)){ case 'foo': foo(); break; default: if (a){ bar(); } }", options: functionsOnlyArgs },
         { code: "switch(a){}", options: neverArgs },
         { code: "switch(a){}", options: functionsOnlyArgs },
         { code: "switch(a) {}", options: keywordOnlyArgs },
-        { code: "try {}catch(a) {}" },
+        "try {}catch(a) {}",
         { code: "try{}catch(a){}", options: neverArgs },
         { code: "try{}catch(a){}", options: functionsOnlyArgs },
         { code: "try {} catch(a) {}", options: keywordOnlyArgs },
         { code: "try{ function b() {} }catch(a){}", options: functionsOnlyArgs },
         { code: "try { function b(){} } catch(a) {}", options: keywordOnlyArgs },
-        { code: "for(;;) {}" },
+        "for(;;) {}",
         { code: "for(;;){}", options: neverArgs },
         { code: "for(;;){}", options: functionsOnlyArgs },
         { code: "for(;;) {}", options: keywordOnlyArgs },
         { code: "for(;;){ function a() {} }", options: functionsOnlyArgs },
         { code: "for(;;) { function a(){} }", options: keywordOnlyArgs },
-        { code: "while(a) {}" },
+        "while(a) {}",
         { code: "while(a){}", options: neverArgs },
         { code: "while(a){}", options: functionsOnlyArgs },
         { code: "while(a) {}", options: keywordOnlyArgs },
@@ -137,7 +137,7 @@ ruleTester.run("space-before-blocks", rule, {
         { code: "() => {};", options: ["never"], parserOptions: { ecmaVersion: 6 } },
 
         // https://github.com/eslint/eslint/issues/1338
-        { code: "if(a) {}else{}" },
+        "if(a) {}else{}",
         { code: "if(a){}else {}", options: neverArgs },
         { code: "try {}catch(a){}", options: functionsOnlyArgs },
         { code: "export default class{}", options: classesOnlyArgs, parserOptions: { sourceType: "module" } }
diff --git a/tests/lib/rules/space-before-function-paren.js b/tests/lib/rules/space-before-function-paren.js
index c8c4ca4c3..8db800810 100644
--- a/tests/lib/rules/space-before-function-paren.js
+++ b/tests/lib/rules/space-before-function-paren.js
@@ -21,10 +21,10 @@ const ruleTester = new RuleTester();
 ruleTester.run("space-before-function-paren", rule, {
 
     valid: [
-        { code: "function foo () {}" },
-        { code: "var foo = function () {}" },
-        { code: "var bar = function foo () {}" },
-        { code: "var obj = { get foo () {}, set foo (val) {} };" },
+        "function foo () {}",
+        "var foo = function () {}",
+        "var bar = function foo () {}",
+        "var obj = { get foo () {}, set foo (val) {} };",
         {
             code: "var obj = { foo () {} };",
             parserOptions: { ecmaVersion: 6 }
diff --git a/tests/lib/rules/space-in-parens.js b/tests/lib/rules/space-in-parens.js
index 9e344e977..c9249e730 100644
--- a/tests/lib/rules/space-in-parens.js
+++ b/tests/lib/rules/space-in-parens.js
@@ -57,7 +57,7 @@ ruleTester.run("space-in-parens", rule, {
         { code: "foo( baz /* bar */ )", options: ["always"] },
         { code: "foo(/* bar */)", options: ["never"] },
         { code: "foo(/* bar */ baz)", options: ["never"] },
-        { code: "foo( //some comment\nbar\n)\n" },
+        "foo( //some comment\nbar\n)\n",
         { code: "foo(//some comment\nbar\n)\n", options: ["never"] },
         { code: "foo( //some comment\nbar\n)\n", options: ["never"] },
 
diff --git a/tests/lib/rules/space-unary-ops.js b/tests/lib/rules/space-unary-ops.js
index d5466bff5..22efa2088 100644
--- a/tests/lib/rules/space-unary-ops.js
+++ b/tests/lib/rules/space-unary-ops.js
@@ -36,9 +36,7 @@ ruleTester.run("space-unary-ops", rule, {
             code: "this.a--",
             options: [{ words: true }]
         },
-        {
-            code: "foo .bar++"
-        },
+        "foo .bar++",
         {
             code: "foo.bar --",
             options: [{ nonwords: true }]
diff --git a/tests/lib/rules/strict.js b/tests/lib/rules/strict.js
index 29dcc2ab1..6c75f74b8 100644
--- a/tests/lib/rules/strict.js
+++ b/tests/lib/rules/strict.js
@@ -81,7 +81,7 @@ ruleTester.run("strict", rule, {
         { code: "function foo() { return; }", options: ["safe"], parserOptions: { ecmaFeatures: { impliedStrict: true } } },
 
         // defaults to "safe" mode
-        { code: "function foo() { 'use strict'; return; }" },
+        "function foo() { 'use strict'; return; }",
         { code: "'use strict'; function foo() { return; }", parserOptions: { ecmaFeatures: { globalReturn: true } } },
         { code: "function foo() { return; }", parserOptions: { sourceType: "module" } },
         { code: "function foo() { return; }", parserOptions: { ecmaFeatures: { impliedStrict: true } } }
diff --git a/tests/lib/rules/valid-jsdoc.js b/tests/lib/rules/valid-jsdoc.js
index 8a8a158b7..e9519278a 100644
--- a/tests/lib/rules/valid-jsdoc.js
+++ b/tests/lib/rules/valid-jsdoc.js
@@ -559,24 +559,18 @@ ruleTester.run("valid-jsdoc", rule, {
         },
 
         // https://github.com/eslint/eslint/issues/7184
-        {
-            code:
-            "/**\n" +
+        "/**\n" +
             "* Foo\n" +
             "* @param {{foo}} hi - desc\n" +
             "* @returns {ASTNode} returns a node\n" +
             "*/\n" +
-            "function foo(hi){}"
-        },
-        {
-            code:
-            "/**\n" +
+            "function foo(hi){}",
+        "/**\n" +
             "* Foo\n" +
             "* @param {{foo:String, bar, baz:Array}} hi - desc\n" +
             "* @returns {ASTNode} returns a node\n" +
             "*/\n" +
-            "function foo(hi){}"
-        },
+            "function foo(hi){}",
         {
             code:
             "/**\n" +