anchor.diff:      let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
       printfn "%A" r
       match r with
  -    | Yard.Generators.RNGLR.Parser.Error (_, tok, message, debug, _) ->
  +    | Error (_, tok, message, debug, _) ->
           printfn "Errors in file %s on Tokens %A: %s" inputFilePath tok message
           debug.drawGSSDot "out.dot"
           if shouldContainsSuccess
           then Assert.Fail(sprintf "Test %s should produce sucess parsing result but its fully failed." inputFilePath)
           else Assert.AreEqual(errorsCount, tok.Length, "Errors count mismatch.")
  -    | Yard.Generators.RNGLR.Parser.Success(tree, tok, _) ->
  +    | Success(tree, tok, _) ->
           tree.PrintAst()
           RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
           if shouldContainsSuccess
  
positive.code:         let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Yard.Generators.RNGLR.Parser.Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!!!"
          | Yard.Generators.RNGLR.Parser.Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
negative.code: 
      [<Test>]
      member this.``Simple calc. Sequence input.`` () =
          let qGraph = new ParserInputGraph<_>()        
          qGraph.AddVerticesAndEdgeRange
              [edg 0 1 (RNGLR.ParseSimpleCalc.NUM 1)
               edg 1 2 (RNGLR.ParseSimpleCalc.PLUS 0)
               edg 2 3 (RNGLR.ParseSimpleCalc.NUM 2)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseSimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!!!"
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseSimpleCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
      [<Test>]
      member this.``Calc. Sequence input.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVertexRange[0;1;2;3] |> ignore
          qGraph.AddVerticesAndEdgeRange
              [edg 0 1 (RNGLR.ParseCalc.NUMBER  1)
               edg 1 2 (RNGLR.ParseCalc.PLUS 0)
               edg 2 3 (RNGLR.ParseCalc.NUMBER 2)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!!!"
          | Success(tree, _ ,_) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
      [<Test>]
      member this.``Calc. Branched input.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVertexRange[0;1;2;3] |> ignore
          qGraph.AddVerticesAndEdgeRange
              [edg 0 1 (RNGLR.ParseCalc.NUMBER  1)
               edg 1 2 (RNGLR.ParseCalc.PLUS 0)
               edg 2 3 (RNGLR.ParseCalc.NUMBER 2)
               edg 3 4 (RNGLR.ParseCalc.MULT 3)
               edg 4 5 (RNGLR.ParseCalc.NUMBER 4)
               edg 3 6 (RNGLR.ParseCalc.DIV 5)
               edg 6 5 (RNGLR.ParseCalc.NUMBER 6)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!"
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  
      [<Test>]
      member this.``Calc. Branched input error.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               edg 0 3 (RNGLR.ParseCalc.NUMBER 2)
               edg 3 4 (RNGLR.ParseCalc.MULT 3)
               edg 4 5 (RNGLR.ParseCalc.NUMBER 4)
               edg 3 6 (RNGLR.ParseCalc.DIV 5)
               edg 6 5 (RNGLR.ParseCalc.PLUS 6)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Pass()
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Fail "This test should "
      
      [<Test>]
      member this.``Pretty Simple Calc. Error Handling Temp.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               edg 0 1 (RNGLR.PrettySimpleCalc.NUM 1)
               edg 1 2 (RNGLR.PrettySimpleCalc.PLUS 2)
               edg 2 3 (RNGLR.PrettySimpleCalc.NUM 3)
               edg 3 4 (RNGLR.PrettySimpleCalc.PLUS 4)
               edg 4 5 (RNGLR.PrettySimpleCalc.NUM 5)
               edg 5 6 (RNGLR.PrettySimpleCalc.RNGLR_EOF 6)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.PrettySimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!"
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.PrettySimpleCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass() 
  
      [<Test>]
      member this.``Pretty Simple Calc. Error Is Not Handled Without EOF.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               edg 0 1 (RNGLR.PrettySimpleCalc.NUM 1)
               edg 1 2 (RNGLR.PrettySimpleCalc.PLUS 2)
               edg 2 3 (RNGLR.PrettySimpleCalc.NUM 3)
               edg 1 3 (RNGLR.PrettySimpleCalc.PLUS 4)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.PrettySimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!"
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.PrettySimpleCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass() 
  
      [<Test>]
      member this.``Pretty Simple Calc. Error Is Handled With EOF.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVerticesAndEdgeRange
              [
               edg 0 1 (RNGLR.PrettySimpleCalc.NUM 1)
               edg 1 2 (RNGLR.PrettySimpleCalc.PLUS 2)
               edg 2 3 (RNGLR.PrettySimpleCalc.NUM 3)
               edg 1 3 (RNGLR.PrettySimpleCalc.PLUS 4)
               edg 1 3 (RNGLR.PrettySimpleCalc.RNGLR_EOF 5)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.PrettySimpleCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Pass()
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.PrettySimpleCalc.defaultAstToDot tree "ast.dot"
              Assert.Fail "!!!!" 
  
      [<Test>]
      member this.``Calc. Branched input 2.`` () =
          let qGraph = new ParserInputGraph<_>()
          qGraph.AddVertexRange[0;1;2;3] |> ignore
          qGraph.AddVerticesAndEdgeRange
              [edg 0 1 (RNGLR.ParseCalc.NUMBER  1)
               edg 1 2 (RNGLR.ParseCalc.PLUS 0)
               edg 2 3 (RNGLR.ParseCalc.NUMBER 2)
               edg 3 4 (RNGLR.ParseCalc.MULT 3)
               edg 4 5 (RNGLR.ParseCalc.NUMBER 4)
               edg 3 6 (RNGLR.ParseCalc.MINUS 5)
               edg 6 5 (RNGLR.ParseCalc.NUMBER 6)
               edg 5 7 (RNGLR.ParseCalc.MULT 3)
               edg 7 8 (RNGLR.ParseCalc.NUMBER 4)
               ] |> ignore
  
          let r = (new Parser<_>()).Parse  RNGLR.ParseCalc.buildAstAbstract qGraph
          printfn "%A" r
          match r with
          | Error (num, tok, message, debug, _) ->
              printfn "Error in position %d on Token %A: %s" num tok message
              debug.drawGSSDot "out.dot"
              Assert.Fail "!!!!!!"
          | Success(tree, _, _) ->
              tree.PrintAst()
              RNGLR.ParseCalc.defaultAstToDot tree "ast.dot"
              Assert.Pass()
  