El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Depuración y Pruebas

Siguiente ►
►

La depuración y las pruebas son componentes esenciales del ciclo de desarrollo de software. En este módulo, aprenderás cómo identificar y corregir errores en tu código Ada, así como a diseñar y ejecutar pruebas para asegurar que tu software funcione correctamente.

  1. Introducción a la Depuración

1.1 ¿Qué es la Depuración?

La depuración es el proceso de identificar, analizar y corregir errores en el código. Estos errores pueden ser de varios tipos, como errores de sintaxis, errores lógicos o errores en tiempo de ejecución.

1.2 Herramientas de Depuración

Para depurar programas en Ada, puedes utilizar varias herramientas. Algunas de las más comunes son:

  • GDB (GNU Debugger): Una herramienta de depuración poderosa y ampliamente utilizada.
  • GPS (GNAT Programming Studio): Un entorno de desarrollo integrado (IDE) que incluye herramientas de depuración.

1.3 Técnicas de Depuración

  • Impresión de Mensajes: Utilizar Put_Line para imprimir valores de variables y mensajes en la consola.
  • Puntos de Interrupción (Breakpoints): Detener la ejecución del programa en puntos específicos para inspeccionar el estado del programa.
  • Inspección de Variables: Verificar el valor de las variables en tiempo de ejecución.

  1. Uso de GDB para Depurar Programas en Ada

2.1 Configuración Inicial

Para utilizar GDB con Ada, primero debes compilar tu programa con la opción de depuración:

gnatmake -g my_program.adb

2.2 Comandos Básicos de GDB

  • Iniciar GDB: 
    gdb my_program
  • Establecer un Punto de Interrupción: 
    (gdb) break main
  • Ejecutar el Programa: 
    (gdb) run
  • Inspeccionar una Variable: 
    (gdb) print variable_name
  • Continuar la Ejecución: 
    (gdb) continue

2.3 Ejemplo Práctico

Supongamos que tienes el siguiente programa Ada:

with Ada.Text_IO; use Ada.Text_IO;

procedure Hello is
   X : Integer := 10;
begin
   Put_Line("Hello, World!");
   Put_Line("X = " & Integer'Image(X));
end Hello;

Para depurarlo con GDB:

  1. Compila el programa con la opción de depuración: 
    gnatmake -g hello.adb
  2. Inicia GDB: 
    gdb hello
  3. Establece un punto de interrupción en la línea donde se asigna el valor a X: 
    (gdb) break hello.adb:4
  4. Ejecuta el programa: 
    (gdb) run
  5. Inspecciona el valor de X: 
    (gdb) print X

  1. Pruebas en Ada

3.1 Tipos de Pruebas

  • Pruebas Unitarias: Verifican el funcionamiento de componentes individuales del software.
  • Pruebas de Integración: Verifican la interacción entre diferentes componentes.
  • Pruebas de Sistema: Verifican el sistema completo en un entorno que simula el entorno de producción.
  • Pruebas de Aceptación: Verifican que el sistema cumple con los requisitos especificados.

3.2 Frameworks de Pruebas

  • AUnit: Un framework de pruebas unitarias para Ada, similar a JUnit para Java.

3.3 Uso de AUnit para Pruebas Unitarias

3.3.1 Instalación de AUnit

AUnit generalmente viene incluido con GNAT. Si no lo tienes, puedes instalarlo desde el repositorio de AdaCore.

3.3.2 Estructura de una Prueba Unitaria

Una prueba unitaria en AUnit se estructura de la siguiente manera:

with AUnit.Test_Cases; use AUnit.Test_Cases;
with Ada.Text_IO; use Ada.Text_IO;

procedure Test_Hello is
   type My_Test_Case is new Test_Case with null record;

   procedure Test (Self : in out My_Test_Case) is
   begin
      -- Aquí van las aserciones
      Assert (1 + 1 = 2, "Simple arithmetic test");
   end Test;

   package My_Test_Cases is new Test_Case_Operations (My_Test_Case);

begin
   My_Test_Cases.Run ("Test_Hello");
end Test_Hello;

3.3.3 Ejemplo Práctico

Supongamos que tienes una función que suma dos números:

function Add (A, B : Integer) return Integer is
begin
   return A + B;
end Add;

Puedes escribir una prueba unitaria para esta función:

with AUnit.Test_Cases; use AUnit.Test_Cases;
with Ada.Text_IO; use Ada.Text_IO;

procedure Test_Add is
   type Add_Test_Case is new Test_Case with null record;

   procedure Test (Self : in out Add_Test_Case) is
   begin
      Assert (Add(2, 3) = 5, "2 + 3 should equal 5");
      Assert (Add(-1, 1) = 0, "-1 + 1 should equal 0");
   end Test;

   package Add_Test_Cases is new Test_Case_Operations (Add_Test_Case);

begin
   Add_Test_Cases.Run ("Test_Add");
end Test_Add;

  1. Ejercicios Prácticos

Ejercicio 1: Depuración con GDB

  1. Escribe un programa Ada que calcule el factorial de un número.
  2. Introduce un error lógico en el cálculo del factorial.
  3. Utiliza GDB para identificar y corregir el error.

Ejercicio 2: Pruebas Unitarias con AUnit

  1. Escribe una función Ada que determine si un número es primo.
  2. Escribe pruebas unitarias para esta función utilizando AUnit.
  3. Ejecuta las pruebas y corrige cualquier error que encuentres.

  1. Conclusión

En este módulo, has aprendido las técnicas y herramientas esenciales para depurar y probar programas en Ada. La depuración te ayuda a identificar y corregir errores, mientras que las pruebas aseguran que tu software funcione correctamente y cumpla con los requisitos especificados. Con estas habilidades, estarás mejor preparado para desarrollar software robusto y confiable en Ada.

Resumen:

  • La depuración es crucial para identificar y corregir errores en el código.
  • GDB es una herramienta poderosa para depurar programas en Ada.
  • Las pruebas unitarias, de integración, de sistema y de aceptación son esenciales para asegurar la calidad del software.
  • AUnit es un framework útil para escribir y ejecutar pruebas unitarias en Ada.

En el próximo módulo, exploraremos técnicas avanzadas de optimización del rendimiento y mejores prácticas de codificación para mejorar la eficiencia y la calidad de tu código Ada.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados