noexcept for <unordered_set>.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@132647 91177308-0d34-0410-b5e6-96231b3b80d8

include/unordered_set

@@ -43,7 +43,12 @@ public:
     typedef /unspecified/ local_iterator;
     typedef /unspecified/ const_local_iterator;
 
-    explicit unordered_set(size_type n = 0, const hasher& hf = hasher(),
+    unordered_set()
+        noexcept(
+            is_nothrow_default_constructible<hasher>::value &&
+            is_nothrow_default_constructible<key_equal>::value &&
+            is_nothrow_default_constructible<allocator_type>::value);
+    explicit unordered_set(size_type n, const hasher& hf = hasher(),
                            const key_equal& eql = key_equal(),
                            const allocator_type& a = allocator_type());
     template <class InputIterator>
@@ -54,28 +59,37 @@ public:
     explicit unordered_set(const allocator_type&);
     unordered_set(const unordered_set&);
     unordered_set(const unordered_set&, const Allocator&);
-    unordered_set(unordered_set&&);
+    unordered_set(unordered_set&&)
+        noexcept(
+            is_nothrow_move_constructible<hasher>::value &&
+            is_nothrow_move_constructible<key_equal>::value &&
+            is_nothrow_move_constructible<allocator_type>::value);
     unordered_set(unordered_set&&, const Allocator&);
     unordered_set(initializer_list<value_type>, size_type n = 0,
                   const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                   const allocator_type& a = allocator_type());
     ~unordered_set();
     unordered_set& operator=(const unordered_set&);
-    unordered_set& operator=(unordered_set&&);
+    unordered_set& operator=(unordered_set&&)
+        noexcept(
+            allocator_type::propagate_on_container_move_assignment::value &&
+            is_nothrow_move_assignable<allocator_type>::value &&
+            is_nothrow_move_assignable<hasher>::value &&
+            is_nothrow_move_assignable<key_equal>::value);
     unordered_set& operator=(initializer_list<value_type>);
 
-    allocator_type get_allocator() const;
+    allocator_type get_allocator() const noexcept;
 
-    bool      empty() const;
-    size_type size() const;
-    size_type max_size() const;
+    bool      empty() const noexcept;
+    size_type size() const noexcept;
+    size_type max_size() const noexcept;
 
-    iterator       begin();
-    iterator       end();
-    const_iterator begin()  const;
-    const_iterator end()    const;
-    const_iterator cbegin() const;
-    const_iterator cend()   const;
+    iterator       begin() noexcept;
+    iterator       end() noexcept;
+    const_iterator begin()  const noexcept;
+    const_iterator end()    const noexcept;
+    const_iterator cbegin() const noexcept;
+    const_iterator cend()   const noexcept;
 
     template <class... Args>
         pair<iterator, bool> emplace(Args&&... args);
@@ -92,9 +106,14 @@ public:
     iterator erase(const_iterator position);
     size_type erase(const key_type& k);
     iterator erase(const_iterator first, const_iterator last);
-    void clear();
+    void clear() noexcept;
 
-    void swap(unordered_set&);
+    void swap(unordered_set&)
+        noexcept(
+            (!allocator_type::propagate_on_container_swap::value ||
+             __is_nothrow_swappable<allocator_type>::value) &&
+            __is_nothrow_swappable<hasher>::value &&
+            __is_nothrow_swappable<key_equal>::value);
 
     hasher hash_function() const;
     key_equal key_eq() const;
@@ -105,8 +124,8 @@ public:
     pair<iterator, iterator>             equal_range(const key_type& k);
     pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 
-    size_type bucket_count() const;
-    size_type max_bucket_count() const;
+    size_type bucket_count() const noexcept;
+    size_type max_bucket_count() const noexcept;
 
     size_type bucket_size(size_type n) const;
     size_type bucket(const key_type& k) const;
@@ -118,8 +137,8 @@ public:
     const_local_iterator cbegin(size_type n) const;
     const_local_iterator cend(size_type n) const;
 
-    float load_factor() const;
-    float max_load_factor() const;
+    float load_factor() const noexcept;
+    float max_load_factor() const noexcept;
     void max_load_factor(float z);
     void rehash(size_type n);
     void reserve(size_type n);
@@ -127,7 +146,8 @@ public:
 
 template <class Value, class Hash, class Pred, class Alloc>
     void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
-              unordered_set<Value, Hash, Pred, Alloc>& y);
+              unordered_set<Value, Hash, Pred, Alloc>& y)
+              noexcept(noexcept(x.swap(y)));
 
 template <class Value, class Hash, class Pred, class Alloc>
     bool
@@ -162,7 +182,12 @@ public:
     typedef /unspecified/ local_iterator;
     typedef /unspecified/ const_local_iterator;
 
-    explicit unordered_multiset(size_type n = 0, const hasher& hf = hasher(),
+    unordered_multiset()
+        noexcept(
+            is_nothrow_default_constructible<hasher>::value &&
+            is_nothrow_default_constructible<key_equal>::value &&
+            is_nothrow_default_constructible<allocator_type>::value);
+    explicit unordered_multiset(size_type n, const hasher& hf = hasher(),
                            const key_equal& eql = key_equal(),
                            const allocator_type& a = allocator_type());
     template <class InputIterator>
@@ -173,28 +198,37 @@ public:
     explicit unordered_multiset(const allocator_type&);
     unordered_multiset(const unordered_multiset&);
     unordered_multiset(const unordered_multiset&, const Allocator&);
-    unordered_multiset(unordered_multiset&&);
+    unordered_multiset(unordered_multiset&&)
+        noexcept(
+            is_nothrow_move_constructible<hasher>::value &&
+            is_nothrow_move_constructible<key_equal>::value &&
+            is_nothrow_move_constructible<allocator_type>::value);
     unordered_multiset(unordered_multiset&&, const Allocator&);
     unordered_multiset(initializer_list<value_type>, size_type n = /see below/,
                   const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                   const allocator_type& a = allocator_type());
     ~unordered_multiset();
     unordered_multiset& operator=(const unordered_multiset&);
-    unordered_multiset& operator=(unordered_multiset&&);
+    unordered_multiset& operator=(unordered_multiset&&)
+        noexcept(
+            allocator_type::propagate_on_container_move_assignment::value &&
+            is_nothrow_move_assignable<allocator_type>::value &&
+            is_nothrow_move_assignable<hasher>::value &&
+            is_nothrow_move_assignable<key_equal>::value);
     unordered_multiset& operator=(initializer_list<value_type>);
 
-    allocator_type get_allocator() const;
+    allocator_type get_allocator() const noexcept;
 
-    bool      empty() const;
-    size_type size() const;
-    size_type max_size() const;
+    bool      empty() const noexcept;
+    size_type size() const noexcept;
+    size_type max_size() const noexcept;
 
-    iterator       begin();
-    iterator       end();
-    const_iterator begin()  const;
-    const_iterator end()    const;
-    const_iterator cbegin() const;
-    const_iterator cend()   const;
+    iterator       begin() noexcept;
+    iterator       end() noexcept;
+    const_iterator begin()  const noexcept;
+    const_iterator end()    const noexcept;
+    const_iterator cbegin() const noexcept;
+    const_iterator cend()   const noexcept;
 
     template <class... Args>
         iterator emplace(Args&&... args);
@@ -211,9 +245,14 @@ public:
     iterator erase(const_iterator position);
     size_type erase(const key_type& k);
     iterator erase(const_iterator first, const_iterator last);
-    void clear();
+    void clear() noexcept;
 
-    void swap(unordered_multiset&);
+    void swap(unordered_multiset&)
+        noexcept(
+            (!allocator_type::propagate_on_container_swap::value ||
+             __is_nothrow_swappable<allocator_type>::value) &&
+            __is_nothrow_swappable<hasher>::value &&
+            __is_nothrow_swappable<key_equal>::value);
 
     hasher hash_function() const;
     key_equal key_eq() const;
@@ -224,8 +263,8 @@ public:
     pair<iterator, iterator>             equal_range(const key_type& k);
     pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 
-    size_type bucket_count() const;
-    size_type max_bucket_count() const;
+    size_type bucket_count() const noexcept;
+    size_type max_bucket_count() const noexcept;
 
     size_type bucket_size(size_type n) const;
     size_type bucket(const key_type& k) const;
@@ -237,8 +276,8 @@ public:
     const_local_iterator cbegin(size_type n) const;
     const_local_iterator cend(size_type n) const;
 
-    float load_factor() const;
-    float max_load_factor() const;
+    float load_factor() const noexcept;
+    float max_load_factor() const noexcept;
     void max_load_factor(float z);
     void rehash(size_type n);
     void reserve(size_type n);
@@ -246,7 +285,8 @@ public:
 
 template <class Value, class Hash, class Pred, class Alloc>
     void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
-              unordered_multiset<Value, Hash, Pred, Alloc>& y);
+              unordered_multiset<Value, Hash, Pred, Alloc>& y)
+              noexcept(noexcept(x.swap(y)));
 
 template <class Value, class Hash, class Pred, class Alloc>
     bool
@@ -300,7 +340,9 @@ public:
     typedef typename __table::const_local_iterator const_local_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
-    unordered_set() {} // = default;
+    unordered_set()
+        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
+        {} // = default;
     explicit unordered_set(size_type __n, const hasher& __hf = hasher(),
                            const key_equal& __eql = key_equal());
     unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql,
@@ -319,7 +361,8 @@ public:
     unordered_set(const unordered_set& __u);
     unordered_set(const unordered_set& __u, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_set(unordered_set&& __u);
+    unordered_set(unordered_set&& __u)
+        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
     unordered_set(unordered_set&& __u, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     unordered_set(initializer_list<value_type> __il);
@@ -332,33 +375,34 @@ public:
     // ~unordered_set() = default;
     // unordered_set& operator=(const unordered_set& __u) = default;
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_set& operator=(unordered_set&& __u);
+    unordered_set& operator=(unordered_set&& __u)
+        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
 #endif
     unordered_set& operator=(initializer_list<value_type> __il);
 
     _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const
+    allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(__table_.__node_alloc());}
 
     _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const {return __table_.size() == 0;}
+    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
-    size_type size() const  {return __table_.size();}
+    size_type size() const _NOEXCEPT  {return __table_.size();}
     _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const {return __table_.max_size();}
+    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
 
     _LIBCPP_INLINE_VISIBILITY
-    iterator       begin()        {return __table_.begin();}
+    iterator       begin() _NOEXCEPT        {return __table_.begin();}
     _LIBCPP_INLINE_VISIBILITY
-    iterator       end()          {return __table_.end();}
+    iterator       end() _NOEXCEPT          {return __table_.end();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const {return __table_.begin();}
+    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const {return __table_.end();}
+    const_iterator end()    const _NOEXCEPT {return __table_.end();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const {return __table_.begin();}
+    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const {return __table_.end();}
+    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
 
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class... _Args>
@@ -400,10 +444,12 @@ public:
     iterator erase(const_iterator __first, const_iterator __last)
         {return __table_.erase(__first, __last);}
     _LIBCPP_INLINE_VISIBILITY
-    void clear() {__table_.clear();}
+    void clear() _NOEXCEPT {__table_.clear();}
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_set& __u) {__table_.swap(__u.__table_);}
+    void swap(unordered_set& __u)
+        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
+        {__table_.swap(__u.__table_);}
 
     _LIBCPP_INLINE_VISIBILITY
     hasher hash_function() const {return __table_.hash_function();}
@@ -424,9 +470,9 @@ public:
         {return __table_.__equal_range_unique(__k);}
 
     _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const {return __table_.bucket_count();}
+    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
     _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const {return __table_.max_bucket_count();}
+    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
 
     _LIBCPP_INLINE_VISIBILITY
     size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
@@ -447,9 +493,9 @@ public:
     const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}
 
     _LIBCPP_INLINE_VISIBILITY
-    float load_factor() const {return __table_.load_factor();}
+    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
     _LIBCPP_INLINE_VISIBILITY
-    float max_load_factor() const {return __table_.max_load_factor();}
+    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
     _LIBCPP_INLINE_VISIBILITY
     void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
     _LIBCPP_INLINE_VISIBILITY
@@ -536,6 +582,7 @@ template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
         unordered_set&& __u)
+    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
     : __table_(_STD::move(__u.__table_))
 {
 }
@@ -588,6 +635,7 @@ template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 unordered_set<_Value, _Hash, _Pred, _Alloc>&
 unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
+    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
 {
     __table_ = _STD::move(__u.__table_);
     return *this;
@@ -621,6 +669,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
      unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
@@ -684,7 +733,9 @@ public:
     typedef typename __table::const_local_iterator const_local_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset() {} // = default
+    unordered_multiset()
+        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
+        {} // = default
     explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(),
                                 const key_equal& __eql = key_equal());
     unordered_multiset(size_type __n, const hasher& __hf,
@@ -703,7 +754,8 @@ public:
     unordered_multiset(const unordered_multiset& __u);
     unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_multiset(unordered_multiset&& __u);
+    unordered_multiset(unordered_multiset&& __u)
+        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
     unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     unordered_multiset(initializer_list<value_type> __il);
@@ -716,33 +768,34 @@ public:
     // ~unordered_multiset() = default;
     // unordered_multiset& operator=(const unordered_multiset& __u) = default;
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_multiset& operator=(unordered_multiset&& __u);
+    unordered_multiset& operator=(unordered_multiset&& __u)
+        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
 #endif
     unordered_multiset& operator=(initializer_list<value_type> __il);
 
     _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const
+    allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(__table_.__node_alloc());}
 
     _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const {return __table_.size() == 0;}
+    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
-    size_type size() const  {return __table_.size();}
+    size_type size() const _NOEXCEPT  {return __table_.size();}
     _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const {return __table_.max_size();}
+    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
 
     _LIBCPP_INLINE_VISIBILITY
-    iterator       begin()        {return __table_.begin();}
+    iterator       begin() _NOEXCEPT        {return __table_.begin();}
     _LIBCPP_INLINE_VISIBILITY
-    iterator       end()          {return __table_.end();}
+    iterator       end() _NOEXCEPT          {return __table_.end();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const {return __table_.begin();}
+    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const {return __table_.end();}
+    const_iterator end()    const _NOEXCEPT {return __table_.end();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const {return __table_.begin();}
+    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
     _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const {return __table_.end();}
+    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
 
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class... _Args>
@@ -782,10 +835,12 @@ public:
     iterator erase(const_iterator __first, const_iterator __last)
         {return __table_.erase(__first, __last);}
     _LIBCPP_INLINE_VISIBILITY
-    void clear() {__table_.clear();}
+    void clear() _NOEXCEPT {__table_.clear();}
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_multiset& __u) {__table_.swap(__u.__table_);}
+    void swap(unordered_multiset& __u)
+        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
+        {__table_.swap(__u.__table_);}
 
     _LIBCPP_INLINE_VISIBILITY
     hasher hash_function() const {return __table_.hash_function();}
@@ -806,9 +861,9 @@ public:
         {return __table_.__equal_range_multi(__k);}
 
     _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const {return __table_.bucket_count();}
+    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
     _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const {return __table_.max_bucket_count();}
+    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
 
     _LIBCPP_INLINE_VISIBILITY
     size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
@@ -829,9 +884,9 @@ public:
     const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}
 
     _LIBCPP_INLINE_VISIBILITY
-    float load_factor() const {return __table_.load_factor();}
+    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
     _LIBCPP_INLINE_VISIBILITY
-    float max_load_factor() const {return __table_.max_load_factor();}
+    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
     _LIBCPP_INLINE_VISIBILITY
     void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
     _LIBCPP_INLINE_VISIBILITY
@@ -919,6 +974,7 @@ template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
         unordered_multiset&& __u)
+    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
     : __table_(_STD::move(__u.__table_))
 {
 }
@@ -972,6 +1028,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
         unordered_multiset&& __u)
+    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
 {
     __table_ = _STD::move(__u.__table_);
     return *this;
@@ -1005,6 +1062,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
      unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }

test/containers/unord/unord.multiset/unord.multiset.cnstr/default_noexcept.pass.cpp

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// unordered_multiset()
+//    noexcept(
+//        is_nothrow_default_constructible<allocator_type>::value &&
+//        is_nothrow_default_constructible<key_compare>::value &&
+//        is_nothrow_copy_constructible<key_compare>::value);
+
+// This tests a conforming extension
+
+#include <unordered_set>
+#include <cassert>
+
+#include "../../../MoveOnly.h"
+#include "../../../test_allocator.h"
+#include "../../../test_hash.h"
+
+template <class T>
+struct some_comp
+{
+    typedef T value_type;
+    some_comp();
+    some_comp(const some_comp&);
+};
+
+template <class T>
+struct some_hash
+{
+    typedef T value_type;
+    some_hash();
+    some_hash(const some_hash&);
+};
+
+int main()
+{
+#if __has_feature(cxx_noexcept)
+    {
+        typedef std::unordered_multiset<MoveOnly> C;
+        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                           std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                          std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
+        static_assert(!std::is_nothrow_default_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C;
+        static_assert(!std::is_nothrow_default_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                                                         some_comp<MoveOnly>> C;
+        static_assert(!std::is_nothrow_default_constructible<C>::value, "");
+    }
+#endif
+}

test/containers/unord/unord.multiset/unord.multiset.cnstr/dtor_noexcept.pass.cpp

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// ~unordered_multiset() // implied noexcept;
+
+#include <unordered_set>
+#include <cassert>
+
+#include "../../../MoveOnly.h"
+#include "../../../test_allocator.h"
+
+#if __has_feature(cxx_noexcept)
+
+template <class T>
+struct some_comp
+{
+    typedef T value_type;
+    ~some_comp() noexcept(false);
+};
+
+template <class T>
+struct some_hash
+{
+    typedef T value_type;
+    some_hash();
+    some_hash(const some_hash&);
+    ~some_hash() noexcept(false);
+};
+
+#endif
+
+int main()
+{
+#if __has_feature(cxx_noexcept)
+    {
+        typedef std::unordered_multiset<MoveOnly> C;
+        static_assert(std::is_nothrow_destructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                           std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_destructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                          std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_destructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C;
+        static_assert(!std::is_nothrow_destructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                                                         some_comp<MoveOnly>> C;
+        static_assert(!std::is_nothrow_destructible<C>::value, "");
+    }
+#endif
+}

test/containers/unord/unord.multiset/unord.multiset.cnstr/move_assign_noexcept.pass.cpp

@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// unordered_multiset& operator=(unordered_multiset&& c)
+//     noexcept(
+//          allocator_type::propagate_on_container_move_assignment::value &&
+//          is_nothrow_move_assignable<allocator_type>::value &&
+//          is_nothrow_move_assignable<key_compare>::value);
+
+// This tests a conforming extension
+
+#include <unordered_set>
+#include <cassert>
+
+#include "../../../MoveOnly.h"
+#include "../../../test_allocator.h"
+
+template <class T>
+struct some_comp
+{
+    typedef T value_type;
+    some_comp& operator=(const some_comp&);
+};
+
+template <class T>
+struct some_hash
+{
+    typedef T value_type;
+    some_hash();
+    some_hash(const some_hash&);
+    some_hash& operator=(const some_hash&);
+};
+
+int main()
+{
+#if __has_feature(cxx_noexcept)
+    {
+        typedef std::unordered_multiset<MoveOnly> C;
+        static_assert(std::is_nothrow_move_assignable<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                           std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
+        static_assert(!std::is_nothrow_move_assignable<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                          std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_move_assignable<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C;
+        static_assert(!std::is_nothrow_move_assignable<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                                                         some_comp<MoveOnly>> C;
+        static_assert(!std::is_nothrow_move_assignable<C>::value, "");
+    }
+#endif
+}

test/containers/unord/unord.multiset/unord.multiset.cnstr/move_noexcept.pass.cpp

@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// unordered_multiset(unordered_multiset&&)
+//        noexcept(is_nothrow_move_constructible<allocator_type>::value &&
+//                 is_nothrow_move_constructible<key_compare>::value);
+
+// This tests a conforming extension
+
+#include <unordered_set>
+#include <cassert>
+
+#include "../../../MoveOnly.h"
+#include "../../../test_allocator.h"
+
+template <class T>
+struct some_comp
+{
+    typedef T value_type;
+    some_comp(const some_comp&);
+};
+
+template <class T>
+struct some_hash
+{
+    typedef T value_type;
+    some_hash();
+    some_hash(const some_hash&);
+};
+
+int main()
+{
+#if __has_feature(cxx_noexcept)
+    {
+        typedef std::unordered_multiset<MoveOnly> C;
+        static_assert(std::is_nothrow_move_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                           std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_move_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                          std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_move_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C;
+        static_assert(!std::is_nothrow_move_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                                                         some_comp<MoveOnly>> C;
+        static_assert(!std::is_nothrow_move_constructible<C>::value, "");
+    }
+#endif
+}

test/containers/unord/unord.multiset/unord.multiset.swap/swap_noexcept.pass.cpp

@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// void swap(unordered_multiset& c)
+//     noexcept(!allocator_type::propagate_on_container_swap::value ||
+//              __is_nothrow_swappable<allocator_type>::value);
+
+// This tests a conforming extension
+
+#include <unordered_set>
+#include <cassert>
+
+#include "../../../MoveOnly.h"
+#include "../../../test_allocator.h"
+
+template <class T>
+struct some_comp
+{
+    typedef T value_type;
+    
+    some_comp() {}
+    some_comp(const some_comp&) {}
+};
+
+template <class T>
+struct some_hash
+{
+    typedef T value_type;
+    some_hash() {}
+    some_hash(const some_hash&);
+};
+
+int main()
+{
+#if __has_feature(cxx_noexcept)
+    {
+        typedef std::unordered_multiset<MoveOnly> C;
+        C c1, c2;
+        static_assert(noexcept(swap(c1, c2)), "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                           std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
+        C c1, c2;
+        static_assert(noexcept(swap(c1, c2)), "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                          std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
+        C c1, c2;
+        static_assert(noexcept(swap(c1, c2)), "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, some_hash<MoveOnly>> C;
+        C c1, c2;
+        static_assert(!noexcept(swap(c1, c2)), "");
+    }
+    {
+        typedef std::unordered_multiset<MoveOnly, std::hash<MoveOnly>,
+                                                         some_comp<MoveOnly>> C;
+        C c1, c2;
+        static_assert(!noexcept(swap(c1, c2)), "");
+    }
+#endif
+}

test/containers/unord/unord.set/unord.set.cnstr/default_noexcept.pass.cpp

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// unordered_set()
+//    noexcept(
+//        is_nothrow_default_constructible<allocator_type>::value &&
+//        is_nothrow_default_constructible<key_compare>::value &&
+//        is_nothrow_copy_constructible<key_compare>::value);
+
+// This tests a conforming extension
+
+#include <unordered_set>
+#include <cassert>
+
+#include "../../../MoveOnly.h"
+#include "../../../test_allocator.h"
+#include "../../../test_hash.h"
+
+template <class T>
+struct some_comp
+{
+    typedef T value_type;
+    some_comp();
+    some_comp(const some_comp&);
+};
+
+template <class T>
+struct some_hash
+{
+    typedef T value_type;
+    some_hash();
+    some_hash(const some_hash&);
+};
+
+int main()
+{
+#if __has_feature(cxx_noexcept)
+    {
+        typedef std::unordered_set<MoveOnly> C;
+        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                           std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_default_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                          std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
+        static_assert(!std::is_nothrow_default_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C;
+        static_assert(!std::is_nothrow_default_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                                                         some_comp<MoveOnly>> C;
+        static_assert(!std::is_nothrow_default_constructible<C>::value, "");
+    }
+#endif
+}

test/containers/unord/unord.set/unord.set.cnstr/dtor_noexcept.pass.cpp

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// ~unordered_set() // implied noexcept;
+
+#include <unordered_set>
+#include <cassert>
+
+#include "../../../MoveOnly.h"
+#include "../../../test_allocator.h"
+
+#if __has_feature(cxx_noexcept)
+
+template <class T>
+struct some_comp
+{
+    typedef T value_type;
+    ~some_comp() noexcept(false);
+};
+
+template <class T>
+struct some_hash
+{
+    typedef T value_type;
+    some_hash();
+    some_hash(const some_hash&);
+    ~some_hash() noexcept(false);
+};
+
+#endif
+
+int main()
+{
+#if __has_feature(cxx_noexcept)
+    {
+        typedef std::unordered_set<MoveOnly> C;
+        static_assert(std::is_nothrow_destructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                           std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_destructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                          std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_destructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C;
+        static_assert(!std::is_nothrow_destructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                                                         some_comp<MoveOnly>> C;
+        static_assert(!std::is_nothrow_destructible<C>::value, "");
+    }
+#endif
+}

test/containers/unord/unord.set/unord.set.cnstr/move_assign_noexcept.pass.cpp

@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// unordered_set& operator=(unordered_set&& c)
+//     noexcept(
+//          allocator_type::propagate_on_container_move_assignment::value &&
+//          is_nothrow_move_assignable<allocator_type>::value &&
+//          is_nothrow_move_assignable<key_compare>::value);
+
+// This tests a conforming extension
+
+#include <unordered_set>
+#include <cassert>
+
+#include "../../../MoveOnly.h"
+#include "../../../test_allocator.h"
+
+template <class T>
+struct some_comp
+{
+    typedef T value_type;
+    some_comp& operator=(const some_comp&);
+};
+
+template <class T>
+struct some_hash
+{
+    typedef T value_type;
+    some_hash();
+    some_hash(const some_hash&);
+    some_hash& operator=(const some_hash&);
+};
+
+int main()
+{
+#if __has_feature(cxx_noexcept)
+    {
+        typedef std::unordered_set<MoveOnly> C;
+        static_assert(std::is_nothrow_move_assignable<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                           std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
+        static_assert(!std::is_nothrow_move_assignable<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                          std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_move_assignable<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C;
+        static_assert(!std::is_nothrow_move_assignable<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                                                         some_comp<MoveOnly>> C;
+        static_assert(!std::is_nothrow_move_assignable<C>::value, "");
+    }
+#endif
+}

test/containers/unord/unord.set/unord.set.cnstr/move_noexcept.pass.cpp

@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// unordered_set(unordered_set&&)
+//        noexcept(is_nothrow_move_constructible<allocator_type>::value &&
+//                 is_nothrow_move_constructible<key_compare>::value);
+
+// This tests a conforming extension
+
+#include <unordered_set>
+#include <cassert>
+
+#include "../../../MoveOnly.h"
+#include "../../../test_allocator.h"
+
+template <class T>
+struct some_comp
+{
+    typedef T value_type;
+    some_comp(const some_comp&);
+};
+
+template <class T>
+struct some_hash
+{
+    typedef T value_type;
+    some_hash();
+    some_hash(const some_hash&);
+};
+
+int main()
+{
+#if __has_feature(cxx_noexcept)
+    {
+        typedef std::unordered_set<MoveOnly> C;
+        static_assert(std::is_nothrow_move_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                           std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_move_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                          std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
+        static_assert(std::is_nothrow_move_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C;
+        static_assert(!std::is_nothrow_move_constructible<C>::value, "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                                                         some_comp<MoveOnly>> C;
+        static_assert(!std::is_nothrow_move_constructible<C>::value, "");
+    }
+#endif
+}

test/containers/unord/unord.set/unord.set.swap/swap_noexcept.pass.cpp

@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// void swap(unordered_set& c)
+//     noexcept(!allocator_type::propagate_on_container_swap::value ||
+//              __is_nothrow_swappable<allocator_type>::value);
+
+// This tests a conforming extension
+
+#include <unordered_set>
+#include <cassert>
+
+#include "../../../MoveOnly.h"
+#include "../../../test_allocator.h"
+
+template <class T>
+struct some_comp
+{
+    typedef T value_type;
+    
+    some_comp() {}
+    some_comp(const some_comp&) {}
+};
+
+template <class T>
+struct some_hash
+{
+    typedef T value_type;
+    some_hash() {}
+    some_hash(const some_hash&);
+};
+
+int main()
+{
+#if __has_feature(cxx_noexcept)
+    {
+        typedef std::unordered_set<MoveOnly> C;
+        C c1, c2;
+        static_assert(noexcept(swap(c1, c2)), "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                           std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C;
+        C c1, c2;
+        static_assert(noexcept(swap(c1, c2)), "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                          std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C;
+        C c1, c2;
+        static_assert(noexcept(swap(c1, c2)), "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C;
+        C c1, c2;
+        static_assert(!noexcept(swap(c1, c2)), "");
+    }
+    {
+        typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
+                                                         some_comp<MoveOnly>> C;
+        C c1, c2;
+        static_assert(!noexcept(swap(c1, c2)), "");
+    }
+#endif
+}