/*
    * 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.list.ListOf;
  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.hamcrest.collection.IsIterableContainingInOrder;
  import org.junit.jupiter.api.Test;
  
  /**
   * Test case for {@link CheckstyleValidator}'s detection of banned
   * API usages such as Guava {@code Lists.newArrayList()} with no
   * size, Apache Commons {@code CharEncoding}, and interface type
   * parameter naming.
   *
   * @since 0.25.1
   */
  final class CheckstyleBannedApiTest {
  
      @Test
      void reportsGuavaNewArrayListWithoutSize() throws Exception {
          final String file = "GuavaNewArrayList.java";
          MatcherAssert.assertThat(
              "Guava Lists.newArrayList without size must be reported",
              this.runValidation(file, false),
              Matchers.hasItem(
                  new ViolationMatcher(
                      "Lists.newArrayList should be initialized with a size parameter",
                      file
                  )
              )
          );
      }
  
      @Test
      @SuppressWarnings("unchecked")
      void reportsAllCharEncodingUsages() throws Exception {
          final String message =
              "Use java.nio.charset.StandardCharsets instead";
          final String file = "DoNotUseCharEncoding.java";
          final String name = "RegexpSinglelineCheck";
          MatcherAssert.assertThat(
              "9 violations should be found",
              this.runValidation(file, false),
              new IsIterableContainingInOrder<>(
                  new ListOf<>(
                      new ViolationMatcher(message, file, "6", name),
                      new ViolationMatcher(message, file, "7", name),
                      new ViolationMatcher(message, file, "8", name),
                      new ViolationMatcher(message, file, "9", name),
                      new ViolationMatcher(message, file, "31", name),
                      new ViolationMatcher(message, file, "32", name),
                      new ViolationMatcher(message, file, "33", name),
                      new ViolationMatcher(
                          "is redundant, import it and use",
                          file, "34", "FullyQualifiedTypeCheck"
                      ),
                      new ViolationMatcher(message, file, "34", name)
                  )
              )
          );
      }
  
      @Test
      void reportsInvalidInterfaceTypeParameterName() throws Exception {
          final String file = "InterfaceTypeParameterName.java";
          MatcherAssert.assertThat(
              "Interface type parameter violation must be reported",
              this.runValidation(file, false),
              Matchers.hasItem(
                  new ViolationMatcher(
                      "Name 'wRoNg' must match pattern", file,
                      "12", "InterfaceTypeParameterNameCheck"
                  )
              )
          );
      }
  
      @Test
      @SuppressWarnings("unchecked")
      void reportsUnnecessaryJavaLangPrefix() throws Exception {
          final String message =
              "Unnecessary java.lang. prefix, use the simple class name";
          final String file = "UnnecessaryJavaLang.java";
          final String name = "UnnecessaryJavaLangCheck";
          MatcherAssert.assertThat(
              "cannot find all java.lang. violations",
             this.runValidation(file, false),
             Matchers.hasItems(
                 new ViolationMatcher(message, file, "11", name),
                 new ViolationMatcher(message, file, "19", name),
                 new ViolationMatcher(message, file, "25", name),
                 new ViolationMatcher(message, file, "27", name)
             )
         );
     }
 
     @Test
     @SuppressWarnings("unchecked")
     void ignoresJavaLangInsideStringLiterals() throws Exception {
         final String message =
             "Unnecessary java.lang. prefix, use the simple class name";
         final String file = "UnnecessaryJavaLang.java";
         final String name = "UnnecessaryJavaLangCheck";
         MatcherAssert.assertThat(
             "java.lang. inside a string literal or text block must be ignored",
             this.runValidation(file, false),
             Matchers.not(
                 Matchers.anyOf(
                     Matchers.hasItem(new ViolationMatcher(message, file, "47", name)),
                     Matchers.hasItem(new ViolationMatcher(message, file, "57", name))
                 )
             )
         );
     }
 
     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));
         if (passes) {
             MatcherAssert.assertThat(
                 results,
                 Matchers.<Violation>empty()
             );
         } else {
             MatcherAssert.assertThat(
                 results,
                 Matchers.not(Matchers.<Violation>empty())
             );
         }
         return results;
     }
 }