Junit es un marco de prueba de regresión escrito por Erich Gamma y Kent Beck. La prueba JUNIT es una prueba de programador, es decir, una prueba de caja blanca. La página de inicio del proyecto: http://www.junit.org/
Cuando usa JUnit, escribe principalmente casos de prueba heredando la categoría de prueba y usa el nombre testXxxx () para escribir pruebas unitarias.
Hay tres cosas que realmente necesitan escribir pruebas con Junit:
1. Una declaración de importación presenta todas las clases en Junit.framework.*.
2. Una declaración de extensión permite que su clase herede de TestCase.
3. Un constructor que llama a Super (cadena).
Mathtool funcional
paquete com.zj.c01; public class MathTool {public static int gcd (int num1, int num2) {int r = 0; while (num2! = 0) {r = num1 % num2; num1 = num2; num2 = r; } return num1; }}Clase de prueba MathToolTest
paquete com.zj.c01; import junit.framework.testcase; public class MathToolTest extiende TestCase {public MathToolTest (nombre de cadena) {super (nombre); } public void testgcd () {afirmarequals (5, mathtool.gcd (10, 5)); }} Cuando usamos Junit para probar excepciones, la forma más fácil de pensar es usar el intento ... atrapar para atrapar la excepción. Necesitamos afirmar las siguientes condiciones:
1. Excepción que de hecho se arroja 2. Tipo de clase de la excepción lanzada 3. Se lanza el tipo específico de la excepción. En general, verifique la determinación de la cadena contenida en el atributo de mensaje de la excepción. Entonces puede escribir el código común como este:
@Test public void testBizexception () {try {contraseña.validate ("123"); fail ("sin excepción lanzada"); } capt (excepción ex) {afirmarTrue (ex instancia de bizexception); afirmarTrue (ex.getMessage (). Contiene ("Error")); }} El método probado aquí es si el método Password.Validate () lanza la excepción correspondiente. Tenga en cuenta que Fail ("No hay excepción lanzada"). En el intento no se pierde aquí.
Línea de código, de lo contrario, si el método que se está probando no lanza una excepción, este caso de uso pasará y lo que espera es lanzar una excepción.
En Junit 4, no hay necesidad de probar excepciones del método como esta. Aunque esto también puede determinar si la excepción esperada se ejecuta, todavía tiene desventajas. Lo sabrás después de compararlo. Junit no puede mostrarle la razón detallada de la falla de afirmación en el método de captura try ...
Entonces, echemos un vistazo a cómo probar las excepciones desde Junit 4. Solo use la anotación de @Test (Execed = Exception.Class), consulte el siguiente código:
@Test (esperado = bizexception.class) public void testBizexception () {contraseña.validate (nulo); }
Si el método que se está probando tiene el tipo BizException lanzado, la afirmación es exitosa. Por cierto, @Test (esperado = bizexception.class) solo puede determinar el tipo de excepción, y no hay una anotación correspondiente para afirmar información más específica sobre la excepción, es decir, no puede determinar el atributo de mensaje de la excepción lanzada.
Luego, a veces lanzaremos una excepción de un tipo varias veces en un método, pero las razones son diferentes, es decir, la información del mensaje de la excepción es diferente. Por ejemplo, cuando ocurra una BizException, habrá las siguientes dos excepciones:
nueva BizException ("La contraseña debe contener al menos 6 letras") Nueva bizexception ("Longitud de contraseña menos de 15 letras") Esto requiere una forma de afirmar un mensaje de excepción. Por esta razón, desde Junit 4.7, hemos dado una opción más perfecta, que es el siguiente código:
@Rule public EcharingException esperadox = esperadoxception.none (); @Test public void testBizexception () lanza InvalidPasswordException {expectingEx.expect (bizexception.class); esperadox.expectMessage ("requerido"); Contraseña.validate (""); } El código anterior debe centrarse en:
1. @Rule anotó la declaración de variable esperadoxception, debe ser público
2. En @Test, no se puede escribir como @Test (esperado = bizexception.class), de lo contrario no se puede probar correctamente. Es decir, el método @Test (esperado = bizexception.class) y el método esperadox.expectxxx () en el método de prueba no puede coexistir al mismo tiempo. 3. Los parámetros en ExpectedEx.expectMessage () son combinadores o subcadres, lo que significa que las expresiones regulares se pueden usar para determinar o determinar si se incluye una subcadena. 4. Otra cosa es muy pesada, escriba el método probado detrás del método esperadox.expectxxx (), de lo contrario la excepción que no se puede probar correctamente 5. El último es que el método de prueba lanza directamente la excepción del método que se está probando, no afectará la excepción que le preocupa. Como se mencionó anteriormente, utilizando el método de try ... Catch también puede probar correctamente la excepción. ¿Cuáles son los beneficios de comparar el @Test (esperado = ...) o @rule e intente ... el método de captura? Obviamente, el método recomendado por JUnit 4 es conciso y claro. Veamos lo que Junit le indicará cuando falle la prueba.
El aviso que obtiene cuando la prueba falló anormalmente:
Cuando no hay excepción:
java.lang.assertionError: No se lanzó ninguna excepción. en org.junit.assert.fail (afirmar.java:91) en cc.unmi.passwordtest.passwordlengthlessthan6lettersthrowseCeSception (PasswordTest.java:20)
Cuando el tipo de excepción es incorrecto o el mensaje de excepción es incorrecto:
java.lang.assertionError: en org.junit.assert.fail (afirmación.java:91) en org.junit.assert.asserttrue (afirmo.java:43) en org.junit.assert.asserttrue (afirs.java:54) en cc.unmi.passwordTest.passwordLenghinglessThan6letterStrowseCeption (PasswordTest.Java:22)
La ayuda anterior para posicionar errores no es particularmente grande. Mire las indicaciones cuando la prueba falla cuando @Test (esperado = bizexception.class):
java.lang.assertionError: Excepción esperada: cc.test.bizexception en org.junit.internal.runners.statements.expectexception.evaluate (expectException.java:32) en org.junit.rules.ExtreectException $ esperadoxception.evaluate (esperadoxception.Java:110)
Use @Rules esperadoxception para probar excepciones. Consejos cuando falla:
java.lang.assertionError: esperado: (Excepción con mensaje Una cadena que contiene "sí. org.junit.rules.EXPECTECTEXCEPTION $ esperadoxceptionStatement.evaluate (esperadoxception.java:114)
Especialmente el método de @Rules esperadoxception es claramente consciente de por qué la prueba falló. Qué excepción se espera, qué cadena está contenida en el mensaje de excepción, qué tipo de excepción se obtiene realmente y cuál es el mensaje en la excepción. Con esto, sabrá cómo arreglar su programa tan pronto como lo vea.