///////////////////////////////////////////////////////////////////////////////////////////////
   // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
   // Copyright (C) 2001-2026 the original author or authors.
   //
   // This library is free software; you can redistribute it and/or
   // modify it under the terms of the GNU Lesser General Public
   // License as published by the Free Software Foundation; either
   // version 2.1 of the License, or (at your option) any later version.
   //
  // This library is distributed in the hope that it will be useful,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  // Lesser General Public License for more details.
  //
  // You should have received a copy of the GNU Lesser General Public
  // License along with this library; if not, write to the Free Software
  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  ///////////////////////////////////////////////////////////////////////////////////////////////
  
  package com.puppycrawl.tools.checkstyle.bdd;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.StringReader;
  import java.math.BigDecimal;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.BitSet;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Properties;
  import java.util.Set;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  import java.util.stream.Collectors;
  
  import org.xml.sax.InputSource;
  
  import com.puppycrawl.tools.checkstyle.ConfigurationLoader;
  import com.puppycrawl.tools.checkstyle.PropertiesExpander;
  import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
  import com.puppycrawl.tools.checkstyle.api.Configuration;
  import com.puppycrawl.tools.checkstyle.internal.utils.TestUtil;
  import com.puppycrawl.tools.checkstyle.meta.ModuleDetails;
  import com.puppycrawl.tools.checkstyle.meta.ModulePropertyDetails;
  import com.puppycrawl.tools.checkstyle.meta.XmlMetaReader;
  import com.puppycrawl.tools.checkstyle.utils.InlineConfigUtils;
  import com.puppycrawl.tools.checkstyle.utils.JavadocUtil;
  import com.puppycrawl.tools.checkstyle.utils.TokenUtil;
  
  public final class InlineConfigParser {
  
      /** A pattern matching the symbol: "\" or "/". */
      private static final Pattern SLASH_PATTERN = Pattern.compile("[\\\\/]");
  
      /**
       * Triple-quote delimiter used to start and end a multiline violation message.
       *
       * <p>The parser assembles all continuation {@code //} lines until a line
       * ending with {@code """} is found, joining them with a single space.
       * See :
       * <a href="https://github.com/checkstyle/checkstyle/blob/master/docs/specifying-violations.md"
       * >specifying-violations</a>.
       */
      private static final String TRIPLE_QUOTE = "\"\"\"";
  
      /**
       * Pattern to match a continuation line of a multiline triple-quote violation message.
       * Captures everything after the leading {@code //} and optional whitespace.
       */
      private static final Pattern MULTILINE_CONTINUATION_PATTERN =
              Pattern.compile("^\\s*//(.*)$");
  
      /**
       * Pattern for lines under
       * {@link InlineConfigParser#VIOLATIONS_SOME_LINES_ABOVE_PATTERN}.
       */
      private static final Pattern VIOLATION_MESSAGE_PATTERN = Pattern
              .compile(".*//\\s*(?:['\"](.*)['\"])?$");
      /**
       * A pattern that matches the following comments formats.
       * <ol>
       *     <li> // violation </li>
       *     <li> // violation, 'violation message' </li>
       *     <li> // violation 'violation messages' </li>
       *     <li> // violation, "violation messages" </li>
       *     <li> // violation """multiline violation message </li>
       * </ol>
       *
       * <p>
       * This pattern will not match the following formats.
       * <ol>
      *     <li> // violation, explanation </li>
      *     <li> // violation, explanation, 'violation message' </li>
      * </ol>
      *
      * These are matched by
      * {@link InlineConfigParser#VIOLATION_WITH_EXPLANATION_PATTERN}.
      * </p>
      */
     private static final Pattern VIOLATION_PATTERN = Pattern
             .compile(".*//\\s*violation\\s*(?:['\"](.*)['\"])?$");
 
     /** A pattern to find the string: "// violation above". */
     private static final Pattern VIOLATION_ABOVE_PATTERN = Pattern
             .compile(".*//\\s*violation above\\s*(?:['\"](.*))?$");
 
     /** A pattern to find the string: "// violation below". */
     private static final Pattern VIOLATION_BELOW_PATTERN = Pattern
             .compile(".*//\\s*violation below\\s*(?:['\"](.*))?$");
 
     /** A pattern to find the string: "// violation above, explanation". */
     private static final Pattern VIOLATION_ABOVE_WITH_EXPLANATION_PATTERN = Pattern
             .compile(".*//\\s*violation above,\\s.+\\s(?:['\"](.*)['\"])?$");
 
     /** A pattern to find the string: "// violation below, explanation". */
     private static final Pattern VIOLATION_BELOW_WITH_EXPLANATION_PATTERN = Pattern
             .compile(".*//\\s*violation below,\\s.+\\s(?:['\"](.*)['\"])?$");
 
     /** A pattern to find the string: "// violation, explanation". */
     private static final Pattern VIOLATION_WITH_EXPLANATION_PATTERN = Pattern
             .compile(".*//\\s*violation,\\s+(?:.*)?$");
 
     /** A pattern to find the string: "// X violations". */
     private static final Pattern MULTIPLE_VIOLATIONS_PATTERN = Pattern
             .compile(".*//\\s*(\\d+) violations$");
 
     /** A pattern to find the string: "// X violations above". */
     private static final Pattern MULTIPLE_VIOLATIONS_ABOVE_PATTERN = Pattern
             .compile(".*//\\s*(\\d+) violations above$");
 
     /** A pattern to find the string: "// X violations below". */
     private static final Pattern MULTIPLE_VIOLATIONS_BELOW_PATTERN = Pattern
             .compile(".*//\\s*(\\d+) violations below$");
 
     /** A pattern to find the string: "// filtered violation". */
     private static final Pattern FILTERED_VIOLATION_PATTERN = Pattern
             .compile(".*//\\s*filtered violation\\s*(?:['\"](.*)['\"])?$");
 
     /** A pattern to find the string: "// filtered violation above". */
     private static final Pattern FILTERED_VIOLATION_ABOVE_PATTERN = Pattern
             .compile(".*//\\s*filtered violation above\\s*(?:['\"](.*)['\"])?$");
 
     /** A pattern to find the string: "// filtered violation below". */
     private static final Pattern FILTERED_VIOLATION_BELOW_PATTERN = Pattern
             .compile(".*//\\s*filtered violation below\\s*(?:['\"](.*)['\"])?$");
 
     /** A pattern to find the string: "// filtered violation X lines above". */
     private static final Pattern FILTERED_VIOLATION_SOME_LINES_ABOVE_PATTERN = Pattern
             .compile(".*//\\s*filtered violation (\\d+) lines above\\s*(?:['\"](.*))?$");
 
     /** A pattern to find the string: "// filtered violation X lines below". */
     private static final Pattern FILTERED_VIOLATION_SOME_LINES_BELOW_PATTERN = Pattern
             .compile(".*//\\s*filtered violation (\\d+) lines below\\s*(?:['\"](.*))?$");
 
     /** A pattern to find the string: "// violation X lines above". */
     private static final Pattern VIOLATION_SOME_LINES_ABOVE_PATTERN = Pattern
             .compile(".*//\\s*violation (\\d+) lines above\\s*(?:['\"](.*))?$");
 
     /** A pattern to find the string: "// violation X lines below". */
     private static final Pattern VIOLATION_SOME_LINES_BELOW_PATTERN = Pattern
             .compile(".*//\\s*violation (\\d+) lines below\\s*(?:['\"](.*))?$");
 
     /** A pattern to find the string: "// violation first line". */
     private static final Pattern VIOLATION_FIRST_LINE_PATTERN = Pattern
             .compile(".*//\\s*violation first line\\s*(?:['\"](.*))?$");
 
     /** A pattern to find the string: "// violation last line". */
     private static final Pattern VIOLATION_LAST_LINE_PATTERN = Pattern
             .compile(".*//\\s*violation last line\\s*(?:['\"](.*))?$");
 
     /**
      * <div>
      * Multiple violations for above line. Messages are X lines below.
      * {@code
      *   // X violations above:
      *   //                    'violation message1'
      *   //                    'violation messageX'
      * }
      *
      * Messages are matched by {@link InlineConfigParser#VIOLATION_MESSAGE_PATTERN}
      * </div>
      */
     private static final Pattern VIOLATIONS_ABOVE_PATTERN_WITH_MESSAGES = Pattern
             .compile(".*//\\s*(\\d+) violations above:$");
 
     /**
      * <div>
      * Multiple violations for line. Violations are Y lines above, messages are X lines below.
      * {@code
      *   // X violations Y lines above:
      *   //                            'violation message1'
      *   //                            'violation messageX'
      * }
      *
      * Messages are matched by {@link InlineConfigParser#VIOLATION_MESSAGE_PATTERN}
      * </div>
      */
     private static final Pattern VIOLATIONS_SOME_LINES_ABOVE_PATTERN = Pattern
             .compile(".*//\\s*(\\d+) violations (\\d+) lines above:$");
 
     /**
      * <div>
      * Multiple violations for line. Violations are Y lines below, messages are X lines below.
      * {@code
      *   // X violations Y lines below:
      *   //                            'violation message1'
      *   //                            'violation messageX'
      * }
      *
      * Messages are matched by {@link InlineConfigParser#VIOLATION_MESSAGE_PATTERN}
      * </div>
      */
     private static final Pattern VIOLATIONS_SOME_LINES_BELOW_PATTERN = Pattern
             .compile(".*//\\s*(\\d+) violations (\\d+) lines below:$");
 
     /** A pattern that matches any comment by default. */
     private static final Pattern VIOLATION_DEFAULT = Pattern
             .compile(".*//.*violation.*");
 
     /** The String "(null)". */
     private static final String NULL_STRING = "(null)";
 
     private static final String LATEST_DTD = String.format(Locale.ROOT,
             "<!DOCTYPE module PUBLIC \"%s\" \"%s\">%n",
             ConfigurationLoader.DTD_PUBLIC_CS_ID_1_3,
             ConfigurationLoader.DTD_PUBLIC_CS_ID_1_3);
 
     /**
      * ALLOWED: any code, then "// ok" or "// violation" (lowercase),
      * optionally followed by either a space or a comma (with optional spaces)
      * plus explanation text.
      */
     private static final Pattern ALLOWED_OK_VIOLATION_PATTERN =
             Pattern.compile(".*//\\s*(ok|violation)\\b(?:[ ,]\\s*.*)?$");
 
     /**
      * DETECT any comment containing ok/violation in any case/spacing.
      */
     private static final Pattern ANY_OK_VIOLATION_PATTERN =
             Pattern.compile(".*//\\s*(?i)(ok|violation).*");
 
     /**
      *  Inlined configs can not be used in non-java checks, as Inlined config is java style
      *  multiline comment.
      *  Such check files needs to be permanently suppressed.
      */
     private static final Set<String> PERMANENT_SUPPRESSED_CHECKS = Set.of(
             // Inlined config is not supported for non java files.
             "com.puppycrawl.tools.checkstyle.checks.OrderedPropertiesCheck",
             "com.puppycrawl.tools.checkstyle.checks.UniquePropertiesCheck",
             "com.puppycrawl.tools.checkstyle.checks.TranslationCheck"
     );
 
     /**
      * Checks in which violation message is not yet fully specified in all input files.
      * Temporary suppression until
      * <a href="https://github.com/checkstyle/checkstyle/issues/15456">#15456</a>
      * is fully resolved for these checks. Remove entries here as their input files
      * are updated with proper violation messages.
      */
     private static final Set<String> SUPPRESSED_CHECKS = Set.of(
             "com.puppycrawl.tools.checkstyle.checks.blocks.EmptyBlockCheck",
             "com.puppycrawl.tools.checkstyle.checks.blocks.LeftCurlyCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.EqualsAvoidNullCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.ExplicitInitializationCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.FallThroughCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.FinalLocalVariableCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.HiddenFieldCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.ModifiedControlVariableCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.MultipleStringLiteralsCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.MultipleVariableDeclarationsCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.RequireThisCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.SimplifyBooleanExpressionCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.UnnecessaryParenthesesCheck",
             "com.puppycrawl.tools.checkstyle.checks.coding.VariableDeclarationUsageDistanceCheck",
             "com.puppycrawl.tools.checkstyle.checks.design.HideUtilityClassConstructorCheck",
             "com.puppycrawl.tools.checkstyle.checks.design.VisibilityModifierCheck",
             "com.puppycrawl.tools.checkstyle.checks.imports.CustomImportOrderCheck",
             "com.puppycrawl.tools.checkstyle.checks.javadoc.JavadocMethodCheck",
             "com.puppycrawl.tools.checkstyle.checks.javadoc.JavadocTypeCheck",
             "com.puppycrawl.tools.checkstyle.checks.javadoc.JavadocVariableCheck",
             "com.puppycrawl.tools.checkstyle.checks.naming.ParameterNameCheck",
             "com.puppycrawl.tools.checkstyle.checks.sizes.MethodCountCheck",
             "com.puppycrawl.tools.checkstyle.checks.whitespace.EmptyLineSeparatorCheck",
             "com.puppycrawl.tools.checkstyle.checks.whitespace.GenericWhitespaceCheck",
             "com.puppycrawl.tools.checkstyle.checks.whitespace.OperatorWrapCheck",
             "com.puppycrawl.tools.checkstyle.checks.whitespace.WhitespaceAfterCheck"
     );
 
     /**
      * Input files where violation messages are not yet fully specified with quoted
      * messages. Temporary suppression until these files are updated with proper
      * violation messages. Remove entries here as their input files are fixed.
      * <a href="https://github.com/checkstyle/checkstyle/issues/20954">#20954</a>
      */
     private static final Set<String> SUPPRESSED_VALIDATE_MESSAGE_FILES = Set.of(
             "checks/coding/equalshashcode/Example1.java",
             "checks/coding/noclone/Example1.java",
             "checks/coding/unusedlocalvariable/Example1.java",
             "checks/sizes/recordcomponentnumber/Example2.java",
             "checks/whitespace/separatorwrap/Example1.java",
             "com/google/checkstyle/test/chapter5naming/rule53camelcase/"
                     + "InputUnderscoreUsedInNames.java"
     );
 
     /**
      * Input files where default values for properties are intentionally not specified.
      * This two required for pitest coverage in javadoc and util profiles:
      * checks/javadoc/abstractjavadoc/InputAbstractJavadocTokensPass.java
      */
     private static final Set<String> SUPPRESSED_VALIDATE_DEFAULT_FILES = Set.of(
         "checks/coding/matchxpath/InputMatchXpath2.java",
         "checks/javadoc/abstractjavadoc/InputAbstractJavadocTokensFail.java",
         "checks/javadoc/abstractjavadoc/InputAbstractJavadocNonTightHtmlTags2.java",
         "checks/javadoc/abstractjavadoc/InputAbstractJavadocNonTightHtmlTags3.java",
         "checks/javadoc/abstractjavadoc/InputAbstractJavadocNonTightHtmlTagsOne.java",
         "checks/javadoc/abstractjavadoc/InputAbstractJavadocNonTightHtmlTagsTwo.java",
         "checks/javadoc/abstractjavadoc/InputAbstractJavadocNonTightHtmlTagsVisitCountOne.java",
         "checks/javadoc/abstractjavadoc/InputAbstractJavadocNonTightHtmlTagsVisitCountTwo.java",
         "checks/javadoc/abstractjavadoc/InputAbstractJavadocTokensPass.java",
         "checkstyle/checks/imports/importcontrol/InputImportControlFileNameNoExtension"
     );
 
     // This is a hack until https://github.com/checkstyle/checkstyle/issues/13845
     private static final Map<String, String> MODULE_MAPPINGS = new HashMap<>();
 
     private static final Map<String, ModuleDetails> PUBLIC_MODULE_DETAILS_MAP = new HashMap<>();
 
     // -@cs[ExecutableStatementCount] Suppressing due to large module mappings
     static {
         MODULE_MAPPINGS.put("IllegalCatch",
                 "com.puppycrawl.tools.checkstyle.checks.coding.IllegalCatchCheck");
         MODULE_MAPPINGS.put("MagicNumber",
                 "com.puppycrawl.tools.checkstyle.checks.coding.MagicNumberCheck");
         MODULE_MAPPINGS.put("SummaryJavadoc",
                 "com.puppycrawl.tools.checkstyle.checks.javadoc.SummaryJavadocCheck");
         MODULE_MAPPINGS.put("ClassDataAbstractionCoupling",
                 "com.puppycrawl.tools.checkstyle.checks.metrics.ClassDataAbstractionCouplingCheck");
         MODULE_MAPPINGS.put("ConstantName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.ConstantNameCheck");
         MODULE_MAPPINGS.put("MemberName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.MemberNameCheck");
         MODULE_MAPPINGS.put("GoogleNonConstantFieldName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.GoogleNonConstantFieldNameCheck");
         MODULE_MAPPINGS.put("MethodName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.MethodNameCheck");
         MODULE_MAPPINGS.put("GoogleMethodName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.GoogleMethodNameCheck");
         MODULE_MAPPINGS.put("ParameterName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.ParameterNameCheck");
         MODULE_MAPPINGS.put("RegexpOnFilename",
                 "com.puppycrawl.tools.checkstyle.checks.regexp.RegexpOnFilenameCheck");
         MODULE_MAPPINGS.put("RegexpSingleline",
                 "com.puppycrawl.tools.checkstyle.checks.regexp.RegexpSinglelineCheck");
         MODULE_MAPPINGS.put("RegexpSinglelineJava",
                 "com.puppycrawl.tools.checkstyle.checks.regexp.RegexpSinglelineJavaCheck");
         MODULE_MAPPINGS.put("LineLength",
                 "com.puppycrawl.tools.checkstyle.checks.sizes.LineLengthCheck");
         MODULE_MAPPINGS.put("ParameterNumber",
                 "com.puppycrawl.tools.checkstyle.checks.sizes.ParameterNumberCheck");
         MODULE_MAPPINGS.put("NoWhitespaceAfter",
                 "com.puppycrawl.tools.checkstyle.checks.whitespace.NoWhitespaceAfterCheck");
         MODULE_MAPPINGS.put("OrderedProperties",
                 "com.puppycrawl.tools.checkstyle.checks.OrderedPropertiesCheck");
         MODULE_MAPPINGS.put("SuppressWarningsHolder",
                 "com.puppycrawl.tools.checkstyle.checks.SuppressWarningsHolder");
         MODULE_MAPPINGS.put("UniqueProperties",
                 "com.puppycrawl.tools.checkstyle.checks.UniquePropertiesCheck");
         MODULE_MAPPINGS.put("SuppressionXpathSingleFilter",
                 "com.puppycrawl.tools.checkstyle.filters.SuppressionXpathSingleFilter");
         MODULE_MAPPINGS.put("SuppressWarningsFilter",
                 "com.puppycrawl.tools.checkstyle.filters.SuppressWarningsFilter");
         MODULE_MAPPINGS.put("LeftCurly",
                 "com.puppycrawl.tools.checkstyle.checks.blocks.LeftCurlyCheck");
         MODULE_MAPPINGS.put("RequireThis",
                 "com.puppycrawl.tools.checkstyle.checks.coding.RequireThisCheck");
         MODULE_MAPPINGS.put("IllegalThrows",
                 "com.puppycrawl.tools.checkstyle.checks.coding.IllegalThrowsCheck");
         MODULE_MAPPINGS.put("LocalFinalVariableName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.LocalFinalVariableNameCheck");
         MODULE_MAPPINGS.put("PackageName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.PackageNameCheck");
         MODULE_MAPPINGS.put("RedundantModifier",
                 "com.puppycrawl.tools.checkstyle.checks.modifier.RedundantModifierCheck");
         MODULE_MAPPINGS.put("AbstractClassName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.AbstractClassNameCheck");
         MODULE_MAPPINGS.put("JavadocMethod",
                 "com.puppycrawl.tools.checkstyle.checks.javadoc.JavadocMethodCheck");
         MODULE_MAPPINGS.put("IllegalIdentifierName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.IllegalIdentifierNameCheck");
         MODULE_MAPPINGS.put("FileLength",
                 "com.puppycrawl.tools.checkstyle.checks.sizes.FileLengthCheck");
         MODULE_MAPPINGS.put("EqualsAvoidNull",
                 "com.puppycrawl.tools.checkstyle.checks.coding.EqualsAvoidNullCheck");
         MODULE_MAPPINGS.put("CyclomaticComplexity",
                 "com.puppycrawl.tools.checkstyle.checks.metrics.CyclomaticComplexityCheck");
         MODULE_MAPPINGS.put("EmptyLineSeparator",
                 "com.puppycrawl.tools.checkstyle.checks.whitespace.EmptyLineSeparatorCheck");
         MODULE_MAPPINGS.put("LocalVariableName",
                 "com.puppycrawl.tools.checkstyle.checks.naming.LocalVariableNameCheck");
         MODULE_MAPPINGS.put("ModifierOrder",
                 "com.puppycrawl.tools.checkstyle.checks.modifier.ModifierOrderCheck");
     }
 
     /** Stop instances being created. */
     private InlineConfigParser() {
     }
 
     public static TestInputConfiguration parse(String inputFilePath) throws Exception {
         return parse(inputFilePath, false);
     }
 
     /**
      * Parses the input file provided.
      *
      * @param inputFilePath the input file path.
      * @param setFilteredViolations flag to set filtered violations.
      * @throws Exception if unable to read file or file not formatted properly.
      */
     private static TestInputConfiguration parse(String inputFilePath,
                                                 boolean setFilteredViolations) throws Exception {
         final TestInputConfiguration.Builder testInputConfigBuilder =
                 new TestInputConfiguration.Builder();
         final Path filePath = Path.of(inputFilePath);
         final List<String> lines = readFile(filePath);
         try {
             setModules(testInputConfigBuilder, inputFilePath, lines);
         }
         catch (Exception exc) {
             throw new CheckstyleException("Config comment not specified properly in "
                     + inputFilePath, exc);
         }
         try {
             setViolations(testInputConfigBuilder, lines, setFilteredViolations, inputFilePath);
         }
         catch (CheckstyleException exc) {
             throw new CheckstyleException("Failed to set violations in " + inputFilePath, exc);
         }
         return testInputConfigBuilder.build();
     }
 
     public static List<TestInputViolation> getViolationsFromInputFile(String inputFilePath)
             throws Exception {
         final TestInputConfiguration.Builder testInputConfigBuilder =
                 new TestInputConfiguration.Builder();
         final Path filePath = Path.of(inputFilePath);
         final List<String> lines = readFile(filePath);
 
         try {
             for (int lineNo = 0; lineNo < lines.size(); lineNo++) {
                 setViolations(testInputConfigBuilder, lines, false, lineNo, true);
             }
         }
         catch (CheckstyleException exc) {
             throw new CheckstyleException("Failed to set violations in " + inputFilePath, exc);
         }
 
         return testInputConfigBuilder.build().violations();
     }
 
     public static List<TestInputViolation> getFilteredViolationsFromInputFile(String inputFilePath)
             throws Exception {
         final TestInputConfiguration.Builder testInputConfigBuilder =
                 new TestInputConfiguration.Builder();
         final Path filePath = Path.of(inputFilePath);
         final List<String> lines = readFile(filePath);
 
         try {
             for (int lineNo = 0; lineNo < lines.size(); lineNo++) {
                 setViolations(testInputConfigBuilder, lines, true, lineNo, true);
             }
         }
         catch (CheckstyleException exc) {
             throw new CheckstyleException("Failed to set violations in " + inputFilePath, exc);
         }
 
         return testInputConfigBuilder.build().filteredViolations();
     }
 
     public static TestInputConfiguration parseWithFilteredViolations(String inputFilePath)
             throws Exception {
         return parse(inputFilePath, true);
     }
 
     /**
      * Parse the input file with configuration in xml header.
      *
      * @param inputFilePath the input file path.
      * @throws Exception if unable to parse the xml header
      */
     public static TestInputConfiguration parseWithXmlHeader(String inputFilePath)
             throws Exception {
 
         final Path filePath = Path.of(inputFilePath);
         final List<String> lines = readFile(filePath);
         final InlineConfigUtils.MatchedDelimiter matched =
                 InlineConfigUtils.matchDelimiter(lines, inputFilePath);
         if (matched == null || !matched.xmlStyleConfig()) {
             throw new CheckstyleException("Config cannot be parsed as xml.");
         }
 
         final List<String> inlineConfig = getInlineConfig(lines, inputFilePath, matched);
         final String stringXmlConfig = LATEST_DTD + String.join("", inlineConfig);
         final InputSource inputSource = new InputSource(new StringReader(stringXmlConfig));
         final Configuration xmlConfig = ConfigurationLoader.loadConfiguration(
                 inputSource, new PropertiesExpander(System.getProperties()),
                 ConfigurationLoader.IgnoredModulesOptions.EXECUTE
         );
         final String configName = xmlConfig.getName();
         if (!"Checker".equals(configName)) {
             throw new CheckstyleException(
                     "First module should be Checker, but was " + configName);
         }
 
         final TestInputConfiguration.Builder testInputConfigBuilder =
                 new TestInputConfiguration.Builder();
         testInputConfigBuilder.setXmlConfiguration(xmlConfig);
         try {
             setViolations(testInputConfigBuilder, lines, false, inputFilePath);
         }
         catch (CheckstyleException exc) {
             throw new CheckstyleException("Failed to set violations in " + inputFilePath, exc);
         }
         return testInputConfigBuilder.buildWithXmlConfiguration();
     }
 
     private static void setModules(TestInputConfiguration.Builder testInputConfigBuilder,
                                    String inputFilePath, List<String> lines)
             throws Exception {
         final InlineConfigUtils.MatchedDelimiter matched =
                 InlineConfigUtils.matchDelimiter(lines, inputFilePath);
         if (matched == null) {
             throw new CheckstyleException("Config not specified on top. Expected "
                     + InlineConfigUtils.describeExpectedDelimiters(inputFilePath)
                     + " as the first line. Please see other inputs for examples of what"
                     + " is required.");
         }
 
         final List<String> inlineConfig = getInlineConfig(lines, inputFilePath, matched);
 
         if (matched.xmlStyleConfig()) {
             final String stringXmlConfig = LATEST_DTD + String.join("", inlineConfig);
             final InputSource inputSource = new InputSource(new StringReader(stringXmlConfig));
             final Configuration xmlConfig = ConfigurationLoader.loadConfiguration(
                     inputSource, new PropertiesExpander(System.getProperties()),
                     ConfigurationLoader.IgnoredModulesOptions.EXECUTE
             );
             final String configName = xmlConfig.getName();
             if (!"Checker".equals(configName)) {
                 throw new CheckstyleException(
                         "First module should be Checker, but was " + configName);
             }
             handleXmlConfig(testInputConfigBuilder, inputFilePath, xmlConfig.getChildren());
         }
         else {
             handleKeyValueConfig(testInputConfigBuilder, inputFilePath, inlineConfig);
         }
     }
 
     /**
      * Extracts the raw config lines (between the start and end delimiter) for the given
      * file, stripping the leading {@code #} comment marker from each line when the target
      * file is a {@code .properties} file (since every config line there must itself be a
      * valid properties-file comment).
      *
      * @param lines all lines of the file.
      * @param inputFilePath the input file path, used to select the delimiter and
      *     line-prefix-stripping behavior.
      * @return the inline config lines, ready to be parsed as XML or key-value pairs.
      */
     private static List<String> getInlineConfig(List<String> lines, String inputFilePath,
                                                 InlineConfigUtils.MatchedDelimiter matched) {
         final int endIndex = InlineConfigUtils.getConfigEndIndex(lines, matched);
         final int startIndex;
         if (matched.end() == null) {
             startIndex = 0;
         }
         else {
             startIndex = 1;
         }
         final List<String> rawConfigLines = lines.subList(startIndex, endIndex);
 
         final List<String> result;
         if (inputFilePath.endsWith(".properties")) {
             result = InlineConfigUtils.stripPropertiesCommentPrefix(rawConfigLines);
         }
         else {
             result = rawConfigLines;
         }
         return result;
     }
 
     private static void handleXmlConfig(TestInputConfiguration.Builder testInputConfigBuilder,
                                         String inputFilePath,
                                         Configuration... modules)
             throws CheckstyleException {
 
         for (Configuration module: modules) {
             final String moduleName = module.getName();
             if ("TreeWalker".equals(moduleName)) {
                 handleXmlConfig(testInputConfigBuilder, inputFilePath, module.getChildren());
             }
             else {
                 final ModuleInputConfiguration.Builder moduleInputConfigBuilder =
                         new ModuleInputConfiguration.Builder();
                 setModuleName(moduleInputConfigBuilder, inputFilePath, moduleName);
                 setProperties(inputFilePath, module, moduleInputConfigBuilder);
                 testInputConfigBuilder.addChildModule(moduleInputConfigBuilder.build());
             }
         }
     }
 
     private static void handleKeyValueConfig(TestInputConfiguration.Builder testInputConfigBuilder,
                                              String inputFilePath, List<String> lines)
             throws CheckstyleException, IOException, ReflectiveOperationException {
         int lineNo = 0;
         while (lineNo < lines.size()) {
             final ModuleInputConfiguration.Builder moduleInputConfigBuilder =
                     new ModuleInputConfiguration.Builder();
             final String moduleName = lines.get(lineNo);
             setModuleName(moduleInputConfigBuilder, inputFilePath, moduleName);
             setProperties(moduleInputConfigBuilder, inputFilePath, lines, lineNo + 1, moduleName);
             testInputConfigBuilder.addChildModule(moduleInputConfigBuilder.build());
             do {
                 lineNo++;
             } while (lineNo < lines.size()
                     && lines.get(lineNo).isEmpty()
                     || !lines.get(lineNo - 1).isEmpty());
         }
     }
 
     private static Map<String, String> getDefaultProperties(String fullyQualifiedClassName) {
 
         final Map<String, String> defaultProperties = new HashMap<>();
 
         if (PUBLIC_MODULE_DETAILS_MAP.isEmpty()) {
             XmlMetaReader.readAllModulesIncludingThirdPartyIfAny().forEach(module -> {
                 PUBLIC_MODULE_DETAILS_MAP.put(module.getFullQualifiedName(), module);
             });
         }
 
         final ModuleDetails moduleDetails = PUBLIC_MODULE_DETAILS_MAP.get(fullyQualifiedClassName);
 
         if (moduleDetails != null) {
             defaultProperties.putAll(moduleDetails.getProperties().stream()
                     .filter(prop -> prop.getName() != null)
                     .collect(Collectors.toUnmodifiableMap(
                         ModulePropertyDetails::getName,
                         prop -> {
                             final String value;
                             if (prop.getDefaultValue() == null) {
                                 value = "null";
                             }
                             else {
                                 value = prop.getDefaultValue();
                             }
                             return value;
                         }
                     ))
             );
         }
 
         return defaultProperties;
     }
 
     private static String getFullyQualifiedClassName(String filePath, String moduleName)
             throws CheckstyleException {
         String fullyQualifiedClassName;
         if (MODULE_MAPPINGS.containsKey(moduleName)) {
             fullyQualifiedClassName = MODULE_MAPPINGS.get(moduleName);
         }
         else if (moduleName.startsWith("com.")) {
             fullyQualifiedClassName = moduleName;
         }
         else {
             final String path = SLASH_PATTERN.matcher(filePath).replaceAll(".");
             final int endIndex = path.lastIndexOf(moduleName.toLowerCase(Locale.ROOT));
             if (endIndex == -1) {
                 throw new CheckstyleException("Unable to resolve module name: " + moduleName
                     + ". Please check for spelling errors or specify fully qualified class name.");
             }
             final int beginIndex = path.indexOf("com.puppycrawl");
             fullyQualifiedClassName = path.substring(beginIndex, endIndex) + moduleName;
             if (!fullyQualifiedClassName.endsWith("Filter")) {
                 fullyQualifiedClassName += "Check";
             }
         }
         return fullyQualifiedClassName;
     }
 
     private static String getFilePath(String fileName, String inputFilePath) {
         final int lastSlashIndex = Math.max(inputFilePath.lastIndexOf('\\'),
                 inputFilePath.lastIndexOf('/'));
         final String root = inputFilePath.substring(0, lastSlashIndex + 1);
         return root + fileName;
     }
 
     private static String getResourcePath(String fileName, String inputFilePath) {
         final String filePath = getUriPath(fileName, inputFilePath);
         final int lastSlashIndex = filePath.lastIndexOf('/');
         final String root = filePath.substring(filePath.indexOf("puppycrawl") - 5,
                 lastSlashIndex + 1);
         return root + fileName;
     }
 
     private static String getUriPath(String fileName, String inputFilePath) {
         return new File(getFilePath(fileName, inputFilePath)).toURI().toString();
     }
 
     private static String getResolvedPath(String fileValue, String inputFilePath) {
         final String resolvedFilePath;
 
         if (fileValue.startsWith("(resource)")) {
             resolvedFilePath =
                     getResourcePath(fileValue.substring(fileValue.indexOf(')') + 1),
                             inputFilePath);
         }
         else if (fileValue.startsWith("(uri)")) {
             resolvedFilePath =
                     getUriPath(fileValue.substring(fileValue.indexOf(')') + 1), inputFilePath);
         }
         else if (fileValue.contains("/") || fileValue.contains("\\")) {
             resolvedFilePath = fileValue;
         }
         else {
             resolvedFilePath = getFilePath(fileValue, inputFilePath);
         }
 
         return resolvedFilePath;
     }
 
     private static List<String> readFile(Path filePath) throws CheckstyleException {
         try {
             return Files.readAllLines(filePath);
         }
         catch (IOException exc) {
             throw new CheckstyleException("Failed to read " + filePath, exc);
         }
     }
 
     private static void setModuleName(ModuleInputConfiguration.Builder moduleInputConfigBuilder,
                                       String filePath, String moduleName)
             throws CheckstyleException {
         final String fullyQualifiedClassName = getFullyQualifiedClassName(filePath, moduleName);
         moduleInputConfigBuilder.setModuleName(fullyQualifiedClassName);
     }
 
     private static String toStringConvertForArrayValue(Object value) {
         String result = NULL_STRING;
 
         if (value instanceof double[] arr) {
             result = Arrays.stream(arr)
                            .boxed()
                            .map(number -> {
                                return BigDecimal.valueOf(number)
                                                 .stripTrailingZeros()
                                                 .toPlainString();
                            })
                            .collect(Collectors.joining(","));
         }
         else if (value instanceof int[] ints) {
             result = Arrays.toString(ints).replaceAll("[\\[\\]\\s]", "");
         }
         else if (value instanceof boolean[] booleans) {
             result = Arrays.toString(booleans).replaceAll("[\\[\\]\\s]", "");
         }
         else if (value instanceof long[] longs) {
             result = Arrays.toString(longs).replaceAll("[\\[\\]\\s]", "");
         }
         else if (value instanceof Object[] objects) {
             result = Arrays.toString(objects).replaceAll("[\\[\\]\\s]", "");
         }
         return result;
     }
 
     /**
      * Validate default value.
      *
      * @param propertyName the property name.
      * @param propertyDefaultValue the specified default value in the file.
      * @param fullyQualifiedModuleName the fully qualified module name.
      */
     private static void validateDefault(String propertyName,
                                            String propertyDefaultValue,
                                            String fullyQualifiedModuleName)
             throws ReflectiveOperationException {
         final Object checkInstance = createCheckInstance(fullyQualifiedModuleName);
         final Object actualDefault;
         final Class<?> propertyType;
         final String actualDefaultAsString;
 
         if ("tokens".equals(propertyName)) {
             actualDefault = TestUtil.invokeMethod(checkInstance,
                     "getDefaultTokens", Object.class);
             propertyType = actualDefault.getClass();
             final int[] arr = (int[]) actualDefault;
             actualDefaultAsString = Arrays.stream(arr)
                                           .mapToObj(TokenUtil::getTokenName)
                                           .collect(Collectors.joining(", "));
         }
         else if ("javadocTokens".equals(propertyName)) {
             actualDefault = TestUtil.invokeMethod(checkInstance,
                     "getDefaultJavadocTokens", Object.class);
             propertyType = actualDefault.getClass();
             final int[] arr = (int[]) actualDefault;
             actualDefaultAsString = Arrays.stream(arr)
                                           .mapToObj(JavadocUtil::getTokenName)
                                           .collect(Collectors.joining(", "));
         }
         else {
             actualDefault = getPropertyDefaultValue(checkInstance, propertyName);
             if (actualDefault == null) {
                 propertyType = null;
             }
             else {
                 propertyType = actualDefault.getClass();
             }
             actualDefaultAsString = convertDefaultValueToString(actualDefault);
         }
         if (!isDefaultValue(propertyDefaultValue, actualDefaultAsString, propertyType)) {
             final String message = String.format(Locale.ROOT,
                     "Default value mismatch for %s in %s: specified '%s' but actually is '%s'",
                     propertyName, fullyQualifiedModuleName,
                     propertyDefaultValue, actualDefaultAsString);
             throw new IllegalArgumentException(message);
         }
     }
 
     private static boolean isCollectionValues(String specifiedDefault, String actualDefault) {
         final Set<String> specifiedSet = new HashSet<>(
             Arrays.asList(specifiedDefault.replaceAll("[\\[\\]\\s]", "").split(",")));
         final Set<String> actualSet = new HashSet<>(
             Arrays.asList(actualDefault.replaceAll("[\\[\\]\\s]", "").split(",")));
         return actualSet.equals(specifiedSet);
     }
 
     private static String convertDefaultValueToString(Object value) {
         final String defaultValueAsString;
         if (value == null) {
             defaultValueAsString = NULL_STRING;
         }
         else if (value instanceof String strValue) {
             defaultValueAsString = toStringForStringValue(strValue);
         }
         else if (value.getClass().isArray()) {
             defaultValueAsString = toStringConvertForArrayValue(value);
         }
         else if (value instanceof BitSet set) {
             defaultValueAsString = toStringForBitSetValue(set);
         }
         else if (value instanceof Collection<?> values) {
             defaultValueAsString = toStringForCollectionValue(values);
         }
         else {
             defaultValueAsString = String.valueOf(value);
         }
         return defaultValueAsString;
     }
 
     private static String toStringForStringValue(String strValue) {
         final String str;
         if (strValue.startsWith("(") && strValue.endsWith(")")) {
             str = strValue.substring(1, strValue.length() - 1);
         }
         else {
             str = strValue;
         }
         return str;
     }
 
     private static String toStringForBitSetValue(BitSet bitSet) {
         return bitSet.stream()
                      .mapToObj(TokenUtil::getTokenName)
                      .collect(Collectors.joining(","));
     }
 
     private static String toStringForCollectionValue(Collection<?> collection) {
         return collection.toString().replaceAll("[\\[\\]\\s]", "");
     }
 
     /**
      * Validate default value.
      *
      * @param propertyDefaultValue the specified default value in the file.
      * @param actualDefault the actual default value
      * @param fieldType the data type of default value.
      */
     private static boolean isDefaultValue(final String propertyDefaultValue,
                                           final String actualDefault,
                                           final Class<?> fieldType) {
         final boolean result;
 
         if (NULL_STRING.equals(actualDefault)) {
             result = isNull(propertyDefaultValue);
         }
         else if (isNumericType(fieldType)) {
             final BigDecimal specified = new BigDecimal(propertyDefaultValue);
             final BigDecimal actual = new BigDecimal(actualDefault);
             result = specified.compareTo(actual) == 0;
         }
         else if (fieldType.isArray()
             || Collection.class.isAssignableFrom(fieldType)
             || BitSet.class.isAssignableFrom(fieldType)) {
             result = isCollectionValues(propertyDefaultValue, actualDefault);
         }
         else if (fieldType.isEnum() || fieldType.isLocalClass()) {
             result = propertyDefaultValue.equalsIgnoreCase(actualDefault);
         }
         else {
             result = propertyDefaultValue.equals(actualDefault);
         }
         return result;
     }
 
     private static Object createCheckInstance(String className) throws
             ReflectiveOperationException {
         final Class<?> checkClass = Class.forName(className);
         return TestUtil.instantiate(checkClass);
     }
 
     private static String readPropertiesContent(int beginLineNo, List<String> lines) {
         final StringBuilder stringBuilder = new StringBuilder(128);
         int lineNo = beginLineNo;
         String line = lines.get(lineNo);
         while (!line.isEmpty() && !"*/".equals(line)) {
             stringBuilder.append(line).append('\n');
             lineNo++;
             line = lines.get(lineNo);
         }
         return stringBuilder.toString();
     }
 
     private static void validateProperties(Map<String, String> propertiesWithMissingDefaultTag,
             List<String> unusedProperties) throws CheckstyleException {
 
         if (!propertiesWithMissingDefaultTag.isEmpty()) {
 
             final String propertiesList = propertiesWithMissingDefaultTag.entrySet().stream()
                     .map(entry -> {
                         return String.format(Locale.ROOT, "%s = (default)%s",
                                 entry.getKey(), entry.getValue());
                     })
                     .collect(Collectors.joining(", "));
 
             final String message = String.format(Locale.ROOT,
                     "Default properties must use the '(default)' tag."
                     + " Properties missing the '(default)' tag: %s", propertiesList);
             throw new CheckstyleException(message);
         }
         if (!unusedProperties.isEmpty()) {
             final String message = String.format(Locale.ROOT,
                     "All properties must be explicitly specified."
                     + " Found unused properties: %s", unusedProperties);
             throw new CheckstyleException(message);
         }
     }
 
     private static void validateDefaultProperties(
         Map<Object, Object> actualProperties,
         Map<String, String> defaultProperties) throws CheckstyleException {
 
         final Map<String, String> propertiesWithMissingDefaultTag = actualProperties
                 .entrySet().stream()
                 .filter(entry -> !"id".equals(entry.getKey().toString()))
                 .filter(entry -> !"tabWidth".equals(entry.getKey().toString()))
                 .filter(entry -> !"severity".equals(entry.getKey().toString()))
                 .filter(entry -> !entry.getKey().toString().startsWith("message."))
                 .filter(entry -> !entry.getValue().toString().startsWith("(default)"))
                 .filter(entry -> {
                     return defaultProperties
                             .get(entry.getKey().toString())
                             .equals(entry.getValue().toString());
                 })
                 .collect(HashMap::new,
                         (map, entry) -> {
                         map.put(entry.getKey().toString(), entry.getValue().toString());
                     }, HashMap::putAll);
         final List<String> unusedProperties = defaultProperties.keySet().stream()
                 .filter(propertyName -> !actualProperties.containsKey(propertyName))
                 .toList();
 
         validateProperties(propertiesWithMissingDefaultTag, unusedProperties);
     }
 
     private static void setProperties(String inputFilePath, Configuration module,
                                       ModuleInputConfiguration.Builder moduleInputConfigBuilder)
             throws CheckstyleException {
         final String[] getPropertyNames = module.getPropertyNames();
         for (final String propertyName : getPropertyNames) {
             final String propertyValue = module.getProperty(propertyName);
 
             if ("file".equals(propertyName)) {
                 final String filePath = getResolvedPath(propertyValue, inputFilePath);
                 moduleInputConfigBuilder.addNonDefaultProperty(propertyName, filePath);
             }
             else {
                 if (NULL_STRING.equals(propertyValue)) {
                     moduleInputConfigBuilder.addNonDefaultProperty(propertyName, null);
                 }
                 else {
                     moduleInputConfigBuilder.addNonDefaultProperty(propertyName, propertyValue);
                 }
             }
         }
 
         final Map<String, String> messages = module.getMessages();
         for (final Map.Entry<String, String> entry : messages.entrySet()) {
             final String key = entry.getKey();
             final String value = entry.getValue();
             moduleInputConfigBuilder.addModuleMessage(key, value);
         }
     }
 
     private static void setProperties(ModuleInputConfiguration.Builder inputConfigBuilder,
                             String inputFilePath,
                             List<String> lines,
                             int beginLineNo, String moduleName)
             throws IOException, CheckstyleException, ReflectiveOperationException {
 
         final String propertyContent = readPropertiesContent(beginLineNo, lines);
         final Map<Object, Object> properties = loadProperties(propertyContent);
         final String fullyQualifiedClassName =
                 getFullyQualifiedClassName(inputFilePath, moduleName);
 
         final boolean isSuppressedValidateDefaultFile = SUPPRESSED_VALIDATE_DEFAULT_FILES.stream()
                 .anyMatch(Path.of(inputFilePath)::endsWith);
 
         if (!isSuppressedValidateDefaultFile) {
             validateDefaultProperties(properties, getDefaultProperties(fullyQualifiedClassName));
         }
 
         for (final Map.Entry<Object, Object> entry : properties.entrySet()) {
             final String key = entry.getKey().toString();
             final String value = entry.getValue().toString();
 
             if (key.startsWith("message.")) {
                 inputConfigBuilder.addModuleMessage(key.substring(8), value);
             }
             else if (NULL_STRING.equals(value)) {
                 inputConfigBuilder.addNonDefaultProperty(key, null);
             }
             else if (value.startsWith("(file)")) {
                 final String fileName = value.substring(value.indexOf(')') + 1);
                 final String filePath = getResolvedPath(fileName, inputFilePath);
                 inputConfigBuilder.addNonDefaultProperty(key, filePath);
             }
             else if (value.startsWith("(default)")) {
                 final String defaultValue = value.substring(value.indexOf(')') + 1);
                 if (!isSuppressedValidateDefaultFile) {
                     validateDefault(key, defaultValue, fullyQualifiedClassName);
                 }
                 if (NULL_STRING.equals(defaultValue)) {
                     inputConfigBuilder.addDefaultProperty(key, null);
                 }
                 else {
                     inputConfigBuilder.addDefaultProperty(key, defaultValue);
                 }
             }
             else {
                 inputConfigBuilder.addNonDefaultProperty(key, value);
             }
         }
     }
 
     private static boolean shouldSpecifyViolationMessage(
             TestInputConfiguration.Builder inputConfigBuilder, String inputFilePath) {
 
         boolean result = false;
 
         final List<ModuleInputConfiguration> moduleLists =
                 inputConfigBuilder.getChildrenModules();
 
         final boolean isSuppressedFile = SUPPRESSED_VALIDATE_MESSAGE_FILES.stream()
                 .anyMatch(Path.of(inputFilePath)::endsWith);
 
         if (!isSuppressedFile && moduleLists.size() == 1) {
             final String moduleName = moduleLists.getFirst().getModuleName();
 
             if (!PERMANENT_SUPPRESSED_CHECKS.contains(moduleName)
                     && !SUPPRESSED_CHECKS.contains(moduleName)) {
                 result = true;
             }
         }
 
         return result;
     }
 
     private static void setViolations(TestInputConfiguration.Builder inputConfigBuilder,
                                       List<String> lines,
                                       boolean useFilteredViolations,
                                       String inputFilePath)
             throws CheckstyleException {
 
         final boolean specifyViolationMessage =
                 shouldSpecifyViolationMessage(inputConfigBuilder, inputFilePath);
 
         for (int lineNo = 0; lineNo < lines.size(); lineNo++) {
             setViolations(inputConfigBuilder, lines,
                     useFilteredViolations, lineNo, specifyViolationMessage);
         }
     }
 
     /**
      * Sets the violations.
      *
      * @param inputConfigBuilder the input file path.
      * @param lines all the lines in the file.
      * @param useFilteredViolations flag to set filtered violations.
      * @param lineNo current line.
      * @noinspection IfStatementWithTooManyBranches
      * @noinspectionreason IfStatementWithTooManyBranches - complex logic of violation
      *      parser requires giant if/else
      * @throws CheckstyleException if violation message is not specified
      */
     // -@cs[JavaNCSS|CyclomaticComplexity] splitting this method is not reasonable.
     // -@cs[MethodLength|ExecutableStatementCount] splitting this method is not reasonable.
     private static void setViolations(TestInputConfiguration.Builder inputConfigBuilder,
                                       List<String> lines, boolean useFilteredViolations,
                                       int lineNo, boolean specifyViolationMessage)
             throws CheckstyleException {
         final String line = lines.get(lineNo);
         if (ANY_OK_VIOLATION_PATTERN.matcher(line).matches()
                 && !ALLOWED_OK_VIOLATION_PATTERN.matcher(line).matches()) {
             throw new CheckstyleException(
                     "Invalid format (must be \"// ok...\" or \"// violation...\"): " + line);
         }
 
         final Matcher violationMatcher =
                 VIOLATION_PATTERN.matcher(line);
         final Matcher violationAboveMatcher =
                 VIOLATION_ABOVE_PATTERN.matcher(line);
         final Matcher violationBelowMatcher =
                 VIOLATION_BELOW_PATTERN.matcher(line);
         final Matcher violationAboveWithExplanationMatcher =
                 VIOLATION_ABOVE_WITH_EXPLANATION_PATTERN.matcher(line);
         final Matcher violationBelowWithExplanationMatcher =
                 VIOLATION_BELOW_WITH_EXPLANATION_PATTERN.matcher(line);
         final Matcher violationWithExplanationMatcher =
                 VIOLATION_WITH_EXPLANATION_PATTERN.matcher(line);
         final Matcher violationSomeLinesAboveMatcher =
                 VIOLATION_SOME_LINES_ABOVE_PATTERN.matcher(line);
         final Matcher violationSomeLinesBelowMatcher =
                 VIOLATION_SOME_LINES_BELOW_PATTERN.matcher(line);
         final Matcher violationFirstLineMatcher =
                 VIOLATION_FIRST_LINE_PATTERN.matcher(line);
         final Matcher violationLastLineMatcher =
                 VIOLATION_LAST_LINE_PATTERN.matcher(line);
 
         if (violationMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationMatcher.group(1), lines, lineNo);
             final int violationLineNum = lineNo + 1;
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                     violationLineNum);
             inputConfigBuilder.addViolation(violationLineNum, violationMessage);
         }
         else if (violationAboveMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationAboveMatcher.group(1), lines, lineNo);
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage, lineNo);
             inputConfigBuilder.addViolation(lineNo, violationMessage);
         }
         else if (violationBelowMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationBelowMatcher.group(1), lines, lineNo);
             final int violationLineNum = lineNo + 2;
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                     violationLineNum);
             inputConfigBuilder.addViolation(violationLineNum, violationMessage);
         }
         else if (violationAboveWithExplanationMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationAboveWithExplanationMatcher.group(1), lines, lineNo);
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage, lineNo);
             inputConfigBuilder.addViolation(lineNo, violationMessage);
         }
         else if (violationBelowWithExplanationMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationBelowWithExplanationMatcher.group(1), lines, lineNo);
             final int violationLineNum = lineNo + 2;
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                     violationLineNum);
             inputConfigBuilder.addViolation(violationLineNum, violationMessage);
         }
         else if (violationWithExplanationMatcher.matches()) {
             final int violationLineNum = lineNo + 1;
             checkWhetherViolationSpecified(specifyViolationMessage, null, violationLineNum);
             inputConfigBuilder.addViolation(violationLineNum, null);
         }
         else if (violationSomeLinesAboveMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationSomeLinesAboveMatcher.group(2), lines, lineNo);
             final int linesAbove = Integer.parseInt(violationSomeLinesAboveMatcher.group(1)) - 1;
             final int violationLineNum = lineNo - linesAbove;
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                     violationLineNum);
             inputConfigBuilder.addViolation(violationLineNum, violationMessage);
         }
         else if (violationSomeLinesBelowMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationSomeLinesBelowMatcher.group(2), lines, lineNo);
             final int linesBelow = Integer.parseInt(violationSomeLinesBelowMatcher.group(1)) + 1;
             final int violationLineNum = lineNo + linesBelow;
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                     violationLineNum);
             inputConfigBuilder.addViolation(violationLineNum, violationMessage);
         }
         else if (violationFirstLineMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationFirstLineMatcher.group(1), lines, lineNo);
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage, 1);
             inputConfigBuilder.addViolation(1, violationMessage);
         }
         else if (violationLastLineMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationLastLineMatcher.group(1), lines, lineNo);
             final int lastLineNum = lines.size();
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                     lastLineNum);
             inputConfigBuilder.addViolation(lastLineNum, violationMessage);
         }
         else {
             setViolationsForMultipleAndFiltered(inputConfigBuilder, lines,
                     useFilteredViolations, lineNo, specifyViolationMessage);
         }
     }
 
     /**
      * Sets violations for multiple-violation patterns, grouped patterns, and filtered violations.
      *
      * @param inputConfigBuilder the builder to add violations to.
      * @param lines all the lines in the file.
      * @param useFilteredViolations flag to set filtered violations.
      * @param lineNo current line number.
      * @param specifyViolationMessage whether violation message must be specified.
      * @throws CheckstyleException if violation message is not specified.
      */
     private static void setViolationsForMultipleAndFiltered(
             TestInputConfiguration.Builder inputConfigBuilder,
             List<String> lines, boolean useFilteredViolations,
             int lineNo, boolean specifyViolationMessage)
             throws CheckstyleException {
         final String line = lines.get(lineNo);
 
         boolean matched = isRelativeLineViolationProcessed(inputConfigBuilder, lines, line, lineNo,
                 specifyViolationMessage);
 
         if (!matched) {
             matched = isMultipleViolationProcessed(inputConfigBuilder, line, lineNo,
                     specifyViolationMessage);
         }
 
         if (!matched) {
             if (useFilteredViolations) {
                 setFilteredViolation(inputConfigBuilder, lineNo + 1,
                         lines, lineNo, specifyViolationMessage);
             }
             else if (!isFilteredViolationComment(line)) {
                 final Matcher violationsDefault = VIOLATION_DEFAULT.matcher(line);
                 if (violationsDefault.matches()) {
                     final int violationLineNum = lineNo + 1;
                     checkWhetherViolationSpecified(specifyViolationMessage, null, violationLineNum);
                     inputConfigBuilder.addViolation(violationLineNum, null);
                 }
             }
         }
     }
 
     private static boolean isRelativeLineViolationProcessed(
             TestInputConfiguration.Builder inputConfigBuilder, List<String> lines,
             String line, int lineNo, boolean specifyViolationMessage) throws CheckstyleException {
         final Matcher violationsAboveMatcherWithMessages =
                 VIOLATIONS_ABOVE_PATTERN_WITH_MESSAGES.matcher(line);
         final Matcher violationsSomeLinesAboveMatcher =
                 VIOLATIONS_SOME_LINES_ABOVE_PATTERN.matcher(line);
         final Matcher violationsSomeLinesBelowMatcher =
                 VIOLATIONS_SOME_LINES_BELOW_PATTERN.matcher(line);
 
         boolean processed = true;
         if (violationsAboveMatcherWithMessages.matches()) {
             inputConfigBuilder.addViolations(
                     getExpectedViolationsForSpecificLine(
                             lines, lineNo, lineNo, violationsAboveMatcherWithMessages,
                             specifyViolationMessage));
         }
         else if (violationsSomeLinesAboveMatcher.matches()) {
             inputConfigBuilder.addViolations(
                     getExpectedViolations(
                             lines, lineNo, violationsSomeLinesAboveMatcher, true,
                             specifyViolationMessage));
         }
         else if (violationsSomeLinesBelowMatcher.matches()) {
             inputConfigBuilder.addViolations(
                     getExpectedViolations(
                             lines, lineNo, violationsSomeLinesBelowMatcher, false,
                             specifyViolationMessage));
         }
         else {
             processed = false;
         }
         return processed;
     }
 
     private static boolean isMultipleViolationProcessed(
             TestInputConfiguration.Builder inputConfigBuilder, String line,
             int lineNo, boolean specifyViolationMessage) throws CheckstyleException {
         final Matcher multipleViolationsMatcher = MULTIPLE_VIOLATIONS_PATTERN.matcher(line);
         final Matcher multipleViolationsAboveMatcher =
                 MULTIPLE_VIOLATIONS_ABOVE_PATTERN.matcher(line);
         final Matcher multipleViolationsBelowMatcher =
                 MULTIPLE_VIOLATIONS_BELOW_PATTERN.matcher(line);
 
         boolean processed = true;
         if (multipleViolationsMatcher.matches()) {
             final int violationLineNum = lineNo + 1;
             final int count = Integer.parseInt(multipleViolationsMatcher.group(1));
             checkWhetherViolationSpecified(specifyViolationMessage, null, violationLineNum);
             Collections.nCopies(count, violationLineNum)
                     .forEach(actualLineNumber -> {
                         inputConfigBuilder.addViolation(actualLineNumber, null);
                     });
         }
         else if (multipleViolationsAboveMatcher.matches()) {
             final int count = Integer.parseInt(multipleViolationsAboveMatcher.group(1));
             checkWhetherViolationSpecified(specifyViolationMessage, null, lineNo);
             Collections.nCopies(count, lineNo)
                     .forEach(actualLineNumber -> {
                         inputConfigBuilder.addViolation(actualLineNumber, null);
                     });
         }
         else if (multipleViolationsBelowMatcher.matches()) {
             final int violationLineNum = lineNo + 2;
             final int count = Integer.parseInt(multipleViolationsBelowMatcher.group(1));
             checkWhetherViolationSpecified(specifyViolationMessage, null, violationLineNum);
             Collections.nCopies(count, violationLineNum)
                     .forEach(actualLineNumber -> {
                         inputConfigBuilder.addViolation(actualLineNumber, null);
                     });
         }
         else {
             processed = false;
         }
         return processed;
     }
 
     private static List<TestInputViolation> getExpectedViolationsForSpecificLine(
             List<String> lines, int lineNo, int violationLineNum,
             Matcher matcher, boolean specifyViolationMessage) throws CheckstyleException {
         final List<TestInputViolation> results = new ArrayList<>();
 
         final int expectedMessageCount =
             Integer.parseInt(matcher.group(1));
         for (int index = 1; index <= expectedMessageCount; index++) {
             final String lineWithMessage = lines.get(lineNo + index);
             final Matcher messageMatcher = VIOLATION_MESSAGE_PATTERN.matcher(lineWithMessage);
             if (messageMatcher.find()) {
                 final String violationMessage = messageMatcher.group(1);
                 checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                         violationLineNum);
                 results.add(new TestInputViolation(violationLineNum, violationMessage));
             }
         }
         if (results.size() != expectedMessageCount) {
             final String message = String.format(Locale.ROOT,
                 "Declared amount of violation messages at line %s is %s but found %s",
                 lineNo + 1, expectedMessageCount, results.size());
             throw new IllegalStateException(message);
         }
         return results;
     }
 
     private static List<TestInputViolation> getExpectedViolations(
             List<String> lines, int lineNo,
             Matcher matcher, boolean isAbove, boolean specifyViolationMessage)
                     throws CheckstyleException {
         final int violationLine =
             Integer.parseInt(matcher.group(2));
         final int violationLineNum;
         if (isAbove) {
             violationLineNum = lineNo - violationLine + 1;
         }
         else {
             violationLineNum = lineNo + violationLine + 1;
         }
         return getExpectedViolationsForSpecificLine(lines,
             lineNo, violationLineNum, matcher, specifyViolationMessage);
     }
 
     private static void setFilteredViolation(TestInputConfiguration.Builder inputConfigBuilder,
                                              int lineNo, List<String> lines,
                                              int currentLineNo,
                                              boolean specifyViolationMessage)
             throws CheckstyleException {
         final String line = lines.get(currentLineNo);
         final Matcher violationMatcher =
                 FILTERED_VIOLATION_PATTERN.matcher(line);
         final Matcher violationAboveMatcher =
                 FILTERED_VIOLATION_ABOVE_PATTERN.matcher(line);
         final Matcher violationBelowMatcher =
                 FILTERED_VIOLATION_BELOW_PATTERN.matcher(line);
         final Matcher violationSomeLinesAboveMatcher =
                 FILTERED_VIOLATION_SOME_LINES_ABOVE_PATTERN.matcher(line);
         final Matcher violationSomeLinesBelowMatcher =
                 FILTERED_VIOLATION_SOME_LINES_BELOW_PATTERN.matcher(line);
         if (violationMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationMatcher.group(1), lines, currentLineNo);
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage, lineNo);
             inputConfigBuilder.addFilteredViolation(lineNo, violationMessage);
         }
         else if (violationAboveMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationAboveMatcher.group(1), lines, currentLineNo);
             final int violationLineNum = lineNo - 1;
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                     violationLineNum);
             inputConfigBuilder.addFilteredViolation(violationLineNum, violationMessage);
         }
         else if (violationBelowMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationBelowMatcher.group(1), lines, currentLineNo);
             final int violationLineNum = lineNo + 1;
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                     violationLineNum);
             inputConfigBuilder.addFilteredViolation(violationLineNum, violationMessage);
         }
         else if (violationSomeLinesAboveMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationSomeLinesAboveMatcher.group(2), lines, currentLineNo);
             final int linesAbove = Integer.parseInt(violationSomeLinesAboveMatcher.group(1));
             final int violationLineNum = lineNo - linesAbove;
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                     violationLineNum);
             inputConfigBuilder.addFilteredViolation(violationLineNum, violationMessage);
         }
         else if (violationSomeLinesBelowMatcher.matches()) {
             final String violationMessage =
                     extractMessage(violationSomeLinesBelowMatcher.group(2), lines, currentLineNo);
             final int linesBelow = Integer.parseInt(violationSomeLinesBelowMatcher.group(1));
             final int violationLineNum = lineNo + linesBelow;
             checkWhetherViolationSpecified(specifyViolationMessage, violationMessage,
                     violationLineNum);
             inputConfigBuilder.addFilteredViolation(violationLineNum, violationMessage);
         }
     }
 
     private static boolean isViolationComment(String line) {
         return VIOLATION_PATTERN.matcher(line).matches()
                 || VIOLATION_ABOVE_PATTERN.matcher(line).matches()
                 || VIOLATION_BELOW_PATTERN.matcher(line).matches()
                 || VIOLATION_SOME_LINES_ABOVE_PATTERN.matcher(line).matches()
                 || VIOLATION_SOME_LINES_BELOW_PATTERN.matcher(line).matches()
                 || VIOLATION_FIRST_LINE_PATTERN.matcher(line).matches()
                 || VIOLATION_LAST_LINE_PATTERN.matcher(line).matches()
                 || isFilteredViolationComment(line);
     }
 
     /**
      * Checks whether the given line is a well-formed "filtered violation" comment,
      * in any of its recognized forms (bare, above, below, N-lines-above, N-lines-below).
      *
      * @param line the line to check.
      * @return true if the line matches any filtered-violation comment pattern.
      */
     private static boolean isFilteredViolationComment(String line) {
         return FILTERED_VIOLATION_PATTERN.matcher(line).matches()
                 || FILTERED_VIOLATION_ABOVE_PATTERN.matcher(line).matches()
                 || FILTERED_VIOLATION_BELOW_PATTERN.matcher(line).matches()
                 || FILTERED_VIOLATION_SOME_LINES_ABOVE_PATTERN.matcher(line).matches()
                 || FILTERED_VIOLATION_SOME_LINES_BELOW_PATTERN.matcher(line).matches();
     }
 
     private static String assembleTripleQuoteMessage(String firstPart,
                                                      List<String> lines, int startLineNo) {
         final String result;
         if (firstPart.endsWith("\"\"")) {
             result = firstPart.substring(0, firstPart.length() - 2);
         }
         else {
             final StringBuilder builder = new StringBuilder(firstPart.strip());
             int nextLine = startLineNo + 1;
             boolean done = false;
             while (!done && nextLine < lines.size()) {
                 final String candidate = lines.get(nextLine);
                 final Matcher continuation =
                         MULTILINE_CONTINUATION_PATTERN.matcher(candidate);
 
                 final boolean isViolation = isViolationComment(candidate);
                 final boolean isContinuation = continuation.matches();
 
                 if (!isViolation && isContinuation) {
                     final String part = continuation.group(1);
                     if (part.contains(TRIPLE_QUOTE)) {
                         final int idx = part.indexOf(TRIPLE_QUOTE);
                         final String lastPart = part.substring(0, idx).trim();
                         if (!lastPart.isEmpty()) {
                             builder.append(' ').append(lastPart);
                         }
                         done = true;
                     }
                     else {
                         builder.append(' ').append(part.strip());
                         nextLine++;
                     }
                 }
                 else {
                     done = true;
                 }
             }
             result = builder.toString();
         }
         return result.replaceAll("\\s+", " ").trim();
     }
 
     private static String extractMessage(String rawMessage,
                                          List<String> lines, int lineNo) {
         String result = null;
 
         if (rawMessage != null) {
             if (rawMessage.startsWith("\"\"")) {
                 result = assembleTripleQuoteMessage(
                         rawMessage.substring(2), lines, lineNo);
             }
             else {
                 // Strip trailing quote left by relaxed pattern for single-line messages
                 if (rawMessage.endsWith("'") || rawMessage.endsWith("\"")) {
                     result = rawMessage.substring(0, rawMessage.length() - 1);
                 }
                 else {
                     result = rawMessage;
                 }
             }
         }
 
         return result;
     }
 
     /**
      * Check whether violation is specified along with {@code // violation} comment.
      *
      * @param shouldViolationMsgBeSpecified should violation messages be specified.
      * @param violationMessage violation message
      * @param lineNum line number
      * @throws CheckstyleException if violation message is not specified
      */
     private static void checkWhetherViolationSpecified(boolean shouldViolationMsgBeSpecified,
             String violationMessage, int lineNum) throws CheckstyleException {
         if (shouldViolationMsgBeSpecified && violationMessage == null) {
             throw new CheckstyleException(
                     "Violation message should be specified on line " + lineNum);
         }
     }
 
     private static Map<Object, Object> loadProperties(String propertyContent) throws IOException {
         final Properties properties = new Properties();
         properties.load(new StringReader(propertyContent));
         return properties;
     }
 
     private static boolean isNumericType(Class<?> fieldType) {
         return Number.class.isAssignableFrom(fieldType)
                 || fieldType.equals(int.class)
                 || fieldType.equals(double.class)
                 || fieldType.equals(long.class)
                 || fieldType.equals(float.class);
     }
 
     public static Object getPropertyDefaultValue(Object checkInstance,
                                                  String propertyName) {
         Object retVal;
         try {
             retVal = TestUtil.getInternalState(checkInstance, propertyName, Object.class);
         }
         catch (IllegalStateException exc) {
             retVal = null;
         }
         return retVal;
     }
 
     private static boolean isNull(String propertyDefaultValue) {
         return NULL_STRING.equals(propertyDefaultValue)
                 || propertyDefaultValue.isEmpty()
                 || "null".equals(propertyDefaultValue)
                 || "\"\"".equals(propertyDefaultValue);
     }
 
 }