// calloc reserva n elementos y los deja en cero.
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 5;
    int *counts = calloc(n, sizeof *counts);
    if (counts == NULL) {
        return 1;
    }

    counts[2] = counts[2] + 1;
    for (int i = 0; i < n; i++) {
        printf("%d ", counts[i]);
    }
    printf("\n");

    free(counts);
    return 0;
}

// Cuenta las llamadas a realloc al agregar 20000 enteros, con dos reglas.
#include <stdio.h>
#include <stdlib.h>

#define TOTAL 20000

// factor 0: crece de uno en uno. factor 2: duplica la capacidad.
// Devuelve cuántas veces llamó a realloc, o -1 si no hubo memoria.
long fill(int factor) {
    int *items = NULL;
    size_t capacity = 0;
    long calls = 0;

    for (size_t count = 0; count < TOTAL; count++) {
        if (count == capacity) {
            size_t wanted = factor == 0 || capacity == 0 ? capacity + 1 : capacity * factor;
            int *bigger = realloc(items, wanted * sizeof *items);
            if (bigger == NULL) {
                free(items);
                return -1;
            }
            items = bigger;
            capacity = wanted;
            calls++;
        }
        items[count] = (int) count;
    }

    free(items);
    return calls;
}

int main(void) {
    printf("de uno en uno: %ld llamadas\n", fill(0));
    printf("duplicando:    %ld llamadas\n", fill(2));
    return 0;
}

// El struct ya no lleva los píxeles adentro: solo un puntero a ellos.
#include <stdio.h>

#include "lab/image.h"

int main(void) {
    printf("sizeof(struct image) = %zu\n", sizeof(struct image));
    return 0;
}

// Pide un bloque imposible, para ver cómo avisa malloc.
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    size_t huge = SIZE_MAX / 2;

    char *block = malloc(huge);
    if (block == NULL) {
        printf("malloc devolvió NULL: no hay memoria\n");
        return 1;
    }

    printf("Se reservó el bloque\n");
    free(block);
    return 0;
}

// Una función reserva un bloque, y el bloque sobrevive a su marco.
#include <stdio.h>
#include <stdlib.h>

// Devuelve un bloque nuevo con first, first + 1, ... (n elementos), o NULL si no hay
// memoria. Quien llama es owner del bloque, y debe liberarlo con free.
int *range_new(int first, int n) {
    int *block = malloc(n * sizeof *block);
    if (block == NULL) {
        return NULL;
    }
    for (int i = 0; i < n; i++) {
        block[i] = first + i;
    }
    return block;
}

int main(void) {
    int *numbers = range_new(10, 4);
    if (numbers == NULL) {
        fprintf(stderr, "No hay memoria\n");
        return 1;
    }

    for (int i = 0; i < 4; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    free(numbers);
    return 0;
}

// realloc cambia el tamaño de un bloque y conserva lo que tenía.
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *values = malloc(2 * sizeof *values);
    if (values == NULL) {
        return 1;
    }
    values[0] = 10;
    values[1] = 20;

    int *bigger = realloc(values, 4 * sizeof *values);
    if (bigger == NULL) {
        // values sigue siendo válido: su owner todavía debe liberarlo.
        free(values);
        return 1;
    }
    values = bigger;
    values[2] = 30;
    values[3] = 40;

    for (int i = 0; i < 4; i++) {
        printf("%d ", values[i]);
    }
    printf("\n");

    free(values);
    return 0;
}

// Lee n y luego n números, y los escribe al revés. El tamaño se conoce al ejecutar.
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n;
    if (scanf("%d", &n) != 1 || n < 1) {
        fprintf(stderr, "Entrada inválida\n");
        return 1;
    }

    int *values = malloc(n * sizeof *values);
    if (values == NULL) {
        fprintf(stderr, "No hay memoria para %d números\n", n);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        if (scanf("%d", &values[i]) != 1) {
            fprintf(stderr, "Entrada inválida\n");
            free(values);
            return 1;
        }
    }

    for (int i = n - 1; i >= 0; i--) {
        printf("%d ", values[i]);
    }
    printf("\n");

    free(values);
    return 0;
}

// Cuánto mide cada cosa. malloc recibe bytes, no elementos.
#include <stdio.h>
#include <stdlib.h>

struct point {
    int x;
    int y;
};

int main(void) {
    int *p = malloc(10 * sizeof *p);
    struct point *q = malloc(sizeof *q);
    if (p == NULL || q == NULL) {
        free(p);
        free(q);
        return 1;
    }

    printf("sizeof(int)          = %zu\n", sizeof(int));
    printf("sizeof p  (puntero)  = %zu\n", sizeof p);
    printf("sizeof *p (un int)   = %zu\n", sizeof *p);
    printf("sizeof q  (puntero)  = %zu\n", sizeof q);
    printf("sizeof *q (un point) = %zu\n", sizeof *q);
    printf("10 enteros           = %zu bytes\n", 10 * sizeof *p);

    free(p);
    free(q);
    return 0;
}

// Tres firmas, tres respuestas a la pregunta: ¿quién libera?
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Devuelve una cadena nueva con text en mayúsculas, o NULL si no hay memoria.
// Quien llama es owner del resultado, y debe liberarlo con free.
char *upper_copy(const char *text) {
    char *copy = malloc(strlen(text) + 1);
    if (copy == NULL) {
        return NULL;
    }

    size_t i = 0;
    for (; text[i] != '\0'; i++) {
        copy[i] = (char) toupper((unsigned char) text[i]);
    }
    copy[i] = '\0';
    return copy;
}

// Cambia text en su lugar. El owner de text sigue siendo quien llama.
void upper_in_place(char *text) {
    for (size_t i = 0; text[i] != '\0'; i++) {
        text[i] = (char) toupper((unsigned char) text[i]);
    }
}

// Devuelve una de las dos cadenas que recibió. No hay memoria nueva: no se libera.
const char *longer_of(const char *a, const char *b) {
    return strlen(a) >= strlen(b) ? a : b;
}

int main(void) {
    char *upper = upper_copy("paradero");
    if (upper == NULL) {
        return 1;
    }
    printf("%s\n", upper);
    free(upper);

    char word[] = "ruta";
    upper_in_place(word);
    printf("%s\n", word);

    printf("%s\n", longer_of("Lima", "Arequipa"));
    return 0;
}

// Un struct que es owner de un bloque: reservar dos veces y liberar dos veces.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct student {
    int code;
    char *name;
};

// Devuelve un estudiante nuevo, con su propia copia de name, o NULL si no hay memoria.
// Quien llama es owner del resultado, y lo libera con student_free.
struct student *student_new(int code, const char *name) {
    struct student *s = malloc(sizeof *s);
    if (s == NULL) {
        return NULL;
    }

    s->name = malloc(strlen(name) + 1);
    if (s->name == NULL) {
        free(s);
        return NULL;
    }

    strcpy(s->name, name);
    s->code = code;
    return s;
}

// Libera el estudiante y su nombre. Con NULL no hace nada.
void student_free(struct student *s) {
    if (s == NULL) {
        return;
    }
    free(s->name);
    free(s);
}

int main(void) {
    struct student *ana = student_new(101, "Ana");
    if (ana == NULL) {
        return 1;
    }

    // Copiar el struct copia el puntero, no el nombre: ahora los dos comparten un bloque.
    struct student shallow = *ana;
    shallow.name[0] = 'E';
    printf("%s %s\n", ana->name, shallow.name);
    printf("mismo bloque: %d\n", ana->name == shallow.name);

    student_free(ana);
    return 0;
}

// Error: un arreglo local más grande que la pila.
#include <stdio.h>

#define SIZE 4000000

int main(void) {
    int values[SIZE];
    for (int i = 0; i < SIZE; i++) {
        values[i] = i;
    }
    printf("%d\n", values[SIZE - 1]);
    return 0;
}

// Error: liberar dos veces. Dos funciones creen ser owners del mismo bloque.
#include <stdio.h>
#include <stdlib.h>

void show_and_free(int *values, int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", values[i]);
    }
    printf("\n");
    free(values);
}

int main(void) {
    int *values = calloc(3, sizeof *values);
    if (values == NULL) {
        return 1;
    }

    show_and_free(values, 3);
    free(values);
    return 0;
}

// Error: free recibe la dirección que dio malloc, no otra dentro del bloque.
#include <stdlib.h>

int main(void) {
    int *values = malloc(4 * sizeof *values);
    if (values == NULL) {
        return 1;
    }

    values++;
    free(values);
    return 0;
}

// Error: fuga de memoria. Nadie libera lo que devuelve range_new.
#include <stdio.h>
#include <stdlib.h>

int *range_new(int first, int n) {
    int *block = malloc(n * sizeof *block);
    if (block == NULL) {
        return NULL;
    }
    for (int i = 0; i < n; i++) {
        block[i] = first + i;
    }
    return block;
}

int main(void) {
    for (int round = 0; round < 3; round++) {
        int *numbers = range_new(round, 10);
        if (numbers == NULL) {
            return 1;
        }
        printf("%d\n", numbers[9]);
    }
    return 0;
}

// Error: devuelve la dirección de una local. Su marco ya no existe al volver.
#include <stdio.h>

int *range_local(int first) {
    int block[4];
    for (int i = 0; i < 4; i++) {
        block[i] = first + i;
    }
    return block;
}

int main(void) {
    int *numbers = range_local(10);
    printf("%d\n", numbers[0]);
    return 0;
}

// Error: salirse de un arreglo local, no de un bloque del heap.
#include <stdio.h>

int main(void) {
    int values[4] = {1, 2, 3, 4};
    int total = 0;
    for (int i = 0; i <= 4; i++) {
        total = total + values[i];
    }
    printf("%d\n", total > 0);
    return 0;
}

// Error: salirse del bloque por uno.
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 4;
    int *values = malloc(n * sizeof *values);
    if (values == NULL) {
        return 1;
    }

    for (int i = 0; i <= n; i++) {
        values[i] = i * i;
    }
    printf("%d\n", values[n - 1]);

    free(values);
    return 0;
}

// Error: p = realloc(p, n). Si realloc falla, se pierde la única dirección del bloque.
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    size_t huge = SIZE_MAX / 2;

    int *p = malloc(10 * sizeof *p);
    if (p == NULL) {
        return 1;
    }

    p = realloc(p, huge);
    if (p == NULL) {
        printf("realloc devolvió NULL\n");
        return 1;
    }

    free(p);
    return 0;
}

// Error: malloc recibe bytes. 10 bytes no alcanzan para 10 enteros.
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(10);
    if (p == NULL) {
        return 1;
    }

    for (int i = 0; i < 10; i++) {
        p[i] = i;
    }
    printf("%d\n", p[9]);

    free(p);
    return 0;
}

// Error: seguir usando la dirección de antes de realloc.
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *values = calloc(2, sizeof *values);
    if (values == NULL) {
        return 1;
    }
    int *first = values;

    int *bigger = realloc(values, 100000 * sizeof *values);
    if (bigger == NULL) {
        free(values);
        return 1;
    }
    values = bigger;

    printf("%d\n", *first);
    free(values);
    return 0;
}

// strdup no está en C17: con -std=c17, stdlib y string.h no la declaran.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
    char *copy = strdup("Lima");
    if (copy == NULL) {
        return 1;
    }
    printf("%s\n", copy);
    free(copy);
    return 0;
}

// Error: decidir con un valor que nadie escribió. malloc no limpia el bloque.
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *counts = malloc(3 * sizeof *counts);
    if (counts == NULL) {
        return 1;
    }

    counts[0] = 5;
    counts[2] = 5;
    if (counts[1] > 0) {
        printf("hay datos\n");
    } else {
        printf("no hay datos\n");
    }

    free(counts);
    return 0;
}

// Error: usar un bloque después de liberarlo.
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *p = malloc(10 * sizeof *p);
    if (p == NULL) {
        return 1;
    }

    p[0] = 7;
    free(p);
    printf("%d\n", *p);
    return 0;
}

"""Comprueba los programas de la clase y lo que los apuntes dicen de sus errores."""
import pathlib
import subprocess
import tempfile
import unittest

HERE = pathlib.Path(__file__).parent
BUILD = HERE / "build"
FLAGS = ["-Wall", "-Wextra", "-std=c17", "-g", "-fsanitize=address,undefined"]
VALGRIND_FLAGS = ["-Wall", "-Wextra", "-std=c17", "-g", "-O0"]
PROGRAMS = ["reverse_numbers", "range_block", "sizes", "calloc_zero", "strings_owner",
            "realloc_grow", "growth_count", "image_size", "no_memory"]

# Programa de errors/ y lo que debe decir su informe con sanitizers.
SANITIZER_ERRORS = {
    "big_local": "stack-overflow",
    "short_block": "heap-buffer-overflow",
    "leak": "LeakSanitizer: detected memory leaks",
    "use_after_free": "heap-use-after-free",
    "double_free": "attempting double-free",
    "off_by_one": "heap-buffer-overflow",
    "free_middle": "attempting free on address which was not malloc()-ed",
    "local_overflow": "stack-buffer-overflow",
    "stale_pointer": "heap-use-after-free",
    "realloc_lost": "allocation-size-too-big",
}
# Programa de errors/ y lo que debe decir valgrind.
VALGRIND_ERRORS = {
    "leak": "definitely lost: 120 bytes in 3 blocks",
    "use_after_free": "Invalid read of size 4",
    "double_free": "Invalid free()",
    "off_by_one": "Invalid write of size 4",
    "uninit_read": "Conditional jump or move depends on uninitialised value(s)",
    "stale_pointer": "Invalid read of size 4",
    "realloc_lost": "definitely lost: 40 bytes in 1 blocks",
}
# Programa de la cacería y lo que reporta cada herramienta en la versión sin corregir.
HUNT_ERRORS = {
    "longest_word": ("LeakSanitizer", "definitely lost"),
    "seat_list": ("heap-use-after-free", "Invalid read"),
    "route_backup": ("attempting double-free", "Invalid free()"),
    "grade_histogram": ("heap-buffer-overflow", "Invalid read"),
    "passing_groups": (None, "Conditional jump"),
}


def run(command, stdin=None):
    done = subprocess.run(
        command, cwd=HERE, text=True, encoding="utf-8", input=stdin,
        stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=60,
    )
    return done.stdout, done.returncode


def with_sanitizers(source, stdin=None):
    with tempfile.TemporaryDirectory() as folder:
        binary = pathlib.Path(folder) / "program"
        built, code = run(["gcc", *FLAGS, str(source), "-o", str(binary)])
        if code != 0:
            raise AssertionError(built)
        return run([str(binary)], stdin)


def with_valgrind(source):
    with tempfile.TemporaryDirectory() as folder:
        binary = pathlib.Path(folder) / "program"
        built, code = run(["gcc", *VALGRIND_FLAGS, str(source), "-o", str(binary)])
        if code != 0:
            raise AssertionError(built)
        return run(["valgrind", "--leak-check=full", str(binary)])


class Programs(unittest.TestCase):
    def test_every_program_compiles_without_warnings(self):
        for name in [*PROGRAMS, "student"]:
            with self.subTest(program=name):
                output, code = run(["gcc", *FLAGS, "-Werror", "-c", f"{name}.c", "-o", "/dev/null"])
                self.assertEqual(code, 0, output)

    def test_examples_end_without_errors(self):
        # Con sanitizers: una fuga o un acceso inválido cambiaría el código de salida.
        for name in ["range_block", "sizes", "calloc_zero", "strings_owner", "student",
                     "realloc_grow", "growth_count", "image_size"]:
            with self.subTest(program=name):
                output, code = run([str(BUILD / name)])
                self.assertEqual(code, 0, output)

    def test_examples_are_clean_in_valgrind(self):
        for name in ["range_block", "calloc_zero", "strings_owner", "student", "realloc_grow"]:
            with self.subTest(program=name):
                output, _ = with_valgrind(HERE / f"{name}.c")
                self.assertIn("ERROR SUMMARY: 0 errors", output)
                self.assertIn("no leaks are possible", output)

    def test_reverse_reads_any_count(self):
        numbers = " ".join(str(i) for i in range(5000))
        output, code = run([str(BUILD / "reverse_numbers")], f"5000 {numbers}\n")
        self.assertEqual(code, 0)
        self.assertEqual(output.split(), [str(i) for i in reversed(range(5000))])

    def test_reverse_rejects_bad_input_without_leaks(self):
        for text in ("x\n", "0\n", "-2\n", "3 1 2\n"):
            with self.subTest(text=text):
                output, code = run([str(BUILD / "reverse_numbers")], text)
                self.assertEqual(code, 1)
                self.assertEqual(output.strip(), "Entrada inválida")

    def test_no_memory_reports_null_without_sanitizers(self):
        output, code = run([str(BUILD / "no_memory")])
        self.assertEqual(code, 1)
        self.assertIn("devolvió NULL", output)


class Errors(unittest.TestCase):
    def test_sanitizers_name_each_error(self):
        for name, marker in SANITIZER_ERRORS.items():
            with self.subTest(program=name):
                output, code = with_sanitizers(HERE / "errors" / f"{name}.c")
                self.assertNotEqual(code, 0)
                self.assertIn(marker, output)

    def test_valgrind_names_each_error(self):
        for name, marker in VALGRIND_ERRORS.items():
            with self.subTest(program=name):
                output, _ = with_valgrind(HERE / "errors" / f"{name}.c")
                self.assertIn(marker, output)

    def test_asan_does_not_see_uninitialized_reads(self):
        output, code = with_sanitizers(HERE / "errors" / "uninit_read.c")
        self.assertEqual(code, 0)
        self.assertNotIn("ERROR", output)

    def test_valgrind_does_not_see_local_overflows(self):
        output, _ = with_valgrind(HERE / "errors" / "local_overflow.c")
        self.assertIn("ERROR SUMMARY: 0 errors", output)

    def test_strdup_is_not_declared_in_c17(self):
        output, code = run(["gcc", *VALGRIND_FLAGS, "-c", "errors/strdup_c17.c", "-o", "/dev/null"])
        self.assertNotEqual(code, 0)
        self.assertIn("strdup", output)


@unittest.skipUnless((HERE / "solution").exists(), "falta la solución")
class LabAsPublished(unittest.TestCase):
    """Solo con la carpeta de la solución, antes de entregar el laboratorio: ustedes van a
    corregir lab/hunt, y estas pruebas ya no tendrían sentido en su copia."""

    def test_hunt_compiles_without_warnings(self):
        for name in HUNT_ERRORS:
            with self.subTest(program=name):
                output, code = run(["gcc", *FLAGS, "-Werror", "-c", f"lab/hunt/{name}.c",
                                    "-o", "/dev/null"])
                self.assertEqual(code, 0, output)

    def test_each_hunt_program_has_the_error_it_should(self):
        for name, (with_asan, with_vg) in HUNT_ERRORS.items():
            source = HERE / "lab" / "hunt" / f"{name}.c"
            with self.subTest(program=name, tool="sanitizers"):
                output, code = with_sanitizers(source)
                if with_asan is None:
                    self.assertEqual(code, 0, output)
                else:
                    self.assertNotEqual(code, 0)
                    self.assertIn(with_asan, output)
            with self.subTest(program=name, tool="valgrind"):
                self.assertIn(with_vg, with_valgrind(source)[0])

    def test_starter_and_solution_compile_without_warnings(self):
        for folder in ("lab", "solution"):
            for name in ("image.c", "str_tools.c", "int_array.c", "image_tests.c", "str_tests.c",
                         "array_tests.c"):
                with self.subTest(file=f"{folder}/{name}"):
                    output, code = run(["gcc", *FLAGS, "-Werror", "-Ilab", "-c", f"{folder}/{name}",
                                        "-o", "/dev/null"])
                    self.assertEqual(code, 0, output)
        for name in ("filters.c", "image_demo.c", "sum_file.c"):
            with self.subTest(file=f"lab/{name}"):
                output, code = run(["gcc", *FLAGS, "-Werror", "-Ilab", "-c", f"lab/{name}",
                                    "-o", "/dev/null"])
                self.assertEqual(code, 0, output)


if __name__ == "__main__":
    unittest.main()

"""Pruebas del laboratorio. LAB_DIR dice dónde está el código: lab o solution.

Cada prueba compila un main propio con los archivos de esa carpeta, y lo corre con
sanitizers: una fuga o un acceso inválido hace fallar la prueba, aunque el resultado
parezca correcto.
"""
import os
import pathlib
import re
import resource
import subprocess
import tempfile
import unittest

HERE = pathlib.Path(__file__).parent
LAB_DIR = os.environ.get("LAB_DIR", "solution")
SOURCE = HERE / LAB_DIR
HEADERS = HERE / "lab"
FLAGS = ["-Wall", "-Wextra", "-std=c17", "-g", "-fsanitize=address,undefined"]
VALGRIND_FLAGS = ["-Wall", "-Wextra", "-std=c17", "-g", "-O0"]
# Con este límite, un archivo sin cerrar se nota después de pocas lecturas. Los sanitizers
# no lo reportan como fuga, porque la biblioteca estándar conserva una lista de archivos abiertos.
OPEN_FILES_LIMIT = 32

# Hace fallar la llamada número fail_at a malloc, calloc o realloc. Solo para estas pruebas.
FAILING_ALLOCATOR = """
#include <stdlib.h>
void *__real_malloc(size_t size);
void *__real_calloc(size_t count, size_t size);
void *__real_realloc(void *block, size_t size);
static int calls = 0;
static int fail_at = 0;
static int next_fails(void) { calls++; return calls == fail_at; }
void *__wrap_malloc(size_t size) { return next_fails() ? NULL : __real_malloc(size); }
void *__wrap_calloc(size_t count, size_t size) {
    return next_fails() ? NULL : __real_calloc(count, size);
}
void *__wrap_realloc(void *block, size_t size) {
    return next_fails() ? NULL : __real_realloc(block, size);
}
"""
WRAP = ["-Wl,--wrap=malloc", "-Wl,--wrap=calloc", "-Wl,--wrap=realloc"]


def short_report(text):
    """Deja lo útil de un informe de los sanitizers: el tipo de error y las líneas propias."""
    if "ERROR:" not in text and "runtime error" not in text:
        return text.strip()
    useful = [line for line in text.splitlines()
              if "ERROR:" in line or "SUMMARY:" in line or "runtime error" in line
              or re.search(r"\b(driver|image|filters|str_tools|int_array)\.c:\d+", line)]
    return "\n".join(line.strip() for line in useful[:12])


def limit_open_files():
    resource.setrlimit(resource.RLIMIT_NOFILE, (OPEN_FILES_LIMIT, OPEN_FILES_LIMIT))


def compile_and_run(main_source, sources, files=None, extra=(), stdin=None, setup=None):
    with tempfile.TemporaryDirectory() as name:
        folder = pathlib.Path(name)
        driver = folder / "driver.c"
        driver.write_text(main_source, encoding="utf-8")
        for file_name, content in (files or {}).items():
            (folder / file_name).write_text(content, encoding="utf-8")
        binary = folder / "driver"
        built = subprocess.run(
            ["gcc", *FLAGS, f"-I{HEADERS}", str(driver), *map(str, sources), *extra, "-o", str(binary)],
            text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
        )
        if built.returncode != 0:
            raise AssertionError(f"No compila:\n{built.stdout}")
        done = subprocess.run(
            [str(binary)], cwd=folder, text=True, encoding="utf-8", input=stdin, preexec_fn=setup,
            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=60,
        )
        return done.stdout, done.returncode


class LabTest(unittest.TestCase):
    maxDiff = None

    def run_clean(self, source, sources, files=None, extra=(), context="", setup=None):
        """Corre el programa y exige que termine bien, sin informes de los sanitizers."""
        out, code = compile_and_run(source, sources, files, extra, setup=setup)
        if code != 0:
            self.fail(f"{context}\nEl programa falló:\n{short_report(out)}")
        return out

    def same(self, got, wanted, context):
        if got != wanted:
            self.fail(f"{context}\n  esperado: {wanted}\n  obtuvo:   {got}")


def image_sources():
    return [SOURCE / "image.c", HERE / "lab" / "filters.c"]


def image_main(body):
    return ('#include <stdio.h>\n#include "filters.h"\n'
            "static void dump(const struct image *img) {\n"
            '    if (img == NULL) { printf("NULL\\n"); return; }\n'
            '    printf("%d %d %d", img->width, img->height, img->max_value);\n'
            "    for (int i = 0; i < img->width * img->height; i++) {\n"
            '        printf(" %d", img->pixels[i]);\n    }\n    printf("\\n");\n}\n'
            "int main(void) {\n" + body + "\nreturn 0;\n}\n")


def pgm(width, height, max_value, values):
    numbers = " ".join(map(str, values))
    return f"P2\n{width} {height}\n{max_value}\n{numbers}\n"


@unittest.skipUnless((SOURCE / "image.c").exists(), f"no está {LAB_DIR}/image.c")
class Images(LabTest):
    def load(self, content, context):
        """Carga content con image_load. Devuelve lo que escribe dump, sin espacios al final."""
        body = 'struct image *img = image_load("in.pgm"); dump(img); image_free(img);'
        return self.run_clean(image_main(body), image_sources(), {"in.pgm": content},
                              context=context).strip()

    def test_new_fills_every_pixel(self):
        body = "struct image *img = image_new(3, 2, 200, 7); dump(img); image_free(img);"
        out = self.run_clean(image_main(body), image_sources(),
                             context="image_new(3, 2, 200, 7)")
        self.same(out.strip(), "3 2 200 7 7 7 7 7 7", "image_new(3, 2, 200, 7)")

    def test_new_rejects_bad_data(self):
        cases = ["0, 2, 255, 0", "3, 0, 255, 0", "-3, 2, 255, 0", "3, -2, 255, 0", "3, 2, 0, 0",
                 "3, 2, 256, 0", "3, 2, 255, 256", "3, 2, 255, -1"]
        for case in cases:
            with self.subTest(args=case):
                body = f"dump(image_new({case}));"
                out = self.run_clean(image_main(body), image_sources(),
                                     context=f"image_new({case})")
                self.same(out.strip(), "NULL", f"image_new({case}) debe devolver NULL")

    def test_new_rejects_a_size_that_does_not_fit(self):
        # width * height no cabe en un int. Hay que notarlo antes de multiplicar.
        body = "dump(image_new(50000, 50000, 255, 0));"
        out = self.run_clean(image_main(body), image_sources(),
                             context="image_new(50000, 50000, 255, 0)")
        self.same(out.strip(), "NULL", "image_new(50000, 50000, 255, 0) debe devolver NULL")

    def test_free_accepts_null(self):
        self.run_clean(image_main("image_free(NULL);"), image_sources(), context="image_free(NULL)")

    def test_load_small_image_with_comment(self):
        content = "P2\n# un comentario\n3 2\n255\n0 10 20\n30 40 50\n"
        self.same(self.load(content, "imagen de 3 x 2"), "3 2 255 0 10 20 30 40 50",
                  "imagen de 3 x 2 con un comentario")

    def test_load_keeps_the_rows_in_order(self):
        # No es cuadrada: descubre si se confundieron width y height.
        content = pgm(2, 3, 9, [1, 2, 3, 4, 5, 6])
        self.same(self.load(content, "imagen de 2 x 3"), "2 3 9 1 2 3 4 5 6", "imagen de 2 x 3")

    def test_load_larger_than_the_old_limit(self):
        width, height = 300, 200
        values = [(x * 7 + y * 11) % 256 for y in range(height) for x in range(width)]
        expected = " ".join(map(str, [width, height, 255, *values]))
        got = self.load(pgm(width, height, 255, values), "imagen de 300 x 200")
        if got != expected:
            self.fail("La imagen de 300 x 200 no se cargó bien: sus píxeles no coinciden.")

    def test_load_the_range_image(self):
        body = ('struct image *img = image_load("' + str(HERE / "lab/images/range.pgm") + '");\n'
                'if (img != NULL) { printf("%d %d\\n", img->width, img->height); }\n'
                "image_free(img);")
        out = self.run_clean(image_main(body), image_sources(), context="lab/images/range.pgm")
        self.same(out.strip(), "96 28", "ancho y alto de lab/images/range.pgm")

    def test_load_failures_release_everything(self):
        cases = {
            "no es P2": "P5\n2 1\n255\n0 0\n",
            "archivo vacío": "",
            "sin alto": "P2\n2\n",
            "ancho 0": pgm(0, 1, 255, []),
            "max_value mayor que 255": pgm(1, 1, 256, [0]),
            "faltan píxeles": "P2\n3 2\n255\n1 2 3 4\n",
            "píxel mayor que max_value": pgm(2, 1, 9, [1, 10]),
            "una letra entre los píxeles": "P2\n2 1\n255\n1 x\n",
            "el tamaño no cabe en un int": "P2\n50000 50000\n255\n1\n",
            "un número que no cabe en un int": "P2\n99999999999 1\n255\n1\n",
        }
        for label, content in cases.items():
            with self.subTest(label):
                self.same(self.load(content, label), "NULL", f"{label}: debe devolver NULL")

    def test_load_missing_file(self):
        body = 'dump(image_load("no_existe.pgm"));'
        out = self.run_clean(image_main(body), image_sources(), context="archivo que no existe")
        self.same(out.strip(), "NULL", "un archivo que no existe debe dar NULL")

    def test_load_closes_the_file(self):
        body = ("for (int i = 0; i < 100; i++) {\n"
                '    struct image *good = image_load("good.pgm");\n'
                '    if (good == NULL) { printf("falló la lectura %d\\n", i); return 1; }\n'
                "    image_free(good);\n"
                '    image_free(image_load("bad.pgm"));\n'
                "}")
        self.run_clean(image_main(body), image_sources(),
                       {"good.pgm": pgm(1, 1, 9, [1]), "bad.pgm": "P2\n2 1\n9\n1\n"},
                       context="100 lecturas seguidas: ¿se cierra el archivo en todos los caminos?",
                       setup=limit_open_files)

    def test_save_and_load_again(self):
        body = ("const int values[] = {1, 2, 3, 4, 5, 6};\n"
                "struct image *img = image_from_values(3, 2, 9, values);\n"
                'if (img == NULL || !image_save(img, "out.pgm")) { return 1; }\n'
                'struct image *again = image_load("out.pgm");\n'
                "dump(again);\n"
                "image_free(again);\nimage_free(img);")
        out = self.run_clean(image_main(body), image_sources(), context="guardar y volver a cargar")
        self.same(out.strip(), "3 2 9 1 2 3 4 5 6", "guardar y volver a cargar")

    def test_filters_work_on_any_size(self):
        body = ("struct image *img = image_new(70, 3, 255, 200);\n"
                "if (img == NULL) { return 1; }\n"
                "img->pixels[0] = 10;\n"
                "flip_horizontal(img);\ninvert(img);\n"
                'printf("%d %d\\n", img->pixels[69], img->pixels[0]);\n'
                "image_free(img);")
        out = self.run_clean(image_main(body), image_sources(), context="filtros en 70 x 3")
        self.same(out.strip(), "245 55", "flip_horizontal e invert en una imagen de 70 x 3")

    def out_of_memory(self, call, context):
        source = FAILING_ALLOCATOR + image_main(
            "int nulls = 0;\n"
            "for (fail_at = 1; ; fail_at++) {\n"
            "    calls = 0;\n"
            f"    struct image *img = {call};\n"
            "    if (img == NULL) { nulls++; }\n"
            "    image_free(img);\n"
            "    if (calls < fail_at) { break; }\n"
            "}\n"
            'printf("%d\\n", nulls);')
        out = self.run_clean(source, image_sources(), {"in.pgm": pgm(2, 1, 9, [1, 2])}, WRAP,
                             context=f"{context}, cuando malloc devuelve NULL")
        numbers = re.findall(r"^\d+$", out, re.M)
        if not numbers or int(numbers[-1]) < 1:
            self.fail(f"{context}: debe devolver NULL cuando malloc devuelve NULL.")

    def test_new_when_there_is_no_memory(self):
        self.out_of_memory("image_new(2, 1, 9, 0)", "image_new")

    def test_load_when_there_is_no_memory(self):
        self.out_of_memory('image_load("in.pgm")', "image_load")


def str_main(body):
    return ('#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include "str_tools.h"\n'
            "int main(void) {\n" + body + "\nreturn 0;\n}\n")


@unittest.skipUnless((SOURCE / "str_tools.c").exists(), f"no está {LAB_DIR}/str_tools.c")
class Strings(LabTest):
    def result_of(self, call):
        body = (f"char *result = {call};\n"
                'if (result == NULL) { printf("NULL\\n"); return 0; }\n'
                'printf("[%s]\\n", result);\nfree(result);')
        return self.run_clean(str_main(body), [SOURCE / "str_tools.c"], context=call).strip()

    def test_duplicate(self):
        for text in ("Lima", "", "a", "con ñ y tilde á"):
            with self.subTest(text=text):
                call = f'str_duplicate("{text}")'
                self.same(self.result_of(call), f"[{text}]", call)

    def test_duplicate_is_a_new_block(self):
        body = ('char original[] = "Lima";\nchar *copy = str_duplicate(original);\n'
                "if (copy == NULL) { return 1; }\n"
                "if (copy == original) { return 2; }\n"
                "copy[0] = 'K';\n"
                'printf("%s %s\\n", original, copy);\nfree(copy);')
        out = self.run_clean(str_main(body), [SOURCE / "str_tools.c"],
                             context="str_duplicate debe devolver otro bloque")
        self.same(out.strip(), "Lima Kima", "cambiar la copia no debe cambiar el original")

    def test_concat(self):
        cases = [("Puno", " y Tacna"), ("", "Ica"), ("Ica", ""), ("", "")]
        for first, second in cases:
            with self.subTest(first=first, second=second):
                call = f'str_concat("{first}", "{second}")'
                self.same(self.result_of(call), f"[{first}{second}]", call)

    def test_concat_with_itself_and_keeps_the_arguments(self):
        body = ('char word[] = "ab";\nchar *joined = str_concat(word, word);\n'
                "if (joined == NULL) { return 1; }\n"
                'printf("%s %s\\n", word, joined);\nfree(joined);')
        out = self.run_clean(str_main(body), [SOURCE / "str_tools.c"],
                             context="str_concat(word, word)")
        self.same(out.strip(), "ab abab", "str_concat(word, word)")

    def test_no_memory(self):
        for call in ('str_duplicate("Lima")', 'str_concat("Li", "ma")'):
            with self.subTest(call=call):
                source = FAILING_ALLOCATOR + str_main(
                    "fail_at = 1;\n"
                    f"char *result = {call};\n"
                    'printf("%s\\n", result == NULL ? "NULL" : "otra");\n'
                    "free(result);")
                out = self.run_clean(source, [SOURCE / "str_tools.c"], extra=WRAP,
                                     context=f"{call}, cuando malloc devuelve NULL")
                self.same(out.strip(), "NULL", f"{call} debe devolver NULL si no hay memoria")


# Lo que debe escribir cada programa de la cacería ya corregido.
HUNT_OUTPUT = {
    "longest_word": "CAJAMARCA\n",
    "seat_list": "primero: 1, último: 103\n",
    "route_backup": "ruta: Kallao, respaldo: Callao\n",
    "grade_histogram": "7: 1\n11: 1\n14: 2\n20: 2\n",
    "passing_groups": "grupos que llegan a 30: 1\n",
}


@unittest.skipUnless((SOURCE / "hunt").exists(), f"no está {LAB_DIR}/hunt")
class Hunt(LabTest):
    def check_with_sanitizers(self, name):
        source = (SOURCE / "hunt" / f"{name}.c").read_text(encoding="utf-8")
        out, code = compile_and_run(source, [])
        if code != 0 or "ERROR:" in out or "runtime error" in out:
            self.fail(f"{name}.c aún tiene un error:\n{short_report(out)}")
        self.same(out, HUNT_OUTPUT[name], f"lo que escribe {name}.c")

    def check_with_valgrind(self, name):
        with tempfile.TemporaryDirectory() as folder:
            binary = pathlib.Path(folder) / name
            subprocess.run(
                ["gcc", *VALGRIND_FLAGS, str(SOURCE / "hunt" / f"{name}.c"), "-o", str(binary)],
                check=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
            )
            done = subprocess.run(
                ["valgrind", "-q", "--leak-check=full", "--error-exitcode=9", str(binary)],
                text=True, encoding="utf-8", stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
                timeout=60,
            )
        if done.returncode != 0:
            lines = [line for line in done.stdout.splitlines() if "==" in line][:6]
            self.fail(f"valgrind todavía reporta errores en {name}.c:\n" + "\n".join(lines))

    def test_longest_word(self):
        self.check_with_sanitizers("longest_word")
        self.check_with_valgrind("longest_word")

    def test_seat_list(self):
        self.check_with_sanitizers("seat_list")
        self.check_with_valgrind("seat_list")

    def test_route_backup(self):
        self.check_with_sanitizers("route_backup")
        self.check_with_valgrind("route_backup")

    def test_grade_histogram(self):
        self.check_with_sanitizers("grade_histogram")
        self.check_with_valgrind("grade_histogram")

    def test_passing_groups(self):
        self.check_with_sanitizers("passing_groups")
        self.check_with_valgrind("passing_groups")


def array_main(body):
    return ('#include <stdio.h>\n#include "int_array.h"\n'
            "int main(void) {\n" + body + "\nreturn 0;\n}\n")


@unittest.skipUnless((SOURCE / "int_array.c").exists(), f"no está {LAB_DIR}/int_array.c")
class GrowingArray(LabTest):
    def read(self, content, context):
        body = ('struct int_array *a = int_array_read_file("in.txt");\n'
                'if (a == NULL) { printf("NULL\\n"); return 0; }\n'
                'printf("%zu", a->count);\n'
                'for (size_t i = 0; i < a->count; i++) { printf(" %d", a->items[i]); }\n'
                'printf("\\n");\nint_array_free(a);')
        return self.run_clean(array_main(body), [SOURCE / "int_array.c"],
                              {"in.txt": content}, context=context).strip()

    def test_new_is_empty(self):
        body = ("struct int_array *a = int_array_new();\n"
                "if (a == NULL) { return 1; }\n"
                'printf("%zu\\n", a->count);\nint_array_free(a);')
        out = self.run_clean(array_main(body), [SOURCE / "int_array.c"], context="int_array_new")
        self.same(out.strip(), "0", "un arreglo nuevo tiene count en 0")

    def test_free_accepts_null(self):
        self.run_clean(array_main("int_array_free(NULL);"), [SOURCE / "int_array.c"],
                       context="int_array_free(NULL)")

    def test_push_keeps_everything(self):
        body = ("struct int_array *a = int_array_new();\n"
                "if (a == NULL) { return 1; }\n"
                "for (int i = 0; i < 1000; i++) { if (!int_array_push(a, i * 3)) { return 2; } }\n"
                "long sum = 0;\n"
                "for (size_t i = 0; i < a->count; i++) {\n"
                "    if (a->items[i] != (int) i * 3) { return 3; }\n"
                "    sum += a->items[i];\n}\n"
                'printf("%zu %ld\\n", a->count, sum);\nint_array_free(a);')
        out = self.run_clean(array_main(body), [SOURCE / "int_array.c"], context="1000 int_array_push")
        self.same(out.strip(), "1000 1498500", "count y suma después de 1000 int_array_push")

    def test_capacity_doubles(self):
        source = FAILING_ALLOCATOR + array_main(
            "struct int_array *a = int_array_new();\n"
            "if (a == NULL) { return 1; }\n"
            "calls = 0;\n"
            "for (int i = 0; i < 10000; i++) { if (!int_array_push(a, i)) { return 2; } }\n"
            'printf("%d\\n", calls);\nint_array_free(a);')
        out = self.run_clean(source, [SOURCE / "int_array.c"], extra=WRAP, context="10000 int_array_push")
        calls = int(out.strip())
        if calls > 20:
            self.fail(f"10000 int_array_push hicieron {calls} reservas. "
                      "Si la capacidad se duplica, bastan unas 15.")

    def test_push_without_memory_keeps_the_data(self):
        source = FAILING_ALLOCATOR + array_main(
            "for (fail_at = 1; ; fail_at++) {\n"
            "    calls = 0;\n"
            "    struct int_array *a = int_array_new();\n"
            "    int pushed = 0;\n"
            "    if (a != NULL) {\n"
            "        for (int i = 0; i < 100; i++) {\n"
            "            size_t before = a->count;\n"
            "            if (int_array_push(a, i)) { pushed++; }\n"
            '            else if (a->count != before) { printf("cambió count\\n"); return 3; }\n'
            "        }\n"
            "        for (int i = 0; i < pushed; i++) {\n"
            '            if (a->items[i] < 0) { printf("dato perdido\\n"); return 3; }\n'
            "        }\n"
            "    }\n"
            "    int_array_free(a);\n"
            "    if (calls < fail_at) { break; }\n"
            "}\n"
            'printf("listo\\n");')
        out = self.run_clean(source, [SOURCE / "int_array.c"], extra=WRAP,
                             context="int_array_push cuando realloc devuelve NULL")
        self.assertIn("listo", out)

    def test_read_small_file(self):
        self.same(self.read("12\n-5\n40\n", "tres líneas"), "3 12 -5 40", "archivo de tres líneas")

    def test_read_last_line_without_newline(self):
        self.same(self.read("1\n2", "sin salto al final"), "2 1 2", "archivo sin salto de línea al final")

    def test_read_empty_file(self):
        self.same(self.read("", "archivo vacío"), "0", "un archivo vacío da un arreglo vacío")

    def test_read_long_file(self):
        values = [i * 2 - 50000 for i in range(50000)]
        content = "".join(f"{v}\n" for v in values)
        expected = " ".join(map(str, [len(values), *values]))
        if self.read(content, "50000 líneas") != expected:
            self.fail("El archivo de 50000 líneas no se leyó bien.")

    def test_read_bad_files_release_everything(self):
        cases = {
            "una letra": "1\nx\n3\n",
            "dos números en una línea": "1\n2 3\n",
            "un número y algo más": "4 hola\n",
            "una línea vacía": "1\n\n2\n",
            "muchas líneas y luego una mala": "1\n" * 500 + "mal\n",
        }
        for label, content in cases.items():
            with self.subTest(label):
                self.same(self.read(content, label), "NULL", f"{label}: debe devolver NULL")

    def test_read_closes_the_file(self):
        body = ("for (int i = 0; i < 100; i++) {\n"
                '    struct int_array *good = int_array_read_file("good.txt");\n'
                '    if (good == NULL) { printf("falló la lectura %d\\n", i); return 1; }\n'
                "    int_array_free(good);\n"
                '    int_array_free(int_array_read_file("bad.txt"));\n'
                "}")
        self.run_clean(array_main(body), [SOURCE / "int_array.c"],
                       {"good.txt": "1\n2\n", "bad.txt": "1\nmal\n"},
                       context="100 lecturas seguidas: ¿se cierra el archivo en todos los caminos?",
                       setup=limit_open_files)

    def test_read_missing_file(self):
        body = 'printf("%s\\n", int_array_read_file("no_existe.txt") == NULL ? "NULL" : "otra");'
        out = self.run_clean(array_main(body), [SOURCE / "int_array.c"], context="archivo que no existe")
        self.same(out.strip(), "NULL", "un archivo que no existe debe dar NULL")

    def test_read_without_memory_releases_everything(self):
        source = FAILING_ALLOCATOR + array_main(
            "int nulls = 0;\n"
            "for (fail_at = 1; ; fail_at++) {\n"
            "    calls = 0;\n"
            '    struct int_array *a = int_array_read_file("in.txt");\n'
            "    if (a == NULL) { nulls++; }\n"
            "    int_array_free(a);\n"
            "    if (calls < fail_at) { break; }\n"
            "}\n"
            'printf("%d\\n", nulls);')
        content = "".join(f"{i}\n" for i in range(100))
        out = self.run_clean(source, [SOURCE / "int_array.c"], {"in.txt": content}, WRAP,
                             context="int_array_read_file cuando no hay memoria")
        if int(out.strip().splitlines()[-1]) < 1:
            self.fail("int_array_read_file debe devolver NULL cuando no hay memoria.")

    def test_sum_file(self):
        source = (HERE / "lab" / "sum_file.c").read_text(encoding="utf-8")
        out, code = compile_and_run(source, [SOURCE / "int_array.c"], {"in.txt": "5\n-2\n10\n"},
                                    stdin="in.txt\n")
        if code != 0:
            self.fail(f"sum_file falló:\n{short_report(out)}")
        self.same(out.strip(), "3 enteros, suma 13", "lo que escribe sum_file")


class YourTests(LabTest):
    """Comprueba que sus archivos de prueba cubren lo pedido y que pasan."""
    CASES = {
        "image_tests.c": (["image_new", "image_free", "image_load"], ["image.c"]),
        "str_tests.c": (["str_duplicate", "str_concat"], ["str_tools.c"]),
        "array_tests.c": (["int_array_push", "int_array_read_file"], ["int_array.c"]),
    }

    def check(self, file_name):
        path = SOURCE / file_name
        if not path.exists():
            self.skipTest(f"no está {LAB_DIR}/{file_name}")
        names, others = self.CASES[file_name]
        text = re.sub(r"//[^\n]*", "", path.read_text(encoding="utf-8"))
        for name in names:
            self.assertRegex(text, rf"\b{name}\(", f"{file_name} no prueba {name}")
        with tempfile.TemporaryDirectory() as folder:
            binary = pathlib.Path(folder) / "tests"
            built = subprocess.run(
                ["gcc", *FLAGS, f"-I{HEADERS}", str(path), *[str(SOURCE / o) for o in others],
                 "-o", str(binary)],
                text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
            )
            if built.returncode != 0:
                self.fail(f"{file_name} no compila:\n{built.stdout}")
            done = subprocess.run(
                [str(binary)], cwd=HERE, text=True, encoding="utf-8",
                stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=60,
            )
        if done.returncode != 0:
            self.fail(f"{file_name} falla:\n{short_report(done.stdout)}")

    def test_image_tests(self):
        self.check("image_tests.c")

    def test_str_tests(self):
        self.check("str_tests.c")

    def test_array_tests(self):
        self.check("array_tests.c")


if __name__ == "__main__":
    unittest.main()