Is there a nicer way to write in jUnit
String x = "foo bar";
Assert.assertTrue(x.contains("foo"));
If you add in Hamcrest and JUnit4, you could do:
String x = "foo bar";
Assert.assertThat(x, CoreMatchers.containsString("foo"));
With some static imports, it looks a lot better:
assertThat(x, containsString("foo"));
The static imports needed would be:
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.CoreMatchers.containsString;
use fest assert 2.0 whenever possible EDIT: assertj may have more assertions (a fork)
assertThat(x).contains("foo");
Use hamcrest Matcher containsString()
// Hamcrest assertion
assertThat(person.getName(), containsString("myName"));
// Error Message
java.lang.AssertionError:
Expected: a string containing "myName"
got: "some other name"
You can optional add an even more detail error message.
// Hamcrest assertion with custom error message
assertThat("my error message", person.getName(), containsString("myName"));
// Error Message
java.lang.AssertionError: my error message
Expected: a string containing "myName"
got: "some other name"
Posted my answer to a duplicate question here
It's too late, but just to update I got it done with below syntax
import org.hamcrest.core.StringContains;
import org.junit.Assert;
Assert.assertThat("this contains test", StringContains.containsString("test"));
You can use assertj-fluent assertions. It has lot of capabilities to write assertions in more human readable - user friendly manner.
In your case, it would be
String x = "foo bar";
assertThat(x).contains("foo");
It is not only for the strings, it can be used to assert lists, collections etc.. in a friendlier way
Example (junit version- 4.13)
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
public class TestStr {
@Test
public void testThatStringIsContained(){
String testStr = "hi,i am a test string";
assertThat(testStr).contains("test");
}
}
Another variant is
Assert.assertThat(actual, new Matches(expectedRegex));
Moreover in org.mockito.internal.matchers
there are some other interesting matchers, like StartWith
, Contains
etc.
assertj variant
import org.assertj.core.api.Assertions;
Assertions.assertThat(actualStr).contains(subStr);
I've tried out many answers on this page, none really worked:
org.hamcrest.CoreMatchers.containsString does not compile, cannot resolve method.
JUnitMatchers.containsString is depricated (and refers to CoreMatchers.containsString).
org.hamcrest.Matchers.containsString: NoSuchMethodError
So instead of writing readable code, I decided to use the simple and workable approach mentioned in the question instead.
Hopefully another solution will come up.
Success story sharing
org.junit.Assert
versusjunit.framework.Assert
, as the latter doesn't have the Hamcrest MatcherassertThat()
assertThat
is way more helpful then anassertTrue
import static org.junit.Assert.assertThat; import static org.hamcrest.CoreMatchers.containsString;
- just to save someone from troubleorg.hamcrest.Matchers.containsString;
in the latest api, in thehamcrest-library
dependency.