avl_tree: nit (upper-case methods) bug fix and adding test for equality operator.

src/lol/base/avl_tree.h

@@ -32,27 +32,25 @@ public:
         m_count(0)
     {
         for (auto iterator : other)
-            this->insert(iterator.key, iterator.value);
+            this->Insert(iterator.key, iterator.value);
     }
 
     avl_tree & operator=(avl_tree const & other)
     {
-        this->clear();
-
-        this->m_count = other.m_count;
+        this->Clear();
 
         for (auto iterator : other)
-            this->insert(iterator.key, iterator.value);
+            this->Insert(iterator.key, iterator.value);
 
         return *this;
     }
 
     ~avl_tree()
     {
-        this->clear();
+        this->Clear();
     }
 
-    bool insert(K const & key, V const & value)
+    bool Insert(K const & key, V const & value)
     {
         if (!m_root)
         {
@@ -61,7 +59,7 @@ public:
             return true;
         }
 
-        if(this->m_root->insert(key, value))
+        if(this->m_root->Insert(key, value))
         {
             ++this->m_count;
             return true;
@@ -70,12 +68,12 @@ public:
         return false;
     }
 
-    bool erase(K const & key)
+    bool Erase(K const & key)
     {
         if (!m_root)
             return false;
 
-        if(this->m_root->erase(key))
+        if(this->m_root->Erase(key))
         {
             --this->m_count;
             return true;
@@ -84,24 +82,24 @@ public:
         return false;
     }
 
-    bool exists(K const & key)
+    bool Exists(K const & key)
     {
         if (!m_root)
             return false;
 
-        return this->m_root->exists(key);
+        return this->m_root->Exists(key);
     }
 
-    void clear()
+    void Clear()
     {
         if (this->m_root)
         {
             tree_node * node = nullptr;
-            this->m_root->get_min(node);
+            this->m_root->GetMin(node);
 
             while (node)
             {
-                tree_node * next = node->get_next();
+                tree_node * next = node->GetNext();
                 delete node;
                 node = next;
             }
@@ -111,23 +109,23 @@ public:
         this->m_count = 0;
     }
 
-    bool try_get_value(K const & key, V * & value_ptr) const
+    bool TryGetValue(K const & key, V * & value_ptr) const
     {
         if (this->m_root)
-            return this->m_root->try_get_value(key, value_ptr);
+            return this->m_root->TryGetValue(key, value_ptr);
 
         return false;
     }
 
-    bool try_get_min(K const * & key_ptr, V * & value_ptr) const
+    bool TryGetMin(K const * & key_ptr, V * & value_ptr) const
     {
         tree_node * min_node = nullptr;
 
         if (this->m_root)
         {
-            this->m_root->get_min(min_node);
-            key_ptr = &min_node->get_key();
-            value_ptr = &min_node->get_value();
+            this->m_root->GetMin(min_node);
+            key_ptr = &min_node->GetKey();
+            value_ptr = &min_node->GetValue();
 
             return true;
         }
@@ -135,15 +133,15 @@ public:
         return false;
     }
 
-    bool try_get_max(K const * & key_ptr, V * & value_ptr) const
+    bool TryGetMax(K const * & key_ptr, V * & value_ptr) const
     {
         tree_node * max_node = nullptr;
 
         if (this->m_root)
         {
-            this->m_root->get_max(max_node);
-            key_ptr = &max_node->get_key();
-            value_ptr = &max_node->get_value();
+            this->m_root->GetMax(max_node);
+            key_ptr = &max_node->GetKey();
+            value_ptr = &max_node->GetValue();
 
             return true;
         }
@@ -159,7 +157,7 @@ public:
         tree_node * node = nullptr;
 
         if (this->m_root)
-            this->m_root->get_min(node);
+            this->m_root->GetMin(node);
 
         return Iterator(node);
     }
@@ -169,12 +167,12 @@ public:
         tree_node * node = nullptr;
 
         if (this->m_root)
-            this->m_root->get_min(node);
+            this->m_root->GetMin(node);
 
         return ConstIterator(node);
     }
 
-    int get_count() const
+    int GetCount() const
     {
         return this->m_count;
     }
@@ -204,19 +202,19 @@ protected:
             m_chain[0] = m_chain[1] = nullptr;
         }
 
-        K const & get_key()
+        K const & GetKey()
         {
             return this->m_key;
         }
 
-        V & get_value()
+        V & GetValue()
         {
             return this->m_value;
         }
 
         /* Insert a value in tree and return true or update an existing value for
          * the existing key and return false */
-        bool insert(K const & key, V const & value)
+        bool Insert(K const & key, V const & value)
         {
             int i = -1 + (key < this->m_key) + 2 * (this->m_key < key);
 
@@ -229,7 +227,7 @@ protected:
             bool created = false;
 
             if (this->m_child[i])
-                created = this->m_child[i]->insert(key, value);
+                created = this->m_child[i]->Insert(key, value);
             else
             {
                 created = true;
@@ -245,32 +243,32 @@ protected:
             }
 
             if (created)
-                this->rebalance_if_needed();
+                this->RebalanceIfNeeded();
 
             return created;
         }
 
         /* Erase a value in tree and return true or return false */
-        bool erase(K const & key)
+        bool Erase(K const & key)
         {
             int i = -1 + (key < this->m_key) + 2 * (this->m_key < key);
 
             if (i < 0)
             {
-                this->erase_self();
+                this->EraseSelf();
                 delete this;
                 return true;
             }
-            else if(this->m_child[i]->erase(key))
+            else if(this->m_child[i]->Erase(key))
             {
-                this->rebalance_if_needed();
+                this->RebalanceIfNeeded();
                 return true;
             }
 
             return false;
         }
 
-        bool try_get_value(K const & key, V * & value_ptr)
+        bool TryGetValue(K const & key, V * & value_ptr)
         {
             int i = -1 + (key < this->m_key) + 2 * (this->m_key < key);
 
@@ -281,12 +279,12 @@ protected:
             }
 
             if (this->m_child[i])
-                return this->m_child[i]->try_get_value(key, value_ptr);
+                return this->m_child[i]->TryGetValue(key, value_ptr);
 
             return false;
         }
 
-        bool exists(K const & key)
+        bool Exists(K const & key)
         {
             int i = -1 + (key < this->m_key) + 2 * (this->m_key < key);
 
@@ -294,12 +292,12 @@ protected:
                 return true;
 
             if (this->m_child[i])
-                return this->m_child[i]->exists(key);
+                return this->m_child[i]->Exists(key);
 
             return false;
         }
 
-        void get_min(tree_node * & min_node)
+        void GetMin(tree_node * & min_node)
         {
             min_node = this;
 
@@ -307,7 +305,7 @@ protected:
                 min_node = min_node->m_child[0];
         }
 
-        void get_max(tree_node * & max_node) const
+        void GetMax(tree_node * & max_node) const
         {
             max_node = this;
 
@@ -315,62 +313,62 @@ protected:
                 max_node = max_node->m_child[1];
         }
 
-        int get_balance() const
+        int GetBalance() const
         {
             return this->m_stairs[1] - this->m_stairs[0];
         }
 
-        tree_node * get_previous() const
+        tree_node * GetPrevious() const
         {
             return this->m_chain[0];
         }
 
-        tree_node * get_next() const
+        tree_node * GetNext() const
         {
             return this->m_chain[1];
         }
 
     protected:
 
-        void update_balance()
+        void UpdateBalance()
         {
             this->m_stairs[0] = this->m_child[0] ? (this->m_child[0]->m_stairs[0] > this->m_child[0]->m_stairs[1] ? this->m_child[0]->m_stairs[0] : this->m_child[0]->m_stairs[1]) + 1 : 0;
             this->m_stairs[1] = this->m_child[1] ? (this->m_child[1]->m_stairs[0] > this->m_child[1]->m_stairs[1] ? this->m_child[1]->m_stairs[0] : this->m_child[1]->m_stairs[1]) + 1 : 0;
         }
 
-        void rebalance_if_needed()
+        void RebalanceIfNeeded()
         {
-            this->update_balance();
+            this->UpdateBalance();
 
-            int i = (this->get_balance() ==  2);
-            int j = (this->get_balance() == -2);
+            int i = (this->GetBalance() ==  2);
+            int j = (this->GetBalance() == -2);
 
             if (i || j)
             {
                 tree_node * save = this->m_child[i];
                 tree_node ** save_parent = this->m_parent_slot;
 
-                this->set_child(i, save->m_child[j]);
-                save->set_child(j, this);
+                this->SetChild(i, save->m_child[j]);
+                save->SetChild(j, this);
 
                 save->m_parent_slot = save_parent;
                 *save_parent = save;
 
-                this->update_balance();
-                save->update_balance();
+                this->UpdateBalance();
+                save->UpdateBalance();
             }
         }
 
-        void set_child(int i, tree_node * node)
+        void SetChild(int i, tree_node * node)
         {
             this->m_child[i] = node;
             if (node)
                 node->m_parent_slot = &this->m_child[i];
         }
 
-        void erase_self()
+        void EraseSelf()
         {
-            int i = (this->get_balance() == -1);
+            int i = (this->GetBalance() == -1);
 
             tree_node * replacement = this->m_child[1 - i];
 
@@ -384,7 +382,7 @@ protected:
             {
                 *replacement->m_parent_slot = replacement->m_child[1 - i];
                 if (*replacement->m_parent_slot)
-                    (*replacement->m_parent_slot)->rebalance_if_needed();
+                    (*replacement->m_parent_slot)->RebalanceIfNeeded();
 
                 replacement->m_parent_slot = this->m_parent_slot;
                 *replacement->m_parent_slot = replacement;
@@ -478,7 +476,7 @@ public:
         Iterator operator++()
         {
             tree_node * ret = this->m_node;
-            this->m_node = this->m_node->get_next();
+            this->m_node = this->m_node->GetNext();
 
             return Iterator(ret);
         }
@@ -486,14 +484,14 @@ public:
         Iterator operator--()
         {
             tree_node * ret = this->m_node;
-            this->m_node = this->m_node->get_previous();
+            this->m_node = this->m_node->GetPrevious();
 
             return Iterator(ret);
         }
 
         OutputValue operator*()
         {
-            return OutputValue(this->m_node->get_key(), this->m_node->get_value());
+            return OutputValue(this->m_node->GetKey(), this->m_node->GetValue());
         }
 
         bool operator!=(Iterator const & that) const
@@ -544,7 +542,7 @@ public:
         ConstIterator operator++()
         {
             tree_node * ret = this->m_node;
-            this->m_node = this->m_node->get_next();
+            this->m_node = this->m_node->GetNext();
 
             return ConstIterator(ret);
         }
@@ -552,14 +550,14 @@ public:
         ConstIterator operator--()
         {
             tree_node * ret = this->m_node;
-            this->m_node = this->m_node->get_previous();
+            this->m_node = this->m_node->GetPrevious();
 
             return ConstIterator(ret);
         }
 
         ConstOutputValue operator*()
         {
-            return ConstOutputValue(this->m_node->get_key(), this->m_node->get_value());
+            return ConstOutputValue(this->m_node->GetKey(), this->m_node->GetValue());
         }
 
         bool operator!=(ConstIterator const & that) const

src/lol/base/map.h

@@ -37,7 +37,7 @@ public:
     {
         /* Look for the hash in our table and return the value. */
         V * value_ptr = nullptr;
-        ASSERT(m_tree.try_get_value(key, value_ptr), "trying to read a nonexistent key in map");
+        ASSERT(m_tree.TryGetValue(key, value_ptr), "trying to read a nonexistent key in map");
 
         return *value_ptr;
     }
@@ -50,13 +50,13 @@ public:
         K typed_key(key);
         V * value_ptr = nullptr;
 
-        if (!m_tree.try_get_value(typed_key, value_ptr))
+        if (!m_tree.TryGetValue(typed_key, value_ptr))
         {
             V default_value = V();
-            m_tree.insert(typed_key, default_value);
+            m_tree.Insert(typed_key, default_value);
         }
 
-        ASSERT(m_tree.try_get_value(typed_key, value_ptr), "inner tree is messed up in map");
+        ASSERT(m_tree.TryGetValue(typed_key, value_ptr), "inner tree is messed up in map");
 
         /* If not found, insert a new value. */
         return *value_ptr;
@@ -66,14 +66,14 @@ public:
     inline void Remove(E const &key)
     {
         K typed_key(key);
-        m_tree.erase(typed_key);
+        m_tree.Erase(typed_key);
     }
 
     template <typename E>
     inline bool HasKey(E const &key)
     {
         K typed_key(key);
-        return m_tree.exists(typed_key);
+        return m_tree.Exists(typed_key);
     }
 
     template <typename E>
@@ -81,7 +81,7 @@ public:
     {
         K typed_key(key);
         V * value_ptr;
-        if (m_tree.try_get_value(typed_key, value_ptr))
+        if (m_tree.TryGetValue(typed_key, value_ptr))
         {
             value = *value_ptr;
             return true;
@@ -102,12 +102,12 @@ public:
 
     inline ptrdiff_t Count() const
     {
-        return m_tree.get_count();
+        return m_tree.GetCount();
     }
 
     inline void Empty()
     {
-        m_tree.clear();
+        m_tree.Clear();
     }
 
 private:

src/t/base/avl_tree.cpp

@@ -22,9 +22,9 @@ class test_tree : public avl_tree<int, int>
 public:
     virtual ~test_tree() {}
 
-	int get_root_balance()
+	int GetRootBalance()
 	{
-		return this->m_root->get_balance();
+		return this->m_root->GetBalance();
 	}
 };
 
@@ -38,59 +38,59 @@ lolunit_declare_fixture(AvlTreeTest)
     {
         test_tree tree;
 
-        lolunit_assert_equal(tree.insert(1, 1), true);
-        lolunit_assert_equal(tree.insert(2, 3), true);
-        lolunit_assert_equal(tree.insert(2, 0), false);
+        lolunit_assert_equal(tree.Insert(1, 1), true);
+        lolunit_assert_equal(tree.Insert(2, 3), true);
+        lolunit_assert_equal(tree.Insert(2, 0), false);
     }
 
     lolunit_declare_test(AvlTreeBalanceCheck)
     {
         test_tree tree;
 
-        lolunit_assert_equal(tree.insert(10, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(10, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(20, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 1);
+        lolunit_assert_equal(tree.Insert(20, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 1);
 
-        lolunit_assert_equal(tree.insert(30, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(30, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(00, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), -1);
+        lolunit_assert_equal(tree.Insert(00, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), -1);
 
-        lolunit_assert_equal(tree.insert(-10, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), -1);
+        lolunit_assert_equal(tree.Insert(-10, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), -1);
 
-        lolunit_assert_equal(tree.insert(-20, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(-20, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(-20, 1), false);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(-20, 1), false);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(11, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 1);
+        lolunit_assert_equal(tree.Insert(11, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 1);
 
-        lolunit_assert_equal(tree.insert(13, 2), true);
-        lolunit_assert_equal(tree.get_root_balance(), 1);
+        lolunit_assert_equal(tree.Insert(13, 2), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 1);
     }
 
     lolunit_declare_test(AvlTreeDeletion)
     {
         test_tree tree;
 
-        lolunit_assert_equal(tree.insert(10, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(10, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(20, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 1);
+        lolunit_assert_equal(tree.Insert(20, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 1);
 
-        lolunit_assert_equal(tree.insert(30, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(30, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.get_count(), 3);
+        lolunit_assert_equal(tree.GetCount(), 3);
 
-        lolunit_assert_equal(tree.erase(30), true);
+        lolunit_assert_equal(tree.Erase(30), true);
 
         int test = 0;
 
@@ -100,12 +100,12 @@ lolunit_declare_fixture(AvlTreeTest)
             lolunit_assert_equal(iterator.key, test);
         }
 
-        lolunit_assert_equal(tree.get_count(), 2);
-        lolunit_assert_equal(tree.insert(30, 1), true);
+        lolunit_assert_equal(tree.GetCount(), 2);
+        lolunit_assert_equal(tree.Insert(30, 1), true);
 
-        lolunit_assert_equal(tree.erase(20), true);
-        lolunit_assert_equal(tree.insert(20, 1), true);
-        lolunit_assert_equal(tree.exists(10), true);
+        lolunit_assert_equal(tree.Erase(20), true);
+        lolunit_assert_equal(tree.Insert(20, 1), true);
+        lolunit_assert_equal(tree.Exists(10), true);
 
         test = 0;
 
@@ -120,31 +120,31 @@ lolunit_declare_fixture(AvlTreeTest)
     {
         test_tree tree;
 
-        lolunit_assert_equal(tree.insert(10, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(10, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(20, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 1);
+        lolunit_assert_equal(tree.Insert(20, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 1);
 
-        lolunit_assert_equal(tree.erase(10), true);
-        lolunit_assert_equal(tree.exists(20), true);
-        lolunit_assert_equal(tree.exists(10), false);
+        lolunit_assert_equal(tree.Erase(10), true);
+        lolunit_assert_equal(tree.Exists(20), true);
+        lolunit_assert_equal(tree.Exists(10), false);
 
-        lolunit_assert_equal(tree.insert(10, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), -1);
+        lolunit_assert_equal(tree.Insert(10, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), -1);
 
-        lolunit_assert_equal(tree.insert(30, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(30, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(40, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 1);
+        lolunit_assert_equal(tree.Insert(40, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 1);
 
-        lolunit_assert_equal(tree.insert(50, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 1);
+        lolunit_assert_equal(tree.Insert(50, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 1);
 
-        lolunit_assert_equal(tree.erase(30), true);
-        lolunit_assert_equal(tree.exists(40), true);
-        lolunit_assert_equal(tree.exists(50), true);
+        lolunit_assert_equal(tree.Erase(30), true);
+        lolunit_assert_equal(tree.Exists(40), true);
+        lolunit_assert_equal(tree.Exists(50), true);
     }
 
 
@@ -152,45 +152,45 @@ lolunit_declare_fixture(AvlTreeTest)
     {
         test_tree tree;
 
-        lolunit_assert_equal(tree.insert(10, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(10, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(20, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 1);
+        lolunit_assert_equal(tree.Insert(20, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 1);
 
-        lolunit_assert_equal(tree.insert(30, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(30, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(00, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), -1);
+        lolunit_assert_equal(tree.Insert(00, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), -1);
 
-        lolunit_assert_equal(tree.insert(-10, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), -1);
+        lolunit_assert_equal(tree.Insert(-10, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), -1);
 
-        lolunit_assert_equal(tree.insert(-20, 1), true);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(-20, 1), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(-20, 1), false);
-        lolunit_assert_equal(tree.get_root_balance(), 0);
+        lolunit_assert_equal(tree.Insert(-20, 1), false);
+        lolunit_assert_equal(tree.GetRootBalance(), 0);
 
-        lolunit_assert_equal(tree.insert(11, 2), true);
-        lolunit_assert_equal(tree.get_root_balance(), 1);
+        lolunit_assert_equal(tree.Insert(11, 2), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 1);
 
-        lolunit_assert_equal(tree.insert(13, 3), true);
-        lolunit_assert_equal(tree.get_root_balance(), 1);
+        lolunit_assert_equal(tree.Insert(13, 3), true);
+        lolunit_assert_equal(tree.GetRootBalance(), 1);
 
         int * value_ptr = nullptr;
 
-        lolunit_assert_equal(tree.try_get_value(-10, value_ptr), true);
+        lolunit_assert_equal(tree.TryGetValue(-10, value_ptr), true);
         lolunit_assert_equal(*value_ptr, 1);
 
-        lolunit_assert_equal(tree.try_get_value(11, value_ptr), true);
+        lolunit_assert_equal(tree.TryGetValue(11, value_ptr), true);
         lolunit_assert_equal(*value_ptr, 2);
 
-        lolunit_assert_equal(tree.try_get_value(13, value_ptr), true);
+        lolunit_assert_equal(tree.TryGetValue(13, value_ptr), true);
         lolunit_assert_equal(*value_ptr, 3);
 
-        lolunit_assert_equal(tree.try_get_value(67, value_ptr), false);
+        lolunit_assert_equal(tree.TryGetValue(67, value_ptr), false);
         lolunit_assert_equal(*value_ptr, 3);
     }
 
@@ -199,7 +199,7 @@ lolunit_declare_fixture(AvlTreeTest)
         test_tree tree;
 
         for (int i = 1 ; i < 100 ; ++i)
-            tree.insert(i, 2 * i + i % 3);
+            tree.Insert(i, 2 * i + i % 3);
 
         int tmp = 0;
 
@@ -210,7 +210,7 @@ lolunit_declare_fixture(AvlTreeTest)
             tmp = iterator.key;
         }
 
-        lolunit_assert_equal(tree.get_count(), 99);
+        lolunit_assert_equal(tree.GetCount(), 99);
     }
 
     lolunit_declare_test(AvlTreeTestIteratorCopy)
@@ -218,7 +218,7 @@ lolunit_declare_fixture(AvlTreeTest)
         test_tree tree;
 
         for (int i = 1 ; i < 100 ; ++i)
-            tree.insert(i, 2 * i + i % 3);
+            tree.Insert(i, 2 * i + i % 3);
 
         test_tree other = tree;
 
@@ -231,7 +231,53 @@ lolunit_declare_fixture(AvlTreeTest)
             tmp = iterator.key;
         }
 
-        lolunit_assert_equal(other.get_count(), 99);
+        lolunit_assert_equal(other.GetCount(), 99);
+    }
+
+    lolunit_declare_test(AvlTreeTestCopy)
+    {
+        avl_tree<int, int> test1, test2;
+
+        for (int i = 0 ; i < 10 ; ++i)
+            test1.Insert(i, 2*i);
+
+        for (int i = 10 ; i < 15 ; ++i)
+            test2.Insert(i, 3*i);
+
+        lolunit_assert_equal(test1.GetCount(), 10);
+        lolunit_assert_equal(test2.GetCount(), 5);
+
+        int i = -1;
+        for (auto iterator : test1)
+        {
+            ++i;
+            lolunit_assert_equal(iterator.key, i);
+            lolunit_assert_equal(iterator.value, 2*i);
+        }
+
+        for (auto iterator : test2)
+        {
+            ++i;
+            lolunit_assert_equal(iterator.key, i);
+            lolunit_assert_equal(iterator.value, 3*i);
+        }
+
+        test2 = test1;
+
+        auto it1 = test1.begin();
+        auto it2 = test2.begin();
+
+        for ( ; it1 != test1.end() && it2 != test2.end() ; ++it1 , ++it2)
+        {
+            lolunit_assert_equal((*it1).key, (*it2).key);
+            lolunit_assert_equal((*it1).value, (*it2).value);
+        }
+
+        lolunit_assert(!(it1 != test1.end()));
+        lolunit_assert(!(it2 != test2.end()));
+
+        lolunit_assert_equal(test1.GetCount(), 10);
+        lolunit_assert_equal(test2.GetCount(), 10);
     }
 };