/*
    * 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.Joined;
  import org.cactoos.text.TextOf;
  import org.hamcrest.MatcherAssert;
  import org.hamcrest.Matchers;
  import org.junit.jupiter.api.Assertions;
  import org.junit.jupiter.api.Test;
  
  /**
   * Test case for {@link CheckstyleValidator}'s handling of the
   * stock {@code AbbreviationAsWordInName} check.
   * @since 0.25.1
   */
  final class CheckstyleAbbreviationAsWordInNameTest {
  
      @Test
      @SuppressWarnings("unchecked")
      void rejectsUppercaseAbbreviations() throws Exception {
          final String file = "InvalidAbbreviationAsWordInNameXML.java";
          final String name = "AbbreviationAsWordInNameCheck";
          final String message = new Joined(
              " ",
              "Abbreviation in name '%s'",
              "must contain no more than '2' consecutive capital letters."
          ).asString();
          MatcherAssert.assertThat(
              "All long abbreviations should be found",
              this.runValidation(file, false),
              Matchers.hasItems(
                  new ViolationMatcher(
                      String.format(
                          message, "InvalidAbbreviationAsWordInNameXML"
                      ),
                      file, "10", name
                  ),
                  new ViolationMatcher(
                      String.format(message, "InvalidHTML"), file,
                      "14", name
                  )
              )
          );
      }
  
      @Test
      void allowsITUppercaseAbbreviation() throws Exception {
          Assertions.assertDoesNotThrow(
              () -> this.runValidation("ValidAbbreviationAsWordInNameIT.java", true)
          );
      }
  
      @Test
      void allowsUppercaseAbbreviationExceptions() throws Exception {
          Assertions.assertDoesNotThrow(
              () -> this.runValidation("ValidAbbreviationAsWordInName.java", true)
          );
      }
  
      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;
     }
 }