diff --git a/docs/rules/generator-star-spacing.md b/docs/rules/generator-star-spacing.md
index 6a19e05827d..a7b4f1742bc 100644
--- a/docs/rules/generator-star-spacing.md
+++ b/docs/rules/generator-star-spacing.md
@@ -104,7 +104,7 @@ Examples of **correct** code for this rule with the `"before"` option:
 /*eslint generator-star-spacing: ["error", {"before": true, "after": false}]*/
 /*eslint-env es6*/
 
-function *generator() {};
+function *generator() {}
 
 var anonymous = function *() {};
 
@@ -119,7 +119,7 @@ Examples of **correct** code for this rule with the `"after"` option:
 /*eslint generator-star-spacing: ["error", {"before": false, "after": true}]*/
 /*eslint-env es6*/
 
-function* generator() {};
+function* generator() {}
 
 var anonymous = function* () {};
 
@@ -134,7 +134,7 @@ Examples of **correct** code for this rule with the `"both"` option:
 /*eslint generator-star-spacing: ["error", {"before": true, "after": true}]*/
 /*eslint-env es6*/
 
-function * generator() {};
+function * generator() {}
 
 var anonymous = function * () {};
 
@@ -149,7 +149,7 @@ Examples of **correct** code for this rule with the `"neither"` option:
 /*eslint generator-star-spacing: ["error", {"before": false, "after": false}]*/
 /*eslint-env es6*/
 
-function*generator() {};
+function*generator() {}
 
 var anonymous = function*() {};
 
@@ -168,13 +168,13 @@ Examples of **correct** code for this rule with overrides present
 }]*/
 /*eslint-env es6*/
 
-function* generator() {};
+function* generator() {}
 
 var anonymous = function*() {};
 
 var shorthand = { *generator() {} };
 
-class Class { static * method() {} };
+class Class { static * method() {} }
 ```
 
 ## When Not To Use It
diff --git a/tests/lib/rules/generator-star-spacing.js b/tests/lib/rules/generator-star-spacing.js
index 584f7b51944..74b02650aec 100644
--- a/tests/lib/rules/generator-star-spacing.js
+++ b/tests/lib/rules/generator-star-spacing.js
@@ -23,30 +23,30 @@ ruleTester.run("generator-star-spacing", rule, {
     valid: [
 
         // Default ("before")
-        "function foo(){};",
-        "function *foo(){};",
-        "function *foo(arg1, arg2){};",
+        "function foo(){}",
+        "function *foo(){}",
+        "function *foo(arg1, arg2){}",
         "var foo = function *foo(){};",
         "var foo = function *(){};",
         "var foo = { *foo(){} };",
         "var foo = {*foo(){} };",
-        "class Foo { *foo(){} };",
-        "class Foo {*foo(){} };",
-        "class Foo { static *foo(){} };",
+        "class Foo { *foo(){} }",
+        "class Foo {*foo(){} }",
+        "class Foo { static *foo(){} }",
         "var foo = {*[ foo ](){} };",
-        "class Foo {*[ foo ](){} };",
+        "class Foo {*[ foo ](){} }",
 
         // "before"
         {
-            code: "function foo(){};",
+            code: "function foo(){}",
             options: ["before"]
         },
         {
-            code: "function *foo(){};",
+            code: "function *foo(){}",
             options: ["before"]
         },
         {
-            code: "function *foo(arg1, arg2){};",
+            code: "function *foo(arg1, arg2){}",
             options: ["before"]
         },
         {
@@ -66,19 +66,19 @@ ruleTester.run("generator-star-spacing", rule, {
             options: ["before"]
         },
         {
-            code: "class Foo { *foo(){} };",
+            code: "class Foo { *foo(){} }",
             options: ["before"]
         },
         {
-            code: "class Foo {*foo(){} };",
+            code: "class Foo {*foo(){} }",
             options: ["before"]
         },
         {
-            code: "class Foo { static *foo(){} };",
+            code: "class Foo { static *foo(){} }",
             options: ["before"]
         },
         {
-            code: "class Foo {*[ foo ](){} };",
+            code: "class Foo {*[ foo ](){} }",
             options: ["before"]
         },
         {
@@ -88,15 +88,15 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // "after"
         {
-            code: "function foo(){};",
+            code: "function foo(){}",
             options: ["after"]
         },
         {
-            code: "function* foo(){};",
+            code: "function* foo(){}",
             options: ["after"]
         },
         {
-            code: "function* foo(arg1, arg2){};",
+            code: "function* foo(arg1, arg2){}",
             options: ["after"]
         },
         {
@@ -116,15 +116,15 @@ ruleTester.run("generator-star-spacing", rule, {
             options: ["after"]
         },
         {
-            code: "class Foo {* foo(){} };",
+            code: "class Foo {* foo(){} }",
             options: ["after"]
         },
         {
-            code: "class Foo { * foo(){} };",
+            code: "class Foo { * foo(){} }",
             options: ["after"]
         },
         {
-            code: "class Foo { static* foo(){} };",
+            code: "class Foo { static* foo(){} }",
             options: ["after"]
         },
         {
@@ -132,21 +132,21 @@ ruleTester.run("generator-star-spacing", rule, {
             options: ["after"]
         },
         {
-            code: "class Foo {* [foo](){} };",
+            code: "class Foo {* [foo](){} }",
             options: ["after"]
         },
 
         // "both"
         {
-            code: "function foo(){};",
+            code: "function foo(){}",
             options: ["both"]
         },
         {
-            code: "function * foo(){};",
+            code: "function * foo(){}",
             options: ["both"]
         },
         {
-            code: "function * foo(arg1, arg2){};",
+            code: "function * foo(arg1, arg2){}",
             options: ["both"]
         },
         {
@@ -166,15 +166,15 @@ ruleTester.run("generator-star-spacing", rule, {
             options: ["both"]
         },
         {
-            code: "class Foo { * foo(){} };",
+            code: "class Foo { * foo(){} }",
             options: ["both"]
         },
         {
-            code: "class Foo {* foo(){} };",
+            code: "class Foo {* foo(){} }",
             options: ["both"]
         },
         {
-            code: "class Foo { static * foo(){} };",
+            code: "class Foo { static * foo(){} }",
             options: ["both"]
         },
         {
@@ -182,21 +182,21 @@ ruleTester.run("generator-star-spacing", rule, {
             options: ["both"]
         },
         {
-            code: "class Foo {* [foo](){} };",
+            code: "class Foo {* [foo](){} }",
             options: ["both"]
         },
 
         // "neither"
         {
-            code: "function foo(){};",
+            code: "function foo(){}",
             options: ["neither"]
         },
         {
-            code: "function*foo(){};",
+            code: "function*foo(){}",
             options: ["neither"]
         },
         {
-            code: "function*foo(arg1, arg2){};",
+            code: "function*foo(arg1, arg2){}",
             options: ["neither"]
         },
         {
@@ -216,15 +216,15 @@ ruleTester.run("generator-star-spacing", rule, {
             options: ["neither"]
         },
         {
-            code: "class Foo {*foo(){} };",
+            code: "class Foo {*foo(){} }",
             options: ["neither"]
         },
         {
-            code: "class Foo { *foo(){} };",
+            code: "class Foo { *foo(){} }",
             options: ["neither"]
         },
         {
-            code: "class Foo { static*foo(){} };",
+            code: "class Foo { static*foo(){} }",
             options: ["neither"]
         },
         {
@@ -232,21 +232,21 @@ ruleTester.run("generator-star-spacing", rule, {
             options: ["neither"]
         },
         {
-            code: "class Foo {*[ foo ](){} };",
+            code: "class Foo {*[ foo ](){} }",
             options: ["neither"]
         },
 
         // {"before": true, "after": false}
         {
-            code: "function foo(){};",
+            code: "function foo(){}",
             options: [{ before: true, after: false }]
         },
         {
-            code: "function *foo(){};",
+            code: "function *foo(){}",
             options: [{ before: true, after: false }]
         },
         {
-            code: "function *foo(arg1, arg2){};",
+            code: "function *foo(arg1, arg2){}",
             options: [{ before: true, after: false }]
         },
         {
@@ -266,29 +266,29 @@ ruleTester.run("generator-star-spacing", rule, {
             options: [{ before: true, after: false }]
         },
         {
-            code: "class Foo { *foo(){} };",
+            code: "class Foo { *foo(){} }",
             options: [{ before: true, after: false }]
         },
         {
-            code: "class Foo {*foo(){} };",
+            code: "class Foo {*foo(){} }",
             options: [{ before: true, after: false }]
         },
         {
-            code: "class Foo { static *foo(){} };",
+            code: "class Foo { static *foo(){} }",
             options: [{ before: true, after: false }]
         },
 
         // {"before": false, "after": true}
         {
-            code: "function foo(){};",
+            code: "function foo(){}",
             options: [{ before: false, after: true }]
         },
         {
-            code: "function* foo(){};",
+            code: "function* foo(){}",
             options: [{ before: false, after: true }]
         },
         {
-            code: "function* foo(arg1, arg2){};",
+            code: "function* foo(arg1, arg2){}",
             options: [{ before: false, after: true }]
         },
         {
@@ -308,29 +308,29 @@ ruleTester.run("generator-star-spacing", rule, {
             options: [{ before: false, after: true }]
         },
         {
-            code: "class Foo {* foo(){} };",
+            code: "class Foo {* foo(){} }",
             options: [{ before: false, after: true }]
         },
         {
-            code: "class Foo { * foo(){} };",
+            code: "class Foo { * foo(){} }",
             options: [{ before: false, after: true }]
         },
         {
-            code: "class Foo { static* foo(){} };",
+            code: "class Foo { static* foo(){} }",
             options: [{ before: false, after: true }]
         },
 
         // {"before": true, "after": true}
         {
-            code: "function foo(){};",
+            code: "function foo(){}",
             options: [{ before: true, after: true }]
         },
         {
-            code: "function * foo(){};",
+            code: "function * foo(){}",
             options: [{ before: true, after: true }]
         },
         {
-            code: "function * foo(arg1, arg2){};",
+            code: "function * foo(arg1, arg2){}",
             options: [{ before: true, after: true }]
         },
         {
@@ -350,29 +350,29 @@ ruleTester.run("generator-star-spacing", rule, {
             options: [{ before: true, after: true }]
         },
         {
-            code: "class Foo { * foo(){} };",
+            code: "class Foo { * foo(){} }",
             options: [{ before: true, after: true }]
         },
         {
-            code: "class Foo {* foo(){} };",
+            code: "class Foo {* foo(){} }",
             options: [{ before: true, after: true }]
         },
         {
-            code: "class Foo { static * foo(){} };",
+            code: "class Foo { static * foo(){} }",
             options: [{ before: true, after: true }]
         },
 
         // {"before": false, "after": false}
         {
-            code: "function foo(){};",
+            code: "function foo(){}",
             options: [{ before: false, after: false }]
         },
         {
-            code: "function*foo(){};",
+            code: "function*foo(){}",
             options: [{ before: false, after: false }]
         },
         {
-            code: "function*foo(arg1, arg2){};",
+            code: "function*foo(arg1, arg2){}",
             options: [{ before: false, after: false }]
         },
         {
@@ -392,21 +392,21 @@ ruleTester.run("generator-star-spacing", rule, {
             options: [{ before: false, after: false }]
         },
         {
-            code: "class Foo {*foo(){} };",
+            code: "class Foo {*foo(){} }",
             options: [{ before: false, after: false }]
         },
         {
-            code: "class Foo { *foo(){} };",
+            code: "class Foo { *foo(){} }",
             options: [{ before: false, after: false }]
         },
         {
-            code: "class Foo { static*foo(){} };",
+            code: "class Foo { static*foo(){} }",
             options: [{ before: false, after: false }]
         },
 
         // full configurability
         {
-            code: "function * foo(){};",
+            code: "function * foo(){}",
             options: [{ before: false, after: false, named: "both" }]
         },
         {
@@ -414,17 +414,17 @@ ruleTester.run("generator-star-spacing", rule, {
             options: [{ before: false, after: false, anonymous: "both" }]
         },
         {
-            code: "class Foo { * foo(){} };",
+            code: "class Foo { * foo(){} }",
             options: [{ before: false, after: false, method: "both" }]
         },
         {
-            code: "class Foo { static * foo(){} };",
+            code: "class Foo { static * foo(){} }",
             options: [{ before: false, after: false, static: "both" }]
         },
 
         // https://github.com/eslint/eslint/issues/7101#issuecomment-246080531
         {
-            code: "async function foo() { };",
+            code: "async function foo() { }",
             parserOptions: { ecmaVersion: 8 }
         },
         {
@@ -432,7 +432,7 @@ ruleTester.run("generator-star-spacing", rule, {
             parserOptions: { ecmaVersion: 8 }
         },
         {
-            code: "async () => { };",
+            code: "async () => { }",
             parserOptions: { ecmaVersion: 8 }
         },
         {
@@ -440,7 +440,7 @@ ruleTester.run("generator-star-spacing", rule, {
             parserOptions: { ecmaVersion: 8 }
         },
         {
-            code: "class A {async foo() { }};",
+            code: "class A {async foo() { }}",
             parserOptions: { ecmaVersion: 8 }
         },
         {
@@ -453,16 +453,16 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // Default ("before")
         {
-            code: "function*foo(){};",
-            output: "function *foo(){};",
+            code: "function*foo(){}",
+            output: "function *foo(){}",
             errors: [{
                 message: "Missing space before *.",
                 type: "Punctuator"
             }]
         },
         {
-            code: "function* foo(arg1, arg2){};",
-            output: "function *foo(arg1, arg2){};",
+            code: "function* foo(arg1, arg2){}",
+            output: "function *foo(arg1, arg2){}",
             errors: [{
                 message: "Missing space before *.",
                 type: "Punctuator"
@@ -499,16 +499,16 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo {* foo(){} };",
-            output: "class Foo {*foo(){} };",
+            code: "class Foo {* foo(){} }",
+            output: "class Foo {*foo(){} }",
             errors: [{
                 message: "Unexpected space after *.",
                 type: "Punctuator"
             }]
         },
         {
-            code: "class Foo { static* foo(){} };",
-            output: "class Foo { static *foo(){} };",
+            code: "class Foo { static* foo(){} }",
+            output: "class Foo { static *foo(){} }",
             errors: [{
                 message: "Missing space before *.",
                 type: "Punctuator"
@@ -520,8 +520,8 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // "before"
         {
-            code: "function*foo(){};",
-            output: "function *foo(){};",
+            code: "function*foo(){}",
+            output: "function *foo(){}",
             options: ["before"],
             errors: [{
                 message: "Missing space before *.",
@@ -529,8 +529,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "function* foo(arg1, arg2){};",
-            output: "function *foo(arg1, arg2){};",
+            code: "function* foo(arg1, arg2){}",
+            output: "function *foo(arg1, arg2){}",
             options: ["before"],
             errors: [{
                 message: "Missing space before *.",
@@ -571,8 +571,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo {* foo(){} };",
-            output: "class Foo {*foo(){} };",
+            code: "class Foo {* foo(){} }",
+            output: "class Foo {*foo(){} }",
             options: ["before"],
             errors: [{
                 message: "Unexpected space after *.",
@@ -589,8 +589,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo {* [ foo ](){} };",
-            output: "class Foo {*[ foo ](){} };",
+            code: "class Foo {* [ foo ](){} }",
+            output: "class Foo {*[ foo ](){} }",
             options: ["before"],
             errors: [{
                 message: "Unexpected space after *.",
@@ -600,8 +600,8 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // "after"
         {
-            code: "function*foo(){};",
-            output: "function* foo(){};",
+            code: "function*foo(){}",
+            output: "function* foo(){}",
             options: ["after"],
             errors: [{
                 message: "Missing space after *.",
@@ -609,8 +609,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "function *foo(arg1, arg2){};",
-            output: "function* foo(arg1, arg2){};",
+            code: "function *foo(arg1, arg2){}",
+            output: "function* foo(arg1, arg2){}",
             options: ["after"],
             errors: [{
                 message: "Unexpected space before *.",
@@ -654,8 +654,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { *foo(){} };",
-            output: "class Foo { * foo(){} };",
+            code: "class Foo { *foo(){} }",
+            output: "class Foo { * foo(){} }",
             options: ["after"],
             errors: [{
                 message: "Missing space after *.",
@@ -663,8 +663,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { static *foo(){} };",
-            output: "class Foo { static* foo(){} };",
+            code: "class Foo { static *foo(){} }",
+            output: "class Foo { static* foo(){} }",
             options: ["after"],
             errors: [{
                 message: "Unexpected space before *.",
@@ -684,8 +684,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { *[foo](){} };",
-            output: "class Foo { * [foo](){} };",
+            code: "class Foo { *[foo](){} }",
+            output: "class Foo { * [foo](){} }",
             options: ["after"],
             errors: [{
                 message: "Missing space after *.",
@@ -695,8 +695,8 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // "both"
         {
-            code: "function*foo(){};",
-            output: "function * foo(){};",
+            code: "function*foo(){}",
+            output: "function * foo(){}",
             options: ["both"],
             errors: [{
                 message: "Missing space before *.",
@@ -707,8 +707,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "function*foo(arg1, arg2){};",
-            output: "function * foo(arg1, arg2){};",
+            code: "function*foo(arg1, arg2){}",
+            output: "function * foo(arg1, arg2){}",
             options: ["both"],
             errors: [{
                 message: "Missing space before *.",
@@ -752,8 +752,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo {*foo(){} };",
-            output: "class Foo {* foo(){} };",
+            code: "class Foo {*foo(){} }",
+            output: "class Foo {* foo(){} }",
             options: ["both"],
             errors: [{
                 message: "Missing space after *.",
@@ -761,8 +761,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { static*foo(){} };",
-            output: "class Foo { static * foo(){} };",
+            code: "class Foo { static*foo(){} }",
+            output: "class Foo { static * foo(){} }",
             options: ["both"],
             errors: [{
                 message: "Missing space before *.",
@@ -782,8 +782,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo {*[foo](){} };",
-            output: "class Foo {* [foo](){} };",
+            code: "class Foo {*[foo](){} }",
+            output: "class Foo {* [foo](){} }",
             options: ["both"],
             errors: [{
                 message: "Missing space after *.",
@@ -793,8 +793,8 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // "neither"
         {
-            code: "function * foo(){};",
-            output: "function*foo(){};",
+            code: "function * foo(){}",
+            output: "function*foo(){}",
             options: ["neither"],
             errors: [{
                 message: "Unexpected space before *.",
@@ -805,8 +805,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "function * foo(arg1, arg2){};",
-            output: "function*foo(arg1, arg2){};",
+            code: "function * foo(arg1, arg2){}",
+            output: "function*foo(arg1, arg2){}",
             options: ["neither"],
             errors: [{
                 message: "Unexpected space before *.",
@@ -850,8 +850,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { * foo(){} };",
-            output: "class Foo { *foo(){} };",
+            code: "class Foo { * foo(){} }",
+            output: "class Foo { *foo(){} }",
             options: ["neither"],
             errors: [{
                 message: "Unexpected space after *.",
@@ -859,8 +859,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { static * foo(){} };",
-            output: "class Foo { static*foo(){} };",
+            code: "class Foo { static * foo(){} }",
+            output: "class Foo { static*foo(){} }",
             options: ["neither"],
             errors: [{
                 message: "Unexpected space before *.",
@@ -880,8 +880,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { * [ foo ](){} };",
-            output: "class Foo { *[ foo ](){} };",
+            code: "class Foo { * [ foo ](){} }",
+            output: "class Foo { *[ foo ](){} }",
             options: ["neither"],
             errors: [{
                 message: "Unexpected space after *.",
@@ -891,8 +891,8 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // {"before": true, "after": false}
         {
-            code: "function*foo(){};",
-            output: "function *foo(){};",
+            code: "function*foo(){}",
+            output: "function *foo(){}",
             options: [{ before: true, after: false }],
             errors: [{
                 message: "Missing space before *.",
@@ -900,8 +900,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "function* foo(arg1, arg2){};",
-            output: "function *foo(arg1, arg2){};",
+            code: "function* foo(arg1, arg2){}",
+            output: "function *foo(arg1, arg2){}",
             options: [{ before: true, after: false }],
             errors: [{
                 message: "Missing space before *.",
@@ -942,8 +942,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo {* foo(){} };",
-            output: "class Foo {*foo(){} };",
+            code: "class Foo {* foo(){} }",
+            output: "class Foo {*foo(){} }",
             options: [{ before: true, after: false }],
             errors: [{
                 message: "Unexpected space after *.",
@@ -953,8 +953,8 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // {"before": false, "after": true}
         {
-            code: "function*foo(){};",
-            output: "function* foo(){};",
+            code: "function*foo(){}",
+            output: "function* foo(){}",
             options: [{ before: false, after: true }],
             errors: [{
                 message: "Missing space after *.",
@@ -962,8 +962,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "function *foo(arg1, arg2){};",
-            output: "function* foo(arg1, arg2){};",
+            code: "function *foo(arg1, arg2){}",
+            output: "function* foo(arg1, arg2){}",
             options: [{ before: false, after: true }],
             errors: [{
                 message: "Unexpected space before *.",
@@ -1007,8 +1007,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { *foo(){} };",
-            output: "class Foo { * foo(){} };",
+            code: "class Foo { *foo(){} }",
+            output: "class Foo { * foo(){} }",
             options: [{ before: false, after: true }],
             errors: [{
                 message: "Missing space after *.",
@@ -1016,8 +1016,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { static *foo(){} };",
-            output: "class Foo { static* foo(){} };",
+            code: "class Foo { static *foo(){} }",
+            output: "class Foo { static* foo(){} }",
             options: [{ before: false, after: true }],
             errors: [{
                 message: "Unexpected space before *.",
@@ -1030,8 +1030,8 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // {"before": true, "after": true}
         {
-            code: "function*foo(){};",
-            output: "function * foo(){};",
+            code: "function*foo(){}",
+            output: "function * foo(){}",
             options: [{ before: true, after: true }],
             errors: [{
                 message: "Missing space before *.",
@@ -1042,8 +1042,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "function*foo(arg1, arg2){};",
-            output: "function * foo(arg1, arg2){};",
+            code: "function*foo(arg1, arg2){}",
+            output: "function * foo(arg1, arg2){}",
             options: [{ before: true, after: true }],
             errors: [{
                 message: "Missing space before *.",
@@ -1087,8 +1087,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo {*foo(){} };",
-            output: "class Foo {* foo(){} };",
+            code: "class Foo {*foo(){} }",
+            output: "class Foo {* foo(){} }",
             options: [{ before: true, after: true }],
             errors: [{
                 message: "Missing space after *.",
@@ -1096,8 +1096,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { static*foo(){} };",
-            output: "class Foo { static * foo(){} };",
+            code: "class Foo { static*foo(){} }",
+            output: "class Foo { static * foo(){} }",
             options: [{ before: true, after: true }],
             errors: [{
                 message: "Missing space before *.",
@@ -1110,8 +1110,8 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // {"before": false, "after": false}
         {
-            code: "function * foo(){};",
-            output: "function*foo(){};",
+            code: "function * foo(){}",
+            output: "function*foo(){}",
             options: [{ before: false, after: false }],
             errors: [{
                 message: "Unexpected space before *.",
@@ -1122,8 +1122,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "function * foo(arg1, arg2){};",
-            output: "function*foo(arg1, arg2){};",
+            code: "function * foo(arg1, arg2){}",
+            output: "function*foo(arg1, arg2){}",
             options: [{ before: false, after: false }],
             errors: [{
                 message: "Unexpected space before *.",
@@ -1167,8 +1167,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { * foo(){} };",
-            output: "class Foo { *foo(){} };",
+            code: "class Foo { * foo(){} }",
+            output: "class Foo { *foo(){} }",
             options: [{ before: false, after: false }],
             errors: [{
                 message: "Unexpected space after *.",
@@ -1176,8 +1176,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { static * foo(){} };",
-            output: "class Foo { static*foo(){} };",
+            code: "class Foo { static * foo(){} }",
+            output: "class Foo { static*foo(){} }",
             options: [{ before: false, after: false }],
             errors: [{
                 message: "Unexpected space before *.",
@@ -1190,8 +1190,8 @@ ruleTester.run("generator-star-spacing", rule, {
 
         // full configurability
         {
-            code: "function*foo(){};",
-            output: "function * foo(){};",
+            code: "function*foo(){}",
+            output: "function * foo(){}",
             options: [{ before: false, after: false, named: "both" }],
             errors: [{
                 message: "Missing space before *.",
@@ -1214,8 +1214,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { *foo(){} };",
-            output: "class Foo { * foo(){} };",
+            code: "class Foo { *foo(){} }",
+            output: "class Foo { * foo(){} }",
             options: [{ before: false, after: false, method: "both" }],
             errors: [{
                 message: "Missing space after *.",
@@ -1223,8 +1223,8 @@ ruleTester.run("generator-star-spacing", rule, {
             }]
         },
         {
-            code: "class Foo { static*foo(){} };",
-            output: "class Foo { static * foo(){} };",
+            code: "class Foo { static*foo(){} }",
+            output: "class Foo { static * foo(){} }",
             options: [{ before: false, after: false, static: "both" }],
             errors: [{
                 message: "Missing space before *.",