Ejercicios: Testing, Variables Globales y Estructura de Código

Acerca de¶

El testing y el diseño estructurado de código son disciplinas indispensables para asegurar la confiabilidad de los programas en C. En este bloque no solo vas a escribir código nuevo, sino también a leer, analizar, depurar y refactorizar programas existentes.

Aprenderás a identificar el impacto negativo de las variables globales mutables, diseñar suites de pruebas unitarias automatizadas con assert(), analizar la cobertura de ramas de ejecución y aplicar las reglas de estilo institucional (Allman, contratos y desacoplamiento de entrada/salida).

Capítulos de Apunte Correspondientes¶

Cuestiones de Estilo Aplicables¶

Variables Globales Prohibidas: Según la Regla 0x2004h, está estrictamente prohibido el uso de variables globales.
Una aserción por función de prueba: Según la Regla 0x2006h, cada función de test debe validar un escenario o comportamiento específico.
Desacoplamiento de E/S: En conformidad con la Regla 0x2002h, las funciones de cálculo deben ser puras y no contener printf ni scanf.
Cláusulas de Guarda: Según la Regla 0x2001h, se deben usar retornos anticipados para evitar anidaciones profundas.
Estilo Allman: Según la Regla 0x000Bh, las llaves deben colocarse en su propia línea alineadas con el bloque.

1. Conceptos Fundamentales de Testing y Aserciones¶

Ejercicio 4.1 - Anatomía de una aserción ⭐☆☆☆☆¶

Exercise 1

Analizá el siguiente código y respondé:

¿Qué biblioteca estándar se debe incluir para utilizar la macro assert?
¿Qué ocurre exactamente en tiempo de ejecución si la condición evaluada resulta verdadera (true)?
¿Qué ocurre si la condición resulta falsa (false)?

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <assert.h>

int cuadrado(int n)
{
    return n * n;
}

int main(void)
{
    assert(cuadrado(4) == 16);
    assert(cuadrado(-3) == 9);
    return 0;
}

[plus ultra]: Explicar qué información diagnóstica imprime assert en la consola al fallar (archivo, línea, expresión y función).
[plus ultra]: Investigar qué efecto produce la macro #define NDEBUG colocada antes de #include <assert.h>.

Solution to Exercise 1

Se incluye <assert.h>.
Si la condición es true, el programa continúa su ejecución normal sin ninguna interrupción ni mensaje.
Si la condición es false, la macro assert aborta inmediatamente el programa con SIGABRT e imprime en stderr el nombre del archivo, el número de línea, la función y el texto exacto de la condición que falló.

Ejercicio 4.2 - Patrón AAA (Arrange - Act - Assert) ⭐☆☆☆☆¶

Exercise 2

Identificá y comentá las tres etapas del patrón AAA en la siguiente función de prueba unitaria:

1
2
3
4
5
6
7
8
9
10
11
void test_calcular_promedio_tres_notas(void)
{
    int nota1 = 8;
    int nota2 = 6;
    int nota3 = 10;
    double esperado = 8.0;

    double resultado = calcular_promedio(nota1, nota2, nota3);

    assert(resultado == esperado);
}

[plus ultra]: Separar explícitamente cada bloque con comentarios `//
1. Arrange, // 2. Act, // 3. Assert`.
[plus ultra]: Escribir una segunda función de prueba test_calcular_promedio_con_decimales para notas 7, 8, 8.

Solution to Exercise 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void test_calcular_promedio_tres_notas(void)
{
    // 1. Arrange (Preparar): Definición de datos de entrada y resultado esperado
    int nota1 = 8;
    int nota2 = 6;
    int nota3 = 10;
    double esperado = 8.0;

    // 2. Act (Actuar): Invocación de la función bajo prueba
    double resultado = calcular_promedio(nota1, nota2, nota3);

    // 3. Assert (Verificar): Comprobación de que el resultado coincide con lo esperado
    assert(resultado == esperado);
}

Ejercicio 4.3 - Refactorización de pruebas acumuladas ⭐⭐☆☆☆¶

Exercise 3

El siguiente bloque de pruebas viola la Regla 0x2006h (una aserción o caso por función de prueba). Refactorizalo en funciones independientes con nombres descriptivos:

1
2
3
4
5
6
7
8
void test_todas_las_operaciones(void)
{
    assert(sumar(2, 3) == 5);
    assert(sumar(-1, 1) == 0);
    assert(restar(10, 4) == 6);
    assert(restar(3, 8) == -5);
    assert(multiplicar(3, 4) == 12);
}

[plus ultra]: Crear una función correr_todas_las_pruebas() que invoque a cada función individual de test.
[plus ultra]: Explicar por qué acumular muchos assert en una sola función dificulta saber qué otros casos fallan cuando el primero aborta.

Solution to Exercise 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <assert.h>

void test_sumar_positivos(void)
{
    assert(sumar(2, 3) == 5);
}

void test_sumar_opuestos(void)
{
    assert(sumar(-1, 1) == 0);
}

void test_restar_positivo_mayor(void)
{
    assert(restar(10, 4) == 6);
}

void test_restar_resultado_negativo(void)
{
    assert(restar(3, 8) == -5);
}

void test_multiplicar_positivos(void)
{
    assert(multiplicar(3, 4) == 12);
}

void correr_todas_las_pruebas(void)
{
    test_sumar_positivos();
    test_sumar_opuestos();
    test_restar_positivo_mayor();
    test_restar_resultado_negativo();
    test_multiplicar_positivos();
}

Ejercicio 4.4 - Efectos colaterales prohibidos dentro de assert ⭐⭐☆☆☆¶

Exercise 4

Analizá el siguiente código. ¿Qué error crítico ocurrirá si este programa se compila en modo Release con -DNDEBUG?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <assert.h>
#include <stdio.h>

int procesar_siguiente_item(int *indice)
{
    return (*indice)++;
}

int main(void)
{
    int idx = 0;
    assert(procesar_siguiente_item(&idx) == 0);
    assert(procesar_siguiente_item(&idx) == 1);
    printf("Índice final: %d\n", idx);
    return 0;
}

[plus ultra]: Formular la regla general: Nunca colocar llamadas con efectos colaterales dentro de un assert().
[plus ultra]: Reescribir el código separando la acción del assert.

Solution to Exercise 4

Cuando se define NDEBUG, el preprocesador reemplaza todas las macros assert(x) por nada (bloque vacío ((void)0)).

En consecuencia, las llamadas a procesar_siguiente_item(&idx) desaparecen por completo del código ejecutable, por lo que idx nunca se incrementa y el programa finaliza imprimiendo Índice final: 0 en lugar de 2.

Forma correcta:

int idx = 0;
int r1 = procesar_siguiente_item(&idx);
assert(r1 == 0);
int r2 = procesar_siguiente_item(&idx);
assert(r2 == 1);

Ejercicio 4.5 - Particiones de Equivalencia ⭐⭐☆☆☆¶

Solution to Exercise 5

Las particiones de equivalencia mínimas son:

Inválida negativa: edad = -5 $\rightarrow$ Esperado: -1
Menor de edad: edad = 10 $\rightarrow$ Esperado: 1
Adulto: edad = 30 $\rightarrow$ Esperado: 2
Adulto mayor: edad = 70 $\rightarrow$ Esperado: 3
Inválida excesiva: edad = 150 $\rightarrow$ Esperado: -1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <assert.h>

int clasificar_edad(int edad)
{
    if (edad < 0 || edad > 130)
    {
        return -1;
    }
    if (edad < 18)
    {
        return 1;
    }
    if (edad <= 64)
    {
        return 2;
    }
    return 3;
}

Ejercicio 4.6 - Análisis de Valores de Borde (Boundary Values) ⭐⭐☆☆☆¶

Solution to Exercise 6

Valores de borde críticos:

Límite inferior de validez: -1 (inválido) y 0 (válido, menor).
Frontera menor/adulto: 17 (menor) y 18 (adulto).
Frontera adulto/mayor: 64 (adulto) y 65 (mayor).
Límite superior de validez: 130 (mayor) y 131 (inválido).

1
2
3
4
5
6
7
8
9
10
11
void test_bordes_clasificar_edad(void)
{
    assert(clasificar_edad(-1) == -1);
    assert(clasificar_edad(0) == 1);
    assert(clasificar_edad(17) == 1);
    assert(clasificar_edad(18) == 2);
    assert(clasificar_edad(64) == 2);
    assert(clasificar_edad(65) == 3);
    assert(clasificar_edad(130) == 3);
    assert(clasificar_edad(131) == -1);
}

Ejercicio 4.7 - Comparación de punto flotante en testing ⭐⭐☆☆☆¶

Exercise 7

Analizá por qué la siguiente prueba puede fallar inesperadamente en C y escribí una función auxiliar son_cercanos(double a, double b, double epsilon) para solucionarlo:

double tercio = 1.0 / 3.0;
assert(tercio * 3.0 == 1.0); // ¡Peligro de precisión!

[plus ultra]: Implementar bool son_cercanos(double a, double b, double eps) usando fabs() de <math.h>.
[plus ultra]: Escribir un test que verifique 0.1 + 0.2 frente a 0.3 con tolerancia 10^-6.

Solution to Exercise 7

En aritmética binaria de punto flotante (IEEE 754), números como 0.1 o 1.0/3.0 no tienen representación exacta finita, lo que produce pequeñas discrepancias en los últimos decimales.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <assert.h>
#include <math.h>
#include <stdbool.h>

bool son_cercanos(double a, double b, double epsilon)
{
    return fabs(a - b) < epsilon;
}

void test_suma_decimales(void)
{
    double resultado = 0.1 + 0.2;
    double esperado = 0.3;
    assert(son_cercanos(resultado, esperado, 1e-9));
}

Ejercicio 4.8 - Aserciones defensivas vs Validación de Usuario ⭐☆☆☆☆¶

Solution to Exercise 8

Validación de Usuario (if / manejo de errores): Es obligatoria para entradas externas incontrolables (teclado, archivos, red). El programa debe manejar el error con gracia, avisar al usuario y recuperarse.
Aserciones (assert): Son herramientas de depuración para detectar bugs de lógica del programador (violaciones de contrato que “nunca deberían ocurrir” si el código estuviera bien escrito).

Ejercicio 4.9 - Función pura para cálculo de descuento ⭐⭐☆☆☆¶

Solution to Exercise 9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <assert.h>
#include <stdbool.h>

double aplicar_descuento(double precio_base, double porcentaje)
{
    if (precio_base < 0.0 || porcentaje < 0.0 || porcentaje > 100.0)
    {
        return -1.0;
    }
    return precio_base * (1.0 - (porcentaje / 100.0));
}

void test_descuento_normal(void)
{
    assert(aplicar_descuento(200.0, 25.0) == 150.0);
}

void test_descuento_cero(void)
{
    assert(aplicar_descuento(100.0, 0.0) == 100.0);
}

void test_descuento_total(void)
{
    assert(aplicar_descuento(100.0, 100.0) == 0.0);
}

void test_descuento_precio_invalido(void)
{
    assert(aplicar_descuento(-50.0, 10.0) == -1.0);
}

void test_descuento_porcentaje_invalido(void)
{
    assert(aplicar_descuento(100.0, 150.0) == -1.0);
}

Ejercicio 4.10 - Estructura de Runner de Tests sin bibliotecas ⭐⭐☆☆☆¶

Solution to Exercise 10

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <assert.h>
#include <stdio.h>

int test_cuadrado_positivo(void)
{
    assert(2 * 2 == 4);
    return 1;
}

int test_cuadrado_cero(void)
{
    assert(0 * 0 == 0);
    return 1;
}

int main(void)
{
    int pasados = 0;
    int totales = 0;

    totales++;
    pasados += test_cuadrado_positivo();

    totales++;
    pasados += test_cuadrado_cero();

    printf("Resultados: %d/%d tests aprobados.\n", pasados, totales);
    return (pasados == totales) ? 0 : 1;
}

2. Variables Globales y Efectos Colaterales¶

Ejercicio 4.11 - El misterio del test que falla según el orden ⭐⭐⭐☆☆¶

Exercise 11

Analizá el siguiente código. ¿Por qué test_dos() pasa exitosamente si se ejecuta primero, pero falla si se ejecuta después de test_uno()?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <assert.h>

int total_acumulado = 0; // Variable global

void acumular(int valor)
{
    total_acumulado += valor;
}

void test_uno(void)
{
    acumular(5);
    acumular(10);
    assert(total_acumulado == 15);
}

void test_dos(void)
{
    acumular(20);
    assert(total_acumulado == 20); // ¿Por qué falla si corre después de test_uno?
}

int main(void)
{
    test_uno();
    test_dos();
    return 0;
}

[plus ultra]: Identificar la violación de la Regla 0x2004h.
[plus ultra]: Refactorizar acumular para que reciba el total actual y retorne el nuevo total de forma pura.

Solution to Exercise 11

total_acumulado es una variable global mutable. Al terminar test_uno(), su valor queda en 15. Cuando inicia test_dos(), acumular(20) suma 20 a 15, resultando en 35 en lugar de 20, provocando la caída del assert.

Refactorización a función pura:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int acumular(int total_actual, int valor)
{
    return total_actual + valor;
}

void test_uno(void)
{
    int total = 0;
    total = acumular(total, 5);
    total = acumular(total, 10);
    assert(total == 15);
}

void test_dos(void)
{
    int total = 0;
    total = acumular(total, 20);
    assert(total == 20);
}

Ejercicio 4.12 - Sombreado de Variables (Shadowing) ⭐⭐☆☆☆¶

Exercise 12

Leé el siguiente fragmento e indicá qué imprime en consola y por qué:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>

int factor = 10; // Global

int multiplicar(int valor)
{
    int factor = 2; // Local con mismo nombre que la global
    return valor * factor;
}

int main(void)
{
    int resultado = multiplicar(5);
    printf("Resultado: %d, Factor: %d\n", resultado, factor);
    return 0;
}

[plus ultra]: Explicar qué advertencia emite el compilador al compilar con -Wshadow.
[plus ultra]: Eliminar la variable global para evitar confusiones de alcance (scope).

Solution to Exercise 12

Imprime: Resultado: 10, Factor: 10.

La variable local factor = 2 dentro de multiplicar oculta (“ensombrece”) a la variable global factor = 10 durante el alcance de la función. Al salir de la función, la global permanece inalterada con valor 10. La bandera -Wshadow alerta explícitamente sobre estas declaraciones ambiguas.

Ejercicio 4.13 - Refactorización de Cuenta Bancaria con Estado Global ⭐⭐⭐☆☆¶

Exercise 13

El siguiente código implementa operaciones bancarias usando estado global. Refactorizalo a funciones puras que reciban el saldo como parámetro y retornen el nuevo saldo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
double saldo_global = 0.0;

void depositar(double monto)
{
    if (monto > 0)
    {
        saldo_global += monto;
    }
}

bool extraer(double monto)
{
    if (monto > 0 && saldo_global >= monto)
    {
        saldo_global -= monto;
        return true;
    }
    return false;
}

[plus ultra]: Escribir tests unitarios que verifiquen depósitos y extracciones sin necesidad de reiniciar variables globales.
[plus ultra]: Manejar saldos negativos o montos inválidos retornando códigos de error.

Solution to Exercise 13

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <assert.h>
#include <stdbool.h>

double depositar(double saldo_actual, double monto)
{
    if (monto <= 0.0 || saldo_actual < 0.0)
    {
        return saldo_actual;
    }
    return saldo_actual + monto;
}

double extraer(double saldo_actual, double monto, bool *exito)
{
    if (monto <= 0.0 || monto > saldo_actual)
    {
        *exito = false;
        return saldo_actual;
    }
    *exito = true;
    return saldo_actual - monto;
}

void test_operaciones_bancarias_puras(void)
{
    double saldo = 1000.0;
    bool ok = false;

    saldo = depositar(saldo, 500.0);
    assert(saldo == 1500.0);

    saldo = extraer(saldo, 200.0, &ok);
    assert(ok == true);
    assert(saldo == 1300.0);

    saldo = extraer(saldo, 2000.0, &ok);
    assert(ok == false);
    assert(saldo == 1300.0);
}

Ejercicio 4.14 - Clasificación de funciones: Puras vs Impuras ⭐⭐☆☆☆¶

Exercise 14

Clasificá cada una de las siguientes funciones en Pura o Impura, justificando en cada caso:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int g_contador = 0;

// Función 1
int duplicar(int x) {
    return x * 2;
}

// Función 2
int obtener_siguiente(void) {
    return ++g_contador;
}

// Función 3
int sumar_con_log(int a, int b) {
    printf("Sumando %d y %d\n", a, b);
    return a + b;
}

// Función 4
bool es_positivo(int n) {
    return n > 0;
}

[plus ultra]: Explicar por qué las funciones puras son triviales de testear en comparación con las funciones impuras.
[plus ultra]: Reformular sumar_con_log para cumplir con la Regla 0x2002h.

Solution to Exercise 14

duplicar (Pura): Para el mismo valor de entrada siempre devuelve el mismo resultado y no produce ningún efecto secundario.
obtener_siguiente (Impura): Modifica y depende de la variable global g_contador. Llamadas sucesivas devuelven valores distintos.
sumar_con_log (Impura): Produce un efecto secundario en la consola mediante printf.
es_positivo (Pura): Cálculo determinístico basado únicamente en su parámetro.

Ejercicio 4.15 - Variable `static` local vs Variable Global ⭐⭐⭐☆☆¶

Exercise 15

Analizá el siguiente código. ¿Qué valores retorna en las sucesivas llamadas? ¿Por qué una variable static local también genera problemas para el testing unitario independiente?

1
2
3
4
5
6
int contador_llamadas(void)
{
    static int veces = 0;
    veces++;
    return veces;
}

[plus ultra]: Explicar la diferencia de alcance (scope) y tiempo de vida (lifetime) entre una variable global y una variable local static.
[plus ultra]: Escribir una versión reseteable o pasar el contador por parámetro.

Solution to Exercise 15

La primera llamada retorna 1, la segunda 2, la tercera 3, etc.

Aunque su alcance está restringido a la función, su tiempo de vida es durante toda la ejecución del programa. Esto retiene estado mutable entre pruebas, imposibilitando correr tests unitarios aislados y repetibles sin reiniciar el binario.

Ejercicio 4.16 - Modificación inadvertida de bandera global ⭐⭐☆☆☆¶

Exercise 16

Descubrí el bug en este programa donde dos funciones manipulan la misma variable global hay_error:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdbool.h>
#include <stdio.h>

bool hay_error = false;

void validar_rango(int x)
{
    if (x < 0 || x > 100)
    {
        hay_error = true;
    }
}

void validar_paridad(int x)
{
    if (x % 2 != 0)
    {
        hay_error = true;
    }
    else
    {
        hay_error = false; // ¡Peligro!
    }
}

[plus ultra]: ¿Qué ocurre si se llama validar_rango(-5) seguido de validar_paridad(4)?
[plus ultra]: Refactorizar ambas funciones para que retornen un bool independiente.

Solution to Exercise 16

validar_rango(-5) detecta el error y pone hay_error = true. Pero luego validar_paridad(4) como 4 es par, ejecuta la rama else y pone hay_error = false, borrando el error detectado previamente.

Refactorización:

1
2
3
4
5
6
7
8
9
bool es_rango_valido(int x)
{
    return (x >= 0 && x <= 100);
}

bool es_par(int x)
{
    return (x % 2 == 0);
}

Ejercicio 4.17 - Acoplamiento espurio entre módulos ⭐⭐⭐☆☆¶

Solution to Exercise 17

Cuando dos módulos acceden a una variable global compartida mediante extern:

No existe un contrato explícito sobre quién tiene derecho a modificarla ni cuándo.
Es imposible razonar sobre el estado de un módulo sin inspeccionar todo el código fuente del otro.
Las pruebas unitarias de un módulo requieren simular o sincronizar el estado global del otro, eliminando el aislamiento.

Ejercicio 4.18 - Conversor de Temperaturas desacoplado de estado ⭐⭐☆☆☆¶

Solution to Exercise 18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <assert.h>
#include <math.h>
#include <stdbool.h>

bool son_cercanos(double a, double b, double eps)
{
    return fabs(a - b) < eps;
}

double celsius_a_fahrenheit(double c)
{
    return (c * 9.0 / 5.0) + 32.0;
}

double fahrenheit_a_celsius(double f)
{
    return (f - 32.0) * 5.0 / 9.0;
}

double celsius_a_kelvin(double c)
{
    return c + 273.15;
}

void test_celsius_a_fahrenheit_cero(void)
{
    assert(son_cercanos(celsius_a_fahrenheit(0.0), 32.0, 1e-6));
}

void test_celsius_a_fahrenheit_ebullicion(void)
{
    assert(son_cercanos(celsius_a_fahrenheit(100.0), 212.0, 1e-6));
}

void test_celsius_a_kelvin_cero(void)
{
    assert(son_cercanos(celsius_a_kelvin(0.0), 273.15, 1e-6));
}

Ejercicio 4.19 - Simulación de cronómetro sin estado global ⭐⭐⭐☆☆¶

Solution to Exercise 19

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <assert.h>

int tiempo_avanzar(int tiempo_actual, int segundos_delta)
{
    if (segundos_delta < 0)
    {
        return tiempo_actual;
    }
    return tiempo_actual + segundos_delta;
}

int tiempo_reiniciar(void)
{
    return 0;
}

int tiempo_obtener_minutos(int tiempo_total)
{
    return tiempo_total / 60;
}

int tiempo_obtener_segundos(int tiempo_total)
{
    return tiempo_total % 60;
}

void test_cronometro_avance(void)
{
    int t = tiempo_reiniciar();
    t = tiempo_avanzar(t, 45);
    t = tiempo_avanzar(t, 30);
    assert(t == 75);
    assert(tiempo_obtener_minutos(t) == 1);
    assert(tiempo_obtener_segundos(t) == 15);
}

Ejercicio 4.20 - Detección de fugas de estado entre funciones ⭐⭐☆☆☆¶

Exercise 20

Dado el siguiente código con una variable global oculta:

1
2
3
4
5
6
7
int ultimo_resultado = 0;

int multiplicar_y_guardar(int a, int b)
{
    ultimo_resultado = a * b;
    return ultimo_resultado;
}

Explicá qué problema de diseño introduce ultimo_resultado si dos partes del programa invocan la función en momentos intercalados.

[plus ultra]: Refactorizar eliminando la variable global.
[plus ultra]: Explicar el concepto de función reentrante (reentrant function).

Solution to Exercise 20

Si una parte del programa llama a multiplicar_y_guardar(3, 4), el resultado esperado es 12. Pero si otra parte del programa llama a multiplicar_y_guardar(10, 2) antes de que la primera lea ultimo_resultado, el valor se sobrescribe a 20, corrompiendo los datos del primer llamador.

Ejercicio 4.21 - Calculadora con memoria local vs global ⭐⭐⭐☆☆¶

Solution to Exercise 21

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <assert.h>
#include <stdbool.h>

double calc_sumar(double acumulador, double valor)
{
    return acumulador + valor;
}

double calc_restar(double acumulador, double valor)
{
    return acumulador - valor;
}

double calc_multiplicar(double acumulador, double valor)
{
    return acumulador * valor;
}

double calc_dividir(double acumulador, double valor, bool *ok)
{
    if (valor == 0.0)
    {
        *ok = false;
        return acumulador;
    }
    *ok = true;
    return acumulador / valor;
}

void test_secuencia_calculadora(void)
{
    double acc = 0.0;
    bool ok = false;

    acc = calc_sumar(acc, 50.0);
    acc = calc_multiplicar(acc, 2.0);
    acc = calc_restar(acc, 20.0);
    acc = calc_dividir(acc, 4.0, &ok);

    assert(ok == true);
    assert(acc == 20.0);
}

Ejercicio 4.22 - Máquina de Estados Finita Pura ⭐⭐⭐☆☆¶

Solution to Exercise 22

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <assert.h>
#include <ctype.h>

int transicion_estado(int estado_actual, char entrada)
{
    if (estado_actual == 0)
    {
        return isalpha(entrada) ? 1 : -1;
    }
    if (estado_actual == 1)
    {
        return isdigit(entrada) ? 2 : 1;
    }
    if (estado_actual == 2)
    {
        return 2;
    }
    return -1;
}

void test_fsm_camino_exitoso(void)
{
    int estado = 0;
    estado = transicion_estado(estado, a);
    assert(estado == 1);
    estado = transicion_estado(estado, b);
    assert(estado == 1);
    estado = transicion_estado(estado, '9\);
    assert(estado == 2);
}

3. Lectura, Análisis y Flujo de Control¶

Ejercicio 4.23 - Cobertura de Ramas (Branch Coverage) ⭐⭐☆☆☆¶

Exercise 23

Dada la siguiente función de aprobación:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int evaluar_alumno(int parcial1, int parcial2, int asistencia_pct)
{
    if (asistencia_pct < 75)
    {
        return 0; // Libre por asistencia
    }
    if (parcial1 >= 60 && parcial2 >= 60)
    {
        return 2; // Promocionado
    }
    if (parcial1 >= 40 || parcial2 >= 40)
    {
        return 1; // Regular
    }
    return 0; // Reprobado
}

¿Cuántas pruebas unitarias como mínimo se requieren para lograr el 100% de cobertura de ramas (Branch Coverage)? Escribí los casos de prueba con sus valores de entrada y salida esperada.

[plus ultra]: Identificar todas las ramas de decisión booleanas (&&, ||).
[plus ultra]: Escribir una suite con assert() que ejecute exactamente todos los caminos.

Solution to Exercise 4

Se requieren al menos 5 casos de prueba para cubrir todas las ramas:

asistencia_pct < 75 (ej. 50, 80, 80) $\rightarrow$ 0
parcial1 >= 60 && parcial2 >= 60 (ej. 80, 70, 80) $\rightarrow$ 2
parcial1 >= 60 pero parcial2 < 60 y >= 40 (ej. 70, 50, 80) $\rightarrow$ 1
parcial1 < 60 pero parcial2 >= 40 (ej. 30, 50, 80) $\rightarrow$ 1
Ambos parciales < 40 con asistencia (ej. 30, 20, 80) $\rightarrow$ 0

Ejercicio 4.24 - Detección de Código Muerto (Dead Code) ⭐⭐☆☆☆¶

Exercise 24

Analizá la siguiente función e identificá qué bloque de código es código muerto (nunca podrá ejecutarse bajo ninguna circunstancia):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int calcular_tarifa(int edad)
{
    if (edad < 0)
    {
        return -1;
    }
    if (edad >= 0 && edad <= 12)
    {
        return 50;
    }
    if (edad > 12)
    {
        return 100;
    }
    // ¿Puede ejecutarse esta línea alguna vez?
    return 0;
}

[plus ultra]: Simplificar la estructura lógica eliminando redundancias.
[plus ultra]: Escribir pruebas unitarias que demuestren que la versión simplificada produce los mismos resultados.

Solution to Exercise 24

La línea return 0; al final es código muerto porque los tres bloques if anteriores cubren exhaustivamente todos los números enteros posibles ( $ext{edad} < 0$ , $0 \le ext{edad} \le 12$ , $ext{edad} > 12$ ).

Versión refactorizada y limpia:

1
2
3
4
5
6
7
8
9
10
11
12
int calcular_tarifa(int edad)
{
    if (edad < 0)
    {
        return -1;
    }
    if (edad <= 12)
    {
        return 50;
    }
    return 100;
}

Ejercicio 4.25 - Cortocircuito Lógico y Orden de Evaluación ⭐⭐☆☆☆¶

Exercise 25

Analizá el comportamiento de las operaciones con cortocircuito lógico (&& y ||). ¿Qué imprime el siguiente código y por qué la función incrementar no siempre es invocada?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>

int llamadas = 0;

int incrementar(void)
{
    llamadas++;
    return 1;
}

int main(void)
{
    int a = 0;
    if (a != 0 && incrementar())
    {
        printf("Rama 1\n");
    }
    printf("Llamadas tras primer if: %d\n", llamadas);

    int b = 1;
    if (b == 1 || incrementar())
    {
        printf("Rama 2\n");
    }
    printf("Llamadas tras segundo if: %d\n", llamadas);
    return 0;
}

[plus ultra]: Explicar por qué es peligroso colocar funciones con efectos secundarios dentro de condiciones compuestas.
[plus ultra]: Escribir aserciones que verifiquen el valor final de llamadas.

Solution to Exercise 25

Imprime:

Llamadas tras primer if: 0
Rama 2
Llamadas tras segundo if: 0

En a != 0 && incrementar(), como a != 0 es falso, el operador && evalúa a falso sin evaluar la segunda parte.
En b == 1 || incrementar(), como b == 1 es verdadero, el operador || evalúa a verdadero sin evaluar la segunda parte. En ningún caso se ejecuta incrementar().

Ejercicio 4.26 - Cláusulas de Guarda vs Código en Flecha ⭐⭐☆☆☆¶

Exercise 26

Refactorizá la siguiente función anidada aplicando cláusulas de guarda según la Regla 0x2001h:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int procesar_pedido(int cantidad, double precio_unitario, bool cliente_vip)
{
    int resultado = -1;
    if (cantidad > 0)
    {
        if (precio_unitario > 0.0)
        {
            if (cliente_vip)
            {
                resultado = (int)(cantidad * precio_unitario * 0.85);
            }
            else
            {
                resultado = (int)(cantidad * precio_unitario);
            }
        }
    }
    return resultado;
}

[plus ultra]: Comprobar que la función reduzca la sangría horizontal manteniendo exactamente el mismo comportamiento.
[plus ultra]: Escribir pruebas unitarias con assert() para cada salida prematura.

Solution to Exercise 26

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <assert.h>
#include <stdbool.h>

int procesar_pedido(int cantidad, double precio_unitario, bool cliente_vip)
{
    if (cantidad <= 0 || precio_unitario <= 0.0)
    {
        return -1;
    }
    if (cliente_vip)
    {
        return (int)(cantidad * precio_unitario * 0.85);
    }
    return (int)(cantidad * precio_unitario);
}

void test_pedido_invalido_cantidad(void)
{
    assert(procesar_pedido(0, 10.0, false) == -1);
}

void test_pedido_invalido_precio(void)
{
    assert(procesar_pedido(5, -2.0, false) == -1);
}

void test_pedido_regular(void)
{
    assert(procesar_pedido(10, 10.0, false) == 100);
}

void test_pedido_vip(void)
{
    assert(procesar_pedido(10, 10.0, true) == 85);
}

Ejercicio 4.27 - Detección de Fallthrough accidental en switch ⭐⭐☆☆☆¶

Exercise 27

Descubrí el bug en la siguiente función de cálculo de días de un mes y corregilo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int dias_del_mes(int mes)
{
    int dias = 0;
    switch (mes)
    {
        case 2:
            dias = 28;
        case 4:
        case 6:
        case 9:
        case 11:
            dias = 30;
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            dias = 31;
        default:
            dias = -1;
    }
    return dias;
}

[plus ultra]: Explicar qué valor retornaría dias_del_mes(2) en el código original con bug.
[plus ultra]: Escribir una prueba unitaria que detecte el error.

Solution to Exercise 27

En el código original falta la instrucción break; al final de cada grupo de casos. Por lo tanto, para cualquier mes, la ejecución continúa cayendo (fallthrough) hasta el bloque default, retornando siempre -1.

Solución:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int dias_del_mes(int mes)
{
    switch (mes)
    {
        case 2:
            return 28;
        case 4:
        case 6:
        case 9:
        case 11:
            return 30;
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            return 31;
        default:
            return -1;
    }
}

Ejercicio 4.28 - Detección de Error Off-by-one en Lazos ⭐⭐☆☆☆¶

Exercise 28

El siguiente algoritmo debe sumar los primeros $N$ números naturales ( $1 + 2 + \dots + N$ ). Descubrí el error en la condición del lazo:

1
2
3
4
5
6
7
8
9
10
11
12
13
int suma_primeros_n(int n)
{
    if (n <= 0)
    {
        return 0;
    }
    int total = 0;
    for (int i = 1; i < n; i++) // ¿Qué error hay acá?
    {
        total += i;
    }
    return total;
}

[plus ultra]: Escribir un test unitario para suma_primeros_n(4) cuyo resultado esperado es 10.
[plus ultra]: Corregir el lazo para que incluya al número $N$ usando <=.

Solution to Exercise 28

El lazo utiliza i < n, lo que omite sumar el último valor $N$ . Para $N=4$ , suma $1+2+3 = 6$ en lugar de $1+2+3+4 = 10$ .

Corrección:

1
2
3
4
5
6
7
8
9
10
11
12
13
int suma_primeros_n(int n)
{
    if (n <= 0)
    {
        return 0;
    }
    int total = 0;
    for (int i = 1; i <= n; i++)
    {
        total += i;
    }
    return total;
}

Ejercicio 4.29 - Desacople de Entrada/Salida para Testabilidad ⭐⭐⭐☆☆¶

Exercise 29

La siguiente función no se puede someter a pruebas unitarias automatizadas porque lee con scanf e imprime con printf. Refactorizala en dos funciones: una de cálculo puro y otra para la interacción con el usuario:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void calcular_imc_interactivo(void)
{
    float peso = 0.0f;
    float altura = 0.0f;
    printf("Ingrese peso en kg: ");
    scanf("%f", &peso);
    printf("Ingrese altura en m: ");
    scanf("%f", &altura);

    float imc = peso / (altura * altura);
    if (imc < 18.5f)
    {
        printf("Bajo peso\n");
    }
    else if (imc < 25.0f)
    {
        printf("Normal\n");
    }
    else
    {
        printf("Sobrepeso\n");
    }
}

[plus ultra]: Crear la función pura float calcular_imc(float peso, float altura) y int clasificar_imc(float imc).
[plus ultra]: Escribir la suite completa de pruebas unitarias automatizadas para ambas funciones puras.

Solution to Exercise 29

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <assert.h>
#include <stdbool.h>

float calcular_imc(float peso, float altura)
{
    if (peso <= 0.0f || altura <= 0.0f)
    {
        return -1.0f;
    }
    return peso / (altura * altura);
}

int clasificar_imc(float imc)
{
    if (imc <= 0.0f)
    {
        return -1; // Inválido
    }
    if (imc < 18.5f)
    {
        return 1; // Bajo peso
    }
    if (imc < 25.0f)
    {
        return 2; // Normal
    }
    return 3; // Sobrepeso
}

void test_calculo_y_clasificacion_imc(void)
{
    float imc = calcular_imc(70.0f, 1.75f);
    assert(imc > 22.8f && imc < 22.9f);
    assert(clasificar_imc(imc) == 2);
    assert(clasificar_imc(16.0f) == 1);
    assert(clasificar_imc(28.0f) == 3);
    assert(clasificar_imc(-1.0f) == -1);
}

Ejercicio 4.30 - Tabla de Traza de Ejecución (Trace Table) ⭐⭐☆☆☆¶

Exercise 30

Construí una tabla de traza paso a paso para la llamada mcd(18, 12) mostrando los valores de las variables en cada iteración del lazo:

1
2
3
4
5
6
7
8
9
10
int mcd(int a, int b)
{
    while (b != 0)
    {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

[plus ultra]: Escribir una suite de tests unitarios verificando mcd(18, 12) == 6, mcd(7, 5) == 1 y mcd(20, 0) == 20.
[plus ultra]: Demostrar la invariante del algoritmo: $\text{mcd}(a, b) = \text{mcd}(b, a \pmod b)$ .

Solution to Exercise 30

Iteración	`a` (inicio)	`b` (inicio)	`temp` (`b`)	`a % b`	`b` (nuevo)	`a` (nuevo)	Condición (`b != 0`)
Inicio	18	12	-	-	-	-	`true`
1	18	12	12	6	6	12	`true`
2	12	6	6	0	0	6	`false`
Fin	6	0	-	-	-	-	Retorna `6`

Ejercicio 4.31 - Principio de Responsabilidad Única (SRP) ⭐⭐☆☆☆¶

Exercise 31

La siguiente función realiza tres tareas simultáneas: calcular la suma de un arreglo, buscar el máximo y contar negativos. Refactorizala en tres funciones atómicas según la Regla 0x2005h:

void procesar_todo(const int arr[], int n, int *suma, int *maximo, int *negativos);

[plus ultra]: Escribir pruebas unitarias independientes para cada función resultante.
[plus ultra]: Explicar por qué es más fácil reutilizar y mantener funciones con una sola responsabilidad.

Solution to Exercise 31

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <assert.h>

int calcular_suma(const int arr[], int n)
{
    int total = 0;
    for (int i = 0; i < n; i++)
    {
        total += arr[i];
    }
    return total;
}

int encontrar_maximo(const int arr[], int n)
{
    if (n <= 0)
    {
        return 0;
    }
    int max = arr[0];
    for (int i = 1; i < n; i++)
    {
        if (arr[i] > max)
        {
            max = arr[i];
        }
    }
    return max;
}

int contar_negativos(const int arr[], int n)
{
    int cont = 0;
    for (int i = 0; i < n; i++)
    {
        if (arr[i] < 0)
        {
            cont++;
        }
    }
    return cont;
}

void test_funciones_atomicas(void)
{
    int datos[] = {3, -1, 8, -5, 2};
    assert(calcular_suma(datos, 5) == 7);
    assert(encontrar_maximo(datos, 5) == 8);
    assert(contar_negativos(datos, 5) == 2);
}

Ejercicio 4.32 - Testeo de Año Bisiesto Exhaustivo ⭐⭐☆☆☆¶

Solution to Exercise 32

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <assert.h>
#include <stdbool.h>

bool es_bisiesto(int anio)
{
    if (anio <= 0)
    {
        return false;
    }
    return ((anio % 4 == 0 && anio % 100 != 0) || (anio % 400 == 0));
}

void test_bisiesto_multiplo_4(void)
{
    assert(es_bisiesto(2024) == true);
}

void test_no_bisiesto_comun(void)
{
    assert(es_bisiesto(2023) == false);
}

void test_no_bisiesto_fin_de_siglo(void)
{
    assert(es_bisiesto(1900) == false);
}

void test_bisiesto_cuatrisecular(void)
{
    assert(es_bisiesto(2000) == true);
}

void test_bisiesto_invalido(void)
{
    assert(es_bisiesto(-400) == false);
}

Ejercicio 4.33 - Detección de mutación en arreglos de solo lectura ⭐⭐☆☆☆¶

Exercise 33

Analizá el siguiente código. ¿Por qué agregar el calificador const en la firma de buscar_elemento previene bugs accidentales de modificación en las pruebas?

// Incorrecto:
int buscar_elemento(int arr[], int n, int objetivo);

// Correcto (seguro):
int buscar_elemento(const int arr[], int n, int objetivo);

[plus ultra]: Explicar qué error genera el compilador si una función intenta modificar un elemento de un arreglo declarado const.
[plus ultra]: Escribir un test que valide que el arreglo original no sufrió modificaciones tras la búsqueda.

Solution to Exercise 33

El calificador const garantiza contractualmente que la función es de solo lectura. Si por error un programador escribe arr[i] = 0; en lugar de if (arr[i] == 0), el compilador rechaza la compilación con un error inmediato (assignment of read-only location), evitando corromper los datos del llamador.

Ejercicio 4.34 - Búsqueda de errores lógicos con aserciones de invariante ⭐⭐⭐☆☆¶

Exercise 34

En el siguiente algoritmo para calcular la división entera por restas sucesivas, agregá una aserción al final que verifique la invariante matemática fundamental: $\text{dividendo} = \text{divisor} \times \text{cociente} + \text{resto}$ .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void division_lenta(int dividendo, int divisor, int *cociente, int *resto)
{
    assert(divisor > 0);
    assert(dividendo >= 0);

    int c = 0;
    int r = dividendo;
    while (r >= divisor)
    {
        r -= divisor;
        c++;
    }
    *cociente = c;
    *resto = r;

    // Aserción de invariante:
    assert(dividendo == (divisor * (*cociente)) + (*resto));
}

[plus ultra]: Diseñar tests unitarios para $10 \div 3$ , $20 \div 5$ y $3 \div 7$ .
[plus ultra]: Verificar que el resto siempre cumpla $0 \le r < \text{divisor}$ .

Solution to Exercise 34

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <assert.h>

void test_division_con_invariante(void)
{
    int c = 0;
    int r = 0;

    division_lenta(10, 3, &c, &r);
    assert(c == 3 && r == 1);

    division_lenta(20, 5, &c, &r);
    assert(c == 4 && r == 0);

    division_lenta(3, 7, &c, &r);
    assert(c == 0 && r == 3);
}

4. Estilo, Estructura y Contratos¶

Ejercicio 4.35 - Verificación de Estilo Allman ⭐☆☆☆☆¶

Exercise 35

Identificá las violaciones de la Regla 0x000Bh (Estilo Allman) en el siguiente código y reescribilo con las llaves correctamente alineadas en su propia línea:

1
2
3
4
5
6
7
8
// Código mal formateado:
int valor_absoluto(int n) {
    if (n < 0) {
        return -n;
    } else {
        return n;
    }
}

[plus ultra]: Formatear con 4 espacios de indentación.
[plus ultra]: Escribir una prueba unitaria para valor_absoluto(-12) y valor_absoluto(0).

Solution to Exercise 35

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <assert.h>

int valor_absoluto(int n)
{
    if (n < 0)
    {
        return -n;
    }
    else
    {
        return n;
    }
}

void test_valor_absoluto(void)
{
    assert(valor_absoluto(-12) == 12);
    assert(valor_absoluto(0) == 0);
    assert(valor_absoluto(15) == 15);
}

Ejercicio 4.36 - Eliminación de Números Mágicos ⭐⭐☆☆☆¶

Exercise 36

Refactorizá la siguiente función reemplazando todos los números mágicos por constantes simbólicas (#define o const) descriptivas según la Regla 0x0004h:

1
2
3
4
5
6
7
8
9
10
11
12
double calcular_costo_envio(double peso)
{
    if (peso <= 5.0)
    {
        return 500.0;
    }
    if (peso <= 20.0)
    {
        return 500.0 + (peso - 5.0) * 80.0;
    }
    return 1700.0 + (peso - 20.0) * 120.0;
}

[plus ultra]: Escribir tests unitarios para los puntos de quiebre (5.0 kg y 20.0 kg).
[plus ultra]: Explicar por qué los números mágicos dificultan el mantenimiento del código.

Solution to Exercise 36

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <assert.h>

#define PESO_LIMITE_LIVIANO 5.0
#define PESO_LIMITE_MEDIO 20.0
#define TARIFA_BASE_LIVIANO 500.0
#define TARIFA_BASE_MEDIO 1700.0
#define COSTO_KG_MEDIO 80.0
#define COSTO_KG_PESADO 120.0

double calcular_costo_envio(double peso)
{
    if (peso <= 0.0)
    {
        return -1.0;
    }
    if (peso <= PESO_LIMITE_LIVIANO)
    {
        return TARIFA_BASE_LIVIANO;
    }
    if (peso <= PESO_LIMITE_MEDIO)
    {
        return TARIFA_BASE_LIVIANO + (peso - PESO_LIMITE_LIVIANO) * COSTO_KG_MEDIO;
    }
    return TARIFA_BASE_MEDIO + (peso - PESO_LIMITE_MEDIO) * COSTO_KG_PESADO;
}

void test_costo_envio_limites(void)
{
    assert(calcular_costo_envio(5.0) == 500.0);
    assert(calcular_costo_envio(10.0) == 900.0);
    assert(calcular_costo_envio(20.0) == 1700.0);
}

Ejercicio 4.37 - Documentación de Contratos con Doxygen ⭐⭐☆☆☆¶

Exercise 37

Escribí el bloque de documentación estructurada con etiquetas Doxygen (@brief, @param, @pre, @returns, @post) para la función calcular_potencia_entera:

1
2
3
4
5
6
7
8
9
10
/**
 * @brief ...
 * @param base ...
 * @param exponente ...
 * @param ok ...
 * @pre ...
 * @returns ...
 * @post ...
 */
int calcular_potencia_entera(int base, int exponente, bool *ok);

[plus ultra]: Implementar la función validando que exponente >= 0.
[plus ultra]: Escribir tests unitarios que verifiquen las postcondiciones.

Solution to Exercise 37

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <assert.h>
#include <stdbool.h>

/**
 * @brief Calcula la potencia entera de una base elevada a un exponente no negativo.
 *
 * @param base Base entera.
 * @param exponente Exponente entero.
 * @param ok Puntero a booleano de estado de éxito.
 *
 * @pre `exponente >= 0`
 * @pre `ok != NULL`
 *
 * @returns El resultado de base^exponente si ok es true, o 0 en caso de error.
 *
 * @post Si exponente == 0, el retorno es 1 y *ok == true.
 */
int calcular_potencia_entera(int base, int exponente, bool *ok)
{
    if (ok == NULL || exponente < 0)
    {
        if (ok != NULL)
        {
            *ok = false;
        }
        return 0;
    }
    *ok = true;
    int resultado = 1;
    for (int i = 0; i < exponente; i++)
    {
        resultado *= base;
    }
    return resultado;
}

void test_potencia_contrato(void)
{
    bool ok = false;
    assert(calcular_potencia_entera(2, 3, &ok) == 8 && ok);
    assert(calcular_potencia_entera(5, 0, &ok) == 1 && ok);
    calcular_potencia_entera(2, -1, &ok);
    assert(ok == false);
}

Ejercicio 4.38 - Inicialización obligatoria de variables ⭐☆☆☆☆¶

Exercise 38

Analizá qué comportamiento indefinido (Undefined Behavior) ocurre en la siguiente función y corregilo aplicando la Regla 0x0003h:

1
2
3
4
5
6
7
8
9
10
11
12
int contar_multiplos(const int arr[], int n, int divisor)
{
    int contador; // ¡Variable no inicializada!
    for (int i = 0; i < n; i++)
    {
        if (arr[i] % divisor == 0)
        {
            contador++;
        }
    }
    return contador;
}

[plus ultra]: Explicar por qué las variables locales contienen valores basura si no se inicializan explícitamente.
[plus ultra]: Escribir una prueba unitaria para verificar contar_multiplos.

Solution to Exercise 38

Al no inicializarse, contador contiene un valor residual indeterminado proveniente de la memoria de la pila. El incremento contador++ genera comportamiento indefinido y resultados erróneos impredecibles.

Corrección:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int contar_multiplos(const int arr[], int n, int divisor)
{
    if (divisor == 0)
    {
        return -1;
    }
    int contador = 0;
    for (int i = 0; i < n; i++)
    {
        if (arr[i] % divisor == 0)
        {
            contador++;
        }
    }
    return contador;
}

Ejercicio 4.39 - Organización de Archivo `.c` Estándar ⭐☆☆☆☆¶

Solution to Exercise 39

El orden estándar según la Regla 0x5005h es:

Inclusiones de bibliotecas estándar (#include <stdio.h>).
Inclusiones de cabeceras del proyecto (#include "modulo.h").
Definición de macros y constantes (#define).
Prototipos de funciones privadas (static int auxiliar(void);).
Función main (si es el archivo principal) o funciones públicas.
Implementación de funciones privadas (static).

Ejercicio 4.40 - Red de Seguridad: Default en Switch ⭐⭐☆☆☆¶

Solution to Exercise 40

El bloque default actúa como una red de seguridad defensiva ante datos imprevistos, corrupción de memoria o adición futura de nuevos valores en el dominio que no fueron contemplados.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <assert.h>

int obtener_dias_trimestre(int trimestre)
{
    switch (trimestre)
    {
        case 1:
            return 90;
        case 2:
            return 91;
        case 3:
            return 92;
        case 4:
            return 92;
        default:
            return -1; // Captura de valores inválidos
    }
}

void test_trimestres(void)
{
    assert(obtener_dias_trimestre(1) == 90);
    assert(obtener_dias_trimestre(5) == -1);
    assert(obtener_dias_trimestre(-1) == -1);
}

Ejercicio 4.41 - Nombres de Variables Autoexplicativos ⭐☆☆☆☆¶

Exercise 41

Refactorizá el siguiente código reemplazando los nombres de variables crípticos por identificadores claros en snake_case según la Regla 0x0007h:

1
2
3
4
5
6
7
// Código críptico:
double c(double p, double d, double t)
{
    double r = p - (p * (d / 100.0));
    double f = r + (r * (t / 100.0));
    return f;
}

[plus ultra]: Escribir un test unitario con assert para verificar el cálculo del precio final con descuento e impuesto.

Solution to Exercise 41

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <assert.h>

double calcular_precio_final(double precio_base, double porcentaje_descuento, double porcentaje_impuesto)
{
    double precio_con_descuento = precio_base - (precio_base * (porcentaje_descuento / 100.0));
    double precio_final = precio_con_descuento + (precio_con_descuento * (porcentaje_impuesto / 100.0));
    return precio_final;
}

void test_precio_final(void)
{
    assert(calcular_precio_final(100.0, 10.0, 21.0) == 108.9);
}

Ejercicio 4.42 - Prohibición de Reutilización de Variables ⭐⭐☆☆☆¶

Exercise 42

Analizá qué problema de legibilidad y mantenimiento tiene el siguiente código donde la variable aux se usa para tres propósitos completamente distintos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int calcular_estadisticas_ventas(int ventas[], int n)
{
    int aux = 0;
    // Uso 1: acumular suma
    for (int i = 0; i < n; i++)
    {
        aux += ventas[i];
    }
    int promedio = aux / n;

    // Uso 2: buscar maximo
    aux = ventas[0];
    for (int i = 1; i < n; i++)
    {
        if (ventas[i] > aux)
        {
            aux = ventas[i];
        }
    }
    return aux;
}

[plus ultra]: Refactorizar declarando variables con nombres de propósito único (suma, maximo).
[plus ultra]: Modularizar en funciones independientes.

Solution to Exercise 42

Reutilizar la misma variable para propósitos disímiles dificulta la lectura, impide agregar aserciones claras sobre estados intermedios y propaga errores si un bloque asume que la variable conserva su valor anterior.

Ejercicio 4.43 - Flags de Compilación Obligatorios ⭐☆☆☆☆¶

Solution to Exercise 43

-Wall: Habilita todas las advertencias comunes sobre construcciones dudosas (variables no usadas, conversiones implícitas riesgosas).
-Wextra: Habilita advertencias adicionales más rigurosas (comparaciones con signo/sin signo, parámetros no utilizados).
-Werror: Trata todas las advertencias como errores de compilación, impidiendo generar el binario si existen problemas.
-Wpedantic: Exige estricto apego al estándar ISO de C, rechazando extensiones propietarias del compilador.

Ejercicio 4.44 - Funciones Auxiliares Privadas `static` ⭐⭐☆☆☆¶

Solution to Exercise 44

El calificador static en una función a nivel de archivo restringe su visibilidad exclusivamente a la unidad de traducción actual (internal linkage). Esto encapsula los detalles de implementación internos y previene errores de símbolos duplicados en tiempo de enlace (linker collision).

5. Suites de Pruebas Integradoras y Diagnóstico¶

Ejercicio 4.45 - Suite de Pruebas: Validador de Fecha ⭐⭐⭐☆☆¶

Solution to Exercise 45

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <assert.h>
#include <stdbool.h>

bool es_bisiesto_aux(int anio)
{
    return (anio % 4 == 0 && anio % 100 != 0) || (anio % 400 == 0);
}

bool es_fecha_valida(int dia, int mes, int anio)
{
    if (anio <= 0 || mes < 1 || mes > 12 || dia < 1)
    {
        return false;
    }
    int dias_max = 31;
    if (mes == 4 || mes == 6 || mes == 9 || mes == 11)
    {
        dias_max = 30;
    }
    else if (mes == 2)
    {
        dias_max = es_bisiesto_aux(anio) ? 29 : 28;
    }
    return dia <= dias_max;
}

void test_fecha_31_dias(void)
{
    assert(es_fecha_valida(31, 1, 2024) == true);
    assert(es_fecha_valida(32, 1, 2024) == false);
}

void test_fecha_30_dias(void)
{
    assert(es_fecha_valida(30, 4, 2024) == true);
    assert(es_fecha_valida(31, 4, 2024) == false);
}

void test_febrero_bisiesto(void)
{
    assert(es_fecha_valida(29, 2, 2024) == true);
    assert(es_fecha_valida(29, 2, 2023) == false);
}

void test_fecha_mes_invalido(void)
{
    assert(es_fecha_valida(15, 13, 2024) == false);
    assert(es_fecha_valida(15, 0, 2024) == false);
}

void correr_pruebas_fechas(void)
{
    test_fecha_31_dias();
    test_fecha_30_dias();
    test_febrero_bisiesto();
    test_fecha_mes_invalido();
}

Ejercicio 4.46 - Suite de Pruebas: Tarifa de Estacionamiento ⭐⭐⭐☆☆¶

Solution to Exercise 46

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <assert.h>
#include <math.h>
#include <stdbool.h>

double calcular_estacionamiento(int minutos)
{
    if (minutos <= 0)
    {
        return 0.0;
    }
    int horas = (minutos + 59) / 60; // Redondeo hacia arriba a la hora siguiente
    double total = 200.0;
    if (horas > 1)
    {
        total += (horas - 1) * 150.0;
    }
    if (horas > 6)
    {
        total *= 0.90;
    }
    if (total > 1200.0)
    {
        total = 1200.0;
    }
    return total;
}

void test_estacionamiento_primera_hora(void)
{
    assert(calcular_estacionamiento(30) == 200.0);
    assert(calcular_estacionamiento(60) == 200.0);
}

void test_estacionamiento_horas_adicionales(void)
{
    assert(calcular_estacionamiento(61) == 350.0); // 2 horas
    assert(calcular_estacionamiento(180) == 500.0); // 3 horas
}

void test_estacionamiento_descuento_larga_estadia(void)
{
    // 7 horas = 200 + 6*150 = 1100. Con 10% desc = 990.
    assert(calcular_estacionamiento(420) == 990.0);
}

void test_estacionamiento_tope_maximo(void)
{
    assert(calcular_estacionamiento(1440) == 1200.0);
}

Ejercicio 4.47 - Diagnóstico de Aserción Fallida ⭐⭐☆☆☆¶

Exercise 47

Al ejecutar una suite de pruebas, la terminal reporta el siguiente mensaje:

assertion failed: mcd(0, 5) == 5, file tests.c, line 42, function test_mcd_cero
Aborted (core dumped)

Analizá la causa raíz del fallo en la función mcd(a, b) y corregila:

int mcd(int a, int b)
{
    if (b == 0) return a;
    return mcd(b, a % b); // ¿Qué ocurre si a=0 y b=5 en la primera llamada?
}

[plus ultra]: Explicar por qué 0 % 5 == 0 y la siguiente llamada es mcd(5, 0) retornando 5.
[plus ultra]: Asegurar que la función maneje argumentos negativos convirtiéndolos a valor absoluto.

Solution to Exercise 47

Si se pasa a = 0 y b = 5, la primera llamada no entra en b == 0. Llama a mcd(5, 0 % 5) que es mcd(5, 0), el cual entra en b == 0 y retorna 5.

Si la función original no contempla a < 0 o b < 0, los módulos con signo en C pueden generar números negativos. La corrección robusta es:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <assert.h>
#include <stdlib.h>

int mcd(int a, int b)
{
    a = abs(a);
    b = abs(b);
    while (b != 0)
    {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

Ejercicio 4.48 - Test de Regresión ⭐⭐☆☆☆¶

Solution to Exercise 48

Procedimiento:
- Reproducir el bug reportado.
- Escribir una prueba unitaria específica que falle debido a ese bug.
- Modificar el código fuente hasta que la prueba pase.
- Incorporar la nueva prueba a la suite continua del proyecto.
Escribir la prueba primero confirma científicamente la existencia del bug y asegura que la corrección realmente solucione la causa raíz sin depender de verificaciones manuales.

Ejercicio 4.49 - Suite de Pruebas: Desglose de Billetes ⭐⭐⭐☆☆¶

Solution to Exercise 49

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <assert.h>
#include <stdbool.h>

bool desglosar_monto(int monto, int *b1000, int *b500, int *b200, int *b100)
{
    if (monto <= 0 || monto % 100 != 0 || !b1000 || !b500 || !b200 || !b100)
    {
        return false;
    }
    *b1000 = monto / 1000;
    monto %= 1000;

    *b500 = monto / 500;
    monto %= 500;

    *b200 = monto / 200;
    monto %= 200;

    *b100 = monto / 100;
    return true;
}

void test_desglose_combinado(void)
{
    int mil = 0, quin = 0, dosc = 0, cien = 0;
    bool ok = desglosar_monto(3800, &mil, &quin, &dosc, &cien);
    assert(ok == true);
    assert(mil == 3 && quin == 1 && dosc == 1 && cien == 1);
}

void test_desglose_monto_invalido(void)
{
    int mil = 0, quin = 0, dosc = 0, cien = 0;
    assert(desglosar_monto(350, &mil, &quin, &dosc, &cien) == false);
    assert(desglosar_monto(-100, &mil, &quin, &dosc, &cien) == false);
}

Ejercicio 4.50 - Suite de Pruebas: Validador de Números Primos ⭐⭐⭐☆☆¶

Solution to Exercise 50

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <assert.h>
#include <stdbool.h>

bool es_primo(int n)
{
    if (n <= 1)
    {
        return false;
    }
    if (n == 2)
    {
        return true;
    }
    if (n % 2 == 0)
    {
        return false;
    }
    for (int i = 3; i * i <= n; i += 2)
    {
        if (n % i == 0)
        {
            return false;
        }
    }
    return true;
}

void test_primos_menores_o_iguales_uno(void)
{
    assert(es_primo(0) == false);
    assert(es_primo(1) == false);
    assert(es_primo(-7) == false);
}

void test_primos_basicos(void)
{
    assert(es_primo(2) == true);
    assert(es_primo(3) == true);
    assert(es_primo(13) == true);
    assert(es_primo(997) == true);
}

void test_compuestos_impares(void)
{
    assert(es_primo(9) == false);
    assert(es_primo(25) == false);
    assert(es_primo(49) == false);
}

Ejercicio 4.51 - Testeo de Funciones con Códigos de Error ⭐⭐⭐☆☆¶

Solution to Exercise 51

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <assert.h>
#include <stddef.h>

int calcular_velocidad(double distancia, double tiempo, double *velocidad)
{
    if (velocidad == NULL)
    {
        return 3;
    }
    if (distancia < 0.0)
    {
        return 1;
    }
    if (tiempo <= 0.0)
    {
        return 2;
    }
    *velocidad = distancia / tiempo;
    return 0;
}

void test_velocidad_exito(void)
{
    double v = 0.0;
    int codigo = calcular_velocidad(100.0, 2.0, &v);
    assert(codigo == 0);
    assert(v == 50.0);
}

void test_velocidad_distancia_invalida(void)
{
    double v = -99.0;
    int codigo = calcular_velocidad(-10.0, 2.0, &v);
    assert(codigo == 1);
    assert(v == -99.0);
}

void test_velocidad_tiempo_invalido(void)
{
    double v = -99.0;
    int codigo = calcular_velocidad(100.0, 0.0, &v);
    assert(codigo == 2);
    assert(v == -99.0);
}

void test_velocidad_puntero_nulo(void)
{
    int codigo = calcular_velocidad(100.0, 2.0, NULL);
    assert(codigo == 3);
}

Ejercicio 4.52 - Suite de Pruebas: Palíndromo Numérico ⭐⭐☆☆☆¶

Solution to Exercise 52

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <assert.h>
#include <stdbool.h>

int invertir_entero(int n)
{
    int invertido = 0;
    while (n > 0)
    {
        invertido = (invertido * 10) + (n % 10);
        n /= 10;
    }
    return invertido;
}

bool es_numero_capicua(int n)
{
    if (n < 0)
    {
        return false;
    }
    if (n < 10)
    {
        return true;
    }
    return n == invertir_entero(n);
}

void test_capicua_un_digito(void)
{
    assert(es_numero_capicua(0) == true);
    assert(es_numero_capicua(7) == true);
}

void test_capicua_multiples_digitos(void)
{
    assert(es_numero_capicua(1221) == true);
    assert(es_numero_capicua(12321) == true);
    assert(es_numero_capicua(123) == false);
    assert(es_numero_capicua(-121) == false);
}

Ejercicio 4.53 - Suite de Pruebas: Validador de Triángulo ⭐⭐⭐☆☆¶

Solution to Exercise 53

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <assert.h>
#include <math.h>
#include <stdbool.h>

bool lados_cercanos(double x, double y)
{
    return fabs(x - y) < 1e-6;
}

int clasificar_triangulo(double a, double b, double c)
{
    if (a <= 0.0 || b <= 0.0 || c <= 0.0)
    {
        return 0;
    }
    if (a + b <= c || a + c <= b || b + c <= a)
    {
        return 0; // Desigualdad triangular violada
    }
    if (lados_cercanos(a, b) && lados_cercanos(b, c))
    {
        return 1; // Equilátero
    }
    if (lados_cercanos(a, b) || lados_cercanos(a, c) || lados_cercanos(b, c))
    {
        return 2; // Isósceles
    }
    return 3; // Escaleno
}

void test_triangulo_invalido(void)
{
    assert(clasificar_triangulo(1.0, 2.0, 3.0) == 0); // Degenerado
    assert(clasificar_triangulo(-1.0, 2.0, 2.0) == 0);
}

void test_triangulo_tipos(void)
{
    assert(clasificar_triangulo(5.0, 5.0, 5.0) == 1);
    assert(clasificar_triangulo(5.0, 5.0, 8.0) == 2);
    assert(clasificar_triangulo(3.0, 4.0, 5.0) == 3);
}

Ejercicio 4.54 - Suite de Pruebas: Conversión de Segundos a Tiempo ⭐⭐☆☆☆¶

Solution to Exercise 54

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>

bool segundos_a_tiempo(int total_segundos, int *horas, int *minutos, int *segundos)
{
    if (total_segundos < 0 || !horas || !minutos || !segundos)
    {
        return false;
    }
    *horas = total_segundos / 3600;
    int resto = total_segundos % 3600;
    *minutos = resto / 60;
    *segundos = resto % 60;
    return true;
}

void test_segundos_a_tiempo_normal(void)
{
    int h = 0, m = 0, s = 0;
    bool ok = segundos_a_tiempo(3661, &h, &m, &s);
    assert(ok == true);
    assert(h == 1 && m == 1 && s == 1);
}

void test_segundos_a_tiempo_cero(void)
{
    int h = 0, m = 0, s = 0;
    bool ok = segundos_a_tiempo(0, &h, &m, &s);
    assert(ok == true);
    assert(h == 0 && m == 0 && s == 0);
}

void test_segundos_a_tiempo_invalido(void)
{
    int h = 0, m = 0, s = 0;
    assert(segundos_a_tiempo(-10, &h, &m, &s) == false);
    assert(segundos_a_tiempo(100, NULL, &m, &s) == false);
}

Ejercicio 4.55 - Suite Integradora de Evaluación de Sistema de Calificaciones ⭐⭐⭐☆☆¶

Exercise 55

Diseñá una biblioteca modular completa para la gestión de notas de un curso con las siguientes especificaciones:

bool validar_nota(int nota): valida que la nota esté entre 1 y 10.
double calcular_promedio_curso(const int notas[], int cantidad): calcula el promedio de notas válidas.
int contar_aprobados(const int notas[], int cantidad, int nota_minima): cuenta cuántos alumnos superan o igualan la nota mínima.
int estado_final_alumno(int parcial1, int parcial2, int recuperatorio):
- Si parcial1 >= 4 y parcial2 >= 4, la nota final es el promedio de ambos.
- Si uno de los dos es $< 4$ , se reemplaza la nota reprobada por la del recuperatorio. Si luego de esto ambas son $\ge 4$ , aprueba.
- Retorna -1 si algún dato es inválido, 0 si reprueba, o la nota final entera.

Construí una suite integradora de pruebas unitarias automatizadas que cubra todos los caminos y bordes con un runner central.

[plus ultra]: Verificar que todas las funciones sigan estrictamente el estilo Allman y no empleen variables globales.
[plus ultra]: Documentar cada función con etiquetas @brief, @param, @pre, @returns y @post.

Solution to Exercise 55

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>

bool validar_nota(int nota)
{
    return (nota >= 1 && nota <= 10);
}

double calcular_promedio_curso(const int notas[], int cantidad)
{
    if (notas == NULL || cantidad <= 0)
    {
        return -1.0;
    }
    int suma = 0;
    for (int i = 0; i < cantidad; i++)
    {
        if (!validar_nota(notas[i]))
        {
            return -1.0;
        }
        suma += notas[i];
    }
    return (double)suma / cantidad;
}

int contar_aprobados(const int notas[], int cantidad, int nota_minima)
{
    if (notas == NULL || cantidad <= 0 || !validar_nota(nota_minima))
    {
        return -1;
    }
    int aprobados = 0;
    for (int i = 0; i < cantidad; i++)
    {
        if (notas[i] >= nota_minima)
        {
            aprobados++;
        }
    }
    return aprobados;
}

int estado_final_alumno(int p1, int p2, int rec)
{
    if (!validar_nota(p1) || !validar_nota(p2))
    {
        return -1;
    }
    if (p1 >= 4 && p2 >= 4)
    {
        return (p1 + p2) / 2;
    }
    if (!validar_nota(rec))
    {
        return 0; // Reprobado sin recuperatorio válido
    }
    if (p1 < 4 && rec >= 4 && p2 >= 4)
    {
        return (rec + p2) / 2;
    }
    if (p2 < 4 && rec >= 4 && p1 >= 4)
    {
        return (p1 + rec) / 2;
    }
    return 0;
}

void test_sistema_calificaciones(void)
{
    int notas[] = {7, 8, 4, 10, 6};
    assert(calcular_promedio_curso(notas, 5) == 7.0);
    assert(contar_aprobados(notas, 5, 6) == 4);

    // Caso directo aprobado
    assert(estado_final_alumno(8, 6, 0) == 7);

    // Caso recupera primer parcial
    assert(estado_final_alumno(2, 8, 6) == 7);

    // Caso recupera segundo parcial
    assert(estado_final_alumno(7, 3, 5) == 6);

    // Caso reprueba recuperatorio
    assert(estado_final_alumno(2, 8, 3) == 0);

    // Caso notas inválidas
    assert(estado_final_alumno(12, 8, 5) == -1);
}

int main(void)
{
    test_sistema_calificaciones();
    printf("¡Suite integradora ejecutada con 100%% de éxito!\n");
    return 0;
}