Assertcontains op snaren in Junit

Is er een mooiere manier om in Junit

te schrijven

String x = "foo bar";
Assert.assertTrue(x.contains("foo"));

Antwoord 1, Autoriteit 100%

Als u in Hamcrest en Junit4 toevoegt, zou u kunnen doen:

String x = "foo bar";
Assert.assertThat(x, CoreMatchers.containsString("foo"));

Met enkele statische invoer ziet het er veel beter uit:

assertThat(x, containsString("foo"));

De benodigde statische invoer zou zijn:

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.CoreMatchers.containsString;

Antwoord 2, Autoriteit 5%

Gebruik fest assert 2.0 Waar mogelijk bewerken: assertj kan meer beweringen (een vork)

assertThat(x).contains("foo");

Antwoord 3, Autoriteit 3%

Gebruik Hamcrest-matcher containsString()

// Hamcrest assertion
assertThat(person.getName(), containsString("myName"));
// Error Message
java.lang.AssertionError:
Expected: a string containing "myName"
     got: "some other name"

U kunt optioneel een nog meer detail-foutbericht toevoegen.

// 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"

Geplaatst mijn antwoord op een dubbele vraag hier

Antwoord 4

Gebruik de nieuwe assertThatSyntax Samen met hamcrest .

Het is beschikbaar vanaf JUNIP 4.4 .

Antwoord 5

Het is te laat, maar gewoon om bij te werken, heb ik het gedaan met onderstaande syntaxis

import org.hamcrest.core.StringContains;
import org.junit.Assert;
Assert.assertThat("this contains test", StringContains.containsString("test"));

Antwoord 6

U kunt assertj -fluense beweringen gebruiken. Het heeft veel mogelijkheden om beweringen op meer menselijke leesbare – gebruiksvriendelijke manier te schrijven.

In uw geval zou het

zijn

String x = "foo bar";
 assertThat(x).contains("foo");

Het is niet alleen voor de snaren, het kan worden gebruikt om lijsten, collecties enz .. op een vriendelijkere manier te beweren

Antwoord 7

Voorbeeld (JUNIST VERSIE- 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");
 }
}

Antwoord 8

Een andere variant is

Assert.assertThat(actual, new Matches(expectedRegex));

Bovendien in org.mockito.internal.matchersEr zijn enkele andere interessante matchers, zoals StartWith, ContainsETC.

Antwoord 9

Assertj-variant

import org.assertj.core.api.Assertions;
Assertions.assertThat(actualStr).contains(subStr);

Antwoord 10

Ik heb veel antwoorden op deze pagina uitgeprobeerd, geen enkele werkte echt:

• org.hamcrest.CoreMatchers.containsStringcompileert niet, kan methode niet oplossen.
• JUnitMatchers.containsStringwordt afgeraden (en verwijst naar CoreMatchers.containsString).
• org.hamcrest.Matchers.containsString: NoSuchMethodError

Dus in plaats van leesbare code te schrijven, heb ik besloten om in plaats daarvan de eenvoudige en werkbare aanpak te gebruiken die in de vraag wordt genoemd.

Hopelijk komt er een andere oplossing.