// Un programa escrito como en C. g++ lo compila sin cambiar casi nada.
#include <cstdio>

struct point {
    int x;
    int y;
};

int manhattan(const point *p) {
    int dx = p->x < 0 ? -p->x : p->x;
    int dy = p->y < 0 ? -p->y : p->y;
    return dx + dy;
}

int main() {
    point origin = {0, 0};
    point target = {3, -4};
    int values[] = {manhattan(&origin), manhattan(&target)};
    for (int i = 0; i < 2; i++) {
        std::printf("%d\n", values[i]);
    }
    return 0;
}

// Las formas de const con punteros y referencias. Se leen de derecha a izquierda.
#include <cstddef>
#include <iostream>
#include <string>

std::size_t count_letter(const std::string& text, char letter) {
    std::size_t found = 0;
    for (char c : text) {
        if (c == letter) {
            found++;
        }
    }
    return found;
}

int main() {
    int a = 1;
    int b = 2;
    const int *to_const = &a;    // no se puede escribir *to_const
    to_const = &b;               // sí se puede cambiar el puntero
    int *const fixed = &a;       // no se puede cambiar el puntero
    *fixed = 5;                  // sí se puede escribir a través de él
    const int& view = a;         // no se puede escribir a través de view
    a = 7;                       // a sí cambia, y view lo ve
    std::cout << *to_const << " " << *fixed << " " << view << "\n";

    // Una literal crea una std::string temporal; const& se puede atar a ella.
    std::cout << count_letter("banana", 'a') << "\n";
    return 0;
}

// const protege los campos del objeto, no lo que hay al otro lado de un puntero.
#include <iostream>

class Remote {
public:
    explicit Remote(int *target) : target_(target) {}

    // Compila: no cambia target_, solo el entero al que apunta.
    void reset() const {
        *target_ = 0;
    }

private:
    int *target_;
};

int main() {
    int counter = 5;
    const Remote remote(&counter);
    remote.reset();
    std::cout << counter << "\n";
    return 0;
}

// Suma n elementos llamando a una función en cada vuelta. Uso: copy_in_loop n copy|ref
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>

#include "value_at.h"

int main(int argc, char *argv[]) {
    if (argc != 3) {
        std::cerr << "uso: copy_in_loop n copy|ref\n";
        return 1;
    }
    std::size_t n = std::strtoul(argv[1], nullptr, 10);
    std::string mode = argv[2];
    std::vector<int> values(n, 1);

    long long sum = 0;
    long long copied = 0;
    for (std::size_t i = 0; i < n; i++) {
        if (mode == "copy") {
            sum += value_at_copy(values, i);
            copied += values.size();
        } else {
            sum += value_at_ref(values, i);
        }
    }
    std::cout << "suma = " << sum << ", elementos copiados = " << copied << "\n";
    return 0;
}

// ¿Pasar un std::vector crea otro bloque? Se comprueba comparando direcciones.
#include <iostream>
#include <vector>

void by_value(std::vector<int> values, const int *original) {
    values[0] = 99;
    std::cout << "por valor:      mismo bloque = " << (values.data() == original)
              << ", values[0] = " << values[0] << "\n";
}

void by_const_reference(const std::vector<int>& values, const int *original) {
    std::cout << "por const&:     mismo bloque = " << (values.data() == original)
              << ", values[0] = " << values[0] << "\n";
}

void by_reference(std::vector<int>& values, const int *original) {
    values[0] = 99;
    std::cout << "por referencia: mismo bloque = " << (values.data() == original)
              << ", values[0] = " << values[0] << "\n";
}

int main() {
    std::vector<int> numbers = {1, 2, 3};
    const int *block = numbers.data();

    by_value(numbers, block);
    std::cout << "en main:        numbers[0] = " << numbers[0] << "\n";

    by_const_reference(numbers, block);
    std::cout << "en main:        numbers[0] = " << numbers[0] << "\n";

    by_reference(numbers, block);
    std::cout << "en main:        numbers[0] = " << numbers[0] << "\n";
    return 0;
}

// Una clase con constructor, campos privados, métodos const y una referencia devuelta.
#include <cassert>
#include <iostream>
#include <string>

class Course {
public:
    Course(const std::string& name, int credits) : name_(name), credits_(credits) {
        assert(credits > 0);
    }

    void enroll() {
        enrolled_++;
    }

    int enrolled() const {
        return enrolled_;
    }

    int credits() const {
        return credits_;
    }

    // Devuelve el nombre sin copiarlo. La referencia es del objeto y vive lo que él.
    const std::string& name() const {
        return name_;
    }

    // private es por clase: este método puede ver los campos de other.
    bool same_credits_as(const Course& other) const {
        return credits_ == other.credits_;
    }

private:
    std::string name_;
    int credits_;
    int enrolled_ = 0;
};

void print_summary(const Course& course) {
    std::cout << course.name() << ": " << course.credits() << " créditos, "
              << course.enrolled() << " matriculados\n";
}

int main() {
    Course data("Estructuras de Datos", 4);
    Course math("Matemática Discreta", 4);
    data.enroll();
    data.enroll();
    print_summary(data);
    print_summary(math);
    std::cout << "mismos créditos: " << data.same_credits_as(math) << "\n";
    return 0;
}

// Primer programa en C++: lo mismo que un printf, con std::cout.
#include <iostream>

int main() {
    int students = 32;
    std::cout << "Hola, Estructuras de Datos\n";
    std::cout << "Somos " << students << " estudiantes\n";
    return 0;
}

// Busca los n códigos de una lista de n estudiantes y cuenta las comparaciones.
// Uso: lookup n linear|binary
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>

// Devuelve el índice de code, o -1. Suma a comparisons cada elemento que mira.
long long linear_search(const std::vector<int>& codes, int code, long long& comparisons) {
    long long size = static_cast<long long>(codes.size());
    for (long long i = 0; i < size; i++) {
        comparisons++;
        if (codes[i] == code) {
            return i;
        }
    }
    return -1;
}

// Igual, pero exige que codes esté ordenado.
long long binary_search(const std::vector<int>& codes, int code, long long& comparisons) {
    long long low = 0;
    long long high = static_cast<long long>(codes.size()) - 1;
    while (low <= high) {
        long long middle = low + (high - low) / 2;
        comparisons++;
        if (codes[middle] == code) {
            return middle;
        }
        if (codes[middle] < code) {
            low = middle + 1;
        } else {
            high = middle - 1;
        }
    }
    return -1;
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        std::cerr << "uso: lookup n linear|binary\n";
        return 1;
    }
    int n = std::atoi(argv[1]);
    std::string mode = argv[2];

    std::vector<int> codes;
    for (int i = 0; i < n; i++) {
        codes.push_back(2 * i);
    }

    long long comparisons = 0;
    long long found = 0;
    for (int code : codes) {
        long long index = mode == "linear" ? linear_search(codes, code, comparisons)
                                           : binary_search(codes, code, comparisons);
        if (index >= 0) {
            found++;
        }
    }
    std::cout << "n = " << n << ", encontrados = " << found
              << ", comparaciones = " << comparisons << "\n";
    return 0;
}

"""Mide los programas de la semana: mediana de 5 corridas, compilados con -O2 y sin
sanitizers. Los tiempos dependen de la máquina; lo que importa es cómo crecen."""
import statistics
import subprocess
import time

REPETITIONS = 5


def median_seconds(command):
    times = []
    for _ in range(REPETITIONS):
        start = time.perf_counter()
        subprocess.run(command, check=True, stdout=subprocess.DEVNULL)
        times.append(time.perf_counter() - start)
    return statistics.median(times)


def table(title, program, mode, sizes):
    print(title)
    previous = None
    for n in sizes:
        seconds = median_seconds([program, str(n), mode])
        growth = "" if previous is None else f"  x{seconds / previous:.1f}"
        print(f"{n:>10} {seconds:>9.3f} s{growth}")
        previous = seconds


table("Búsqueda lineal", "build/fast/lookup", "linear", [10000, 20000, 40000, 80000])
table("Búsqueda binaria", "build/fast/lookup", "binary", [5000000, 10000000, 20000000])
table("Por copia", "build/fast/copy_in_loop", "copy", [20000, 40000, 80000])
table("Por referencia constante", "build/fast/copy_in_loop", "ref", [20000, 40000, 80000])
table("Por referencia constante, n mucho mayor", "build/fast/copy_in_loop", "ref",
      [10000000, 20000000, 40000000])

// Dos funciones con el mismo nombre, cada una en su namespace.
#include <iostream>

namespace circle {
double area(double radius) {
    return 3.14159 * radius * radius;
}
}  // namespace circle

namespace square {
double area(double side) {
    return side * side;
}
}  // namespace square

int main() {
    std::cout << circle::area(2.0) << "\n";
    std::cout << square::area(2.0) << "\n";
    return 0;
}

// for por rango con copia, con referencia y con auto.
#include <iostream>
#include <string>
#include <vector>

int main() {
    std::vector<int> grades = {10, 15};

    // x es una copia de cada elemento.
    for (int x : grades) {
        x = x + 1;
        std::cout << x << " ";
    }
    std::cout << "/ " << grades[0] << " " << grades[1] << "\n";

    // x es otro nombre del elemento.
    for (int& x : grades) {
        x = x + 1;
    }
    std::cout << grades[0] << " " << grades[1] << "\n";

    std::vector<std::string> names = {"Ana", "Luis"};
    for (const std::string& name : names) {
        std::cout << name << " ";
    }
    std::cout << "\n";

    // auto deduce el tipo; sin & sigue siendo una copia.
    for (auto name : names) {
        name += "!";
    }
    std::cout << names[0] << "\n";
    for (auto& name : names) {
        name += "!";
    }
    std::cout << names[0] << "\n";

    auto size = names.size();
    const auto& first = names[0];
    std::cout << size << " " << first << "\n";
    return 0;
}

// Una referencia es otro nombre para un objeto que ya existe.
#include <iostream>

int main() {
    int grade = 14;
    int& alias = grade;

    alias = 15;
    std::cout << "grade = " << grade << "\n";
    std::cout << "misma dirección: " << (&alias == &grade) << "\n";

    // Esto no cambia a quién se refiere alias: copia 20 dentro de grade.
    int other = 20;
    alias = other;
    other = 0;
    std::cout << "grade = " << grade << ", other = " << other << "\n";
    return 0;
}

// Quien usa una clase conoce su tamaño, aunque los campos sean privados.
#include <iostream>

#include "tally.h"

int main() {
    Tally local;
    local.add(4);
    std::cout << "sizeof(Tally) = " << sizeof(Tally) << "\n";
    std::cout << "cuenta = " << local.count() << "\n";
    return 0;
}

// Diferencias pequeñas con C: bool, nullptr, static_cast y división entera.
#include <iostream>

bool is_passing(int grade) {
    return grade >= 11;
}

int main() {
    int total = 29;
    int count = 2;
    const int *missing = nullptr;
    std::cout << is_passing(14) << " " << is_passing(9) << "\n";
    std::cout << (missing == nullptr) << "\n";
    std::cout << total / count << "\n";
    std::cout << static_cast<double>(total) / count << "\n";
    return 0;
}

// std::string: lo que en C hacían strlen, strcpy, strcat y strcmp.
#include <cstddef>
#include <cstdio>
#include <iostream>
#include <string>

int main() {
    std::string first = "Ana";
    std::string full = first + " Quispe";
    std::string copy = full;
    copy[0] = 'E';

    std::cout << full << " / " << copy << "\n";
    std::cout << "largo: " << full.size() << "\n";
    std::cout << "iguales: " << (full == copy) << "\n";
    std::cout << "ordenadas: " << (full < copy) << "\n";

    std::size_t space = full.find(' ');
    std::cout << "apellido: " << full.substr(space + 1) << "\n";
    if (full.find('z') == std::string::npos) {
        std::cout << "no hay z\n";
    }

    full += ", sección A";
    std::cout << full << "\n";

    // Para una función de C que pide const char *.
    std::printf("%s\n", first.c_str());
    return 0;
}

// El mismo intercambio con punteros, como en C, y con referencias.
#include <iostream>

void swap_pointer(int *a, int *b) {
    int saved = *a;
    *a = *b;
    *b = saved;
}

void swap_reference(int& a, int& b) {
    int saved = a;
    a = b;
    b = saved;
}

int main() {
    int x = 1;
    int y = 2;
    swap_pointer(&x, &y);
    std::cout << x << " " << y << "\n";
    swap_reference(x, y);
    std::cout << x << " " << y << "\n";
    return 0;
}

// Uso de la clase: no hay puntero, no se revisa memoria y no se libera a mano.
#include <iostream>

#include "tally.h"

int main() {
    Tally tally;
    tally.add(14);
    tally.add(9);
    tally.add(17);
    std::cout << tally.count() << " valores, suma " << tally.sum() << ", mayor " << tally.max() << "\n";
    return 0;
}

#include "tally.h"

#include <cassert>

void Tally::add(int value) {
    values_.push_back(value);
}

std::size_t Tally::count() const {
    return values_.size();
}

int Tally::sum() const {
    int total = 0;
    for (int value : values_) {
        total += value;
    }
    return total;
}

int Tally::max() const {
    assert(!values_.empty());
    int largest = values_[0];
    for (int value : values_) {
        if (value > largest) {
            largest = value;
        }
    }
    return largest;
}

// Clase Tally: acumula enteros y responde cuántos son, cuánto suman y cuál es el mayor.
#ifndef TALLY_H
#define TALLY_H

#include <cstddef>
#include <vector>

class Tally {
public:
    // Agrega un valor.
    void add(int value);

    // Devuelve cuántos valores se agregaron.
    std::size_t count() const;

    // Devuelve la suma de los valores. Con cero valores, es 0.
    int sum() const;

    // Devuelve el mayor valor. Exige: count() > 0.
    int max() const;

private:
    std::vector<int> values_;
};

#endif

#include "value_at.h"

int value_at_copy(std::vector<int> values, std::size_t index) {
    return values[index];
}

int value_at_ref(const std::vector<int>& values, std::size_t index) {
    return values[index];
}

// Dos formas de leer un elemento. Están en otro archivo para que el compilador no
// pueda quitar la copia al optimizar.
#ifndef VALUE_AT_H
#define VALUE_AT_H

#include <cstddef>
#include <vector>

int value_at_copy(std::vector<int> values, std::size_t index);
int value_at_ref(const std::vector<int>& values, std::size_t index);

#endif

// std::vector: lo que en C era un arreglo con malloc y realloc.
#include <iostream>
#include <string>
#include <vector>

struct Score {
    std::string name;
    int points;
};

int main() {
    std::vector<int> grades;
    grades.push_back(14);
    grades.push_back(9);
    grades.push_back(17);
    std::cout << "tamaño: " << grades.size() << "\n";
    std::cout << "último: " << grades.back() << "\n";

    grades[1] = 11;
    grades.erase(grades.begin());
    std::cout << "primero tras borrar: " << grades[0] << "\n";

    std::vector<int> zeros(3, 0);
    std::vector<int> primes = {2, 3, 5};
    std::vector<int> other = primes;
    other[0] = 7;
    std::cout << primes[0] << " " << other[0] << "\n";
    std::cout << "iguales: " << (primes == other) << "\n";
    std::cout << "ceros: " << zeros.size() << ", vacío: " << zeros.empty() << "\n";

    std::vector<Score> table;
    table.push_back({"Ana", 18});
    table.push_back({"Luis", 12});
    std::cout << table[1].name << " tiene " << table[1].points << "\n";

    grades.clear();
    std::cout << "tras clear: " << grades.size() << "\n";
    return 0;
}

// Uso del módulo en C: quien lo usa crea, revisa y libera.
#include <stdio.h>

#include "tally.h"

int main(void) {
    Tally *tally = tally_new();
    if (tally == NULL) {
        return 1;
    }
    int ok = tally_add(tally, 14) && tally_add(tally, 9) && tally_add(tally, 17);
    if (!ok) {
        tally_free(tally);
        return 1;
    }
    printf("%d valores, suma %d, mayor %d\n", tally_count(tally), tally_sum(tally), tally_max(tally));
    tally_free(tally);
    return 0;
}

// Implementación con un arreglo que crece: guarda todos los valores.
#include "tally.h"

#include <assert.h>
#include <stdlib.h>

struct tally {
    int *values;
    int count;
    int capacity;
};

Tally *tally_new(void) {
    Tally *tally = malloc(sizeof *tally);
    if (tally == NULL) {
        return NULL;
    }
    tally->values = NULL;
    tally->count = 0;
    tally->capacity = 0;
    return tally;
}

void tally_free(Tally *tally) {
    if (tally == NULL) {
        return;
    }
    free(tally->values);
    free(tally);
}

int tally_add(Tally *tally, int value) {
    if (tally->count == tally->capacity) {
        int capacity = tally->capacity == 0 ? 4 : 2 * tally->capacity;
        int *values = realloc(tally->values, capacity * sizeof *values);
        if (values == NULL) {
            return 0;
        }
        tally->values = values;
        tally->capacity = capacity;
    }
    tally->values[tally->count] = value;
    tally->count++;
    return 1;
}

int tally_count(const Tally *tally) {
    return tally->count;
}

int tally_sum(const Tally *tally) {
    int sum = 0;
    for (int i = 0; i < tally->count; i++) {
        sum += tally->values[i];
    }
    return sum;
}

int tally_max(const Tally *tally) {
    assert(tally->count > 0);
    int largest = tally->values[0];
    for (int i = 1; i < tally->count; i++) {
        if (tally->values[i] > largest) {
            largest = tally->values[i];
        }
    }
    return largest;
}

// Módulo Tally: acumula enteros y responde cuántos son, cuánto suman y cuál es el mayor.
// Es un tipo opaco: quien lo usa solo tiene punteros y solo llama a estas funciones.
#ifndef TALLY_H
#define TALLY_H

typedef struct tally Tally;

// Crea un acumulador vacío. Devuelve NULL si no hay memoria.
// Owner: quien llama, que debe liberarlo con tally_free.
Tally *tally_new(void);

// Libera el acumulador. Acepta NULL. Después de esto, tally ya no se puede usar.
void tally_free(Tally *tally);

// Agrega un valor. Devuelve 1 si pudo y 0 si no hay memoria; en ese caso, no cambia nada.
int tally_add(Tally *tally, int value);

// Devuelve cuántos valores se agregaron.
int tally_count(const Tally *tally);

// Devuelve la suma de los valores. Con cero valores, es 0.
int tally_sum(const Tally *tally);

// Devuelve el mayor valor. Exige: tally_count(tally) > 0.
int tally_max(const Tally *tally);

#endif

// Con NDEBUG, assert desaparece, y con él lo que hacía adentro.
#include <cassert>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> values = {1, 2, 3};
    values.pop_back();
    assert((values.push_back(9), values.size() == 3));
    std::cout << values.size() << "\n";
    return 0;
}

// Un método const no puede modificar un campo.
class Counter {
public:
    int next() const {
        value_++;
        return value_;
    }

private:
    int value_ = 0;
};

int main() {
    Counter counter;
    return counter.next();
}

// A un objeto const solo se le pueden pedir métodos const.
#include "../tally.h"

int total_after_add(const Tally& tally) {
    tally.add(1);
    return tally.sum();
}

int main() {
    Tally tally;
    return total_after_add(tally);
}

// Una referencia constante no permite escribir.
void reset(const int& value) {
    value = 0;
}

int main() {
    int grade = 14;
    reset(grade);
    return grade;
}

// Los campos se inicializan en el orden en que están declarados, no en el de la lista.
#include <iostream>

class Range {
public:
    explicit Range(int width) : high_(low_ + width), low_(0) {}

    int high() const {
        return high_;
    }

private:
    int low_;
    int high_;
};

int main() {
    Range range(5);
    std::cout << range.high() << "\n";
    return 0;
}

// Sin & en el for por rango, se modifica una copia.
#include <iostream>
#include <vector>

struct Score {
    int points;
};

int main() {
    std::vector<Score> table = {{10}, {15}};
    for (auto score : table) {
        score.points += 1;
    }
    std::cout << table[0].points << " " << table[1].points << "\n";
    return 0;
}

// Válido en C, no en C++: class es una palabra reservada.
int main() {
    int class = 3;
    return class;
}

// En C++, void * no se convierte solo a otro tipo de puntero.
#include <cstdlib>

int main() {
    int *block = std::malloc(4 * sizeof *block);
    std::free(block);
    return 0;
}

// Al declarar un constructor, el compilador ya no genera el que no recibe nada.
class Range {
public:
    Range(int low, int high) : low_(low), high_(high) {}

    int width() const {
        return high_ - low_;
    }

private:
    int low_;
    int high_;
};

int main() {
    Range range;
    return range.width();
}

// Quien usa la clase no puede tocar sus campos privados.
#include "../tally.h"

int main() {
    Tally tally;
    tally.values_.clear();
    return 0;
}

// Una referencia sin const no se ata a un valor temporal.
#include <cstddef>
#include <string>

std::size_t length(std::string& text) {
    return text.size();
}

int main() {
    return static_cast<int>(length("hola"));
}

// Una referencia debe atarse a un objeto al crearse.
int main() {
    int& alias;
    return 0;
}

// Referencia colgante: la local muere al retornar.
#include <iostream>

int& next_code(int code) {
    int result = code + 1;
    return result;
}

int main() {
    int& code = next_code(10);
    std::cout << code << "\n";
    return 0;
}

// size() no tiene signo: comparar con int da una advertencia.
#include <iostream>
#include <vector>

int main() {
    std::vector<int> values = {1, 2, 3};
    for (int i = 0; i < values.size(); i++) {
        std::cout << values[i] << "\n";
    }
    return 0;
}

// size() - 1 con un vector vacío da un número enorme, no -1.
#include <iostream>
#include <vector>

int main() {
    std::vector<int> empty;
    std::cout << empty.size() - 1 << "\n";
    return 0;
}

// Con using namespace std, un nombre propio choca con uno de la biblioteca.
#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

int count = 0;

int main() {
    vector<int> values = {1, 2, 3};
    for (int value : values) {
        count += value;
    }
    cout << count << "\n";
    return 0;
}

// at revisa el índice.
#include <iostream>
#include <vector>

int main() {
    std::vector<int> values = {1, 2, 3};
    std::cout << values.at(3) << "\n";
    return 0;
}

// operator[] no revisa el índice.
#include <iostream>
#include <vector>

int main() {
    std::vector<int> values = {1, 2, 3};
    std::cout << values[3] << "\n";
    return 0;
}

// Fuera de size(), pero dentro del bloque: ASan no lo ve.
#include <iostream>
#include <vector>

int main() {
    std::vector<int> values;
    values.reserve(8);
    values.push_back(1);
    values[5] = 42;
    std::cout << "size = " << values.size() << ", values[5] = " << values[5] << "\n";
    return 0;
}

// Con paréntesis vacíos, esto declara una función, no un objeto.
#include "../tally.h"

int main() {
    Tally tally();
    tally.add(1);
    return 0;
}

// Pruebas de Tally: casos dirigidos y operaciones al azar con semilla fija.
#include <algorithm>
#include <cassert>
#include <iostream>
#include <numeric>
#include <random>
#include <vector>

#include "tally.h"

void test_starts_empty() {
    Tally tally;
    assert(tally.count() == 0);
    assert(tally.sum() == 0);
}

void test_one_value() {
    Tally tally;
    tally.add(-3);
    assert(tally.count() == 1);
    assert(tally.sum() == -3);
    assert(tally.max() == -3);
}

void test_read_through_const_reference(const Tally& tally) {
    assert(tally.count() == 3);
    assert(tally.max() == 17);
}

void test_several_values() {
    Tally tally;
    tally.add(14);
    tally.add(9);
    tally.add(17);
    assert(tally.sum() == 40);
    test_read_through_const_reference(tally);
}

// Compara contra un std::vector, que hace de referencia.
void test_against_reference() {
    std::mt19937 random(2026);
    Tally tally;
    std::vector<int> reference;
    for (int step = 0; step < 2000; step++) {
        int value = static_cast<int>(random() % 201) - 100;
        tally.add(value);
        reference.push_back(value);
        assert(tally.count() == reference.size());
        assert(tally.sum() == std::accumulate(reference.begin(), reference.end(), 0));
        assert(tally.max() == *std::max_element(reference.begin(), reference.end()));
    }
}

int main() {
    test_starts_empty();
    test_one_value();
    test_several_values();
    test_against_reference();
    std::cout << "tally: todas las pruebas pasaron\n";
    return 0;
}

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

HERE = pathlib.Path(__file__).parent
BUILD = HERE / "build"
CXX = ["g++", "-Wall", "-Wextra", "-std=c++20", "-g", "-fsanitize=address,undefined"]
C_MODULE = HERE / "lab" / "c"

# Programa de errors/ que no compila, y parte del mensaje de g++.
COMPILE_ERRORS = {
    "malloc_no_cast": "invalid conversion from 'void*' to 'int*'",
    "keyword_name": "expected primary-expression before 'int'",
    "using_std_collision": "reference to 'count' is ambiguous",
    "ref_uninitialized": "'alias' declared as reference but not initialized",
    "ref_to_temporary": "cannot bind non-const lvalue reference",
    "const_ref_write": "assignment of read-only reference 'value'",
    "private_access": "is private within this context",
    "const_method_writes": "increment of member 'Counter::value_' in read-only object",
    "const_object_call": "discards qualifiers",
    "no_default_ctor": "no matching function for call to 'Range::Range()'",
    "vexing_parse": "which is of non-class type 'Tally()'",
}
# Programa de errors/ que compila con una advertencia, y su opción.
WARNINGS = {
    "return_local_ref": "-Wreturn-local-addr",
    "init_order": "-Wreorder",
    "sign_compare": "-Wsign-compare",
}
# Programa de errors/ que falla al correr, y lo que debe decir.
RUNTIME_ERRORS = {
    "vector_index": "heap-buffer-overflow",
    "vector_at": "std::out_of_range",
}


def compile_error(name):
    done = subprocess.run(CXX + ["-I.", "-c", f"errors/{name}.cpp", "-o", "/dev/null"], cwd=HERE, text=True,
                          stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=120)
    return done.returncode, done.stdout.replace("‘", "'").replace("’", "'")


class Programs(unittest.TestCase):
    def output(self, name, *args):
        done = subprocess.run([str(BUILD / name), *args], cwd=HERE, text=True, capture_output=True, timeout=60)
        self.assertEqual(done.returncode, 0, done.stderr)
        return done.stdout

    def test_every_program_builds_without_warnings(self):
        with tempfile.TemporaryDirectory() as temp:
            for source in sorted(HERE.glob("*.cpp")):
                done = subprocess.run(CXX + ["-c", str(source), "-o", f"{temp}/program.o"], cwd=HERE, text=True,
                                      capture_output=True, timeout=120)
                with self.subTest(source=source.name):
                    self.assertEqual((done.returncode, done.stderr), (0, ""))

    def test_tally_tests_pass(self):
        self.assertIn("todas las pruebas pasaron", self.output("tally_tests"))

    def test_both_tallies_say_the_same(self):
        self.assertEqual(self.output("tally_demo"), self.output("tally_c_demo"))

    def test_lookup_counts(self):
        # Lineal: 1 + 2 + ... + n exactamente.
        for n in (1, 10, 1000):
            text = self.output("lookup", str(n), "linear")
            self.assertIn(f"comparaciones = {n * (n + 1) // 2}", text)
        # Binaria: como mucho floor(log2(n)) + 1 por búsqueda.
        text = self.output("lookup", "1000", "binary")
        count = int(re.search(r"comparaciones = (\d+)", text).group(1))
        self.assertLessEqual(count, 1000 * 10)

    def test_copy_counts(self):
        self.assertIn("elementos copiados = 1000000", self.output("copy_in_loop", "1000", "copy"))
        self.assertIn("elementos copiados = 0", self.output("copy_in_loop", "1000", "ref"))

    def test_only_by_value_makes_another_block(self):
        lines = self.output("copy_or_not").splitlines()
        self.assertIn("mismo bloque = 0", lines[0])
        self.assertIn("mismo bloque = 1", lines[2])
        self.assertIn("mismo bloque = 1", lines[4])


class DeliberateErrors(unittest.TestCase):
    def test_compile_errors(self):
        for name, message in COMPILE_ERRORS.items():
            with self.subTest(program=name):
                code, text = compile_error(name)
                self.assertNotEqual(code, 0)
                self.assertIn(message, text)

    def test_warnings(self):
        for name, option in WARNINGS.items():
            with self.subTest(program=name):
                code, text = compile_error(name)
                self.assertEqual(code, 0)
                self.assertIn(option, text)

    def test_runtime_errors(self):
        with tempfile.TemporaryDirectory() as temp:
            for name, message in RUNTIME_ERRORS.items():
                with self.subTest(program=name):
                    program = f"{temp}/{name}"
                    subprocess.run(CXX + [f"errors/{name}.cpp", "-o", program], cwd=HERE, check=True, timeout=120)
                    done = subprocess.run([program], text=True, capture_output=True, timeout=60)
                    self.assertNotEqual(done.returncode, 0)
                    self.assertIn(message, done.stderr)


class GivenCModule(unittest.TestCase):
    """El módulo en C del laboratorio es de verdad: compila limpio, pasa sus pruebas y no tiene fugas."""

    def test_compiles_and_passes_with_sanitizers(self):
        with tempfile.TemporaryDirectory() as temp:
            program = f"{temp}/tests"
            done = subprocess.run(["gcc", "-Wall", "-Wextra", "-std=c17", "-g", "-fsanitize=address,undefined",
                                   str(C_MODULE / "test_grade_book.c"), str(C_MODULE / "grade_book.c"), "-o", program],
                                  text=True, capture_output=True, timeout=120)
            self.assertEqual((done.returncode, done.stderr), (0, ""))
            run = subprocess.run([program], text=True, capture_output=True, timeout=60)
            self.assertEqual(run.returncode, 0, run.stderr)

    def test_clean_under_valgrind(self):
        with tempfile.TemporaryDirectory() as temp:
            program = f"{temp}/tests"
            subprocess.run(["gcc", "-Wall", "-Wextra", "-std=c17", "-g", "-O0", str(C_MODULE / "test_grade_book.c"),
                            str(C_MODULE / "grade_book.c"), "-o", program], check=True, timeout=120)
            run = subprocess.run(["valgrind", "--leak-check=full", "--error-exitcode=9", program], text=True,
                                 capture_output=True, timeout=120)
            self.assertEqual(run.returncode, 0, run.stderr)
            self.assertIn("All heap blocks were freed", run.stderr)


class SolutionComparison(unittest.TestCase):
    @unittest.skipUnless((HERE / "solution").exists(), "falta la solución")
    def test_numbers_match_the_files(self):
        def lines(path):
            return len((HERE / path).read_text(encoding="utf-8").splitlines())

        text = (HERE / "solution" / "comparison.txt").read_text(encoding="utf-8")
        h_c, c_c = lines("lab/c/grade_book.h"), lines("lab/c/grade_book.c")
        h_cpp, c_cpp = lines("solution/grade_book.h"), lines("solution/grade_book.cpp")
        self.assertIn(f"{h_c + c_c} ({h_c} + {c_c})", text)
        self.assertIn(f"{h_cpp + c_cpp} ({h_cpp} + {c_cpp})", text)


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

"""Pruebas del laboratorio. LAB_DIR dice dónde está la clase: lab o solution.

Cada prueba compila con sanitizers lo que necesita y lo corre: una fuga o un acceso
inválido la hace fallar, aunque el resultado parezca correcto.
"""
import os
import pathlib
import random
import re
import subprocess
import tempfile
import unittest

HERE = pathlib.Path(__file__).parent
LAB_DIR = os.environ.get("LAB_DIR", "solution")
SOURCE = HERE / LAB_DIR
GIVEN = HERE / "lab"
CXX_FLAGS = ["g++", "-Wall", "-Wextra", "-std=c++20", "-g", "-fsanitize=address,undefined"]
C_FLAGS = ["gcc", "-Wall", "-Wextra", "-std=c17", "-g", "-fsanitize=address,undefined"]
# Mínimo de assert en sus pruebas: los 38 del módulo en C que se pueden pasar a la clase,
# más al menos tres de casos borde.
MIN_ASSERTS = 41
# Lo que ya no debe aparecer en la clase.
MANUAL_MEMORY = r"\b(malloc|calloc|realloc|free|strdup|strcpy|strcmp|strlen|new|delete)\b|\bchar\s*\*"


def strip_comments(text):
    return re.sub(r"//[^\n]*", "", text)


def build(command, output):
    done = subprocess.run(command + ["-o", str(output)], cwd=HERE, text=True,
                          stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=120)
    return done.returncode, done.stdout


def run(program, stdin=""):
    return subprocess.run([str(program)], cwd=HERE, input=stdin, text=True,
                          stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=60)


def random_commands(seed, steps):
    """Una secuencia de órdenes con semilla fija, para comparar las dos versiones."""
    generator = random.Random(seed)
    lines = []
    for _ in range(steps):
        name = f"e{generator.randrange(25)}"
        grade = generator.randrange(-2, 23)
        command = generator.choice(["add", "add", "set", "get", "remove", "list"])
        if command in ("add", "set"):
            lines.append(f"{command} {name} {grade}")
        elif command in ("get", "remove"):
            lines.append(f"{command} {name}")
        else:
            lines.append("list")
    return "\n".join(lines) + "\n"


@unittest.skipUnless(SOURCE.exists(), f"no existe {LAB_DIR}/")
class LabCase(unittest.TestCase):
    def setUp(self):
        self.folder = tempfile.TemporaryDirectory()
        self.addCleanup(self.folder.cleanup)
        self.temp = pathlib.Path(self.folder.name)

    def compile_class(self, main_source):
        """Compila main_source con la clase. Falla la prueba si no compila o si da advertencias."""
        program = self.temp / "program"
        code, messages = build(CXX_FLAGS + [f"-I{SOURCE}", str(main_source),
                                            str(SOURCE / "grade_book.cpp")], program)
        self.assertEqual(code, 0, f"no compila:\n{messages}")
        self.assertEqual(messages.strip(), "", "hay advertencias del compilador")
        return program

    def assert_runs(self, program):
        done = run(program)
        self.assertEqual(done.returncode, 0, done.stdout + done.stderr)


class Step1Environment(LabCase):
    def test_hello(self):
        program = self.temp / "hello"
        code, messages = build(CXX_FLAGS + [str(GIVEN / "hello.cpp")], program)
        self.assertEqual((code, messages.strip()), (0, ""))
        self.assertEqual(run(program).stdout, "entorno: ok\ncompilador: ok\nmake: ok\n")


class Step2GivenModule(LabCase):
    def test_c_module_compiles_and_passes(self):
        program = self.temp / "tests_c"
        code, messages = build(C_FLAGS + [str(GIVEN / "c" / "test_grade_book.c"),
                                          str(GIVEN / "c" / "grade_book.c")], program)
        self.assertEqual((code, messages.strip()), (0, ""))
        self.assert_runs(program)


class Step3Port(LabCase):
    def test_public_tests(self):
        self.assert_runs(self.compile_class(GIVEN / "tests" / "public_port.cpp"))

    def test_name_at_checks_its_contract(self):
        source = self.temp / "out_of_range.cpp"
        source.write_text('#include "grade_book.h"\nint main() {\n    GradeBook book;\n'
                          '    return static_cast<int>(book.name_at(0).size());\n}\n')
        done = run(self.compile_class(source))
        self.assertNotEqual(done.returncode, 0, "name_at fuera de rango debe detenerse con assert")

    def test_same_behavior_as_the_c_module(self):
        driver_c = self.temp / "driver_c"
        code, messages = build(C_FLAGS + [str(GIVEN / "c" / "driver.c"),
                                          str(GIVEN / "c" / "grade_book.c")], driver_c)
        self.assertEqual((code, messages.strip()), (0, ""))
        driver = self.compile_class(GIVEN / "tests" / "driver.cpp")
        for seed in (1, 2, 3):
            commands = random_commands(seed, 2000)
            expected = run(driver_c, commands)
            actual = run(driver, commands)
            self.assertEqual(expected.returncode, 0, expected.stderr)
            self.assertEqual(actual.returncode, 0, actual.stderr)
            self.assertEqual(actual.stdout, expected.stdout, f"semilla {seed}")

    def test_no_manual_memory(self):
        for name in ("grade_book.h", "grade_book.cpp"):
            text = strip_comments((SOURCE / name).read_text(encoding="utf-8"))
            found = re.search(MANUAL_MEMORY, text)
            self.assertIsNone(found, f"{name}: {found.group(0) if found else ''}")

    def test_uses_string_and_vector(self):
        text = strip_comments((SOURCE / "grade_book.h").read_text(encoding="utf-8"))
        self.assertIn("std::vector", text)
        self.assertNotIn("placeholder_", text)


class Step4OwnTests(LabCase):
    def test_own_tests_pass(self):
        self.assert_runs(self.compile_class(SOURCE / "test_grade_book.cpp"))

    def test_own_tests_cover_the_c_tests_and_more(self):
        text = strip_comments((SOURCE / "test_grade_book.cpp").read_text(encoding="utf-8"))
        count = len(re.findall(r"\bassert\(", text))
        self.assertGreaterEqual(count, MIN_ASSERTS, f"hay {count} assert")


class Step5Stats(LabCase):
    def test_public_tests(self):
        self.assert_runs(self.compile_class(GIVEN / "tests" / "public_stats.cpp"))

    def test_add_is_not_const(self):
        source = self.temp / "const_add.cpp"
        source.write_text('#include "grade_book.h"\nvoid f(const GradeBook& book) { book.add("a", 1); }\n')
        command = CXX_FLAGS + [f"-I{SOURCE}", "-c", str(source)]
        code, _ = build(command, self.temp / "const_add.o")
        self.assertNotEqual(code, 0, "un GradeBook const no debe aceptar add")


class Step6Comparison(LabCase):
    def test_comparison_is_filled_in(self):
        text = (SOURCE / "comparison.txt").read_text(encoding="utf-8")
        self.assertNotIn("PENDIENTE", text)
        self.assertRegex(text, "read-only|discards qualifiers", "falta la línea del error del compilador")


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