AssertContains en cadenas en jUnit

3 minutos de lectura

avatar de usuario
destripador234

¿Hay una mejor manera de escribir en jUnit?

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

  • En mi opinión, esto es lo suficientemente bueno, las opciones sugeridas son menos legibles

    – El Padrino

    26/10/2018 a las 19:25

  • @TheGodfather menos legible, pero produce errores de aserción más significativos (es decir, la respuesta aceptada mostrará la diferencia en las cadenas, mientras que la solución de OP solo mostrará “Falso cuando se espera Verdadero” en caso de falla)

    – Miguel

    12 de junio de 2019 a las 22:57

  • Lo que hace que una afirmación sea “más agradable” es el mensaje de error cuando falla. Lo legible que es en el código es secundario a eso, porque no tienes que mirar el código hasta que falla, y el mensaje de falla es lo primero que ves.

    – rjmunro

    12 de marzo de 2020 a las 11:36

  • La pregunta en sí debería ser la respuesta aceptada 😀

    – d1Maestro

    5 de mayo a las 14:32

avatar de usuario
Yishai

Si agrega Hamcrest y JUnit4, podría hacer:

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

Con algunas importaciones estáticas, se ve mucho mejor:

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

Las importaciones estáticas necesarias serían:

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

  • Asegúrate de estar usando org.junit.Assert versus junit.framework.Assertya que este último no tiene Hamcrest Matcher assertThat()

    – Soluciones de software visionarias

    8 de agosto de 2012 a las 17:09


  • Creo que cuando se ejecuta JUnit 4.10, la clase a usar es org.junit.matchers.JUnitMatchers, por ejemplo: assertThat(“algo”, JUnitMatchers.containsString(“algo”));

    –Ewen Cartwright

    21 de febrero de 2013 a las 13:04


  • El mensaje de falla para una falla assertThat es mucho más útil que un assertTrue

    –Mike Rylander

    1 de abril de 2013 a las 15:04

  • las importaciones estáticas necesarias son import static org.junit.Assert.assertThat; import static org.hamcrest.CoreMatchers.containsString; – solo para salvar a alguien de problemas

    – eis

    7 ago 2013 a las 16:03

  • … y org.hamcrest.Matchers.containsString; en la última api, en el hamcrest-library dependencia.

    – eis

    26 de noviembre de 2013 a las 14:25


avatar de usuario
piotrek

usar festival afirmar 2.0 siempre que sea posible EDITAR: afirmar puede tener más afirmaciones (un tenedor)

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

  • No encontré un método contiene con AssertJ.assertThat. Esto es lo que encontré en su lugar: org.assertj.core.api.Assertions.assertThat(conversionException).hasMessageContaining(“some substring”);

    – Raj

    5 de diciembre de 2018 a las 1:18

  • lo siento, creo que mi comentario anterior no se adapta al contexto de esta respuesta. Estaba en un caso de uso diferente en el que necesito verificar una subcadena dentro de un mensaje de excepción.

    – Raj

    5 de diciembre de 2018 a las 1:24

avatar de usuario
mike rylander

Usar Hamcrest Matcher containsString()

// Hamcrest assertion
assertThat(person.getName(), containsString("myName"));

// Error Message
java.lang.AssertionError:
Expected: a string containing "myName"
     got: "some other name"

Puede agregar opcionalmente un mensaje de error aún más detallado.

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

Publiqué mi respuesta a una pregunta duplicada aquí

Usa el nuevo assertThat sintaxis junto con Hamcrest.

Está disponible a partir de JUnit 4.4.

Es demasiado tarde, pero solo para actualizar lo hice con la siguiente sintaxis

import org.hamcrest.core.StringContains;
import org.junit.Assert;

Assert.assertThat("this contains test", StringContains.containsString("test"));

avatar de usuario
usuario2739602

Puedes usar afirmar-afirmaciones fluidas. Tiene muchas capacidades para escribir aserciones de una manera más legible por humanos y fácil de usar.

En tu caso seria

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

No es solo para las cadenas, se puede usar para afirmar listas, colecciones, etc. de una manera más amigable.

avatar de usuario
Torre de perforación Muriithi

Ejemplo (junit versión- 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");
 }

}

  • Esta debería ser la respuesta aceptada. Lo mas facil y funciona

    – ajpieri

    21 de diciembre de 2020 a las 18:15

  • Gracias @ajpieri.

    – Muriithi Torre de perforación

    21 de diciembre de 2020 a las 21:02

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad