Add a StringSubject.containsAll method, with a case-insensitive variation.

RELNOTES=Adds a StringSubject.containsAll method.
PiperOrigin-RevId: 788927984

Author: java-team-github-bot

core/src/main/java/com/google/common/truth/StringSubject.java

@@ -17,10 +17,15 @@
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.truth.Fact.fact;
 import static com.google.common.truth.Fact.simpleFact;
+import static java.util.Arrays.stream;
 
 import com.google.common.annotations.GwtIncompatible;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import org.jspecify.annotations.Nullable;
@@ -87,6 +92,26 @@ public void contains(@Nullable CharSequence string) {
     }
   }
 
+  /** Checks that the actual value contains the given sequences. */
+  public void containsAllOf(@Nullable CharSequence... strings) {
+    checkNotNull(strings);
+    ImmutableSet<String> expected =
+        stream(strings).map(charSeq -> checkNotNull(charSeq).toString()).collect(toImmutableSet());
+    checkArgument(expected.size() == strings.length, "duplicate strings in expected");
+    if (actual == null) {
+      failWithActual("expected a string that contains all of", expected);
+      return;
+    }
+    ImmutableList<String> missing =
+        expected.stream()
+            .filter(string -> !checkNotNull(actual).contains(string))
+            .collect(toImmutableList());
+    if (!missing.isEmpty()) {
+      failWithoutActual(
+          fact("expected to contain all of", expected), butWas(), fact("missing", missing));
+    }
+  }
+
   /** Checks that the actual value does not contain the given sequence. */
   public void doesNotContain(@Nullable CharSequence string) {
     checkNotNull(string);
@@ -321,6 +346,34 @@ public void contains(@Nullable CharSequence string) {
       }
     }
 
+    /** Checks that the actual value contains the given sequences. */
+    public void containsAllOf(@Nullable CharSequence... strings) {
+      checkNotNull(strings);
+      ImmutableSet<String> expected =
+          stream(strings)
+              .map(charSeq -> checkNotNull(charSeq).toString())
+              .collect(toImmutableSet());
+      checkArgument(expected.size() == strings.length, "duplicate strings in expected");
+      if (actual == null) {
+        failWithoutActual(
+            fact("expected a string that contains all of", expected),
+            butWas(),
+            simpleFact("(case is ignored)"));
+        return;
+      }
+      ImmutableList<String> missing =
+          expected.stream()
+              .filter(string -> !containsIgnoreCase(checkNotNull(actual), string))
+              .collect(toImmutableList());
+      if (!missing.isEmpty()) {
+        failWithoutActual(
+            fact("expected to contain all of", expected),
+            butWas(),
+            fact("missing", missing),
+            simpleFact("(case is ignored)"));
+      }
+    }
+
     /** Checks that the actual value does not contain the given sequence (while ignoring case). */
     public void doesNotContain(@Nullable CharSequence string) {
       checkNotNull(string);

core/src/test/java/com/google/common/truth/StringSubjectTest.java

@@ -112,6 +112,19 @@ public void containsFail() {
     assertFailureValue(e, "expected to contain", "d");
   }
 
+  @Test
+  public void containsAllOf() {
+    assertThat("abc").containsAllOf("a", "c", "b");
+  }
+
+  @Test
+  public void containsAllOfFail() {
+    AssertionError e =
+        expectFailure(whenTesting -> whenTesting.that("abc").containsAllOf("a", "-", "b", "d"));
+    assertFailureValue(e, "expected to contain all of", "[a, -, b, d]");
+    assertFailureValue(e, "missing", "[-, d]");
+  }
+
   @Test
   public void doesNotContain() {
     assertThat("abc").doesNotContain("d");
@@ -184,6 +197,7 @@ public void endsWithFail() {
   @Test
   public void emptyStringTests() {
     assertThat("").contains("");
+    assertThat("").containsAllOf("");
     assertThat("").startsWith("");
     assertThat("").endsWith("");
     assertThat("a").contains("");
@@ -533,6 +547,21 @@ public void containsIgnoringCaseFailBecauseNullSubject() {
     assertThat(e).factKeys().contains("(case is ignored)");
   }
 
+  @Test
+  public void containsAllOfIgnoringCase() {
+    assertThat("AbCd").ignoringCase().containsAllOf("a", "c", "b");
+  }
+
+  @Test
+  public void containsAllOfIgnoringCaseFail() {
+    AssertionError e =
+        expectFailure(
+            whenTesting ->
+                whenTesting.that("AbC").ignoringCase().containsAllOf("a", "-", "b", "d"));
+    assertFailureValue(e, "expected to contain all of", "[a, -, b, d]");
+    assertFailureValue(e, "missing", "[-, d]");
+  }
+
   @Test
   public void doesNotContainIgnoringCase() {
     assertThat("äbc").ignoringCase().doesNotContain("Äc");