Refactor merging list of arguments to MethodMatchers

tomasz-tylenda-sonarsource · tomasz-tylenda-sonarsource · commit 849d44605786 · 2026-06-05T10:40:14.000+02:00
diff --git a/java-checks/src/main/java/org/sonar/java/checks/helpers/StringUtils.java b/java-checks/src/main/java/org/sonar/java/checks/helpers/StringUtils.java
@@ -17,6 +17,11 @@
 package org.sonar.java.checks.helpers;
 
 import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 
 public class StringUtils {
   private StringUtils() {}
@@ -41,4 +46,30 @@ public static int countMatches(@Nullable String string, @Nullable String pattern
 
     return count;
   }
+
+  /**
+   * Build String[] by concatenating Strings, arrays of Strings, and Collections of Strings.
+   * Nested collections and arrays are not supported, and will throw an IllegalArgumentException if encountered.
+   */
+  public static String[] stringArgs(Object ... args) {
+    List<String> result = new ArrayList<>();
+    for (Object arg : args) {
+      if (arg instanceof String s) {
+        result.add(s);
+      } else if (arg instanceof String[] arr) {
+        Collections.addAll(result, arr);
+      } else if (arg instanceof Collection<?> col) {
+        for (Object o : col) {
+          if (o instanceof String s) {
+            result.add(s);
+          } else {
+            throw new IllegalArgumentException("Unsupported collection element type: " + o.getClass());
+          }
+        }
+      } else {
+        throw new IllegalArgumentException("Unsupported argument type: " + arg.getClass());
+      }
+    }
+    return result.toArray(new String[0]);
+  }
 }
diff --git a/java-checks/src/main/java/org/sonar/java/checks/helpers/UnitTestUtils.java b/java-checks/src/main/java/org/sonar/java/checks/helpers/UnitTestUtils.java
@@ -23,7 +23,6 @@
 import java.util.Set;
 import java.util.function.Predicate;
 import java.util.regex.Pattern;
-import java.util.stream.Stream;
 import javax.annotation.Nullable;
 
 import org.sonar.java.annotations.VisibleForTesting;
@@ -42,6 +41,7 @@
 import org.sonar.plugins.java.api.tree.Tree;
 
 import static java.util.Arrays.asList;
+import static org.sonar.java.checks.helpers.StringUtils.stringArgs;
 
 public final class UnitTestUtils {
   private static final List<String> ORG_ASSERTJ_CORE_API_ASSERTIONS = List.of(
@@ -103,8 +103,7 @@ public final class UnitTestUtils {
 
   public static final MethodMatchers FAIL_METHOD_MATCHER = MethodMatchers.or(
     MethodMatchers.create().ofTypes(
-        Stream.concat(
-          Stream.of(
+        stringArgs(
             // JUnit 5
             "org.junit.jupiter.api.Assertions",
             // JUnit 4
@@ -114,14 +113,13 @@ public final class UnitTestUtils {
             // Fest assert
             "org.fest.assertions.Fail",
             // AssertJ
-            "org.assertj.core.api.Fail"
-          ),
-          ORG_ASSERTJ_CORE_API_ASSERTIONS.stream()
-        ).toArray(String[]::new))
+            "org.assertj.core.api.Fail",
+            ORG_ASSERTJ_CORE_API_ASSERTIONS
+        ))
       .names("fail").withAnyParameters().build(),
     MethodMatchers.create().ofTypes(
         // AssertJ
-        ORG_ASSERTJ_CORE_API_ASSERTIONS.toArray(String[]::new)
+        stringArgs(ORG_ASSERTJ_CORE_API_ASSERTIONS)
       )
       .names("failBecauseExceptionWasNotThrown").withAnyParameters().build());
 
@@ -134,7 +132,7 @@ public final class UnitTestUtils {
       .build(),
     // Fest assert and AssertJ
     MethodMatchers.create()
-      .ofTypes(Stream.concat(ORG_ASSERTJ_CORE_API_ASSERTIONS.stream(), Stream.of("org.fest.assertions.Assertions")).toArray(String[]::new))
+      .ofTypes(stringArgs(ORG_ASSERTJ_CORE_API_ASSERTIONS, "org.fest.assertions.Assertions"))
       .names("assertThat")
       .withAnyParameters()
       .build());
diff --git a/java-checks/src/test/java/org/sonar/java/checks/helpers/StringUtilsTest.java b/java-checks/src/test/java/org/sonar/java/checks/helpers/StringUtilsTest.java
@@ -18,7 +18,11 @@
 
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 class StringUtilsTest {
   @Test
@@ -42,4 +46,32 @@ void testCountMatches() {
     assertThat(StringUtils.countMatches("abaTaba", "aba")).isEqualTo(2);
     assertThat(StringUtils.countMatches("abababa", "aba")).isEqualTo(2);
   }
+
+  @Test
+  void testStringArgs() {
+    assertThat(StringUtils.stringArgs()).isEmpty();
+    assertThat(StringUtils.stringArgs("a", "b", "c")).containsExactly("a", "b", "c");
+
+    assertThat(StringUtils.stringArgs(new String[] {"a", "b"}, "c")).containsExactly("a", "b", "c");
+    assertThat(StringUtils.stringArgs("a", new String[] {"b", "c"})).containsExactly("a", "b", "c");
+
+    assertThat(StringUtils.stringArgs(List.of("A", "B"), "a", new String[] {"b", "c"}))
+      .containsExactly("A", "B", "a", "b", "c");
+  }
+
+  @Test
+  void testStringArgs_exceptions() {
+    assertThatIllegalArgumentException()
+      .isThrownBy(() -> StringUtils.stringArgs("a", 2))
+      .withMessageContaining("Unsupported argument type:");
+
+    assertThatIllegalArgumentException()
+      .isThrownBy(() -> StringUtils.stringArgs(new int[]{4, 5}))
+      .withMessageContaining("Unsupported argument type:");
+
+    var list = List.of("b", List.of("c", "d"));
+    assertThatIllegalArgumentException()
+      .isThrownBy(() -> StringUtils.stringArgs("a", list))
+      .withMessageContaining("Unsupported collection element type:");
+  }
 }
