Line data    Source code

       1              : #include "../inc/lexicalAnalysis/nicoleSintax.h"
       2              : #include <catch2/catch_test_macros.hpp>
       3              : 
       4            9 : TEST_CASE("The lexer works", "[Lexer]") {
       5              :   // Instancia de NicoleSintax
       6            9 :   const nicole::NicoleSintax sintax;
       7              :   // Crear el Lexer
       8            9 :   const nicole::Lexer lexer{sintax.createLexer()};
       9              :   // Verificar que las categorías del Lexer no estén vacías
      10            9 :   REQUIRE_FALSE(lexer.categories().empty());
      11              :   // Ruta al archivo fuente de prueba
      12            9 :   std::filesystem::path testFile{"../examples/literals/literals.nc"};
      13              :   // Analizar el archivo fuente
      14            9 :   std::expected<nicole::TokenStream, nicole::Error> result{
      15            9 :       lexer.analyze(testFile)};
      16              :   // Verificar que el análisis fue exitoso
      17            9 :   REQUIRE(result.has_value());
      18              :   // Verificar que el TokenStream no esté vacío
      19            9 :   REQUIRE(result->size() == 99);
      20              : 
      21              :   // Ruta al archivo fuente de prueba
      22            9 :   testFile = std::filesystem::path{"../examples/loops/matrix.nc"};
      23              :   // Analizar el archivo fuente
      24            9 :   result = lexer.analyze(testFile);
      25              :   // Verificar que el análisis fue exitoso
      26            9 :   REQUIRE(result.has_value());
      27              :   // Verificar que el TokenStream no esté vacío
      28            9 :   REQUIRE(result->size() == 84);
      29              : 
      30              :   // Ruta al archivo fuente de prueba
      31            9 :   testFile = std::filesystem::path{"../examples/conditionals/conditionals.nc"};
      32              :   // Analizar el archivo fuente
      33            9 :   result = lexer.analyze(testFile);
      34              :   // Verificar que el análisis fue exitoso
      35            9 :   REQUIRE(result.has_value());
      36              :   // Verificar que el TokenStream no esté vacío
      37            9 :   REQUIRE(result->size() == 147);
      38              : 
      39              :   // Ruta al archivo fuente de prueba
      40            9 :   testFile = std::filesystem::path{"../examples/conditionals/switch.nc"};
      41              :   // Analizar el archivo fuente
      42            9 :   result = lexer.analyze(testFile);
      43              :   // Verificar que el análisis fue exitoso
      44            9 :   REQUIRE(result.has_value());
      45              :   // Verificar que el TokenStream no esté vacío
      46            9 :   REQUIRE(result->size() == 78);
      47              : 
      48              :   // Ruta al archivo fuente de prueba
      49            9 :   testFile = std::filesystem::path{"../examples/functions/functions.nc"};
      50              :   // Analizar el archivo fuente
      51            9 :   result = lexer.analyze(testFile);
      52              :   // Verificar que el análisis fue exitoso
      53            9 :   REQUIRE(result.has_value());
      54              :   // Verificar que el TokenStream no esté vacío
      55            9 :   REQUIRE(result->size() == 172);
      56              : 
      57              :   // Ruta al archivo fuente de prueba
      58            9 :   testFile = std::filesystem::path{"../examples/imports/import1.nc"};
      59              :   // Analizar el archivo fuente
      60            9 :   result = lexer.analyze(testFile);
      61              :   // Verificar que el análisis fue exitoso
      62            9 :   REQUIRE(result.has_value());
      63              :   // Verificar que el TokenStream no esté vacío
      64            9 :   REQUIRE(result->size() == 25);
      65              : 
      66              :   // Ruta al archivo fuente de prueba
      67            9 :   testFile = std::filesystem::path{"../examples/operations/opWithVariables.nc"};
      68              :   // Analizar el archivo fuente
      69            9 :   result = lexer.analyze(testFile);
      70              :   // Verificar que el análisis fue exitoso
      71            9 :   REQUIRE(result.has_value());
      72              :   // Verificar que el TokenStream no esté vacío
      73            9 :   REQUIRE(result->size() == 202);
      74              : 
      75              :   // Ruta al archivo fuente de prueba
      76            9 :   testFile = std::filesystem::path{"../examples/userTypes/classes.nc"};
      77              :   // Analizar el archivo fuente
      78            9 :   result = lexer.analyze(testFile);
      79              :   // Verificar que el análisis fue exitoso
      80            9 :   REQUIRE(result.has_value());
      81              :   // Verificar que el TokenStream no esté vacío
      82            9 :   REQUIRE(result->size() == 60);
      83              : 
      84              :   // Ruta al archivo fuente de prueba
      85            9 :   testFile = std::filesystem::path{"../examples/hsufhuhdf"};
      86              :   // Analizar el archivo fuente
      87            9 :   result = lexer.analyze(testFile);
      88              :   // Verificar que el análisis fue exitoso
      89            9 :   REQUIRE(result.error().type() == nicole::ERROR_TYPE::FILE_EXTENSION);
      90              : 
      91              :   // Ruta al archivo fuente de prueba
      92            9 :   testFile = std::filesystem::path{"../examples/unmatched/unmatched"};
      93              :   // Analizar el archivo fuente
      94            9 :   result = lexer.analyze(testFile);
      95              :   // Verificar que el análisis fue exitoso
      96            9 :   REQUIRE(result.error().type() == nicole::ERROR_TYPE::FILE_EXTENSION);
      97              : 
      98              :   // Ruta al archivo fuente de prueba
      99            9 :   testFile = std::filesystem::path{"../examples/unmatched/unmatched.nc"};
     100              :   // Analizar el archivo fuente
     101            9 :   result = lexer.analyze(testFile);
     102              :   // Verificar que el análisis fue exitoso
     103            9 :   REQUIRE(result.error().type() == nicole::ERROR_TYPE::CHECK_UNMATCHED);
     104            9 : }