[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: [["&&", "||", "?:"]] }]
        },
        "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: "&&"
                    }
                }
            ]
        }
    ]
});
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	},
	55	{
	56	code: "a \|\| (b ? c : d)",
	57	options: [{ groups: [["&&", "\|\|", "?:"]] }]
	58	},
	59	"a \|\| (b ? c : d)",
	60	"(a \|\| b) ? c : d",
	61	"a \|\| b ? c : d"
	62	],
	63	invalid: [
	64	{
65	code: "a && b \|\| c",
66	errors: [
67	{
68	column: 3,
69	endColumn: 5,
70	messageId: "unexpectedMixedOperator",
71	data: {
72	leftOperator: "&&",
73	rightOperator: "\|\|"
74	}
75	},
76	{
77	column: 8,
78	endColumn: 10,
79	messageId: "unexpectedMixedOperator",
80	data: {
81	leftOperator: "&&",
82	rightOperator: "\|\|"
83	}
84	}
85	]
86	},
87	{
88	code: "a && b > 0 \|\| c",
89	options: [{ groups: [["&&", "\|\|", ">"]] }],
90	errors: [
91	{
92	column: 3,
93	messageId: "unexpectedMixedOperator",
94	data: {
95	leftOperator: "&&",
96	rightOperator: "\|\|"
97	}
98	},
99	{
100	column: 3,
101	messageId: "unexpectedMixedOperator",
102	data: {
103	leftOperator: "&&",
104	rightOperator: ">"
105	}
106	},
107	{
108	column: 8,
109	messageId: "unexpectedMixedOperator",
110	data: {
111	leftOperator: "&&",
112	rightOperator: ">"
113	}
114	},
115	{
116	column: 12,
117	messageId: "unexpectedMixedOperator",
118	data: {
119	leftOperator: "&&",
120	rightOperator: "\|\|"
121	}
122	}
123	]
124	},
125	{
126	code: "a && b > 0 \|\| c",
127	options: [{ groups: [["&&", "\|\|"]] }],
128	errors: [
129	{
130	column: 3,
131	messageId: "unexpectedMixedOperator",
132	data: {
133	leftOperator: "&&",
134	rightOperator: "\|\|"
135	}
136	},
137	{
138	column: 12,
139	messageId: "unexpectedMixedOperator",
140	data: {
141	leftOperator: "&&",
142	rightOperator: "\|\|"
143	}
144	}
145	]
146	},
147	{
148	code: "a && b + c - d / e \|\| f",
149	options: [{ groups: [["&&", "\|\|"], ["+", "-", "*", "/"]] }],
150	errors: [
151	{
152	column: 3,
153	messageId: "unexpectedMixedOperator",
154	data: {
155	leftOperator: "&&",
156	rightOperator: "\|\|"
157	}
158	},
159	{
160	column: 12,
161	messageId: "unexpectedMixedOperator",
162	data: {
163	leftOperator: "-",
164	rightOperator: "/"
165	}
166	},
167	{
168	column: 16,
169	messageId: "unexpectedMixedOperator",
170	data: {
171	leftOperator: "-",
172	rightOperator: "/"
173	}
174	},
175	{
176	column: 20,
177	messageId: "unexpectedMixedOperator",
178	data: {
179	leftOperator: "&&",
180	rightOperator: "\|\|"
181	}
182	}
183	]
184	},
185	{
186	code: "a && b + c - d / e \|\| f",
187	options: [{ groups: [["&&", "\|\|"], ["+", "-", "*", "/"]], allowSamePrecedence: true }],
188	errors: [
189	{
190	column: 3,
191	messageId: "unexpectedMixedOperator",
192	data: {
193	leftOperator: "&&",
194	rightOperator: "\|\|"
195	}
196	},
197	{
198	column: 12,
199	messageId: "unexpectedMixedOperator",
200	data: {
201	leftOperator: "-",
202	rightOperator: "/"
203	}
204	},
205	{
206	column: 16,
207	messageId: "unexpectedMixedOperator",
208	data: {
209	leftOperator: "-",
210	rightOperator: "/"
211	}
212	},
213	{
214	column: 20,
215	messageId: "unexpectedMixedOperator",
216	data: {
217	leftOperator: "&&",
218	rightOperator: "\|\|"
219	}
220	}
221	]
222	},
223	{
224	code: "a + b - c",
225	options: [{ allowSamePrecedence: false }],
226	errors: [
227	{
228	column: 3,
229	endColumn: 4,
230	messageId: "unexpectedMixedOperator",
231	data: {
232	leftOperator: "+",
233	rightOperator: "-"
234	}
235	},
236	{
237	column: 7,
238	endColumn: 8,
239	messageId: "unexpectedMixedOperator",
240	data: {
241	leftOperator: "+",
242	rightOperator: "-"
243	}
244	}
245	]
246	},
247	{
248	code: "a * b / c",
249	options: [{ allowSamePrecedence: false }],
250	errors: [
251	{
252	column: 3,
253	endColumn: 4,
254	messageId: "unexpectedMixedOperator",
255	data: {
256	leftOperator: "*",
257	rightOperator: "/"
258	}
259	},
260	{
261	column: 7,
262	endColumn: 8,
263	messageId: "unexpectedMixedOperator",
264	data: {
265	leftOperator: "*",
266	rightOperator: "/"
267	}
268	}
269	]
270	},
271	{
272	code: "a \|\| b ? c : d",
273	options: [{ groups: [["&&", "\|\|", "?:"]] }],
274	errors: [
275	{
276	column: 3,
277	endColumn: 5,
278	messageId: "unexpectedMixedOperator",
279	data: {
280	leftOperator: "\|\|",
281	rightOperator: "?:"
282	}
283	},
284	{
285	column: 8,
286	endColumn: 9,
287	messageId: "unexpectedMixedOperator",
288	data: {
289	leftOperator: "\|\|",
290	rightOperator: "?:"
291	}
292	}
293	]
294	},
295	{
296	code: "a && b ? 1 : 2",
297	options: [{ groups: [["&&", "\|\|", "?:"]] }],
298	errors: [
299	{
300	column: 3,
301	endColumn: 5,
302	messageId: "unexpectedMixedOperator",
303	data: {
304	leftOperator: "&&",
305	rightOperator: "?:"
306	}
307	},
308	{
309	column: 8,
310	endColumn: 9,
311	messageId: "unexpectedMixedOperator",
312	data: {
313	leftOperator: "&&",
314	rightOperator: "?:"
315	}
316	}
317	]
318	},
319	{
320	code: "x ? a && b : 0",
321	options: [{ groups: [["&&", "\|\|", "?:"]] }],
322	errors: [
323	{
324	column: 3,
325	endColumn: 4,
326	messageId: "unexpectedMixedOperator",
327	data: {
328	leftOperator: "?:",
329	rightOperator: "&&"
330	}
331	},
332	{
333	column: 7,
334	endColumn: 9,
335	messageId: "unexpectedMixedOperator",
336	data: {
337	leftOperator: "?:",
338	rightOperator: "&&"
339	}
340	}
341	]
342	},
343	{
344	code: "x ? 0 : a && b",
345	options: [{ groups: [["&&", "\|\|", "?:"]] }],
346	errors: [
347	{
348	column: 3,
349	endColumn: 4,
350	messageId: "unexpectedMixedOperator",
351	data: {
352	leftOperator: "?:",
353	rightOperator: "&&"
354	}
355	},
356	{
357	column: 11,
358	endColumn: 13,
359	messageId: "unexpectedMixedOperator",
360	data: {
361	leftOperator: "?:",
362	rightOperator: "&&"
363	}
364	}
365	]
366	}
367	]
368	});