// Lo que hace una llamada de Mini con los marcos, escrito a mano con Env.
//
//     let rate = 2
//     def scale(n) = n * rate
//     def outer(n) = scale(n + 1)
//     print outer(4)
#include <stdio.h>

#include "env.h"

// Busca name desde ese marco y escribe lo que encuentra.
static void show(const char *where, const Env *frame, const char *name) {
    double value;
    if (env_get(frame, name, &value)) {
        printf("%-10s %-5s = %g\n", where, name, value);
    } else {
        printf("%-10s %-5s no existe\n", where, name);
    }
}

int main(void) {
    Env *global = env_new(NULL);
    Env *outer = env_new(global);
    Env *scale = env_new(global);       // cuelga del global, no de outer
    Env *wrong = env_new(outer);        // lo que NO hace Mini: colgar del marco de quien llama
    if (global == NULL || outer == NULL || scale == NULL || wrong == NULL) {
        fprintf(stderr, "no hay memoria\n");
        env_free(wrong);
        env_free(scale);
        env_free(outer);
        env_free(global);
        return 1;
    }
    if (!env_set(global, "rate", 2) || !env_set(outer, "n", 4) || !env_set(scale, "n", 5)) {
        fprintf(stderr, "no hay memoria\n");
        env_free(wrong);
        env_free(scale);
        env_free(outer);
        env_free(global);
        return 1;
    }

    show("global", global, "rate");
    show("global", global, "n");
    show("outer", outer, "n");
    show("outer", outer, "rate");
    show("scale", scale, "n");
    show("scale", scale, "rate");
    show("wrong", wrong, "n");

    // Primero los marcos hijos, aunque Env no libera al padre: el orden de la pila.
    env_free(wrong);
    env_free(scale);
    env_free(outer);
    env_free(global);
    return 0;
}

"""Comprueba el ejemplo de clase, los módulos ya terminados y lo que los apuntes dicen del intérprete."""
import pathlib
import shutil
import subprocess
import tempfile
import unittest

HERE = pathlib.Path(__file__).parent
BUILD = HERE / "build"
LAB = HERE / "lab"
SOLUTION = HERE / "solution"
BASE = ["-Wall", "-Wextra", "-std=c17"]
FLAGS = [*BASE, "-g", "-fsanitize=address,undefined"]
FINISHED = ["env.c", "expr.c", "lexer.c", "stmt.c"]
REPORTS = ("AddressSanitizer", "LeakSanitizer", "runtime error")


def run(program, *args, cwd=HERE):
    done = subprocess.run(
        [str(program), *map(str, args)], cwd=cwd, text=True, encoding="utf-8", errors="replace",
        stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=120,
    )
    return done.stdout, done.returncode


def run_c(body, sources=FINISHED):
    """Compila y corre un main con los módulos dados, y devuelve (salida, código)."""
    with tempfile.TemporaryDirectory() as name:
        folder = pathlib.Path(name)
        driver = folder / "driver.c"
        driver.write_text(body, encoding="utf-8")
        binary = folder / "driver"
        files = [str(driver)] + [str(LAB / s) for s in sources]
        done = subprocess.run(["gcc", *FLAGS, "-Werror", f"-I{LAB}", *files, "-o", str(binary)],
                              text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        if done.returncode != 0:
            raise AssertionError(f"No compila:\n{done.stdout}")
        return run(binary)


def solution_copy(folder, change=None):
    """Copia lab/ con la solución encima. change recibe el texto de interp.c y lo modifica."""
    for path in list(LAB.glob("*.[ch]")) + list(SOLUTION.glob("*.c")):
        shutil.copy(path, folder)
    if change is not None:
        interp = pathlib.Path(folder) / "interp.c"
        interp.write_text(change(interp.read_text(encoding="utf-8")), encoding="utf-8")


def compile_all(folder, flags, name):
    binary = pathlib.Path(folder) / name
    sources = [str(path) for path in pathlib.Path(folder).glob("*.c")]
    subprocess.run(["gcc", *flags, *sources, "-o", str(binary)], check=True,
                   stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    return binary


class Frames(unittest.TestCase):
    def test_frames_program(self):
        out, code = run(BUILD / "frames")
        self.assertEqual(code, 0, out)
        self.assertIn("scale      rate  = 2", out)
        self.assertIn("global     n     no existe", out)
        self.assertIn("wrong      n     = 4", out)


class Compiled(unittest.TestCase):
    def test_lab_compiles_without_warnings(self):
        for path in sorted(LAB.glob("*.c")):
            with self.subTest(file=path.name):
                subprocess.run(["gcc", *FLAGS, "-Werror", f"-I{LAB}", "-c", str(path), "-o", "/dev/null"],
                               check=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

    def test_finished_modules_also_compile_with_o2(self):
        for name in FINISHED + ["mini.c"]:
            with self.subTest(file=name):
                subprocess.run(["gcc", *BASE, "-O2", "-Werror", f"-I{LAB}", "-c", str(LAB / name), "-o", "/dev/null"],
                               check=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

    def test_env_is_a_copy_of_the_contract(self):
        # Env se usa solo por su encabezado: nadie entra a sus campos.
        for name in ("parser.c", "interp.c", "expr.c", "mini.c"):
            self.assertNotIn("->first", (LAB / name).read_text(encoding="utf-8"), name)


class FinishedExpr(unittest.TestCase):
    def test_print_keeps_the_tree(self):
        body = r"""
        #include <stdio.h>
        #include "expr.h"
        static Expr *n(double v) { return expr_number(v); }
        static Expr *v(const char *s) { return expr_variable(s); }
        static void show(Expr *e) { expr_print(e, stdout); printf("\n"); expr_free(e); }
        int main(void) {
            show(expr_binary(OP_SUB, n(1), expr_binary(OP_SUB, n(2), n(3))));
            show(expr_binary(OP_SUB, expr_binary(OP_SUB, n(1), n(2)), n(3)));
            show(expr_binary(OP_MUL, expr_binary(OP_ADD, v("a"), n(1)), v("b")));
            show(expr_binary(OP_ADD, v("a"), expr_binary(OP_MUL, n(1), v("b"))));
            show(expr_binary(OP_LESS, expr_binary(OP_LESS, n(1), n(2)), n(3)));
            show(expr_binary(OP_ADD, expr_if(v("c"), n(1), n(2)), n(3)));
            show(expr_if(expr_if(v("a"), n(1), n(0)), n(2), expr_if(v("b"), n(3), n(4))));
            show(expr_call("f", NULL, 0));
            return 0;
        }
        """
        out, code = run_c(body)
        self.assertEqual(code, 0, out)
        self.assertEqual(out.splitlines(), [
            "1 - (2 - 3)", "1 - 2 - 3", "(a + 1) * b", "a + 1 * b", "(1 < 2) < 3", "(if c then 1 else 2) + 3",
            "if if a then 1 else 0 then 2 else if b then 3 else 4", "f()",
        ])

    def test_a_failed_eval_does_not_touch_the_result(self):
        body = r"""
        #include <stdio.h>
        #include "expr.h"
        int main(void) {
            Env *env = env_new(NULL);
            if (env == NULL) { return 1; }
            Expr *trees[3] = {
                expr_variable("missing"),
                expr_binary(OP_DIV, expr_number(1), expr_number(0)),
                expr_if(expr_number(1), expr_call("f", NULL, 0), expr_number(2)),
            };
            for (int i = 0; i < 3; i++) {
                double r = 42;
                int ok = expr_eval(trees[i], env, &r);
                printf("%d %g\n", ok, r);
                expr_free(trees[i]);
            }
            env_free(env);
            return 0;
        }
        """
        out, code = run_c(body, ["env.c", "expr.c"])
        self.assertEqual(code, 0, out)
        self.assertEqual(out.splitlines(), ["0 42", "0 42", "0 42"])

    def test_simplify_follows_the_rules_of_week_13(self):
        body = r"""
        #include <stdio.h>
        #include "expr.h"
        int main(void) {
            // (0 - 1) * 0 es 0, no -0: la regla de x * 0 va antes que calcular.
            Expr *e = expr_simplify(expr_binary(OP_MUL, expr_binary(OP_SUB, expr_number(0), expr_number(1)), expr_number(0)));
            expr_print(e, stdout);
            printf("\n%d\n", expr_simplify(NULL) == NULL);
            expr_free(e);
            return 0;
        }
        """
        out, code = run_c(body, ["env.c", "expr.c"])
        self.assertEqual(code, 0, out)
        self.assertEqual(out.splitlines(), ["0", "1"])

    def test_constructors_take_ownership_when_they_fail(self):
        body = r"""
        #include <stdio.h>
        #include <stdlib.h>
        #include "expr.h"
        int main(void) {
            printf("%d", expr_binary(OP_ADD, expr_variable("a"), NULL) == NULL);
            printf("%d", expr_binary(OP_ADD, NULL, expr_variable("a")) == NULL);
            printf("%d", expr_if(expr_variable("a"), NULL, expr_number(1)) == NULL);
            Expr **args = malloc(2 * sizeof *args);
            if (args == NULL) { return 1; }
            args[0] = expr_number(1);
            args[1] = NULL;
            printf("%d\n", expr_call("f", args, 2) == NULL);
            return 0;
        }
        """
        out, code = run_c(body)
        self.assertEqual((out.strip(), code), ("1111", 0), out)

    def test_copy_equal_simplify_derive_eval(self):
        body = r"""
        #include <stdio.h>
        #include <stdlib.h>
        #include "expr.h"
        static Expr *n(double v) { return expr_number(v); }
        static Expr *v(const char *s) { return expr_variable(s); }
        static void show(Expr *e) { expr_print(e, stdout); printf("\n"); expr_free(e); }
        int main(void) {
            Expr **args = malloc(2 * sizeof *args);
            if (args == NULL) { return 1; }
            args[0] = expr_binary(OP_ADD, v("x"), n(0));
            args[1] = expr_if(v("a"), n(1), n(2));
            Expr *call = expr_call("f", args, 2);
            Expr *copy = expr_copy(call);
            printf("%d\n", expr_equal(call, copy));
            expr_free(copy);
            show(expr_simplify(call));
            show(expr_simplify(expr_binary(OP_MUL, expr_binary(OP_ADD, v("x"), n(0)), n(1))));
            show(expr_simplify(expr_binary(OP_MUL, v("x"), n(0))));
            show(expr_simplify(expr_binary(OP_ADD, n(2), expr_binary(OP_MUL, n(3), n(4)))));
            show(expr_simplify(expr_binary(OP_DIV, n(1), n(0))));
            Expr *e = expr_binary(OP_MUL, v("x"), v("x"));
            show(expr_simplify(expr_derive(e, "x")));
            expr_free(e);
            e = expr_binary(OP_LESS, v("x"), n(1));
            printf("%d\n", expr_derive(e, "x") == NULL);
            Env *env = env_new(NULL);
            double r = 0;
            if (env == NULL || !env_set(env, "x", 3)) { return 1; }
            int ok = expr_eval(e, env, &r);
            printf("%d %g\n", ok, r);
            expr_free(e);
            e = expr_if(v("x"), n(7), expr_binary(OP_DIV, n(1), n(0)));
            ok = expr_eval(e, env, &r);
            printf("%d %g\n", ok, r);
            expr_free(e);
            e = expr_call("f", NULL, 0);
            ok = expr_eval(e, env, &r);
            printf("%d\n", ok);
            expr_free(e);
            env_free(env);
            return 0;
        }
        """
        out, code = run_c(body)
        self.assertEqual(code, 0, out)
        self.assertEqual(out.splitlines(), [
            "1", "f(x, if a then 1 else 2)", "x", "0", "14", "1 / 0", "x + x", "1", "1 0", "1 7", "0",
        ])


class FinishedLexer(unittest.TestCase):
    def tokens(self, text):
        literal = text.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
        body = r"""
        #include <stdio.h>
        #include "lexer.h"
        int main(void) {
            Lexer *lexer = lexer_new("%s");
            if (lexer == NULL) { return 1; }
            Token t;
            do {
                t = lexer_next(lexer);
                printf("%%d:%%d:%%d:%%s\n", t.kind, t.line, t.column, t.text);
            } while (t.kind != TOKEN_END && t.kind != TOKEN_ERROR);
            lexer_free(lexer);
            return 0;
        }
        """ % literal
        out, code = run_c(body, ["lexer.c"])
        self.assertEqual(code, 0, out)
        return [line.split(":", 3) for line in out.splitlines()]

    def test_positions_and_comments(self):
        got = self.tokens("let x1 = 3.5 # nada\n  print <= != ==")
        self.assertEqual([t[3] for t in got], ["let", "x1", "=", "3.5", "print", "<=", "!=", "==", ""])
        self.assertEqual(got[4][1:3], ["2", "3"])
        self.assertEqual(got[0][0], "2")    # TOKEN_LET
        self.assertEqual(got[1][0], "1")    # TOKEN_NAME

    def test_errors(self):
        self.assertIn("inesperado", self.tokens("1 @")[-1][3])
        self.assertIn("!", self.tokens("!")[-1][3])
        self.assertIn("largo", self.tokens("a" * 64)[-1][3])
        self.assertEqual(self.tokens("a" * 63)[0][3], "a" * 63)
        self.assertIn("largo", self.tokens("1" * 70)[-1][3])

    def test_a_point_needs_digits(self):
        self.assertIn("inesperado", self.tokens("3.")[-1][3])
        self.assertEqual(self.tokens("3.25")[0][3], "3.25")


class FinishedExpressionParser(unittest.TestCase):
    """parse_expression, sin if ni llamadas: esa parte está en lab/parser.c antes de que la toquen."""

    def show(self, text):
        literal = text.replace('"', '\\"')
        body = r"""
        #include <stdio.h>
        #include "parser.h"
        int main(void) {
            ParseError error;
            Expr *e = parse_expression("%s", &error);
            if (e == NULL) {
                printf("%%d:%%d\n", error.line, error.column);
                return 0;
            }
            expr_print(e, stdout);
            printf("\n");
            expr_free(e);
            return 0;
        }
        """ % literal
        out, code = run_c(body, FINISHED + ["parser.c"])
        self.assertEqual(code, 0, out)
        return out.strip()

    def test_precedence_and_association(self):
        self.assertEqual(self.show("1 + 2 * 3"), "1 + 2 * 3")
        self.assertEqual(self.show("(1 + 2) * 3"), "(1 + 2) * 3")
        self.assertEqual(self.show("1 - 2 - 3"), "1 - 2 - 3")
        self.assertEqual(self.show("-x"), "0 - x")
        self.assertEqual(self.show("a + 1 < b * 2"), "a + 1 < b * 2")

    def test_errors_without_leaks(self):
        self.assertEqual(self.show("1 +"), "1:4")
        self.assertEqual(self.show("(1 + 2"), "1:7")
        self.assertEqual(self.show("1 < 2 < 3"), "1:7")
        self.assertEqual(self.show("a * (b + * c)"), "1:10")


@unittest.skipUnless(SOLUTION.exists(), "falta la solución")
class WhatTheNotesSayOfTheInterpreter(unittest.TestCase):
    PROGRAM = "lab/programs/{}.mini"

    def test_runaway_recursion_overflows_the_c_stack(self):
        # En x86-64 emulado, ASan a veces muere sin informe: también vale una señal.
        out, code = run(BUILD / "solution" / "mini", self.PROGRAM.format("runaway"))
        self.assertNotEqual(code, 0)
        if "AddressSanitizer" in out:
            self.assertIn("stack-overflow", out)
            self.assertIn("eval_call", out)
            self.assertNotIn("forever", out)

    def test_my_if_never_reaches_its_base_case(self):
        out, code = run(BUILD / "solution" / "mini", self.PROGRAM.format("my_if"))
        self.assertNotEqual(code, 0)
        self.assertNotIn("6\n", out.split("AddressSanitizer")[0])

    def test_without_sanitizers_it_is_a_signal(self):
        with tempfile.TemporaryDirectory() as folder:
            solution_copy(folder)
            binary = compile_all(folder, [*BASE, "-g", "-O0"], "plain")
            _, code = run(binary, self.PROGRAM.format("runaway"))
        self.assertIn(code, (-11, 139))

    def test_a_forgotten_env_free_leaks_three_blocks_per_frame(self):
        def forget(text):
            old = "    env_free(callee);\n    return ok;"
            self.assertIn(old, text)
            return text.replace(old, "    return ok;")

        with tempfile.TemporaryDirectory() as folder:
            solution_copy(folder, forget)
            binary = compile_all(folder, FLAGS, "leaky")
            out, code = run(binary, self.PROGRAM.format("fact"))
        self.assertNotEqual(code, 0)
        self.assertIn("in 15 allocation(s)", out)

    def test_the_frame_of_the_caller_changes_the_result(self):
        def wrong_parent(text):
            old = "env_new(in->global);\n    if (callee"
            self.assertIn(old, text)
            return text.replace(old, "env_new((Env *) frame);\n    if (callee")

        with tempfile.TemporaryDirectory() as folder:
            solution_copy(folder, wrong_parent)
            binary = compile_all(folder, FLAGS, "dynamic")
            out, _ = run(binary, SOLUTION / "mine" / "frames.mini")
            self.assertEqual(out.strip(), "100")
            out, _ = run(binary, self.PROGRAM.format("fact"))
            self.assertEqual(out.strip(), "120")
            out, _ = run(binary, self.PROGRAM.format("fib"))
            self.assertEqual(out.split(), ["1", "55", "6765"])
        out, _ = run(BUILD / "solution" / "mini", SOLUTION / "mine" / "frames.mini")
        self.assertEqual(out.strip(), "20")

    def test_argument_in_the_new_frame_gives_the_wrong_result(self):
        def args_in_new_frame(text):
            old = "        if (!env_set(callee, function->as.def.params[i], values[i])) {"
            self.assertIn(old, text)
            return text.replace(old, "        if (!eval(in, e->as.call.args[i], callee, &values[i])) { return 0; }\n" + old)

        program = "def sub(a, b) = a - b\nlet a = 10\nlet b = 3\nprint sub(b, a)\n"
        with tempfile.TemporaryDirectory() as folder:
            solution_copy(folder, args_in_new_frame)
            binary = compile_all(folder, FLAGS, "wrong_args")
            path = pathlib.Path(folder) / "p.mini"
            path.write_text(program, encoding="utf-8")
            self.assertEqual(run(binary, path)[0].strip(), "0")
        with tempfile.TemporaryDirectory() as folder:
            path = pathlib.Path(folder) / "p.mini"
            path.write_text(program, encoding="utf-8")
            self.assertEqual(run(BUILD / "solution" / "mini", path)[0].strip(), "-7")

    def test_two_stacks_in_gdb(self):
        if shutil.which("gdb") is None:
            self.skipTest("no hay gdb")
        with tempfile.TemporaryDirectory() as folder:
            solution_copy(folder)
            binary = compile_all(folder, [*BASE, "-g", "-O0"], "with_gdb")
            out, _ = run("gdb", "-q", "-batch", "-ex", "set print frame-arguments none",
                         "-ex", "break eval if e->kind == EXPR_NUMBER && e->as.number == 1", "-ex", "ignore 1 2",
                         "-ex", f"run {self.PROGRAM.format('fact3')}", "-ex", "backtrace", binary)
        if " main " not in out:
            self.skipTest("gdb no puede correr programas aquí")
        frames = [line for line in out.splitlines() if line.startswith("#")]
        self.assertEqual(sum(" eval_call " in line for line in frames), 3)
        self.assertEqual(len(frames), 20)


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

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

Son de varios niveles: programas de Mini completos, errores esperados, y un main en C que mira
los árboles por la interfaz. Todo corre con ASan y UBSan: una fuga o un aviso hacen fallar la prueba.
"""
import os
import pathlib
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
LAB = HERE / "lab"
FLAGS = ["-Wall", "-Wextra", "-std=c17", "-g", "-fsanitize=address,undefined"]
MODULES = ["env.c", "expr.c", "lexer.c", "stmt.c", "parser.c", "interp.c"]
REPORTS = ("AddressSanitizer", "LeakSanitizer", "runtime error")
FOLDER = tempfile.TemporaryDirectory()
BUILT = {}


def source(name):
    """El archivo de la carpeta que se prueba. Si no está ahí, es uno de los ya hechos de lab/."""
    path = SOURCE / name
    return path if path.exists() else LAB / name


def compile_program(name, sources):
    """Compila una sola vez cada programa, y devuelve su ruta."""
    if name not in BUILT:
        binary = pathlib.Path(FOLDER.name) / name
        done = subprocess.run(
            ["gcc", *FLAGS, f"-I{LAB}", *map(str, sources), "-o", str(binary)],
            text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
        )
        BUILT[name] = (binary, done.returncode, done.stdout)
    binary, code, messages = BUILT[name]
    if code != 0:
        raise AssertionError(f"No compila:\n{messages}")
    if messages:
        raise AssertionError(f"Compila con advertencias, y no debe:\n{messages}")
    return binary


def mini():
    return compile_program("mini", [source(m) for m in MODULES] + [LAB / "mini.c"])


def run_binary(binary, *args):
    try:
        done = subprocess.run(
            [str(binary), *map(str, args)], text=True, encoding="utf-8", errors="replace",
            stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=60,
        )
    except subprocess.TimeoutExpired:
        raise AssertionError("El programa no terminó en 60 segundos.") from None
    return done.stdout, done.stderr, done.returncode


def run_mini(program):
    """Corre el texto de un programa de Mini. Devuelve (salida, errores, código)."""
    path = pathlib.Path(FOLDER.name) / "program.mini"
    path.write_text(program, encoding="utf-8")
    return run_binary(mini(), path)


class MiniCase(unittest.TestCase):
    longMessage = False

    @classmethod
    def setUpClass(cls):
        if not SOURCE.exists():
            raise unittest.SkipTest(f"no está {LAB_DIR}")

    def no_reports(self, program, out, err):
        for word in REPORTS:
            if word in out or word in err:
                lines = err.splitlines()[:14]
                self.fail(f"Hay un informe de {word} con este programa:\n{program}\n" + "\n".join(lines))

    def prints(self, program, wanted):
        out, err, code = run_mini(program)
        self.no_reports(program, out, err)
        if code != 0:
            self.fail(f"Terminó con error, y no debía:\n{program}\n{err}")
        got = out.split()
        if got != wanted.split():
            self.fail(f"Este programa:\n{program}\n  debe escribir: {wanted}\n  escribió:       {' '.join(got)}")

    def run_error(self, program, words, printed=""):
        out, err, code = run_mini(program)
        self.no_reports(program, out, err)
        if code != 1:
            self.fail(f"Debe terminar con un error de ejecución:\n{program}\n  escribió: {out}")
        if "error de ejecución" not in err:
            self.fail(f"Debe ser un error de ejecución:\n{program}\n  se obtuvo: {err}")
        for word in words:
            if word not in err:
                self.fail(f"El mensaje debe decir '{word}':\n{program}\n  se obtuvo: {err}")
        if out.split() != printed.split():
            self.fail(f"Antes del error debe escribir: {printed}\n{program}\n  escribió: {out}")

    def syntax_error(self, program, line=None):
        out, err, code = run_mini(program)
        self.no_reports(program, out, err)
        if code != 1 or "error de sintaxis" not in err:
            self.fail(f"Debe dar un error de sintaxis:\n{program}\n  se obtuvo: {out}{err}")
        if "falta " in err:
            self.fail(f"Aún falta escribir una parte: {err}")
        if out:
            self.fail(f"Con un error de sintaxis no se corre nada:\n{program}\n  escribió: {out}")
        if line is not None and f":{line}:" not in err:
            self.fail(f"El error debe estar en la línea {line}:\n{program}\n  se obtuvo: {err}")


class LetAndPrint(MiniCase):
    def test_print(self):
        self.prints("print 1 + 2 * 3", "7")
        self.prints("print (1 + 2) * 3", "9")
        self.prints("print -2 - -3", "1")
        self.prints("print 0.5", "0.5")
        self.prints("print 1 / 3", "0.333333")

    def test_several_prints_in_order(self):
        self.prints("print 1\nprint 2\nprint 3\n", "1 2 3")

    def test_let(self):
        self.prints("let x = 4\nprint x * x", "16")

    def test_let_changes_the_value(self):
        self.prints("let x = 1\nlet x = x + 1\nprint x", "2")

    def test_no_separator_is_needed(self):
        self.prints("let a = 1 let b = a + 1 print a + b", "3")

    def test_comments_and_blank_lines(self):
        self.prints("# hola\n\nlet a = 2 # dos\n\n# fin\nprint a # listo\n", "2")

    def test_comparisons_print_one_or_zero(self):
        self.prints("print 1 < 2\nprint 2 < 1\nprint 2 <= 2\nprint 3 > 4\nprint 4 >= 4\nprint 1 == 1\nprint 1 != 1",
                    "1 0 1 0 1 1 0")

    def test_empty_program(self):
        self.prints("", "")
        self.prints("# solo un comentario\n", "")


class IfExpression(MiniCase):
    def test_both_branches(self):
        self.prints("print if 1 < 2 then 10 else 20", "10")
        self.prints("print if 2 < 1 then 10 else 20", "20")

    def test_any_value_except_zero_is_true(self):
        self.prints("print if 0.5 then 1 else 2\nprint if -3 then 1 else 2\nprint if 0 then 1 else 2", "1 1 2")

    def test_only_the_chosen_branch_runs(self):
        self.prints("print if 1 then 2 else 1 / 0", "2")
        self.prints("print if 0 then 1 / 0 else 3", "3")
        self.prints("print if 1 then 2 else missing", "2")

    def test_nested(self):
        self.prints("let x = 5\nprint if x < 3 then 1 else if x < 6 then 2 else 3", "2")
        self.prints("print if if 1 then 0 else 1 then 10 else 20", "20")

    def test_inside_parentheses(self):
        self.prints("print 1 + (if 1 then 2 else 3) * 4", "9")

    def test_else_reaches_as_far_as_it_can(self):
        self.prints("print if 1 then 2 else 3 + 4\nprint if 0 then 2 else 3 + 4", "2 7")

    def test_condition_errors(self):
        self.run_error("print if missing then 1 else 2", ["missing"])


class Calls(MiniCase):
    def test_required_example(self):
        self.prints("def fact(n) = if n < 2 then 1 else n * fact(n - 1)\nlet x = 5\nprint fact(x)     # 120\n", "120")

    def test_no_parameters(self):
        self.prints("def seven() = 7\nprint seven() + 1", "8")

    def test_several_parameters(self):
        self.prints("def sub(a, b) = a - b\nprint sub(10, 3)", "7")

    def test_more_arguments_than_any_first_capacity(self):
        names = [f"p{i}" for i in range(20)]
        args = ", ".join(str(i + 1) for i in range(20))
        self.prints(f"def total({', '.join(names)}) = {' + '.join(names)}\nprint total({args})", "210")

    def test_calls_inside_arguments(self):
        self.prints("def inc(n) = n + 1\ndef add(a, b) = a + b\nprint add(inc(1), inc(inc(1)))", "5")

    def test_if_as_argument(self):
        self.prints("def id(n) = n\nprint id(if 1 then 2 else 3)", "2")

    def test_arguments_use_the_frame_of_the_caller(self):
        self.prints("def sub(a, b) = a - b\nlet a = 10\nlet b = 3\nprint sub(b, a)", "-7")
        self.prints("def sub(a, b) = a - b\ndef swap(a, b) = sub(b, a)\nprint swap(1, 5)", "4")

    def test_parameter_covers_a_global(self):
        self.prints("let x = 10\ndef double(x) = x * 2\nprint double(3)\nprint x", "6 10")

    def test_body_reads_globals_when_it_runs(self):
        self.prints("let r = 2\ndef scale(n) = n * r\nprint scale(5)\nlet r = 3\nprint scale(5)", "10 15")

    def test_body_does_not_see_the_locals_of_its_caller(self):
        self.run_error("def show() = n\ndef outer(n) = show()\nprint outer(7)", ["variable desconocida", "n"])

    def test_after_a_call_the_parameter_is_gone(self):
        self.run_error("def id(n) = n\nprint id(1)\nprint n", ["variable desconocida", "n"], "1")

    def test_functions_and_variables_are_separate(self):
        self.prints("let f = 1\ndef f(x) = x + 1\nprint f(f)", "2")

    def test_def_takes_effect_when_it_runs(self):
        self.run_error("print 1\nprint twice(4)\ndef twice(n) = n * 2", ["función desconocida", "twice"], "1")

    def test_body_may_name_a_function_defined_later(self):
        self.prints("def even(n) = if n == 0 then 1 else odd(n - 1)\n"
                    "def odd(n) = if n == 0 then 0 else even(n - 1)\n"
                    "print even(10)\nprint even(7)", "1 0")

    def test_a_new_def_replaces_the_old_one(self):
        self.prints("def f() = 1\nprint f()\ndef f() = 2\nprint f()", "1 2")


class Programs(MiniCase):
    """Los programas de lab/programs, enteros."""

    def run_file(self, name, wanted):
        self.prints((LAB / "programs" / name).read_text(encoding="utf-8"), wanted)

    def test_factorial(self):
        self.run_file("fact.mini", "120")

    def test_large_factorial_goes_through_percent_g(self):
        self.run_file("big.mini", "720 3.6288e+06 6.22702e+09")

    def test_fibonacci(self):
        self.run_file("fib.mini", "1 55 6765")

    def test_mutual_recursion(self):
        self.run_file("even_odd.mini", "1 0")

    def test_a_thousand_mini_frames(self):
        self.run_file("deep.mini", "500500")

    def test_many_calls_leave_no_leaks(self):
        self.prints("def fib(n) = if n < 2 then n else fib(n - 1) + fib(n - 2)\nprint fib(22)", "17711")


class RunErrors(MiniCase):
    def test_unknown_variable(self):
        self.run_error("print 1\nprint x\nprint 2", ["variable desconocida", "x"], "1")

    def test_unknown_function(self):
        self.run_error("print f(1)", ["función desconocida", "f"])

    def test_too_few_arguments(self):
        self.run_error("def add(a, b) = a + b\nprint add(1)", ["argumentos", "add"])

    def test_too_many_arguments(self):
        self.run_error("def add(a, b) = a + b\nprint add(1, 2, 3)", ["argumentos", "add"])

    def test_arguments_for_no_parameters(self):
        self.run_error("def f() = 1\nprint f(2)", ["argumentos", "f"])

    def test_division_by_zero(self):
        self.run_error("print 1 / 0", ["división entre cero"])
        self.run_error("let x = 0\nlet y = 1 / x", ["división entre cero"])

    def test_error_in_an_argument_frees_the_values(self):
        self.run_error("def f(a, b, c) = a\nprint f(1, 2 / 0, 3)", ["división entre cero"])
        self.run_error("def f(a, b, c) = a\nprint f(1, 2, missing)", ["variable desconocida"])

    def test_error_deep_inside_frees_every_frame(self):
        self.run_error("def down(n, m) = if n == 0 then 1 / 0 else 1 + down(n - 1, m)\nprint down(50, 1)",
                       ["división entre cero"])
        self.run_error("def down(n, m) = if n == 0 then nope(1, 2) else n + down(n - 1, m)\nprint down(50, 1)",
                       ["función desconocida", "nope"])

    def test_error_in_a_nested_argument(self):
        self.run_error("def id(n) = n\ndef two(a, b) = a + b\nprint two(id(1), id(two(id(2), id(missing))))",
                       ["variable desconocida", "missing"])


class SyntaxErrors(MiniCase):
    def test_statements(self):
        for program in ("let", "let x", "let x =", "let 3 = 1", "let if = 1", "print", "x = 1", "1 + 2"):
            with self.subTest(program=program):
                self.syntax_error(program)

    def test_if(self):
        for program in ("print if", "print if 1", "print if 1 then", "print if 1 then 2", "print if 1 then 2 else",
                        "print 1 + if 1 then 2 else 3", "print if 1 else 2 then 3"):
            with self.subTest(program=program):
                self.syntax_error(program)

    def test_if_frees_what_it_read(self):
        for program in ("print if a + 1 then", "print if a + 1 then b + 2", "print if a + 1 then b + 2 else *",
                        "print if a + 1 + then 2 else 3", "print if a then b + * else 3"):
            with self.subTest(program=program):
                self.syntax_error(program)

    def test_call(self):
        for program in ("print f(", "print f(1", "print f(1,", "print f(1,)", "print f(,1)", "print f(1 2)",
                        "print f(a + 1, b * 2, c - 3", "print f(a + 1, b * 2, g(c, d), e + ) + 1",
                        "print f(1, 2, 3, 4, 5, 6, 7, 8, 9, *)"):
            with self.subTest(program=program):
                self.syntax_error(program)

    def test_def(self):
        for program in ("def", "def 1() = 2", "def f", "def f(", "def f(a", "def f(a,", "def f(a,) = 1", "def f(1) = 2",
                        "def f(a, b)", "def f(a, b) 1", "def f(a, b) =", "def f(a, b) = a +", "def if() = 1",
                        "def f(a, b, c, d, e, g, h) = *"):
            with self.subTest(program=program):
                self.syntax_error(program)

    def test_comparisons_do_not_chain(self):
        self.syntax_error("print 1 < 2 < 3")

    def test_an_error_after_good_statements_frees_them(self):
        self.syntax_error("def f(a) = a + 1\nlet x = f(2)\nprint x\nprint (", line=4)

    def test_position_of_the_error(self):
        self.syntax_error("let x = 1\n\nprint x +\n", line=4)
        self.syntax_error("let x = 1\nlet = 2\n", line=2)


API_MAIN = r"""
#include <stdio.h>
#include <string.h>
#include "interp.h"
#include "parser.h"

static int shows(const char *source) {
    ParseError error;
    Stmt *program = parse_program(source, &error);
    if (program == NULL) {
        printf("%d:%s\n", error.line, error.message[0] != '\0' ? "error" : "vacio");
        return 0;
    }
    for (const Stmt *s = program; s != NULL; s = s->next) {
        switch (s->kind) {
        case STMT_LET:
            printf("let %s ", s->as.let.name);
            expr_print(s->as.let.value, stdout);
            break;
        case STMT_PRINT:
            printf("print ");
            expr_print(s->as.print.value, stdout);
            break;
        case STMT_DEF:
            printf("def %s %d", s->as.def.name, s->as.def.param_count);
            for (int i = 0; i < s->as.def.param_count; i++) {
                printf(" %s", s->as.def.params[i]);
            }
            printf(" ");
            expr_print(s->as.def.body, stdout);
            break;
        }
        printf("\n");
    }
    stmt_free(program);
    return 1;
}

static void runs_on(const char *source) {
    ParseError syntax;
    RunError error;
    Stmt *program = parse_program(source, &syntax);
    FILE *out = tmpfile();
    if (out == NULL) {
        printf("sin tmpfile\n");
        stmt_free(program);
        return;
    }
    int ok = run_program(program, out, &error);
    rewind(out);
    int c;
    printf("%d [", ok);
    while ((c = fgetc(out)) != EOF) {
        putchar(c == '\n' ? ' ' : c);
    }
    printf("] %s\n", ok ? (error.message[0] == '\0' ? "sin-mensaje" : "con-mensaje") : "error");
    fclose(out);
    stmt_free(program);
}

int main(void) {
    shows("");
    shows("let\n");
    shows("let a = 1\nprint a + 2\ndef f(x, y) = g(x, 1) * (if y then 2 else 3)\ndef h() = 0\n");
    runs_on("print 1 print 2");
    runs_on("");
    runs_on("print 1 print 1 / 0 print 2");
    // Un programa se puede correr dos veces: run_program no se lo apropia.
    ParseError syntax;
    RunError error;
    Stmt *program = parse_program("def f() = 1 print f()", &syntax);
    FILE *out = tmpfile();
    if (out != NULL) {
        int first = run_program(program, out, &error);
        int second = run_program(program, out, &error);
        printf("%d %d\n", first, second);
        fclose(out);
    }
    stmt_free(program);
    return 0;
}
"""


class Interface(MiniCase):
    """Lo mismo, pero por la interfaz de parser.h e interp.h."""

    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        path = pathlib.Path(FOLDER.name) / "api_main.c"
        path.write_text(API_MAIN, encoding="utf-8")
        cls.main_path = path

    def test_trees_and_results(self):
        binary = compile_program("api", [self.main_path] + [source(m) for m in MODULES])
        out, err, code = run_binary(binary)
        self.no_reports("(main de prueba)", out, err)
        self.assertEqual(code, 0, err)
        wanted = [
            "0:vacio",
            "2:error",
            "let a 1",
            "print a + 2",
            "def f 2 x y g(x, 1) * (if y then 2 else 3)",
            "def h 0 0",
            "1 [1 2 ] sin-mensaje",
            "1 [] sin-mensaje",
            "0 [1 ] error",
            "1 1",
        ]
        got = out.splitlines()
        if got != wanted:
            self.fail("La interfaz no da lo esperado.\n  se esperaba:\n    " + "\n    ".join(wanted)
                      + "\n  se obtuvo:\n    " + "\n    ".join(got))

    def test_no_writable_globals(self):
        for name in ("parser.c", "interp.c"):
            with tempfile.TemporaryDirectory() as folder:
                obj = pathlib.Path(folder) / "file.o"
                subprocess.run(["gcc", "-std=c17", "-fno-pic", f"-I{LAB}", "-c", str(source(name)), "-o", str(obj)], check=True)
                done = subprocess.run(["nm", str(obj)], text=True, stdout=subprocess.PIPE, check=True)
            found = [line.split()[-1] for line in done.stdout.splitlines() if re.search(r" [bBdD] ", line)]
            with self.subTest(file=name):
                self.assertEqual(found, [], f"{name} no debe tener variables globales: {found}")


class OwnPrograms(MiniCase):
    """Sus programas de mine/: cada x.mini con su x.expected, que dice qué debe escribir."""

    def programs(self):
        folder = SOURCE / "mine"
        return sorted(path for path in folder.glob("*.mini") if path.stem != "example")

    def test_there_are_at_least_two(self):
        self.assertGreaterEqual(len(self.programs()), 2,
                                "Falta la parte 5: agreguen a lab/mine al menos dos programas con su .expected.")

    def test_every_program_gives_what_it_expects(self):
        for path in sorted((SOURCE / "mine").glob("*.mini")):
            with self.subTest(program=path.name):
                expected = path.with_suffix(".expected")
                self.assertTrue(expected.exists(), f"Falta {expected.name}.")
                self.prints(path.read_text(encoding="utf-8"), expected.read_text(encoding="utf-8"))


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