[pve-eslint.git] / eslint / tests / lib / rules / function-paren-newline.js

/**
 * @fileoverview enforce consistent line breaks inside function parentheses
 * @author Teddy Katz
 */
"use strict";

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const rule = require("../../../lib/rules/function-paren-newline");
const { RuleTester } = require("../../../lib/rule-tester");


//------------------------------------------------------------------------------
// Tests
//------------------------------------------------------------------------------

const LEFT_MISSING_ERROR = { messageId: "expectedAfter", type: "Punctuator" };
const LEFT_UNEXPECTED_ERROR = { messageId: "unexpectedAfter", type: "Punctuator" };
const RIGHT_MISSING_ERROR = { messageId: "expectedBefore", type: "Punctuator" };
const RIGHT_UNEXPECTED_ERROR = { messageId: "unexpectedBefore", type: "Punctuator" };
const EXPECTED_BETWEEN = { messageId: "expectedBetween", type: "Identifier" };

const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });

ruleTester.run("function-paren-newline", rule, {

    valid: [

        // multiline option (default)
        "function baz(foo, bar) {}",
        "(function(foo, bar) {});",
        "(function baz(foo, bar) {});",
        "(foo, bar) => {};",
        "foo => {};",
        "baz(foo, bar);",
        "function baz() {}",
        `
            function baz(
                foo,
                bar
            ) {}
        `,
        `
            (function(
                foo,
                bar
            ) {});
        `,
        `
            (function baz(
                foo,
                bar
            ) {});
        `,
        `
            (
                foo,
                bar
            ) => {};
        `,
        `
            baz(
                foo,
                bar
            );
        `,
        `
            baz(\`foo
                bar\`)
        `,
        "new Foo(bar, baz)",
        "new Foo",
        "new (Foo)",

        `
            (foo)
            (bar)
        `,
        `
            foo.map(value => {
              return value;
            })
        `,
        {
            code: "function baz(foo, bar) {}",
            options: ["multiline"]
        },
        {
            code: "import(source)",
            parserOptions: { ecmaVersion: 2020 }
        },
        {
            code: "import(source\n  + ext)",
            parserOptions: { ecmaVersion: 2020 }
        },

        // multiline-arguments
        {
            code: "function baz(foo, bar) {}",
            options: ["multiline-arguments"]
        },
        {
            code: "function baz(foo) {}",
            options: ["multiline-arguments"]
        },
        {
            code: "(function(foo, bar) {});",
            options: ["multiline-arguments"]
        },
        {
            code: "(function(foo) {});",
            options: ["multiline-arguments"]
        },
        {
            code: "(function baz(foo, bar) {});",
            options: ["multiline-arguments"]
        },
        {
            code: "(function baz(foo) {});",
            options: ["multiline-arguments"]
        },
        {
            code: "(foo, bar) => {};",
            options: ["multiline-arguments"]
        },
        {
            code: "foo => {};",
            options: ["multiline-arguments"]
        },
        {
            code: "baz(foo, bar);",
            options: ["multiline-arguments"]
        },
        {
            code: "baz(foo);",
            options: ["multiline-arguments"]
        },
        {
            code: "function baz() {}",
            options: ["multiline-arguments"]
        },
        {
            code: `
                function baz(
                    foo,
                    bar
                ) {}
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                function baz(
                    foo
                ) {}
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                (function(
                    foo,
                    bar
                ) {});
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                (function(
                    foo
                ) {});
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                (function baz(
                    foo,
                    bar
                ) {});
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                (function baz(
                    foo
                ) {});
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                (
                    foo,
                    bar
                ) => {};
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                (
                    foo
                ) => {};
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                baz(
                    foo,
                    bar
                );
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                baz(
                    foo
                );
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                baz(\`foo
                    bar\`)
            `,
            options: ["multiline-arguments"]
        },
        {
            code: "new Foo(bar, baz)",
            options: ["multiline-arguments"]
        },
        {
            code: "new Foo(bar)",
            options: ["multiline-arguments"]
        },
        {
            code: "new Foo",
            options: ["multiline-arguments"]
        },
        {
            code: "new (Foo)",
            options: ["multiline-arguments"]
        },
        {
            code: "import(source)",
            options: ["multiline-arguments"],
            parserOptions: { ecmaVersion: 2020 }
        },
        {
            code: "import(source\n  + ext)",
            options: ["multiline-arguments"],
            parserOptions: { ecmaVersion: 2020 }
        },

        {
            code: `
                (foo)
                (bar)
            `,
            options: ["multiline-arguments"]
        },
        {
            code: `
                foo.map(value => {
                  return value;
                })
            `,
            options: ["multiline-arguments"]
        },

        // always option
        {
            code: `
                function baz(
                    foo,
                    bar
                ) {}
            `,
            options: ["always"]
        },
        {
            code: `
                (function(
                    foo,
                    bar
                ) {});
            `,
            options: ["always"]
        },
        {
            code: `
                (function baz(
                    foo,
                    bar
                ) {});
            `,
            options: ["always"]
        },
        {
            code: `
                (
                    foo,
                    bar
                ) => {};
            `,
            options: ["always"]
        },
        {
            code: `
                baz(
                    foo,
                    bar
                );
            `,
            options: ["always"]
        },
        {
            code: `
                function baz(
                ) {}
            `,
            options: ["always"]
        },
        {
            code: "import(\n  source\n)",
            options: ["always"],
            parserOptions: { ecmaVersion: 2020 }
        },

        // never option
        {
            code: "function baz(foo, bar) {}",
            options: ["never"]
        },
        {
            code: "(function(foo, bar) {});",
            options: ["never"]
        },
        {
            code: "(function baz(foo, bar) {});",
            options: ["never"]
        },
        {
            code: "(foo, bar) => {};",
            options: ["never"]
        },
        {
            code: "baz(foo, bar);",
            options: ["never"]
        },
        {
            code: "function baz() {}",
            options: ["never"]
        },
        {
            code: "import(source)",
            options: ["never"],
            parserOptions: { ecmaVersion: 2020 }
        },

        // minItems option
        {
            code: "function baz(foo, bar) {}",
            options: [{ minItems: 3 }]
        },
        {
            code: `
                function baz(
                    foo, bar, qux
                ) {}
            `,
            options: [{ minItems: 3 }]
        },
        {
            code: `
                baz(
                    foo, bar, qux
                );
            `,
            options: [{ minItems: 3 }]
        },
        {
            code: "baz(foo, bar);",
            options: [{ minItems: 3 }]
        },
        {
            code: "import(source)",
            options: [{ minItems: 3 }],
            parserOptions: { ecmaVersion: 2020 }
        },
        {
            code: "import(\n  source\n)",
            options: [{ minItems: 1 }],
            parserOptions: { ecmaVersion: 2020 }
        },

        // consistent option
        {
            code: "foo(bar, baz)",
            options: ["consistent"]
        },
        {
            code: `
                foo(bar,
                baz)
            `,
            options: ["consistent"]
        },
        {
            code: `
                foo(
                    bar, baz
                )
            `,
            options: ["consistent"]
        },
        {
            code: `
                foo(
                    bar,
                    baz
                )
            `,
            options: ["consistent"]
        },
        {
            code: "import(source)",
            options: ["consistent"],
            parserOptions: { ecmaVersion: 2020 }
        },
        {
            code: "import(\n  source\n)",
            options: ["consistent"],
            parserOptions: { ecmaVersion: 2020 }
        }
    ],

    invalid: [

        // multiline option (default)
        {
            code: `
                function baz(foo,
                    bar
                ) {}
            `,
            output: `
                function baz(\nfoo,
                    bar
                ) {}
            `,
            errors: [LEFT_MISSING_ERROR]
        },
        {
            code: `
                (function(
                    foo,
                    bar) {})
            `,
            output: `
                (function(
                    foo,
                    bar\n) {})
            `,
            errors: [RIGHT_MISSING_ERROR]
        },
        {
            code: `
                (function baz(foo,
                    bar) {})
            `,
            output: `
                (function baz(\nfoo,
                    bar\n) {})
            `,
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: `
                baz(
                    foo, bar);
            `,
            output: `
                baz(foo, bar);
            `,
            errors: [LEFT_UNEXPECTED_ERROR]
        },
        {
            code: `
                (foo, bar
                ) => {};
            `,
            output: `
                (foo, bar) => {};
            `,
            errors: [RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                function baz(
                    foo, bar
                ) {}
            `,
            output: `
                function baz(foo, bar) {}
            `,
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                function baz(
                    foo =
                    1
                ) {}
            `,
            output: `
                function baz(foo =
                    1) {}
            `,
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                function baz(
                ) {}
            `,
            output: `
                function baz() {}
            `,
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                new Foo(bar,
                    baz);
            `,
            output: `
                new Foo(\nbar,
                    baz\n);
            `,
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: `
                function baz(/* not fixed due to comment */
                foo) {}
            `,
            output: null,
            errors: [LEFT_UNEXPECTED_ERROR]
        },
        {
            code: `
                function baz(foo
                /* not fixed due to comment */) {}
            `,
            output: null,
            errors: [RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: "import(\n  source\n)",
            output: "import(source)",
            parserOptions: { ecmaVersion: 2020 },
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },

        // multiline-arguments
        {
            code: `
                function baz(foo,
                    bar
                ) {}
            `,
            output: `
                function baz(\nfoo,
                    bar
                ) {}
            `,
            options: ["multiline-arguments"],
            errors: [LEFT_MISSING_ERROR]
        },
        {
            code: `
                (function(
                    foo,
                    bar) {})
            `,
            output: `
                (function(
                    foo,
                    bar\n) {})
            `,
            options: ["multiline-arguments"],
            errors: [RIGHT_MISSING_ERROR]
        },
        {
            code: `
                (function baz(foo,
                    bar) {})
            `,
            output: `
                (function baz(\nfoo,
                    bar\n) {})
            `,
            options: ["multiline-arguments"],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: `
                baz(
                    foo, bar);
            `,
            output: `
                baz(foo, bar);
            `,
            options: ["multiline-arguments"],
            errors: [LEFT_UNEXPECTED_ERROR]
        },
        {
            code: `
                (foo, bar
                ) => {};
            `,
            output: `
                (foo, bar) => {};
            `,
            options: ["multiline-arguments"],
            errors: [RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                function baz(
                    foo, bar
                ) {}
            `,
            output: `
                function baz(foo, bar) {}
            `,
            options: ["multiline-arguments"],
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                function baz(
                ) {}
            `,
            output: `
                function baz() {}
            `,
            options: ["multiline-arguments"],
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                new Foo(bar,
                    baz);
            `,
            output: `
                new Foo(\nbar,
                    baz\n);
            `,
            options: ["multiline-arguments"],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: `
                function baz(/* not fixed due to comment */
                foo) {}
            `,
            output: `
                function baz(/* not fixed due to comment */
                foo\n) {}
            `,
            options: ["multiline-arguments"],
            errors: [RIGHT_MISSING_ERROR]
        },
        {
            code: `
                function baz(foo
                /* not fixed due to comment */) {}
            `,
            output: null,
            options: ["multiline-arguments"],
            errors: [RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                function baz(
                    qwe,
                    foo, bar
                ) {}
            `,
            output: `
                function baz(
                    qwe,
                    foo, \nbar
                ) {}
            `,
            options: ["multiline-arguments"],
            errors: [EXPECTED_BETWEEN]
        },
        {
            code: `
                function baz(
                    qwe, foo,
                    bar
                ) {}
            `,
            output: `
                function baz(
                    qwe, \nfoo,
                    bar
                ) {}
            `,
            options: ["multiline-arguments"],
            errors: [EXPECTED_BETWEEN]
        },
        {
            code: `
                function baz(qwe, foo,
                    bar) {}
            `,
            output: `
                function baz(\nqwe, \nfoo,
                    bar\n) {}
            `,
            options: ["multiline-arguments"],
            errors: [LEFT_MISSING_ERROR, EXPECTED_BETWEEN, RIGHT_MISSING_ERROR]
        },
        {
            code: `
                baz(
                    foo);
            `,
            output: `
                baz(
                    foo\n);
            `,
            options: ["multiline-arguments"],
            errors: [RIGHT_MISSING_ERROR]
        },
        {
            code: `
                baz(foo
                    );
            `,
            output: `
                baz(foo);
            `,
            options: ["multiline-arguments"],
            errors: [RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: "import(source\n)",
            output: "import(source)",
            options: ["multiline-arguments"],
            parserOptions: { ecmaVersion: 2020 },
            errors: [RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: "import(\n  source)",
            output: "import(\n  source\n)",
            options: ["multiline-arguments"],
            parserOptions: { ecmaVersion: 2020 },
            errors: [RIGHT_MISSING_ERROR]
        },

        // always option
        {
            code: `
                function baz(foo,
                    bar
                ) {}
            `,
            output: `
                function baz(\nfoo,
                    bar
                ) {}
            `,
            options: ["always"],
            errors: [LEFT_MISSING_ERROR]
        },
        {
            code: `
                (function(
                    foo,
                    bar) {})
            `,
            output: `
                (function(
                    foo,
                    bar\n) {})
            `,
            options: ["always"],
            errors: [RIGHT_MISSING_ERROR]
        },
        {
            code: `
                (function baz(foo,
                    bar) {})
            `,
            output: `
                (function baz(\nfoo,
                    bar\n) {})
            `,
            options: ["always"],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: "function baz(foo, bar) {}",
            output: "function baz(\nfoo, bar\n) {}",
            options: ["always"],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: "(function(foo, bar) {});",
            output: "(function(\nfoo, bar\n) {});",
            options: ["always"],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: "(function baz(foo, bar) {});",
            output: "(function baz(\nfoo, bar\n) {});",
            options: ["always"],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: "(foo, bar) => {};",
            output: "(\nfoo, bar\n) => {};",
            options: ["always"],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: "baz(foo, bar);",
            output: "baz(\nfoo, bar\n);",
            options: ["always"],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: "function baz() {}",
            output: "function baz(\n) {}",
            options: ["always"],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: "import(source)",
            output: "import(\nsource\n)",
            options: ["always"],
            parserOptions: { ecmaVersion: 2020 },
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },

        // never option
        {
            code: `
                function baz(foo,
                    bar
                ) {}
            `,
            output: `
                function baz(foo,
                    bar) {}
            `,
            options: ["never"],
            errors: [RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                (function(
                    foo,
                    bar) {})
            `,
            output: `
                (function(foo,
                    bar) {})
            `,
            options: ["never"],
            errors: [LEFT_UNEXPECTED_ERROR]
        },
        {
            code: `
                function baz(
                    foo,
                    bar
                ) {}
            `,
            output: `
                function baz(foo,
                    bar) {}
            `,
            options: ["never"],
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                (function(
                    foo,
                    bar
                ) {});
            `,
            output: `
                (function(foo,
                    bar) {});
            `,
            options: ["never"],
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                (function baz(
                    foo,
                    bar
                ) {});
            `,
            output: `
                (function baz(foo,
                    bar) {});
            `,
            options: ["never"],
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                (
                    foo,
                    bar
                ) => {};
            `,
            output: `
                (foo,
                    bar) => {};
            `,
            options: ["never"],
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                baz(
                    foo,
                    bar
                );
            `,
            output: `
                baz(foo,
                    bar);
            `,
            options: ["never"],
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: `
                function baz(
                ) {}
            `,
            output: `
                function baz() {}
            `,
            options: ["never"],
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: "import(\n  source\n)",
            output: "import(source)",
            options: ["never"],
            parserOptions: { ecmaVersion: 2020 },
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },

        // minItems option
        {
            code: "function baz(foo, bar, qux) {}",
            output: "function baz(\nfoo, bar, qux\n) {}",
            options: [{ minItems: 3 }],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: `
                function baz(
                    foo, bar
                ) {}
            `,
            output: `
                function baz(foo, bar) {}
            `,
            options: [{ minItems: 3 }],
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: "baz(foo, bar, qux);",
            output: "baz(\nfoo, bar, qux\n);",
            options: [{ minItems: 3 }],
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },
        {
            code: `
                baz(
                    foo,
                    bar
                );
            `,
            output: `
                baz(foo,
                    bar);
            `,
            options: [{ minItems: 3 }],
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: "import(\n  source\n)",
            output: "import(source)",
            options: [{ minItems: 3 }],
            parserOptions: { ecmaVersion: 2020 },
            errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: "import(source)",
            output: "import(\nsource\n)",
            options: [{ minItems: 1 }],
            parserOptions: { ecmaVersion: 2020 },
            errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
        },

        // consistent option
        {
            code: `
                foo(
                    bar,
                    baz)
            `,
            output: `
                foo(
                    bar,
                    baz\n)
            `,
            options: ["consistent"],
            errors: [RIGHT_MISSING_ERROR]
        },
        {
            code: `
                foo(bar,
                    baz
                )
            `,
            output: `
                foo(bar,
                    baz)
            `,
            options: ["consistent"],
            errors: [RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: "import(source\n)",
            output: "import(source)",
            options: ["consistent"],
            parserOptions: { ecmaVersion: 2020 },
            errors: [RIGHT_UNEXPECTED_ERROR]
        },
        {
            code: "import(\n  source)",
            output: "import(\n  source\n)",
            options: ["consistent"],
            parserOptions: { ecmaVersion: 2020 },
            errors: [RIGHT_MISSING_ERROR]
        }
    ]
});
Commit	Line	Data
eb39fafa DC	1	/**
	2	* @fileoverview enforce consistent line breaks inside function parentheses
	3	* @author Teddy Katz
	4	*/
	5	"use strict";
	6
	7	//------------------------------------------------------------------------------
	8	// Requirements
	9	//------------------------------------------------------------------------------
	10
	11	const rule = require("../../../lib/rules/function-paren-newline");
	12	const { RuleTester } = require("../../../lib/rule-tester");
	13
	14
	15	//------------------------------------------------------------------------------
	16	// Tests
	17	//------------------------------------------------------------------------------
	18
	19	const LEFT_MISSING_ERROR = { messageId: "expectedAfter", type: "Punctuator" };
	20	const LEFT_UNEXPECTED_ERROR = { messageId: "unexpectedAfter", type: "Punctuator" };
	21	const RIGHT_MISSING_ERROR = { messageId: "expectedBefore", type: "Punctuator" };
	22	const RIGHT_UNEXPECTED_ERROR = { messageId: "unexpectedBefore", type: "Punctuator" };
	23	const EXPECTED_BETWEEN = { messageId: "expectedBetween", type: "Identifier" };
	24
	25	const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
	26
	27	ruleTester.run("function-paren-newline", rule, {
	28
	29	valid: [
	30
	31	// multiline option (default)
	32	"function baz(foo, bar) {}",
	33	"(function(foo, bar) {});",
	34	"(function baz(foo, bar) {});",
	35	"(foo, bar) => {};",
	36	"foo => {};",
	37	"baz(foo, bar);",
	38	"function baz() {}",
	39	`
	40	function baz(
	41	foo,
	42	bar
	43	) {}
	44	`,
	45	`
	46	(function(
	47	foo,
	48	bar
	49	) {});
	50	`,
	51	`
	52	(function baz(
	53	foo,
	54	bar
	55	) {});
	56	`,
	57	`
	58	(
	59	foo,
	60	bar
	61	) => {};
	62	`,
	63	`
	64	baz(
65	foo,
66	bar
67	);
68	`,
69	`
70	baz(\`foo
71	bar\`)
72	`,
73	"new Foo(bar, baz)",
74	"new Foo",
75	"new (Foo)",
76
77	`
78	(foo)
79	(bar)
80	`,
81	`
82	foo.map(value => {
83	return value;
84	})
85	`,
86	{
87	code: "function baz(foo, bar) {}",
88	options: ["multiline"]
89	},
90	{
91	code: "import(source)",
92	parserOptions: { ecmaVersion: 2020 }
93	},
94	{
95	code: "import(source\n + ext)",
96	parserOptions: { ecmaVersion: 2020 }
97	},
98
99	// multiline-arguments
100	{
101	code: "function baz(foo, bar) {}",
102	options: ["multiline-arguments"]
103	},
104	{
105	code: "function baz(foo) {}",
106	options: ["multiline-arguments"]
107	},
108	{
109	code: "(function(foo, bar) {});",
110	options: ["multiline-arguments"]
111	},
112	{
113	code: "(function(foo) {});",
114	options: ["multiline-arguments"]
115	},
116	{
117	code: "(function baz(foo, bar) {});",
118	options: ["multiline-arguments"]
119	},
120	{
121	code: "(function baz(foo) {});",
122	options: ["multiline-arguments"]
123	},
124	{
125	code: "(foo, bar) => {};",
126	options: ["multiline-arguments"]
127	},
128	{
129	code: "foo => {};",
130	options: ["multiline-arguments"]
131	},
132	{
133	code: "baz(foo, bar);",
134	options: ["multiline-arguments"]
135	},
136	{
137	code: "baz(foo);",
138	options: ["multiline-arguments"]
139	},
140	{
141	code: "function baz() {}",
142	options: ["multiline-arguments"]
143	},
144	{
145	code: `
146	function baz(
147	foo,
148	bar
149	) {}
150	`,
151	options: ["multiline-arguments"]
152	},
153	{
154	code: `
155	function baz(
156	foo
157	) {}
158	`,
159	options: ["multiline-arguments"]
160	},
161	{
162	code: `
163	(function(
164	foo,
165	bar
166	) {});
167	`,
168	options: ["multiline-arguments"]
169	},
170	{
171	code: `
172	(function(
173	foo
174	) {});
175	`,
176	options: ["multiline-arguments"]
177	},
178	{
179	code: `
180	(function baz(
181	foo,
182	bar
183	) {});
184	`,
185	options: ["multiline-arguments"]
186	},
187	{
188	code: `
189	(function baz(
190	foo
191	) {});
192	`,
193	options: ["multiline-arguments"]
194	},
195	{
196	code: `
197	(
198	foo,
199	bar
200	) => {};
201	`,
202	options: ["multiline-arguments"]
203	},
204	{
205	code: `
206	(
207	foo
208	) => {};
209	`,
210	options: ["multiline-arguments"]
211	},
212	{
213	code: `
214	baz(
215	foo,
216	bar
217	);
218	`,
219	options: ["multiline-arguments"]
220	},
221	{
222	code: `
223	baz(
224	foo
225	);
226	`,
227	options: ["multiline-arguments"]
228	},
229	{
230	code: `
231	baz(\`foo
232	bar\`)
233	`,
234	options: ["multiline-arguments"]
235	},
236	{
237	code: "new Foo(bar, baz)",
238	options: ["multiline-arguments"]
239	},
240	{
241	code: "new Foo(bar)",
242	options: ["multiline-arguments"]
243	},
244	{
245	code: "new Foo",
246	options: ["multiline-arguments"]
247	},
248	{
249	code: "new (Foo)",
250	options: ["multiline-arguments"]
251	},
252	{
253	code: "import(source)",
254	options: ["multiline-arguments"],
255	parserOptions: { ecmaVersion: 2020 }
256	},
257	{
258	code: "import(source\n + ext)",
259	options: ["multiline-arguments"],
260	parserOptions: { ecmaVersion: 2020 }
261	},
262
263	{
264	code: `
265	(foo)
266	(bar)
267	`,
268	options: ["multiline-arguments"]
269	},
270	{
271	code: `
272	foo.map(value => {
273	return value;
274	})
275	`,
276	options: ["multiline-arguments"]
277	},
278
279	// always option
280	{
281	code: `
282	function baz(
283	foo,
284	bar
285	) {}
286	`,
287	options: ["always"]
288	},
289	{
290	code: `
291	(function(
292	foo,
293	bar
294	) {});
295	`,
296	options: ["always"]
297	},
298	{
299	code: `
300	(function baz(
301	foo,
302	bar
303	) {});
304	`,
305	options: ["always"]
306	},
307	{
308	code: `
309	(
310	foo,
311	bar
312	) => {};
313	`,
314	options: ["always"]
315	},
316	{
317	code: `
318	baz(
319	foo,
320	bar
321	);
322	`,
323	options: ["always"]
324	},
325	{
326	code: `
327	function baz(
328	) {}
329	`,
330	options: ["always"]
331	},
332	{
333	code: "import(\n source\n)",
334	options: ["always"],
335	parserOptions: { ecmaVersion: 2020 }
336	},
337
338	// never option
339	{
340	code: "function baz(foo, bar) {}",
341	options: ["never"]
342	},
343	{
344	code: "(function(foo, bar) {});",
345	options: ["never"]
346	},
347	{
348	code: "(function baz(foo, bar) {});",
349	options: ["never"]
350	},
351	{
352	code: "(foo, bar) => {};",
353	options: ["never"]
354	},
355	{
356	code: "baz(foo, bar);",
357	options: ["never"]
358	},
359	{
360	code: "function baz() {}",
361	options: ["never"]
362	},
363	{
364	code: "import(source)",
365	options: ["never"],
366	parserOptions: { ecmaVersion: 2020 }
367	},
368
369	// minItems option
370	{
371	code: "function baz(foo, bar) {}",
372	options: [{ minItems: 3 }]
373	},
374	{
375	code: `
376	function baz(
377	foo, bar, qux
378	) {}
379	`,
380	options: [{ minItems: 3 }]
381	},
382	{
383	code: `
384	baz(
385	foo, bar, qux
386	);
387	`,
388	options: [{ minItems: 3 }]
389	},
390	{
391	code: "baz(foo, bar);",
392	options: [{ minItems: 3 }]
393	},
394	{
395	code: "import(source)",
396	options: [{ minItems: 3 }],
397	parserOptions: { ecmaVersion: 2020 }
398	},
399	{
400	code: "import(\n source\n)",
401	options: [{ minItems: 1 }],
402	parserOptions: { ecmaVersion: 2020 }
403	},
404
405	// consistent option
406	{
407	code: "foo(bar, baz)",
408	options: ["consistent"]
409	},
410	{
411	code: `
412	foo(bar,
413	baz)
414	`,
415	options: ["consistent"]
416	},
417	{
418	code: `
419	foo(
420	bar, baz
421	)
422	`,
423	options: ["consistent"]
424	},
425	{
426	code: `
427	foo(
428	bar,
429	baz
430	)
431	`,
432	options: ["consistent"]
433	},
434	{
435	code: "import(source)",
436	options: ["consistent"],
437	parserOptions: { ecmaVersion: 2020 }
438	},
439	{
440	code: "import(\n source\n)",
441	options: ["consistent"],
442	parserOptions: { ecmaVersion: 2020 }
443	}
444	],
445
446	invalid: [
447
448	// multiline option (default)
449	{
450	code: `
451	function baz(foo,
452	bar
453	) {}
454	`,
455	output: `
456	function baz(\nfoo,
457	bar
458	) {}
459	`,
460	errors: [LEFT_MISSING_ERROR]
461	},
462	{
463	code: `
464	(function(
465	foo,
466	bar) {})
467	`,
468	output: `
469	(function(
470	foo,
471	bar\n) {})
472	`,
473	errors: [RIGHT_MISSING_ERROR]
474	},
475	{
476	code: `
477	(function baz(foo,
478	bar) {})
479	`,
480	output: `
481	(function baz(\nfoo,
482	bar\n) {})
483	`,
484	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
485	},
486	{
487	code: `
488	baz(
489	foo, bar);
490	`,
491	output: `
492	baz(foo, bar);
493	`,
494	errors: [LEFT_UNEXPECTED_ERROR]
495	},
496	{
497	code: `
498	(foo, bar
499	) => {};
500	`,
501	output: `
502	(foo, bar) => {};
503	`,
504	errors: [RIGHT_UNEXPECTED_ERROR]
505	},
506	{
507	code: `
508	function baz(
509	foo, bar
510	) {}
511	`,
512	output: `
513	function baz(foo, bar) {}
514	`,
515	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
516	},
517	{
518	code: `
519	function baz(
520	foo =
521	1
522	) {}
523	`,
524	output: `
525	function baz(foo =
526	1) {}
527	`,
528	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
529	},
530	{
531	code: `
532	function baz(
533	) {}
534	`,
535	output: `
536	function baz() {}
537	`,
538	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
539	},
540	{
541	code: `
542	new Foo(bar,
543	baz);
544	`,
545	output: `
546	new Foo(\nbar,
547	baz\n);
548	`,
549	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
550	},
551	{
552	code: `
553	function baz(/* not fixed due to comment */
554	foo) {}
555	`,
556	output: null,
557	errors: [LEFT_UNEXPECTED_ERROR]
558	},
559	{
560	code: `
561	function baz(foo
562	/* not fixed due to comment */) {}
563	`,
564	output: null,
565	errors: [RIGHT_UNEXPECTED_ERROR]
566	},
567	{
568	code: "import(\n source\n)",
569	output: "import(source)",
570	parserOptions: { ecmaVersion: 2020 },
571	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
572	},
573
574	// multiline-arguments
575	{
576	code: `
577	function baz(foo,
578	bar
579	) {}
580	`,
581	output: `
582	function baz(\nfoo,
583	bar
584	) {}
585	`,
586	options: ["multiline-arguments"],
587	errors: [LEFT_MISSING_ERROR]
588	},
589	{
590	code: `
591	(function(
592	foo,
593	bar) {})
594	`,
595	output: `
596	(function(
597	foo,
598	bar\n) {})
599	`,
600	options: ["multiline-arguments"],
601	errors: [RIGHT_MISSING_ERROR]
602	},
603	{
604	code: `
605	(function baz(foo,
606	bar) {})
607	`,
608	output: `
609	(function baz(\nfoo,
610	bar\n) {})
611	`,
612	options: ["multiline-arguments"],
613	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
614	},
615	{
616	code: `
617	baz(
618	foo, bar);
619	`,
620	output: `
621	baz(foo, bar);
622	`,
623	options: ["multiline-arguments"],
624	errors: [LEFT_UNEXPECTED_ERROR]
625	},
626	{
627	code: `
628	(foo, bar
629	) => {};
630	`,
631	output: `
632	(foo, bar) => {};
633	`,
634	options: ["multiline-arguments"],
635	errors: [RIGHT_UNEXPECTED_ERROR]
636	},
637	{
638	code: `
639	function baz(
640	foo, bar
641	) {}
642	`,
643	output: `
644	function baz(foo, bar) {}
645	`,
646	options: ["multiline-arguments"],
647	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
648	},
649	{
650	code: `
651	function baz(
652	) {}
653	`,
654	output: `
655	function baz() {}
656	`,
657	options: ["multiline-arguments"],
658	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
659	},
660	{
661	code: `
662	new Foo(bar,
663	baz);
664	`,
665	output: `
666	new Foo(\nbar,
667	baz\n);
668	`,
669	options: ["multiline-arguments"],
670	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
671	},
672	{
673	code: `
674	function baz(/* not fixed due to comment */
675	foo) {}
676	`,
677	output: `
678	function baz(/* not fixed due to comment */
679	foo\n) {}
680	`,
681	options: ["multiline-arguments"],
682	errors: [RIGHT_MISSING_ERROR]
683	},
684	{
685	code: `
686	function baz(foo
687	/* not fixed due to comment */) {}
688	`,
689	output: null,
690	options: ["multiline-arguments"],
691	errors: [RIGHT_UNEXPECTED_ERROR]
692	},
693	{
694	code: `
695	function baz(
696	qwe,
697	foo, bar
698	) {}
699	`,
700	output: `
701	function baz(
702	qwe,
703	foo, \nbar
704	) {}
705	`,
706	options: ["multiline-arguments"],
707	errors: [EXPECTED_BETWEEN]
708	},
709	{
710	code: `
711	function baz(
712	qwe, foo,
713	bar
714	) {}
715	`,
716	output: `
717	function baz(
718	qwe, \nfoo,
719	bar
720	) {}
721	`,
722	options: ["multiline-arguments"],
723	errors: [EXPECTED_BETWEEN]
724	},
725	{
726	code: `
727	function baz(qwe, foo,
728	bar) {}
729	`,
730	output: `
731	function baz(\nqwe, \nfoo,
732	bar\n) {}
733	`,
734	options: ["multiline-arguments"],
735	errors: [LEFT_MISSING_ERROR, EXPECTED_BETWEEN, RIGHT_MISSING_ERROR]
736	},
737	{
738	code: `
739	baz(
740	foo);
741	`,
742	output: `
743	baz(
744	foo\n);
745	`,
746	options: ["multiline-arguments"],
747	errors: [RIGHT_MISSING_ERROR]
748	},
749	{
750	code: `
751	baz(foo
752	);
753	`,
754	output: `
755	baz(foo);
756	`,
757	options: ["multiline-arguments"],
758	errors: [RIGHT_UNEXPECTED_ERROR]
759	},
760	{
761	code: "import(source\n)",
762	output: "import(source)",
763	options: ["multiline-arguments"],
764	parserOptions: { ecmaVersion: 2020 },
765	errors: [RIGHT_UNEXPECTED_ERROR]
766	},
767	{
768	code: "import(\n source)",
769	output: "import(\n source\n)",
770	options: ["multiline-arguments"],
771	parserOptions: { ecmaVersion: 2020 },
772	errors: [RIGHT_MISSING_ERROR]
773	},
774
775	// always option
776	{
777	code: `
778	function baz(foo,
779	bar
780	) {}
781	`,
782	output: `
783	function baz(\nfoo,
784	bar
785	) {}
786	`,
787	options: ["always"],
788	errors: [LEFT_MISSING_ERROR]
789	},
790	{
791	code: `
792	(function(
793	foo,
794	bar) {})
795	`,
796	output: `
797	(function(
798	foo,
799	bar\n) {})
800	`,
801	options: ["always"],
802	errors: [RIGHT_MISSING_ERROR]
803	},
804	{
805	code: `
806	(function baz(foo,
807	bar) {})
808	`,
809	output: `
810	(function baz(\nfoo,
811	bar\n) {})
812	`,
813	options: ["always"],
814	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
815	},
816	{
817	code: "function baz(foo, bar) {}",
818	output: "function baz(\nfoo, bar\n) {}",
819	options: ["always"],
820	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
821	},
822	{
823	code: "(function(foo, bar) {});",
824	output: "(function(\nfoo, bar\n) {});",
825	options: ["always"],
826	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
827	},
828	{
829	code: "(function baz(foo, bar) {});",
830	output: "(function baz(\nfoo, bar\n) {});",
831	options: ["always"],
832	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
833	},
834	{
835	code: "(foo, bar) => {};",
836	output: "(\nfoo, bar\n) => {};",
837	options: ["always"],
838	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
839	},
840	{
841	code: "baz(foo, bar);",
842	output: "baz(\nfoo, bar\n);",
843	options: ["always"],
844	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
845	},
846	{
847	code: "function baz() {}",
848	output: "function baz(\n) {}",
849	options: ["always"],
850	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
851	},
852	{
853	code: "import(source)",
854	output: "import(\nsource\n)",
855	options: ["always"],
856	parserOptions: { ecmaVersion: 2020 },
857	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
858	},
859
860	// never option
861	{
862	code: `
863	function baz(foo,
864	bar
865	) {}
866	`,
867	output: `
868	function baz(foo,
869	bar) {}
870	`,
871	options: ["never"],
872	errors: [RIGHT_UNEXPECTED_ERROR]
873	},
874	{
875	code: `
876	(function(
877	foo,
878	bar) {})
879	`,
880	output: `
881	(function(foo,
882	bar) {})
883	`,
884	options: ["never"],
885	errors: [LEFT_UNEXPECTED_ERROR]
886	},
887	{
888	code: `
889	function baz(
890	foo,
891	bar
892	) {}
893	`,
894	output: `
895	function baz(foo,
896	bar) {}
897	`,
898	options: ["never"],
899	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
900	},
901	{
902	code: `
903	(function(
904	foo,
905	bar
906	) {});
907	`,
908	output: `
909	(function(foo,
910	bar) {});
911	`,
912	options: ["never"],
913	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
914	},
915	{
916	code: `
917	(function baz(
918	foo,
919	bar
920	) {});
921	`,
922	output: `
923	(function baz(foo,
924	bar) {});
925	`,
926	options: ["never"],
927	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
928	},
929	{
930	code: `
931	(
932	foo,
933	bar
934	) => {};
935	`,
936	output: `
937	(foo,
938	bar) => {};
939	`,
940	options: ["never"],
941	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
942	},
943	{
944	code: `
945	baz(
946	foo,
947	bar
948	);
949	`,
950	output: `
951	baz(foo,
952	bar);
953	`,
954	options: ["never"],
955	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
956	},
957	{
958	code: `
959	function baz(
960	) {}
961	`,
962	output: `
963	function baz() {}
964	`,
965	options: ["never"],
966	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
967	},
968	{
969	code: "import(\n source\n)",
970	output: "import(source)",
971	options: ["never"],
972	parserOptions: { ecmaVersion: 2020 },
973	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
974	},
975
976	// minItems option
977	{
978	code: "function baz(foo, bar, qux) {}",
979	output: "function baz(\nfoo, bar, qux\n) {}",
980	options: [{ minItems: 3 }],
981	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
982	},
983	{
984	code: `
985	function baz(
986	foo, bar
987	) {}
988	`,
989	output: `
990	function baz(foo, bar) {}
991	`,
992	options: [{ minItems: 3 }],
993	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
994	},
995	{
996	code: "baz(foo, bar, qux);",
997	output: "baz(\nfoo, bar, qux\n);",
998	options: [{ minItems: 3 }],
999	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
1000	},
1001	{
1002	code: `
1003	baz(
1004	foo,
1005	bar
1006	);
1007	`,
1008	output: `
1009	baz(foo,
1010	bar);
1011	`,
1012	options: [{ minItems: 3 }],
1013	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
1014	},
1015	{
1016	code: "import(\n source\n)",
1017	output: "import(source)",
1018	options: [{ minItems: 3 }],
1019	parserOptions: { ecmaVersion: 2020 },
1020	errors: [LEFT_UNEXPECTED_ERROR, RIGHT_UNEXPECTED_ERROR]
1021	},
1022	{
1023	code: "import(source)",
1024	output: "import(\nsource\n)",
1025	options: [{ minItems: 1 }],
1026	parserOptions: { ecmaVersion: 2020 },
1027	errors: [LEFT_MISSING_ERROR, RIGHT_MISSING_ERROR]
1028	},
1029
1030	// consistent option
1031	{
1032	code: `
1033	foo(
1034	bar,
1035	baz)
1036	`,
1037	output: `
1038	foo(
1039	bar,
1040	baz\n)
1041	`,
1042	options: ["consistent"],
1043	errors: [RIGHT_MISSING_ERROR]
1044	},
1045	{
1046	code: `
1047	foo(bar,
1048	baz
1049	)
1050	`,
1051	output: `
1052	foo(bar,
1053	baz)
1054	`,
1055	options: ["consistent"],
1056	errors: [RIGHT_UNEXPECTED_ERROR]
1057	},
1058	{
1059	code: "import(source\n)",
1060	output: "import(source)",
1061	options: ["consistent"],
1062	parserOptions: { ecmaVersion: 2020 },
1063	errors: [RIGHT_UNEXPECTED_ERROR]
1064	},
1065	{
1066	code: "import(\n source)",
1067	output: "import(\n source\n)",
1068	options: ["consistent"],
1069	parserOptions: { ecmaVersion: 2020 },
1070	errors: [RIGHT_MISSING_ERROR]
1071	}
1072	]
1073	});