diff --git a/headers/flat_hpp/flat_map.hpp b/headers/flat_hpp/flat_map.hpp
index e972657..6bf2379 100644
--- a/headers/flat_hpp/flat_map.hpp
+++ b/headers/flat_hpp/flat_map.hpp
@@ -319,7 +319,10 @@ namespace flat_hpp
                 : 0;
         }
 
-        void swap(flat_map& other) {
+        void swap(flat_map& other)
+            noexcept(std::is_nothrow_swappable_v<base_type>
+                && std::is_nothrow_swappable_v<container_type>)
+        {
             using std::swap;
             swap(
                 static_cast<base_type&>(*this),
@@ -397,6 +400,7 @@ namespace flat_hpp
     void swap(
         flat_map<Key, Value, Compare, Container>& l,
         flat_map<Key, Value, Compare, Container>& r)
+        noexcept(noexcept(l.swap(r)))
     {
         l.swap(r);
     }
diff --git a/headers/flat_hpp/flat_multimap.hpp b/headers/flat_hpp/flat_multimap.hpp
index adbf5ed..b5131d3 100644
--- a/headers/flat_hpp/flat_multimap.hpp
+++ b/headers/flat_hpp/flat_multimap.hpp
@@ -315,7 +315,10 @@ namespace flat_hpp
             return r;
         }
 
-        void swap(flat_multimap& other) {
+        void swap(flat_multimap& other)
+            noexcept(std::is_nothrow_swappable_v<base_type>
+                && std::is_nothrow_swappable_v<container_type>)
+        {
             using std::swap;
             swap(
                 static_cast<base_type&>(*this),
@@ -393,6 +396,7 @@ namespace flat_hpp
     void swap(
         flat_multimap<Key, Value, Compare, Container>& l,
         flat_multimap<Key, Value, Compare, Container>& r)
+        noexcept(noexcept(l.swap(r)))
     {
         l.swap(r);
     }
diff --git a/headers/flat_hpp/flat_multiset.hpp b/headers/flat_hpp/flat_multiset.hpp
index f944c05..128906f 100644
--- a/headers/flat_hpp/flat_multiset.hpp
+++ b/headers/flat_hpp/flat_multiset.hpp
@@ -230,7 +230,10 @@ namespace flat_hpp
             return r;
         }
 
-        void swap(flat_multiset& other) {
+        void swap(flat_multiset& other)
+            noexcept(std::is_nothrow_swappable_v<base_type>
+                && std::is_nothrow_swappable_v<container_type>)
+        {
             using std::swap;
             swap(
                 static_cast<base_type&>(*this),
@@ -301,6 +304,7 @@ namespace flat_hpp
     void swap(
         flat_multiset<Key, Compare, Container>& l,
         flat_multiset<Key, Compare, Container>& r)
+        noexcept(noexcept(l.swap(r)))
     {
         l.swap(r);
     }
diff --git a/headers/flat_hpp/flat_set.hpp b/headers/flat_hpp/flat_set.hpp
index 77f3999..366e810 100644
--- a/headers/flat_hpp/flat_set.hpp
+++ b/headers/flat_hpp/flat_set.hpp
@@ -234,7 +234,10 @@ namespace flat_hpp
                 : 0;
         }
 
-        void swap(flat_set& other) {
+        void swap(flat_set& other)
+            noexcept(std::is_nothrow_swappable_v<base_type>
+                && std::is_nothrow_swappable_v<container_type>)
+        {
             using std::swap;
             swap(
                 static_cast<base_type&>(*this),
@@ -305,6 +308,7 @@ namespace flat_hpp
     void swap(
         flat_set<Key, Compare, Container>& l,
         flat_set<Key, Compare, Container>& r)
+        noexcept(noexcept(l.swap(r)))
     {
         l.swap(r);
     }
diff --git a/untests/flat_map_tests.cpp b/untests/flat_map_tests.cpp
index ccad8af..6d7a79e 100644
--- a/untests/flat_map_tests.cpp
+++ b/untests/flat_map_tests.cpp
@@ -38,6 +38,15 @@ namespace
     void swap(dummy_less2<T>&, dummy_less2<T>&) noexcept {
     }
 
+    template < typename T >
+    class dummy_less3 {
+        dummy_less3() = default;
+        dummy_less3(dummy_less3&&) noexcept(false) {}
+        bool operator()(const T& l, const T& r) const {
+            return l < r;
+        }
+    };
+
     template < typename T >
     constexpr std::add_const_t<T>& my_as_const(T& t) noexcept {
         return t;
@@ -57,50 +66,30 @@ TEST_CASE("flat_map") {
         using alloc_t = std::allocator<std::pair<int,unsigned>>;
         using map_t = flat_map<int, unsigned, dummy_less<int>, std::vector<std::pair<int,unsigned>, alloc_t>>;
         using map2_t = flat_map<int, unsigned, dummy_less2<int>>;
+        using map3_t = flat_map<int, unsigned, dummy_less3<int>>;
 
-        static_assert(
-            std::is_nothrow_default_constructible_v<map_t>,
-            "unit test static error");
-        static_assert(
-            std::is_nothrow_move_constructible_v<map_t>,
-            "unit test static error");
-        static_assert(
-            std::is_nothrow_move_assignable_v<map_t>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_nothrow_default_constructible_v<map_t>);
+        STATIC_REQUIRE(std::is_nothrow_move_constructible_v<map_t>);
+        STATIC_REQUIRE(std::is_nothrow_move_assignable_v<map_t>);
+        STATIC_REQUIRE(std::is_nothrow_swappable_v<map_t>);
+        STATIC_REQUIRE(std::is_nothrow_swappable_v<map2_t>);
+        STATIC_REQUIRE(!std::is_nothrow_swappable_v<map3_t>);
     }
     SECTION("types") {
         using map_t = flat_map<int, unsigned>;
 
-        static_assert(
-            std::is_same_v<map_t::key_type, int>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<map_t::mapped_type, unsigned>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<map_t::value_type, std::pair<int, unsigned>>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<map_t::key_type, int>);
+        STATIC_REQUIRE(std::is_same_v<map_t::mapped_type, unsigned>);
+        STATIC_REQUIRE(std::is_same_v<map_t::value_type, std::pair<int, unsigned>>);
 
-        static_assert(
-            std::is_same_v<map_t::size_type, std::size_t>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<map_t::difference_type, std::ptrdiff_t>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<map_t::size_type, std::size_t>);
+        STATIC_REQUIRE(std::is_same_v<map_t::difference_type, std::ptrdiff_t>);
 
-        static_assert(
-            std::is_same_v<map_t::reference, std::pair<int, unsigned>&>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<map_t::const_reference, const std::pair<int, unsigned>&>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<map_t::reference, std::pair<int, unsigned>&>);
+        STATIC_REQUIRE(std::is_same_v<map_t::const_reference, const std::pair<int, unsigned>&>);
 
-        static_assert(
-            std::is_same_v<map_t::pointer, std::pair<int, unsigned>*>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<map_t::const_pointer, const std::pair<int, unsigned>*>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<map_t::pointer, std::pair<int, unsigned>*>);
+        STATIC_REQUIRE(std::is_same_v<map_t::const_pointer, const std::pair<int, unsigned>*>);
     }
     SECTION("ctors") {
         using alloc_t = std::allocator<
diff --git a/untests/flat_multimap_tests.cpp b/untests/flat_multimap_tests.cpp
index 590c59d..bc550f1 100644
--- a/untests/flat_multimap_tests.cpp
+++ b/untests/flat_multimap_tests.cpp
@@ -38,6 +38,15 @@ namespace
     void swap(dummy_less2<T>&, dummy_less2<T>&) noexcept {
     }
 
+    template < typename T >
+    class dummy_less3 {
+        dummy_less3() = default;
+        dummy_less3(dummy_less3&&) noexcept(false) {}
+        bool operator()(const T& l, const T& r) const {
+            return l < r;
+        }
+    };
+
     template < typename T >
     constexpr std::add_const_t<T>& my_as_const(T& t) noexcept {
         return t;
@@ -57,50 +66,30 @@ TEST_CASE("flat_multimap") {
         using alloc_t = std::allocator<std::pair<int,unsigned>>;
         using map_t = flat_multimap<int, unsigned, dummy_less<int>, std::vector<std::pair<int,unsigned>, alloc_t>>;
         using map2_t = flat_multimap<int, unsigned, dummy_less2<int>>;
+        using map3_t = flat_multimap<int, unsigned, dummy_less3<int>>;
 
-        static_assert(
-            std::is_nothrow_default_constructible_v<map_t>,
-            "unit test static error");
-        static_assert(
-            std::is_nothrow_move_constructible_v<map_t>,
-            "unit test static error");
-        static_assert(
-            std::is_nothrow_move_assignable_v<map_t>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_nothrow_default_constructible_v<map_t>);
+        STATIC_REQUIRE(std::is_nothrow_move_constructible_v<map_t>);
+        STATIC_REQUIRE(std::is_nothrow_move_assignable_v<map_t>);
+        STATIC_REQUIRE(std::is_nothrow_swappable_v<map_t>);
+        STATIC_REQUIRE(std::is_nothrow_swappable_v<map2_t>);
+        STATIC_REQUIRE(!std::is_nothrow_swappable_v<map3_t>);
     }
     SECTION("types") {
         using map_t = flat_multimap<int, unsigned>;
 
-        static_assert(
-            std::is_same_v<map_t::key_type, int>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<map_t::mapped_type, unsigned>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<map_t::value_type, std::pair<int, unsigned>>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<map_t::key_type, int>);
+        STATIC_REQUIRE(std::is_same_v<map_t::mapped_type, unsigned>);
+        STATIC_REQUIRE(std::is_same_v<map_t::value_type, std::pair<int, unsigned>>);
 
-        static_assert(
-            std::is_same_v<map_t::size_type, std::size_t>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<map_t::difference_type, std::ptrdiff_t>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<map_t::size_type, std::size_t>);
+        STATIC_REQUIRE(std::is_same_v<map_t::difference_type, std::ptrdiff_t>);
 
-        static_assert(
-            std::is_same_v<map_t::reference, std::pair<int, unsigned>&>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<map_t::const_reference, const std::pair<int, unsigned>&>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<map_t::reference, std::pair<int, unsigned>&>);
+        STATIC_REQUIRE(std::is_same_v<map_t::const_reference, const std::pair<int, unsigned>&>);
 
-        static_assert(
-            std::is_same_v<map_t::pointer, std::pair<int, unsigned>*>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<map_t::const_pointer, const std::pair<int, unsigned>*>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<map_t::pointer, std::pair<int, unsigned>*>);
+        STATIC_REQUIRE(std::is_same_v<map_t::const_pointer, const std::pair<int, unsigned>*>);
     }
     SECTION("ctors") {
         using alloc_t = std::allocator<
diff --git a/untests/flat_multiset_tests.cpp b/untests/flat_multiset_tests.cpp
index 4d9fa0b..014cb1a 100644
--- a/untests/flat_multiset_tests.cpp
+++ b/untests/flat_multiset_tests.cpp
@@ -38,6 +38,15 @@ namespace
     void swap(dummy_less2<T>&, dummy_less2<T>&) noexcept {
     }
 
+    template < typename T >
+    class dummy_less3 {
+        dummy_less3() = default;
+        dummy_less3(dummy_less3&&) noexcept(false) {}
+        bool operator()(const T& l, const T& r) const {
+            return l < r;
+        }
+    };
+
     template < typename T >
     constexpr std::add_const_t<T>& my_as_const(T& t) noexcept {
         return t;
@@ -57,47 +66,29 @@ TEST_CASE("flat_multiset") {
         using alloc_t = std::allocator<int>;
         using set_t = flat_multiset<int, dummy_less<int>, std::vector<int, alloc_t>>;
         using set2_t = flat_multiset<int, dummy_less2<int>>;
+        using set3_t = flat_multiset<int, dummy_less3<int>>;
 
-        static_assert(
-            std::is_nothrow_default_constructible_v<set_t>,
-            "unit test static error");
-        static_assert(
-            std::is_nothrow_move_constructible_v<set_t>,
-            "unit test static error");
-        static_assert(
-            std::is_nothrow_move_assignable_v<set_t>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_nothrow_default_constructible_v<set_t>);
+        STATIC_REQUIRE(std::is_nothrow_move_constructible_v<set_t>);
+        STATIC_REQUIRE(std::is_nothrow_move_assignable_v<set_t>);
+        STATIC_REQUIRE(std::is_nothrow_swappable_v<set_t>);
+        STATIC_REQUIRE(std::is_nothrow_swappable_v<set2_t>);
+        STATIC_REQUIRE(!std::is_nothrow_swappable_v<set3_t>);
     }
     SECTION("types") {
         using set_t = flat_multiset<int>;
 
-        static_assert(
-            std::is_same_v<set_t::key_type, int>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<set_t::value_type, int>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<set_t::key_type, int>);
+        STATIC_REQUIRE(std::is_same_v<set_t::value_type, int>);
 
-        static_assert(
-            std::is_same_v<set_t::size_type, std::size_t>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<set_t::difference_type, std::ptrdiff_t>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<set_t::size_type, std::size_t>);
+        STATIC_REQUIRE(std::is_same_v<set_t::difference_type, std::ptrdiff_t>);
 
-        static_assert(
-            std::is_same_v<set_t::reference, int&>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<set_t::const_reference, const int&>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<set_t::reference, int&>);
+        STATIC_REQUIRE(std::is_same_v<set_t::const_reference, const int&>);
 
-        static_assert(
-            std::is_same_v<set_t::pointer, int*>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<set_t::const_pointer, const int*>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<set_t::pointer, int*>);
+        STATIC_REQUIRE(std::is_same_v<set_t::const_pointer, const int*>);
     }
     SECTION("ctors") {
         using alloc_t = std::allocator<int>;
diff --git a/untests/flat_set_tests.cpp b/untests/flat_set_tests.cpp
index 5419ef1..40a04c4 100644
--- a/untests/flat_set_tests.cpp
+++ b/untests/flat_set_tests.cpp
@@ -38,6 +38,15 @@ namespace
     void swap(dummy_less2<T>&, dummy_less2<T>&) noexcept {
     }
 
+    template < typename T >
+    class dummy_less3 {
+        dummy_less3() = default;
+        dummy_less3(dummy_less3&&) noexcept(false) {}
+        bool operator()(const T& l, const T& r) const {
+            return l < r;
+        }
+    };
+
     template < typename T >
     constexpr std::add_const_t<T>& my_as_const(T& t) noexcept {
         return t;
@@ -57,47 +66,29 @@ TEST_CASE("flat_set") {
         using alloc_t = std::allocator<int>;
         using set_t = flat_set<int, dummy_less<int>, std::vector<int, alloc_t>>;
         using set2_t = flat_set<int, dummy_less2<int>>;
+        using set3_t = flat_set<int, dummy_less3<int>>;
 
-        static_assert(
-            std::is_nothrow_default_constructible_v<set_t>,
-            "unit test static error");
-        static_assert(
-            std::is_nothrow_move_constructible_v<set_t>,
-            "unit test static error");
-        static_assert(
-            std::is_nothrow_move_assignable_v<set_t>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_nothrow_default_constructible_v<set_t>);
+        STATIC_REQUIRE(std::is_nothrow_move_constructible_v<set_t>);
+        STATIC_REQUIRE(std::is_nothrow_move_assignable_v<set_t>);
+        STATIC_REQUIRE(std::is_nothrow_swappable_v<set_t>);
+        STATIC_REQUIRE(std::is_nothrow_swappable_v<set2_t>);
+        STATIC_REQUIRE(!std::is_nothrow_swappable_v<set3_t>);
     }
     SECTION("types") {
         using set_t = flat_set<int>;
 
-        static_assert(
-            std::is_same_v<set_t::key_type, int>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<set_t::value_type, int>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<set_t::key_type, int>);
+        STATIC_REQUIRE(std::is_same_v<set_t::value_type, int>);
 
-        static_assert(
-            std::is_same_v<set_t::size_type, std::size_t>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<set_t::difference_type, std::ptrdiff_t>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<set_t::size_type, std::size_t>);
+        STATIC_REQUIRE(std::is_same_v<set_t::difference_type, std::ptrdiff_t>);
 
-        static_assert(
-            std::is_same_v<set_t::reference, int&>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<set_t::const_reference, const int&>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<set_t::reference, int&>);
+        STATIC_REQUIRE(std::is_same_v<set_t::const_reference, const int&>);
 
-        static_assert(
-            std::is_same_v<set_t::pointer, int*>,
-            "unit test static error");
-        static_assert(
-            std::is_same_v<set_t::const_pointer, const int*>,
-            "unit test static error");
+        STATIC_REQUIRE(std::is_same_v<set_t::pointer, int*>);
+        STATIC_REQUIRE(std::is_same_v<set_t::const_pointer, const int*>);
     }
     SECTION("ctors") {
         using alloc_t = std::allocator<int>;