#!/bin/sh
# Las pruebas que no caben en un assert: compilar programas, ejecutarlos y comparar su salida
# con un archivo, byte por byte. Lo llama make test, desde code/week-11.
set -e
CXX=${CXX:-g++}
CXXFLAGS=${CXXFLAGS:--Wall -Wextra -std=c++20}
BUILD=${BUILD:-build}
tmp=$BUILD/tmp
mkdir -p "$tmp"

# 1. Cada programa es lo que make_self construye con su molde.
for name in quine quine_payload self_check; do
    "$BUILD/make_self" < "templates/$name.tpl" | cmp - "$name.cpp"
done
echo "make_self: ok (3 moldes)"

# 2. El quine imprime su fuente. Su salida, compilada, vuelve a imprimir lo mismo.
"$BUILD/quine" > "$tmp/copy.cpp"
cmp "$tmp/copy.cpp" quine.cpp
$CXX $CXXFLAGS "$tmp/copy.cpp" -o "$tmp/copy"
"$tmp/copy" | cmp - quine.cpp
echo "quine: ok ($(wc -c < quine.cpp) bytes, y la copia de la copia es igual)"

# 3. El quine con payload: la salida estándar es el fuente, y el payload dice sus líneas y bytes.
"$BUILD/quine_payload" > "$tmp/payload.out" 2> "$tmp/payload.err"
cmp "$tmp/payload.out" quine_payload.cpp
lines=$(wc -l < quine_payload.cpp)
bytes=$(wc -c < quine_payload.cpp)
echo "payload: me copié completo, $((lines)) líneas y $((bytes)) bytes" | cmp - "$tmp/payload.err"
echo "quine_payload: ok ($((lines)) líneas, $((bytes)) bytes)"

# 4. self_check reconoce su código y solo su código.
"$BUILD/self_check" < self_check.cpp | grep -q '^es mi código'
"$BUILD/self_check" < quine.cpp | grep -q '^no es mi código'
"$BUILD/self_check" < /dev/null | grep -q '^no es mi código'
{ cat self_check.cpp; echo; } | "$BUILD/self_check" | grep -q '^no es mi código'
echo "self_check: ok"

# 5. El intento ingenuo: P2 imprime P1, P1 imprime P0, y ninguno se imprime a sí mismo.
for k in 0 1 2 3; do
    "$BUILD/naive_growth" --emit "$k" > "$tmp/p$k.cpp"
done
for k in 1 2 3; do
    $CXX $CXXFLAGS "$tmp/p$k.cpp" -o "$tmp/p$k"
    "$tmp/p$k" | cmp - "$tmp/p$((k - 1)).cpp"
    if "$tmp/p$k" | cmp -s - "$tmp/p$k.cpp"; then
        echo "P$k se imprime a sí mismo: no debería"
        exit 1
    fi
done
echo "naive_growth: ok (P3 imprime P2, P2 imprime P1, P1 imprime P0)"

# 6. Los programas de errors/ compilan y no son quines.
for name in prints_other reads_file; do
    $CXX $CXXFLAGS "errors/$name.cpp" -o "$tmp/$name"
done
if "$tmp/prints_other" | cmp -s - errors/prints_other.cpp; then
    echo "errors/prints_other.cpp se imprime a sí mismo: no debería"
    exit 1
fi
# reads_file sí imprime su fuente, pero solo si se ejecuta desde la carpeta donde se compiló:
# el compilador dejó dentro del ejecutable la ruta errors/reads_file.cpp, y desde otra carpeta
# esa ruta no lleva a nada.
"$tmp/reads_file" | cmp - errors/reads_file.cpp
if (cd "$tmp" && ./reads_file) > "$tmp/reads_file.out" 2> /dev/null; then
    echo "errors/reads_file.cpp funcionó sin su archivo: no debería"
    exit 1
fi
echo "errors: ok (prints_other no se imprime; reads_file falla sin su archivo)"

# 7. Las cadenas de la sección de Kolmogorov: longitud exacta, siempre las mismas, y los
# compresores devuelven la original.
for kind in pattern count prng; do
    "$BUILD/gen_string" "$kind" 100000 > "$tmp/$kind.txt"
    test "$(wc -c < "$tmp/$kind.txt")" -eq 100000
    "$BUILD/gen_string" "$kind" 100000 | cmp - "$tmp/$kind.txt"
    gzip -9 -c "$tmp/$kind.txt" | gzip -dc | cmp - "$tmp/$kind.txt"
    xz -9 -c "$tmp/$kind.txt" | xz -dc | cmp - "$tmp/$kind.txt"
done
test "$("$BUILD/gen_string" pattern 12)" = 010101010101
test "$("$BUILD/gen_string" count 17)" = 11011100101110111
# Con un bit por símbolo, ningún código de prefijo baja de n/8 bytes para la cadena del generador.
test "$(gzip -9 -c "$tmp/prng.txt" | wc -c)" -ge 12500
test "$(gzip -9 -c "$tmp/pattern.txt" | wc -c)" -lt 1000
echo "gen_string: ok"
