anchor.diff:      | MULT x -> box x
       | RNGLR_EOF x -> box x
   
  -let leftSide = [|2; 3; 0; 0; 1|]
  -
   [<TestFixture>]
   type CommonAstTest () = 
       [<Test>]
       member this.FindNonterminalsByIndTest () =
  -        Assert.AreEqual(1, tree.FindNonterminalsByInd 3 leftSide |> Array.length)
  -        Assert.AreEqual(1, tree.FindNonterminalsByInd 2 leftSide |> Array.length)
  -        Assert.AreEqual(4, tree.FindNonterminalsByInd 0 leftSide |> Array.length)
  -        Assert.AreEqual(0, tree.FindNonterminalsByInd 10 leftSide |> Array.length)
  +        Assert.AreEqual(1, tree.FindNonterminalsByInd 3 |> Array.length)
  +        Assert.AreEqual(1, tree.FindNonterminalsByInd 2 |> Array.length)
  +        Assert.AreEqual(4, tree.FindNonterminalsByInd 0 |> Array.length)
  +        Assert.AreEqual(0, tree.FindNonterminalsByInd 10 |> Array.length)
   
       [<Test>]
       member this.FindNonterminalsByStringTest () =
  -        Assert.AreEqual(1, tree.FindNonterminalsByString "yard_start_rule" leftSide numToString |> Array.length)
  -        Assert.AreEqual(1, tree.FindNonterminalsByString "s" leftSide numToString |> Array.length)
  -        Assert.AreEqual(4, tree.FindNonterminalsByString "e" leftSide numToString |> Array.length)
  -        Assert.AreEqual(0, tree.FindNonterminalsByString "nothing" leftSide numToString  |> Array.length)
  +        Assert.AreEqual(1, tree.FindNonterminalsByString "yard_start_rule" |> Array.length)
  +        Assert.AreEqual(1, tree.FindNonterminalsByString "s" |> Array.length)
  +        Assert.AreEqual(4, tree.FindNonterminalsByString "e" |> Array.length)
  +        Assert.AreEqual(0, tree.FindNonterminalsByString "nothing" |> Array.length)
   
       [<Test>]
       member this.GetTypeOfExpressionTest () =
  -        let typeOfExpr = tree.GetTypeOfExpression [|"s"; "e"|] leftSide numToString
  +        let typeOfExpr = tree.GetTypeOfExpression [|"s"; "e"|]
           Assert.IsTrue(typeOfExpr <> null && typeOfExpr.Length = 1 && String.Equals(typeOfExpr.[0], "s"))
   
   
       [<Test>]
       member this.GetTypeOfExpressionTest2 () =
  -        let typeOfExpr = tree.GetTypeOfExpression [|"e"|] leftSide numToString
  +        let typeOfExpr = tree.GetTypeOfExpression [|"e"|]
           Assert.IsTrue(typeOfExpr <> null && typeOfExpr.Length = 1 && String.Equals(typeOfExpr.[0], "e"))
           
   
       [<Test>]
       member this.GetTypeOfExpressionTest_1 () =
  -        let typeOfExpr = tree_1.GetTypeOfExpression [|"s"; "e"|] leftSide numToString
  +        let typeOfExpr = tree_1.GetTypeOfExpression [|"s"; "e"|]
           Assert.IsTrue(typeOfExpr <> null && typeOfExpr.Length = 1 && String.Equals(typeOfExpr.[0], "s"))
   
   
       [<Test>]
       member this.GetTypeOfExpressionTest2_1 () =
  -        let typeOfExpr = tree_1.GetTypeOfExpression [|"e"|] leftSide numToString
  +        let typeOfExpr = tree_1.GetTypeOfExpression [|"e"|]
           Assert.IsTrue(typeOfExpr <> null && typeOfExpr.Length = 1 && String.Equals(typeOfExpr.[0], "e"))
   
       [<Test>]
       member this.GetTypeOfExpressionTest_2 () =
  -        let typeOfExpr = tree_2.GetTypeOfExpression [|"s"; "error"|] leftSide numToString
  +        let typeOfExpr = tree_2.GetTypeOfExpression [|"s"; "error"|]
           Assert.IsTrue(typeOfExpr <> null 
                         && typeOfExpr.Length = 2 
                         && typeOfExpr |> Array.exists (fun x -> String.Equals("s", x))
  
positive.code:     | 7 -> "MULT"
      | _ -> ""
  
  let tokenToNumber = function
      | NUM _ -> 4
      | PLUS _ -> 5
  
negative.code: let getAst family otherFamilies = new AST(family, otherFamilies)
  let getTree<'T> tokens root rules = new Tree<'T>(tokens, root, rules)
  
  let leftSide = [|2; 3; 0; 0; 1|]
  
  let numToString = function
      | 0 -> "e"
  