Parseo de enteros

Para mi caso, quise probar que al tener ambas expresiones (identificadores y enteros) se estuviera devolviendo bien la cadena, sin embargo, gracias a este test me di cuenta que en el archivo ast.py estábamos devolviendo el statement sin “;” desde el dunder methos de __str__, eso hacía que el test fallara porque “foo” era diferente de “foo;” (lo expectado), así que lo primero que hice fue arreglar el dunder method __str__ de la clase ExpressionStatement:

    def __str__(self) -> str:
        return f"{str(self.expression)};"

Y por último, ahora si puse mis tests que revisan ambas expresiones, integers e identificadores 😄

    def test_expression_statement(self) -> None:

        program: Program = Program(statements=[

            ExpressionStatement(

                token=Token(TokenType.IDENT, literal="foobar"),

                expression=Identifier(
                    token=Token(TokenType.IDENT, literal="foobar"),
                    value="foobar"
                )

            ),

            ExpressionStatement(

                token=Token(TokenType.INT, literal="5"),

                expression=Identifier(
                    token=Token(TokenType.INT, literal="5"),
                    value="5"
                )

            )

        ])

        program_str = str(program)
        self.assertEquals(program_str, "foobar;5;")

Hola a todos, esta fue mi solución al reto:

deftest_integer_expressions(self) -> None:
        program: Program = Program(statements=[
            LetStatement(
                token=Token(TokenType.LET, literal='variable'),
                name=Identifier(
                    token=Token(TokenType.IDENT, literal='cinco'),
                    value='cinco'
                ),
                value=Integer(
                    token=Token(TokenType.INT, literal='5'),
                    value=5
                )
            )
        ])

        program_str = str(program)

        self.assertEquals(program_str, 'variable cinco = 5;')

Aquí esta el reto, aunque no estoy del todo claro si lo hice bien, agradecería mucho si alguien pudiera corroborar el test que hice

    def test_intergers_in_statements(self) ->None:
        program: Program = Program(statements=[
            LetStatement(
                token = Token(TokenType.LET, literal='variable'),
                name=Identifier(
                    token = Token(TokenType.IDENT, literal='chocolates'),
                    value= 'chocolates'
                ),
                value= Identifier(
                    token = Token(TokenType.INT, literal='10'),
                    value= '10'
                ),
            ),
            ReturnStatement(
                token = Token(TokenType.RETURN, literal='regresa'),
                return_value= Identifier(
                    token = Token(TokenType.INT, literal='5'),
                    value= '5'
                ),
            )
        ])

        expected_statement: List[str] = [
            'variable chocolates = 10;',
            'regresa 5;'
        ]
        self.assertEquals(str(program.statements[0]), expected_statement[0])
        self.assertEquals(str(program.statements[1]), expected_statement[1])

LPP languaje powerfull --Pues es el curso mas “profundo” que he visto en Platzi, no se si seré capaz de entenderlo todo.

Aqui les dejo el reto, hice tres funciones para probar esto

variable mi_var = 8;
regresa 8;
8;

    def test_return_statement_with_integer(self) -> None:
        program: Program = Program(statements=[
            ReturnStatement(
                token=Token(TokenType.RETURN, literal='regresa'),
                return_value=Integer(
                    token=Token(TokenType.INT, '6'),
                    value=6
                ),
            )
        ])

        program_str = str(program)
        self.assertEquals(program_str, 'regresa 6;')

    def test_integer_expressions(self) -> None:
        program: Program = Program(statements=[
            ExpressionStatement(
                token=Token(TokenType.INT, literal='5'),
                expression=Integer(
                    token=Token(TokenType.INT, literal='5'),
                    value=5
                )
            )
        ])

        program_str = str(program)

        self.assertEquals(program_str, '5')

    def test_let_statement_with_integer(self) -> None:
        program: Program = Program(statements=[
            LetStatement(
                token=Token(TokenType.LET, literal='variable'),
                name=Identifier(
                    token=Token(TokenType.IDENT, literal='mi_var'),
                    value='mi_var'
                ),
                value=Integer(
                    token=Token(TokenType.INT, literal='8'),
                    value=8
                )
            )
        ])

        program_str = str(program)
        self.assertEquals(program_str, 'variable mi_var = 8;')

Quise pasar por aquí como hice para crear un tipo de token float, pero parece que escribí mucho y no se publicó, así que pasó el link del repo donde lo estoy subiendo para los que se quieran guiar. Aqui

Yo lo hice de esta forma

def test_integer_in_let_and_return_statement(self) -> None:
        program: Program = Program(statements=[
            LetStatement(
                token=Token(
                    TokenType.LET,
                    literal="var"
                ),
                name=Identifier(
                    token=Token(TokenType.IDENT, literal="mi_num"),
                    value="mi_num"
                ),
                value=Integer(
                    token=Token(TokenType.INT, literal="5"),
                    value=5
                )
            ),
            ReturnStatement(
                token=Token(TokenType.RETURN, literal="regresa"),
                return_value=Identifier(
                    token=Token(TokenType.IDENT, literal="mi_num"),
                    value="mi_num"
                )
            )
        ])

        program_str = str(program)

        self.assertEquals(program_str, 'var mi_num = 5;regresa mi_num;')