Index: uspace/lib/cpp/include/internal/hash_table.hpp
===================================================================
--- uspace/lib/cpp/include/internal/hash_table.hpp	(revision 1fafb3e823ce33a7b68c9c48a55552a969f608c2)
+++ uspace/lib/cpp/include/internal/hash_table.hpp	(revision b22ccaa60d7166c5ab9c53efecda53f5c976ea39)
@@ -577,5 +577,5 @@
                     if (idx_ < max_idx_)
                     {
-                        while (!table_[++idx_].head)
+                        while (!table_[++idx_].head && idx_ < max_idx_)
                         { /* DUMMY BODY */ }
 
@@ -602,5 +602,5 @@
                     if (idx_ < max_idx_)
                     {
-                        while (!table_[++idx_].head)
+                        while (!table_[++idx_].head && idx_ < max_idx_)
                         { /* DUMMY BODY */ }
 
@@ -693,5 +693,5 @@
                     if (idx_ < max_idx_)
                     {
-                        while (!table_[++idx_].head)
+                        while (!table_[++idx_].head && idx_ < max_idx_)
                         { /* DUMMY BODY */ }
 
@@ -718,5 +718,5 @@
                     if (idx_ < max_idx_)
                     {
-                        while (!table_[++idx_].head)
+                        while (!table_[++idx_].head && idx_ < max_idx_)
                         { /* DUMMY BODY */ }
 
@@ -996,8 +996,5 @@
             {
                 for (const auto& x: other)
-                {
-                    auto spot = find_insertion_spot(key_extractor_(x));
-                    insert(spot, x);
-                }
+                    insert(x);
             }
 
@@ -1048,7 +1045,8 @@
             iterator begin() noexcept
             {
+                auto idx = first_filled_bucket_();
                 return iterator{
-                    table_, size_type{}, bucket_count_,
-                    table_[0].head
+                    table_, idx, bucket_count_,
+                    table_[idx].head
                 };
             }
@@ -1071,7 +1069,8 @@
             const_iterator cbegin() const noexcept
             {
+                auto idx = first_filled_bucket_();
                 return const_iterator{
-                    table_, size_type{}, bucket_count_,
-                    table_[0].head
+                    table_, idx, bucket_count_,
+                    table_[idx].head
                 };
             }
@@ -1348,6 +1347,35 @@
             bool is_eq_to(const hash_table& other) const
             {
-                // TODO: implement
-                return false;
+                if (size() != other.size())
+                    return false;
+
+                auto it = begin();
+                while (it != end())
+                {
+                    /**
+                     * For each key K we will check how many
+                     * instances of K are there in the table.
+                     * Then we will check if the count for K
+                     * is equal to that amount.
+                     */
+
+                    size_type cnt{};
+                    auto tmp = it;
+
+                    while (key_eq_(key_extractor_(*it), key_extractor_(*tmp)))
+                    {
+                        ++cnt;
+                        if (++tmp == end())
+                            break;
+                    }
+
+                    auto other_cnt = other.count(key_extractor_(*it));
+                    if (cnt != other_cnt)
+                        return false;
+
+                    it = tmp; // tmp  is one past *it's key.
+                }
+
+                return true;
             }
 
@@ -1431,4 +1459,25 @@
             }
 
+            size_type first_filled_bucket_() const
+            {
+                size_type res{};
+                while (res < bucket_count_)
+                {
+                    if (table_[res].head)
+                        return res;
+                    ++res;
+                }
+
+                /**
+                 * Note: This is used for iterators,
+                 *       so we need to return a valid index.
+                 *       But since table_[0].head is nullptr
+                 *       we know that if we return 0 the
+                 *       created iterator will test as equal
+                 *       to end().
+                 */
+                return 0;
+            }
+
             friend Policy;
     };