function testInvalidTemplate(item) {
			assert.ok(
				typeof item.code === "string",
				"Test case must specify a string value for 'code'",
			);
			if (item.name) {
				assert.ok(
					typeof item.name === "string",
					"Optional test case property 'name' must be a string",
				);
			}
			assert.ok(
				item.errors || item.errors === 0,
				`Did not specify errors for an invalid test of ${ruleName}`,
			);

			if (Array.isArray(item.errors) && item.errors.length === 0) {
				assert.fail("Invalid cases must have at least one error");
			}

			checkDuplicateTestCase(item, seenInvalidTestCases);

			const ruleHasMetaMessages =
				hasOwnProperty(rule, "meta") &&
				hasOwnProperty(rule.meta, "messages");
			const friendlyIDList = ruleHasMetaMessages
				? `[${Object.keys(rule.meta.messages)
						.map(key => `'${key}'`)
						.join(", ")}]`
				: null;

			const result = runRuleForItem(item);
			const messages = result.messages;

			for (const message of messages) {
				if (hasOwnProperty(message, "suggestions")) {
					/** @type {Map<string, number>} */
					const seenMessageIndices = new Map();

					for (let i = 0; i < message.suggestions.length; i += 1) {
						const suggestionMessage = message.suggestions[i].desc;
						const previous =
							seenMessageIndices.get(suggestionMessage);

						assert.ok(
							!seenMessageIndices.has(suggestionMessage),
							`Suggestion message '${suggestionMessage}' reported from suggestion ${i} was previously reported by suggestion ${previous}. Suggestion messages should be unique within an error.`,
						);
						seenMessageIndices.set(suggestionMessage, i);
					}
				}
			}

			if (typeof item.errors === "number") {
				if (item.errors === 0) {
					assert.fail(
						"Invalid cases must have 'error' value greater than 0",
					);
				}

				assert.strictEqual(
					messages.length,
					item.errors,
					util.format(
						"Should have %d error%s but had %d: %s",
						item.errors,
						item.errors === 1 ? "" : "s",
						messages.length,
						util.inspect(messages),
					),
				);
			} else {
				assert.strictEqual(
					messages.length,
					item.errors.length,
					util.format(
						"Should have %d error%s but had %d: %s",
						item.errors.length,
						item.errors.length === 1 ? "" : "s",
						messages.length,
						util.inspect(messages),
					),
				);

				const hasMessageOfThisRule = messages.some(
					m => m.ruleId === ruleId,
				);

				for (let i = 0, l = item.errors.length; i < l; i++) {
					const error = item.errors[i];
					const message = messages[i];

					assert(
						hasMessageOfThisRule,
						"Error rule name should be the same as the name of the rule being tested",
					);

					if (typeof error === "string" || error instanceof RegExp) {
						// Just an error message.
						assertMessageMatches(message.message, error);
						assert.ok(
							message.suggestions === void 0,
							`Error at index ${i} has suggestions. Please convert the test error into an object and specify 'suggestions' property on it to test suggestions.`,
						);
					} else if (typeof error === "object" && error !== null) {
						/*
						 * Error object.
						 * This may have a message, messageId, data, node type, line, and/or
						 * column.
						 */

						Object.keys(error).forEach(propertyName => {
							assert.ok(
								errorObjectParameters.has(propertyName),
								`Invalid error property name '${propertyName}'. Expected one of ${friendlyErrorObjectParameterList}.`,
							);
						});

						if (hasOwnProperty(error, "message")) {
							assert.ok(
								!hasOwnProperty(error, "messageId"),
								"Error should not specify both 'message' and a 'messageId'.",
							);
							assert.ok(
								!hasOwnProperty(error, "data"),
								"Error should not specify both 'data' and 'message'.",
							);
							assertMessageMatches(
								message.message,
								error.message,
							);
						} else if (hasOwnProperty(error, "messageId")) {
							assert.ok(
								ruleHasMetaMessages,
								"Error can not use 'messageId' if rule under test doesn't define 'meta.messages'.",
							);
							if (
								!hasOwnProperty(
									rule.meta.messages,
									error.messageId,
								)
							) {
								assert(
									false,
									`Invalid messageId '${error.messageId}'. Expected one of ${friendlyIDList}.`,
								);
							}
							assert.strictEqual(
								message.messageId,
								error.messageId,
								`messageId '${message.messageId}' does not match expected messageId '${error.messageId}'.`,
							);

							const unsubstitutedPlaceholders =
								getUnsubstitutedMessagePlaceholders(
									message.message,
									rule.meta.messages[message.messageId],
									error.data,
								);

							assert.ok(
								unsubstitutedPlaceholders.length === 0,
								`The reported message has ${unsubstitutedPlaceholders.length > 1 ? `unsubstituted placeholders: ${unsubstitutedPlaceholders.map(name => `'${name}'`).join(", ")}` : `an unsubstituted placeholder '${unsubstitutedPlaceholders[0]}'`}. Please provide the missing ${unsubstitutedPlaceholders.length > 1 ? "values" : "value"} via the 'data' property in the context.report() call.`,
							);

							if (hasOwnProperty(error, "data")) {
								/*
								 *  if data was provided, then directly compare the returned message to a synthetic
								 *  interpolated message using the same message ID and data provided in the test.
								 *  See https://github.com/eslint/eslint/issues/9890 for context.
								 */
								const unformattedOriginalMessage =
									rule.meta.messages[error.messageId];
								const rehydratedMessage = interpolate(
									unformattedOriginalMessage,
									error.data,
								);

								assert.strictEqual(
									message.message,
									rehydratedMessage,
									`Hydrated message "${rehydratedMessage}" does not match "${message.message}"`,
								);
							}
						} else {
							assert.fail(
								"Test error must specify either a 'messageId' or 'message'.",
							);
						}

						if (error.type) {
							assert.strictEqual(
								message.nodeType,
								error.type,
								`Error type should be ${error.type}, found ${message.nodeType}`,
							);
						}

						if (hasOwnProperty(error, "line")) {
							assert.strictEqual(
								message.line,
								error.line,
								`Error line should be ${error.line}`,
							);
						}

						if (hasOwnProperty(error, "column")) {
							assert.strictEqual(
								message.column,
								error.column,
								`Error column should be ${error.column}`,
							);
						}

						if (hasOwnProperty(error, "endLine")) {
							assert.strictEqual(
								message.endLine,
								error.endLine,
								`Error endLine should be ${error.endLine}`,
							);
						}

						if (hasOwnProperty(error, "endColumn")) {
							assert.strictEqual(
								message.endColumn,
								error.endColumn,
								`Error endColumn should be ${error.endColumn}`,
							);
						}

						assert.ok(
							!message.suggestions ||
								hasOwnProperty(error, "suggestions"),
							`Error at index ${i} has suggestions. Please specify 'suggestions' property on the test error object.`,
						);
						if (hasOwnProperty(error, "suggestions")) {
							// Support asserting there are no suggestions
							const expectsSuggestions = Array.isArray(
								error.suggestions,
							)
								? error.suggestions.length > 0
								: Boolean(error.suggestions);
							const hasSuggestions =
								message.suggestions !== void 0;

							if (!hasSuggestions && expectsSuggestions) {
								assert.ok(
									!error.suggestions,
									`Error should have suggestions on error with message: "${message.message}"`,
								);
							} else if (hasSuggestions) {
								assert.ok(
									expectsSuggestions,
									`Error should have no suggestions on error with message: "${message.message}"`,
								);
								if (typeof error.suggestions === "number") {
									assert.strictEqual(
										message.suggestions.length,
										error.suggestions,
										`Error should have ${error.suggestions} suggestions. Instead found ${message.suggestions.length} suggestions`,
									);
								} else if (Array.isArray(error.suggestions)) {
									assert.strictEqual(
										message.suggestions.length,
										error.suggestions.length,
										`Error should have ${error.suggestions.length} suggestions. Instead found ${message.suggestions.length} suggestions`,
									);

									error.suggestions.forEach(
										(expectedSuggestion, index) => {
											assert.ok(
												typeof expectedSuggestion ===
													"object" &&
													expectedSuggestion !== null,
												"Test suggestion in 'suggestions' array must be an object.",
											);
											Object.keys(
												expectedSuggestion,
											).forEach(propertyName => {
												assert.ok(
													suggestionObjectParameters.has(
														propertyName,
													),
													`Invalid suggestion property name '${propertyName}'. Expected one of ${friendlySuggestionObjectParameterList}.`,
												);
											});

											const actualSuggestion =
												message.suggestions[index];
											const suggestionPrefix = `Error Suggestion at index ${index}:`;

											if (
												hasOwnProperty(
													expectedSuggestion,
													"desc",
												)
											) {
												assert.ok(
													!hasOwnProperty(
														expectedSuggestion,
														"data",
													),
													`${suggestionPrefix} Test should not specify both 'desc' and 'data'.`,
												);
												assert.ok(
													!hasOwnProperty(
														expectedSuggestion,
														"messageId",
													),
													`${suggestionPrefix} Test should not specify both 'desc' and 'messageId'.`,
												);
												assert.strictEqual(
													actualSuggestion.desc,
													expectedSuggestion.desc,
													`${suggestionPrefix} desc should be "${expectedSuggestion.desc}" but got "${actualSuggestion.desc}" instead.`,
												);
											} else if (
												hasOwnProperty(
													expectedSuggestion,
													"messageId",
												)
											) {
												assert.ok(
													ruleHasMetaMessages,
													`${suggestionPrefix} Test can not use 'messageId' if rule under test doesn't define 'meta.messages'.`,
												);
												assert.ok(
													hasOwnProperty(
														rule.meta.messages,
														expectedSuggestion.messageId,
													),
													`${suggestionPrefix} Test has invalid messageId '${expectedSuggestion.messageId}', the rule under test allows only one of ${friendlyIDList}.`,
												);
												assert.strictEqual(
													actualSuggestion.messageId,
													expectedSuggestion.messageId,
													`${suggestionPrefix} messageId should be '${expectedSuggestion.messageId}' but got '${actualSuggestion.messageId}' instead.`,
												);

												const unsubstitutedPlaceholders =
													getUnsubstitutedMessagePlaceholders(
														actualSuggestion.desc,
														rule.meta.messages[
															expectedSuggestion
																.messageId
														],
														expectedSuggestion.data,
													);

												assert.ok(
													unsubstitutedPlaceholders.length ===
														0,
													`The message of the suggestion has ${unsubstitutedPlaceholders.length > 1 ? `unsubstituted placeholders: ${unsubstitutedPlaceholders.map(name => `'${name}'`).join(", ")}` : `an unsubstituted placeholder '${unsubstitutedPlaceholders[0]}'`}. Please provide the missing ${unsubstitutedPlaceholders.length > 1 ? "values" : "value"} via the 'data' property for the suggestion in the context.report() call.`,
												);

												if (
													hasOwnProperty(
														expectedSuggestion,
														"data",
													)
												) {
													const unformattedMetaMessage =
														rule.meta.messages[
															expectedSuggestion
																.messageId
														];
													const rehydratedDesc =
														interpolate(
															unformattedMetaMessage,
															expectedSuggestion.data,
														);

													assert.strictEqual(
														actualSuggestion.desc,
														rehydratedDesc,
														`${suggestionPrefix} Hydrated test desc "${rehydratedDesc}" does not match received desc "${actualSuggestion.desc}".`,
													);
												}
											} else if (
												hasOwnProperty(
													expectedSuggestion,
													"data",
												)
											) {
												assert.fail(
													`${suggestionPrefix} Test must specify 'messageId' if 'data' is used.`,
												);
											} else {
												assert.fail(
													`${suggestionPrefix} Test must specify either 'messageId' or 'desc'.`,
												);
											}

											assert.ok(
												hasOwnProperty(
													expectedSuggestion,
													"output",
												),
												`${suggestionPrefix} The "output" property is required.`,
											);
											const codeWithAppliedSuggestion =
												SourceCodeFixer.applyFixes(
													item.code,
													[actualSuggestion],
												).output;

											// Verify if suggestion fix makes a syntax error or not.
											const errorMessageInSuggestion =
												linter
													.verify(
														codeWithAppliedSuggestion,
														result.configs,
														result.filename,
													)
													.find(m => m.fatal);

											assert(
												!errorMessageInSuggestion,
												[
													"A fatal parsing error occurred in suggestion fix.",
													`Error: ${errorMessageInSuggestion && errorMessageInSuggestion.message}`,
													"Suggestion output:",
													codeWithAppliedSuggestion,
												].join("\n"),
											);

											assert.strictEqual(
												codeWithAppliedSuggestion,
												expectedSuggestion.output,
												`Expected the applied suggestion fix to match the test suggestion output for suggestion at index: ${index} on error with message: "${message.message}"`,
											);
											assert.notStrictEqual(
												expectedSuggestion.output,
												item.code,
												`The output of a suggestion should differ from the original source code for suggestion at index: ${index} on error with message: "${message.message}"`,
											);
										},
									);
								} else {
									assert.fail(
										"Test error object property 'suggestions' should be an array or a number",
									);
								}
							}
						}
					} else {
						// Message was an unexpected type
						assert.fail(
							`Error should be a string, object, or RegExp, but found (${util.inspect(message)})`,
						);
					}
				}
			}

			if (hasOwnProperty(item, "output")) {
				if (item.output === null) {
					assert.strictEqual(
						result.output,
						item.code,
						"Expected no autofixes to be suggested",
					);
				} else {
					assert.strictEqual(
						result.output,
						item.output,
						"Output is incorrect.",
					);
					assert.notStrictEqual(
						item.code,
						item.output,
						"Test property 'output' matches 'code'. If no autofix is expected, then omit the 'output' property or set it to null.",
					);
				}
			} else {
				assert.strictEqual(
					result.output,
					item.code,
					"The rule fixed the code. Please add 'output' property.",
				);
			}

			assertASTDidntChange(result.beforeAST, result.afterAST);
		}
Check if the template is invalid or not
all invalid cases go through this.
@param {string|Object} item Item to run the rule against
@returns {void}
@private