diff --git a/include/tsl/ordered_hash.h b/include/tsl/ordered_hash.h
index 5fb7e6d..6aeefe9 100644
--- a/include/tsl/ordered_hash.h
+++ b/include/tsl/ordered_hash.h
@@ -949,7 +949,6 @@ class ordered_hash : private Hash, private KeyEqual {
     m_max_load_factor = clamp(ml, float(MAX_LOAD_FACTOR__MINIMUM),
                               float(MAX_LOAD_FACTOR__MAXIMUM));
 
-    m_max_load_factor = ml;
     m_load_threshold = size_type(float(bucket_count()) * m_max_load_factor);
   }
 
diff --git a/tests/ordered_map_tests.cpp b/tests/ordered_map_tests.cpp
index a412904..a1eca6f 100644
--- a/tests/ordered_map_tests.cpp
+++ b/tests/ordered_map_tests.cpp
@@ -1352,6 +1352,40 @@ BOOST_AUTO_TEST_CASE(test_swap_empty) {
                                      {1, 10}, {8, 80}, {3, 30}, {4, 40}}));
 }
 
+/**
+ * max_load_factor
+ */
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_max_load_factor_clamp, HMap, test_types) {
+  const std::pair<float, float> factors[] = {
+      {0.05f, 0.1f}, {0.1f, 0.1f}, {0.5f, 0.5f},
+      {0.95f, 0.95f}, {0.99f, 0.95f}};
+
+  for (std::size_t count : {std::size_t(0), std::size_t(3)}) {
+    for (const auto& factor : factors) {
+      auto map = utils::get_filled_hash_map<HMap>(count);
+      const auto buckets = map.bucket_count();
+      map.max_load_factor(factor.first);
+      BOOST_REQUIRE_EQUAL(map.max_load_factor(), factor.second);
+      BOOST_CHECK_EQUAL(map.bucket_count(), buckets);
+
+      serializer serial;
+      map.serialize(serial);
+      deserializer header(serial.str());
+      header.template operator()<std::uint64_t>();  // protocol version
+      BOOST_CHECK_EQUAL(header.template operator()<std::uint64_t>(), count);
+      BOOST_CHECK_EQUAL(header.template operator()<std::uint64_t>(), buckets);
+      BOOST_CHECK_EQUAL(header.template operator()<float>(), factor.second);
+
+      for (bool hash_compatible : {false, true}) {
+        deserializer dserial(serial.str());
+        auto restored = HMap::deserialize(dserial, hash_compatible);
+        BOOST_CHECK_EQUAL(restored.max_load_factor(), factor.second);
+        BOOST_CHECK(utils::test_is_equal(restored, map));
+      }
+    }
+  }
+}
+
 /**
  * serialize and deserialize
  */
diff --git a/tests/ordered_set_tests.cpp b/tests/ordered_set_tests.cpp
index 9c9847f..d6bb5c5 100644
--- a/tests/ordered_set_tests.cpp
+++ b/tests/ordered_set_tests.cpp
@@ -46,6 +46,46 @@ using test_types = boost::mpl::list<
     tsl::ordered_set<std::string, mod_hash<9>>,
     tsl::ordered_set<move_only_test, mod_hash<9>>>;
 
+/**
+ * max_load_factor
+ */
+BOOST_AUTO_TEST_CASE_TEMPLATE(test_max_load_factor_clamp, HSet, test_types) {
+  const std::pair<float, float> factors[] = {
+      {0.05f, 0.1f}, {0.1f, 0.1f}, {0.5f, 0.5f},
+      {0.95f, 0.95f}, {0.99f, 0.95f}};
+
+  for (std::size_t count : {std::size_t(0), std::size_t(3)}) {
+    for (const auto& factor : factors) {
+      HSet set;
+      for (std::size_t i = 0; i < count; ++i) {
+        set.insert(utils::get_key<typename HSet::key_type>(i));
+      }
+      const auto buckets = set.bucket_count();
+      set.max_load_factor(factor.first);
+      BOOST_REQUIRE_EQUAL(set.max_load_factor(), factor.second);
+      BOOST_CHECK_EQUAL(set.bucket_count(), buckets);
+
+      serializer serial;
+      set.serialize(serial);
+      deserializer header(serial.str());
+      header.template operator()<std::uint64_t>();  // protocol version
+      BOOST_CHECK_EQUAL(header.template operator()<std::uint64_t>(), count);
+      BOOST_CHECK_EQUAL(header.template operator()<std::uint64_t>(), buckets);
+      BOOST_CHECK_EQUAL(header.template operator()<float>(), factor.second);
+
+      for (bool hash_compatible : {false, true}) {
+        deserializer dserial(serial.str());
+        auto restored = HSet::deserialize(dserial, hash_compatible);
+        BOOST_CHECK_EQUAL(restored.max_load_factor(), factor.second);
+        BOOST_CHECK(restored == set);
+        for (const auto& key : set) {
+          BOOST_CHECK(restored.find(key) != restored.end());
+        }
+      }
+    }
+  }
+}
+
 /**
  * insert
  */