Junit 4, el famoso marco de pruebas de la unidad Java, ha estado fuera por mucho tiempo. En ese momento, descubrí que Junit 5 estaba en versión beta, por lo que iba a escribir un artículo para presentar Junit 5. Sin embargo, porque todavía es una versión beta, algunas partes no son perfectas, y soy un poco perezoso y no las escribo bien. De repente recordé este incidente en estos días. Cuando lo revisé en el sitio web oficial, descubrí que el 10 de septiembre, ¡la versión oficial de Junit 5 finalmente salió! Luego volví a escribir el artículo y presentarle el último marco Junit.
Estructura marco
En comparación con JUnit 4, la estructura de Junit 5 es muy clara y proporciona un buen soporte para funciones extendidas como complementos personalizados, ejecución de la prueba IDE, etc. Esto se puede ver desde la estructura del proyecto.
Plataforma Junit
El nombre del paquete de este grupo es org.junit.platform. Como puede ver en el nombre, la función principal de este grupo es servir como la plataforma básica para el marco de prueba. Los módulos en este paquete incluyen API básicas, motores de ejecución y ejecutores, funciones básicas de ejecución de línea de comandos, interfaces de línea de comandos, complementos de prueba de graduación y gradle y otras funciones básicas.
Junit Júpiter
Júpiter es el nombre de código de JUnit 5. Los módulos de este paquete contienen las funciones principales de Junit 5. Si queremos usar JUnit 5, debemos incluir este conjunto de módulos.
Junit Vintage
Vintage es el nombre de código de la versión anterior de Junit. Los módulos bajo este paquete nos permiten ejecutar pruebas de Old Junit 3 y 4 en la nueva plataforma Junit.
Biblioteca de clase de importación
Mientras que Junit 5 todavía está en la fase beta, hay ejemplos de integración de Junit 5 en Maven y Gradle en la documentación oficial. Pero en la versión oficial, el contenido de esta parte desapareció, dejando solo dos enlaces al proyecto de muestra, referámonos (copiar y pegar).
Usando Maven
JUNIT5-Maven-Consumer es el ejemplo oficial de Maven. Originalmente iba a publicar la configuración de POM relevante aquí, pero cuando vi que la configuración de Maven era demasiado larga, será mejor que lo olvide. Si tiene algún requisito, consulte la configuración de POM de este proyecto usted mismo.
Usando Gradle
Si usa Gradle, entonces este problema es mucho más simple. También hay descripciones detalladas en el proyecto de muestra JUNIT5-Gradle-Consumer.
En primer lugar, Gradle no es compatible con JUnit 5 por defecto, por lo que el complemento de Gradle JUNIT Platform debe haberse habilitado para admitirlo.
BuildScript {repositorios {mavencentral ()} dependencias {classpath 'org.junit.platform: Junit-Platform-Gradle-Plugin: 1.0.0'}} Aplicar complemento: 'org.junit.platform.gradle.plugin'Luego está la configuración de este complemento de Gradle. Por defecto, se ejecutarán todos los motores y etiquetas. Si desea elegir realizar pruebas solo para ciertos motores y etiquetas, puede desenchufar lo siguiente y modificarlas de acuerdo con sus propias necesidades. Por supuesto, si no tiene estos requisitos avanzados, puede eliminar esta parte.
Junitplatform {// PlatformVersion '1.0.0' Engines {Engines {// Incluya 'Junit-Jupiter', 'Junit-Vintage' // excluye 'Custom-Engine'} etiquetas {// incluye 'ayunar' excluir 'lento'} // incluido Archivo ('Build/Test-Results/Junit-Platform') // Este es el valor predeterminado // logManager 'org.apache.logging.log4j.jul.logmanager'}Si solo necesita ejecutar pruebas JUnit 5, simplemente importe las siguientes dos dependencias. Las dependencias de la plataforma JUNIT se importan automáticamente.
Dependencias {testCompile ("org.junit.jupiter: junit-jupiter-api: 5.0.0") testRuntime ("org.junit.jupiter: junit-jupiter-engine: 5.0.0")}Si desea ejecutar pruebas Old Junit 3 y 4 en la nueva plataforma, debe importar las siguientes dependencias.
Dependencias {testCompile ("Junit: Junit: 4.12") testRunTime ("org.junit.vintage: junit-vintage-engine: 4.12.0")}Escribir pruebas
Prueba de Junit 4
Si toda la configuración anterior está completa, puede comenzar a escribir pruebas ahora. Primero, revisemos la antigua prueba Junit 4.
clase pública Junit4test {@beforeclass public static void init () {System.out.println ("antes de clases");}@Afterclass public static void limpiar () {system.println ("después de la clase");}@antes de public void () {System.println ("antes");}@después del público después () después () {System.out.println ("After");}@Test public void test1 () {System.out.println ("Test 1");}@Test public Void test2 () {System.out.println ("Test 2");}}Use la prueba de Gradle y otros comandos para ejecutar esta prueba. El resultado es similar al de esto.
Antes de classbeForetest 1test 2Fter Class
Prueba de Junit 5
Echemos un vistazo a cómo escribir la prueba equivalente de Junit 5. El cambio más obvio se puede ver: en primer lugar, varias anotaciones se renombraron a nombres más famosos; Otro punto es que el método de prueba no tiene que ser un método público, por lo que podemos escribir el teclado unas pocas veces menos.
clase pública Junit5Test {@beforealll static void beforeAll () {System.out.println ("antes de todo");}@después de todo Static void después de lo posible () {System.out.println ("después de todo");}@antes de la vecina antes () {System.println ("antes");}@AfterEach Void () () {System.out.println ("después");}@test void test1 () {System.out.println ("test 1");}@test void test2 () {system.out.println ("prueba 2");}}Escribir afirmaciones
Para verificar que los casos de prueba son correctos, necesitamos escribir algunas afirmaciones. Junit 5 viene con muchas afirmaciones que pueden ayudarnos a escribir casos de prueba. Además, estas afirmaciones vienen con versiones sobrecargadas que pueden aceptar expresiones lambda, que son muy adecuadas para el uso de Java 8. Por supuesto, personalmente creo que es más conveniente afirmar.
import static org.junit.assert.asserttrue; import static org.junit.jupiter.api.assertions.*; public class asertionDemo {@test void testAssertion () {afirmarequals (10, 10); afirmartrue (verdadero); afirmarequals (100, 100, "dos números iguales"); afirmarall ("número", () -> afirmarequals ("nombre", "nombre"), () -> afirmarequals (500, 500)); AfirmarThrows (InvalidParamEterException.class, () -> {lanzar nueva invalidParameterException ();}); int resultado = afirmout (duration.ofSeconds (5), () -> {int i = 0, j = 0; while (i <= 100) {for (; j <= 100000; j ++) j ++; i ++;} return i;}); afirmarequals (100, resultado); }}Inyección de dependencia
Ahora tanto los métodos de constructor como de prueba de la clase de prueba pueden aceptar parámetros. La interfaz ParametResolver define cómo inyectar parámetros en tiempo de ejecución. Varios incorporados nos permiten obtener información sobre el tiempo de ejecución del caso de prueba.
Primero es TestInfoparametResolver. Si hay una instancia de tipo testInfo en el método, el marco JUnit 5 inyectará automáticamente la instancia. Varios métodos de esta instancia pueden permitirnos obtener el nombre, el nombre de la pantalla, la etiqueta y otra información de la clase de prueba y el método de prueba.
clase pública dependencyinjectionDemo {@test @displayname ("inyección de dependencia") @tag ("test") void testdisplayname (testInfo testInfo) {afirmarequals ("inyección de dependencia", testInfo.getDisplayName ()); afirmarequals (colección.singleton ("test"), testInfo.gettags ()); }}También hay analizadores de parámetros incorporados, como RepetitionInfoparametResolver, que se introducirán más adelante.
Anotaciones comunes
nombre para mostrar
Podemos agregar nombres personalizados para probar clases y métodos de prueba, que se muestran por el corredor de prueba y los informes de prueba. El nombre de la pantalla no se muestra como un nombre de variable. Puede ser una cadena larga que contiene espacios, o incluso un emoji emoji.
@DisplayName ("La clase de prueba puede especificar el nombre de visualización") clase pública DisplayNamedemo {@test @DisplayName ("El método de prueba también puede especificar el nombre de visual {}}Desactivar pruebas
La anotación de @disable se puede usar en las clases de prueba o los métodos de prueba, y la prueba correspondiente puede deshabilitarse.
@DISABLEDPublic de clase DISCABLEDTDEMO {@test // @discapaced void testDisable () {}}Prueba repetida
Si necesita que se ejecute un método de prueba varias veces, use la anotación @RepeatedTest.
clase pública RepetedTestDemo {@RepeatedTest (10) Void testRepeated10Times () {}}También puede inyectar una instancia RepetitionInfo para verificar el número actual de repeticiones y el número total de repeticiones.
public class RepetedTestDemo {@beboreEch void BeforeEach (RepetitionInfo Info) {System.out.printf (" %d - %d/n", info.getCurrentRepetition (), info.getTotalRepetitions ());}@repetidostest (10) vaceRepeated10Times () {}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}Viene con etiquetas
Cuando presenté la configuración de Gradle, dije que puede elegir filtrar ciertas etiquetas en la configuración. También es muy simple dar etiquetas en el código, solo use la anotación de @tag.
@Tag ("taggedTest") public class tagDemo {@test @tag ("taggedTest1") void testwithtag1 () {} @test @tag ("taggedTest2") void testwithtag2 () {}}}}}}}Pruebas anidadas
A veces, se pueden requerir pruebas anidadas para indicar la relación de inclusión entre ciertas pruebas. Las pruebas anidadas usan la anotación @nested.
@DisplayName ("Test Outer Test") Public Clase NestedDemo {@Test void testouter () {} @nested @displayname ("interner test") clase innertestDemo {@test void testInner () {}}}Cabe señalar que solo las clases internas estáticas pueden usar anotaciones anidadas. Además, dado que Java no permite que las clases internas tengan métodos estáticos, no puede tener anotaciones @boreally y @Afterall. Si desea romper esta limitación, debe agregar la anotación @TestinStance (Lifecycle.per_class) a la clase interna anidada. Para más detalles, consulte el ciclo de vida de la instancia de prueba.
Soporte IDE
Aunque Junit 5 ha salido ahora. Sin embargo, el soporte de varias cadenas de herramientas no se ha mantenido. Actualmente, solo la idea de IntelliJ y Eclipse 4.7 (oxígeno) han agregado apoyo para Junit 5. Por lo tanto, si se encuentra en una situación formal, es más seguro usar JUnit 4.
Preguntas frecuentes
Distinguir entre diferentes versiones de la anotación @test
Justo cuando estaba escribiendo este artículo, encontré un problema con mi ejemplo de prueba. La prueba no se pudo pasar y se muestra el mensaje de error a continuación.
Fallos (1): Junit Vintage: yitian.study.test.assertiondemo: inicializationError classSource [classname = 'yitian.study.test.assertiondemo', filePosition = null] => java.lang.exception: testimonio de métodos () debe ser público
Los estudiantes con buen inglés deberían poder reconocerlo. Este mensaje de error dice que el método de prueba debe ser público. Pero como se mencionó anteriormente, Junit 5 ha cancelado esta restricción, entonces, ¿por qué todavía ocurre este error? Miré cuidadosamente y encontré el error. Tal vez se deba a que Junit 4 se usó mucho en el pasado, por lo que el IDE predeterminado es la anotación @test, que se completa automáticamente.
importar org.junit.test;
Este paquete es la anotación @test bajo Junit 4. Si queremos usar Junit 5, necesitamos la siguiente anotación @test.
importar org.junit.jupiter.api.test;
Después de modificarlo, ejecute la prueba nuevamente, y de hecho no hubo ningún problema. Por supuesto, en aras del aprendizaje y el uso, también hago referencia al paquete Junit 4, por lo que se produce este conflicto. Si no tiene necesidades especiales, se recomienda importar solo paquetes JUnit 5 JAR para evitar confusiones. Por supuesto, importarlos a todos está bien, pero debe tener cuidado de distinguirlos y no escribir anotaciones Junit 4 a las pruebas Junit 5. Finalmente, adjuntaré mis ejemplos de prueba. Los interesados pueden echar un vistazo.
Resumir
Lo anterior es todo el contenido de este artículo sobre el contenido relacionado con Junit5, y espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!