Verificación y Validación de Software: Tipos de Pruebas y Casos Prácticos

Verificación y Validación de Software

Mediante la realización de pruebas de software, se van a llevar a cabo las tareas de verificación y validación del mismo.

• Verificación: Proceso por el que se comprueba que el software cumple los requisitos especificados. Con la verificación se comprueba si la aplicación se está construyendo correctamente.
• Validación: Proceso que comprueba si el software hace lo que el usuario deseaba (tiene que estar verificado). La validación es el proceso de evaluación del sistema, o de uno de sus componentes, para determinar si satisface los requisitos especificados.

Caso de Prueba

Un caso de prueba es un conjunto de entradas, condiciones de ejecución y resultados esperados, desarrollado para conseguir un objetivo particular o condición de prueba.

Tipos de Pruebas de Software

Prueba de Caja Negra

Se centran en validar los requisitos funcionales sin fijarse en el funcionamiento interno del programa (necesitan saber la funcionalidad que el código ha de proporcionar).

Prueba de Caja Blanca

Se centra en validar la estructura interna del programa (necesita conocer los detalles procedimentales del código).

Enfoque de las Pruebas

Caja Blanca

Las pruebas de caja blanca deben garantizar que:

• Se ejecuten al menos una vez todos los caminos independientes de cada módulo.
• Se ejecuten todas las sentencias al menos una vez.
• Se ejecuten todas las decisiones lógicas en su parte verdadera y en su parte falsa.
• Se ejecuten todos los bucles en sus límites.
• Se utilicen todas las estructuras de datos internas para asegurar su validez.

Caja Negra

Con este tipo de pruebas se intenta encontrar errores de las siguientes categorías:

• Funcionalidades incorrectas o ausentes.
• Errores de interfaz.
• Errores en estructuras de datos o en accesos a bases de datos externas.
• Errores de rendimiento.
• Errores de inicialización y finalización.

Pruebas Funcionales

Particiones Equivalentes

La idea de este tipo de pruebas funcionales es considerar el menor número posible de casos de prueba. Para ello, cada caso de prueba tiene que abarcar el mayor número posible de entradas diferentes.

Análisis de Valores Límite

En este caso, a la hora de implementar un caso de prueba, se van a elegir como valores de entrada aquellos que se encuentran en el límite de las clases de equivalencia.

Pruebas Aleatorias

Consiste en generar entradas aleatorias para la aplicación que hay que probar. Se suelen utilizar generadores de prueba.

Procedimientos y Casos de Prueba

Un caso de prueba es un conjunto de entradas, condiciones de ejecución y resultados esperados, desarrollados para un objetivo particular.

Procedimientos para el Diseño de los Casos de Prueba

• Enfoque funcional o de caja negra: En este tipo de prueba, nos centramos en que el programa, o parte del programa que estamos probando, reciba una entrada de forma adecuada y se produzca una salida correcta.
• Enfoque estructural o caja blanca: En este tipo de pruebas, debemos centrarnos en la implementación interna del programa. Se trata de comprobar que la operación interna se ajusta a las especificaciones.
• Enfoque aleatorio: A partir de modelos obtenidos estadísticamente, se elaboran casos de prueba que prueben las entradas del programa.

Ejemplo de Código en Java: Clase CCuenta

package practicaunidad3;

public class CCuenta {

    // Propiedades de la Clase Cuenta
    private String nombre;
    private String cuenta;
    private double saldo;
    private double tipoInteres;

    /* Constructor sin argumentos */
    public CCuenta() {
    }

    public CCuenta(String nom, String cue, double sal, double tipo) {
        nombre = nom;
        cuenta = cue;
        saldo = sal;
        tipoInteres = tipo;
    }

    public void asignarNombre(String nom) {
        nombre = nom;
    }

    public String obtenerNombre() {
        return nombre;
    }

    public double estado() {
        return saldo;
    }

    public void ingresar(double cantidad) {
        if (cantidad < 0) {
            System.out.println("No se puede ingresar una cantidad negativa");
        } else {
            saldo = saldo + cantidad;
        }
    }

    public void retirar(double cantidad) {
        if (cantidad < 0) {
            System.out.println("No se puede retirar una cantidad negativa");
        } else {
            if (estado() < cantidad) {
                System.out.println("No hay suficiente saldo");
            } else {
                saldo = saldo - cantidad;
            }
        }
    }

    public String obtenerCuenta() {
        return cuenta;
    }
}

Clase Main para Pruebas

package practicaunidad3;

public class Main {

    public static void main(String[] args) throws Exception {
        CCuenta miCuenta;
        double saldoActual;

        miCuenta = new CCuenta("Juan López", "1000-2365-85-123456789", 2500, 0);
        miCuenta.retirar(2300);
        System.out.println("Ingreso en cuenta");
        miCuenta.ingresar(-1695);
        saldoActual = miCuenta.estado();
        System.out.println("El saldo actual es " + saldoActual);
    }
}

Clase de Prueba con JUnit

package practicaunidad3;

import org.junit.Test;
import static org.junit.Assert.*;

public class CCuentaTest {

    public CCuentaTest() {
    }

    @Test
    public void testIngresar() {
        System.out.println("ingresar");
        double cantidad = 2500;
        CCuenta instance = new CCuenta("", "", 10000, 0.0);
        instance.ingresar(cantidad);
        assertEquals("Error en el calculo", 12500f, instance.estado(), 8f);
    }

    @Test
    public void testRetirar() throws Exception {
        System.out.println("retirar");
        double cantidad = 1000f;
        CCuenta instance = new CCuenta("", "", 10000, 0);
        instance.retirar(cantidad);
        assertEquals(9000f, instance.estado(), 8f);
    }

    @Test
    public void testIngresarRetirar() {
        System.out.println("ingresar-retirar");
        double cantidad = 1000;
        CCuenta instance = new CCuenta();
        instance.ingresar(cantidad);
        instance.retirar(cantidad);
        assertEquals("Error en el calculo", 0f, instance.estado(), 8f);
    }
}