Add null-checks to StringSubject

Also add some missing unit tests while we're here. RELNOTES=Add null-checks to StringSubject ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=304241733
google · Apr 2, 2020 · 3481ab0 · 3481ab0
1 parent 1af73cb
commit 3481ab0
Show file tree

Hide file tree

Showing 2 changed files with 110 additions and 10 deletions.
diff --git a/core/src/main/java/com/google/common/truth/StringSubject.java b/core/src/main/java/com/google/common/truth/StringSubject.java
@@ -114,56 +114,77 @@ public void endsWith(String string) {
     }
   }
 
-  // TODO(cpovirk): Probably these should check for null first like the earlier methods do.
-
   /** Fails if the string does not match the given regex. */
   public void matches(String regex) {
-    if (!actual.matches(regex)) {
+    checkNotNull(regex);
+    if (actual == null) {
+      failWithActual("expected a string that matches", regex);
+    } else if (!actual.matches(regex)) {
       failWithActual("expected to match", regex);
     }
   }
 
   /** Fails if the string does not match the given regex. */
   @GwtIncompatible("java.util.regex.Pattern")
   public void matches(Pattern regex) {
-    if (!regex.matcher(actual).matches()) {
+    checkNotNull(regex);
+    if (actual == null) {
+      failWithActual("expected a string that matches", regex);
+    } else if (!regex.matcher(actual).matches()) {
       failWithActual("expected to match", regex);
     }
   }
 
   /** Fails if the string matches the given regex. */
   public void doesNotMatch(String regex) {
-    if (actual.matches(regex)) {
+    checkNotNull(regex);
+    if (actual == null) {
+      failWithActual("expected a string that does not match", regex);
+    } else if (actual.matches(regex)) {
       failWithActual("expected not to match", regex);
     }
   }
 
   /** Fails if the string matches the given regex. */
   @GwtIncompatible("java.util.regex.Pattern")
   public void doesNotMatch(Pattern regex) {
-    if (regex.matcher(actual).matches()) {
+    checkNotNull(regex);
+    if (actual == null) {
+      failWithActual("expected a string that does not match", regex);
+    } else if (regex.matcher(actual).matches()) {
       failWithActual("expected not to match", regex);
     }
   }
 
   /** Fails if the string does not contain a match on the given regex. */
   @GwtIncompatible("java.util.regex.Pattern")
   public void containsMatch(Pattern regex) {
-    if (!regex.matcher(actual).find()) {
+    checkNotNull(regex);
+    if (actual == null) {
+      failWithActual("expected a string that contains a match for", regex);
+    } else if (!regex.matcher(actual).find()) {
       failWithActual("expected to contain a match for", regex);
     }
   }
 
   /** Fails if the string does not contain a match on the given regex. */
   public void containsMatch(String regex) {
-    if (!Platform.containsMatch(actual, regex)) {
+    checkNotNull(regex);
+    if (actual == null) {
+      failWithActual("expected a string that contains a match for", regex);
+    } else if (!Platform.containsMatch(actual, regex)) {
       failWithActual("expected to contain a match for", regex);
     }
   }
 
   /** Fails if the string contains a match on the given regex. */
   @GwtIncompatible("java.util.regex.Pattern")
   public void doesNotContainMatch(Pattern regex) {
+    checkNotNull(regex);
+    if (actual == null) {
+      failWithActual("expected a string that does not contain a match for", regex);
+      return;
+    }
     Matcher matcher = regex.matcher(actual);
     if (matcher.find()) {
       failWithoutActual(
@@ -175,7 +196,10 @@ public void doesNotContainMatch(Pattern regex) {
 
   /** Fails if the string contains a match on the given regex. */
   public void doesNotContainMatch(String regex) {
-    if (Platform.containsMatch(actual, regex)) {
+    checkNotNull(regex);
+    if (actual == null) {
+      failWithActual("expected a string that does not contain a match for", regex);
+    } else if (Platform.containsMatch(actual, regex)) {
       failWithActual("expected not to contain a match for", regex);
     }
   }

diff --git a/core/src/test/java/com/google/common/truth/StringSubjectTest.java b/core/src/test/java/com/google/common/truth/StringSubjectTest.java
@@ -199,19 +199,69 @@ public void stringMatchesStringWithFail() {
     assertFailureValue("expected to match", ".*aaa.*");
   }
 
+  @Test
+  public void stringMatchesStringFailNull() {
+    expectFailureWhenTestingThat(null).matches(".*aaa.*");
+    assertFailureValue("expected a string that matches", ".*aaa.*");
+  }
+
   @Test
   @GwtIncompatible("Pattern")
   public void stringMatchesPattern() {
-    assertThat("abcaqadev").doesNotMatch(Pattern.compile(".*aaa.*"));
+    assertThat("abcaaadev").matches(Pattern.compile(".*aaa.*"));
   }
 
   @Test
   @GwtIncompatible("Pattern")
   public void stringMatchesPatternWithFail() {
+    expectFailureWhenTestingThat("abcaqadev").matches(Pattern.compile(".*aaa.*"));
+    assertFailureValue("expected to match", ".*aaa.*");
+  }
+
+  @Test
+  @GwtIncompatible("Pattern")
+  public void stringMatchesPatternFailNull() {
+    expectFailureWhenTestingThat(null).matches(Pattern.compile(".*aaa.*"));
+    assertFailureValue("expected a string that matches", ".*aaa.*");
+  }
+
+  @Test
+  public void stringDoesNotMatchString() {
+    assertThat("abcaqadev").doesNotMatch(".*aaa.*");
+  }
+
+  @Test
+  public void stringDoesNotMatchStringWithFail() {
+    expectFailureWhenTestingThat("abcaaadev").doesNotMatch(".*aaa.*");
+    assertFailureValue("expected not to match", ".*aaa.*");
+  }
+
+  @Test
+  public void stringDoesNotMatchStringFailNull() {
+    expectFailureWhenTestingThat(null).doesNotMatch(".*aaa.*");
+    assertFailureValue("expected a string that does not match", ".*aaa.*");
+  }
+
+  @Test
+  @GwtIncompatible("Pattern")
+  public void stringDoesNotMatchPattern() {
+    assertThat("abcaqadev").doesNotMatch(Pattern.compile(".*aaa.*"));
+  }
+
+  @Test
+  @GwtIncompatible("Pattern")
+  public void stringDoesNotMatchPatternWithFail() {
     expectFailureWhenTestingThat("abcaaadev").doesNotMatch(Pattern.compile(".*aaa.*"));
     assertFailureValue("expected not to match", ".*aaa.*");
   }
 
+  @Test
+  @GwtIncompatible("Pattern")
+  public void stringDoesNotMatchPatternFailNull() {
+    expectFailureWhenTestingThat(null).doesNotMatch(Pattern.compile(".*aaa.*"));
+    assertFailureValue("expected a string that does not match", ".*aaa.*");
+  }
+
   @Test
   @GwtIncompatible("Pattern")
   public void stringContainsMatchStringUsesFind() {
@@ -227,6 +277,12 @@ public void stringContainsMatchString() {
     assertFailureValue("expected to contain a match for", ".*b.*");
   }
 
+  @Test
+  public void stringContainsMatchStringFailNull() {
+    expectFailureWhenTestingThat(null).containsMatch(".*b.*");
+    assertFailureValue("expected a string that contains a match for", ".*b.*");
+  }
+
   @Test
   @GwtIncompatible("Pattern")
   public void stringContainsMatchPattern() {
@@ -236,6 +292,13 @@ public void stringContainsMatchPattern() {
     assertFailureValue("expected to contain a match for", ".*b.*");
   }
 
+  @Test
+  @GwtIncompatible("Pattern")
+  public void stringContainsMatchPatternFailNull() {
+    expectFailureWhenTestingThat(null).containsMatch(Pattern.compile(".*b.*"));
+    assertFailureValue("expected a string that contains a match for", ".*b.*");
+  }
+
   @Test
   public void stringDoesNotContainMatchString() {
     assertThat("aaa").doesNotContainMatch(".*b.*");
@@ -250,6 +313,12 @@ public void stringDoesNotContainMatchStringUsesFind() {
     assertFailureValue("expected not to contain a match for", "[b]");
   }
 
+  @Test
+  public void stringDoesNotContainMatchStringUsesFindFailNull() {
+    expectFailureWhenTestingThat(null).doesNotContainMatch("[b]");
+    assertFailureValue("expected a string that does not contain a match for", "[b]");
+  }
+
   @Test
   @GwtIncompatible("Pattern")
   public void stringDoesNotContainMatchPattern() {
@@ -261,6 +330,13 @@ public void stringDoesNotContainMatchPattern() {
     assertFailureValue("full string", "zzabazz");
   }
 
+  @Test
+  @GwtIncompatible("Pattern")
+  public void stringDoesNotContainMatchPatternFailNull() {
+    expectFailureWhenTestingThat(null).doesNotContainMatch(Pattern.compile(".b."));
+    assertFailureValue("expected a string that does not contain a match for", ".b.");
+  }
+
   @Test
   public void stringEqualityIgnoringCase() {
     assertThat("café").ignoringCase().isEqualTo("CAFÉ");