350 lines
9.1 KiB
Python
350 lines
9.1 KiB
Python
from __future__ import annotations
|
|
|
|
import ast
|
|
import textwrap
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from foreignthon.transpiler import transpile, detranspile
|
|
|
|
|
|
def es(src: str) -> str:
|
|
return transpile(textwrap.dedent(src).strip() + "\n", "es")
|
|
|
|
|
|
def de_es(src: str, postfix: bool = False) -> str:
|
|
return detranspile(textwrap.dedent(src).strip() + "\n", "es", postfix=postfix)
|
|
|
|
|
|
def valid(src: str) -> bool:
|
|
try:
|
|
ast.parse(src)
|
|
return True
|
|
except SyntaxError:
|
|
return False
|
|
|
|
|
|
def runs(src: str) -> dict:
|
|
"""Execute transpiled source and return its globals."""
|
|
code = compile(src, "<test>", "exec")
|
|
glob = {}
|
|
exec(code, glob)
|
|
return glob
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Complex class with methods, properties, exceptions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_class_with_methods():
|
|
src = """
|
|
clase Contador:
|
|
def __init__(self, inicio=0):
|
|
self.valor = inicio
|
|
|
|
def incrementar(self):
|
|
self.valor += 1
|
|
retornar self.valor
|
|
|
|
def reiniciar(self):
|
|
self.valor = 0
|
|
|
|
c = Contador(10)
|
|
c.incrementar()
|
|
c.incrementar()
|
|
"""
|
|
out = es(src)
|
|
assert valid(out)
|
|
g = runs(out)
|
|
assert g["c"].valor == 12
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Exception handling with custom exception
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_exception_handling():
|
|
src = """
|
|
clase MiError(Excepcion):
|
|
pasar
|
|
|
|
def dividir(a, b):
|
|
si b == 0:
|
|
lanzar ErrorDeDivisionCero("no dividas por cero")
|
|
retornar a / b
|
|
|
|
intentar:
|
|
resultado = dividir(10, 2)
|
|
excepto ErrorDeDivisionCero como e:
|
|
resultado = -1
|
|
finalmente:
|
|
hecho = Verda
|
|
"""
|
|
out = es(src)
|
|
assert valid(out)
|
|
g = runs(out)
|
|
assert g["resultado"] == 5.0
|
|
assert g["hecho"] is True
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Generator with yield
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_generator():
|
|
src = """
|
|
def cuadrados(n):
|
|
para i en dist(n):
|
|
generar i * i
|
|
|
|
resultado = lista(cuadrados(5))
|
|
"""
|
|
out = es(src)
|
|
assert valid(out)
|
|
g = runs(out)
|
|
assert g["resultado"] == [0, 1, 4, 9, 16]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Lambda and higher order functions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_lambda_and_builtins():
|
|
src = """
|
|
nums = [3, 1, 4, 1, 5, 9, 2, 6]
|
|
pares = lista(filtrar(lambda x: x % 2 == 0, nums))
|
|
dobles = lista(map(lambda x: x * 2, nums))
|
|
total = sum(nums)
|
|
mayor = max(nums)
|
|
menor = min(nums)
|
|
"""
|
|
out = es(src)
|
|
assert valid(out)
|
|
g = runs(out)
|
|
assert g["pares"] == [4, 2, 6]
|
|
assert g["total"] == 31
|
|
assert g["mayor"] == 9
|
|
assert g["menor"] == 1
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Nested functions and closures
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_nested_functions():
|
|
src = """
|
|
def hacer_multiplicador(n):
|
|
def multiplicar(x):
|
|
retornar x * n
|
|
retornar multiplicar
|
|
|
|
doble = hacer_multiplicador(2)
|
|
triple = hacer_multiplicador(3)
|
|
resultado = doble(5) + triple(4)
|
|
"""
|
|
out = es(src)
|
|
assert valid(out)
|
|
g = runs(out)
|
|
assert g["resultado"] == 22
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# While loop with break and continue
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_while_break_continue():
|
|
src = """
|
|
resultado = []
|
|
i = 0
|
|
mientras i < 20:
|
|
i += 1
|
|
si i % 2 == 0:
|
|
continuar
|
|
si i > 9:
|
|
parar
|
|
resultado.append(i)
|
|
"""
|
|
out = es(src)
|
|
assert valid(out)
|
|
g = runs(out)
|
|
assert g["resultado"] == [1, 3, 5, 7, 9]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# List/dict/set comprehensions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_comprehensions():
|
|
src = """
|
|
cuadrados = [x*x para x en dist(6)]
|
|
pares = {x para x en dist(10) si x % 2 == 0}
|
|
cubo_dict = {x: x**3 para x en dist(5)}
|
|
"""
|
|
out = es(src)
|
|
assert valid(out)
|
|
g = runs(out)
|
|
assert g["cuadrados"] == [0, 1, 4, 9, 16, 25]
|
|
assert g["pares"] == {0, 2, 4, 6, 8}
|
|
assert g["cubo_dict"] == {0: 0, 1: 1, 2: 8, 3: 27, 4: 64}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# @@ postfix syntax — mixed with prefix
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_postfix_mixed_with_prefix():
|
|
src = """
|
|
def clasificar(n):
|
|
n > 0 @@si:
|
|
retornar "positivo"
|
|
n < 0 @@osi:
|
|
retornar "negativo"
|
|
sino:
|
|
retornar "cero"
|
|
|
|
resultados = [clasificar(x) para x en [-2, 0, 3]]
|
|
"""
|
|
out = es(src)
|
|
assert valid(out)
|
|
assert "@@" not in out
|
|
g = runs(out)
|
|
assert g["resultados"] == ["negativo", "cero", "positivo"]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# @@ postfix in while and nested ifs
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_postfix_while_nested():
|
|
src = """
|
|
acum = 0
|
|
i = 1
|
|
i <= 10 @@mientras:
|
|
i % 2 == 0 @@si:
|
|
acum += i
|
|
i += 1
|
|
"""
|
|
out = es(src)
|
|
assert valid(out)
|
|
assert "@@" not in out
|
|
g = runs(out)
|
|
assert g["acum"] == 30 # 2+4+6+8+10
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Strings and comments never touched
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_strings_with_keyword_names():
|
|
src = """
|
|
msg = "si para mientras def class"
|
|
comentario = 'si esto no se traduce'
|
|
fstr = f"valor si={42}"
|
|
lista_kw = ["si", "para", "mientras"]
|
|
"""
|
|
out = es(src)
|
|
assert '"si para mientras def class"' in out
|
|
assert "'si esto no se traduce'" in out
|
|
assert '["si", "para", "mientras"]' in out
|
|
|
|
|
|
def test_comment_lines_untouched():
|
|
src = """
|
|
# si para mientras escribir dist
|
|
x = 1 # si esto es un comentario
|
|
y = 2
|
|
"""
|
|
out = es(src)
|
|
assert "# si para mientras escribir dist" in out
|
|
assert "# si esto es un comentario" in out
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Spacing — no double blank lines, no spaces around parens
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def test_no_double_blank_lines():
|
|
src = """
|
|
def foo():
|
|
pasar
|
|
|
|
def bar():
|
|
pasar
|
|
|
|
def baz():
|
|
pasar
|
|
"""
|
|
out = es(src)
|
|
assert "\n\n\n" not in out
|
|
|
|
|
|
def test_no_spaces_around_parens():
|
|
src = "escribir(dist(10))\n"
|
|
out = es(src)
|
|
assert "print(range(10))" in out
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Decompile — round trip
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_decompile_postfix():
|
|
src = textwrap.dedent("""
|
|
def check(x):
|
|
if x > 0:
|
|
print(x)
|
|
elif x == 0:
|
|
print(0)
|
|
else:
|
|
pass
|
|
""").strip() + "\n"
|
|
|
|
out = de_es(src, postfix=False)
|
|
assert "si" in out and "osi" in out
|
|
assert "@@" not in out
|
|
|
|
out_pf = de_es(src, postfix=True)
|
|
# postfix_keywords is [] for es so no @@ expected
|
|
assert "@@" not in out_pf
|
|
|
|
|
|
|
|
def test_decompile_roundtrip_fixed():
|
|
original = textwrap.dedent("""
|
|
def sumar(a, b):
|
|
return a + b
|
|
|
|
for i in range(5):
|
|
print(sumar(i, 1))
|
|
""").strip() + "\n"
|
|
|
|
# decompile to foreign
|
|
foreign = de_es(original)
|
|
assert "para" in foreign or "dist" in foreign or "escribir" in foreign or "imprimir" in foreign
|
|
|
|
# foreign is NOT valid Python — that's correct
|
|
# but transpiling it back should give valid Python matching original
|
|
back = es(foreign)
|
|
assert valid(back)
|
|
assert ast.dump(ast.parse(original)) == ast.dump(ast.parse(back))
|
|
|
|
|
|
def test_decompile_exceptions_fixed():
|
|
src = textwrap.dedent("""
|
|
try:
|
|
x = 1 / 0
|
|
except ZeroDivisionError:
|
|
x = 0
|
|
""").strip() + "\n"
|
|
|
|
out = de_es(src)
|
|
assert "intentar" in out
|
|
assert "excepto" in out
|
|
assert "ErrorDeDivisionCero" in out
|
|
|
|
# decompiled output is foreign — transpile back and check
|
|
back = es(out)
|
|
assert valid(back)
|