Line data    Source code

       1              : #include "../inc/errors.h"
       2              : #include <catch2/catch_test_macros.hpp>
       3              : #include <sstream>
       4              : 
       5           36 : TEST_CASE("Pruebas de la clase Error", "[error]") {
       6           36 :   using nicole::Error;
       7           36 :   using nicole::ERROR_TYPE;
       8              : 
       9           36 :   SECTION("Constructor y atributos") {
      10            9 :     const Error error{ERROR_TYPE::MISSING_ARGUMENTS,
      11            9 :                       "Se necesitan más argumentos"};
      12            9 :     std::ostringstream oss;
      13            9 :     oss << error;
      14              : 
      15            9 :     REQUIRE(error.info() == "Se necesitan más argumentos");
      16            9 :     REQUIRE(oss.str() ==
      17            9 :             "Error MISSING_ARGUMENTS: Se necesitan más argumentos");
      18            9 :   }
      19              : 
      20           36 :   SECTION("Tipos de errores y mensajes asociados") {
      21            9 :     const Error errorBinaryName{ERROR_TYPE::MISSING_BINARY_NAME,
      22            9 :                                 "Nombre de binario no proporcionado"};
      23            9 :     std::ostringstream ossBinaryName;
      24            9 :     ossBinaryName << errorBinaryName;
      25              : 
      26            9 :     REQUIRE(errorBinaryName.info() == "Nombre de binario no proporcionado");
      27            9 :     REQUIRE(ossBinaryName.str() ==
      28            9 :             "Error MISSING_BINARY_NAME: Nombre de binario no proporcionado");
      29              : 
      30            9 :     const Error errorFileNotFound{ERROR_TYPE::ENTRY_FILE_NOT_FOUND,
      31            9 :                                   "Archivo de entrada no encontrado"};
      32            9 :     std::ostringstream ossFileNotFound;
      33            9 :     ossFileNotFound << errorFileNotFound;
      34              : 
      35            9 :     REQUIRE(errorFileNotFound.info() == "Archivo de entrada no encontrado");
      36            9 :     REQUIRE(ossFileNotFound.str() ==
      37            9 :             "Error ENTRY_FILE_NOT_FOUND: Archivo de entrada no encontrado");
      38            9 :   }
      39              : 
      40           36 :   SECTION("Errores de lexer") {
      41            9 :     const Error errorUnmatched{ERROR_TYPE::CHECK_UNMATCHED,
      42            9 :                                "Token no reconocido"};
      43            9 :     std::ostringstream ossUnmatched;
      44            9 :     ossUnmatched << errorUnmatched;
      45              : 
      46            9 :     REQUIRE(errorUnmatched.info() == "Token no reconocido");
      47            9 :     REQUIRE(ossUnmatched.str() == "Error CHECK_UNMATCHED: Token no reconocido");
      48              : 
      49            9 :     const Error errorFileExtension{ERROR_TYPE::FILE_EXTENSION,
      50            9 :                                    "Extensión de archivo no válida"};
      51            9 :     std::ostringstream ossFileExtension;
      52            9 :     ossFileExtension << errorFileExtension;
      53              : 
      54            9 :     REQUIRE(errorFileExtension.info() == "Extensión de archivo no válida");
      55            9 :     REQUIRE(ossFileExtension.str() ==
      56            9 :             "Error FILE_EXTENSION: Extensión de archivo no válida");
      57            9 :   }
      58              : 
      59           36 :   SECTION("Errores de flujo de tokens") {
      60            9 :     const Error errorEat{ERROR_TYPE::EAT,
      61            9 :                          "No se puede consumir el token actual"};
      62            9 :     std::ostringstream ossEat;
      63            9 :     ossEat << errorEat;
      64              : 
      65            9 :     REQUIRE(errorEat.info() == "No se puede consumir el token actual");
      66            9 :     REQUIRE(ossEat.str() == "Error EAT: No se puede consumir el token actual");
      67              : 
      68            9 :     const Error errorLookAhead{ERROR_TYPE::LOOK_AHEAD,
      69            9 :                                "No se puede mirar más allá en el flujo"};
      70            9 :     std::ostringstream ossLookAhead;
      71            9 :     ossLookAhead << errorLookAhead;
      72              : 
      73            9 :     REQUIRE(errorLookAhead.info() == "No se puede mirar más allá en el flujo");
      74            9 :     REQUIRE(ossLookAhead.str() ==
      75            9 :             "Error LOOK_AHEAD: No se puede mirar más allá en el flujo");
      76            9 :   }
      77           36 : }