INVESTIGACION DE JUNIT

VERIFICACION Y VALIDACION

Alumno: Daniel Luna Guevara

12 DE JULIO DE 2013
INSTITUTO TECNOLOGICO SUPERIOR DE TEPEXI DE RODRIGUEZ

Contenido
1. Introduccin a las pruebas unitarias ........................................................................................... 3 1.1. Las pruebas unitarias............................................................................................................ 3 1.2. Las pruebas unitarias con JUnit ............................................................................................ 3 1.3. Anotaciones JUnit disponibles ............................................................................................. 4 1.4. Assert.................................................................................................................................... 6 1.5. Crear un conjunto de pruebas JUnit .................................................................................... 7 1.6 Ejecute la prueba fuera de Eclipse ........................................................................................ 8 2. Instalacin de JUnit ..................................................................................................................... 9 2.1. Con JUnit integrado en Eclipse ............................................................................................. 9 2.2. Descarga de la biblioteca JUnit ............................................................................................ 9 3. Apoyo Eclipse para JUnit ............................................................................................................. 9 3.1. Creacin de pruebas JUnit ................................................................................................... 9 3.2. Correr pruebas JUnit .......................................................................................................... 10 Nota .......................................................................................................................................... 11 3.3. JUnit importaciones estticas ............................................................................................ 11 3.4. Asistente para la creacin de bancos de pruebas .............................................................. 12 3.5. Prueba de excepcin .......................................................................................................... 13 4 Ejercicio: El uso de JUnit ............................................................................................................. 14 4.1. Preparacin del proyecto ................................................................................................... 14 4.2. Crear una clase Java ........................................................................................................... 15 4.3. Crear una prueba JUnit ...................................................................................................... 15 4.4. Ejecute la prueba de Eclipse............................................................................................... 19 5. Opciones avanzadas JUnit ......................................................................................................... 19 5.1. Prueba con parmetros ...................................................................................................... 19 5.2. Reglas ................................................................................................................................. 21 Referencia ..................................................................................................................................... 23

Tabla de ilustraciones
1ventana de resultado de pruebas de JUnit ..................................................................................... 10 2comfiguracion de pruebas .............................................................................................................. 11 3pruebas de falla............................................................................................................................... 11 4configuracin de importacin ......................................................................................................... 12 5banco de pruebas............................................................................................................................ 13 6origen de prueba ............................................................................................................................. 14 7configuracin de prueba ................................................................................................................. 15 8Comprobacion de prueba ............................................................................................................... 16 9Biblioteca de JUnit .......................................................................................................................... 17 10Ventana de pruebas...................................................................................................................... 19

1. Introduccin a las pruebas unitarias

1.1. Las pruebas unitarias
Una prueba unitaria es una pieza de cdigo escrito por un desarrollador que realiza una funcionalidad especfica en el cdigo que se prueba. El porcentaje de cdigo que est probado por las pruebas unitarias se suele llamar cobertura de la prueba. Pruebas de unidad objetivo pequeas unidades de cdigo, por ejemplo, un mtodo o una clase, (pruebas locales), mientras que las pruebas de componentes y la integracin de marketing para probar el comportamiento de un componente o de la integracin entre un conjunto de componentes o una aplicacin completa que consta de varios componentes. Las pruebas unitarias aseguran que el cdigo funciona como se pretende. Tambin son muy tiles para garantizar que el cdigo sigue funcionando segn lo previsto en caso de tener que modificar el cdigo para la fijacin de un error o ampliar la funcionalidad. Tener una cobertura de pruebas de alta de su cdigo le permite continuar con las funciones en desarrollo sin tener que realizar un montn de pruebas manuales. Tpicamente pruebas unitarias se crean en su propio proyecto o en su propia carpeta de origen para evitar que el cdigo normal y el cdigo de prueba es mixta.

1.2. Las pruebas unitarias con JUnit

JUnit prueba unitaria en la versin 4.x es un marco de pruebas que utiliza anotaciones para identificar los mtodos que especifican una prueba. Tpicamente estos mtodos de ensayo estn contenidos en una clase que slo se utiliza para la prueba. Normalmente se llama clase de prueba. El siguiente cdigo muestra un mtodo de prueba JUnit que se pueden crear a travs de Archivo Nuevo JUnit Caso de prueba JUnit.

@ Prueba

pblico void testMultiply () {

/ / MyClass se prueba MyClass tester = nuevo MyClass ();

/ / Comprobar si se multiplican (10,5) devuelve 50 assertEquals ( "10 x 5 debe ser de 50" , 50 , tester.multiply ( 10 , 5 )); }

JUnit asume que todos los mtodos de prueba se pueden ejecutar en un orden arbitrario. Por lo tanto, las pruebas no deben depender de otras pruebas. Para escribir un test con JUnit que anotar un mtodo con el @ org.junit.Test anotacin y utilizar un mtodo proporcionado por JUnit para comprobar el resultado esperado de la ejecucin de cdigo en comparacin con el resultado real. Puede utilizar la interfaz de usuario de Eclipse para ejecutar la prueba, a travs de clic derecho sobre la clase de prueba y seleccionar Ejecutar Ejecutar como JUnit prueba. Fuera de Eclipse puede utilizar org.junit.runner.JUnitCore clase para ejecutar la prueba.

1.3. Anotaciones JUnit disponibles

La siguiente tabla ofrece una visin general de las anotaciones disponibles en JUnit 4.x.

Tabla 1. Anotaciones Anotacin Descripcin

@ Prueba mtodo public void () @ Antes mtodo public void () @ Despus mtodo public void ()

La anotacin @ prueba identifica que un mtodo es un mtodo de prueba.

Este mtodo se ejecuta antes de cada prueba. Este mtodo se puede preparar el entorno de prueba (por ejemplo, leer los datos de entrada, se inicializa la clase). Este mtodo se ejecuta despus de cada prueba. Este mtodo puede limpiar el entorno de prueba (por ejemplo, eliminar los datos temporales, restaurar los valores predeterminados).Tambin puede guardar la memoria mediante la limpieza de las estructuras de memoria caros. Este mtodo se ejecuta una vez, antes del comienzo de todas las pruebas. Esto se puede utilizar para llevar a cabo actividades intensivas de tiempo, por ejemplo, para conectarse a una base de datos. Los mtodos anotados con esta anotacin es necesario definir comoestticos para trabajar con JUnit. Este mtodo se ejecuta una vez, despus de haber realizado todas las pruebas. Esto se puede utilizar para llevar a cabo las actividades de limpieza, por ejemplo, para desconectarse de una base de datos. Los mtodos anotados con esta anotacin es necesario definir comoestticos para trabajar con JUnit. No tiene en cuenta el mtodo de ensayo. Esto es til cuando se ha cambiado el cdigo subyacente y el caso de prueba todava no se ha adaptado. O si el tiempo de ejecucin de esta prueba es demasiado larga para ser incluida. No logra, si el mtodo no produce la excepcin nombrada.

@ BeforeClass mtodo public static void ()

@ AfterClass mtodo public static void ()

@ Ignorar

@ Prueba (esperado = Exception.class) @ Prueba (timeout = 100)

No logra, si el mtodo tarda ms de 100 milisegundos.

1.4. Assert
JUnit proporciona mtodos estticos en el Afirmar clase para comprobar la existencia de ciertas condiciones. Estos mtodos afirmacin tpicamente comienzan con asevera y le permiten especificar el mensaje de error, el esperado y el resultado real. Un mtodo de afirmacin compara el valor real devuelto por una prueba para el valor esperado, y una AssertionException si la prueba de comparacin falla. se produce

La siguiente tabla ofrece una visin general de estos mtodos. Los parmetros en corchetes [] son opcionales. Tabla 2. Mtodos de ensayo Declaracin Descripcin

fallar (String)

Deje que el mtodo falle. Podra ser utilizado para comprobar que cierta parte del cdigo no se alcanza. O tener una prueba de no haber antes de implementar el cdigo de prueba.

assertTrue ([Mensaje], condicin booleana)

Comprueba que la condicin booleana es verdadera.

assertsEquals ([String mensaje], que se espera, real)

Los exmenes que dos valores son iguales. Nota: para las matrices no se comprueba la referencia el contenido de las matrices.

assertsEquals ([String mensaje], esperada, actual, la tolerancia)

Prueba de que los valores float o double coinciden. La tolerancia es el nmero de decimales que debe ser la misma.

assertNull objeto)

([Mensaje],

Comprueba si el objeto es nulo.

assertNotNull ([Mensaje], objeto)

Comprueba que el objeto no es nulo.

assertSame ([cadena], que se espera, real)

Comprueba que ambas variables se refieren al mismo objeto.

assertNotSame ([cadena], que se espera, real)

Comprueba que ambas variables se refieren a objetos diferentes.

Nota Usted debe proporcionar mensajes significativos en las afirmaciones de modo que sea ms fcil para los desarrolladores para identificar el problema. Esto ayuda en la fijacin de la cuestin, sobre todo si alguien se ve en el problema, que no escribi el cdigo de prueba o el cdigo de prueba.

1.5. Crear un conjunto de pruebas JUnit

Si tiene varias clases de prueba se pueden combinar en un conjunto de pruebas. Ejecucin de un conjunto de pruebas ejecutar todas las clases de prueba en esa suite. El siguiente cdigo de ejemplo muestra un conjunto de pruebas que define que dos clases de prueba deben ser ejecutadas. Si desea agregar otra clase de prueba que usted puede agregar a @ Suite.SuiteClasses comunicado.

paquete com.vogella.junit.first;

import org.junit.runner.RunWith; import org.junit.runners.Suite; import org.junit.runners.Suite.SuiteClasses;

@ RunWith (Suite.class) @ SuiteClasses ({MyClassTest.class, MySecondClassTest.class}) pblicos de clase alltests {

1.6 Ejecute la prueba fuera de Eclipse

Eclipse proporciona soporte para ejecutar la prueba de forma interactiva en el IDE de Eclipse. Tambin puede ejecutar las pruebas JUnit fuera de Eclipse estndar. Elorg.junit.runner.JUnitCore clase proporciona la runClasses () mtodo que le permite ejecutar una o varias clases de pruebas. En la prueba de carpeta crear una nueva clase MyTestRunner con el siguiente cdigo. Esta clase se ejecutar la clase de prueba y escriba los posibles fallos en la consola.
paquete de.vogella.junit.first;

import org.junit.runner.JUnitCore; import org.junit.runner.Result; import org.junit.runner.notification.Failure;

pblico de clase MyTestRunner { pblicas estticas void (String [] args) { Resultado = JUnitCore.runClasses (MyClassTest. clase ), para (fallo Fallo: result.getFailures ()) { System.out.println (failure.toString ()); } }

Para ejecutar las pruebas JUnit fuera de Eclipse es necesario agregar el tarro biblioteca JUnit a la ruta de clase de su programa. Normalmente construir marcos como Apache Ant y Apache Maven se utilizan para ejecutar pruebas de forma automtica en una base regular.

2. Instalacin de JUnit
2.1. Con JUnit integrado en Eclipse
Eclipse le permite utilizar la versin de JUnit que est integrado en Eclipse. Si utiliza Eclipse no se requiere ninguna configuracin adicional. En este caso se puede omitir la siguiente seccin.

2.2. Descarga de la biblioteca JUnit

Si desea controlar la biblioteca JUnit utiliza explcitamente, JUnit4.x.jar descargar desde el siguiente sitio web de JUnit. La descarga contiene el junit-4. *. jar que es la biblioteca JUnit. Aadir esta biblioteca al proyecto Java y agregarlo a la ruta de clases.
http: / / junit.org /

3. Apoyo Eclipse para JUnit 3.1. Creacin de pruebas JUnit Usted puede escribir las pruebas JUnit manualmente, pero Eclipse apoya la creacin de test JUnit mediante asistentes. Por ejemplo, para crear una prueba JUnit o una clase de prueba para una clase existente, haga clic en su nueva clase, seleccione esta clase en el Explorador de paquetes vista, haga clic derecho sobre l y seleccione Nuevo Caso de prueba JUnit.

Como alternativa, tambin puede utilizar el bajo Archivo Nuevo Otros... Java JUnit.

JUnit

magos

disponible

3.2. Correr pruebas JUnit

Para ejecutar una prueba, seleccione la clase que contiene las pruebas, haga clic en l y seleccione Run-as JUnit prueba. Esto comienza JUnit y ejecuta todos los mtodos de prueba en esta clase. Eclipse proporciona el Alt + Shift + X, T acceso directo para ejecutar la prueba en la clase seleccionada. Si coloca el cursor sobre un nombre de mtodo, este mtodo abreviado slo se ejecuta el mtodo de prueba seleccionado. Para ver el resultado de una prueba de JUnit, Eclipse utiliza la JUnit vista que muestra los resultados de las pruebas. Tambin puede seleccionar la unidad de prueba individual en esta vista, haga clic derecho y seleccionar Ejecutar para ejecutar de nuevo.

1ventana de resultado de pruebas de JUnit Por defecto esta vista muestra todas las pruebas tambin se pueden configurar, que muestra slo las pruebas que fallan.

2comfiguracion de pruebas

Tambin se puede definir que la vista slo se activa si usted tiene una prueba de falla.

3pruebas de falla
Nota

Eclipse crea configuraciones de ejecucin de las pruebas. Puede ver y modificar estos a travs de la ejecucin Ejecutar configuraciones... men.

3.3. JUnit importaciones estticas

JUnit usa mtodos estticos y Eclipse no siempre puede crear las correspondientes a las diversas importaciones estticas declaraciones automticamente. Usted puede hacer los mtodos de prueba JUnit disponible a travs de las Asistencias contenido .Contenido Asistencias es una funcionalidad en Eclipse

que permite al desarrollador obtener finalizacin de cdigo contextual en un editor a peticin del usuario. Abra las Preferencias travs Windows seleccione Java Editor Content Assist Favoritos. Preferencias y

Utilice el nuevo Nuevo Tipo botn para aadir el org.junit.Assert tipo. Esto hace que, por dentro de JUnit se inserte las paqueterias ejemplo, la assertTrue , assertFalse y assertEquals mtodos disponibles directamente en el contenido Asistencias .

4configuracin de importacin Ahora puede utilizar Content Asistencias (atajo: Ctrl + Espacio) para agregar el mtodo y la importacin.

3.4. Asistente para la creacin de bancos de pruebas

Para crear un conjunto de pruebas en Eclipse a seleccionar las clases de prueba que deben incluirse en esto en el Explorador de paquetes vista, haga clic en ellos y seleccione Nuevo Otros... JUnit JUnit Test Suite.

5banco de pruebas

3.5. Prueba de excepcin

El @ Prueba (espera = Exception.class) anotacin est limitada, ya que slo puede examinar una excepcin. Para probar las excepciones se puede utilizar el modelo de prueba siguiente.
tratar { mustThrowException (); fallar (); } coger (Exception e) { / / espera / / Tambin puede comprobar si hay mensajes de excepcin, etc }

4 Ejercicio: El uso de JUnit

4.1. Preparacin del proyecto
Crear un nuevo proyecto llamado com.vogella.junit.first. Crear una nueva carpeta de origen de prueba. Para que este derecho del ratn en el proyecto, seleccione Propiedades y seleccione la ruta de Java Build. Seleccione la Fuente ficha.

6origen de prueba Pulse el Add Folder botn, luego presione el Crate New Folder botn. Cree la prueba de carpeta. El resultado se representa en el siguiente sceenshot.

7configuracin de prueba Alternativamente, usted puede agregar una nueva carpeta de origen, haga clic en un proyecto y seleccionando Nuevo Carpeta de origen.

4.2. Crear una clase Java

En el src carpeta, cree el com.vogella.junit.first paquete y la clase siguiente.
paquete com.vogella.junit.first;

pblico de clase MyClass { pblica int multiplicar ( int x, int y) { / / la siguiente es slo un ejemplo , si (x> 999 ) { lanzar nueva IllegalArgumentException ( "X debe ser inferior a 1000" ); } volver x / y; } }

4.3. Crear una prueba JUnit

Haga clic derecho en la nueva clase en el Explorador de paquetes vista y seleccione Nuevo Caso de prueba JUnit. En el siguiente asistente de garantizar que la prueba de 4 New JUnit se selecciona bandera y establecer la carpeta de origen para probar, para que su clase de prueba se crea en esta carpeta.

8Comprobacion de prueba Pulse el siguiente botn y seleccionar los mtodos que desee probar.

9Biblioteca de JUnit Si la biblioteca JUnit no es parte de la ruta de clases de su proyecto, Eclipse le pedir que lo agregue. Utilice esta opcin para agregar JUnit para su proyecto.

Crear una prueba con el siguiente cdigo.

paquete com.vogella.junit.first;

importar estticas org.junit.Assert.assertEquals;

importacin org.junit.AfterClass; importacin org.junit.BeforeClass; importacin org.junit.Test;

pblico de clase MyClassTest {

@ BeforeClass pblico esttico vaco testSetup () { }

@ AfterClass pblico esttico vaco TestCleanup () { / / desmontaje de los datos utilizados por las pruebas unitarias }

@ Prueba (esperado = IllegalArgumentException.class) pblico void testExceptionIsThrown () { MyClass tester = nuevo MyClass (); tester.multiply ( 1000 , 5 ); }

@ Prueba pblico void testMultiply () { MyClass tester = nuevo MyClass (); assertEquals ( "10 x 5 debe ser de 50" , 50 , tester.multiply ( 10 , 5 )); } }

4.4. Ejecute la prueba de Eclipse

Haga clic derecho en la nueva clase de prueba y seleccione Run-As JUnit prueba.

El resultado de las pruebas se mostrar en el JUnit vista. En nuestro ejemplo, una prueba debe ser exitoso y una prueba debe mostrar un error. Este error es indicado por una barra roja.

10Ventana de pruebas La prueba est fallando porque nuestra clase multiplicador en la actualidad no funciona correctamente. Se hace una divisin en lugar de la multiplicacin. Corregir el error y vuelva a ejecutar la prueba para obtener una barra verde.

5. Opciones avanzadas JUnit

5.1. Prueba con parmetros
JUnit permite utilizar parmetros en una clase de pruebas. Esta clase puede contener un mtodo de prueba y este mtodo se ejecuta con los diferentes parmetros proporcionados.

Usted marca una clase de prueba como una prueba de parmetros con el RunWith (Parameterized.class) @ anotacin. Esta clase de ensayo debe contener un mtodo esttico anotado con @ Parmetros que genera y devuelve una coleccin de matrices. Cada elemento de esta coleccin se utiliza como los parmetros para el mtodo de ensayo. Es necesario tambin crear un constructor en la que almacena los valores de cada prueba. El nmero de elementos en cada matriz proporcionada por el mtodo anotado con @ Parmetros debe corresponder con el nmero de parmetros en el constructor de la clase. La clase se crea para cada parmetro y se transmiten los valores de la prueba a travs del constructor de la clase. El siguiente cdigo muestra un ejemplo de una prueba con parmetros. Se asume que pruebe la multiplicacin () mtodo de la MyClass clase que se utiliz en el ejemplo anterior.
paquete de.vogella.junit.first; importar estticas org.junit.Assert.assertEquals;

importacin java.util.Arrays; importacin java.util.Collection; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameters; @ RunWith (Parameterized.class) pblicos de clase MyParameterizedClassTest {

privada int multiplicador; pblica MyParameterizedClassTest ( int testParameter) { este multiplicador = testParameter.;

/ / Crea los datos de prueba @ Parmetros pblica esttica Collection datos <Object[]> () {

Object [] [] data = nuevo Object [] [] {{ 1 }, { 5 }, { 121 }}; regreso Arrays.asList (datos);

} @ Prueba pblico void testMultiplyException () {

MyClass tester = nuevo MyClass ();

assertEquals ( "Resultado" , multiplicador * multiplicador,

tester.multiply (multiplicador, multiplicador));

Si ejecuta esta clase de prueba, el mtodo de ensayo se ejecuta con cada parmetro definido. En el ejemplo anterior el mtodo de ensayo se ejecuta tres veces.

5.2. Reglas
A travs de la regla @ anotacin se pueden crear objetos que pueden ser utilizados y configurados en los mtodos de prueba. Esto aade ms flexibilidad para sus pruebas. Por ejemplo, puede especificar qu mensaje de excepcin el esperar durante la ejecucin del cdigo de prueba.
paquete de.vogella.junit.first;

importacin org.junit.Rule; importacin org.junit.Test; importacin org.junit.rules.ExpectedException;

pblico de clase RuleExceptionTesterExample {

@ Regla pblica excepcin ExpectedException ExpectedException.none = ();

@ Prueba pblico void throwsIllegalArgumentExceptionIfIconIsNull () { exception.expect (IllegalArgumentException. clase ); exception.expectMessage ( "Valor negativo no permitido" ); ClassToBeTested t = nueva ClassToBeTested (); t.methodToBeTest (- 1 ); } }

JUnit ya proporciona varias implementaciones tiles de reglas. Por ejemplo, el TemporaryFolderclase permite configurar los archivos y carpetas que se eliminan automticamente despus de una prueba. El cdigo siguiente muestra la TemporaryFolder aplicacin. un ejemplo para el uso de

paquete de.vogella.junit.first;

importar esttica org.junit.Assert.assertTrue;

importacin java.io.File; importacin java.io.IOException;

importacin org.junit.Rule;

importacin org.junit.Test; importacin org.junit.rules.TemporaryFolder;

pblico de clase RuleTester {

@ Regla pblica carpeta TemporaryFolder = nueva TemporaryFolder ();

@ Prueba pblico void testUsingTempFolder () lanza IOException { CreatedFolder File = folder.newFolder ( "NewFolder" ); Archivo createdFile = folder.newFile ( "myfilefile.txt" ); (createdFile.exists ()) assertTrue; } }

Para escribir sus propias el TestRule interfaz.

reglas

que

necesita

para

implementar

Referencia http://www.vogella.com/articles/JUnit/article.html Lars Vogel). (10/07/13,hora 6:00 pm autor,