public void LlamadasRecursivasTest()
{
using (var lexer = new FTCCompiler.Lexer("LlamadasRecursivas.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(false, tree.HasErrors);
Assert.AreEqual(0, _resultList.Count);
}
}
public void IdentificadorDuplicadoDiferenteEntornoTest()
{
using (var lexer = new FTCCompiler.Lexer("IdentificadorDuplicadoDiferenteEntorno.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(false, tree.HasErrors);
Assert.AreEqual(0, _resultList.Count);
}
}
public void WhileCondicionFuncionBooleanTest()
{
using (var lexer = new FTCCompiler.Lexer("WhileCondicionFuncionBoolean.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(false, tree.HasErrors);
Assert.AreEqual(0, _resultList.Count);
}
}
public void LlamarProcEnEntornoLocalTest()
{
using (var lexer = new FTCCompiler.Lexer("LlamarProcEnEntornoLocal.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(false, tree.HasErrors);
Assert.AreEqual(0, _resultList.Count);
}
}
public void AsignacionArrayCorrectaTest()
{
using (var lexer = new FTCCompiler.Lexer("AsignacionArrayCorrecta.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(false, tree.HasErrors);
Assert.AreEqual(0, _resultList.Count);
}
}
public void FuncionUsaParametrosTest()
{
using (var lexer = new FTCCompiler.Lexer("FuncionUsaParametros.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(false, tree.HasErrors);
Assert.AreEqual(0, _resultList.Count);
}
}
public void DeclaracionParametrosDuplicadosTest()
{
using (var lexer = new FTCCompiler.Lexer("DeclaracionParametrosDuplicados.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[5,42] SEM: Ya existe un identificador con el nombre 'N'.", _resultList[0]);
}
}
public void ProcedimientoInexistenteTest()
{
using (var lexer = new FTCCompiler.Lexer("ProcedimientoInexistente.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[49,9] SEM: No se encontró un procedimiento con nombre 'PROC20'.", _resultList[0]);
}
}
public void FuncionInexistenteTest()
{
using (var lexer = new FTCCompiler.Lexer("FuncionInexistente.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[22,13] SEM: No se encontró una función con nombre 'FUN10'.", _resultList[0]);
}
}
public void FuncionRetornoNoCoincideConTipoDatoRetornoTest()
{
using (var lexer = new FTCCompiler.Lexer("FuncionRetornoNoCoincideConTipoDatoRetorno.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[17,1] SEM: Se esperaba una expresión 'Integer' y se encontró una del tipo 'Boolean'.", _resultList[0]);
}
}
public void PasajeParametrosTipoArrayTest()
{
using (var lexer = new FTCCompiler.Lexer("PasajeParametrosTipoArray.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[13,7] SEM: En la llamada a 'PROC' no se puede pasar un array como parámetro.", _resultList[0]);
}
}
public void PasajeParametrosMenosParametrosTest()
{
using (var lexer = new FTCCompiler.Lexer("PasajeParametrosMenosParametros.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[13,7] SEM: La cantidad de parametros proporcionados o el tipo de los mismos no coinciden con la definición de 'PROC'.", _resultList[0]);
}
}
public void DeclaracionDeArrayFueraDeEntornoGlobalTest()
{
using (var lexer = new FTCCompiler.Lexer("DeclaracionDeArrayFueraDeEntornoGlobal.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[4,5] SEM: No se puede declarar un array fuera del entorno global.", _resultList[0]);
}
}
public void ExampleTest()
{
using (var lexer = new FTCCompiler.Lexer("Example.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => { _resultList.Add(s); });
parser.Parse();
Assert.IsTrue(_resultList[0] == "[16,12] SIN: Se esperaba ':=' y se encontró ''Visualizacion''.");
Assert.IsTrue(_resultList[1] == "[21,27] SIN: Se esperaba 'integer','boolean' y se encontró 'entero'.");
Assert.IsTrue(_resultList[2] == "[35,12] SIN: Se esperaba 'end-proc' y se encontró ';'.");
Assert.AreEqual(_resultList.Count, 3);
}
}
public void IdentificadorDuplicadoMismoEntornoTest()
{
using (var lexer = new FTCCompiler.Lexer("IdentificadorDuplicadoMismoEntorno.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[3,5] SEM: Ya existe un identificador con el nombre 'A'.", _resultList[0]);
}
}
public void AsignacionDistintoTipoDatoAsignableTest()
{
using (var lexer = new FTCCompiler.Lexer("AsignacionDistintoTipoDatoAsignable.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[5,9] SEM: Se esperaba una expresión 'Integer' y se encontró una del tipo 'Boolean'.", _resultList[0]);
}
}
public void AsignacionIdentificadorInexistenteTest()
{
using (var lexer = new FTCCompiler.Lexer("AsignacionIdentificadorInexistente.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[4,2] SEM: No se encontró el identificador 'M'.", _resultList[0]);
}
}
public void AsignacionExpresionAConstanteTest()
{
using (var lexer = new FTCCompiler.Lexer("AsignacionExpresionAConstante.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[5,2] SEM: No se puede hacer una asignación a una constante", _resultList[0]);
}
}
public void WhileCondicionFuncionIntegerTest()
{
using (var lexer = new FTCCompiler.Lexer("WhileCondicionFuncionInteger.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("[9,3] SEM: Se esperaba una expresión 'Boolean' y se encontró una del tipo 'Integer'.", _resultList[0]);
}
}
public void MainConEntornoLocalTest()
{
using (var lexer = new FTCCompiler.Lexer("MainConEntornoLocal.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(1, _resultList.Count);
Assert.AreEqual("SEM: El procedimiento MAIN no puede tener un entorno local.", _resultList[0]);
}
}
public void ShowIdentificadorInexistenteTest()
{
using (var lexer = new FTCCompiler.Lexer("ShowIdentificadorInexistente.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(2, _resultList.Count);
Assert.AreEqual("[13,9] SEM: No se encontró el identificador 'X'.", _resultList[0]);
Assert.AreEqual("[13,8] SEM: La expresión no puede ser nula.", _resultList[1]);
}
}
public void AsignacionIdentificadorFueraDeScopeTest()
{
using (var lexer = new FTCCompiler.Lexer("AsignacionIdentificadorFueraDeScope.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(2, _resultList.Count);
Assert.AreEqual("[8,7] SEM: No se encontró el identificador 'X'.", _resultList[0]);
Assert.AreEqual("[14,7] SEM: No se encontró el identificador 'B'.", _resultList[1]);
}
}
public void WhileCondicionProcedimientoTest()
{
using (var lexer = new FTCCompiler.Lexer("WhileCondicionProcedimiento.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(2, _resultList.Count);
Assert.AreEqual("[10,13] SEM: No se encontró una función con nombre 'PROC'.", _resultList[0]);
Assert.AreEqual("[10,3] SEM: Se esperaba una expresión 'Boolean' y se encontró una del tipo 'Integer'.", _resultList[1]);
}
}
public void PasajeParametrosIdentificadorInexistenteTest()
{
using (var lexer = new FTCCompiler.Lexer("PasajeParametrosIdentificadorInexistente.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(2, _resultList.Count);
Assert.AreEqual("[14,10] SEM: No se encontró el identificador 'K'.", _resultList[0]);
Assert.AreEqual("[14,8] SEM: La cantidad de parametros proporcionados o el tipo de los mismos no coinciden con la definición de 'PROC1'.", _resultList[1]);
}
}
public void ArrayIndiceExpresionNoEnteraTest()
{
using (var lexer = new FTCCompiler.Lexer("ArrayIndiceExpresionNoEntera.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(3, _resultList.Count);
Assert.AreEqual("[10,16] SEM: El indice de un vector debe ser una expresión entera.", _resultList[0]);
Assert.AreEqual("[11,14] SEM: El indice de un vector debe ser una expresión entera.", _resultList[1]);
Assert.AreEqual("[12,15] SEM: El indice de un vector debe ser una expresión entera.", _resultList[2]);
}
}
public void ExampleSinErroresTest()
{
using (var lexer = new FTCCompiler.Lexer("ExampleSinErrores.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
using (var tw = File.CreateText(@"D:\syntaxTree.xml"))
{
tree.Serialize(tw.BaseStream);
}
Assert.AreEqual(_resultList.Count, 0);
}
}
public void SubroutineTest()
{
using (var lexer = new FTCCompiler.Lexer("Subroutine.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => { _resultList.Add(s); });
var tree = parser.Parse();
//using (var tw = File.CreateText(@"C:\Users\Ivan\Documents\Proyectos\FTC Compiler\tree\syntaxTree.xml"))
//{
// tree.Serialize(tw.BaseStream);
//}
// Assert.AreEqual(_resultList.Count, 0);
}
}
public void AsignacionArrayIncorrectaTest()
{
using (var lexer = new FTCCompiler.Lexer("AsignacionArrayIncorrecta.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(3, _resultList.Count);
Assert.AreEqual("[7,11] SEM: Se esperaba una expresión 'Integer' y se encontró una del tipo 'Boolean'.", _resultList[0]);
Assert.AreEqual("[8,8] SEM: No se encontró el identificador 'X'.", _resultList[1]);
Assert.AreEqual("[9,8] SEM: Se esperaba una expresión 'Integer' y se encontró una del tipo 'Boolean'.", _resultList[2]);
}
}
public void OperacionMenorNoEnterosEnCondicionTest()
{
using (var lexer = new FTCCompiler.Lexer("OperacionMenorNoEnterosEnCondicion.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => _resultList.Add(s));
var tree = parser.Parse();
Assert.AreEqual(true, tree.HasErrors);
Assert.AreEqual(3, _resultList.Count);
Assert.AreEqual("[11,15] SEM: Se esperaba una expresión 'Integer' y se encontró una del tipo 'Boolean'.", _resultList[0]);
Assert.AreEqual("[12,19] SEM: Se esperaba una expresión 'Integer' y se encontró una del tipo 'Boolean'.", _resultList[1]);
Assert.AreEqual("[13,21] SEM: Se esperaba una expresión 'Integer' y se encontró una del tipo 'Boolean'.", _resultList[2]);
}
}
public void ShouldFailWithInvalidExpression()
{
using (var lexer = new FTCCompiler.Lexer("InvalidExpression1.txt"))
{
var parser = new FTCCompiler.Parser(lexer, (s) => { _resultList.Add(s); });
var tree = parser.Parse();
using (var tw = File.CreateText(@"C:\Users\Ivan\Documents\Proyectos\FTC Compiler\tree\syntaxTree.xml"))
{
tree.Serialize(tw.BaseStream);
}
Assert.IsTrue(_resultList[0] == "[4,13] SIN: Se esperaba ';' y se encontró 'M'.");
Assert.AreEqual(_resultList.Count, 1);
}
}