Java Truth OR assertion

Question

I would like to check with Java Truth assertion library if any of the following statements is satisfied:

assertThat(strToCheck).startsWith("a");
assertThat(strToCheck).contains("123");
assertThat(strToCheck).endsWith("@");

In another word, I am checking if strToCheck starts with a OR contains the substring 123, OR ends with @. Aka, if any of the 3 conditions applies. I am just giving the assertions as an example.

Is there a way to do the logical OR assertion with Truth?

I know with Hamcrest, we could do something like:

assertThat(strToCheck, anyOf(startsWith("a"), new StringContains("123"), endsWith("@")));

Answer 1

assertTrue(strToCheck.startsWith("a") || strToCheck.contains("123") ||strToCheck.endsWith("@")); 

You can do what you asked for with this single line only.

Answer 2

Why not use a regular expression to solve this:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
  public static void main(String[] args) {

String strToCheck = "afoobar123barfoo@";
    Pattern pattern = Pattern.compile("a.*123.*@");
    Matcher matcher = pattern.matcher(strToCheck);
    boolean matchFound = matcher.find();
    //matchFound now contains a true/false value. 
  }
}

Answer 3

All the ways of doing this with Truth currently either are very clumsy or don't produce as informative a failure message as we'd aim for. See this comment on issue 991, which mentions some possible future enhancements, but this is never going to be something that Truth is as good at as Hamcrest is.

If I were writing a test that needed this, I would probably write something like:

boolean valid =
    strToCheck.startsWith("a")
        || strToCheck.contains("123")
        || strToCheck.endsWith("@");
if (!valid) {
  assertWithMessage(
          "expected to be a valid <some description of what kind of string you expect>"
              + "\nbut was: %s", strToCheck)
      .fail()
}

And then I'd extract that to a method if it's going to be commonly needed.

Answer 4

Going to flip this on its head, since you're talking about testing.

You should be explicit about what you're asserting, and not so wide-open about it.

For instance, it sounds like you're expecting something like:

• a...123@
• a123@
• a
• @
• 123

...but you may only actually care about one of those cases.

So I would encourage you to explicitly validate only one of each. Even though Hamcrest allows you to find any match, this too feels like an antipattern; you should be more explicit about what it is you're expecting given a set of strings.