anchor.diff:  
       [<Test>]
       member this.GetTypeOfExpressionTest2_2 () =
  -        let typeOfExpr = tree_2.GetTypeOfExpression [|"e"|] leftSide numToString
  +        let typeOfExpr = tree_2.GetTypeOfExpression [|"e"|]
           Assert.IsTrue(typeOfExpr <> null && typeOfExpr.Length = 1 && String.Equals(typeOfExpr.[0], "e"))
           
       [<Test>]
       member this.GetTypeOfExpressionTest_3 () =
  -        let typeOfExpr = tree_3.GetTypeOfExpression [|"e"; "error"|] leftSide numToString
  +        let typeOfExpr = tree_3.GetTypeOfExpression [|"e"; "error"|]
           Assert.IsTrue(typeOfExpr <> null 
                         && typeOfExpr.Length = 2 
                         && typeOfExpr |> Array.exists (fun x -> String.Equals("e", x))
  
positive.code:     | 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)
  
      [<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)
  
      [<Test>]
      member this.GetTypeOfExpressionTest () =
          let typeOfExpr = tree.GetTypeOfExpression [|"s"; "e"|] leftSide numToString
          Assert.IsTrue(typeOfExpr <> null && typeOfExpr.Length = 1 && String.Equals(typeOfExpr.[0], "s"))
  
  
      [<Test>]
      member this.GetTypeOfExpressionTest2 () =
          let typeOfExpr = tree.GetTypeOfExpression [|"e"|] leftSide numToString
          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
          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
          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
          Assert.IsTrue(typeOfExpr <> null 
                        && typeOfExpr.Length = 2 
                        && typeOfExpr |> Array.exists (fun x -> String.Equals("s", x))
  
negative.code: 
      [<Test>]
      member this.GetTypeOfExpressionTest2_3 () =
          let typeOfExpr = tree_3.GetTypeOfExpression [|"e"|]
          Assert.IsTrue(typeOfExpr <> null && typeOfExpr.Length = 1 && String.Equals(typeOfExpr.[0], "e"))
  
      [<Test>]
      member this.CalculateStatisticsTest () =
          let (max, min, average) = tree_3.CalculateStatistics "e" 
          Assert.AreEqual(1, max)
          Assert.AreEqual(1, min)
          Assert.AreEqual(1.0, average)
  
      [<Test>]
      member this.CalculateStatisticsTest_1 () =
          let (max, min, average) = tree_3.CalculateStatistics "s" 
          Assert.AreEqual(3, max)
          Assert.AreEqual(2, min)
          Assert.AreEqual(2.5, average)
  
      [<Test>]
      member this.CalculateStatisticsTest_2 () =
          let (max, min, average) = tree_3.CalculateStatistics "error" 
          Assert.AreEqual(1, max)
          Assert.AreEqual(0, min)
          Assert.AreEqual(0.5, average)
  
      [<Test>]
      member this.CalculateStatisticsTest_3 () =
          let (max, min, average) = tree_3.CalculateStatistics "yard_start_rule"
          Assert.AreEqual(1, max)
          Assert.AreEqual(1, min)
          Assert.AreEqual(1.0, average)
  
      [<Test>]
      member this.CalculateStatisticsTest_4 () =
          let (max, min, average) = tree_2.CalculateStatistics "e"
          Assert.AreEqual(3, max)
          Assert.AreEqual(3, min)
          Assert.AreEqual(3.0, average)
  
      [<Test>]
      member this.CalculateStatisticsTest_5 () =
          let (max, min, average) = tree_2.CalculateStatistics "s"
          Assert.AreEqual(1, max)
          Assert.AreEqual(0, min)
          Assert.AreEqual(0.5, average)
  
      [<Test>]
      member this.GetTypeOfExpressionTest_4 () =
          let typeOfExpr = tree_4.GetTypeOfExpression [|"e"; "error"|]
          Assert.IsTrue(typeOfExpr <> null 
                        && typeOfExpr.Length = 1
                        && String.Equals("error", typeOfExpr.[0]))
  
      [<Test>]
      member this.GetTypeOfExpressionTest2_4 () =
          let typeOfExpr = tree_4.GetTypeOfExpression [|"e"|]
          Assert.IsTrue(typeOfExpr <> null && typeOfExpr.Length = 0)
          
  
  