Tokens:
["int", "main", "(", ")", "{", "int", "tomas", ";", "tomas", "=", "2", ";", "return", "1", "+", "2", ";", "}"]
Begin validate subconstruct (type "Function")
Testing variant Integer (Loop = false) (Loopable = false)
  Validated token "int"
  Validated token "main"
  Validated token "("
  Validated token ")"
  Validated token "{"
  Begin validate subconstruct (type "StatementList")
  Testing variant StatementSequence (Loop = false) (Loopable = false)
    Determining need to loop construct of type Statement
    Testing Statement::StandaloneExpression
      Begin validate subconstruct (type "Expression")
      Testing variant VariableExpression (Loop = false) (Loopable = false)
        Begin validate subconstruct (type "VariableAssignment")
        Testing variant Variable (Loop = false) (Loopable = false)
          Failed to validate token "int". Expected "IDENTIFIER"
        Fail: no valid variants (variant "Variable")

        Subconstruct validation failed
      Fail: no valid variants (variant "VariableExpression")

      Testing variant LogicalOrExpressionSequence (Loop = false) (Loopable = false)
        Begin validate subconstruct (type "LogicalOrExpression")
        Testing variant LogicalAndExpressionSequence (Loop = false) (Loopable = false)
          Begin validate subconstruct (type "LogicalAndExpression")
          Testing variant EqualityExpressionSequence (Loop = false) (Loopable = false)
            Begin validate subconstruct (type "EqualityExpression")
            Testing variant RelationalExpressionSequence (Loop = false) (Loopable = false)
              Begin validate subconstruct (type "RelationalExpression")
              Testing variant AdditiveExpressionSequence (Loop = false) (Loopable = false)
                Begin validate subconstruct (type "AdditiveExpression")
                Testing variant TermSequence (Loop = false) (Loopable = true)
                  Begin validate subconstruct (type "Term")
                  Testing variant FactorSequence (Loop = false) (Loopable = true)
                    Begin validate subconstruct (type "Factor")
                    Testing variant LiteralInteger (Loop = false) (Loopable = false)
                      Failed to validate token "int". Expected "LITERAL_INTEGER"
                    Fail: no valid variants (variant "LiteralInteger")

                    Testing variant ParenthesizedExpression (Loop = false) (Loopable = false)
                      Failed to validate token "int". Expected "PARENTHESIS_OPEN"
                    Fail: no valid variants (variant "ParenthesizedExpression")

                    Testing variant StandaloneVariable (Loop = false) (Loopable = false)
                      Begin validate subconstruct (type "VariableFactor")
                      Testing variant Variable (Loop = false) (Loopable = false)
                        Failed to validate token "int". Expected "IDENTIFIER"
                      Fail: no valid variants (variant "Variable")

                      Subconstruct validation failed
                    Fail: no valid variants (variant "StandaloneVariable")

                    Testing variant UnaryOperation (Loop = false) (Loopable = false)
                      Begin validate subconstruct (type "UnaryOperator")
                      Testing variant LogicalNegation (Loop = false) (Loopable = false)
                        Failed to validate token "int". Expected "LOGICAL_NEGATION"
                      Fail: no valid variants (variant "LogicalNegation")

                      Testing variant BitwiseCompliment (Loop = false) (Loopable = false)
                        Failed to validate token "int". Expected "BITWISE_COMPLIMENT"
                      Fail: no valid variants (variant "BitwiseCompliment")

                      Testing variant Negation (Loop = false) (Loopable = false)
                        Failed to validate token "int". Expected "NEGATION"
                      Fail: no valid variants (variant "Negation")

                      Subconstruct validation failed
                    Fail: no valid variants (variant "UnaryOperation")

                    Subconstruct validation failed
                  Fail: no valid variants (variant "FactorSequence")

                  Subconstruct validation failed
                Fail: no valid variants (variant "TermSequence")

                Subconstruct validation failed
              Fail: no valid variants (variant "AdditiveExpressionSequence")

              Subconstruct validation failed
            Fail: no valid variants (variant "RelationalExpressionSequence")

            Subconstruct validation failed
          Fail: no valid variants (variant "EqualityExpressionSequence")

          Subconstruct validation failed
        Fail: no valid variants (variant "LogicalAndExpressionSequence")

        Subconstruct validation failed
      Fail: no valid variants (variant "LogicalOrExpressionSequence")

      Subconstruct validation failed
    Testing Statement::DeclareVariable
      Begin validate subconstruct (type "VariableDeclaration")
      Testing variant Variable (Loop = false) (Loopable = false)
        Validated token "int"
        Validated token "tomas"
        Determining need to continue. (TestingASSIGNMENT)
        ASSIGNMENT NOT validated. Breaking
      Success (variant "Variable")

      End validate subconstruct (variant "Variable")
      Validated token ";"
    Looping
    Determining need to loop construct of type Statement
    Testing Statement::StandaloneExpression
      Begin validate subconstruct (type "Expression")
      Testing variant VariableExpression (Loop = false) (Loopable = false)
        Begin validate subconstruct (type "VariableAssignment")
        Testing variant Variable (Loop = false) (Loopable = false)
          Validated token "tomas"
          Validated token "="
          Begin validate subconstruct (type "Expression")
          Testing variant VariableExpression (Loop = false) (Loopable = false)
            Begin validate subconstruct (type "VariableAssignment")
            Testing variant Variable (Loop = false) (Loopable = false)
              Failed to validate token "2". Expected "IDENTIFIER"
            Fail: no valid variants (variant "Variable")

            Subconstruct validation failed
          Fail: no valid variants (variant "VariableExpression")

          Testing variant LogicalOrExpressionSequence (Loop = false) (Loopable = false)
            Begin validate subconstruct (type "LogicalOrExpression")
            Testing variant LogicalAndExpressionSequence (Loop = false) (Loopable = false)
              Begin validate subconstruct (type "LogicalAndExpression")
              Testing variant EqualityExpressionSequence (Loop = false) (Loopable = false)
                Begin validate subconstruct (type "EqualityExpression")
                Testing variant RelationalExpressionSequence (Loop = false) (Loopable = false)
                  Begin validate subconstruct (type "RelationalExpression")
                  Testing variant AdditiveExpressionSequence (Loop = false) (Loopable = false)
                    Begin validate subconstruct (type "AdditiveExpression")
                    Testing variant TermSequence (Loop = false) (Loopable = true)
                      Begin validate subconstruct (type "Term")
                      Testing variant FactorSequence (Loop = false) (Loopable = true)
                        Begin validate subconstruct (type "Factor")
                        Testing variant LiteralInteger (Loop = false) (Loopable = false)
                          Validated token "2"
                        Success (variant "LiteralInteger")

                        End validate subconstruct (variant "LiteralInteger")
                        Determining need to loop construct of type MultiplicationPriorityOperator
                        Testing operator MultiplicationPriorityOperator::Division
                          Failed to validate token ";". Expected "DIVISION"
                        Testing operator MultiplicationPriorityOperator::Multiplication
                          Failed to validate token ";". Expected "MULTIPLICATION"
                        Not looping
                      Success (variant "FactorSequence")

                      End validate subconstruct (variant "FactorSequence")
                      Determining need to loop construct of type AdditionPriorityOperator
                      Testing operator AdditionPriorityOperator::Addition
                        Failed to validate token ";". Expected "ADDITION"
                      Testing operator AdditionPriorityOperator::Subtraction
                        Failed to validate token ";". Expected "NEGATION"
                      Not looping
                    Success (variant "TermSequence")

                    End validate subconstruct (variant "TermSequence")
                    Determining need to loop construct of type InequalityPriorityOperator
                    Testing operator InequalityPriorityOperator::LessThan
                      Failed to validate token ";". Expected "LESS_THAN"
                    Testing operator InequalityPriorityOperator::GreaterThanOrEqualTo
                      Failed to validate token ";". Expected "GREATER_THAN_OR_EQUAL_TO"
                    Testing operator InequalityPriorityOperator::LessThanOrEqualTo
                      Failed to validate token ";". Expected "LESS_THAN_OR_EQUAL_TO"
                    Testing operator InequalityPriorityOperator::GreaterThan
                      Failed to validate token ";". Expected "GREATER_THAN"
                    Not looping
                  Success (variant "AdditiveExpressionSequence")

                  End validate subconstruct (variant "AdditiveExpressionSequence")
                  Determining need to loop construct of type EqualityPriorityOperator
                  Testing operator EqualityPriorityOperator::EqualTo
                    Failed to validate token ";". Expected "EQUAL"
                  Testing operator EqualityPriorityOperator::NotEqualTo
                    Failed to validate token ";". Expected "NOT_EQUAL"
                  Not looping
                Success (variant "RelationalExpressionSequence")

                End validate subconstruct (variant "RelationalExpressionSequence")
                Determining need to loop construct of type LogicalAndPriorityOperator
                Testing operator LogicalAndPriorityOperator::LogicalAnd
                  Failed to validate token ";". Expected "LOGICAL_AND"
                Not looping
              Success (variant "EqualityExpressionSequence")

              End validate subconstruct (variant "EqualityExpressionSequence")
              Determining need to loop construct of type LogicalOrPriorityOperator
              Testing operator LogicalOrPriorityOperator::LogicalOr
                Failed to validate token ";". Expected "LOGICAL_OR"
              Not looping
            Success (variant "LogicalAndExpressionSequence")

            End validate subconstruct (variant "LogicalAndExpressionSequence")
          Success (variant "LogicalOrExpressionSequence")

          End validate subconstruct (variant "LogicalOrExpressionSequence")
        Success (variant "Variable")

        End validate subconstruct (variant "Variable")
      Success (variant "VariableExpression")

      End validate subconstruct (variant "VariableExpression")
      Validated token ";"
    Looping
    Determining need to loop construct of type Statement
    Testing Statement::StandaloneExpression
      Begin validate subconstruct (type "Expression")
      Testing variant VariableExpression (Loop = false) (Loopable = false)
        Begin validate subconstruct (type "VariableAssignment")
        Testing variant Variable (Loop = false) (Loopable = false)
          Failed to validate token "return". Expected "IDENTIFIER"
        Fail: no valid variants (variant "Variable")

        Subconstruct validation failed
      Fail: no valid variants (variant "VariableExpression")

      Testing variant LogicalOrExpressionSequence (Loop = false) (Loopable = false)
        Begin validate subconstruct (type "LogicalOrExpression")
        Testing variant LogicalAndExpressionSequence (Loop = false) (Loopable = false)
          Begin validate subconstruct (type "LogicalAndExpression")
          Testing variant EqualityExpressionSequence (Loop = false) (Loopable = false)
            Begin validate subconstruct (type "EqualityExpression")
            Testing variant RelationalExpressionSequence (Loop = false) (Loopable = false)
              Begin validate subconstruct (type "RelationalExpression")
              Testing variant AdditiveExpressionSequence (Loop = false) (Loopable = false)
                Begin validate subconstruct (type "AdditiveExpression")
                Testing variant TermSequence (Loop = false) (Loopable = true)
                  Begin validate subconstruct (type "Term")
                  Testing variant FactorSequence (Loop = false) (Loopable = true)
                    Begin validate subconstruct (type "Factor")
                    Testing variant LiteralInteger (Loop = false) (Loopable = false)
                      Failed to validate token "return". Expected "LITERAL_INTEGER"
                    Fail: no valid variants (variant "LiteralInteger")

                    Testing variant ParenthesizedExpression (Loop = false) (Loopable = false)
                      Failed to validate token "return". Expected "PARENTHESIS_OPEN"
                    Fail: no valid variants (variant "ParenthesizedExpression")

                    Testing variant StandaloneVariable (Loop = false) (Loopable = false)
                      Begin validate subconstruct (type "VariableFactor")
                      Testing variant Variable (Loop = false) (Loopable = false)
                        Failed to validate token "return". Expected "IDENTIFIER"
                      Fail: no valid variants (variant "Variable")

                      Subconstruct validation failed
                    Fail: no valid variants (variant "StandaloneVariable")

                    Testing variant UnaryOperation (Loop = false) (Loopable = false)
                      Begin validate subconstruct (type "UnaryOperator")
                      Testing variant LogicalNegation (Loop = false) (Loopable = false)
                        Failed to validate token "return". Expected "LOGICAL_NEGATION"
                      Fail: no valid variants (variant "LogicalNegation")

                      Testing variant BitwiseCompliment (Loop = false) (Loopable = false)
                        Failed to validate token "return". Expected "BITWISE_COMPLIMENT"
                      Fail: no valid variants (variant "BitwiseCompliment")

                      Testing variant Negation (Loop = false) (Loopable = false)
                        Failed to validate token "return". Expected "NEGATION"
                      Fail: no valid variants (variant "Negation")

                      Subconstruct validation failed
                    Fail: no valid variants (variant "UnaryOperation")

                    Subconstruct validation failed
                  Fail: no valid variants (variant "FactorSequence")

                  Subconstruct validation failed
                Fail: no valid variants (variant "TermSequence")

                Subconstruct validation failed
              Fail: no valid variants (variant "AdditiveExpressionSequence")

              Subconstruct validation failed
            Fail: no valid variants (variant "RelationalExpressionSequence")

            Subconstruct validation failed
          Fail: no valid variants (variant "EqualityExpressionSequence")

          Subconstruct validation failed
        Fail: no valid variants (variant "LogicalAndExpressionSequence")

        Subconstruct validation failed
      Fail: no valid variants (variant "LogicalOrExpressionSequence")

      Subconstruct validation failed
    Testing Statement::DeclareVariable
      Begin validate subconstruct (type "VariableDeclaration")
      Testing variant Variable (Loop = false) (Loopable = false)
        Failed to validate token "return". Expected "INT"
      Fail: no valid variants (variant "Variable")

      Subconstruct validation failed
    Testing Statement::ReturnExpression
      Validated token "return"
      Begin validate subconstruct (type "Expression")
      Testing variant VariableExpression (Loop = false) (Loopable = false)
        Begin validate subconstruct (type "VariableAssignment")
        Testing variant Variable (Loop = false) (Loopable = false)
          Failed to validate token "1". Expected "IDENTIFIER"
        Fail: no valid variants (variant "Variable")

        Subconstruct validation failed
      Fail: no valid variants (variant "VariableExpression")

      Testing variant LogicalOrExpressionSequence (Loop = false) (Loopable = false)
        Begin validate subconstruct (type "LogicalOrExpression")
        Testing variant LogicalAndExpressionSequence (Loop = false) (Loopable = false)
          Begin validate subconstruct (type "LogicalAndExpression")
          Testing variant EqualityExpressionSequence (Loop = false) (Loopable = false)
            Begin validate subconstruct (type "EqualityExpression")
            Testing variant RelationalExpressionSequence (Loop = false) (Loopable = false)
              Begin validate subconstruct (type "RelationalExpression")
              Testing variant AdditiveExpressionSequence (Loop = false) (Loopable = false)
                Begin validate subconstruct (type "AdditiveExpression")
                Testing variant TermSequence (Loop = false) (Loopable = true)
                  Begin validate subconstruct (type "Term")
                  Testing variant FactorSequence (Loop = false) (Loopable = true)
                    Begin validate subconstruct (type "Factor")
                    Testing variant LiteralInteger (Loop = false) (Loopable = false)
                      Validated token "1"
                    Success (variant "LiteralInteger")

                    End validate subconstruct (variant "LiteralInteger")
                    Determining need to loop construct of type MultiplicationPriorityOperator
                    Testing operator MultiplicationPriorityOperator::Division
                      Failed to validate token "+". Expected "DIVISION"
                    Testing operator MultiplicationPriorityOperator::Multiplication
                      Failed to validate token "+". Expected "MULTIPLICATION"
                    Not looping
                  Success (variant "FactorSequence")

                  End validate subconstruct (variant "FactorSequence")
                  Determining need to loop construct of type AdditionPriorityOperator
                  Testing operator AdditionPriorityOperator::Addition
                    Validated token "+"
                  Looping
                  Begin validate subconstruct (type "Term")
                  Testing variant FactorSequence (Loop = true) (Loopable = true)
                    Begin validate subconstruct (type "Factor")
                    Testing variant LiteralInteger (Loop = false) (Loopable = false)
                      Validated token "2"
                    Success (variant "LiteralInteger")

                    End validate subconstruct (variant "LiteralInteger")
                    Determining need to loop construct of type MultiplicationPriorityOperator
                    Testing operator MultiplicationPriorityOperator::Division
                      Failed to validate token ";". Expected "DIVISION"
                    Testing operator MultiplicationPriorityOperator::Multiplication
                      Failed to validate token ";". Expected "MULTIPLICATION"
                    Not looping
                  Success (variant "FactorSequence")

                  End validate subconstruct (variant "FactorSequence")
                  Determining need to loop construct of type AdditionPriorityOperator
                  Testing operator AdditionPriorityOperator::Addition
                    Failed to validate token ";". Expected "ADDITION"
                  Testing operator AdditionPriorityOperator::Subtraction
                    Failed to validate token ";". Expected "NEGATION"
                  Not looping
                Success (variant "TermSequence")

                End validate subconstruct (variant "TermSequence")
                Determining need to loop construct of type InequalityPriorityOperator
                Testing operator InequalityPriorityOperator::LessThan
                  Failed to validate token ";". Expected "LESS_THAN"
                Testing operator InequalityPriorityOperator::GreaterThanOrEqualTo
                  Failed to validate token ";". Expected "GREATER_THAN_OR_EQUAL_TO"
                Testing operator InequalityPriorityOperator::LessThanOrEqualTo
                  Failed to validate token ";". Expected "LESS_THAN_OR_EQUAL_TO"
                Testing operator InequalityPriorityOperator::GreaterThan
                  Failed to validate token ";". Expected "GREATER_THAN"
                Not looping
              Success (variant "AdditiveExpressionSequence")

              End validate subconstruct (variant "AdditiveExpressionSequence")
              Determining need to loop construct of type EqualityPriorityOperator
              Testing operator EqualityPriorityOperator::EqualTo
                Failed to validate token ";". Expected "EQUAL"
              Testing operator EqualityPriorityOperator::NotEqualTo
                Failed to validate token ";". Expected "NOT_EQUAL"
              Not looping
            Success (variant "RelationalExpressionSequence")

            End validate subconstruct (variant "RelationalExpressionSequence")
            Determining need to loop construct of type LogicalAndPriorityOperator
            Testing operator LogicalAndPriorityOperator::LogicalAnd
              Failed to validate token ";". Expected "LOGICAL_AND"
            Not looping
          Success (variant "EqualityExpressionSequence")

          End validate subconstruct (variant "EqualityExpressionSequence")
          Determining need to loop construct of type LogicalOrPriorityOperator
          Testing operator LogicalOrPriorityOperator::LogicalOr
            Failed to validate token ";". Expected "LOGICAL_OR"
          Not looping
        Success (variant "LogicalAndExpressionSequence")

        End validate subconstruct (variant "LogicalAndExpressionSequence")
      Success (variant "LogicalOrExpressionSequence")

      End validate subconstruct (variant "LogicalOrExpressionSequence")
      Validated token ";"
    Looping
    Determining need to loop construct of type Statement
    Testing Statement::StandaloneExpression
      Begin validate subconstruct (type "Expression")
      Testing variant VariableExpression (Loop = false) (Loopable = false)
        Begin validate subconstruct (type "VariableAssignment")
        Testing variant Variable (Loop = false) (Loopable = false)
          Failed to validate token "}". Expected "IDENTIFIER"
        Fail: no valid variants (variant "Variable")

        Subconstruct validation failed
      Fail: no valid variants (variant "VariableExpression")

      Testing variant LogicalOrExpressionSequence (Loop = false) (Loopable = false)
        Begin validate subconstruct (type "LogicalOrExpression")
        Testing variant LogicalAndExpressionSequence (Loop = false) (Loopable = false)
          Begin validate subconstruct (type "LogicalAndExpression")
          Testing variant EqualityExpressionSequence (Loop = false) (Loopable = false)
            Begin validate subconstruct (type "EqualityExpression")
            Testing variant RelationalExpressionSequence (Loop = false) (Loopable = false)
              Begin validate subconstruct (type "RelationalExpression")
              Testing variant AdditiveExpressionSequence (Loop = false) (Loopable = false)
                Begin validate subconstruct (type "AdditiveExpression")
                Testing variant TermSequence (Loop = false) (Loopable = true)
                  Begin validate subconstruct (type "Term")
                  Testing variant FactorSequence (Loop = false) (Loopable = true)
                    Begin validate subconstruct (type "Factor")
                    Testing variant LiteralInteger (Loop = false) (Loopable = false)
                      Failed to validate token "}". Expected "LITERAL_INTEGER"
                    Fail: no valid variants (variant "LiteralInteger")

                    Testing variant ParenthesizedExpression (Loop = false) (Loopable = false)
                      Failed to validate token "}". Expected "PARENTHESIS_OPEN"
                    Fail: no valid variants (variant "ParenthesizedExpression")

                    Testing variant StandaloneVariable (Loop = false) (Loopable = false)
                      Begin validate subconstruct (type "VariableFactor")
                      Testing variant Variable (Loop = false) (Loopable = false)
                        Failed to validate token "}". Expected "IDENTIFIER"
                      Fail: no valid variants (variant "Variable")

                      Subconstruct validation failed
                    Fail: no valid variants (variant "StandaloneVariable")

                    Testing variant UnaryOperation (Loop = false) (Loopable = false)
                      Begin validate subconstruct (type "UnaryOperator")
                      Testing variant LogicalNegation (Loop = false) (Loopable = false)
                        Failed to validate token "}". Expected "LOGICAL_NEGATION"
                      Fail: no valid variants (variant "LogicalNegation")

                      Testing variant BitwiseCompliment (Loop = false) (Loopable = false)
                        Failed to validate token "}". Expected "BITWISE_COMPLIMENT"
                      Fail: no valid variants (variant "BitwiseCompliment")

                      Testing variant Negation (Loop = false) (Loopable = false)
                        Failed to validate token "}". Expected "NEGATION"
                      Fail: no valid variants (variant "Negation")

                      Subconstruct validation failed
                    Fail: no valid variants (variant "UnaryOperation")

                    Subconstruct validation failed
                  Fail: no valid variants (variant "FactorSequence")

                  Subconstruct validation failed
                Fail: no valid variants (variant "TermSequence")

                Subconstruct validation failed
              Fail: no valid variants (variant "AdditiveExpressionSequence")

              Subconstruct validation failed
            Fail: no valid variants (variant "RelationalExpressionSequence")

            Subconstruct validation failed
          Fail: no valid variants (variant "EqualityExpressionSequence")

          Subconstruct validation failed
        Fail: no valid variants (variant "LogicalAndExpressionSequence")

        Subconstruct validation failed
      Fail: no valid variants (variant "LogicalOrExpressionSequence")

      Subconstruct validation failed
    Testing Statement::DeclareVariable
      Begin validate subconstruct (type "VariableDeclaration")
      Testing variant Variable (Loop = false) (Loopable = false)
        Failed to validate token "}". Expected "INT"
      Fail: no valid variants (variant "Variable")

      Subconstruct validation failed
    Testing Statement::ReturnExpression
      Failed to validate token "}". Expected "RETURN"
    Not looping
  Success (variant "StatementSequence")

  End validate subconstruct (variant "StatementSequence")
  Validated token "}"
Success (variant "Integer")

End validate subconstruct (variant "Integer")
Success