llvm-journey

LLVM Journey
git clone git://0xff.ir/g/llvm-journey.git
Log | Files | Refs | README | LICENSE

kaleidoscope_ast.test.cpp (3183B)

      1 
      2 #include "kaleidoscope_ast.hpp"
      3 
      4 #define CATCH_CONFIG_MAIN
      5 #define CATCH_CONFIG_COLOUR_NONE
      6 #include <catch2/catch.hpp>
      7 
      8 #include <array>
      9 
     10 TEST_CASE("to_string", "[str]")
     11 {
     12   SECTION("static_assert the size of ASTNode")
     13   {
     14     static_assert(sizeof(kal::ASTNode) == sizeof(std::shared_ptr<int>), "");
     15   }
     16 
     17   SECTION("Number")
     18   {
     19     std::array<kal::Number, 5> n{ 0, 1, -1, 3.14159265, -3.1415926535 };
     20 
     21     REQUIRE(n[0].value == 0);
     22     REQUIRE(n[1].value == 1);
     23     REQUIRE(n[2].value == -1);
     24     REQUIRE(n[3].value == 3.14159265);
     25     REQUIRE(n[4].value == -3.1415926535);
     26 
     27     REQUIRE(kal::to_string(n[0]) == "(number 0)");
     28     REQUIRE(kal::to_string(n[1]) == "(number 1)");
     29     REQUIRE(kal::to_string(n[2]) == "(number -1)");
     30     REQUIRE(kal::to_string(n[3]) == "(number 3.14159)");  // FIXME str trunc
     31     REQUIRE(kal::to_string(n[4]) == "(number -3.14159)"); // FIXME str trunc
     32 
     33     kal::Number nDefault;
     34 
     35     (void)nDefault;
     36   }
     37 
     38   SECTION("Variable")
     39   {
     40     kal::Variable vDefault;
     41     kal::Variable v{ "var" };
     42 
     43     (void)vDefault;
     44     REQUIRE(v.name == "var");
     45   }
     46 
     47   SECTION("BinaryOp")
     48   {
     49     kal::BinaryOp opDefault;
     50 
     51     (void)opDefault;
     52 
     53     kal::Number n0{ 9.8 };
     54     kal::Number n1{ -2.72 };
     55     kal::BinaryOp op01{ '+', n0, n1 };
     56 
     57     REQUIRE(op01.op == '+');
     58     REQUIRE(op01.lhs == n0);
     59     REQUIRE(op01.rhs == n1);
     60 
     61     kal::Variable v0{ "var0" };
     62     kal::BinaryOp op02{ '*', v0, op01 };
     63 
     64     REQUIRE(op02.op == '*');
     65     REQUIRE(op02.lhs == v0);
     66     REQUIRE(op02.rhs == op01);
     67 
     68     kal::BinaryOp op03{ '/', op01, op02 };
     69 
     70     REQUIRE(op03.op == '/');
     71     REQUIRE(op03.lhs == op01);
     72     REQUIRE(op03.rhs == op02);
     73   }
     74 
     75   SECTION("Call")
     76   {
     77     kal::Call c0{ "pi", {} };
     78     kal::Call c1{ "tan2", { kal::Number{ 3.14 / 6 }, kal::Variable{ "y" } } };
     79 
     80     REQUIRE(kal::to_string(c0) == "(call pi)");
     81     // FIXME stod truncation
     82     REQUIRE(kal::to_string(c1) == "(call tan2 (number 0.523333) (variable y))");
     83 
     84     kal::Call cDefault;
     85 
     86     (void)cDefault;
     87   }
     88 
     89   SECTION("Prototype")
     90   {
     91     kal::Prototype pDefault;
     92     kal::Prototype p{ "memcmp", { "dest", "src", "n" } };
     93 
     94     (void)pDefault;
     95 
     96     REQUIRE(p.name == "memcmp");
     97     REQUIRE(p.params.size() == 3);
     98     REQUIRE(p.params.at(0) == "dest");
     99     REQUIRE(p.params.at(1) == "src");
    100     REQUIRE(p.params.at(2) == "n");
    101   }
    102 
    103   SECTION("Function")
    104   {
    105     kal::Function fDefault;
    106     kal::Function fun{
    107       kal::Prototype{ "fun", { "x", "y", "z" } },
    108       // (- (* b b) (* (* 4 a) c))
    109       kal::BinaryOp{
    110         '-',
    111         kal::BinaryOp{ '*', kal::Variable{ "b" }, kal::Variable{ "b" } },
    112         kal::BinaryOp{
    113           '*',
    114           kal::BinaryOp{ '*', kal::Number{ 4 }, kal::Variable{ "a" } },
    115           kal::Variable{ "c" },
    116         } }
    117     };
    118 
    119     (void)fDefault;
    120 
    121     REQUIRE(kal::to_string(fun) ==
    122             "(function (prototype fun x y z) (binop '-' (binop '*' (variable "
    123             "b) (variable b)) (binop '*' (binop '*' (number 4) (variable a)) "
    124             "(variable c))))");
    125   }
    126 
    127   SECTION("ASTNode")
    128   {
    129     kal::ASTNode nDefault;
    130     kal::ASTNode n{ kal::Number{ 10 } };
    131 
    132     (void)nDefault;
    133 
    134     using kal::to_string;
    135 
    136     REQUIRE(to_string(n) == "(number 10)");
    137   }
    138 }