/*
    * SPDX-FileCopyrightText: Copyright (c) 2011-2026 Yegor Bugayenko
    * SPDX-License-Identifier: MIT
    */
   package com.qulice.checkstyle;
   
   import com.qulice.spi.Environment;
   import com.qulice.spi.Violation;
   import java.io.File;
  import java.io.IOException;
  import java.util.Collection;
  import org.cactoos.io.ResourceOf;
  import org.cactoos.text.FormattedText;
  import org.cactoos.text.IoCheckedText;
  import org.cactoos.text.TextOf;
  import org.hamcrest.MatcherAssert;
  import org.hamcrest.Matchers;
  import org.junit.jupiter.api.Test;
  
  /**
   * Test case for {@link CheckstyleValidator}'s handling of the
   * stock {@code LocalVariableName} and {@code CatchParameterName} checks.
   * @since 0.25.1
   */
  final class CheckstyleLocalVariableNameTest {
  
      @Test
      @SuppressWarnings("unchecked")
      void allowsOnlyProperlyNamedLocalVariables() throws Exception {
          final String file = "LocalVariableNames.java";
          MatcherAssert.assertThat(
              "Only invalid variables name should be found",
              this.runValidation(file, false),
              Matchers.<Iterable<Violation>>allOf(
                  Matchers.iterableWithSize(10),
                  Matchers.not(
                      Matchers.hasItems(
                          new ViolationMatcher("aaa", file),
                          new ViolationMatcher("twelveletter", file),
                          new ViolationMatcher("ise", file),
                          new ViolationMatcher("id", file),
                          new ViolationMatcher("parametername", file)
                      )
                  ),
                  Matchers.hasItems(
                      new ViolationMatcher(
                          "Name 'prolongations' must match pattern", file
                      ),
                      new ViolationMatcher(
                          "Name 'very_long_variable_id' must match pattern", file
                      ),
                      new ViolationMatcher(
                          "Name 'camelCase' must match pattern", file
                      ),
                      new ViolationMatcher(
                          "Name 'it' must match pattern", file
                      ),
                      new ViolationMatcher(
                          "Name 'number1' must match pattern", file
                      ),
                      new ViolationMatcher(
                          "Name 'ex' must match pattern", file
                      ),
                      new ViolationMatcher(
                          "Name 'a' must match pattern", file
                      ),
                      new ViolationMatcher(
                          "Name 'ae' must match pattern", file
                      ),
                      new ViolationMatcher(
                          "Name 'e' must match pattern", file
                      ),
                      new ViolationMatcher(
                          "Name 'it' must match pattern", file
                      )
                  )
              )
          );
      }
  
      private Collection<Violation> runValidation(final String file,
          final boolean passes) throws IOException {
          final Environment.Mock mock = new Environment.Mock();
          final Environment env = mock.withParam(
              "license",
              String.format(
                  "file:%s",
                  new License().savePackageInfo(
                      new File(mock.basedir(), "src/main/java/foo")
                  ).withLines("Hello.")
                      .withEol(String.valueOf('\n')).file()
              )
          ).withFile(
              String.format("src/main/java/foo/%s", file),
              new IoCheckedText(
                  new TextOf(
                      new ResourceOf(
                          new FormattedText("com/qulice/checkstyle/%s", file)
                      )
                 )
             ).asString()
         );
         final Collection<Violation> results =
             new CheckstyleValidator(env).validate(env.files(file));
         MatcherAssert.assertThat(
             "validation result should match expected state",
             results.isEmpty(),
             Matchers.is(passes)
         );
         return results;
     }
 }