anchor.diff:  
       [<Test>]
       member this.``Calc. Epsilon edge 1.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "test_10_1.dot"
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        Assert.AreEqual(res.Edges |> Seq.length, 3)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 4)
  +        calcTokenizationTest "test_10_1.dot" 3 4
   
       [<Test>]
       member this.``Calc. Epsilon edge 2.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "test_10_2.dot"
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        Assert.AreEqual(res.Edges |> Seq.length, 4)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 4)
  +        calcTokenizationTest "test_10_2.dot" 4 4
   
       [<Test>]
       member this.``Literals. Simple.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "literals_simple.dot"
  -        let res = Literals.Lexer._fslex_tables.Tokenize(Literals.Lexer.fslex_actions_token, lexerInputGraph, literalEofToken)
  -        Assert.AreEqual(res.Edges |> Seq.length, 2)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 3)
  +        literalsTokenizationTest "literals_simple.dot" 2 3
   
       [<Test>]
       member this.``Literals. Inner branch.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "literals_inner_branch.dot"
  -        let res = Literals.Lexer._fslex_tables.Tokenize(Literals.Lexer.fslex_actions_token, lexerInputGraph, literalEofToken)
  -        Assert.AreEqual(res.Edges |> Seq.length, 3)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 3)
  +        literalsTokenizationTest "literals_inner_branch.dot" 3 3
   
       [<Test>]
       member this.``Literals. Outer branch.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "literals_outer_branch.dot"
  -        let res = Literals.Lexer._fslex_tables.Tokenize(Literals.Lexer.fslex_actions_token, lexerInputGraph, literalEofToken)
  -        Assert.AreEqual(res.Edges |> Seq.length, 3)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 3)
  +        literalsTokenizationTest "literals_outer_branch.dot" 3 3
   
       [<Test>]
       member this.``Literals. Splitted.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "literals_splitted.dot"
  -        let res = Literals.Lexer._fslex_tables.Tokenize(Literals.Lexer.fslex_actions_token, lexerInputGraph, literalEofToken)
  -        Assert.AreEqual(res.Edges |> Seq.length, 3)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 3)
  -
  -    [<Test>]
  -    member this.``Test with space and idents on edg.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "test_with_space_0.dot"
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        Assert.AreEqual(res.Edges |> Seq.length, 3)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 4)
  +        literalsTokenizationTest "literals_splitted.dot" 3 3
  +
  +    [<Test>]
  +    member this.``Test with space and idents on edge.`` () =
  +        calcTokenizationTest "test_with_space_0.dot" 3 4
   
       [<Test>]
       member this.``Test with space with branch.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "test_with_space_1.dot"
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        Assert.AreEqual(res.Edges |> Seq.length, 4)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 4)
  -        printG res "test_with_space_1"
  +        calcTokenizationTest "test_with_space_1.dot" 4 4
   
       //[<Test>]
       member this.``Test with space at the end of previous tokens at the end of branch.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "test_with_space_at_end_of_prev_token.dot."
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        printG res "test_with_space_at_end_of_prev_token"
  -        Assert.AreEqual(res.Edges |> Seq.length, 4)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 4)
  +        calcTokenizationTest "test_with_space_at_end_of_prev_token.dot." 4 4
   
       [<Test>]
       member this.``Calc with braces.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "calc_1.dot."
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        printG res "calc_1_res"
  -        Assert.AreEqual(res.Edges |> Seq.length, 10)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 10)
  +        calcTokenizationTest "calc_1.dot." 10 10
   
       [<Test>]
       member this.``Calc with braces 2.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "calc_0.dot."
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        printG res "calc_0_res"
  -        Assert.AreEqual(res.Edges |> Seq.length, 4)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 4)
  +        calcTokenizationTest "calc_0.dot." 4 4
   
       [<Test>]
       member this.``Example with eps.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "example_eps.dot."
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        printG res "example_eps"
  -        Assert.AreEqual(res.Edges |> Seq.length, 4)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 5)
  +        calcTokenizationTest "example_eps.dot." 4 5
           
       [<Test>]
       member this.``Eps_closure_1.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "eps_closure_1.dot"
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        printG res "eps_closure_1"
  -        Assert.AreEqual(res.Edges |> Seq.length, 4)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 5)
  +        calcTokenizationTest "eps_closure_1.dot" 4 5
   
       [<Test>]
       member this.``Eps_closure_2.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "eps_closure_2.dot"
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        printG res "eps_res_closure_2"
  -        Assert.AreEqual(res.Edges |> Seq.length, 5)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 5)
  +        calcTokenizationTest "eps_closure_2.dot" 5 5
   
       [<Test>]
       member this.``Eps_closure_3.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "eps_closure_3.dot"
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        //printG res "eps_closure_3"
  -        //let eps_res = EpsClosure.NfaToDfa res
  -        //printGEps eps_res "eps_res_closure_3"
  -        //Assert.AreEqual(res.Edges |> Seq.length, 2)
  -        //Assert.AreEqual(res.Vertices |> Seq.length, 2)
  -        //Assert.AreEqual(eps_res.Edges |> Seq.length, 1)
  -        //Assert.AreEqual(eps_res.Vertices |> Seq.length, 2)
  -        printG res "eps_res_closure_3"
  -        Assert.AreEqual(res.Edges |> Seq.length, 2)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 3)
  +        calcTokenizationTest "eps_closure_3.dot" 2 3
   
       [<Test>]
       member this.``Eps_closure_4.`` () =
  -        let lexerInputGraph = loadLexerInputGraph "eps_closure_4.dot"
  -        let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
  -        printG res "eps_res_closure_4"
  -        Assert.AreEqual(res.Edges |> Seq.length, 4)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 4)
  +        calcTokenizationTest "eps_closure_4.dot" 4 4 
   
       [<Test>]
       member this.``Eps_closure_5.`` () =
           let lexerInputGraph = loadLexerInputGraph "eps_closure_5.dot"
           let res = Calc.Lexer._fslex_tables.Tokenize(Calc.Lexer.fslex_actions_token, lexerInputGraph, eofToken)
           printG res "eps_res_closure_5"
  -        Assert.AreEqual(res.Edges |> Seq.length, 1)
  -        Assert.AreEqual(res.Vertices |> Seq.length, 2)
  +        checkGraph res 1 2
           Assert.AreEqual(eofToken, (res.Edges |> Seq.nth 0).Tag)
  -
  -//[<EntryPoint>]
  -//let f x =
  -//    
  -//    let t = new ``Abstract lexer tests`` () 
  -//    t.``Literals. Simple.``()
  -//    let t = Literals.Lexer222.token <| Lexing.LexBuffer<_>.FromString ( "+1+")
  -//    printfn "%A" t
  -//    1
   
   //[<EntryPoint>]
   //let f x =
  
positive.code: 
  [<TestFixture>]
  type ``Abstract lexer tests`` () =    
  
  //    let printG res (fName:string) =
  //        let f = GraphvizAlgorithm(res)
  //        let printEdg (e:AbstractParsing.Common.ParserEdge<_>) =
  //            let printBrs brs =
  //                "["
  //                + (brs |> Array.map (fun (pos:Position<_>) -> pos.back_ref ) |> String.concat "; ")
  //                + "]"
  //            match e.Tag with
  //            | Some (NUMBER(v,br)) -> "NUM: " + v + "; br= " + printBrs br
  //            | Some (PLUS(v,br))   -> "+: " + v  + printBrs br
  //            | Some (MULT(v,br))   ->  "*: " + v  + printBrs br
  //            | Some (DIV(v,br))   ->  "/: " + v  + printBrs br
  //            | Some (LBRACE(v,br))   ->  "(: " + v  + printBrs br
  //            | Some (RBRACE(v,br))   ->  "): " + v  + printBrs br
  //            | None -> "None"
  //            | e -> string e 
  //        f.FormatEdge.Add(fun e -> (e.EdgeFormatter.Label.Value <- printEdg e.Edge))
  //        let str = f.Generate()
  //        let c = System.IO.Path.GetInvalidFileNameChars()
  //        let fName1 = c |> Array.fold (
  //                                       fun (name:string) ch -> name.Replace(ch,'_')) fName
  //        System.IO.File.WriteAllText(@"../../" + fName1 + ".dot" ,str)
  
      let printG res (fName:string) =
          let f = GraphvizAlgorithm(res)
  
negative.code:         for e in qGraph.Edges do lexerInputG.AddEdgeForsed (new LexerEdge<_,_>(e.Source,e.Target,Some(e.Tag, e.Tag+"|")))
          lexerInputG
  
      let checkArr expectedArr actualArr =
          if Array.length expectedArr = Array.length actualArr
          then 
              Array.iteri2 (
                  fun i x1 x2 -> 
                  if x1 <> x2 then Assert.Fail ("Arrays differ at position: " + string i)) expectedArr actualArr
              Assert.Pass()
          else Assert.Fail ("Arrays have different length")
  
      let check_brs = 
         Seq.iter
          (fun (e:AbstractParsing.Common.ParserEdge<_>) -> 
  