Skip to content
Snippets Groups Projects
Select Git revision
  • 0887dbcca63e1ade29faab5e408dc550bae8402a
  • develop default protected
  • feature/gmsh-reader
  • origin/stage/bouguettaia
  • feature/kinetic-schemes
  • feature/reconstruction
  • feature/local-dt-fsi
  • feature/composite-scheme-sources
  • feature/composite-scheme-other-fluxes
  • feature/serraille
  • feature/variational-hydro
  • feature/composite-scheme
  • hyperplastic
  • feature/polynomials
  • feature/gks
  • feature/implicit-solver-o2
  • feature/coupling_module
  • feature/implicit-solver
  • feature/merge-local-dt-fsi
  • master protected
  • feature/escobar-smoother
  • v0.5.0 protected
  • v0.4.1 protected
  • v0.4.0 protected
  • v0.3.0 protected
  • v0.2.0 protected
  • v0.1.0 protected
  • Kidder
  • v0.0.4 protected
  • v0.0.3 protected
  • v0.0.2 protected
  • v0 protected
  • v0.0.1 protected
33 results

test_Stop.cpp

Blame
    • test_AffectationProcessor.cpp 45.80 KiB 
    #include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_all.hpp>

#include <language/ast/ASTBuilder.hpp>
#include <language/ast/ASTModulesImporter.hpp>
#include <language/ast/ASTNodeAffectationExpressionBuilder.hpp>
#include <language/ast/ASTNodeDataTypeBuilder.hpp>
#include <language/ast/ASTNodeDeclarationToAffectationConverter.hpp>
#include <language/ast/ASTNodeExpressionBuilder.hpp>
#include <language/ast/ASTNodeTypeCleaner.hpp>
#include <language/ast/ASTSymbolTableBuilder.hpp>
#include <language/utils/ASTPrinter.hpp>
#include <utils/Demangle.hpp>

#include <pegtl/string_input.hpp>

#include <sstream>

#define CHECK_AFFECTATION_RESULT(data, variable_name, expected_value)         \
  {                                                                           \
    TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};                \
    auto ast = ASTBuilder::build(input);                                      \
                                                                              \
    ASTModulesImporter{*ast};                                                 \
                                                                              \
    ASTSymbolTableBuilder{*ast};                                              \
    ASTNodeDataTypeBuilder{*ast};                                             \
                                                                              \
    ASTNodeDeclarationToAffectationConverter{*ast};                           \
    ASTNodeTypeCleaner<language::var_declaration>{*ast};                      \
                                                                              \
    ASTNodeExpressionBuilder{*ast};                                           \
    ExecutionPolicy exec_policy;                                              \
    ast->execute(exec_policy);                                                \
                                                                              \
    auto symbol_table = ast->m_symbol_table;                                  \
                                                                              \
    using namespace TAO_PEGTL_NAMESPACE;                                      \
    position use_position{internal::iterator{"fixture"}, "fixture"};          \
    use_position.byte    = 10000;                                             \
    auto [symbol, found] = symbol_table->find(variable_name, use_position);   \
                                                                              \
    auto attributes = symbol->attributes();                                   \
    auto value      = std::get<decltype(expected_value)>(attributes.value()); \
                                                                              \
    REQUIRE(value == expected_value);                                         \
  }

#define CHECK_AFFECTATION_THROWS_WITH(data, error_message)              \
  {                                                                     \
    TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};          \
    auto ast = ASTBuilder::build(input);                                \
                                                                        \
    ASTModulesImporter{*ast};                                           \
                                                                        \
    ASTSymbolTableBuilder{*ast};                                        \
    ASTNodeDataTypeBuilder{*ast};                                       \
                                                                        \
    ASTNodeDeclarationToAffectationConverter{*ast};                     \
    ASTNodeTypeCleaner<language::var_declaration>{*ast};                \
                                                                        \
    REQUIRE_THROWS_WITH(ASTNodeExpressionBuilder{*ast}, error_message); \
  }

#define CHECK_BUILD_THROWS_WITH(data, error_message)              \
  {                                                               \
    TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};    \
    REQUIRE_THROWS_WITH(ASTBuilder::build(input), error_message); \
  }

    // clazy:excludeall=non-pod-global-static

TEST_CASE("AffectationProcessor", "[language]")
{
  SECTION("Affectations")
  {
    SECTION("basic types")
    {
      SECTION("B")
      {
        CHECK_AFFECTATION_RESULT("let b : B; b = true;", "b", true);
      }

      SECTION("N")
      {
        CHECK_AFFECTATION_RESULT("let n : N, n = 1;", "n", 1ul);
        CHECK_AFFECTATION_RESULT("let m : N, m = 2; let n : N, n = m;", "n", 2ul);
        CHECK_AFFECTATION_RESULT("let n : N, n = true;", "n", 1ul);
        CHECK_AFFECTATION_RESULT("let n : N, n = false;", "n", 0ul);
      }

      SECTION("Z")
      {
        CHECK_AFFECTATION_RESULT("let z : Z, z = -1;", "z", -1l);
        CHECK_AFFECTATION_RESULT("let z : Z, z = true;", "z", 1l);
        CHECK_AFFECTATION_RESULT("let z : Z, z = false;", "z", 0l);
      }

      SECTION("R")
      {
        CHECK_AFFECTATION_RESULT("let r : R, r = -1;", "r", double{-1});
        CHECK_AFFECTATION_RESULT("let r : R, r = true;", "r", double{1});
        CHECK_AFFECTATION_RESULT("let r : R, r = false;", "r", double{0});
        CHECK_AFFECTATION_RESULT("let r : R, r = -2.3;", "r", double{-2.3});
      }

      SECTION("R^1")
      {
        CHECK_AFFECTATION_RESULT("let x : R^1, x = -1;", "x", (TinyVector<1>{-1}));
        CHECK_AFFECTATION_RESULT("let x : R^1, x = true;", "x", (TinyVector<1>{true}));
        CHECK_AFFECTATION_RESULT("let x : R^1, x = false;", "x", (TinyVector<1>{false}));
        CHECK_AFFECTATION_RESULT("let x : R^1, x = -2.3;", "x", (TinyVector<1>{-2.3}));
        CHECK_AFFECTATION_RESULT("let x : R^1, x = [-1];", "x", (TinyVector<1>{-1}));
        CHECK_AFFECTATION_RESULT("let x : R^1, x = [true];", "x", (TinyVector<1>{true}));
        CHECK_AFFECTATION_RESULT("let x : R^1, x = [false];", "x", (TinyVector<1>{false}));
        CHECK_AFFECTATION_RESULT("let x : R^1, x = [-2.3];", "x", (TinyVector<1>{-2.3}));
        CHECK_AFFECTATION_RESULT("let x : R^1, x = 0;", "x", (TinyVector<1>{zero}));
      }

      SECTION("R^2")
      {
        CHECK_AFFECTATION_RESULT("let x : R^2, x = [-1, true];", "x", (TinyVector<2>{-1, true}));
        CHECK_AFFECTATION_RESULT("let x : R^2, x = [true, false];", "x", (TinyVector<2>{true, false}));
        CHECK_AFFECTATION_RESULT("let x : R^2, x = [-0.3, 12];", "x", (TinyVector<2>{-0.3, 12}));
        CHECK_AFFECTATION_RESULT("let x : R^2, x = 0;", "x", (TinyVector<2>{zero}));
      }

      SECTION("R^3")
      {
        CHECK_AFFECTATION_RESULT("let x : R^3, x = [-1, true, false];", "x", (TinyVector<3>{-1, true, false}));
        CHECK_AFFECTATION_RESULT("let x : R^3, x = [-0.3, 12, 6.2];", "x", (TinyVector<3>{-0.3, 12, 6.2}));
        CHECK_AFFECTATION_RESULT("let x : R^3; x = 0;", "x", (TinyVector<3>{zero}));
      }

      SECTION("R^1x1")
      {
        CHECK_AFFECTATION_RESULT("let x : R^1x1, x = -1;", "x", (TinyMatrix<1>{-1}));
        CHECK_AFFECTATION_RESULT("let x : R^1x1, x = true;", "x", (TinyMatrix<1>{true}));
        CHECK_AFFECTATION_RESULT("let x : R^1x1, x = false;", "x", (TinyMatrix<1>{false}));
        CHECK_AFFECTATION_RESULT("let x : R^1x1, x = -2.3;", "x", (TinyMatrix<1>{-2.3}));
            CHECK_AFFECTATION_RESULT("let x : R^1x1, x = [[-1]];", "x", (TinyMatrix<1>{-1}));
        CHECK_AFFECTATION_RESULT("let x : R^1x1, x = [[true]];", "x", (TinyMatrix<1>{true}));
        CHECK_AFFECTATION_RESULT("let x : R^1x1, x = [[false]];", "x", (TinyMatrix<1>{false}));
        CHECK_AFFECTATION_RESULT("let x : R^1x1, x = [[-2.3]];", "x", (TinyMatrix<1>{-2.3}));
        CHECK_AFFECTATION_RESULT("let x : R^1x1; x = 0;", "x", (TinyMatrix<1>{zero}));
      }

      SECTION("R^2x2")
      {
        CHECK_AFFECTATION_RESULT("let x : R^2x2, x = [[-1, true], [3, 5]];", "x", (TinyMatrix<2>{-1, true, 3, 5}));
        CHECK_AFFECTATION_RESULT("let x : R^2x2, x = [[true, false], [1==2, 2==2]];", "x",
                                 (TinyMatrix<2>{true, false, false, true}));
        CHECK_AFFECTATION_RESULT("let x : R^2x2, x = [[-0.3, 12],[2, -3]];", "x", (TinyMatrix<2>{-0.3, 12, 2, -3}));
        CHECK_AFFECTATION_RESULT("let x : R^2x2, x = 0;", "x", (TinyMatrix<2>{zero}));
      }

      SECTION("R^3x3")
      {
        CHECK_AFFECTATION_RESULT("let x : R^3x3, x = [[-1, true, false], [2, 3.1, 4], [-1, true, 2]];", "x",
                                 (TinyMatrix<3>{-1, true, false, 2, 3.1, 4, -1, true, 2}));
        CHECK_AFFECTATION_RESULT("let x : R^3x3, x = [[-0.3, 12, 6.2], [7.1, 3.2, 2-3], [2, -1, 0]];", "x",
                                 (TinyMatrix<3>{-0.3, 12, 6.2, 7.1, 3.2, 2 - 3, 2, -1, 0}));
        CHECK_AFFECTATION_RESULT("let x : R^3x3, x = 0;", "x", (TinyMatrix<3>{zero}));
      }
    }

    SECTION("lists")
    {
      SECTION("with (B)")
      {
        SECTION("from value")
        {
          std::string_view data = R"(
let (b1,b2): (B)*(B), (b1,b2) = (false, true);
)";

          CHECK_AFFECTATION_RESULT(data, "b1", (std::vector<bool>{false}));
          CHECK_AFFECTATION_RESULT(data, "b2", (std::vector<bool>{true}));
        }

        SECTION("from list")
        {
          std::string_view data = R"(
let (b1,b2): (B)*B, (b1,b2) = ((true,false), true);
)";

          CHECK_AFFECTATION_RESULT(data, "b1", (std::vector<bool>{true, false}));
          CHECK_AFFECTATION_RESULT(data, "b2", true);
        }

        SECTION("from (B)")
        {
          std::string_view data = R"(
let b : (B), b = (true, false);
let (b1,b2) : (B)*B, (b1,b2) = (b, false);
)";
          CHECK_AFFECTATION_RESULT(data, "b1", (std::vector<bool>{true, false}));
          CHECK_AFFECTATION_RESULT(data, "b2", false);
        }
      }

      SECTION("(N)")
      {
        SECTION("from value")
        {
          std::string_view data = R"(
let n:N, n = 9;
let (n1,n2,n3): (N)*(N)*(N), (n1,n2,n3) = (false, 1, n);
)";

              CHECK_AFFECTATION_RESULT(data, "n1", (std::vector<uint64_t>{false}));
          CHECK_AFFECTATION_RESULT(data, "n2", (std::vector<uint64_t>{1}));
          CHECK_AFFECTATION_RESULT(data, "n3", (std::vector<uint64_t>{9}));
        }

        SECTION("from list")
        {
          std::string_view data = R"(
let (n,m) :(N)*N, (n,m) = ((1,2,3), 7);
)";
          CHECK_AFFECTATION_RESULT(data, "n", (std::vector<uint64_t>{1, 2, 3}));
          CHECK_AFFECTATION_RESULT(data, "m", 7ul);
        }

        SECTION("from (B)")
        {
          std::string_view data = R"(
let b :(B), b = (true,false,true);
let (n,m) :(N)*(N), (n,m) = (b, (false,true));
)";
          CHECK_AFFECTATION_RESULT(data, "n", (std::vector<uint64_t>{1, 0, 1}));
          CHECK_AFFECTATION_RESULT(data, "m", (std::vector<uint64_t>{0, 1}));
        }

        SECTION("from (N)")
        {
          std::string_view data = R"(
let l:(N), l = (1,2,3);
let (n,m):(N)*(N), (n,m) = (l,(2,3,1));
)";
          CHECK_AFFECTATION_RESULT(data, "n", (std::vector<uint64_t>{1, 2, 3}));
          CHECK_AFFECTATION_RESULT(data, "m", (std::vector<uint64_t>{2, 3, 1}));
        }

        SECTION("from (Z)")
        {
          std::string_view data = R"(
let z:(Z), z = (1,2,3);
let (n,x):(N)*R, (n,x) = (z,2.3);
)";
          CHECK_AFFECTATION_RESULT(data, "n", (std::vector<uint64_t>{1, 2, 3}));
          CHECK_AFFECTATION_RESULT(data, "x", double{2.3});
        }
      }

      SECTION("(Z)")
      {
        SECTION("from value")
        {
          std::string_view data = R"(
let n:N, n = 9;
let (z1,z2,z3): (Z)*(Z)*(Z), (z1,z2,z3) = (false, -1, n);
)";

          CHECK_AFFECTATION_RESULT(data, "z1", (std::vector<int64_t>{false}));
          CHECK_AFFECTATION_RESULT(data, "z2", (std::vector<int64_t>{-1}));
          CHECK_AFFECTATION_RESULT(data, "z3", (std::vector<int64_t>{9}));
        }

        SECTION("from list")
        {
          std::string_view data = R"(
let (z1,z2):(Z)*(Z), (z1,z2) = ((1,2,3),(2,1,3));
)";
          CHECK_AFFECTATION_RESULT(data, "z1", (std::vector<int64_t>{1, 2, 3}));
          CHECK_AFFECTATION_RESULT(data, "z2", (std::vector<int64_t>{2, 1, 3}));
        }

        SECTION("from (N)")
        {
              std::string_view data = R"(
let m : (N), m = (1,2,3);
let (z,n) : (Z)*N, (z,n) = (m,2);
)";
          CHECK_AFFECTATION_RESULT(data, "z", (std::vector<int64_t>{1, 2, 3}));
          CHECK_AFFECTATION_RESULT(data, "n", 2ul);
        }

        SECTION("from (Z)")
        {
          std::string_view data = R"(
let z0:(Z), z0 = (1,2,3);
let (z,a): (Z)*Z, (z,a) = (z0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "z", (std::vector<int64_t>{1, 2, 3}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }
      }

      SECTION("(R)")
      {
        SECTION("from value")
        {
          std::string_view data = R"(
let n:N, n = 9;
let (r1,r2,r3,r4): (R)*(R)*(R)*(R), (r1,r2,r3,r4) = (false, -1, n, 2.3);
)";

          CHECK_AFFECTATION_RESULT(data, "r1", (std::vector<double>{false}));
          CHECK_AFFECTATION_RESULT(data, "r2", (std::vector<double>{-1}));
          CHECK_AFFECTATION_RESULT(data, "r3", (std::vector<double>{9}));
          CHECK_AFFECTATION_RESULT(data, "r4", (std::vector<double>{2.3}));
        }

        SECTION("from list")
        {
          std::string_view data = R"(
let (r1,r2):(R)*(R), (r1,r2) = ((1.2,2,3.1),(2.4,1,1.3));
)";
          CHECK_AFFECTATION_RESULT(data, "r1", (std::vector<double>{1.2, 2, 3.1}));
          CHECK_AFFECTATION_RESULT(data, "r2", (std::vector<double>{2.4, 1, 1.3}));
        }

        SECTION("from (N)")
        {
          std::string_view data = R"(
let m : (N), m = (1,2,3);
let (r,n) : (R)*N, (r,n) = (m,2);
)";
          CHECK_AFFECTATION_RESULT(data, "r", (std::vector<double>{1, 2, 3}));
          CHECK_AFFECTATION_RESULT(data, "n", 2ul);
        }

        SECTION("from (Z)")
        {
          std::string_view data = R"(
let z0:(Z), z0 = (1,2,3);
let (r,a): (R)*Z, (r,a) = (z0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "r", (std::vector<double>{1, 2, 3}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }

        SECTION("from (R)")
        {
          std::string_view data = R"(
let r0:(R), r0 = (1.2,2,3);
let (r,a): (R)*Z, (r,a) = (r0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "r", (std::vector<double>{1.2, 2, 3}));
              CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }
      }

      SECTION("(R^1)")
      {
        using R1 = TinyVector<1>;

        SECTION("from value")
        {
          std::string_view data = R"(
let n:N, n = 9;
let (X1,X2,X3,X4,X5): (R^1)*(R^1)*(R^1)*(R^1)*(R^1), (X1,X2,X3,X4,X5) = (false, -1, n, 2.3, [7.2]);
)";

          CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R1>{R1(false)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R1>{R1(-1)}));
          CHECK_AFFECTATION_RESULT(data, "X3", (std::vector<R1>{R1(9)}));
          CHECK_AFFECTATION_RESULT(data, "X4", (std::vector<R1>{R1(2.3)}));
          CHECK_AFFECTATION_RESULT(data, "X5", (std::vector<R1>{R1(7.2)}));
        }

        SECTION("from list")
        {
          std::string_view data = R"(
let (X1,X2):(R^1)*(R^1), (X1,X2) = (([1.2],2,3.1),([2.4],1, true,1.3));
)";
          CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R1>{R1(1.2), R1(2), R1(3.1)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R1>{R1(2.4), R1(1), R1(true), R1(1.3)}));
        }

        SECTION("from (N)")
        {
          std::string_view data = R"(
let m : (N), m = (1,2,3);
let (X,n) : (R^1)*N, (X,n) = (m,2);
)";
          CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1>{R1(1), R1(2), R1(3)}));
          CHECK_AFFECTATION_RESULT(data, "n", 2ul);
        }

        SECTION("from (Z)")
        {
          std::string_view data = R"(
let z0:(Z), z0 = (1,2,3);
let (X,a): (R^1)*Z, (X,a) = (z0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1>{R1(1), R1(2), R1(3)}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }

        SECTION("from (R)")
        {
          std::string_view data = R"(
let r0:(R), r0 = (1.2,2,3);
let (X,a): (R^1)*Z, (X,a) = (r0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1>{R1(1.2), R1(2), R1(3)}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }

        SECTION("from (R^1)")
        {
          std::string_view data = R"(
let X0:(R^1), X0 = (1.2,2,3);
let (X,a): (R^1)*Z, (X,a) = (X0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1>{R1(1.2), R1(2), R1(3)}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }
          }

      SECTION("R^2")
      {
        using R2 = TinyVector<2>;

        SECTION("from value")
        {
          std::string_view data = R"(
let (X1,X2): (R^2)*(R^2), (X1,X2) = ([1,2], 0);
)";

          CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R2>{R2(1, 2)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R2>{R2(0, 0)}));
        }

        SECTION("from list")
        {
          std::string_view data = R"(
let (X1,X2):(R^2)*(R^2), (X1,X2) = (([1.2, 2],0,[3,1]),([2.4,1],[true,1.3]));
)";
          CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R2>{R2(1.2, 2), R2(0, 0), R2(3, 1)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R2>{R2(2.4, 1), R2(true, 1.3)}));
        }

        SECTION("from (R^2)")
        {
          std::string_view data = R"(
let X0:(R^2), X0 = ([1.2,2],[3,1],0);
let (X,a): (R^2)*Z, (X,a) = (X0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R2>{R2(1.2, 2), R2(3, 1), R2(0, 0)}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }
      }

      SECTION("R^3")
      {
        using R3 = TinyVector<3>;

        SECTION("from value")
        {
          std::string_view data = R"(
let (X1,X2): (R^3)*(R^3), (X1,X2) = ([1,2,3], 0);
)";

          CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R3>{R3(1, 2, 3)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R3>{R3(0, 0, 0)}));
        }

        SECTION("from list")
        {
          std::string_view data = R"(
let (X1,X2):(R^3)*(R^3), (X1,X2) = (([5, 1.2, 2],0,[3,6,1]),([2.4,1,1.3],[true,1.3,2]));
)";
          CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R3>{R3(5, 1.2, 2), R3(0, 0, 0), R3(3, 6, 1)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R3>{R3(2.4, 1, 1.3), R3(true, 1.3, 2)}));
        }

        SECTION("from (R^3)")
        {
          std::string_view data = R"(
let X0:(R^3), X0 = ([1.2,-1.3,2],[3,1,5],0);
let (X,a): (R^3)*Z, (X,a) = (X0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R3>{R3(1.2, -1.3, 2), R3(3, 1, 5), R3(0, 0, 0)}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }
      }

          SECTION("R^1x1")
      {
        using R1x1 = TinyMatrix<1>;

        SECTION("from value")
        {
          std::string_view data = R"(
let n:N, n = 9;
let (X1,X2,X3,X4,X5): (R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1), (X1,X2,X3,X4,X5) = (false, -1, n, 2.3, [[7.2]]);
)";

          CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R1x1>{R1x1(false)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R1x1>{R1x1(-1)}));
          CHECK_AFFECTATION_RESULT(data, "X3", (std::vector<R1x1>{R1x1(9)}));
          CHECK_AFFECTATION_RESULT(data, "X4", (std::vector<R1x1>{R1x1(2.3)}));
          CHECK_AFFECTATION_RESULT(data, "X5", (std::vector<R1x1>{R1x1(7.2)}));
        }

        SECTION("from list")
        {
          std::string_view data = R"(
let (X1,X2):(R^1x1)*(R^1x1), (X1,X2) = (([[1.2]],2,3.1),([[2.4]],1, true,1.3));
)";
          CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R1x1>{R1x1(1.2), R1x1(2), R1x1(3.1)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R1x1>{R1x1(2.4), R1x1(1), R1x1(true), R1x1(1.3)}));
        }

        SECTION("from (N)")
        {
          std::string_view data = R"(
let m : (N), m = (1,2,3);
let (X,n) : (R^1x1)*N, (X,n) = (m,2);
)";
          CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1x1>{R1x1(1), R1x1(2), R1x1(3)}));
          CHECK_AFFECTATION_RESULT(data, "n", 2ul);
        }

        SECTION("from (Z)")
        {
          std::string_view data = R"(
let z0:(Z), z0 = (1,2,3);
let (X,a): (R^1x1)*Z, (X,a) = (z0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1x1>{R1x1(1), R1x1(2), R1x1(3)}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }

        SECTION("from (R)")
        {
          std::string_view data = R"(
let r0:(R), r0 = (1.2,2,3);
let (X,a): (R^1x1)*Z, (X,a) = (r0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1x1>{R1x1(1.2), R1x1(2), R1x1(3)}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }

        SECTION("from (R^1x1)")
        {
          std::string_view data = R"(
let X0:(R^1x1), X0 = (1.2,2,3);
let (X,a): (R^1x1)*Z, (X,a) = (X0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1x1>{R1x1(1.2), R1x1(2), R1x1(3)}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }
      }

      SECTION("R^2x2")
      {
            using R2x2 = TinyMatrix<2>;

        SECTION("from value")
        {
          std::string_view data = R"(
let (X1,X2): (R^2x2)*(R^2x2), (X1,X2) = ([[1,2],[3,4]], 0);
)";

          CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R2x2>{R2x2(1, 2, 3, 4)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R2x2>{R2x2(0, 0, 0, 0)}));
        }

        SECTION("from list")
        {
          std::string_view data = R"(
let (X1,X2):(R^2x2)*(R^2x2), (X1,X2) = (([[1.2, 2],[7,4]],0,[[3,1],[5,2]]),([[2.4,1],[1,3]],[[true,1.3],[2,2]]));
)";
          CHECK_AFFECTATION_RESULT(data, "X1",
                                   (std::vector<R2x2>{R2x2(1.2, 2, 7, 4), R2x2(0, 0, 0, 0), R2x2(3, 1, 5, 2)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R2x2>{R2x2(2.4, 1, 1, 3), R2x2(true, 1.3, 2, 2)}));
        }

        SECTION("from (R^2x2)")
        {
          std::string_view data = R"(
let X0:(R^2x2), X0 = ([[1.2,2],[3,1]],[[3,1],[5,8]],0);
let (X,a): (R^2x2)*Z, (X,a) = (X0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "X",
                                   (std::vector<R2x2>{R2x2(1.2, 2, 3, 1), R2x2(3, 1, 5, 8), R2x2(0, 0, 0, 0)}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }
      }

      SECTION("R^3x3")
      {
        using R3x3 = TinyMatrix<3>;

        SECTION("from value")
        {
          std::string_view data = R"(
let (X1,X2): (R^3x3)*(R^3x3), (X1,X2) = ([[1,2,3],[4,5,6],[7,8,9]], 0);
)";

          CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R3x3>{R3x3(1, 2, 3, 4, 5, 6, 7, 8, 9)}));
          CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R3x3>{R3x3(0, 0, 0, 0, 0, 0, 0, 0, 0)}));
        }

        SECTION("from list")
        {
          std::string_view data = R"(
let (X1,X2):(R^3x3)*(R^3x3), (X1,X2) = (([[1.2, 2, 1],[3,1,9],[7,5,4]],0,[[3,0.3,1],[5,7,2],[2,1,8]]),([[3,2.4,1],[2,1,3],[2.2,1.8,3]],[[true,2,1.3],[2.1,4,2],[1.2,2.4,1.2]]));
)";
          CHECK_AFFECTATION_RESULT(data, "X1",
                                   (std::vector<R3x3>{R3x3(1.2, 2, 1, 3, 1, 9, 7, 5, 4),
                                                      R3x3(0, 0, 0, 0, 0, 0, 0, 0, 0),
                                                      R3x3(3, 0.3, 1, 5, 7, 2, 2, 1, 8)}));
          CHECK_AFFECTATION_RESULT(data, "X2",
                                   (std::vector<R3x3>{R3x3(3, 2.4, 1, 2, 1, 3, 2.2, 1.8, 3),
                                                      R3x3(true, 2, 1.3, 2.1, 4, 2, 1.2, 2.4, 1.2)}));
        }

        SECTION("from (R^3x3)")
        {
          std::string_view data = R"(
let X0:(R^3x3), X0 = ([[1.2,7,2],[2,1,6],[1,3,1]],[[3,1,6],[2,7,1],[1,5,8]]);
let (X,a): (R^3x3)*Z, (X,a) = (X0,3);
)";
          CHECK_AFFECTATION_RESULT(data, "X",
                                   (std::vector<R3x3>{R3x3(1.2, 7, 2, 2, 1, 6, 1, 3, 1),
                                                          R3x3(3, 1, 6, 2, 7, 1, 1, 5, 8)}));
          CHECK_AFFECTATION_RESULT(data, "a", 3l);
        }
      }
    }
  }

  SECTION("+=")
  {
    SECTION("N")
    {
      CHECK_AFFECTATION_RESULT("let n : N, n = 1; n += 3;", "n", 4ul);
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let n : N, n = 1; n += m;", "n", 3ul);
      CHECK_AFFECTATION_RESULT("let n : N, n = 1; n += true;", "n", 2ul);
      CHECK_AFFECTATION_RESULT("let n : N, n = 3; n += false;", "n", 3ul);
    }

    SECTION("Z")
    {
      CHECK_AFFECTATION_RESULT("let z : Z, z = 1; z += 3;", "z", 4l);
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let z : Z, z = 1; z += m;", "z", 3l);
      CHECK_AFFECTATION_RESULT("let z : Z, z = 1; z += true;", "z", 2l);
      CHECK_AFFECTATION_RESULT("let z : Z, z = 3; z += false;", "z", 3l);
    }

    SECTION("R")
    {
      CHECK_AFFECTATION_RESULT("let r : R, r = 1.2; r += 2.3;", "r", 3.5);
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let r : R, r = 1.3; r += m;", "r", 3.3);
      CHECK_AFFECTATION_RESULT("let r : R, r = 1.1; r += true;", "r", 2.1);
      CHECK_AFFECTATION_RESULT("let r : R, r = 3.3; r += false;", "r", 3.3);
      CHECK_AFFECTATION_RESULT("let r : R, r = 2; r += 1.1;", "r", 3.1);
    }

    SECTION("R^1")
    {
      CHECK_AFFECTATION_RESULT("let x : R^1, x = -1; let y : R^1, y = 1; x += y;", "x",
                               (TinyVector<1>{-1} + TinyVector<1>{1}));
    }

    SECTION("R^2")
    {
      CHECK_AFFECTATION_RESULT("let x : R^2, x = [-1, true]; x += [1,3];", "x",
                               (TinyVector<2>{-1, true} + TinyVector<2>{1, 3}));
    }

    SECTION("R^3")
    {
      CHECK_AFFECTATION_RESULT("let x : R^3, x = [-1, true, false]; x += [1,2,3];", "x",
                               (TinyVector<3>{-1, true, false} + TinyVector<3>{1, 2, 3}));
    }
  }

  SECTION("-=")
  {
    SECTION("N")
    {
      CHECK_AFFECTATION_RESULT("let n : N, n = 3; n -= 2;", "n", 1ul);
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let n : N, n = 4; n -= m;", "n", 2ul);
      CHECK_AFFECTATION_RESULT("let n : N, n = 1; n -= true;", "n", 0ul);
      CHECK_AFFECTATION_RESULT("let n : N, n = 3; n -= false;", "n", 3ul);
    }

    SECTION("Z")
    {
      CHECK_AFFECTATION_RESULT("let z : Z, z = 1; z -= 3;", "z", -2l);
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let z : Z, z = 1; z -= m;", "z", -1l);
      CHECK_AFFECTATION_RESULT("let z : Z, z = 1; z -= true;", "z", 0l);
      CHECK_AFFECTATION_RESULT("let z : Z, z = 3; z -= false;", "z", 3l);
    }
    
    SECTION("R")
    {
      CHECK_AFFECTATION_RESULT("let r : R, r = 1.1; r -= 2;", "r", (1.1 - 2l));
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let r : R, r = 1.3; r -= m;", "r", (1.3 - 2ul));
      CHECK_AFFECTATION_RESULT("let r : R, r = 1.1; r -= true;", "r", (1.1 - true));
      CHECK_AFFECTATION_RESULT("let r : R, r = 3.3; r -= false;", "r", 3.3);
      CHECK_AFFECTATION_RESULT("let r : R, r = 2; r -= 1.1;", "r", (2. - 1.1));
    }

    SECTION("R^1")
    {
      CHECK_AFFECTATION_RESULT("let x : R^1, x = [-1];  x -= [1];", "x", (TinyVector<1>{-1} - TinyVector<1>{1}));
    }

    SECTION("R^2")
    {
      CHECK_AFFECTATION_RESULT("let x : R^2, x = [-1, true]; x -= [1,3];", "x",
                               (TinyVector<2>{-1, true} - TinyVector<2>{1, 3}));
    }

    SECTION("R^3")
    {
      CHECK_AFFECTATION_RESULT("let x : R^3, x = [-1, true, false]; x-=[1,2,3];", "x",
                               (TinyVector<3>{-1, true, false} - TinyVector<3>{1, 2, 3}));
    }
  }

  SECTION("*=")
  {
    SECTION("N")
    {
      CHECK_AFFECTATION_RESULT("let n : N, n = 3; n *= 2;", "n", 6ul);
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let n : N, n = 4; n *= m;", "n", 8ul);
      CHECK_AFFECTATION_RESULT("let n : N, n = 1; n *= true;", "n", 1ul);
      CHECK_AFFECTATION_RESULT("let n : N, n = 3; n *= false;", "n", 0ul);
    }

    SECTION("Z")
    {
      CHECK_AFFECTATION_RESULT("let z : Z, z = 1; z *= 3;", "z", 3l);
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let z : Z, z = -2; z *= m;", "z", -4l);
      CHECK_AFFECTATION_RESULT("let z : Z, z = 1; z *= true;", "z", 1l);
      CHECK_AFFECTATION_RESULT("let z : Z, z = 3; z *= false;", "z", 0l);
    }

    SECTION("R")
    {
      CHECK_AFFECTATION_RESULT("let r : R, r = 1.1; r *= 2;", "r", (1.1 * 2l));
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let r : R, r = 1.3; r *= m;", "r", (1.3 * 2ul));
      CHECK_AFFECTATION_RESULT("let r : R, r = 1.1; r *= true;", "r", (1.1 * true));
      CHECK_AFFECTATION_RESULT("let r : R, r = 3.3; r *= false;", "r", (3.3 * false));
      CHECK_AFFECTATION_RESULT("let r : R, r = 2; r *= 1.1;", "r", (2. * 1.1));
    }

    SECTION("R^1")
    {
      CHECK_AFFECTATION_RESULT("let x : R^1, x = 2; x *= 2;", "x", (TinyVector<1>{TinyVector<1>{2} *= 2}));
    }

    SECTION("R^2")
    {
      CHECK_AFFECTATION_RESULT("let x : R^2, x = [-1, true];  x *= 3;", "x",
                               (TinyVector<2>{TinyVector<2>{-1, true} *= 3}));
    }

    SECTION("R^3")
    {
      CHECK_AFFECTATION_RESULT("let x : R^3, x = [-1, true, false]; x*=5.2;", "x",
                               (TinyVector<3>{TinyVector<3>{-1, true, false} *= 5.2}));
        }

    SECTION("R^1x1")
    {
      CHECK_AFFECTATION_RESULT("let x : R^1x1, x = 2; x *= 2;", "x", (TinyMatrix<1>{TinyMatrix<1>{2} *= 2}));
    }

    SECTION("R^2x2")
    {
      CHECK_AFFECTATION_RESULT("let x : R^2x2, x = [[-1, true], [3, 6]];  x *= 3;", "x",
                               (TinyMatrix<2>{TinyMatrix<2>{-1, true, 3, 6} *= 3}));
    }

    SECTION("R^3x3")
    {
      CHECK_AFFECTATION_RESULT("let x : R^3x3, x = [[-1, true, false], [2, -3, 11], [5, -4, 2]]; x*=5.2;", "x",
                               (TinyMatrix<3>{TinyMatrix<3>{-1, true, false, 2, -3, 11, 5, -4, 2} *= 5.2}));
    }
  }

  SECTION("/=")
  {
    SECTION("N")
    {
      CHECK_AFFECTATION_RESULT("let n : N, n = 4; n /= 2;", "n", 2ul);
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let n : N, n = 6; n /= m;", "n", 3ul);
      CHECK_AFFECTATION_RESULT("let n : N, n = 1; n /= true;", "n", 1ul);
    }

    SECTION("Z")
    {
      CHECK_AFFECTATION_RESULT("let z : Z, z = 7; z /= -3;", "z", -2l);
      CHECK_AFFECTATION_RESULT("let m : N, m = 3; let z : Z, z = 6; z /= m;", "z", 2l);
      CHECK_AFFECTATION_RESULT("let z : Z, z = 6; z /= true;", "z", 6l);
    }

    SECTION("R")
    {
      CHECK_AFFECTATION_RESULT("let r : R, r = 1.1; r /= 2;", "r", (1.1 / 2l));
      CHECK_AFFECTATION_RESULT("let m : N, m = 2; let r : R, r = 1.3; r /= m;", "r", (1.3 / 2ul));
      CHECK_AFFECTATION_RESULT("let r : R, r = 1.1; r /= true;", "r", (1.1 / true));
      CHECK_AFFECTATION_RESULT("let r : R, r = 2; r /= 1.1;", "r", (2. / 1.1));
    }
  }

  SECTION("errors")
  {
    SECTION("invalid implicit conversions")
    {
      SECTION("-> B")
      {
        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = 1; let b : B; b = n;", "undefined affectation type: B = N");
        CHECK_AFFECTATION_THROWS_WITH("let b : B; b = 1;", "undefined affectation type: B = Z");
        CHECK_AFFECTATION_THROWS_WITH("let b : B; b = 2.3;", "undefined affectation type: B = R");
        CHECK_AFFECTATION_THROWS_WITH("let b : B; b = \"foo\";", "undefined affectation type: B = string");
      }

      SECTION("-> N")
      {
        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = 2.3;", "undefined affectation type: N = R");
        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = \"bar\";", "undefined affectation type: N = string");

        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = 2; n += 1.1;", "undefined affectation type: N += R");
        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = 2; n += \"foo\";", "undefined affectation type: N += string");

        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = 2; n -= 1.1;", "undefined affectation type: N -= R");
        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = 2; n -= \"bar\";", "undefined affectation type: N -= string");

        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = 2; n *= 2.51;", "undefined affectation type: N *= R");
        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = 2; n *= \"foobar\";", "undefined affectation type: N *= string");
    
        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = 2; n /= 2.51;", "undefined affectation type: N /= R");
        CHECK_AFFECTATION_THROWS_WITH("let n : N, n = 2; n /= \"foo\";", "undefined affectation type: N /= string");
      }

      SECTION("-> Z")
      {
        CHECK_AFFECTATION_THROWS_WITH("let z : Z, z = -2.3;", "undefined affectation type: Z = R");
        CHECK_AFFECTATION_THROWS_WITH("let z : Z, z = \"foobar\";", "undefined affectation type: Z = string");

        CHECK_AFFECTATION_THROWS_WITH("let z : Z, z = 2; z += 1.1;", "undefined affectation type: Z += R");
        CHECK_AFFECTATION_THROWS_WITH("let z : Z, z = 2; z += \"foo\";", "undefined affectation type: Z += string");

        CHECK_AFFECTATION_THROWS_WITH("let z : Z, z = 2; z -= 2.1;", "undefined affectation type: Z -= R");
        CHECK_AFFECTATION_THROWS_WITH("let z : Z, z = 2; z -= \"bar\";", "undefined affectation type: Z -= string");

        CHECK_AFFECTATION_THROWS_WITH("let z : Z, z = 2; z *= -2.51;", "undefined affectation type: Z *= R");
        CHECK_AFFECTATION_THROWS_WITH("let z : Z, z = 2; z *= \"foobar\";", "undefined affectation type: Z *= string");

        CHECK_AFFECTATION_THROWS_WITH("let z : Z, z = 4; z /= -2.;", "undefined affectation type: Z /= R");
        CHECK_AFFECTATION_THROWS_WITH("let z : Z, z = 2; z /= \"foo\";", "undefined affectation type: Z /= string");
      }

      SECTION("-> R")
      {
        CHECK_AFFECTATION_THROWS_WITH("let x : R, x = \"foobar\";", "undefined affectation type: R = string");
        CHECK_AFFECTATION_THROWS_WITH("let x : R, x = 2.3; x += \"foo\";", "undefined affectation type: R += string");
        CHECK_AFFECTATION_THROWS_WITH("let x : R, x = 2.1; x -= \"bar\";", "undefined affectation type: R -= string");
        CHECK_AFFECTATION_THROWS_WITH("let x : R, x = 1.2; x *= \"foobar\";",
                                      "undefined affectation type: R *= string");
        CHECK_AFFECTATION_THROWS_WITH("let x : R, x =-2.3; x /= \"foo\";", "undefined affectation type: R /= string");
      }

      SECTION("-> R^n")
      {
        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = \"foobar\";", "undefined affectation type: R^2 = string");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = \"foobar\";", "undefined affectation type: R^3 = string");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 3.2;", "undefined affectation type: R^2 = R");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = 2.3;", "undefined affectation type: R^3 = R");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^1; let y : R^1x1, y = 1; x = y;",
                                      "undefined affectation type: R^1 = R^1x1");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^2; let y : R^2x2, y = [[1,2],[4,4]]; x = y;",
                                      "undefined affectation type: R^2 = R^2x2");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3; let y : R^3x3, y = [[1,2,3],[4,5,6],[7,8,9]]; x = y;",
                                      "undefined affectation type: R^3 = R^3x3");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 4;", "invalid integral value (0 is the solely valid value)");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = 3;", "invalid integral value (0 is the solely valid value)");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^1, x = 0; let y : R^2, y = x;",
                                      "undefined affectation type: R^2 = R^1");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^1, x = 0; let y : R^3, y = x;",
                                      "undefined affectation type: R^3 = R^1");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 0; let y : R^1, y = x;",
                                      "undefined affectation type: R^1 = R^2");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 0; let y : R^3, y = x;",
                                      "undefined affectation type: R^3 = R^2");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = 0; let y : R^1, y = x;",
                                      "undefined affectation type: R^1 = R^3");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = 0; let y : R^2, y = x;",
                                      "undefined affectation type: R^2 = R^3");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^1, x = (1,2);", "undefined affectation type: R^1 = list");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = (1,2);", "undefined affectation type: R^2 = list");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = (1,2,3);", "undefined affectation type: R^3 = list");
      }
    
      SECTION("-> R^n (affectation of components is forbidden)")
      {
        CHECK_BUILD_THROWS_WITH("let x : R^1; x[0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^2; x[0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^3; x[0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");

        CHECK_BUILD_THROWS_WITH("let x : R^1, x=0; x[0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^2, x=0; x[0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^3, x=0; x[0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");

        CHECK_BUILD_THROWS_WITH("let x : R^1, x=0; x[0] += -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^2, x=0; x[0] += -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^3, x=0; x[0] += -1;",
                                "parse error, using subscript expression as lvalue is not allowed");

        CHECK_BUILD_THROWS_WITH("let x : R^1, x=0; x[0] -= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^2, x=0; x[0] -= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^3, x=0; x[0] -= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");

        CHECK_BUILD_THROWS_WITH("let x : R^1, x=0; x[0] *= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^2, x=0; x[0] *= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^3, x=0; x[0] *= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = \"foobar\";", "undefined affectation type: R^2 = string");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = \"foobar\";", "undefined affectation type: R^3 = string");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 3.2;", "undefined affectation type: R^2 = R");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = 2.3;", "undefined affectation type: R^3 = R");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^1; x = [[1]];", "undefined affectation type: R^1 = R^1x1");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^2; x = [[1,2],[4,4]];", "undefined affectation type: R^2 = R^2x2");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3; x = [[1,2,3],[4,5,6],[7,8,9]];",
                                      "undefined affectation type: R^3 = R^3x3");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 4;", "invalid integral value (0 is the solely valid value)");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = 3;", "invalid integral value (0 is the solely valid value)");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^1, x = 0; let y : R^2, y = x;",
                                      "undefined affectation type: R^2 = R^1");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^1, x = 0; let y : R^3, y = x;",
                                      "undefined affectation type: R^3 = R^1");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 0; let y : R^1, y = x;",
                                      "undefined affectation type: R^1 = R^2");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 0; let y : R^3, y = x;",
                                      "undefined affectation type: R^3 = R^2");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = 0; let y : R^1, y = x;",
                                      "undefined affectation type: R^1 = R^3");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = 0; let y : R^2, y = x;",
                                      "undefined affectation type: R^2 = R^3");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^1, x = (1,2);", "undefined affectation type: R^1 = list");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = (1,2);", "undefined affectation type: R^2 = list");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = (1,2,3);", "undefined affectation type: R^3 = list");
          }

      SECTION("-> R^nxn")
      {
        CHECK_BUILD_THROWS_WITH("let x : R^1x1; x[0,0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^2x2; x[0,0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^3x3; x[0,0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");

        CHECK_BUILD_THROWS_WITH("let x : R^1x1, x=0; x[0,0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^2x2, x=0; x[0,0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^3x3, x=0; x[0,0] = -1;",
                                "parse error, using subscript expression as lvalue is not allowed");

        CHECK_BUILD_THROWS_WITH("let x : R^1x1, x=0; x[0,0] += -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^2x2, x=0; x[0,0] += -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^3x3, x=0; x[0,0] += -1;",
                                "parse error, using subscript expression as lvalue is not allowed");

        CHECK_BUILD_THROWS_WITH("let x : R^1x1, x=0; x[0,0] -= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^2x2, x=0; x[0,0] -= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^3x3, x=0; x[0,0] -= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");

        CHECK_BUILD_THROWS_WITH("let x : R^1x1, x=0; x[0,0] *= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^2x2, x=0; x[0,0] *= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");
        CHECK_BUILD_THROWS_WITH("let x : R^3x3, x=0; x[0,0] *= -1;",
                                "parse error, using subscript expression as lvalue is not allowed");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = \"foobar\";", "undefined affectation type: R^2x2 = string");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = \"foobar\";", "undefined affectation type: R^3x3 = string");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = 3.2;", "undefined affectation type: R^2x2 = R");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = 2.3;", "undefined affectation type: R^3x3 = R");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^1x1; x = [1];", "undefined affectation type: R^1x1 = R^1");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2; x = [1,2];", "undefined affectation type: R^2x2 = R^2");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3; x = [1,2,3];", "undefined affectation type: R^3x3 = R^3");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2; x = 3.2;", "undefined affectation type: R^2x2 = R");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3; x = 2.3;", "undefined affectation type: R^3x3 = R");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = 4;", "invalid integral value (0 is the solely valid value)");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = 3;", "invalid integral value (0 is the solely valid value)");

        CHECK_AFFECTATION_THROWS_WITH("let y : R^2x2, y = [[0]];", "undefined affectation type: R^2x2 = R^1x1");
        CHECK_AFFECTATION_THROWS_WITH("let y : R^3x3, y = [[0]];", "undefined affectation type: R^3x3 = R^1x1");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = 0; let y : R^1x1, y = x;",
                                      "undefined affectation type: R^1x1 = R^2x2");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = 0; let y : R^3x3, y = x;",
                                      "undefined affectation type: R^3x3 = R^2x2");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = 0; let y : R^1x1, y = x;",
                                      "undefined affectation type: R^1x1 = R^3x3");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = 0; let y : R^2x2, y = x;",
                                      "undefined affectation type: R^2x2 = R^3x3");

        CHECK_AFFECTATION_THROWS_WITH("let x : R^1x1, x = (1,2);", "undefined affectation type: R^1x1 = list");
        CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = (1,2,3,4);", "undefined affectation type: R^2x2 = list");
            CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = (1,2,3,4,5,6,7,8,9);",
                                      "undefined affectation type: R^3x3 = list");
      }
    }
  }
}