diff --git a/test/test_map.cpp b/test/test_map.cpp
index dd276084..b596f305 100644
--- a/test/test_map.cpp
+++ b/test/test_map.cpp
@@ -49,8 +49,8 @@ using Data         = etl::map<std::string, int, MAX_SIZE, std::greater<std::stri
 using IData        = etl::imap<std::string, int, std::greater<std::string>>;
 using Compare_Data = std::map<std::string, int, std::greater<std::string>>;
 #else
-using Data = etl::map<std::string, int, MAX_SIZE, std::less<std::string>>;
-using IData = etl::imap<std::string, int, std::less<std::string>>;
+using Data         = etl::map<std::string, int, MAX_SIZE, std::less<std::string>>;
+using IData        = etl::imap<std::string, int, std::less<std::string>>;
 using Compare_Data = std::map<std::string, int, std::less<std::string>>;
 #endif
 
@@ -233,6 +233,8 @@ namespace
       CHECK_EQUAL(10U, data.capacity());
       CHECK_EQUAL(10U, data.max_size());
       CHECK(data == check);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 #endif
 
@@ -257,6 +259,8 @@ namespace
                             data2.end(),
                             compare_data.begin());
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
     }
 
     //*************************************************************************
@@ -281,6 +285,8 @@ namespace
       CHECK(2 == data2.at("2").value);
       CHECK(3 == data2.at("3").value);
       CHECK(4 == data2.at("4").value);
+
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
     }
 
     //*************************************************************************
@@ -304,6 +310,7 @@ namespace
       CHECK(d == MAX_SIZE);
       CHECK(data.size() == MAX_SIZE);
       CHECK(!data.empty());
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
 #if ETL_HAS_INITIALIZER_LIST
@@ -324,6 +331,8 @@ namespace
                                  compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 #endif
 
@@ -340,6 +349,8 @@ namespace
                                  otherData.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(otherData.begin(), otherData.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -358,6 +369,8 @@ namespace
                                 data2.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
     }
 
     //*************************************************************************
@@ -399,6 +412,8 @@ namespace
       CHECK(2 == data2.at("2").value);
       CHECK(3 == data2.at("3").value);
       CHECK(4 == data2.at("4").value);
+
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
     }
 
     //*************************************************************************
@@ -633,6 +648,8 @@ namespace
                             compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -655,6 +672,8 @@ namespace
                                  data.end(),
                                  compare_data.begin());
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -679,6 +698,8 @@ namespace
       CHECK(2 == data.at("2").value);
       CHECK(3 == data.at("3").value);
       CHECK(4 == data.at("4").value);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -704,6 +725,8 @@ namespace
                             compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -723,18 +746,20 @@ namespace
 
       // Check that elements in map are the same
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
 
       data.insert(data_result.first, ETL_OR_STD::make_pair(std::string("1"), 1));
       compare_data.insert(compare_result.first, ETL_OR_STD::make_pair(std::string("1"), 1));
 
       isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                            data.end(),
+                            compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -754,8 +779,8 @@ namespace
 
       // Check that elements in map are the same
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
 
       data.insert(Data::const_iterator(data_result.first),
@@ -764,10 +789,12 @@ namespace
         ETL_OR_STD::make_pair(std::string("1"), 1));
 
       isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                            data.end(),
+                            compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -792,6 +819,8 @@ namespace
                                  compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -804,10 +833,12 @@ namespace
       compare_data.insert(random_data.begin(), random_data.end());
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -887,8 +918,8 @@ namespace
       CHECK(data_result.second->second == compare_result.second->second);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
     }
@@ -932,6 +963,8 @@ namespace
       bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -949,6 +982,8 @@ namespace
       bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -973,6 +1008,8 @@ namespace
                                  compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -993,10 +1030,12 @@ namespace
       CHECK(i_compare1->second == i_data1->second);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -1024,6 +1063,8 @@ namespace
                                  data.end(),
                                  compare_data.begin());
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -1048,9 +1089,11 @@ namespace
       data.erase(i_data, i_data_end);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -1576,7 +1619,7 @@ namespace
 #if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST && !defined(ETL_TEMPLATE_DEDUCTION_GUIDE_TESTS_DISABLED)
     TEST_FIXTURE(SetupFixture, test_map_template_deduction)
     {
-      using Pair = std::pair<const etl::string<1>, int>;
+      using Pair = std::pair<const std::string, int>;
 
       etl::map data { Pair{"0", 0}, Pair{"1", 1}, Pair{"2", 2}, Pair{"3", 3}, Pair{"4", 4}, Pair{"5", 5} };
 
@@ -1590,6 +1633,8 @@ namespace
       CHECK_EQUAL(3, data.at("3"));
       CHECK_EQUAL(4, data.at("4"));
       CHECK_EQUAL(5, data.at("5"));
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 #endif
 
@@ -1597,9 +1642,9 @@ namespace
 #if ETL_HAS_INITIALIZER_LIST
     TEST_FIXTURE(SetupFixture, test_make_map)
     {
-      using Pair = ETL_OR_STD::pair<const etl::string<1>, int>;
+      using Pair = ETL_OR_STD::pair<const std::string, int>;
 
-      auto data = etl::make_map<const etl::string<1>, int, std::less<etl::string<1>>>(Pair{ "0", 0 }, Pair{ "1", 1 }, Pair{ "2", 2 }, Pair{ "3", 3 }, Pair{ "4", 4 }, Pair{ "5", 5 });
+      auto data = etl::make_map<const std::string, int, std::less<std::string>>(Pair{ "0", 0 }, Pair{ "1", 1 }, Pair{ "2", 2 }, Pair{ "3", 3 }, Pair{ "4", 4 }, Pair{ "5", 5 });
 
       auto v = *data.begin();
       using Type = decltype(v);
@@ -1611,6 +1656,8 @@ namespace
       CHECK_EQUAL(3, data.at("3"));
       CHECK_EQUAL(4, data.at("4"));
       CHECK_EQUAL(5, data.at("5"));
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 #endif
 
@@ -1657,8 +1704,14 @@ namespace
 
         const std::vector<element> actual(data.begin(), data.end());
 
-        CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
-        CHECK_TRUE((std::equal(data.begin(), data.end(), expected.begin())));
+        CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
+
+        auto compare = [](const etl::map<int, int, 8>::value_type& lhs, const etl::map<int, int, 8>::value_type& rhs)
+          {
+            return (lhs.first == rhs.first) && (lhs.second == rhs.second);
+          };
+
+        CHECK_TRUE((std::equal(data.begin(), data.end(), expected.begin(), compare)));
 
       } while (std::next_permutation(permutation.begin(), permutation.end()));
     }
diff --git a/test/test_multimap.cpp b/test/test_multimap.cpp
index 844c531d..56642957 100644
--- a/test/test_multimap.cpp
+++ b/test/test_multimap.cpp
@@ -47,20 +47,10 @@ static const size_t MAX_SIZE = 10UL;
 using Data = etl::multimap<std::string, int, MAX_SIZE, std::greater<std::string>>;
 using IData = etl::imultimap<std::string, int, std::greater<std::string>>;
 using Compare_Data = std::multimap<std::string, int, std::greater<std::string>>;
-
-auto key_comparator = [](const auto& lhs, const auto& rhs)
-  {
-    return std::greater<>{}(lhs.first, rhs.first);
-  };
 #else
 using Data = etl::multimap<std::string, int, MAX_SIZE, std::less<std::string>>;
 using IData = etl::imultimap<std::string, int, std::less<std::string>>;
 using Compare_Data = std::multimap<std::string, int, std::less<std::string>>;
-
-auto key_comparator = [](const auto& lhs, const auto& rhs)
-  {
-    return std::less<>{}(lhs.first, rhs.first);
-  };
 #endif
 
 using ItemM = TestDataM<int>;
@@ -244,7 +234,7 @@ namespace
       CHECK_EQUAL(10U, data.capacity());
       CHECK_EQUAL(10U, data.max_size());
       CHECK(data == check);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 #endif
 
@@ -269,7 +259,7 @@ namespace
                             data2.end(),
                             compare_data.begin());
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
     }
 
     //*************************************************************************
@@ -313,7 +303,7 @@ namespace
       result = itr->second.value;
       CHECK_EQUAL(4, result);
 
-      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end()));
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
     }
 
     //*************************************************************************
@@ -354,7 +344,7 @@ namespace
                                  compare_data.begin());
 
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 #endif
 
@@ -389,7 +379,7 @@ namespace
                                 data2.begin());
 
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
     }
 
     //*************************************************************************
@@ -450,7 +440,7 @@ namespace
       result = itr->second.value;
       CHECK_EQUAL(4, result);
 
-      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end()));
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.value_comp()));
     }
 
     //*************************************************************************
@@ -506,7 +496,7 @@ namespace
                                  compare_data.begin());
 
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -573,7 +563,7 @@ namespace
                                  data.end(),
                                  compare_data.begin());
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -593,19 +583,19 @@ namespace
 
       // Check that elements in map are the same
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
 
       data.insert(data_result, ETL_OR_STD::make_pair(std::string("1"), 1));
       compare_data.insert(compare_result, ETL_OR_STD::make_pair(std::string("1"), 1));
 
       isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                            data.end(),
+                            compare_data.begin());
 
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -625,8 +615,8 @@ namespace
 
       // Check that elements in map are the same
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
 
       data.insert(Data::const_iterator(data_result),
@@ -635,11 +625,11 @@ namespace
         ETL_OR_STD::make_pair(std::string("1"), 1));
 
       isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                            data.end(),
+                            compare_data.begin());
 
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -664,7 +654,7 @@ namespace
                                  compare_data.begin());
 
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -677,8 +667,8 @@ namespace
       compare_data.insert(random_data.begin(), random_data.end());
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
     }
@@ -753,8 +743,8 @@ namespace
       CHECK(compare_result.second->second == data_result.second->second);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
     }
@@ -779,8 +769,8 @@ namespace
       CHECK(compare_result.second->second == data_result.second->second);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
     }
@@ -812,11 +802,11 @@ namespace
       CHECK(compare_count == data_count);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -849,11 +839,12 @@ namespace
       CHECK(compare_count == data_count);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -875,7 +866,7 @@ namespace
                                  compare_data.begin());
 
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -896,11 +887,11 @@ namespace
       CHECK(i_compare1->second == i_data1->second);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -928,7 +919,7 @@ namespace
                                  data.end(),
                                  compare_data.begin());
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -941,10 +932,10 @@ namespace
       data.erase(data.cbegin(), data.cend());
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), key_comparator));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -1651,7 +1642,8 @@ namespace
       }
 
       CHECK(pass);
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 
     //*************************************************************************
@@ -1680,7 +1672,7 @@ namespace
       ++itr;
       CHECK_EQUAL(5, itr->second);
 
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 #endif
 
@@ -1710,7 +1702,7 @@ namespace
       ++itr;
       CHECK_EQUAL(5, itr->second);
 
-      CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
     }
 #endif
 
@@ -1749,8 +1741,14 @@ namespace
 
         const std::vector<element> actual(data.begin(), data.end());
 
-        CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
-        CHECK_TRUE((std::equal(data.begin(), data.end(), expected.begin())));
+        CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.value_comp()));
+
+        auto compare = [](const etl::multimap<int, int, 8>::value_type& lhs, const etl::multimap<int, int, 8>::value_type& rhs)
+          {
+            return (lhs.first == rhs.first) && (lhs.second == rhs.second);
+          };
+
+        CHECK_TRUE((std::equal(data.begin(), data.end(), expected.begin(), compare)));
 
       } while (std::next_permutation(permutation.begin(), permutation.end()));
     }
diff --git a/test/test_multiset.cpp b/test/test_multiset.cpp
index 4b309438..d4652f46 100644
--- a/test/test_multiset.cpp
+++ b/test/test_multiset.cpp
@@ -536,16 +536,16 @@ namespace
 
       // Check that elements in multiset are the same
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
 
       data.insert(data_result, 1);
       compare_data.insert(compare_result, 1);
 
       isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                            data.end(),
+                            compare_data.begin());
 
       CHECK(isEqual);
       CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
@@ -615,8 +615,8 @@ namespace
       compare_data.insert(random_data.begin(), random_data.end());
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
       CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
@@ -799,8 +799,8 @@ namespace
       CHECK_EQUAL(*i_compare1, *i_data1);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
       CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
@@ -844,8 +844,8 @@ namespace
       data.erase(data.cbegin(), data.cend());
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
 
       CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
diff --git a/test/test_set.cpp b/test/test_set.cpp
index feaad2a9..719998a8 100644
--- a/test/test_set.cpp
+++ b/test/test_set.cpp
@@ -204,6 +204,7 @@ namespace
       CHECK_EQUAL(10U, data.capacity());
       CHECK_EQUAL(10U, data.max_size());
       CHECK(data == check);
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 #endif
 
@@ -228,6 +229,8 @@ namespace
                             data2.end(),
                             compare_data.begin());
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.key_comp()));
     }
 
     //*************************************************************************
@@ -252,6 +255,8 @@ namespace
       CHECK(data2.find(ItemM(2)) != data2.end());
       CHECK(data2.find(ItemM(3)) != data2.end());
       CHECK(data2.find(ItemM(4)) != data2.end());
+
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.key_comp()));
     }
 
     //*************************************************************************
@@ -275,6 +280,8 @@ namespace
 
       bool isEqual = std::equal(data.begin(), data.end(), compare_data.begin());
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
 #if ETL_HAS_INITIALIZER_LIST
@@ -290,6 +297,8 @@ namespace
 
       bool isEqual = std::equal(data.begin(), data.end(), compare_data.begin());
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 #endif
 
@@ -306,6 +315,8 @@ namespace
                                  otherData.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(otherData.begin(), otherData.end(), otherData.key_comp()));
     }
 
     //*************************************************************************
@@ -324,6 +335,8 @@ namespace
                                  data2.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.key_comp()));
     }
 
     //*************************************************************************
@@ -341,6 +354,8 @@ namespace
                                  otherData.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -363,6 +378,8 @@ namespace
       data2 = std::move(data1);
 
       CHECK(!data1.empty()); // Move does not clear the source.
+
+      CHECK_TRUE(std::is_sorted(data2.begin(), data2.end(), data2.key_comp()));
     }
 
     //*************************************************************************
@@ -418,6 +435,8 @@ namespace
                                  compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -464,6 +483,8 @@ namespace
                             compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -480,18 +501,20 @@ namespace
 
       // Check that elements in set are the same
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
 
       data.insert(data_result.first, 1);
       compare_data.insert(compare_result.first, 1);
 
       isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                            data.end(),
+                            compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -510,18 +533,20 @@ namespace
 
       // Check that elements in set are the same
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
 
       data.insert(data_result.first, 1);
       compare_data.insert(compare_result.first, 1);
 
       isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                            data.end(),
+                            compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -546,6 +571,8 @@ namespace
                                  compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -558,10 +585,12 @@ namespace
       compare_data.insert(random_data.begin(), random_data.end());
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -594,6 +623,8 @@ namespace
       CHECK_EQUAL(2, data.find(ItemM(2))->value);
       CHECK_EQUAL(3, data.find(ItemM(3))->value);
       CHECK_EQUAL(4, data.find(ItemM(4))->value);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -634,46 +665,9 @@ namespace
                                  compare_data.begin());
       CHECK(isEqual);
 
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
-    ////*************************************************************************
-    //TEST_FIXTURE(SetupFixture, test_emplace_value)
-    //{
-    //  Compare_Data compare_data;
-    //  Data data;
-
-    //  ETL_OR_STD::pair<Data::iterator, bool> data_result = data.emplace(0);
-    //  ETL_OR_STD::pair<Compare_Data::iterator, bool> compare_result = compare_data.emplace(0);
-
-    //  // Check that both return successful return results
-    //  CHECK_EQUAL(*data_result.first, *compare_result.first);
-
-    //  // Try adding a duplicate (should return iterator pointing to duplicate)
-    //  data_result = data.insert(0);
-    //  compare_result = compare_data.insert(0);
-
-    //  // Check that both return successful return results
-    //  CHECK_EQUAL(*data_result.first, *compare_result.first);
-
-    //  // Check that elements in set are the same
-    //  bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
-    //  CHECK(isEqual);
-
-    //  data.insert(2);
-    //  compare_data.insert(2);
-
-    //  isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
-
-    //  CHECK(isEqual);
-
-    //  data.insert(1);
-    //  compare_data.insert(1);
-
-    //  isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
-
-    //  CHECK(isEqual);
-    //}
-
     //*************************************************************************
     TEST_FIXTURE(SetupFixture, test_equal_range)
     {
@@ -693,6 +687,8 @@ namespace
       bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -711,10 +707,12 @@ namespace
       CHECK_EQUAL(*data_result.second, *compare_result.second);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -729,6 +727,8 @@ namespace
       bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -746,6 +746,8 @@ namespace
       bool isEqual = Check_Equal(data.begin(), data.end(), compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -770,6 +772,8 @@ namespace
                                  compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -790,10 +794,12 @@ namespace
       CHECK_EQUAL(*i_compare1, *i_data1);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
 
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -821,6 +827,8 @@ namespace
                                  data.end(),
                                  compare_data.begin());
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -845,9 +853,11 @@ namespace
       data.erase(i_data, i_data_end);
 
       bool isEqual = Check_Equal(data.begin(),
-        data.end(),
-        compare_data.begin());
+                                 data.end(),
+                                 compare_data.begin());
       CHECK(isEqual);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 
     //*************************************************************************
@@ -1417,6 +1427,8 @@ namespace
       CHECK_EQUAL("E", *itr);
       ++itr;
       CHECK_EQUAL("F", *itr);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 #endif
 
@@ -1443,6 +1455,8 @@ namespace
       CHECK_EQUAL("E", *itr);
       ++itr;
       CHECK_EQUAL("F", *itr);
+
+      CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
     }
 #endif
 
@@ -1487,7 +1501,7 @@ namespace
         auto it = data.find(2);
         data.erase(it);
 
-        CHECK_TRUE(std::is_sorted(data.begin(), data.end()));
+        CHECK_TRUE(std::is_sorted(data.begin(), data.end(), data.key_comp()));
         CHECK_TRUE((std::equal(data.begin(), data.end(), expected.begin())));
 
       } while (std::next_permutation(permutation.begin(), permutation.end()));