investigación de junit- 3 unidad
TRANSCRIPT
INVESTIGACION DE JUNIT VERIFICACION Y VALIDACION
Alumno: Daniel Luna Guevara
12 DE JULIO DE 2013 INSTITUTO TECNOLOGICO SUPERIOR DE TEPEXI DE RODRIGUEZ
Contenido 1. Introducción 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. Instalación 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. Creación de pruebas JUnit ................................................................................................... 9
3.2. Correr pruebas JUnit .......................................................................................................... 10
Nota .......................................................................................................................................... 11
3.3. JUnit importaciones estáticas ............................................................................................ 11
3.4. Asistente para la creación de bancos de pruebas .............................................................. 12
3.5. Prueba de excepción .......................................................................................................... 13
4 Ejercicio: El uso de JUnit ............................................................................................................. 14
4.1. Preparación 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 parámetros ...................................................................................................... 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
4configuración de importación ......................................................................................................... 12
5banco de pruebas ............................................................................................................................ 13
6origen de prueba ............................................................................................................................. 14
7configuración de prueba ................................................................................................................. 15
8Comprobacion de prueba ............................................................................................................... 16
9Biblioteca de JUnit .......................................................................................................................... 17
10Ventana de pruebas ...................................................................................................................... 19
1. Introducción a las pruebas unitarias
1.1. Las pruebas unitarias
Una prueba unitaria es una pieza de código escrito por un desarrollador que
realiza una funcionalidad específica en el código que se prueba. El porcentaje de
código que está probado por las pruebas unitarias se suele llamar cobertura de
la prueba.
Pruebas de unidad objetivo pequeñas unidades de código, por ejemplo, un
método o una clase, (pruebas locales), mientras que las pruebas de
componentes y la integración de marketing para probar el comportamiento de un
componente o de la integración entre un conjunto de componentes o una
aplicación completa que consta de varios componentes.
Las pruebas unitarias aseguran que el código funciona como se
pretende. También son muy útiles para garantizar que el código sigue
funcionando según lo previsto en caso de tener que modificar el código para la
fijación de un error o ampliar la funcionalidad. Tener una cobertura de pruebas
de alta de su código le permite continuar con las funciones en desarrollo sin tener
que realizar un montón de pruebas manuales.
Típicamente pruebas unitarias se crean en su propio proyecto o en su propia
carpeta de origen para evitar que el código normal y el código de prueba es mixta.
1.2. Las pruebas unitarias con JUnit
JUnit prueba unitaria en la versión 4.x es un marco de pruebas que utiliza
anotaciones para identificar los métodos que especifican una
prueba. Típicamente estos métodos de ensayo están contenidos en una clase
que sólo se utiliza para la prueba. Normalmente se llama clase de prueba.
El siguiente código muestra un método de prueba JUnit que se pueden crear a
través de Archivo →Nuevo → JUnit → Caso de prueba JUnit.
@ Prueba
público 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 métodos 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 método con el @
org.junit.Test anotación y utilizar un método proporcionado por JUnit para
comprobar el resultado esperado de la ejecución de código en comparación con
el resultado real.
Puede utilizar la interfaz de usuario de Eclipse para ejecutar la prueba, a través
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 visión general de las anotaciones disponibles en
JUnit 4.x.
Tabla 1. Anotaciones
Anotación Descripción
@ Prueba
método public
void ()
La anotación @ prueba identifica que un método es un método
de prueba.
@ Antes
método public void
()
Este método se ejecuta antes de cada prueba. Este método se
puede preparar el entorno de prueba (por ejemplo, leer los datos
de entrada, se inicializa la clase).
@ Después
método public void
()
Este método se ejecuta después de cada prueba. Este método
puede limpiar el entorno de prueba (por ejemplo, eliminar los
datos temporales, restaurar los valores
predeterminados).También puede guardar la memoria mediante
la limpieza de las estructuras de memoria caros.
@ BeforeClass
método public
static void ()
Este método 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 métodos anotados con esta anotación es necesario
definir comoestáticos para trabajar con JUnit.
@ AfterClass
método public
static void ()
Este método se ejecuta una vez, después 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 métodos anotados con esta anotación es
necesario definir comoestáticos para trabajar con JUnit.
@ Ignorar No tiene en cuenta el método de ensayo. Esto es útil cuando se
ha cambiado el código subyacente y el caso de prueba todavía
no se ha adaptado. O si el tiempo de ejecución de esta prueba es
demasiado larga para ser incluida.
@ Prueba
(esperado =
Exception.class)
No logra, si el método no produce la excepción nombrada.
@ Prueba (timeout
= 100)
No logra, si el método tarda más de 100 milisegundos.
1.4. Assert
JUnit proporciona métodos estáticos en el Afirmar clase para comprobar la
existencia de ciertas condiciones. Estos métodos afirmación típicamente
comienzan con asevera y le permiten especificar el mensaje de error, el
esperado y el resultado real. Un método de afirmación compara el valor real
devuelto por una prueba para el valor esperado, y se produce
una AssertionException si la prueba de comparación falla.
La siguiente tabla ofrece una visión general de estos métodos. Los parámetros
en corchetes [] son opcionales.
Tabla 2. Métodos de ensayo
Declaración Descripción
fallar (String) Deje que el método falle. Podría ser utilizado para
comprobar que cierta parte del código no se alcanza. O
tener una prueba de no haber antes de implementar el
código de prueba.
assertTrue ([Mensaje],
condición booleana)
Comprueba que la condición booleana es verdadera.
assertsEquals ([String
mensaje], que se espera,
real)
Los exámenes 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 número de decimales que debe ser la
misma.
Nota
Usted debe proporcionar mensajes significativos en las afirmaciones de modo que
sea más fácil para los desarrolladores para identificar el problema. Esto ayuda en la
fijación de la cuestión, sobre todo si alguien se ve en el problema, que no escribió
el código de prueba o el código de prueba.
1.5. Crear un conjunto de pruebas JUnit
Si tiene varias clases de prueba se pueden combinar en un conjunto de
pruebas. Ejecución de un conjunto de pruebas ejecutará todas las clases de
prueba en esa suite.
El siguiente código 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;
assertNull ([Mensaje],
objeto)
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.
@ RunWith (Suite.class)
@ SuiteClasses ({MyClassTest.class, MySecondClassTest.class})
públicos 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. También puede ejecutar las pruebas JUnit fuera de Eclipse
estándar. Elorg.junit.runner.JUnitCore clase proporciona la runClasses
() método que le permite ejecutar una o varias clases de pruebas.
En la prueba de carpeta crear una nueva clase MyTestRunner con el siguiente
código. 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;
público de clase MyTestRunner {
públicas estáticas 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
automática en una base regular.
2. Instalación de JUnit
2.1. Con JUnit integrado en Eclipse
Eclipse le permite utilizar la versión de JUnit que está integrado en Eclipse. Si
utiliza Eclipse no se requiere ninguna configuración adicional. En este caso se
puede omitir la siguiente sección.
2.2. Descarga de la biblioteca JUnit
Si desea controlar la biblioteca JUnit utiliza explícitamente, JUnit4.x.jar descargar
desde el siguiente sitio web de JUnit. La descarga contiene el junit-4. *.
jar que es la biblioteca JUnit. Añadir esta biblioteca al proyecto Java y agregarlo
a la ruta de clases.
http: / / junit.org /
3. Apoyo Eclipse para JUnit
3.1. Creación de pruebas JUnit
Usted puede escribir las pruebas JUnit manualmente, pero Eclipse apoya la
creación 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, también puede utilizar el JUnit magos disponible
bajo Archivo → Nuevo → Otros...→ Java → JUnit.
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 métodos 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 método, este
método abreviado sólo se ejecuta el método de prueba seleccionado.
Para ver el resultado de una prueba de JUnit, Eclipse utiliza la JUnit vista que
muestra los resultados de las pruebas. También puede seleccionar la unidad de
prueba individual en esta vista, haga clic derecho y seleccionar Ejecutar para
ejecutar de nuevo.
Por defecto
esta vista muestra todas las pruebas también se pueden configurar, que muestra
sólo las pruebas que fallan.
1ventana de resultado de pruebas de JUnit
También se puede definir que la vista sólo se activa si usted tiene una prueba de
falla.
3pruebas de falla
Nota
Eclipse crea configuraciones de ejecución de las pruebas. Puede ver y modificar
estos a través de la ejecución → Ejecutar configuraciones... menú.
3.3. JUnit importaciones estáticas
JUnit usa métodos estáticos y Eclipse no siempre puede crear las
correspondientes a las diversas importaciones estáticas declaraciones
automáticamente.
Usted puede hacer los métodos de prueba JUnit disponible a través de
las Asistencias contenido .Contenido Asistencias es una funcionalidad en Eclipse
2comfiguracion de pruebas
que permite al desarrollador obtener finalización de código contextual en un
editor a petición del usuario.
Abra las Preferencias través Windows → Preferencias y
seleccione Java → Editor → Content Assist →Favoritos.
Utilice el nuevo Nuevo Tipo botón para añadir el org.junit.Assert tipo. Esto
hace que, por dentro de JUnit se inserte las paqueterias ejemplo,
la assertTrue , assertFalse y assertEquals métodos disponibles
directamente en el contenido Asistencias .
4configuración de importación
Ahora puede utilizar Content Asistencias (atajo: Ctrl + Espacio) para agregar el
método y la importación.
3.4. Asistente para la creación 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 excepción
El @ Prueba (espera = Exception.class) anotación está limitada, ya que
sólo puede examinar una excepción. Para probar las excepciones se puede
utilizar el modelo de prueba siguiente.
tratar {
mustThrowException ();
fallar ();
} coger (Exception e) {
/ / espera
/ / También puede comprobar si hay mensajes de excepción, etc
}
4 Ejercicio: El uso de JUnit
4.1. Preparación del proyecto
Crear un nuevo proyecto llamado com.vogella.junit.first.
Crear una nueva carpeta de origen de prueba. Para que este derecho del ratón
en el proyecto, seleccione Propiedades y seleccione la ruta de Java
Build. Seleccione la Fuente ficha.
6origen de prueba
Pulse el Add Folder botón, luego presione el Créate New Folder botón. Cree
la prueba de carpeta.
El resultado se representa en el siguiente sceenshot.
7configuración 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;
público de clase MyClass {
pública int multiplicar ( int x, int y) {
/ / la siguiente es sólo 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 botón y seleccionar los métodos 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 opción para agregar JUnit para su proyecto.
Crear una prueba con el siguiente código.
paquete com.vogella.junit.first;
importar estáticas org.junit.Assert.assertEquals;
importación org.junit.AfterClass;
importación org.junit.BeforeClass;
importación org.junit.Test;
público de clase MyClassTest {
@ BeforeClass
público estático vacío testSetup () {
}
@ AfterClass
público estático vacío TestCleanup () {
/ / desmontaje de los datos utilizados por las pruebas unitarias
}
@ Prueba (esperado = IllegalArgumentException.class)
público void testExceptionIsThrown () {
MyClass tester = nuevo MyClass ();
tester.multiply ( 1000 , 5 );
}
@ Prueba
público 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.
La
prueba está fallando porque nuestra clase multiplicador en la actualidad no
funciona correctamente. Se hace una división en lugar de la
multiplicación. Corregir el error y vuelva a ejecutar la prueba para obtener una
barra verde.
5. Opciones avanzadas JUnit
5.1. Prueba con parámetros
JUnit permite utilizar parámetros en una clase de pruebas. Esta clase puede
contener un método de prueba y este método se ejecuta con los diferentes
parámetros proporcionados.
10Ventana de pruebas
Usted marca una clase de prueba como una prueba de parámetros con
el RunWith (Parameterized.class) @ anotación.
Esta clase de ensayo debe contener un método estático anotado con @
Parámetros que genera y devuelve una colección de matrices. Cada elemento
de esta colección se utiliza como los parámetros para el método de ensayo.
Es necesario también crear un constructor en la que almacena los valores de
cada prueba. El número de elementos en cada matriz proporcionada por el
método anotado con @ Parámetros debe corresponder con el número de
parámetros en el constructor de la clase. La clase se crea para cada parámetro
y se transmiten los valores de la prueba a través del constructor de la clase.
El siguiente código muestra un ejemplo de una prueba con parámetros. Se
asume que pruebe la multiplicación () método de la MyClass clase que
se utilizó en el ejemplo anterior.
paquete de.vogella.junit.first;
importar estáticas org.junit.Assert.assertEquals;
importación java.util.Arrays;
importación 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)
públicos de clase MyParameterizedClassTest {
privada int multiplicador;
pública MyParameterizedClassTest ( int testParameter) {
este multiplicador = testParameter.;
}
/ / Crea los datos de prueba
@ Parámetros
pública estática Collection datos <Object[]> () {
Object [] [] data = nuevo Object [] [] {{ 1 }, { 5 }, { 121 }};
regreso Arrays.asList (datos);
}
@ Prueba
público void testMultiplyException () {
MyClass tester = nuevo MyClass ();
assertEquals ( "Resultado" , multiplicador * multiplicador,
tester.multiply (multiplicador, multiplicador));
}
Si ejecuta esta clase de prueba, el método de ensayo se ejecuta con cada
parámetro definido. En el ejemplo anterior el método de ensayo se ejecuta tres
veces.
5.2. Reglas
A través de la regla @ anotación se pueden crear objetos que pueden ser
utilizados y configurados en los métodos de prueba. Esto añade más flexibilidad
para sus pruebas. Por ejemplo, puede especificar qué mensaje de excepción el
esperar durante la ejecución del código de prueba.
paquete de.vogella.junit.first;
importación org.junit.Rule;
importación org.junit.Test;
importación org.junit.rules.ExpectedException;
público de clase RuleExceptionTesterExample {
@ Regla
pública excepción ExpectedException ExpectedException.none = ();
@ Prueba
público 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 automáticamente después de una prueba.
El código siguiente muestra un ejemplo para el uso de
la TemporaryFolder aplicación.
paquete de.vogella.junit.first;
importar estática org.junit.Assert.assertTrue;
importación java.io.File;
importación java.io.IOException;
importación org.junit.Rule;
importación org.junit.Test;
importación org.junit.rules.TemporaryFolder;
público de clase RuleTester {
@ Regla
pública carpeta TemporaryFolder = nueva TemporaryFolder ();
@ Prueba
público void testUsingTempFolder () lanza IOException {
CreatedFolder File = folder.newFolder ( "NewFolder" );
Archivo createdFile = folder.newFile ( "myfilefile.txt" );
(createdFile.exists ()) assertTrue;
}
}
Para escribir sus propias reglas que necesita para implementar
el TestRule interfaz.
Referencia
http://www.vogella.com/articles/JUnit/article.html (10/07/13,hora 6:00 pm autor,
Lars Vogel).
