[pve-eslint.git] / eslint / tests / lib / rules / no-mixed-operators.js

/**
 * @fileoverview Tests for no-mixed-operators rule.
 * @author Toru Nagashima
 */

"use strict";

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

const rule = require("../../../lib/rules/no-mixed-operators"),
    { RuleTester } = require("../../../lib/rule-tester");

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

const ruleTester = new RuleTester();

ruleTester.run("no-mixed-operators", rule, {
    valid: [
        "a && b && c && d",
        "a || b || c || d",
        "(a || b) && c && d",
        "a || (b && c && d)",
        "(a || b || c) && d",
        "a || b || (c && d)",
        "a + b + c + d",
        "a * b * c * d",
        "a == 0 && b == 1",
        "a == 0 || b == 1",
        {
            code: "(a == 0) && (b == 1)",
            options: [{ groups: [["&&", "=="]] }]
        },
        {
            code: "a + b - c * d / e",
            options: [{ groups: [["&&", "||"]] }]
        },
        "a + b - c",
        "a * b / c",
        {
            code: "a + b - c",
            options: [{ allowSamePrecedence: true }]
        },
        {
            code: "a * b / c",
            options: [{ allowSamePrecedence: true }]
        },
        {
            code: "(a || b) ? c : d",
            options: [{ groups: [["&&", "||", "?:"]] }]
        },
        {
            code: "a ? (b || c) : d",
            options: [{ groups: [["&&", "||", "?:"]] }]
        },
        {
            code: "a ? b : (c || d)",
            options: [{ groups: [["&&", "||", "?:"]] }]
        },
        {
            code: "a || (b ? c : d)",
            options: [{ groups: [["&&", "||", "?:"]] }]
        },
        {
            code: "(a ? b : c) || d",
            options: [{ groups: [["&&", "||", "?:"]] }]
        },
        "a || (b ? c : d)",
        "(a || b) ? c : d",
        "a || b ? c : d",
        "a ? (b || c) : d",
        "a ? b || c : d",
        "a ? b : (c || d)",
        "a ? b : c || d"
    ],
    invalid: [
        {
            code: "a && b || c",
            errors: [
                {
                    column: 3,
                    endColumn: 5,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "||"
                    }
                },
                {
                    column: 8,
                    endColumn: 10,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "||"
                    }
                }
            ]
        },
        {
            code: "a && b > 0 || c",
            options: [{ groups: [["&&", "||", ">"]] }],
            errors: [
                {
                    column: 3,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "||"
                    }
                },
                {
                    column: 3,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: ">"
                    }
                },
                {
                    column: 8,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: ">"
                    }
                },
                {
                    column: 12,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "||"
                    }
                }
            ]
        },
        {
            code: "a && b > 0 || c",
            options: [{ groups: [["&&", "||"]] }],
            errors: [
                {
                    column: 3,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "||"
                    }
                },
                {
                    column: 12,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "||"
                    }
                }
            ]
        },
        {
            code: "a && b + c - d / e || f",
            options: [{ groups: [["&&", "||"], ["+", "-", "*", "/"]] }],
            errors: [
                {
                    column: 3,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "||"
                    }
                },
                {
                    column: 12,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "-",
                        rightOperator: "/"
                    }
                },
                {
                    column: 16,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "-",
                        rightOperator: "/"
                    }
                },
                {
                    column: 20,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "||"
                    }
                }
            ]
        },
        {
            code: "a && b + c - d / e || f",
            options: [{ groups: [["&&", "||"], ["+", "-", "*", "/"]], allowSamePrecedence: true }],
            errors: [
                {
                    column: 3,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "||"
                    }
                },
                {
                    column: 12,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "-",
                        rightOperator: "/"
                    }
                },
                {
                    column: 16,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "-",
                        rightOperator: "/"
                    }
                },
                {
                    column: 20,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "||"
                    }
                }
            ]
        },
        {
            code: "a + b - c",
            options: [{ allowSamePrecedence: false }],
            errors: [
                {
                    column: 3,
                    endColumn: 4,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "+",
                        rightOperator: "-"
                    }
                },
                {
                    column: 7,
                    endColumn: 8,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "+",
                        rightOperator: "-"
                    }
                }
            ]
        },
        {
            code: "a * b / c",
            options: [{ allowSamePrecedence: false }],
            errors: [
                {
                    column: 3,
                    endColumn: 4,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "*",
                        rightOperator: "/"
                    }
                },
                {
                    column: 7,
                    endColumn: 8,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "*",
                        rightOperator: "/"
                    }
                }
            ]
        },
        {
            code: "a || b ? c : d",
            options: [{ groups: [["&&", "||", "?:"]] }],
            errors: [
                {
                    column: 3,
                    endColumn: 5,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "||",
                        rightOperator: "?:"
                    }
                },
                {
                    column: 8,
                    endColumn: 9,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "||",
                        rightOperator: "?:"
                    }
                }
            ]
        },
        {
            code: "a && b ? 1 : 2",
            options: [{ groups: [["&&", "||", "?:"]] }],
            errors: [
                {
                    column: 3,
                    endColumn: 5,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "?:"
                    }
                },
                {
                    column: 8,
                    endColumn: 9,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "&&",
                        rightOperator: "?:"
                    }
                }
            ]
        },
        {
            code: "x ? a && b : 0",
            options: [{ groups: [["&&", "||", "?:"]] }],
            errors: [
                {
                    column: 3,
                    endColumn: 4,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "?:",
                        rightOperator: "&&"
                    }
                },
                {
                    column: 7,
                    endColumn: 9,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "?:",
                        rightOperator: "&&"
                    }
                }
            ]
        },
        {
            code: "x ? 0 : a && b",
            options: [{ groups: [["&&", "||", "?:"]] }],
            errors: [
                {
                    column: 3,
                    endColumn: 4,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "?:",
                        rightOperator: "&&"
                    }
                },
                {
                    column: 11,
                    endColumn: 13,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "?:",
                        rightOperator: "&&"
                    }
                }
            ]
        },
        {
            code: "a + b ?? c",
            options: [{ groups: [["+", "??"]] }],
            parserOptions: { ecmaVersion: 2020 },
            errors: [
                {
                    column: 3,
                    endColumn: 4,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "+",
                        rightOperator: "??"
                    }
                },
                {
                    column: 7,
                    endColumn: 9,
                    messageId: "unexpectedMixedOperator",
                    data: {
                        leftOperator: "+",
                        rightOperator: "??"
                    }
                }
            ]
        }
    ]
});
Commit	Line	Data
eb39fafa DC	1	/**
	2	* @fileoverview Tests for no-mixed-operators rule.
	3	* @author Toru Nagashima
	4	*/
	5
	6	"use strict";
	7
	8	//------------------------------------------------------------------------------
	9	// Requirements
	10	//------------------------------------------------------------------------------
	11
	12	const rule = require("../../../lib/rules/no-mixed-operators"),
	13	{ RuleTester } = require("../../../lib/rule-tester");
	14
	15	//------------------------------------------------------------------------------
	16	// Tests
	17	//------------------------------------------------------------------------------
	18
	19	const ruleTester = new RuleTester();
	20
	21	ruleTester.run("no-mixed-operators", rule, {
	22	valid: [
	23	"a && b && c && d",
	24	"a \|\| b \|\| c \|\| d",
	25	"(a \|\| b) && c && d",
	26	"a \|\| (b && c && d)",
	27	"(a \|\| b \|\| c) && d",
	28	"a \|\| b \|\| (c && d)",
	29	"a + b + c + d",
	30	"a * b * c * d",
	31	"a == 0 && b == 1",
	32	"a == 0 \|\| b == 1",
	33	{
	34	code: "(a == 0) && (b == 1)",
	35	options: [{ groups: [["&&", "=="]] }]
	36	},
	37	{
	38	code: "a + b - c * d / e",
	39	options: [{ groups: [["&&", "\|\|"]] }]
	40	},
	41	"a + b - c",
	42	"a * b / c",
	43	{
	44	code: "a + b - c",
	45	options: [{ allowSamePrecedence: true }]
	46	},
	47	{
	48	code: "a * b / c",
	49	options: [{ allowSamePrecedence: true }]
	50	},
	51	{
	52	code: "(a \|\| b) ? c : d",
	53	options: [{ groups: [["&&", "\|\|", "?:"]] }]
	54	},
5422a9cc TL	55	{
	56	code: "a ? (b \|\| c) : d",
	57	options: [{ groups: [["&&", "\|\|", "?:"]] }]
	58	},
	59	{
	60	code: "a ? b : (c \|\| d)",
	61	options: [{ groups: [["&&", "\|\|", "?:"]] }]
	62	},
eb39fafa DC	63	{
	64	code: "a \|\| (b ? c : d)",
	65	options: [{ groups: [["&&", "\|\|", "?:"]] }]
	66	},
5422a9cc TL	67	{
	68	code: "(a ? b : c) \|\| d",
	69	options: [{ groups: [["&&", "\|\|", "?:"]] }]
	70	},
eb39fafa DC	71	"a \|\| (b ? c : d)",
eb39fafa DC	72	"(a \|\| b) ? c : d",
5422a9cc TL	73	"a \|\| b ? c : d",
	74	"a ? (b \|\| c) : d",
	75	"a ? b \|\| c : d",
	76	"a ? b : (c \|\| d)",
	77	"a ? b : c \|\| d"
eb39fafa DC	78	],
	79	invalid: [
	80	{
	81	code: "a && b \|\| c",
	82	errors: [
	83	{
	84	column: 3,
	85	endColumn: 5,
	86	messageId: "unexpectedMixedOperator",
	87	data: {
	88	leftOperator: "&&",
	89	rightOperator: "\|\|"
	90	}
	91	},
	92	{
	93	column: 8,
	94	endColumn: 10,
	95	messageId: "unexpectedMixedOperator",
	96	data: {
	97	leftOperator: "&&",
	98	rightOperator: "\|\|"
	99	}
	100	}
	101	]
	102	},
	103	{
	104	code: "a && b > 0 \|\| c",
	105	options: [{ groups: [["&&", "\|\|", ">"]] }],
	106	errors: [
	107	{
	108	column: 3,
	109	messageId: "unexpectedMixedOperator",
	110	data: {
	111	leftOperator: "&&",
	112	rightOperator: "\|\|"
	113	}
	114	},
	115	{
	116	column: 3,
	117	messageId: "unexpectedMixedOperator",
	118	data: {
	119	leftOperator: "&&",
	120	rightOperator: ">"
	121	}
	122	},
	123	{
	124	column: 8,
	125	messageId: "unexpectedMixedOperator",
	126	data: {
	127	leftOperator: "&&",
	128	rightOperator: ">"
	129	}
	130	},
	131	{
	132	column: 12,
	133	messageId: "unexpectedMixedOperator",
	134	data: {
	135	leftOperator: "&&",
	136	rightOperator: "\|\|"
	137	}
	138	}
	139	]
	140	},
	141	{
142	code: "a && b > 0 \|\| c",
143	options: [{ groups: [["&&", "\|\|"]] }],
144	errors: [
145	{
146	column: 3,
147	messageId: "unexpectedMixedOperator",
148	data: {
149	leftOperator: "&&",
150	rightOperator: "\|\|"
151	}
152	},
153	{
154	column: 12,
155	messageId: "unexpectedMixedOperator",
156	data: {
157	leftOperator: "&&",
158	rightOperator: "\|\|"
159	}
160	}
161	]
162	},
163	{
164	code: "a && b + c - d / e \|\| f",
165	options: [{ groups: [["&&", "\|\|"], ["+", "-", "*", "/"]] }],
166	errors: [
167	{
168	column: 3,
169	messageId: "unexpectedMixedOperator",
170	data: {
171	leftOperator: "&&",
172	rightOperator: "\|\|"
173	}
174	},
175	{
176	column: 12,
177	messageId: "unexpectedMixedOperator",
178	data: {
179	leftOperator: "-",
180	rightOperator: "/"
181	}
182	},
183	{
184	column: 16,
185	messageId: "unexpectedMixedOperator",
186	data: {
187	leftOperator: "-",
188	rightOperator: "/"
189	}
190	},
191	{
192	column: 20,
193	messageId: "unexpectedMixedOperator",
194	data: {
195	leftOperator: "&&",
196	rightOperator: "\|\|"
197	}
198	}
199	]
200	},
201	{
202	code: "a && b + c - d / e \|\| f",
203	options: [{ groups: [["&&", "\|\|"], ["+", "-", "*", "/"]], allowSamePrecedence: true }],
204	errors: [
205	{
206	column: 3,
207	messageId: "unexpectedMixedOperator",
208	data: {
209	leftOperator: "&&",
210	rightOperator: "\|\|"
211	}
212	},
213	{
214	column: 12,
215	messageId: "unexpectedMixedOperator",
216	data: {
217	leftOperator: "-",
218	rightOperator: "/"
219	}
220	},
221	{
222	column: 16,
223	messageId: "unexpectedMixedOperator",
224	data: {
225	leftOperator: "-",
226	rightOperator: "/"
227	}
228	},
229	{
230	column: 20,
231	messageId: "unexpectedMixedOperator",
232	data: {
233	leftOperator: "&&",
234	rightOperator: "\|\|"
235	}
236	}
237	]
238	},
239	{
240	code: "a + b - c",
241	options: [{ allowSamePrecedence: false }],
242	errors: [
243	{
244	column: 3,
245	endColumn: 4,
246	messageId: "unexpectedMixedOperator",
247	data: {
248	leftOperator: "+",
249	rightOperator: "-"
250	}
251	},
252	{
253	column: 7,
254	endColumn: 8,
255	messageId: "unexpectedMixedOperator",
256	data: {
257	leftOperator: "+",
258	rightOperator: "-"
259	}
260	}
261	]
262	},
263	{
264	code: "a * b / c",
265	options: [{ allowSamePrecedence: false }],
266	errors: [
267	{
268	column: 3,
269	endColumn: 4,
270	messageId: "unexpectedMixedOperator",
271	data: {
272	leftOperator: "*",
273	rightOperator: "/"
274	}
275	},
276	{
277	column: 7,
278	endColumn: 8,
279	messageId: "unexpectedMixedOperator",
280	data: {
281	leftOperator: "*",
282	rightOperator: "/"
283	}
284	}
285	]
286	},
287	{
288	code: "a \|\| b ? c : d",
289	options: [{ groups: [["&&", "\|\|", "?:"]] }],
290	errors: [
291	{
292	column: 3,
293	endColumn: 5,
294	messageId: "unexpectedMixedOperator",
295	data: {
296	leftOperator: "\|\|",
297	rightOperator: "?:"
298	}
299	},
300	{
301	column: 8,
302	endColumn: 9,
303	messageId: "unexpectedMixedOperator",
304	data: {
305	leftOperator: "\|\|",
306	rightOperator: "?:"
307	}
308	}
309	]
310	},
311	{
312	code: "a && b ? 1 : 2",
313	options: [{ groups: [["&&", "\|\|", "?:"]] }],
314	errors: [
315	{
316	column: 3,
317	endColumn: 5,
318	messageId: "unexpectedMixedOperator",
319	data: {
320	leftOperator: "&&",
321	rightOperator: "?:"
322	}
323	},
324	{
325	column: 8,
326	endColumn: 9,
327	messageId: "unexpectedMixedOperator",
328	data: {
329	leftOperator: "&&",
330	rightOperator: "?:"
331	}
332	}
333	]
334	},
335	{
336	code: "x ? a && b : 0",
337	options: [{ groups: [["&&", "\|\|", "?:"]] }],
338	errors: [
339	{
340	column: 3,
341	endColumn: 4,
342	messageId: "unexpectedMixedOperator",
343	data: {
344	leftOperator: "?:",
345	rightOperator: "&&"
346	}
347	},
348	{
349	column: 7,
350	endColumn: 9,
351	messageId: "unexpectedMixedOperator",
352	data: {
353	leftOperator: "?:",
354	rightOperator: "&&"
355	}
356	}
357	]
358	},
359	{
360	code: "x ? 0 : a && b",
361	options: [{ groups: [["&&", "\|\|", "?:"]] }],
362	errors: [
363	{
364	column: 3,
365	endColumn: 4,
366	messageId: "unexpectedMixedOperator",
367	data: {
368	leftOperator: "?:",
369	rightOperator: "&&"
370	}
371	},
372	{
373	column: 11,
374	endColumn: 13,
375	messageId: "unexpectedMixedOperator",
376	data: {
377	leftOperator: "?:",
378	rightOperator: "&&"
379	}
380	}
381	]
d3726936 TL	382	},
	383	{
	384	code: "a + b ?? c",
	385	options: [{ groups: [["+", "??"]] }],
	386	parserOptions: { ecmaVersion: 2020 },
	387	errors: [
	388	{
	389	column: 3,
	390	endColumn: 4,
	391	messageId: "unexpectedMixedOperator",
	392	data: {
	393	leftOperator: "+",
	394	rightOperator: "??"
	395	}
	396	},
	397	{
	398	column: 7,
	399	endColumn: 9,
	400	messageId: "unexpectedMixedOperator",
	401	data: {
	402	leftOperator: "+",
	403	rightOperator: "??"
	404	}
	405	}
	406	]
eb39fafa DC	407	}
	408	]
	409	});