public void ArrayTest()
        {
            var array = new TreeElement<int, string>(new TreeElement<int, string>("A"), new TreeElement<int, string>("B"));

            var arrayChangedHistory = array.ArrayChanged.SubscribeHistory();
            var grandChildrenChangedHistory = array.GrandChildrenChanged.SubscribeHistory();

            array.Type.Is(ElementType.Array);
            AssertEx.Catch<InvalidOperationException>(() => array.LeafValue.ToString());
            AssertEx.Catch<InvalidOperationException>(() => array.NodeChildren.ToString());
            AssertEx.Catch<InvalidOperationException>(() => array.NodeChildrenChanged.ToString());

            array.Array[0].LeafValue.Is("A");
            array.Array[1].LeafValue.Is("B");
            array.Array.Count.Is(2);

            arrayChangedHistory.Count().Is(0);
            grandChildrenChangedHistory.Count().Is(0);

            array.Array.Add(new TreeElement<int, string>("C"));
            array.Array.Clear();

            arrayChangedHistory.Values.Select(x => x.Action).IsSequenceEqual(NotifyCollectionChangedAction.Add, NotifyCollectionChangedAction.Reset);
            grandChildrenChangedHistory.Values.Select(x => x.Value.Action).IsSequenceEqual(NotifyCollectionChangedAction.Add, NotifyCollectionChangedAction.Reset);
        }

        public override short GetChildRole(TreeElement child)
        {
            if (child is ReferenceName)
                return 0x27;

            return base.GetChildRole(child);
        }

        public void Write(TextWriter writer, IEnumerable<Stack> stacks)
        {
            var root = new TreeElement();

            var filtered = stacks
                .OrderByDescending(s => s.Count);

            foreach (var stack in filtered) {
                AddStacks(root, stack, 0);
            }

            var total = root.Total;
            var normMax = (double)(int.MaxValue / 2);
            var scaleFactor = Math.Min(normMax / total, 1);

            var lowerBound = total * 0.0001;

            RescaleAndTrim(root, scaleFactor, lowerBound);

            using (var jWriter = new JsonTextWriter(writer)) {
                jWriter.Formatting = Formatting.None;
                //jWriter.Formatting = Formatting.Indented;
                WriteTree(root, jWriter);
            }
        }

    public static void Run(TreeElement node, ILexer lexer, ITokenOffsetProvider offsetProvider, bool trimTokens, SeldomInterruptChecker interruptChecker)
    {
      Assertion.Assert(node.parent == null, "node.parent == null");

      var root = node as CompositeElement;
      if (root == null)
      {
        return;
      }

      var inserter = new PsiMissingTokensInserter(lexer, offsetProvider, interruptChecker);
      lexer.Start();

      if (trimTokens)
      {
        using (var container = new DummyContainer(root))
        {
          inserter.Run(container);
        }
      }
      else
      {
        var terminator = new EofToken(lexer.Buffer);
        root.AppendNewChild(terminator);
        inserter.Run(root);
        root.DeleteChildRange(terminator, terminator);
      }
    }

 public override short GetChildRole(TreeElement child)
 {
     if (child.type == L4NElementType.REFERENCE_NAME)
     {
         return REFERENCE_NAME_ROLE;
     }
     return 0;
 }

        public override short GetChildRole(TreeElement child)
        {
            if (child is IColumnElement && ((XmlTag)child).TagName == "column")
                    return Column_ROLE_ID;
                else

            return base.GetChildRole(child);
        }

        public override short GetChildRole(TreeElement child)
        {
            if (child is IParamElement && ((XmlTag)child).TagName == "param")
                    return Param_ROLE_ID;
                else

            return base.GetChildRole(child);
        }

 public override short GetChildRole(TreeElement child)
 {
     if (child is IIdMappingElement && ((XmlTag)child).TagName == "id")
         return ID_MAPPING_ELEMENT_ROLE;
     else if (child is IPropertyMappingElement && ((XmlTag)child).TagName == "property")
         return PROPTIY_ELEMENT_ROLE;
     else
         return base.GetChildRole(child);
 }

        public FileTree(Screen screen, Rectangle bound, Sprite background, string root, string extensionFilter = "")
            : base(screen)
        {
            Bound = bound;
            Background = background;
            elements = new Dictionary<TextBlock, TreeElement>();
            font = screen.Manager.Game.Content.Load<SpriteFont>("Fonts/Hud");

            Root = new TreeElement() { Path = root, isDirectory = true };
            AddToTreeAllChilds(Root, extensionFilter);
        }

        public void LeafTest()
        {
            var leaf = new TreeElement<int, string>("1");

            AssertEx.Catch<InvalidOperationException>(() => leaf.Array.ToString());
            AssertEx.Catch<InvalidOperationException>(() => leaf.ArrayChanged.Subscribe());
            AssertEx.Catch<InvalidOperationException>(() => leaf.NodeChildren.ToString());
            AssertEx.Catch<InvalidOperationException>(() => leaf.NodeChildrenChanged.Subscribe());
            leaf.GrandChildrenChanged.Subscribe(); // throws no exception
            leaf.LeafValue.Is("1");
            leaf.Type.Is(ElementType.Leaf);
        }

        public override short GetChildRole(TreeElement child)
        {
            if (child is IReturnDiscriminatorElement && ((XmlTag)child).TagName == "return-discriminator")
                    return ReturnDiscriminator_ROLE_ID;
                else

                if (child is IReturnPropertyElement && ((XmlTag)child).TagName == "return-property")
                    return ReturnProperty_ROLE_ID;
                else

            return base.GetChildRole(child);
        }

        public override short GetChildRole(TreeElement child)
        {
            if (child is IKeyPropertyElement && ((XmlTag)child).TagName == "key-property")
                    return KeyPropertys_ROLE_ID;
                else

                if (child is IKeyManyToOneElement && ((XmlTag)child).TagName == "key-many-to-one")
                    return KeyManyToOnes_ROLE_ID;
                else

            return base.GetChildRole(child);
        }

        public void EqualsAndHashCodeTest()
        {
            var te_a1 = new TreeElement<string, string>("a");
            var te_a2 = new TreeElement<string, string>("a");
            var te_b = new TreeElement<string, string>("b");
            var te_node = new TreeElement<string, string>();

            te_a1.Is(te_a1);
            te_a1.GetHashCode().Is(te_a1.GetHashCode());
            te_a1.Is(te_a2);
            te_a1.GetHashCode().Is(te_a2.GetHashCode());
            te_a1.IsNot(te_b);
            te_a1.IsNot(te_node);
        }

        private void AddStacks(TreeElement root, Stack stack, int depth)
        {
            root.Total += stack.Count;

            var limit = stack.Stacks.Length;
            //var limit = Math.Min(stack.Stacks.Length, 4);
            if (depth < limit) {
                var frame = stack.Stacks[depth];
                if (!root.Children.ContainsKey(frame)) {
                    root.Children.Add(frame, new TreeElement());
                }

                AddStacks(root.Children[frame], stack, depth + 1);
            }
        }

        public override short GetChildRole(TreeElement child)
        {
            if (child is ICreateElement && ((XmlTag)child).TagName == "create")
                    return Create_ROLE_ID;
                else

                if (child is IDropElement && ((XmlTag)child).TagName == "drop")
                    return Drop_ROLE_ID;
                else

                if (child is IDialectScopeElement && ((XmlTag)child).TagName == "dialect-scope")
                    return DialectScope_ROLE_ID;
                else

            return base.GetChildRole(child);
        }

        public override short GetChildRole(TreeElement child)
        {
            if (child is IParentElement && ((XmlTag)child).TagName == "parent")
                    return Parent_ROLE_ID;
                else

                if (child is IPropertyElement && ((XmlTag)child).TagName == "property")
                    return Properties_ROLE_ID;
                else

                if (child is IManyToOneElement && ((XmlTag)child).TagName == "many-to-one")
                    return ManyToOnes_ROLE_ID;
                else

                if (child is INestedCompositeElementElement && ((XmlTag)child).TagName == "nested-composite-element")
                    return NestedCompositeElements_ROLE_ID;
                else

            return base.GetChildRole(child);
        }

    protected override void ProcessLeafElement(TreeElement element)
    {
      int leafOffset = GetLeafOffset(element).Offset;

      // Check if some tokens are missed before this leaf
      if (myLexer.TokenType != null && myLexer.TokenStart < leafOffset)
      {
        // Find out the right place to insert tokens to
        TreeElement anchor = element;
        CompositeElement parent = anchor.parent;
        while (anchor == parent.firstChild && parent.parent != null)
        {
          anchor = parent;
          parent = parent.parent;
        }

        // proceed with inserting tokens
        while (myLexer.TokenType != null && myLexer.TokenStart < leafOffset)
        {
          LeafElementBase token = CreateMissingToken();

          parent.AddChildBefore(token, anchor);

          myLexer.Advance();
        }
      }

      // skip all tokens which lie inside given leaf element
      int leafEndOffset = leafOffset + element.GetTextLength();
      if ((element is IClosedChameleonBody) && (myLexer is CachingLexer))
      {
        ((CachingLexer)myLexer).FindTokenAt(leafEndOffset);
      }
      else
      {
        while (myLexer.TokenType != null && myLexer.TokenStart < leafEndOffset)
        {
          myLexer.Advance();
        }
      }
    }

 /// <summary>
 /// добавление элемента в дерево
 /// </summary>
 /// <param name="value"></param>
 public void Add(int value)
 {
     if (head == null)
     {
         head = new TreeElement(value);
     }
     else
     {
         TreeElement tmpHead = head;
         while (true)
         {
             if (tmpHead.GetValue() == value)
                 return;
             if (tmpHead.GetValue() > value)
             {
                 if (tmpHead.GetLeft() == null)
                 {
                     tmpHead.SetLeft(new TreeElement(value));
                     return;
                 }
                 else
                 {
                     tmpHead = tmpHead.GetLeft();
                 }
             }
             if (tmpHead.GetValue() < value)
             {
                 if (tmpHead.GetRight() == null)
                 {
                     tmpHead.SetRight(new TreeElement(value));
                     return;
                 }
                 else
                 {
                     tmpHead = tmpHead.GetRight();
                 }
             }
         }
     }
 }

        private void RescaleAndTrim(TreeElement root, double scaleFactor, double lowerBound)
        {
            root.Total = (long)(root.Total * scaleFactor);

            if (root.Total == 0) {
                Console.WriteLine("Zero encountered.");
                root.Total = 1;
            }

            var toRemove = root.Children
                .Where(c => c.Value.Total < lowerBound)
                .Select(c => c.Key)
                .ToArray();

            foreach (var remove in toRemove) {
                root.Children.Remove(remove);
            }

            foreach (var child in root.Children) {
                RescaleAndTrim(child.Value, scaleFactor, lowerBound);
            }
        }

 private void AddToTreeAllChilds(TreeElement parent, string extensionFilter)
 {
     string root = parent.Path;
     foreach (string dir in Directory.GetDirectories(root))
     {
         TreeElement child = new TreeElement() { Path = dir, isDirectory = true, Parent = parent };
         elements.Add(new TextBlock(Screen, nextPos, dir.Split('\\').Last()) { Parent = this }, child);
         nextPos.X += 20;
         nextPos.Y += 30;
         AddToTreeAllChilds(child, extensionFilter);
         parent.Childs.Add(child);
     }
     foreach (string file in Directory.GetFiles(root))
     {
         if (file.EndsWith(extensionFilter))
         {
             TreeElement child = new TreeElement() { Path = file, isDirectory = false, Parent = parent };
             parent.Childs.Add(child);
             elements.Add(new TextBlock(Screen, nextPos, file.Split('\\').Last()) { Parent = this }, child);
             nextPos.Y += 30;
         }
     }
     nextPos.X -= 20;
 }