test-pmd-rule 1.0.1 → 1.0.3

package/dist/test-pmd-rule.js

@@ -220,8 +220,229 @@ function analyzeXPath(xpath) {
   };
 }
 
-// src/xpath/checkCoverage.ts
+// src/xpath/coverage/conditional/checkComparison.ts
+var MIN_EXPRESSION_LENGTH = 0;
 var MIN_COUNT = 0;
+var MIN_REQUIRED_COUNT = 1;
+var MIN_DEMONSTRATION_COUNT = 1;
+var MIN_UNIQUE_VALUES = 1;
+var ATTR_PREFIX_LENGTH = 1;
+function checkComparisonDemonstration(attributes, content) {
+  const attrValues = {};
+  for (const attr of attributes) {
+    const valueMatches = content.match(
+      new RegExp(`${attr}\\s*:\\s*([^\\s\\n]+)`, "gi")
+    );
+    if (valueMatches !== null) {
+      attrValues[attr] = valueMatches.map((match) => {
+        const parts = match.split(":");
+        return parts[ATTR_PREFIX_LENGTH].trim();
+      });
+    }
+  }
+  const uniqueValues = new Set(Object.values(attrValues).flat());
+  return uniqueValues.size > MIN_UNIQUE_VALUES;
+}
+function checkComparisonCoverage(conditional, content) {
+  if (conditional.expression.length === MIN_EXPRESSION_LENGTH) {
+    return {
+      details: [],
+      evidence: [],
+      message: "No expression to check",
+      success: false
+    };
+  }
+  const attrMatches = conditional.expression.match(/@([A-Za-z][A-Za-z0-9]*)/g);
+  if (attrMatches === null || attrMatches.length === MIN_COUNT) {
+    return {
+      details: [],
+      evidence: [],
+      message: "No attributes found in comparison",
+      success: false
+    };
+  }
+  const attributes = attrMatches.map((match) => match.slice(ATTR_PREFIX_LENGTH));
+  const demonstratesComparison = checkComparisonDemonstration(attributes, content);
+  const demonstrationCount = demonstratesComparison ? MIN_DEMONSTRATION_COUNT : MIN_COUNT;
+  const expressionStr = conditional.expression;
+  return {
+    details: [],
+    evidence: [
+      {
+        count: demonstrationCount,
+        description: `Comparison ${expressionStr} coverage`,
+        required: MIN_REQUIRED_COUNT,
+        type: "valid"
+      }
+    ],
+    message: demonstratesComparison ? `Comparison ${expressionStr} is demonstrated` : `Comparison ${expressionStr} not demonstrated in content`,
+    success: demonstratesComparison
+  };
+}
+
+// src/xpath/coverage/conditional/strategies.ts
+function checkAndOperatorCoverage(conditional, content) {
+  const MIN_EXPRESSION_LENGTH2 = 0;
+  const MIN_COUNT4 = 0;
+  const MIN_REQUIRED_COUNT2 = 1;
+  if (conditional.expression.length === MIN_EXPRESSION_LENGTH2) {
+    return {
+      details: [],
+      evidence: [],
+      message: "No expression to check",
+      success: false
+    };
+  }
+  const contentLower = content.toLowerCase();
+  const expressionLower = conditional.expression.toLowerCase();
+  if (expressionLower.includes("@final") || expressionLower.includes("final")) {
+    const hasFinal = contentLower.includes("final");
+    return {
+      details: [],
+      evidence: [
+        {
+          count: hasFinal ? MIN_REQUIRED_COUNT2 : MIN_COUNT4,
+          description: `AND condition "${conditional.expression}" coverage`,
+          required: MIN_REQUIRED_COUNT2,
+          type: "valid"
+        }
+      ],
+      message: hasFinal ? `AND condition "${conditional.expression}" is covered` : `AND condition "${conditional.expression}" not covered - missing 'final' keyword`,
+      success: hasFinal
+    };
+  }
+  if (expressionLower.includes("@static") || expressionLower.includes("static")) {
+    const hasStatic = contentLower.includes("static");
+    return {
+      details: [],
+      evidence: [
+        {
+          count: hasStatic ? MIN_REQUIRED_COUNT2 : MIN_COUNT4,
+          description: `AND condition "${conditional.expression}" coverage`,
+          required: MIN_REQUIRED_COUNT2,
+          type: "valid"
+        }
+      ],
+      message: hasStatic ? `AND condition "${conditional.expression}" is covered` : `AND condition "${conditional.expression}" not covered - missing 'static' keyword`,
+      success: hasStatic
+    };
+  }
+  const keywords = conditional.expression.split(/[=<>!()\[\]]+/).map((s) => s.trim()).filter((s) => s.length > MIN_EXPRESSION_LENGTH2 && !s.startsWith("@"));
+  const hasKeywords = keywords.some(
+    (keyword) => contentLower.includes(keyword.toLowerCase())
+  );
+  return {
+    details: [],
+    evidence: [
+      {
+        count: hasKeywords ? MIN_REQUIRED_COUNT2 : MIN_COUNT4,
+        description: `AND condition "${conditional.expression}" coverage`,
+        required: MIN_REQUIRED_COUNT2,
+        type: "valid"
+      }
+    ],
+    message: hasKeywords ? `AND condition "${conditional.expression}" is covered` : `AND condition "${conditional.expression}" not covered`,
+    success: hasKeywords
+  };
+}
+function checkNotConditionCoverage(conditional, content) {
+  const MIN_EXPRESSION_LENGTH2 = 0;
+  const MIN_COUNT4 = 0;
+  const MIN_REQUIRED_COUNT2 = 1;
+  if (conditional.expression.length === MIN_EXPRESSION_LENGTH2) {
+    return {
+      details: [],
+      evidence: [],
+      message: "No expression to check",
+      success: false
+    };
+  }
+  const contentLower = content.toLowerCase();
+  const expressionLower = conditional.expression.toLowerCase();
+  if (expressionLower.includes("fielddeclarationstatements") || expressionLower.includes("field[") || expressionLower.includes("ancestor::field")) {
+    const hasStaticFinal = /static\s+final/.test(contentLower);
+    const hasFieldDeclaration = contentLower.includes("field") || /(private|public|protected)\s+(static\s+)?(final\s+)?\w+\s+\w+\s*=/.test(
+      contentLower
+    );
+    const isCovered = hasStaticFinal && hasFieldDeclaration;
+    return {
+      details: [],
+      evidence: [
+        {
+          count: isCovered ? MIN_REQUIRED_COUNT2 : MIN_COUNT4,
+          description: `NOT condition "${conditional.expression}" coverage - static final fields present`,
+          required: MIN_REQUIRED_COUNT2,
+          type: "valid"
+        }
+      ],
+      message: isCovered ? `NOT condition "${conditional.expression}" is covered - static final fields found` : `NOT condition "${conditional.expression}" not covered - missing static final field declarations`,
+      success: isCovered
+    };
+  }
+  const keywords = conditional.expression.split(/[=<>!()\[\]:]+/).map((s) => s.trim()).filter(
+    (s) => s.length > MIN_EXPRESSION_LENGTH2 && !s.startsWith("@") && s !== "ancestor" && s !== "not"
+  );
+  const hasKeywords = keywords.some(
+    (keyword) => contentLower.includes(keyword.toLowerCase())
+  );
+  return {
+    details: [],
+    evidence: [
+      {
+        count: hasKeywords ? MIN_REQUIRED_COUNT2 : MIN_COUNT4,
+        description: `NOT condition "${conditional.expression}" coverage`,
+        required: MIN_REQUIRED_COUNT2,
+        type: "valid"
+      }
+    ],
+    message: hasKeywords ? `NOT condition "${conditional.expression}" is covered` : `NOT condition "${conditional.expression}" not covered`,
+    success: hasKeywords
+  };
+}
+function checkOrBranchCoverage(_conditional, _content) {
+  return {
+    details: [],
+    evidence: [],
+    message: "Or branch coverage check not implemented",
+    success: false
+  };
+}
+function checkIfConditionCoverage(_conditional, _content) {
+  return {
+    details: [],
+    evidence: [],
+    message: "If condition coverage check not implemented",
+    success: false
+  };
+}
+function checkQuantifiedCoverage(_conditional, _content) {
+  return {
+    details: [],
+    evidence: [],
+    message: "Quantified condition coverage check not implemented",
+    success: false
+  };
+}
+function checkBooleanFunctionCoverage(_conditional, _content) {
+  return {
+    details: [],
+    evidence: [],
+    message: "Boolean function coverage check not implemented",
+    success: false
+  };
+}
+var conditionalCheckers = {
+  and_operator: checkAndOperatorCoverage,
+  boolean_function: checkBooleanFunctionCoverage,
+  comparison: checkComparisonCoverage,
+  if_condition: checkIfConditionCoverage,
+  not_condition: checkNotConditionCoverage,
+  or_branch: checkOrBranchCoverage,
+  quantified: checkQuantifiedCoverage
+};
+
+// src/xpath/checkCoverage.ts
+var MIN_COUNT2 = 0;
 var NOT_FOUND_INDEX = -1;
 var LINE_OFFSET = 1;
 function findAttributeLineNumber(ruleFilePath, xpath, attribute) {
@@ -257,11 +478,11 @@ function findAttributeLineNumber(ruleFilePath, xpath, attribute) {
         const line = lines[i];
         if (line.includes("<value>")) {
           const xpathBeforeAttribute = xpath.substring(
-            MIN_COUNT,
+            MIN_COUNT2,
             xpathIndex
           );
           const newlineMatches = xpathBeforeAttribute.match(/\n/g);
-          const newlineCount = newlineMatches ? newlineMatches.length : MIN_COUNT;
+          const newlineCount = newlineMatches ? newlineMatches.length : MIN_COUNT2;
           return i + LINE_OFFSET + newlineCount;
         }
       }
@@ -303,11 +524,11 @@ function findNodeTypeLineNumber(ruleFilePath, xpath, nodeType) {
         const line = lines[i];
         if (line.includes("<value>")) {
           const xpathBeforeNodeType = xpath.substring(
-            MIN_COUNT,
+            MIN_COUNT2,
             xpathIndex
           );
           const newlineMatches = xpathBeforeNodeType.match(/\n/g);
-          const newlineCount = newlineMatches ? newlineMatches.length : MIN_COUNT;
+          const newlineCount = newlineMatches ? newlineMatches.length : MIN_COUNT2;
           return i + LINE_OFFSET + newlineCount;
         }
       }
@@ -381,7 +602,7 @@ function checkNodeTypeCoverage(nodeTypes, content, options) {
       missingNodeTypes.push(nodeType);
     }
   }
-  const missingList = missingNodeTypes.length > MIN_COUNT ? missingNodeTypes.map((item) => {
+  const missingList = missingNodeTypes.length > MIN_COUNT2 ? missingNodeTypes.map((item) => {
     if (options !== void 0) {
       const ruleFilePathValue = options.ruleFilePath;
       const xpathValue = options.xpath;
@@ -397,9 +618,9 @@ function checkNodeTypeCoverage(nodeTypes, content, options) {
     }
     return ` - ${item}`;
   }).join("\n") : "";
-  const missingText = missingNodeTypes.length > MIN_COUNT ? `Missing:
+  const missingText = missingNodeTypes.length > MIN_COUNT2 ? `Missing:
 ${missingList}` : "";
-  const description = missingText.length > MIN_COUNT ? missingText : "";
+  const description = missingText.length > MIN_COUNT2 ? missingText : "";
   return {
     count: foundNodeTypes.length,
     description,
@@ -413,16 +634,35 @@ function truncateExpression(expression, maxLength) {
   if (normalized.length <= maxLength) {
     return normalized;
   }
-  return `${normalized.substring(MIN_COUNT, maxLength)}...`;
+  return `${normalized.substring(MIN_COUNT2, maxLength)}...`;
+}
+function mapConditionalTypeToCheckerKey(type) {
+  const typeMap = {
+    and: "and_operator",
+    not: "not_condition",
+    or: "or_branch"
+  };
+  return typeMap[type] ?? type;
 }
 function checkConditionalCoverage(conditionals, content) {
   const lowerContent = content.toLowerCase();
   const foundConditionals = [];
   const missingConditionals = [];
   for (const conditional of conditionals) {
-    const exprLower = conditional.expression.toLowerCase();
+    const checkerKey = mapConditionalTypeToCheckerKey(conditional.type);
+    const checker = conditionalCheckers[checkerKey];
     let isCovered = false;
-    isCovered = lowerContent.includes(exprLower) || lowerContent.includes("if");
+    if (checker) {
+      const result = checker(conditional, content);
+      isCovered = result.success;
+      if (!isCovered) {
+        const exprLower = conditional.expression.toLowerCase();
+        isCovered = lowerContent.includes(exprLower) || lowerContent.includes("if");
+      }
+    } else {
+      const exprLower = conditional.expression.toLowerCase();
+      isCovered = lowerContent.includes(exprLower) || lowerContent.includes("if");
+    }
     if (isCovered) {
       const displayExpr = truncateExpression(
         conditional.expression,
@@ -437,10 +677,10 @@ function checkConditionalCoverage(conditionals, content) {
       missingConditionals.push(` - ${conditional.type}: ${displayExpr}`);
     }
   }
-  const missingList = missingConditionals.length > MIN_COUNT ? missingConditionals : [];
-  const missingText = missingList.length > MIN_COUNT ? `Missing:
+  const missingList = missingConditionals.length > MIN_COUNT2 ? missingConditionals : [];
+  const missingText = missingList.length > MIN_COUNT2 ? `Missing:
 ${missingList.join("\n")}` : "";
-  const description = missingText.length > MIN_COUNT ? missingText : "";
+  const description = missingText.length > MIN_COUNT2 ? missingText : "";
   return {
     count: foundConditionals.length,
     description,
@@ -495,7 +735,7 @@ function checkAttributeCoverage(attributes, content, options) {
       missingAttributes.push(attr);
     }
   }
-  const missingList = missingAttributes.length > MIN_COUNT ? missingAttributes.map((item) => {
+  const missingList = missingAttributes.length > MIN_COUNT2 ? missingAttributes.map((item) => {
     const ruleFilePath = options?.ruleFilePath;
     const xpathValue = options?.xpath;
     const hasOptions = ruleFilePath !== void 0 && xpathValue !== void 0;
@@ -512,9 +752,9 @@ function checkAttributeCoverage(attributes, content, options) {
     }
     return ` - ${item}`;
   }).join("\n") : "";
-  const missingText = missingAttributes.length > MIN_COUNT ? `Missing:
+  const missingText = missingAttributes.length > MIN_COUNT2 ? `Missing:
 ${missingList}` : "";
-  const description = missingText.length > MIN_COUNT ? missingText : "";
+  const description = missingText.length > MIN_COUNT2 ? missingText : "";
   return {
     count: foundAttributes.length,
     description,
@@ -534,13 +774,13 @@ function checkOperatorCoverage(operators, content) {
       missingOperators.push(op);
     }
   }
-  const foundList = foundOperators.length > MIN_COUNT ? foundOperators.map((item) => ` - ${item}`).join("\n") : "";
-  const missingList = missingOperators.length > MIN_COUNT ? missingOperators.map((item) => ` - ${item}`).join("\n") : "";
+  const foundList = foundOperators.length > MIN_COUNT2 ? foundOperators.map((item) => ` - ${item}`).join("\n") : "";
+  const missingList = missingOperators.length > MIN_COUNT2 ? missingOperators.map((item) => ` - ${item}`).join("\n") : "";
   const foundText = foundList;
-  const missingText = missingOperators.length > MIN_COUNT ? `Missing:
+  const missingText = missingOperators.length > MIN_COUNT2 ? `Missing:
 ${missingList}` : "";
-  const hasFound = foundText.length > MIN_COUNT;
-  const hasMissing = missingText.length > MIN_COUNT;
+  const hasFound = foundText.length > MIN_COUNT2;
+  const hasMissing = missingText.length > MIN_COUNT2;
   let description = "";
   if (hasFound) {
     description = hasMissing ? `${foundText}
@@ -557,8 +797,8 @@ ${missingText}` : foundText;
   };
 }
 function checkXPathCoverage(xpath, examples, ruleFilePath) {
-  const hasXPath = xpath !== null && xpath !== void 0 && xpath.length > MIN_COUNT;
-  if (!hasXPath || examples.length === MIN_COUNT) {
+  const hasXPath = xpath !== null && xpath !== void 0 && xpath.length > MIN_COUNT2;
+  if (!hasXPath || examples.length === MIN_COUNT2) {
     return {
       coverage: [],
       overallSuccess: false,
@@ -570,11 +810,11 @@ function checkXPathCoverage(xpath, examples, ruleFilePath) {
   const coverageResults = [];
   const uncoveredBranches = [];
   const coveredLineNumbers = /* @__PURE__ */ new Set();
-  if (analysis.nodeTypes.length > MIN_COUNT) {
+  if (analysis.nodeTypes.length > MIN_COUNT2) {
     const ruleFilePathValue = ruleFilePath;
     const xpathValue = xpath;
-    const hasRuleFilePath = ruleFilePathValue !== void 0 && ruleFilePathValue.length > MIN_COUNT;
-    const hasXpathValue = xpathValue.length > MIN_COUNT;
+    const hasRuleFilePath = ruleFilePathValue !== void 0 && ruleFilePathValue.length > MIN_COUNT2;
+    const hasXpathValue = xpathValue.length > MIN_COUNT2;
     const nodeTypeOptions = hasRuleFilePath && hasXpathValue ? {
       lineNumberCollector: (lineNumber) => {
         coveredLineNumbers.add(lineNumber);
@@ -600,7 +840,7 @@ function checkXPathCoverage(xpath, examples, ruleFilePath) {
       );
     }
   }
-  if (analysis.conditionals.length > MIN_COUNT) {
+  if (analysis.conditionals.length > MIN_COUNT2) {
     const conditionalEvidence = checkConditionalCoverage(
       analysis.conditionals,
       allContent
@@ -618,11 +858,11 @@ function checkXPathCoverage(xpath, examples, ruleFilePath) {
       );
     }
   }
-  if (analysis.attributes.length > MIN_COUNT) {
+  if (analysis.attributes.length > MIN_COUNT2) {
     const ruleFilePathValue = ruleFilePath;
     const xpathValue = xpath;
-    const hasRuleFilePath = ruleFilePathValue !== void 0 && ruleFilePathValue.length > MIN_COUNT;
-    const hasXpathValue = xpathValue.length > MIN_COUNT;
+    const hasRuleFilePath = ruleFilePathValue !== void 0 && ruleFilePathValue.length > MIN_COUNT2;
+    const hasXpathValue = xpathValue.length > MIN_COUNT2;
     const attributeOptions = hasRuleFilePath && hasXpathValue ? {
       lineNumberCollector: (lineNumber) => {
         coveredLineNumbers.add(lineNumber);
@@ -648,7 +888,7 @@ function checkXPathCoverage(xpath, examples, ruleFilePath) {
       );
     }
   }
-  if (analysis.operators.length > MIN_COUNT) {
+  if (analysis.operators.length > MIN_COUNT2) {
     const operatorEvidence = checkOperatorCoverage(
       analysis.operators,
       allContent
@@ -666,7 +906,7 @@ function checkXPathCoverage(xpath, examples, ruleFilePath) {
       );
     }
   }
-  const overallSuccess = coverageResults.length === MIN_COUNT || coverageResults.every(
+  const overallSuccess = coverageResults.length === MIN_COUNT2 || coverageResults.every(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter for every
     (result) => result.success
   );
@@ -782,6 +1022,34 @@ import tmp from "tmp";
 var EMPTY_LENGTH = 0;
 var FIRST_CAPTURE_GROUP_INDEX = 1;
 var SECOND_CAPTURE_GROUP_INDEX = 2;
+var TAB_CHAR = "	";
+var SPACE_CHAR = " ";
+var DEFAULT_INDENT = "    ";
+var FIRST_ELEMENT_INDEX2 = 0;
+function removeInlineMarkers(line) {
+  if (line.includes("// \u274C")) {
+    const splitResult = line.split("// \u274C");
+    const codeLine = splitResult[FIRST_ELEMENT_INDEX2];
+    return codeLine.replace(/\s+$/, "");
+  }
+  if (line.includes("// \u2705")) {
+    const splitResult = line.split("// \u2705");
+    const codeLine = splitResult[FIRST_ELEMENT_INDEX2];
+    return codeLine.replace(/\s+$/, "");
+  }
+  return line;
+}
+function formatMethodDeclarationIndent(methodDecl) {
+  const startsWithTab = methodDecl.startsWith(TAB_CHAR);
+  if (startsWithTab) {
+    return methodDecl;
+  }
+  const startsWithSpace = methodDecl.startsWith(SPACE_CHAR);
+  if (startsWithSpace) {
+    return methodDecl;
+  }
+  return `${DEFAULT_INDENT}${methodDecl}`;
+}
 function inferReturnType(code, methodName) {
   if (new RegExp(`\\b${methodName}\\s*\\(\\s*\\)\\s*[><=!]+\\s*\\d+`).test(
     code
@@ -966,8 +1234,6 @@ function createTestFile({
   });
   const tempFile = tmpFile.name;
   const parsed = parseExample(exampleContent);
-  let classContent = `public class TestClass${String(exampleIndex)} {
-`;
   let codeToInclude = [];
   if (includeViolations && !includeValids) {
     codeToInclude = parsed.violations;
@@ -976,59 +1242,200 @@ function createTestFile({
   } else {
     codeToInclude = [...parsed.violations, ...parsed.valids];
   }
-  const hasClassDefinition = codeToInclude.some(
-    (line) => line.trim().startsWith("public class ") || line.trim().startsWith("class ")
-  );
-  if (hasClassDefinition) {
+  const TEST_CLASS_NAME = `TestClass${String(exampleIndex)}`;
+  const fullExampleContent = parsed.content;
+  const ZERO_BRACE_DEPTH = 0;
+  const hasTopLevelClass = (() => {
+    let foundTopLevelClass = false;
+    let braceDepth = ZERO_BRACE_DEPTH;
+    const exampleLines = fullExampleContent.split("\n");
+    for (const line of exampleLines) {
+      const trimmed = line.trim();
+      const isClassDef = trimmed.startsWith("public class ") || trimmed.startsWith("class ") || trimmed.startsWith("private class ");
+      if (isClassDef && braceDepth === ZERO_BRACE_DEPTH) {
+        foundTopLevelClass = true;
+        break;
+      }
+      const openBracesMatch = line.match(/{/g);
+      const closeBracesMatch = line.match(/}/g);
+      const openBraces = openBracesMatch ? openBracesMatch.length : ZERO_BRACE_DEPTH;
+      const closeBraces = closeBracesMatch ? closeBracesMatch.length : ZERO_BRACE_DEPTH;
+      braceDepth += openBraces - closeBraces;
+    }
+    return foundTopLevelClass;
+  })();
+  const hasClassLikeStructures = (() => {
+    if (hasTopLevelClass) {
+      return false;
+    }
+    const fieldDeclarationRegex = /^\s*(public|private|protected)\s+\w+\s+\w+\s*[;=]/;
+    return codeToInclude.some((line) => {
+      const trimmed = line.trim();
+      const isMethodSignature = (trimmed.startsWith("public ") || trimmed.startsWith("private ") || trimmed.startsWith("protected ")) && trimmed.includes("() {") && !trimmed.includes("class ");
+      const fieldMatch = fieldDeclarationRegex.exec(trimmed);
+      const isFieldDeclaration = Boolean(fieldMatch);
+      const isInnerClass = trimmed.includes("class ") && trimmed.includes("{");
+      return isMethodSignature || isFieldDeclaration || isInnerClass;
+    });
+  })();
+  let classContent = "";
+  if (hasTopLevelClass) {
+    const exampleLines = fullExampleContent.split("\n");
     const extractedCode = [];
+    let insideClass = false;
+    let classBraceDepth = ZERO_BRACE_DEPTH;
+    const INITIAL_BRACE_DEPTH = 1;
+    let methodBraceDepth = ZERO_BRACE_DEPTH;
+    let currentMode = null;
     let insideMethod = false;
-    let braceDepth = 0;
-    for (const line of codeToInclude) {
+    let methodDeclaration = null;
+    let methodDeclarationOriginal = null;
+    let hasIncludedMethodContent = false;
+    for (let lineIndex = 0; lineIndex < exampleLines.length; lineIndex++) {
+      const line = exampleLines[lineIndex];
       const trimmed = line.trim();
-      if (trimmed.startsWith("public class ") || trimmed.startsWith("class ") || trimmed.startsWith("private class ")) {
-        continue;
+      if (trimmed.includes("// \u274C")) {
+        currentMode = "violation";
+      } else if (trimmed.includes("// \u2705")) {
+        currentMode = "valid";
+      } else if (trimmed.startsWith("// Violation:")) {
+        currentMode = "violation";
+      } else if (trimmed.startsWith("// Valid:")) {
+        currentMode = "valid";
       }
-      const isMethodSignature = (trimmed.startsWith("public ") || trimmed.startsWith("private ") || trimmed.startsWith("protected ")) && trimmed.includes("() {") && !insideMethod;
-      const INITIAL_BRACE_DEPTH = 1;
-      const ZERO_BRACE_DEPTH = 0;
-      if (isMethodSignature) {
-        insideMethod = true;
-        braceDepth = INITIAL_BRACE_DEPTH;
-        continue;
+      const shouldInclude = !trimmed.startsWith("//") && trimmed.length > EMPTY_LENGTH && (includeViolations && currentMode === "violation" || includeValids && currentMode === "valid");
+      if (trimmed.startsWith("public class ") || trimmed.startsWith("class ") || trimmed.startsWith("private class ")) {
+        const CLASS_PREFIX_GROUP_INDEX = 1;
+        if (classBraceDepth === ZERO_BRACE_DEPTH) {
+          const classRegex = /^(public\s+|private\s+)?class\s+(\w+)/;
+          const classMatch = classRegex.exec(trimmed);
+          if (classMatch) {
+            const classPrefix = classMatch[CLASS_PREFIX_GROUP_INDEX] ?? "";
+            const newClassLine = `${classPrefix}class ${TEST_CLASS_NAME} {`;
+            extractedCode.push(newClassLine);
+            insideClass = true;
+            classBraceDepth = INITIAL_BRACE_DEPTH;
+            continue;
+          }
+        }
       }
-      if (insideMethod) {
-        const openBraces = (line.match(/{/g) ?? []).length;
-        const closeBraces = (line.match(/}/g) ?? []).length;
-        braceDepth += openBraces - closeBraces;
-        if (braceDepth > ZERO_BRACE_DEPTH) {
-          extractedCode.push(line);
+      if (insideClass || classBraceDepth > ZERO_BRACE_DEPTH) {
+        const openBracesMatch = line.match(/{/g);
+        const closeBracesMatch = line.match(/}/g);
+        const openBraces = openBracesMatch ? openBracesMatch.length : ZERO_BRACE_DEPTH;
+        const closeBraces = closeBracesMatch ? closeBracesMatch.length : ZERO_BRACE_DEPTH;
+        const prevClassBraceDepth = classBraceDepth;
+        classBraceDepth += openBraces - closeBraces;
+        const methodRegex = /\w+\s*\(/;
+        const methodMatch = methodRegex.exec(trimmed);
+        const hasMethodPattern = methodMatch !== null;
+        const isMethodDeclaration = prevClassBraceDepth === INITIAL_BRACE_DEPTH && classBraceDepth > INITIAL_BRACE_DEPTH && !trimmed.startsWith("{") && trimmed.includes("{") && (trimmed.includes("void") || trimmed.includes("(") || hasMethodPattern);
+        if (isMethodDeclaration) {
+          insideMethod = true;
+          methodBraceDepth = classBraceDepth - INITIAL_BRACE_DEPTH;
+          methodDeclaration = trimmed;
+          methodDeclarationOriginal = line;
+          hasIncludedMethodContent = false;
+        }
+        if (insideMethod) {
+          methodBraceDepth += openBraces - closeBraces;
+          if (methodBraceDepth <= ZERO_BRACE_DEPTH) {
+            insideMethod = false;
+            methodDeclaration = null;
+            methodDeclarationOriginal = null;
+            hasIncludedMethodContent = false;
+          }
+        }
+        if (shouldInclude || trimmed === "{" || trimmed === "}") {
+          const hasMethodDeclaration = methodDeclaration !== null && methodDeclarationOriginal !== null;
+          const markerRegex = /\s*\/\/\s*[❌✅].*$/;
+          const trimmedWithoutMarker = trimmed.replace(markerRegex, "").trim();
+          const isMethodDeclarationLine = insideMethod && hasMethodDeclaration && (trimmed === methodDeclaration || trimmedWithoutMarker === methodDeclaration);
+          if (shouldInclude && insideMethod && hasMethodDeclaration && !hasIncludedMethodContent) {
+            if (isMethodDeclarationLine) {
+              const codeLine = removeInlineMarkers(line);
+              extractedCode.push(codeLine);
+              hasIncludedMethodContent = true;
+            } else {
+              const methodDeclOriginal = methodDeclarationOriginal;
+              const methodDeclWithIndent = formatMethodDeclarationIndent(
+                methodDeclOriginal
+              );
+              extractedCode.push(methodDeclWithIndent);
+              const codeLine = removeInlineMarkers(line);
+              extractedCode.push(codeLine);
+              hasIncludedMethodContent = true;
+            }
+          } else if (shouldInclude && !isMethodDeclarationLine) {
+            const codeLine = removeInlineMarkers(line);
+            extractedCode.push(codeLine);
+          } else {
+            extractedCode.push(line);
+          }
         }
-        if (braceDepth <= ZERO_BRACE_DEPTH) {
+        if (classBraceDepth <= ZERO_BRACE_DEPTH) {
+          insideClass = false;
+          classBraceDepth = ZERO_BRACE_DEPTH;
           insideMethod = false;
-          braceDepth = ZERO_BRACE_DEPTH;
+          methodDeclaration = null;
+          methodDeclarationOriginal = null;
         }
-      } else if (!trimmed.startsWith("}") && trimmed.length > EMPTY_LENGTH && !trimmed.startsWith("public ") && !trimmed.startsWith("private ")) {
-        extractedCode.push(line);
+      } else if (shouldInclude) {
+        const codeLine = removeInlineMarkers(line).trim();
+        extractedCode.push(codeLine);
       }
     }
-    codeToInclude = extractedCode.length > EMPTY_LENGTH ? extractedCode : codeToInclude;
-  }
-  if (codeToInclude.length > EMPTY_LENGTH) {
-    classContent += `    public void testMethod${String(exampleIndex)}() {
+    const helperMethods = extractHelperMethods(codeToInclude);
+    const classContentStr = extractedCode.join("\n");
+    const lastBraceIndex = classContentStr.lastIndexOf("}");
+    if (helperMethods.length > EMPTY_LENGTH) {
+      const beforeLastBrace = classContentStr.substring(
+        ZERO_BRACE_DEPTH,
+        lastBraceIndex
+      );
+      const afterLastBrace = classContentStr.substring(lastBraceIndex);
+      classContent = beforeLastBrace + "\n";
+      for (const method of helperMethods) {
+        classContent += `    ${method}
+`;
+      }
+      classContent += afterLastBrace + "\n";
+    } else {
+      classContent = classContentStr + "\n";
+    }
+  } else if (hasClassLikeStructures) {
+    classContent = `public class ${TEST_CLASS_NAME} {
 `;
     codeToInclude.forEach((line) => {
-      classContent += `        ${line}
+      classContent += `    ${line}
 `;
     });
-    classContent += `    }
+    const helperMethods = extractHelperMethods(codeToInclude);
+    for (const method of helperMethods) {
+      classContent += `    ${method}
 `;
-  }
-  const helperMethods = extractHelperMethods(codeToInclude);
-  for (const method of helperMethods) {
-    classContent += `    ${method}
+    }
+    classContent += "}\n";
+  } else {
+    classContent = `public class ${TEST_CLASS_NAME} {
+`;
+    if (codeToInclude.length > EMPTY_LENGTH) {
+      classContent += `    public void testMethod${String(exampleIndex)}() {
+`;
+      codeToInclude.forEach((line) => {
+        classContent += `        ${line}
+`;
+      });
+      classContent += `    }
+`;
+    }
+    const helperMethods = extractHelperMethods(codeToInclude);
+    for (const method of helperMethods) {
+      classContent += `    ${method}
 `;
+    }
+    classContent += "}\n";
   }
-  classContent += "}\n";
   writeFileSync(tempFile, classContent, "utf-8");
   return {
     filePath: tempFile,
@@ -1333,7 +1740,7 @@ var MIN_PATTERN_LENGTH = 10;
 var PATTERN_DISPLAY_LENGTH = 50;
 var INDEX_OFFSET2 = 1;
 var ZERO_ERRORS = 0;
-var MIN_COUNT2 = 0;
+var MIN_COUNT3 = 0;
 function normalizeCode(code) {
   return code.replace(/\s+/g, " ").trim().toLowerCase();
 }
@@ -1341,7 +1748,7 @@ function checkPatternDuplicates(patterns, type, warnings) {
   for (const [pattern, exampleNumbers] of patterns.entries()) {
     if (exampleNumbers.length > MIN_DUPLICATE_COUNT && pattern.length > MIN_PATTERN_LENGTH) {
       const patternPreview = pattern.substring(
-        MIN_COUNT2,
+        MIN_COUNT3,
         PATTERN_DISPLAY_LENGTH
       );
       warnings.push(
@@ -1978,11 +2385,8 @@ async function testRuleFile(ruleFilePath, coverageTracker, maxConcurrency) {
   try {
     const tester = new RuleTester(ruleFilePath);
     const result = await tester.runCoverageTest(false, maxConcurrency);
-    const hasCoverageTracker = coverageTracker !== null;
-    const MIN_COVERED_LINES_COUNT = 0;
-    const coveredLines = result.xpathCoverage.coveredLineNumbers;
-    if (hasCoverageTracker && coveredLines && coveredLines.length > MIN_COVERED_LINES_COUNT) {
-      for (const lineNumber of coveredLines) {
+    if (coverageTracker && result.xpathCoverage.coveredLineNumbers) {
+      for (const lineNumber of result.xpathCoverage.coveredLineNumbers) {
         coverageTracker.recordXPathLine(lineNumber);
       }
     }
@@ -2003,7 +2407,7 @@ async function testRuleFile(ruleFilePath, coverageTracker, maxConcurrency) {
         );
       }
     }
-    const MIN_COUNT3 = 0;
+    const MIN_COUNT4 = 0;
     const INDEX_OFFSET3 = 1;
     if (result.success) {
       console.log("\n\u{1F4CA} Test Summary:");
@@ -2020,10 +2424,9 @@ async function testRuleFile(ruleFilePath, coverageTracker, maxConcurrency) {
     if (result.xpathCoverage.overallSuccess) {
       console.log("  Status: \u2705 Complete");
     } else {
-      const INCOMPLETE_STATUS_MESSAGE = "  Status: \u26A0\uFE0F Incomplete";
-      console.log(INCOMPLETE_STATUS_MESSAGE);
+      console.log("  Status: \u26A0\uFE0F Incomplete");
     }
-    if (result.xpathCoverage.coverage.length > MIN_COUNT3) {
+    if (result.xpathCoverage.coverage.length > MIN_COUNT4) {
       console.log(
         `  Coverage items: ${String(result.xpathCoverage.coverage.length)}`
       );
@@ -2033,17 +2436,17 @@ async function testRuleFile(ruleFilePath, coverageTracker, maxConcurrency) {
           const itemNumber = index + INDEX_OFFSET3;
           const status = coverage.success ? "\u2705" : coverage.evidence.some(
             // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameter for some
-            (evidence) => evidence.count > MIN_COUNT3 && evidence.count < evidence.required
+            (evidence) => evidence.count > MIN_COUNT4 && evidence.count < evidence.required
           ) ? "\u26A0\uFE0F" : "\u274C";
           console.log(
             `    ${String(itemNumber)}. ${status} ${coverage.message}`
           );
-          if (coverage.evidence.length > MIN_COUNT3) {
+          if (coverage.evidence.length > MIN_COUNT4) {
             coverage.evidence.forEach(
               // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Callback parameters for forEach
               (evidence) => {
                 const { description } = evidence;
-                if (description.length > MIN_COUNT3) {
+                if (description.length > MIN_COUNT4) {
                   if (description.includes("\n")) {
                     description.split("\n").forEach(
                       (line) => {
@@ -2062,7 +2465,7 @@ async function testRuleFile(ruleFilePath, coverageTracker, maxConcurrency) {
         }
       );
     }
-    if (result.hardcodedValues.length > MIN_COUNT3) {
+    if (result.hardcodedValues.length > MIN_COUNT4) {
       console.log(
         `
 \u26A0\uFE0F  Hardcoded values found: ${String(result.hardcodedValues.length)}`
@@ -2083,7 +2486,7 @@ async function testRuleFile(ruleFilePath, coverageTracker, maxConcurrency) {
       console.log("\n\u274C Tests failed, incomplete coverage");
     }
     tester.cleanup();
-    const coverageData = coverageTracker !== null ? coverageTracker.getCoverageData() : void 0;
+    const coverageData = coverageTracker ? coverageTracker.getCoverageData() : void 0;
     return {
       coverageData,
       filePath: ruleFilePath,
@@ -2120,8 +2523,7 @@ async function main() {
     console.error("\u274C Invalid path argument");
     process.exit(EXIT_CODE_ERROR);
   }
-  const COVERAGE_FLAG = "--coverage";
-  const hasCoverageFlag = args.length > SECOND_ARG_INDEX && args[SECOND_ARG_INDEX] === COVERAGE_FLAG;
+  const hasCoverageFlag = args.length > SECOND_ARG_INDEX && args[SECOND_ARG_INDEX] === "--coverage";
   if (!existsSync2(pathArg)) {
     console.error(`\u274C Path not found: ${pathArg}`);
     process.exit(EXIT_CODE_ERROR);
@@ -2159,8 +2561,8 @@ async function main() {
   const coverageTrackers = hasCoverageFlag ? /* @__PURE__ */ new Map() : null;
   const tasks = xmlFiles.map(
     (filePath) => async () => {
-      const tracker = coverageTrackers !== null ? coverageTrackers.get(filePath) ?? new CoverageTracker(filePath) : null;
-      if (tracker !== null && coverageTrackers !== null) {
+      const tracker = coverageTrackers ? coverageTrackers.get(filePath) ?? new CoverageTracker(filePath) : null;
+      if (tracker && coverageTrackers) {
         coverageTrackers.set(filePath, tracker);
       }
       return testRuleFile(filePath, tracker, maxExampleConcurrency);
@@ -2190,19 +2592,13 @@ async function main() {
       console.log(`  - ${result.filePath}${errorSuffix}`);
     });
   }
-  if (hasCoverageFlag && coverageTrackers !== null) {
-    const coverageData = Array.from(
-      coverageTrackers.values()
-    ).map(
+  if (hasCoverageFlag && coverageTrackers) {
+    const coverageData = Array.from(coverageTrackers.values()).map(
       (tracker) => tracker.getCoverageData()
     );
-    const COVERAGE_REPORT_PATH = "coverage/lcov.info";
     try {
-      generateLcovReport(coverageData, COVERAGE_REPORT_PATH);
-      console.log(
-        `
-\u{1F4CA} Coverage report generated: ${COVERAGE_REPORT_PATH}`
-      );
+      generateLcovReport(coverageData, "coverage/lcov.info");
+      console.log("\n\u{1F4CA} Coverage report generated: coverage/lcov.info");
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error(