Afirmar coincidencias de expresiones regulares en JUnit

de rubí Test::Unit tiene un bonito assert_matches método que se puede usar en pruebas unitarias para afirmar que una expresión regular coincide con una cadena.

¿Hay algo así en JUnit? Actualmente, hago esto:

assertEquals(true, actual.matches(expectedRegex));

Si utiliza assertThat() con un emparejador Hamcrest que prueba las coincidencias de expresiones regulares, luego, si la afirmación falla, recibirá un buen mensaje que indica el patrón esperado y el texto real. La afirmación se leerá con más fluidez también, por ejemplo

assertThat("FooBarBaz", matchesPattern("^Foo"));

con Hamcrest 2 puedes encontrar un matchesPattern método en MatchesPattern.matchesPattern.

No hay otra opción que yo sepa. Acabo de comprobar el afirmar javadoc para estar seguro. Sin embargo, solo un pequeño cambio:

assertTrue(actual.matches(expectedRegex));

EDITAR: he estado usando los emparejadores de Hamcrest desde la respuesta de pholser, ¡compruébalo también!

Puedes usar Hamcrest, pero tienes que escribir tu propio comparador:

public class RegexMatcher extends TypeSafeMatcher<String> {

    private final String regex;

    public RegexMatcher(final String regex) {
        this.regex = regex;
    }

    @Override
    public void describeTo(final Description description) {
        description.appendText("matches regex=`" + regex + "`");
    }

    @Override
    public boolean matchesSafely(final String string) {
        return string.matches(regex);
    }


    public static RegexMatcher matchesRegex(final String regex) {
        return new RegexMatcher(regex);
    }
}

uso

import org.junit.Assert;


Assert.assertThat("test", RegexMatcher.matchesRegex(".*est");

Puedes usar Hamcrest y jcabi-matchers:

import static com.jcabi.matchers.RegexMatchers.matchesPattern;
import static org.junit.Assert.assertThat;
assertThat("test", matchesPattern("[a-z]+"));

Más detalles aquí: Coincidencias Hamcrest de expresiones regulares.

Necesitará estas dos dependencias en classpath:

<dependency>
  <groupId>org.hamcrest</groupId>
  <artifactId>hamcrest-core</artifactId>
  <version>1.3</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>com.jcabi</groupId>
  <artifactId>jcabi-matchers</artifactId>
  <version>1.3</version>
  <scope>test</scope>
</dependency>

Como también estaba buscando esta funcionalidad, comencé un proyecto en GitHub llamado probador de expresiones regulares. Es una biblioteca que ayuda a facilitar la prueba de expresiones regulares en Java (actualmente solo funciona con JUnit).

La biblioteca es muy limitada en este momento, pero tiene un comparador de Hamcrest que funciona así

assertThat("test", doesMatchRegex("tes.+"));
assertThat("test", doesNotMatchRegex("tex.+"));

Más información sobre cómo usar regex-tester es aquí.

Un emparejador similar a la implementación de Ralph ha sido adicional a la biblioteca oficial de emparejadores de Java Hamcrest. Desafortunadamente, aún no está disponible en un paquete de lanzamiento. la clase esta en GitHub aunque si quieres echar un vistazo.

otra alternativa usando assertj. este enfoque es bueno ya que le permite pasar el objeto de patrón directamente.

import static org.assertj.core.api.Assertions.assertThat;
assertThat("my\nmultiline\nstring").matches(Pattern.compile("(?s)my.*string", Pattern.MULTILINE));