Index: include/experimental/__config
===================================================================
--- include/experimental/__config
+++ include/experimental/__config
@@ -25,6 +25,10 @@
 #define _LIBCPP_END_NAMESPACE_LFTS  } } }
 #define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v1
 
+#define _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 {
+#define _LIBCPP_END_NAMESPACE_LFTS_V2  } } }
+#define _VSTD_LFTS_V2 _VSTD_EXPERIMENTAL::fundamentals_v2
+
 #define _LIBCPP_BEGIN_NAMESPACE_CHRONO_LFTS _LIBCPP_BEGIN_NAMESPACE_STD        \
   namespace chrono { namespace experimental { inline namespace fundamentals_v1 {
 #define _LIBCPP_END_NAMESPACE_CHRONO_LFTS _LIBCPP_END_NAMESPACE_STD } } }
Index: include/experimental/propagate_const
===================================================================
--- /dev/null
+++ include/experimental/propagate_const
@@ -0,0 +1,559 @@
+// -*- C++ -*-
+//===------------------------ propagate_const -----------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
+#define _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
+
+/*
+    propagate_const synopsis
+
+    namespace std { namespace experimental { inline namespace fundamentals_v2 {
+    
+    // [propagate_const]
+    template <class T> class propagate_const;
+    
+    // [propagate_const.underlying], underlying pointer access
+    constexpr const _Tp& get_underlying(const propagate_const<T>& pt) noexcept;
+    constexpr T& get_underlying(__propagate_const<T>& pt) noexcept;
+    
+    // [propagate_const.relational], relational operators
+    template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
+    template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu);
+    template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t);
+    template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu);
+    template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u);
+    template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu);
+    template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu);
+    
+    // [propagate_const.algorithms], specialized algorithms
+    template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below);
+
+    template <class T>
+    class propagate_const
+    {
+    
+    public:
+      typedef remove_reference_t<decltype(*declval<T&>())> element_type;
+    
+      // [propagate_const.ctor], constructors
+      constexpr propagate_const() = default;
+      propagate_const(const propagate_const& p) = delete;
+      constexpr propagate_const(propagate_const&& p) = default;
+      template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below
+      template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below
+      
+      // [propagate_const.assignment], assignment
+      propagate_const& operator=(const propagate_const& p) = delete;
+      constexpr propagate_const& operator=(propagate_const&& p) = default;
+      template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
+      template <class U> constexpr propagate_const& operator=(U&& u); // see below
+    
+      // [propagate_const.const_observers], const observers
+      explicit constexpr operator bool() const;
+      constexpr const element_type* operator->() const;
+      constexpr operator const element_type*() const; // Not always defined
+      constexpr const element_type& operator*() const;
+      constexpr const element_type* get() const;
+    
+      // [propagate_const.non_const_observers], non-const observers
+      constexpr element_type* operator->();
+      constexpr operator element_type*(); // Not always defined
+      constexpr element_type& operator*();
+      constexpr element_type* get();
+    
+      // [propagate_const.modifiers], modifiers
+      constexpr void swap(propagate_const& pt) noexcept(see below)
+    
+    private:
+      T t_; // exposition only
+    };
+    
+  } // namespace fundamentals_v2
+  } // namespace experimental
+
+  // [propagate_const.hash], hash support
+  template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
+
+  // [propagate_const.comparison_function_objects], comparison function objects
+  template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>; 
+  template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
+
+} // namespace std
+    
+*/
+
+#include <experimental/__config>
+
+#if _LIBCPP_STD_VER > 11
+
+#include <type_traits>
+#include <utility>
+#include <functional>
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_V2
+
+template <class _Tp>
+class propagate_const
+{
+
+public:
+  typedef remove_reference_t<decltype(*_VSTD::declval<_Tp&>())> element_type;
+
+private:
+  template <class _Up>
+  static element_type* __get_pointer(_Up* __u)
+  {
+    return __u;
+  }
+
+  template <class _Up>
+  static element_type* __get_pointer(_Up& __u)
+  {
+    return __get_pointer(__u.get());
+  }
+
+  template <class _Up>
+  static const element_type* __get_pointer(const _Up* __u)
+  {
+    return __u;
+  }
+
+  template <class _Up>
+  static const element_type* __get_pointer(const _Up& __u)
+  {
+    return __get_pointer(__u.get());
+  }
+  
+  template <class _Up>
+  struct is_propagate_const : false_type
+  {
+  };
+
+  template <class _Up>
+  struct is_propagate_const<propagate_const<_Up>> : true_type
+  {
+  };
+
+  _Tp __t_;
+
+public:
+  
+  template <class _Up> friend _LIBCPP_CONSTEXPR const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
+  template <class _Up> friend _LIBCPP_CONSTEXPR _Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
+
+  _LIBCPP_CONSTEXPR propagate_const() _LIBCPP_DEFAULT
+
+  propagate_const(const propagate_const&) = delete;
+
+  _LIBCPP_CONSTEXPR propagate_const(propagate_const&&) _LIBCPP_DEFAULT
+  
+  template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value,bool> = true>
+  explicit _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
+      : __t_(std::move(get_underlying(__pu)))
+  {
+  }
+
+  template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value,bool> = false>
+  _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
+      : __t_(std::move(get_underlying(__pu)))
+  {
+  }
+
+  template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value &&
+                                 !is_propagate_const<decay_t<_Up>>::value,bool> = true>
+  explicit _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
+      : __t_(std::forward<_Up>(__u))
+  {
+  }
+
+  template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
+                                 is_constructible<_Tp, _Up&&>::value &&
+                                 !is_propagate_const<decay_t<_Up>>::value,bool> = false>
+  _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
+      : __t_(std::forward<_Up>(__u))
+  {
+  }
+  
+  propagate_const& operator=(const propagate_const&) = delete;
+
+  _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) _LIBCPP_DEFAULT
+
+  template <class _Up>
+  _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu)
+  {
+    __t_ = std::move(get_underlying(__pu));
+    return *this;
+  }
+
+  template <class _Up, class _Vp = enable_if_t<!is_propagate_const<decay_t<_Up>>::value>>
+  _LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u)
+  {
+    __t_ = std::forward<_Up>(__u);
+    return *this;
+  }
+  
+  _LIBCPP_CONSTEXPR const element_type* get() const
+  {
+    return __get_pointer(__t_);
+  }
+
+  _LIBCPP_CONSTEXPR element_type* get() 
+  {
+    return __get_pointer(__t_);
+  }
+  
+  explicit _LIBCPP_CONSTEXPR operator bool() const
+  {
+    return get() != nullptr;
+  }
+
+  _LIBCPP_CONSTEXPR const element_type* operator->() const
+  {
+    return get();
+  }
+
+  template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible<
+                                  const _Tp_, const element_type *>::value>>
+  operator const element_type *() const {
+    return get();
+  }
+
+  _LIBCPP_CONSTEXPR const element_type& operator*() const
+  {
+    return *get();
+  }
+  
+  _LIBCPP_CONSTEXPR element_type* operator->()
+  {
+    return get();
+  }
+
+  template <class _Tp_ = _Tp, class _Up = enable_if_t<
+                                  is_convertible<_Tp_, element_type *>::value>>
+  operator element_type *() {
+    return get();
+  }
+
+  _LIBCPP_CONSTEXPR element_type& operator*()
+  {
+    return *get();
+  }
+
+  _LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+  {
+    _VSTD::swap(__t_, __pt.__t_);
+  }
+};
+
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t)
+{
+  return get_underlying(__pt) == nullptr;
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt)
+{
+  return nullptr == get_underlying(__pt);
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t)
+{
+  return get_underlying(__pt) != nullptr;
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt)
+{
+  return nullptr != get_underlying(__pt);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return get_underlying(__pt) == get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return get_underlying(__pt) != get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt,
+                         const propagate_const<_Up>& __pu)
+{
+  return get_underlying(__pt) < get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt,
+                         const propagate_const<_Up>& __pu)
+{
+  return get_underlying(__pt) > get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return get_underlying(__pt) <= get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt,
+                          const propagate_const<_Up>& __pu)
+{
+  return get_underlying(__pt) >= get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return get_underlying(__pt) == __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return get_underlying(__pt) != __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return get_underlying(__pt) < __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return get_underlying(__pt) > __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return get_underlying(__pt) <= __u;
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u)
+{
+  return get_underlying(__pt) >= __u;
+}
+
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t == get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t != get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t < get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t > get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t <= get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu)
+{
+  return __t >= get_underlying(__pu);
+}
+
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+{
+  _VSTD::swap(get_underlying(__pc1), get_underlying(__pc2));
+}
+
+
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT 
+{ 
+  return __pt.__t_; 
+}
+  
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT 
+{ 
+  return __pt.__t_; 
+}
+
+_LIBCPP_END_NAMESPACE_LFTS_V2
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct hash<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef size_t result_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type;
+
+  size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const
+  {
+    return std::hash<_Tp>()(get_underlying(__pc1));
+  }
+};
+
+template <class _Tp>
+struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::equal_to<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::not_equal_to<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct less<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::less<_Tp>()(get_underlying(__pc1), get_underlying(__pc2)); 
+  }
+};
+
+template <class _Tp>
+struct greater<experimental::fundamentals_v2::propagate_const<_Tp>> 
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::greater<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::less_equal<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
+  }
+};
+
+template <class _Tp>
+struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
+{
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
+  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+
+  bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
+      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  {
+    return std::greater_equal<_Tp>()(get_underlying(__pc1), get_underlying(__pc2));
+  }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 11
+#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
+
Index: test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter,
 //          Predicate<auto, InIter::value_type> Pred>
-//   requires CopyConstructible<Pred>
+//   requires CopyConstructable<Pred>
 //   OutIter
 //   copy_if(InIter first, InIter last, OutIter result, Pred pred);
 
Index: test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<ForwardIterator Iter, Callable Generator>
 //   requires OutputIterator<Iter, Generator::result_type>
-//         && CopyConstructible<Generator>
+//         && CopyConstructable<Generator>
 //   void
 //   generate(Iter first, Iter last, Generator gen);
 
Index: test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<class Iter, IntegralLike Size, Callable Generator>
 //   requires OutputIterator<Iter, Generator::result_type>
-//         && CopyConstructible<Generator>
+//         && CopyConstructable<Generator>
 //   void
 //   generate_n(Iter first, Size n, Generator gen);
 
Index: test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<BidirectionalIterator Iter, Predicate<auto, Iter::value_type> Pred>
 //   requires ShuffleIterator<Iter>
-//         && CopyConstructible<Pred>
+//         && CopyConstructable<Pred>
 //   Iter
 //   partition(Iter first, Iter last, Pred pred);
 
Index: test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<BidirectionalIterator Iter, Predicate<auto, Iter::value_type> Pred>
 //   requires ShuffleIterator<Iter>
-//         && CopyConstructible<Pred>
+//         && CopyConstructable<Pred>
 //   Iter
 //   stable_partition(Iter first, Iter last, Pred pred);
 
Index: test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<InputIterator InIter, OutputIterator<auto, InIter::reference> OutIter,
 //          Predicate<auto, InIter::value_type> Pred>
-//   requires CopyConstructible<Pred>
+//   requires CopyConstructable<Pred>
 //   OutIter
 //   remove_copy_if(InIter first, InIter last, OutIter result, Pred pred);
 
Index: test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred>
 //   requires OutputIterator<Iter, RvalueOf<Iter::reference>::type>
-//         && CopyConstructible<Pred>
+//         && CopyConstructable<Pred>
 //   Iter
 //   remove_if(Iter first, Iter last, Pred pred);
 
Index: test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp
@@ -13,7 +13,7 @@
 //          Predicate<auto, InIter::value_type> Pred, class T>
 //   requires OutputIterator<OutIter, InIter::reference>
 //         && OutputIterator<OutIter, const T&>
-//         && CopyConstructible<Pred>
+//         && CopyConstructable<Pred>
 //   OutIter
 //   replace_copy_if(InIter first, InIter last, OutIter result, Pred pred, const T& new_value);
 
Index: test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp
@@ -12,7 +12,7 @@
 // template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred, class T>
 //   requires OutputIterator<Iter, Iter::reference>
 //         && OutputIterator<Iter, const T&>
-//         && CopyConstructible<Pred>
+//         && CopyConstructable<Pred>
 //   void
 //   replace_if(Iter first, Iter last, Pred pred, const T& new_value);
 
Index: test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<InputIterator InIter1, InputIterator InIter2, class OutIter,
 //          Callable<auto, const InIter1::value_type&, const InIter2::value_type&> BinaryOp>
-//   requires OutputIterator<OutIter, BinaryOp::result_type> && CopyConstructible<BinaryOp>
+//   requires OutputIterator<OutIter, BinaryOp::result_type> && CopyConstructable<BinaryOp>
 // OutIter
 // transform(InIter1 first1, InIter1 last1, InIter2 first2, OutIter result, BinaryOp binary_op);
 
Index: test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<InputIterator InIter, class OutIter,
 //          Callable<auto, const InIter::value_type&> Op>
-//   requires OutputIterator<OutIter, Op::result_type> && CopyConstructible<Op>
+//   requires OutputIterator<OutIter, Op::result_type> && CopyConstructable<Op>
 //   OutIter
 //   transform(InIter first, InIter last, OutIter result, Op op);
 
Index: test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp
@@ -13,7 +13,7 @@
 //   requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type>
 //         && EqualityComparable<InIter::value_type>
 //         && HasAssign<InIter::value_type, InIter::reference>
-//         && Constructible<InIter::value_type, InIter::reference>
+//         && Constructable<InIter::value_type, InIter::reference>
 //   OutIter
 //   unique_copy(InIter first, InIter last, OutIter result);
 
Index: test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp
@@ -13,8 +13,8 @@
 //          EquivalenceRelation<auto, InIter::value_type> Pred>
 //   requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type>
 //         && HasAssign<InIter::value_type, InIter::reference>
-//         && Constructible<InIter::value_type, InIter::reference>
-//         && CopyConstructible<Pred>
+//         && Constructable<InIter::value_type, InIter::reference>
+//         && CopyConstructable<Pred>
 //   OutIter
 //   unique_copy(InIter first, InIter last, OutIter result, Pred pred);
 
Index: test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
+++ test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred>
 //   requires OutputIterator<Iter, RvalueOf<Iter::reference>::type>
-//         && CopyConstructible<Pred>
+//         && CopyConstructable<Pred>
 //   Iter
 //   unique(Iter first, Iter last, Pred pred);
 
Index: test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred>
-//   requires CopyConstructible<Pred>
+//   requires CopyConstructable<Pred>
 //   Iter
 //   adjacent_find(Iter first, Iter last, Pred pred);
 
Index: test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred>
-//   requires CopyConstructible<Pred>
+//   requires CopyConstructable<Pred>
 //   Iter::difference_type
 //   count_if(Iter first, Iter last, Pred pred);
 
Index: test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<InputIterator Iter1, InputIterator Iter2,
 //          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
-//   requires CopyConstructible<Pred>
+//   requires CopyConstructable<Pred>
 //   bool
 //   equal(Iter1 first1, Iter1 last1, Iter2 first2, Pred pred);
 
Index: test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<ForwardIterator Iter1, ForwardIterator Iter2,
 //          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
-//   requires CopyConstructible<Pred>
+//   requires CopyConstructable<Pred>
 //   Iter1
 //   find_end(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred);
 
Index: test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<InputIterator Iter1, ForwardIterator Iter2,
 //          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
-//   requires CopyConstructible<Pred>
+//   requires CopyConstructable<Pred>
 //   Iter1
 //   find_first_of(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred);
 
Index: test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred>
-//   requires CopyConstructible<Pred>
+//   requires CopyConstructable<Pred>
 //   Iter
 //   find_if(Iter first, Iter last, Pred pred);
 
Index: test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred>
-//   requires CopyConstructible<Pred>
+//   requires CopyConstructable<Pred>
 //   Iter
 //   find_if_not(Iter first, Iter last, Pred pred);
 
Index: test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<InputIterator Iter, Callable<auto, Iter::reference> Function>
-//   requires CopyConstructible<Function>
+//   requires CopyConstructable<Function>
 //   Function
 //   for_each(Iter first, Iter last, Function f);
 
Index: test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
===================================================================
--- test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
+++ test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<InputIterator Iter1, InputIterator Iter2,
 //          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
-//   requires CopyConstructible<Pred>
+//   requires CopyConstructable<Pred>
 //   pair<Iter1, Iter2>
 //   mismatch(Iter1 first1, Iter1 last1, Iter2 first2, Pred pred);
 
Index: test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
-//   requires CopyConstructible<Compare>
+//   requires CopyConstructable<Compare>
 //   Iter
 //   is_heap_until(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
-//   requires ShuffleIterator<Iter> && CopyConstructible<Compare>
+//   requires ShuffleIterator<Iter> && CopyConstructable<Compare>
 //   void
 //   make_heap(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
-//   requires ShuffleIterator<Iter> && CopyConstructible<Compare>
+//   requires ShuffleIterator<Iter> && CopyConstructable<Compare>
 //   void
 //   pop_heap(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
-//   requires ShuffleIterator<Iter> && CopyConstructible<Compare>
+//   requires ShuffleIterator<Iter> && CopyConstructable<Compare>
 //   void
 //   sort_heap(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T, CopyConstructible Compare>
+// template<ForwardIterator Iter, class T, CopyConstructable Compare>
 //   requires Predicate<Compare, T, Iter::value_type>
 //         && Predicate<Compare, Iter::value_type, T>
 //   bool
Index: test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<ForwardIterator Iter, class T, CopyConstructible Compare>
+// template<ForwardIterator Iter, class T, CopyConstructable Compare>
 //   requires Predicate<Compare, T, Iter::value_type>
 //         && Predicate<Compare, Iter::value_type, T>
 //   pair<Iter, Iter>
Index: test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<ForwardIterator Iter, class T, Predicate<auto, T, Iter::value_type> Compare>
-//   requires CopyConstructible<Compare>
+//   requires CopyConstructable<Compare>
 //   Iter
 //   upper_bound(Iter first, Iter last, const T& value, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp
@@ -9,7 +9,7 @@
 
 // <algorithm>
 
-// template<InputIterator Iter1, InputIterator Iter2, CopyConstructible Compare>
+// template<InputIterator Iter1, InputIterator Iter2, CopyConstructable Compare>
 //   requires Predicate<Compare, Iter1::value_type, Iter2::value_type>
 //         && Predicate<Compare, Iter2::value_type, Iter1::value_type>
 //   bool
Index: test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<BidirectionalIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
 //   requires ShuffleIterator<Iter>
-//         && CopyConstructible<Compare>
+//         && CopyConstructable<Compare>
 //   void
 //   inplace_merge(Iter first, Iter middle, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp
@@ -15,7 +15,7 @@
 //          Predicate<auto, InIter2::value_type, InIter1::value_type> Compare>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
-//         && CopyConstructible<Compare>
+//         && CopyConstructable<Compare>
 //   OutIter
 //   merge(InIter1 first1, InIter1 last1,
 //         InIter2 first2, InIter2 last2, OutIter result, Compare comp);
Index: test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/max_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<class T, StrictWeakOrder<auto, T> Compare>
-//   requires !SameType<T, Compare> && CopyConstructible<Compare>
+//   requires !SameType<T, Compare> && CopyConstructable<Compare>
 //   const T&
 //   max(const T& a, const T& b, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
-//   requires CopyConstructible<Compare>
+//   requires CopyConstructable<Compare>
 //   Iter
 //   max_element(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/min_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<class T, StrictWeakOrder<auto, T> Compare>
-//   requires !SameType<T, Compare> && CopyConstructible<Compare>
+//   requires !SameType<T, Compare> && CopyConstructable<Compare>
 //   const T&
 //   min(const T& a, const T& b, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
-//   requires CopyConstructible<Compare>
+//   requires CopyConstructable<Compare>
 //   Iter
 //   min_element(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/minmax_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<class T, StrictWeakOrder<auto, T> Compare>
-//   requires !SameType<T, Compare> && CopyConstructible<Compare>
+//   requires !SameType<T, Compare> && CopyConstructable<Compare>
 //   pair<const T&, const T&>
 //   minmax(const T& a, const T& b, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
-//   requires CopyConstructible<Compare>
+//   requires CopyConstructable<Compare>
 //   pair<Iter, Iter>
 //   minmax_element(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
 //   requires ShuffleIterator<Iter>
-//         && CopyConstructible<Compare>
+//         && CopyConstructable<Compare>
 //   void
 //   nth_element(Iter first, Iter nth, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<BidirectionalIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
 //   requires ShuffleIterator<Iter>
-//         && CopyConstructible<Compare>
+//         && CopyConstructable<Compare>
 //   bool
 //   next_permutation(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<BidirectionalIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
 //   requires ShuffleIterator<Iter>
-//         && CopyConstructible<Compare>
+//         && CopyConstructable<Compare>
 //   bool
 //   prev_permutation(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
-//          CopyConstructible Compare>
+//          CopyConstructable Compare>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
-//          CopyConstructible Compare>
+//          CopyConstructable Compare>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
-//          CopyConstructible Compare>
+//          CopyConstructable Compare>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
Index: test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
-//          CopyConstructible Compare>
+//          CopyConstructable Compare>
 //   requires OutputIterator<OutIter, InIter1::reference>
 //         && OutputIterator<OutIter, InIter2::reference>
 //         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
Index: test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
-//   requires CopyConstructible<Compare>
+//   requires CopyConstructable<Compare>
 //   bool
 //   is_sorted(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp
@@ -10,7 +10,7 @@
 // <algorithm>
 
 // template<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
-//   requires CopyConstructible<Compare>
+//   requires CopyConstructable<Compare>
 //   Iter
 //   is_sorted_until(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp
@@ -14,7 +14,7 @@
 //         && OutputIterator<RAIter, InIter::reference>
 //         && Predicate<Compare, InIter::value_type, RAIter::value_type>
 //         && StrictWeakOrder<Compare, RAIter::value_type>}
-//         && CopyConstructible<Compare>
+//         && CopyConstructable<Compare>
 //   RAIter
 //   partial_sort_copy(InIter first, InIter last,
 //                     RAIter result_first, RAIter result_last, Compare comp);
Index: test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
 //   requires ShuffleIterator<Iter>
-//         && CopyConstructible<Compare>
+//         && CopyConstructable<Compare>
 //   void
 //   partial_sort(Iter first, Iter middle, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/sort/sort_comp.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
 //   requires ShuffleIterator<Iter>
-//         && CopyConstructible<Compare>
+//         && CopyConstructable<Compare>
 //   void
 //   sort(Iter first, Iter last, Compare comp);
 
Index: test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
===================================================================
--- test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
+++ test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort_comp.pass.cpp
@@ -11,7 +11,7 @@
 
 // template<RandomAccessIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
 //   requires ShuffleIterator<Iter>
-//         && CopyConstructible<Compare>
+//         && CopyConstructable<Compare>
 //   void
 //   stable_sort(Iter first, Iter last, Compare comp);
 
Index: test/std/containers/NotConstructible.h
===================================================================
--- test/std/containers/NotConstructible.h
+++ test/std/containers/NotConstructible.h
@@ -12,26 +12,26 @@
 
 #include <functional>
 
-class NotConstructible
+class NotConstructable
 {
-    NotConstructible(const NotConstructible&);
-    NotConstructible& operator=(const NotConstructible&);
+    NotConstructable(const NotConstructable&);
+    NotConstructable& operator=(const NotConstructable&);
 public:
 };
 
 inline
 bool
-operator==(const NotConstructible&, const NotConstructible&)
+operator==(const NotConstructable&, const NotConstructable&)
 {return true;}
 
 namespace std
 {
 
 template <>
-struct hash<NotConstructible>
-    : public std::unary_function<NotConstructible, std::size_t>
+struct hash<NotConstructable>
+    : public std::unary_function<NotConstructable, std::size_t>
 {
-    std::size_t operator()(const NotConstructible&) const {return 0;}
+    std::size_t operator()(const NotConstructable&) const {return 0;}
 };
 
 }
Index: test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/alloc.pass.cpp
@@ -15,7 +15,7 @@
 #include <cassert>
 
 #include "test_allocator.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
@@ -30,9 +30,9 @@
 int main()
 {
     test<int>(std::allocator<int>());
-    test<NotConstructible>(test_allocator<NotConstructible>(3));
+    test<NotConstructable>(test_allocator<NotConstructable>(3));
 #if __cplusplus >= 201103L
     test<int>(min_allocator<int>());
-    test<NotConstructible>(min_allocator<NotConstructible>{});
+    test<NotConstructable>(min_allocator<NotConstructable>{});
 #endif
 }
Index: test/std/containers/sequences/deque/deque.cons/default.pass.cpp
===================================================================
--- test/std/containers/sequences/deque/deque.cons/default.pass.cpp
+++ test/std/containers/sequences/deque/deque.cons/default.pass.cpp
@@ -15,7 +15,7 @@
 #include <cassert>
 
 #include "../../../stack_allocator.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "min_allocator.h"
 
 template <class T, class Allocator>
@@ -33,9 +33,9 @@
 int main()
 {
     test<int, std::allocator<int> >();
-    test<NotConstructible, stack_allocator<NotConstructible, 1> >();
+    test<NotConstructable, stack_allocator<NotConstructable, 1> >();
 #if __cplusplus >= 201103L
     test<int, min_allocator<int> >();
-    test<NotConstructible, min_allocator<NotConstructible> >();
+    test<NotConstructable, min_allocator<NotConstructable> >();
 #endif
 }
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.fail.cpp
@@ -15,12 +15,12 @@
 #include <cassert>
 
 #include "test_allocator.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 
 int main()
 {
     {
-        typedef test_allocator<NotConstructible> A;
+        typedef test_allocator<NotConstructable> A;
         typedef A::value_type T;
         typedef std::forward_list<T, A> C;
         C c = A(12);
Index: test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.cons/alloc.pass.cpp
@@ -15,13 +15,13 @@
 #include <cassert>
 
 #include "test_allocator.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
-        typedef test_allocator<NotConstructible> A;
+        typedef test_allocator<NotConstructable> A;
         typedef A::value_type T;
         typedef std::forward_list<T, A> C;
         C c(A(12));
@@ -30,7 +30,7 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef min_allocator<NotConstructible> A;
+        typedef min_allocator<NotConstructable> A;
         typedef A::value_type T;
         typedef std::forward_list<T, A> C;
         C c(A{});
Index: test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
===================================================================
--- test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
+++ test/std/containers/sequences/forwardlist/forwardlist.modifiers/clear.pass.cpp
@@ -14,13 +14,13 @@
 #include <forward_list>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "min_allocator.h"
 
 int main()
 {
     {
-        typedef NotConstructible T;
+        typedef NotConstructable T;
         typedef std::forward_list<T> C;
         C c;
         c.clear();
@@ -40,7 +40,7 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef NotConstructible T;
+        typedef NotConstructable T;
         typedef std::forward_list<T, min_allocator<T>> C;
         C c;
         c.clear();
Index: test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
===================================================================
--- test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
+++ test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 #include "test_allocator.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../stack_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
@@ -65,10 +65,10 @@
 {
     {
     test0<std::vector<int> >();
-    test0<std::vector<NotConstructible> >();
+    test0<std::vector<NotConstructable> >();
     test1<std::vector<int, test_allocator<int> > >(test_allocator<int>(3));
-    test1<std::vector<NotConstructible, test_allocator<NotConstructible> > >
-        (test_allocator<NotConstructible>(5));
+    test1<std::vector<NotConstructable, test_allocator<NotConstructable> > >
+        (test_allocator<NotConstructable>(5));
     }
     {
         std::vector<int, stack_allocator<int, 10> > v;
@@ -77,10 +77,10 @@
 #if TEST_STD_VER >= 11
     {
     test0<std::vector<int, min_allocator<int>> >();
-    test0<std::vector<NotConstructible, min_allocator<NotConstructible>> >();
+    test0<std::vector<NotConstructable, min_allocator<NotConstructable>> >();
     test1<std::vector<int, min_allocator<int> > >(min_allocator<int>{});
-    test1<std::vector<NotConstructible, min_allocator<NotConstructible> > >
-        (min_allocator<NotConstructible>{});
+    test1<std::vector<NotConstructable, min_allocator<NotConstructable> > >
+        (min_allocator<NotConstructable>{});
     }
     {
         std::vector<int, min_allocator<int> > v;
Index: test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,18 +27,18 @@
 int main()
 {
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
-        C c(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10));
+        C c(test_allocator<std::pair<const NotConstructable, NotConstructable> >(10));
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >(10)));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -47,18 +47,18 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
-        C c(min_allocator<std::pair<const NotConstructible, NotConstructible> >{});
+        C c(min_allocator<std::pair<const NotConstructable, NotConstructable> >{});
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -67,7 +67,7 @@
     }
 #if _LIBCPP_STD_VER > 11
     {
-        typedef NotConstructible T;
+        typedef NotConstructable T;
         typedef test_allocator<std::pair<const T, T>> A;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
@@ -86,7 +86,7 @@
         assert(c.max_load_factor() == 1);
     }
     {
-        typedef NotConstructible T;
+        typedef NotConstructable T;
         typedef test_allocator<std::pair<const T, T>> A;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
Index: test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,18 +27,18 @@
 int main()
 {
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c;
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -47,18 +47,18 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c;
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp
@@ -22,7 +22,7 @@
 #include <cfloat>
 
 #include "test_iterators.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
Index: test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
@@ -22,7 +22,7 @@
 #include <cfloat>
 
 #include "test_iterators.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
Index: test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
@@ -23,7 +23,7 @@
 #include <cfloat>
 
 #include "test_iterators.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
Index: test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
@@ -23,7 +23,7 @@
 #include <cfloat>
 
 #include "test_iterators.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
Index: test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include <cfloat>
 
 #include "test_iterators.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
Index: test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,18 +27,18 @@
 int main()
 {
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c = 7;
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -47,18 +47,18 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c = 7;
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,18 +27,18 @@
 int main()
 {
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c(7);
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -47,18 +47,18 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c(7);
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,20 +27,20 @@
 int main()
 {
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8)
+            test_hash<std::hash<NotConstructable> >(8)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -49,20 +49,20 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8)
+            test_hash<std::hash<NotConstructable> >(8)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,21 +27,21 @@
 int main()
 {
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -50,21 +50,21 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,22 +27,22 @@
 int main()
 {
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
-            test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9),
+            test_allocator<std::pair<const NotConstructable, NotConstructable> >(10)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >(10)));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -51,22 +51,22 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_map<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_map<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
-            min_allocator<std::pair<const NotConstructible, NotConstructible> >()
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9),
+            min_allocator<std::pair<const NotConstructable, NotConstructable> >()
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,18 +27,18 @@
 int main()
 {
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
-        C c(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10));
+        C c(test_allocator<std::pair<const NotConstructable, NotConstructable> >(10));
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >(10)));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -47,18 +47,18 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
-        C c(min_allocator<std::pair<const NotConstructible, NotConstructible> >{});
+        C c(min_allocator<std::pair<const NotConstructable, NotConstructable> >{});
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -67,7 +67,7 @@
     }
 #if _LIBCPP_STD_VER > 11
     {
-        typedef NotConstructible T;
+        typedef NotConstructable T;
         typedef test_allocator<std::pair<const T, T>> A;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
@@ -86,7 +86,7 @@
         assert(c.max_load_factor() == 1);
     }
     {
-        typedef NotConstructible T;
+        typedef NotConstructable T;
         typedef test_allocator<std::pair<const T, T>> A;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,18 +27,18 @@
 int main()
 {
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c;
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -47,18 +47,18 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c;
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp
@@ -22,7 +22,7 @@
 #include <cfloat>
 
 #include "test_iterators.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
@@ -22,7 +22,7 @@
 #include <cfloat>
 
 #include "test_iterators.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
@@ -23,7 +23,7 @@
 #include <cfloat>
 
 #include "test_iterators.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
@@ -23,7 +23,7 @@
 #include <cfloat>
 
 #include "test_iterators.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
@@ -24,7 +24,7 @@
 #include <cfloat>
 
 #include "test_iterators.h"
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,18 +27,18 @@
 int main()
 {
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c = 7;
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -47,18 +47,18 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c = 7;
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,18 +27,18 @@
 int main()
 {
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c(7);
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -47,18 +47,18 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c(7);
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,20 +27,20 @@
 int main()
 {
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8)
+            test_hash<std::hash<NotConstructable> >(8)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -49,20 +49,20 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8)
+            test_hash<std::hash<NotConstructable> >(8)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,21 +27,21 @@
 int main()
 {
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -50,21 +50,21 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_map>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,22 +27,22 @@
 int main()
 {
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<std::pair<const NotConstructible,
-                                                                  NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<std::pair<const NotConstructable,
+                                                                  NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
-            test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9),
+            test_allocator<std::pair<const NotConstructable, NotConstructable> >(10)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
         assert(c.get_allocator() ==
-               (test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)));
+               (test_allocator<std::pair<const NotConstructable, NotConstructable> >(10)));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -51,22 +51,22 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multimap<NotConstructible, NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<std::pair<const NotConstructible,
-                                                                 NotConstructible> >
+        typedef std::unordered_multimap<NotConstructable, NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<std::pair<const NotConstructable,
+                                                                 NotConstructable> >
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
-            min_allocator<std::pair<const NotConstructible, NotConstructible> >()
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9),
+            min_allocator<std::pair<const NotConstructable, NotConstructable> >()
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
         assert(c.get_allocator() ==
-               (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
+               (min_allocator<std::pair<const NotConstructable, NotConstructable> >()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,16 +27,16 @@
 int main()
 {
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
-        C c(test_allocator<NotConstructible>(10));
+        C c(test_allocator<NotConstructable>(10));
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == test_allocator<NotConstructible>(10));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == test_allocator<NotConstructable>(10));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -45,16 +45,16 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
-        C c(min_allocator<NotConstructible>{});
+        C c(min_allocator<NotConstructable>{});
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == min_allocator<NotConstructible>());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == min_allocator<NotConstructable>());
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -63,7 +63,7 @@
     }
 #if _LIBCPP_STD_VER > 11
     {
-        typedef NotConstructible T;
+        typedef NotConstructable T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
         typedef test_allocator<T> A;
@@ -83,7 +83,7 @@
         assert(c.max_load_factor() == 1);
     }
     {
-        typedef NotConstructible T;
+        typedef NotConstructable T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
         typedef test_allocator<T> A;
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,16 +27,16 @@
 int main()
 {
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c;
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (test_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (test_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -45,16 +45,16 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c;
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,16 +27,16 @@
 int main()
 {
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c = 7;
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (test_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (test_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -45,16 +45,16 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c = 7;
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,16 +27,16 @@
 int main()
 {
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c(7);
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (test_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (test_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -45,16 +45,16 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c(7);
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,18 +27,18 @@
 int main()
 {
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8)
+            test_hash<std::hash<NotConstructable> >(8)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (test_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (test_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -47,18 +47,18 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8)
+            test_hash<std::hash<NotConstructable> >(8)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,19 +27,19 @@
 int main()
 {
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
-        assert(c.get_allocator() == (test_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
+        assert(c.get_allocator() == (test_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -48,19 +48,19 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,20 +27,20 @@
 int main()
 {
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
-            test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9),
+            test_allocator<std::pair<const NotConstructable, NotConstructable> >(10)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
-        assert(c.get_allocator() == (test_allocator<NotConstructible>(10)));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
+        assert(c.get_allocator() == (test_allocator<NotConstructable>(10)));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -49,20 +49,20 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_multiset<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_multiset<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
-            min_allocator<std::pair<const NotConstructible, NotConstructible> >()
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9),
+            min_allocator<std::pair<const NotConstructable, NotConstructable> >()
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,16 +27,16 @@
 int main()
 {
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
-        C c(test_allocator<NotConstructible>(10));
+        C c(test_allocator<NotConstructable>(10));
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == test_allocator<NotConstructible>(10));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == test_allocator<NotConstructable>(10));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -45,16 +45,16 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
-        C c(min_allocator<NotConstructible>{});
+        C c(min_allocator<NotConstructable>{});
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == min_allocator<NotConstructible>());
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == min_allocator<NotConstructable>());
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -63,7 +63,7 @@
     }
 #if _LIBCPP_STD_VER > 11
     {
-        typedef NotConstructible T;
+        typedef NotConstructable T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
         typedef test_allocator<T> A;
@@ -83,7 +83,7 @@
         assert(c.max_load_factor() == 1);
     }
     {
-        typedef NotConstructible T;
+        typedef NotConstructable T;
         typedef test_hash<std::hash<T>> HF;
         typedef test_compare<std::equal_to<T>> Comp;
         typedef test_allocator<T> A;
Index: test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,16 +27,16 @@
 int main()
 {
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c;
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (test_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (test_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -45,16 +45,16 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c;
         assert(c.bucket_count() == 0);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -26,16 +26,16 @@
 int main()
 {
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c = 7;
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (test_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (test_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,16 +27,16 @@
 int main()
 {
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c(7);
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (test_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (test_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -45,16 +45,16 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c(7);
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >());
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,18 +27,18 @@
 int main()
 {
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8)
+            test_hash<std::hash<NotConstructable> >(8)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (test_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (test_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -47,18 +47,18 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8)
+            test_hash<std::hash<NotConstructable> >(8)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >());
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >());
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,19 +27,19 @@
 int main()
 {
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
-        assert(c.get_allocator() == (test_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
+        assert(c.get_allocator() == (test_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -48,19 +48,19 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
===================================================================
--- test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
+++ test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
@@ -18,7 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
-#include "../../../NotConstructible.h"
+#include "../../../NotConstructable.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -27,20 +27,20 @@
 int main()
 {
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   test_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   test_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
-            test_allocator<NotConstructible>(10)
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9),
+            test_allocator<NotConstructable>(10)
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
-        assert(c.get_allocator() == (test_allocator<NotConstructible>(10)));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
+        assert(c.get_allocator() == (test_allocator<NotConstructable>(10)));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
@@ -49,20 +49,20 @@
     }
 #if __cplusplus >= 201103L
     {
-        typedef std::unordered_set<NotConstructible,
-                                   test_hash<std::hash<NotConstructible> >,
-                                   test_compare<std::equal_to<NotConstructible> >,
-                                   min_allocator<NotConstructible>
+        typedef std::unordered_set<NotConstructable,
+                                   test_hash<std::hash<NotConstructable> >,
+                                   test_compare<std::equal_to<NotConstructable> >,
+                                   min_allocator<NotConstructable>
                                    > C;
         C c(7,
-            test_hash<std::hash<NotConstructible> >(8),
-            test_compare<std::equal_to<NotConstructible> >(9),
-            min_allocator<NotConstructible>()
+            test_hash<std::hash<NotConstructable> >(8),
+            test_compare<std::equal_to<NotConstructable> >(9),
+            min_allocator<NotConstructable>()
            );
         assert(c.bucket_count() == 7);
-        assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8));
-        assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9));
-        assert(c.get_allocator() == (min_allocator<NotConstructible>()));
+        assert(c.hash_function() == test_hash<std::hash<NotConstructable> >(8));
+        assert(c.key_eq() == test_compare<std::equal_to<NotConstructable> >(9));
+        assert(c.get_allocator() == (min_allocator<NotConstructable>()));
         assert(c.size() == 0);
         assert(c.empty());
         assert(std::distance(c.begin(), c.end()) == 0);
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template <CopyConstructible Arg, Returnable Result>
+// template <CopyConstructable Arg, Returnable Result>
 // pointer_to_unary_function<Arg, Result>
 // ptr_fun(Result (*f)(Arg));
 
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template <CopyConstructible Arg1, CopyConstructible Arg2, Returnable Result>
+// template <CopyConstructable Arg1, CopyConstructable Arg2, Returnable Result>
 // pointer_to_binary_function<Arg1,Arg2,Result>
 // ptr_fun(Result (*f)(Arg1, Arg2));
 
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template<Returnable S, ClassType T, CopyConstructible A>
+// template<Returnable S, ClassType T, CopyConstructable A>
 //   const_mem_fun1_t<S,T,A>
 //   mem_fun(S (T::*f)(A) const);
 
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template<Returnable S, ClassType T, CopyConstructible A>
+// template<Returnable S, ClassType T, CopyConstructable A>
 //   const_mem_fun1_ref_t<S,T,A>
 //   mem_fun_ref(S (T::*f)(A) const);
 
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template<Returnable S, ClassType T, CopyConstructible A>
+// template<Returnable S, ClassType T, CopyConstructable A>
 //   mem_fun1_t<S,T,A>
 //   mem_fun(S (T::*f)(A));
 
Index: test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
===================================================================
--- test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
+++ test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template<Returnable S, ClassType T, CopyConstructible A>
+// template<Returnable S, ClassType T, CopyConstructable A>
 //   mem_fun1_ref_t<S,T,A>
 //   mem_fun_ref(S (T::*f)(A));
 
Index: test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp
===================================================================
--- test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp
+++ test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp
@@ -32,7 +32,7 @@
     using namespace std::experimental;
     non_copyable nc;
     any a;
-    a = static_cast<non_copyable &&>(nc); // expected-error@experimental/any:* 2 {{static_assert failed "_ValueType must be CopyConstructible."}}
+    a = static_cast<non_copyable &&>(nc); // expected-error@experimental/any:* 2 {{static_assert failed "_ValueType must be CopyConstructable."}}
         // expected-error@experimental/any:* {{calling a private constructor of class 'non_copyable'}}
 
 }
Index: test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp
===================================================================
--- test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp
+++ test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp
@@ -31,6 +31,6 @@
     using namespace std::experimental;
     non_copyable nc;
     any a(static_cast<non_copyable &&>(nc));
-    // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType must be CopyConstructible."}}
+    // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType must be CopyConstructable."}}
     // expected-error@experimental/any:* 1 {{calling a private constructor of class 'non_copyable'}}
 }
Index: test/std/experimental/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
===================================================================
--- test/std/experimental/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
+++ test/std/experimental/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
@@ -40,6 +40,6 @@
     any_cast<no_copy>(static_cast<any&>(a));
     any_cast<no_copy>(static_cast<any const&>(a));
     any_cast<no_copy>(static_cast<any &&>(a));
-    // expected-error@experimental/any:* 3 {{static_assert failed "_ValueType is required to be a reference or a CopyConstructible type."}}
+    // expected-error@experimental/any:* 3 {{static_assert failed "_ValueType is required to be a reference or a CopyConstructable type."}}
     // expected-error@experimental/any:* 3 {{calling a private constructor of class 'no_copy'}}
-}
\ No newline at end of file
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.fail.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign.fail.cpp
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const& propagate_const::operator=(const propagate_const<U>&)=delete;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1(1);
+  P p2(2);
+
+  p2=p1; // will not compile
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_element_type.pass.cpp
@@ -0,0 +1,34 @@
+
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const& propagate_const::operator=(U&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<CopyConstructableFromX> PY;
+
+  X x1(1);
+  PY p(2);                      
+
+  assert(*p==2);
+
+  p = x1;
+
+  assert(*p==1);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.fail.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_convertible_propagate_const.fail.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const& operator=(U&& u); // won't bind to propagate_const
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> PX;
+  typedef propagate_const<Y> PY;
+
+  PX px2(2);
+  PY py1(1);
+
+  py1=px2; // won't compile
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/assign_element_type.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const& propagate_const::operator=(U&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  X x1(1);
+  P p(2);
+
+  assert(*p==2);
+
+  p = x1;
+
+  assert(*p==1);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const& propagate_const::operator=(propagate_const<U>&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1(1);
+  P p2(2);
+
+  p2=std::move(p1);
+
+  assert(*p2==1);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible.pass.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const& propagate_const::operator=(propagate_const<U>&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> PX;
+  typedef propagate_const<MoveConstructableFromX> PY;
+
+  PX px2(2);
+  PY py1(1);
+
+  py1=std::move(px2);
+
+  assert(*py1==2);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.assignment/move_assign_convertible_propagate_const.pass.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> PX;
+  typedef propagate_const<MoveConstructableFromX> PY;
+
+  PX px2(2);
+  PY py1(1);
+
+  py1=std::move(px2); 
+
+  assert(*py1==2);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.fail.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.explicit.ctor.fail.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<Y> P;
+
+void f(const P& p)
+{      
+}
+
+int main() {
+  f(X(2)); // will not compile
+}
+
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_element_type.non-explicit.ctor.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<CopyConstructableFromX> P;
+
+void f(const P& p)
+{
+  assert(*p==2);
+}
+
+int main() {
+  f(X(2));
+}
+
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.fail.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.copy_ctor.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const& operator(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<Y> PY;
+typedef propagate_const<X> PX;
+
+int main() {
+  PX px(1);
+  PY py(px); // will not compile
+}
+
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.fail.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.explicit.move_ctor.fail.cpp
@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<Y> PY;
+typedef propagate_const<X> PX;
+
+void f(const PY&)
+{
+}
+
+int main() {
+  PX px(1);
+  f(std::move(px)); // will not compile
+}
+
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/convertible_propagate_const.move_ctor.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> constexpr propagate_const& operator(propagate_const<_Up>&& pu);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<MoveConstructableFromX> PY;
+typedef propagate_const<X> PX;
+
+int main() {
+  PX px(1);
+  PY py(std::move(px));
+
+  assert(*py==1);
+}
+
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.fail.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/copy_ctor.fail.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// propagate_const(const propagate_const&)=delete;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1(2);
+  P p2(p1); // will not compile
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.fail.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.explicit.ctor.fail.cpp
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const(U&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<ExplicitX> P;
+
+void f(const P&)
+{
+}
+
+int main() {
+  f(2); // will not compile
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/element_type.non-explicit.ctor.pass.cpp
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class U> propagate_const(U&&);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+typedef propagate_const<X> P;
+
+void f(const P&)
+{
+}
+
+int main() {
+  f(2); // will not compile
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.ctors/move_ctor.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// propagate_const(propagate_const&&)=default;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1(2);
+  P p2(std::move(p1)); // will not compile
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/dereference.pass.cpp
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// element_type& propagate_const::operator*();
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p(1);
+  
+  *p = 2;
+  assert(*p==2);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/get.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// element_type* propagate_const::get();
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p(1);
+
+  *p.get() = 2;
+
+  assert(*(p.get())==2);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/op_arrow.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// element_type* propagate_const::operator->();
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p(1);
+
+  *(p.operator->()) = 2;
+
+  assert(*(p.operator->())==2);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.fail.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// propagate_const::operator element_type*();
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p(1);
+
+  int* ptr_1 = p; // will not compile
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.non-const_observers/operator_element_type_ptr.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// propagate_const::operator element_type*();
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<XWithImplicitIntStarConversion> P;
+
+  P p(1);
+
+  int* ptr_1 = p;
+  
+  assert(*ptr_1==1);
+
+  *ptr_1 = 2;
+
+  assert(*ptr_1==2);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/dereference.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// const element_type& propagate_const::operator*() const;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p(1);
+
+  assert(*p==1);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/get.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// const element_type* propagate_const::get() const;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p(1);
+
+  assert(*(p.get())==1);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/op_arrow.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// const element_type* propagate_const::operator->() const;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p(1);
+
+  assert(*(p.operator->())==1);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.fail.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// propagate_const::operator const element_type*() const;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p(1);
+
+  const int* ptr_1 = p; // will not compile
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/propagate_const.observers/operator_element_type_ptr.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// propagate_const::operator const element_type*() const;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+int main() {
+
+  typedef propagate_const<XWithImplicitConstIntStarConversion> P;
+
+  P p(1);
+
+  const int* ptr_1 = p;
+  
+  assert(*ptr_1==1);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.class/swap.pass.cpp
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr void propagate_const::swap(propagate_const<T>& x);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+void swap(X& x, X& y)
+{
+  std::swap(x.i_,y.i_);
+}
+
+int main() {
+  typedef propagate_const<X> P;
+  
+  P p1_1(1);
+  P p2_2(2);
+
+  assert(*p1_1 == 1);
+  assert(*p2_2 == 2);
+  
+  p1_1.swap(p2_2);
+
+  assert(*p1_1 == 2);
+  assert(*p2_2 == 1);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/hash.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+namespace std {
+template <> struct hash<X>
+{
+  typedef X first_argument_type;
+
+  size_t operator()(const first_argument_type& x1) const
+  {
+    return 99;
+  }
+
+};
+} // namespace std
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p(1);
+
+  auto h = std::hash<P>();
+
+  assert(h(p)==99);
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/equal_to.pass.cpp
@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+namespace std {
+template <> struct equal_to<X>
+{
+  typedef X first_argument_type;
+  typedef X second_argument_type;
+
+  constexpr bool operator()(const first_argument_type& x1, const second_argument_type& x2) const
+  {
+    return equal_to<int>()(x1.i_,x2.i_);
+  }
+};
+} // namespace std
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::equal_to<P>();
+
+  assert(c(p1_1,p2_1));
+  assert(!c(p1_1,p3_2));
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater.pass.cpp
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+namespace std {
+template <> struct greater<X>
+{
+  typedef X first_argument_type;
+  typedef X second_argument_type;
+
+  constexpr bool operator()(const first_argument_type& x1, const second_argument_type& x2) const
+  {
+    return greater<int>()(x1.i_,x2.i_);
+  }
+};
+} // namespace std
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::greater<P>();
+
+  assert(!c(p1_1,p2_1));
+  assert(!c(p2_1,p1_1));
+  assert(!c(p1_1,p3_2));
+  assert(c(p3_2,p1_1));
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/greater_equal.pass.cpp
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+namespace std {
+template <> struct greater_equal<X>
+{
+  typedef X first_argument_type;
+  typedef X second_argument_type;
+
+  constexpr bool operator()(const first_argument_type& x1, const second_argument_type& x2) const
+  {
+    return greater_equal<int>()(x1.i_,x2.i_);
+  }
+};
+} // namespace std
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::greater_equal<P>();
+
+  assert(c(p1_1,p2_1));
+  assert(c(p2_1,p1_1));
+  assert(!c(p1_1,p3_2));
+  assert(c(p3_2,p1_1));
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less.pass.cpp
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+namespace std {
+template <> struct less<X>
+{
+  typedef X first_argument_type;
+  typedef X second_argument_type;
+
+  constexpr bool operator()(const first_argument_type& x1, const second_argument_type& x2) const
+  {
+    return less<int>()(x1.i_,x2.i_);
+  }
+};
+} // namespace std
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::less<P>();
+
+  assert(!c(p1_1,p2_1));
+  assert(!c(p2_1,p1_1));
+  assert(c(p1_1,p3_2));
+  assert(!c(p3_2,p1_1));
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/less_equal.pass.cpp
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+namespace std {
+template <> struct less_equal<X>
+{
+  typedef X first_argument_type;
+  typedef X second_argument_type;
+
+  constexpr bool operator()(const first_argument_type& x1, const second_argument_type& x2) const
+  {
+    return less_equal<int>()(x1.i_,x2.i_);
+  }
+};
+} // namespace std
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::less_equal<P>();
+
+  assert(c(p1_1,p2_1));
+  assert(c(p2_1,p1_1));
+  assert(c(p1_1,p3_2));
+  assert(!c(p3_2,p1_1));
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.comparison_function_objects/not_equal_to.pass.cpp
@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+namespace std {
+template <> struct not_equal_to<X>
+{
+  typedef X first_argument_type;
+  typedef X second_argument_type;
+
+  constexpr bool operator()(const first_argument_type& x1, const second_argument_type& x2) const
+  {
+    return not_equal_to<int>()(x1.i_,x2.i_);
+  }
+};
+} // namespace std
+
+int main() {
+
+  typedef propagate_const<X> P;
+
+  P p1_1(1);
+  P p2_1(1);
+  P p3_2(2);
+
+  auto c = std::not_equal_to<P>();
+
+  assert(!c(p1_1,p2_1));
+  assert(c(p1_1,p3_2));
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/equal.pass.cpp
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator==(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator==(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator==(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+using std::nullptr_t;
+
+constexpr bool operator==(const X &lhs, const X &rhs) {
+  return lhs.i_ == rhs.i_;
+}
+
+constexpr bool operator==(const X &, const nullptr_t &) {
+  return false;
+}
+
+constexpr bool operator==(const nullptr_t &, const X &) {
+  return false;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(x1_1 == x1_1, "");
+  static_assert(x1_1 == x2_1, "");
+  static_assert(!(x1_1 == x3_2), "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(p1_1 == p1_1, "");
+  static_assert(p1_1 == p2_1, "");
+  static_assert(!(p1_1 == p3_2), "");
+
+  static_assert(x1_1 == p1_1, "");
+  static_assert(!(x1_1 == p3_2), "");
+
+  static_assert(p1_1 == x1_1, "");
+  static_assert(!(p1_1 == x3_2), "");
+
+  static_assert(!(p1_1==nullptr),"");
+  static_assert(!(nullptr==p1_1),"");
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_equal.pass.cpp
@@ -0,0 +1,54 @@
+//>==---------------------------------------------------------------------->==//
+//
+//                     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.
+//
+//>==---------------------------------------------------------------------->==//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator>=(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator>=(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator>=(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator>=(const X &lhs, const X &rhs) {
+  return lhs.i_ >= rhs.i_;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(x1_1 >= x2_1, "");
+  static_assert(!(x1_1 >= x3_2), "");
+  static_assert(x3_2 >= x1_1, "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(p1_1 >= p2_1, "");
+  static_assert(!(p1_1 >= p3_2), "");
+  static_assert(p3_2 >= p1_1, "");
+  
+  static_assert(p1_1 >= x2_1, "");
+  static_assert(!(p1_1 >= x3_2), "");
+  static_assert(p3_2 >= x1_1, "");
+  
+  static_assert(x1_1 >= p2_1, "");
+  static_assert(!(x1_1 >= p3_2), "");
+  static_assert(x3_2 >= p1_1, "");
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/greater_than.pass.cpp
@@ -0,0 +1,50 @@
+//>=---------------------------------------------------------------------->=//
+//
+//                     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.
+//
+//>=---------------------------------------------------------------------->=//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator>(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator>(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator>(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator>(const X &lhs, const X &rhs) {
+  return lhs.i_ > rhs.i_;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(!(x1_1 > x2_1), "");
+  static_assert(x3_2 > x1_1, "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(!(p1_1 > p2_1), "");
+  static_assert(p3_2 > p1_1, "");
+  
+  static_assert(!(p1_1 > x2_1), "");
+  static_assert(p3_2 > x1_1, "");
+  
+  static_assert(!(x1_1 > p2_1), "");
+  static_assert(x3_2 > p1_1, "");
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_equal.pass.cpp
@@ -0,0 +1,55 @@
+//<==----------------------------------------------------------------------<==//
+//
+//                     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.
+//
+//<==----------------------------------------------------------------------<==//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator<=(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator<=(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator<=(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator<=(const X &lhs, const X &rhs) {
+  return lhs.i_ <= rhs.i_;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(x1_1 <= x2_1, "");
+  static_assert(x1_1 <= x3_2, "");
+  static_assert(!(x3_2 <= x1_1), "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+  
+  static_assert(p1_1 <= p2_1, "");
+  static_assert(p1_1 <= p3_2, "");
+  static_assert(!(p3_2 <= p1_1), "");
+
+  static_assert(p1_1 <= x2_1, "");
+  static_assert(p1_1 <= x3_2, "");
+  static_assert(!(p3_2 <= x1_1), "");
+
+  static_assert(x1_1 <= p2_1, "");
+  static_assert(x1_1 <= p3_2, "");
+  static_assert(!(x3_2 <= p1_1), "");
+
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/less_than.pass.cpp
@@ -0,0 +1,50 @@
+//<=----------------------------------------------------------------------<=//
+//
+//                     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.
+//
+//<=----------------------------------------------------------------------<=//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator<(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator<(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator<(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+constexpr bool operator<(const X &lhs, const X &rhs) {
+  return lhs.i_ < rhs.i_;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(!(x1_1 < x2_1), "");
+  static_assert(x1_1 < x3_2, "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(!(p1_1 < p2_1), "");
+  static_assert(p1_1 < p3_2, "");
+
+  static_assert(!(x1_1 < p1_1), "");
+  static_assert(x1_1 < p3_2, "");
+
+  static_assert(!(p1_1 < x1_1), "");
+  static_assert(p1_1 < x3_2, "");
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/propagate_const.relops/not_equal.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr bool operator!=(const propagate_const<T>& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator!=(const T& x, const propagate_const<T>& y);
+// template <class T> constexpr bool operator!=(const propagate_const<T>& x, const T& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+using std::nullptr_t;
+
+constexpr bool operator!=(const X &lhs, const X &rhs) {
+  return lhs.i_ != rhs.i_;
+}
+
+constexpr bool operator!=(const X &, const nullptr_t &) {
+  return true;
+}
+
+constexpr bool operator!=(const nullptr_t &, const X &) {
+  return true;
+}
+
+int main() {
+  constexpr X x1_1(1);
+  constexpr X x2_1(1);
+  constexpr X x3_2(2);
+
+  static_assert(!(x1_1 != x2_1), "");
+  static_assert(x1_1 != x3_2, "");
+
+  typedef propagate_const<X> P;
+
+  constexpr P p1_1(1);
+  constexpr P p2_1(1);
+  constexpr P p3_2(2);
+
+  static_assert(!(p1_1 != p2_1), "");
+  static_assert(p1_1 != p3_2, "");
+
+  static_assert(!(x1_1 != p1_1), "");
+  static_assert(x1_1 != p3_2, "");
+
+  static_assert(!(p1_1 != x1_1), "");
+  static_assert(p1_1 != x3_2, "");
+  
+  static_assert(p1_1!=nullptr,"");
+  static_assert(nullptr!=p1_1,"");
+}
Index: test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/utilities/propagate_const/propagate_const.nonmembers/swap.pass.cpp
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// <propagate_const>
+
+// template <class T> constexpr void swap(propagate_const<T>& x, propagate_const<T>& y);
+
+#include <experimental/propagate_const>
+#include "propagate_const_helpers.h"
+#include <cassert>
+
+using std::experimental::propagate_const;
+
+void swap(X& x, X& y)
+{
+  std::swap(x.i_,y.i_);
+}
+
+int main() {
+  typedef propagate_const<X> P;
+  
+  P p1_1(1);
+  P p2_2(2);
+
+  assert(*p1_1 == 1);
+  assert(*p2_2 == 2);
+  
+  swap(p1_1, p2_2);
+
+  assert(*p1_1 == 2);
+  assert(*p2_2 == 1);
+}
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp
@@ -11,7 +11,7 @@
 
 // back_insert_iterator
 
-// requires CopyConstructible<Cont::value_type>
+// requires CopyConstructable<Cont::value_type>
 //   back_insert_iterator<Cont>&
 //   operator=(const Cont::value_type& value);
 
Index: test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp
@@ -11,7 +11,7 @@
 
 // back_insert_iterator
 
-// requires CopyConstructible<Cont::value_type>
+// requires CopyConstructable<Cont::value_type>
 //   back_insert_iterator<Cont>&
 //   operator=(Cont::value_type&& value);
 
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/lv_value.pass.cpp
@@ -11,7 +11,7 @@
 
 // insert_iterator
 
-// requires CopyConstructible<Cont::value_type>
+// requires CopyConstructable<Cont::value_type>
 //   insert_iterator<Cont>&
 //   operator=(const Cont::value_type& value);
 
Index: test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
===================================================================
--- test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
+++ test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op=/rv_value.pass.cpp
@@ -11,7 +11,7 @@
 
 // insert_iterator
 
-// requires CopyConstructible<Cont::value_type>
+// requires CopyConstructable<Cont::value_type>
 //   insert_iterator<Cont>&
 //   operator=(const Cont::value_type& value);
 
Index: test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
+++ test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp
@@ -9,7 +9,7 @@
 
 // <numeric>
 
-// template <InputIterator Iter, MoveConstructible T>
+// template <InputIterator Iter, MoveConstructable T>
 //   requires HasPlus<T, Iter::reference>
 //         && HasAssign<T, HasPlus<T, Iter::reference>::result_type>
 //   T
Index: test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
+++ test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp
@@ -9,10 +9,10 @@
 
 // <numeric>
 
-// template <InputIterator Iter, MoveConstructible T,
+// template <InputIterator Iter, MoveConstructable T,
 //           Callable<auto, const T&, Iter::reference> BinaryOperation>
 //   requires HasAssign<T, BinaryOperation::result_type>
-//         && CopyConstructible<BinaryOperation>
+//         && CopyConstructable<BinaryOperation>
 //   T
 //   accumulate(Iter first, Iter last, T init, BinaryOperation binary_op);
 
Index: test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
+++ test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp
@@ -12,7 +12,7 @@
 // template <InputIterator InIter,
 //           OutputIterator<auto, const InIter::value_type&> OutIter>
 //   requires HasMinus<InIter::value_type, InIter::value_type>
-//         && Constructible<InIter::value_type, InIter::reference>
+//         && Constructable<InIter::value_type, InIter::reference>
 //         && OutputIterator<OutIter,
 //                           HasMinus<InIter::value_type, InIter::value_type>::result_type>
 //         && MoveAssignable<InIter::value_type>
Index: test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
+++ test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp
@@ -12,10 +12,10 @@
 // template <InputIterator InIter,
 //           OutputIterator<auto, const InIter::value_type&> OutIter,
 //           Callable<auto, const InIter::value_type&, const InIter::value_type&> BinaryOperation>
-//   requires Constructible<InIter::value_type, InIter::reference>
+//   requires Constructable<InIter::value_type, InIter::reference>
 //         && OutputIterator<OutIter, BinaryOperation::result_type>
 //         && MoveAssignable<InIter::value_type>
-//         && CopyConstructible<BinaryOperation>
+//         && CopyConstructable<BinaryOperation>
 //   OutIter
 //   adjacent_difference(InIter first, InIter last, OutIter result, BinaryOperation binary_op);
 
Index: test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
+++ test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp
@@ -9,7 +9,7 @@
 
 // <numeric>
 
-// template <InputIterator Iter1, InputIterator Iter2, MoveConstructible T>
+// template <InputIterator Iter1, InputIterator Iter2, MoveConstructable T>
 //   requires HasMultiply<Iter1::reference, Iter2::reference>
 //         && HasPlus<T, HasMultiply<Iter1::reference, Iter2::reference>::result_type>
 //         && HasAssign<T,
Index: test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
+++ test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp
@@ -9,13 +9,13 @@
 
 // <numeric>
 
-// template <InputIterator Iter1, InputIterator Iter2, MoveConstructible T,
+// template <InputIterator Iter1, InputIterator Iter2, MoveConstructable T,
 //           class BinaryOperation1,
 //           Callable<auto, Iter1::reference, Iter2::reference> BinaryOperation2>
 //   requires Callable<BinaryOperation1, const T&, BinaryOperation2::result_type>
 //         && HasAssign<T, BinaryOperation1::result_type>
-//         && CopyConstructible<BinaryOperation1>
-//         && CopyConstructible<BinaryOperation2>
+//         && CopyConstructable<BinaryOperation1>
+//         && CopyConstructable<BinaryOperation2>
 //   T
 //   inner_product(Iter1 first1, Iter1 last1, Iter2 first2,
 //                 T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
Index: test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
+++ test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp
@@ -13,7 +13,7 @@
 //   requires HasPlus<InIter::value_type, InIter::reference>
 //         && HasAssign<InIter::value_type,
 //                      HasPlus<InIter::value_type, InIter::reference>::result_type>
-//         && Constructible<InIter::value_type, InIter::reference>
+//         && Constructable<InIter::value_type, InIter::reference>
 //   OutIter
 //   partial_sum(InIter first, InIter last, OutIter result);
 
Index: test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
+++ test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp
@@ -13,8 +13,8 @@
 //          OutputIterator<auto, const InIter::value_type&> OutIter,
 //          Callable<auto, const InIter::value_type&, InIter::reference> BinaryOperation>
 //   requires HasAssign<InIter::value_type, BinaryOperation::result_type>
-//         && Constructible<InIter::value_type, InIter::reference>
-//         && CopyConstructible<BinaryOperation>
+//         && Constructable<InIter::value_type, InIter::reference>
+//         && CopyConstructable<BinaryOperation>
 //   OutIter
 //   partial_sum(InIter first, InIter last, OutIter result, BinaryOperation binary_op);
 
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/copy.pass.cpp
@@ -11,9 +11,9 @@
 
 // <functional>
 
-// template<CopyConstructible Fn, CopyConstructible... Types>
+// template<CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
-// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
+// template<Returnable R, CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
 
 // http://llvm.org/bugs/show_bug.cgi?id=16385
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_function_object.pass.cpp
@@ -11,9 +11,9 @@
 
 // <functional>
 
-// template<CopyConstructible Fn, CopyConstructible... Types>
+// template<CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
-// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
+// template<Returnable R, CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
 
 // http://llvm.org/bugs/show_bug.cgi?id=22003
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_int_0.pass.cpp
@@ -11,9 +11,9 @@
 
 // <functional>
 
-// template<CopyConstructible Fn, CopyConstructible... Types>
+// template<CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
-// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
+// template<Returnable R, CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
 
 #include <functional>
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_lvalue.pass.cpp
@@ -11,9 +11,9 @@
 
 // <functional>
 
-// template<CopyConstructible Fn, CopyConstructible... Types>
+// template<CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
-// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
+// template<Returnable R, CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
 
 #include <stdio.h>
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_rvalue.pass.cpp
@@ -11,9 +11,9 @@
 
 // <functional>
 
-// template<CopyConstructible Fn, CopyConstructible... Types>
+// template<CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
-// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
+// template<Returnable R, CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
 
 #include <stdio.h>
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/invoke_void_0.pass.cpp
@@ -11,9 +11,9 @@
 
 // <functional>
 
-// template<CopyConstructible Fn, CopyConstructible... Types>
+// template<CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
-// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
+// template<Returnable R, CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
 
 #include <functional>
Index: test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
===================================================================
--- test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
+++ test/std/utilities/function.objects/bind/func.bind/func.bind.bind/nested.pass.cpp
@@ -11,9 +11,9 @@
 
 // <functional>
 
-// template<CopyConstructible Fn, CopyConstructible... Types>
+// template<CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
-// template<Returnable R, CopyConstructible Fn, CopyConstructible... Types>
+// template<Returnable R, CopyConstructable Fn, CopyConstructable... Types>
 //   unspecified bind(Fn, Types...);
 
 // http://llvm.org/bugs/show_bug.cgi?id=16343
Index: test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
+++ test/std/utilities/function.objects/func.memfn/member_function.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template<Returnable R, class T, CopyConstructible... Args>
+// template<Returnable R, class T, CopyConstructable... Args>
 //   unspecified mem_fn(R (T::* pm)(Args...));
 
 #include <functional>
Index: test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
+++ test/std/utilities/function.objects/func.memfn/member_function_const.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template<Returnable R, class T, CopyConstructible... Args>
+// template<Returnable R, class T, CopyConstructable... Args>
 //   unspecified mem_fn(R (T::* pm)(Args...) const);
 
 #include <functional>
Index: test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
+++ test/std/utilities/function.objects/func.memfn/member_function_const_volatile.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template<Returnable R, class T, CopyConstructible... Args>
+// template<Returnable R, class T, CopyConstructable... Args>
 //   unspecified mem_fn(R (T::* pm)(Args...) const volatile);
 
 #include <functional>
Index: test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
+++ test/std/utilities/function.objects/func.memfn/member_function_volatile.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template<Returnable R, class T, CopyConstructible... Args>
+// template<Returnable R, class T, CopyConstructable... Args>
 //   unspecified mem_fn(R (T::* pm)(Args...) volatile);
 
 #include <functional>
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp
@@ -11,7 +11,7 @@
 
 // class function<R(ArgTypes...)>
 
-// template <MoveConstructible  R, MoveConstructible ... ArgTypes>
+// template <MoveConstructable  R, MoveConstructable ... ArgTypes>
 //   void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
 
 
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp
@@ -12,7 +12,7 @@
 // class function<R(ArgTypes...)>
 
 // template<class F>
-//   requires CopyConstructible<F> && Callable<F, ArgTypes..>
+//   requires CopyConstructable<F> && Callable<F, ArgTypes..>
 //         && Convertible<Callable<F, ArgTypes...>::result_type
 //   operator=(F f);
 
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp
@@ -11,16 +11,16 @@
 
 // class function<R(ArgTypes...)>
 
-// template <MoveConstructible R, MoveConstructible ... ArgTypes>
+// template <MoveConstructable R, MoveConstructable ... ArgTypes>
 //   bool operator==(const function<R(ArgTypes...)>&, nullptr_t);
 //
-// template <MoveConstructible R, MoveConstructible ... ArgTypes>
+// template <MoveConstructable R, MoveConstructable ... ArgTypes>
 //   bool operator==(nullptr_t, const function<R(ArgTypes...)>&);
 //
-// template <MoveConstructible R, MoveConstructible ... ArgTypes>
+// template <MoveConstructable R, MoveConstructable ... ArgTypes>
 //   bool operator!=(const function<R(ArgTypes...)>&, nullptr_t);
 //
-// template <MoveConstructible  R, MoveConstructible ... ArgTypes>
+// template <MoveConstructable  R, MoveConstructable ... ArgTypes>
 //   bool operator!=(nullptr_t, const function<R(ArgTypes...)>&);
 
 #include <functional>
Index: test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
===================================================================
--- test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
+++ test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp
@@ -9,7 +9,7 @@
 
 // <functional>
 
-// template<Returnable R, CopyConstructible... ArgTypes>
+// template<Returnable R, CopyConstructable... ArgTypes>
 // class function<R(ArgTypes...)> {
 // public:
 //   typedef R result_type;
Index: test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
===================================================================
--- test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
+++ test/std/utilities/function.objects/refwrap/type_properties.pass.cpp
@@ -12,7 +12,7 @@
 // reference_wrapper
 
 // Test that reference wrapper meets the requirements of TriviallyCopyable,
-// CopyConstructible and CopyAssignable.
+// CopyConstructable and CopyAssignable.
 
 #include <functional>
 #include <type_traits>
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/move01.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/move01.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/move01.pass.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr move assignment
 
-// test move assignment.  Should only require a MoveConstructible deleter, or if
+// test move assignment.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 
 #include <memory>
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move01.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move01.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move01.pass.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr move ctor
 
-// test move ctor.  Should only require a MoveConstructible deleter, or if
+// test move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 
 #include <memory>
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move02.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move02.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move02.pass.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr move ctor
 
-// test move ctor.  Should only require a MoveConstructible deleter, or if
+// test move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 
 #include <memory>
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert01.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert01.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert01.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert02.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert02.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert02.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert03.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert03.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert03.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert04.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert04.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert04.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // implicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert05.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert05.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert05.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Implicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert06.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert06.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert06.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert07.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert07.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert07.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert08.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert08.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert08.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert09.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert09.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert09.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert10.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert10.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert10.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // implicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert11.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert11.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert11.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Implicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert12.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert12.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert12.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert13.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert13.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert13.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert14.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert14.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert14.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert15.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert15.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert15.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert16.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert16.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert16.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // implicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert17.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert17.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert17.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Implicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert18.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert18.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/move_convert18.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter01.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter01.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter01.pass.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr(pointer, deleter) ctor
 
-// unique_ptr(pointer, deleter()) only requires MoveConstructible deleter
+// unique_ptr(pointer, deleter()) only requires MoveConstructable deleter
 
 #include <memory>
 #include <cassert>
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter02.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter02.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter02.pass.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr(pointer, deleter) ctor
 
-// unique_ptr(pointer, d) requires CopyConstructible deleter
+// unique_ptr(pointer, d) requires CopyConstructable deleter
 
 #include <memory>
 #include <cassert>
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter03.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter03.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter03.pass.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr(pointer, deleter) ctor
 
-// unique_ptr<T[], D&>(pointer, d) does not requires CopyConstructible deleter
+// unique_ptr<T[], D&>(pointer, d) does not requires CopyConstructable deleter
 
 #include <memory>
 #include <cassert>
Index: test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter04.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter04.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.runtime/unique.ptr.runtime.ctor/pointer_deleter04.pass.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr(pointer, deleter) ctor
 
-// unique_ptr<T[], const D&>(pointer, d) does not requires CopyConstructible deleter
+// unique_ptr<T[], const D&>(pointer, d) does not requires CopyConstructable deleter
 
 #include <memory>
 #include <cassert>
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.asgn/move01.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.asgn/move01.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.asgn/move01.pass.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr move assignment
 
-// test move assignment.  Should only require a MoveConstructible deleter, or if
+// test move assignment.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 
 #include <memory>
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move.pass.cpp
@@ -24,7 +24,7 @@
 //
 // Concerns
 //   1 The moved from pointer is empty and the new pointer stores the old value.
-//   2 The only requirement on the deleter is that it is MoveConstructible
+//   2 The only requirement on the deleter is that it is MoveConstructable
 //     or a reference.
 //   3 The constructor works for explicitly moved values (ie std::move(x))
 //   4 The constructor works for true temporaries (ie a return value)
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert.pass.cpp
@@ -26,7 +26,7 @@
 
 #include "../../deleter.h"
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert02.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert02.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert02.fail.cpp
@@ -13,7 +13,7 @@
 
 // Test unique_ptr converting move ctor
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert03.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert03.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert03.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert04.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert04.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert04.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // implicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert05.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert05.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert05.fail.cpp
@@ -19,7 +19,7 @@
 
 #include "../../deleter.h"
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Implicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert06.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert06.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert06.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert07.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert07.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert07.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert08.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert08.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert08.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert09.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert09.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert09.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert10.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert10.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert10.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // implicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert11.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert11.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert11.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Implicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert12.fail.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert12.fail.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/move_convert12.fail.cpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <cassert>
 
-// test converting move ctor.  Should only require a MoveConstructible deleter, or if
+// test converting move ctor.  Should only require a MoveConstructable deleter, or if
 //    deleter is a reference, not even that.
 // Explicit version
 
Index: test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/pointer_deleter.pass.cpp
===================================================================
--- test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/pointer_deleter.pass.cpp
+++ test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/pointer_deleter.pass.cpp
@@ -15,10 +15,10 @@
 // TESTING unique_ptr(pointer, deleter)
 //
 // Concerns:
-//   1 unique_ptr(pointer, deleter&&) only requires a MoveConstructible deleter.
-//   2 unique_ptr(pointer, deleter&) requires a CopyConstructible deleter.
-//   3 unique_ptr<T, D&>(pointer, deleter) does not require a CopyConstructible deleter.
-//   4 unique_ptr<T, D const&>(pointer, deleter) does not require a CopyConstructible deleter.
+//   1 unique_ptr(pointer, deleter&&) only requires a MoveConstructable deleter.
+//   2 unique_ptr(pointer, deleter&) requires a CopyConstructable deleter.
+//   3 unique_ptr<T, D&>(pointer, deleter) does not require a CopyConstructable deleter.
+//   4 unique_ptr<T, D const&>(pointer, deleter) does not require a CopyConstructable deleter.
 //   5 unique_ptr(pointer, deleter) should work for derived pointers.
 //   6 unique_ptr(pointer, deleter) should work with function pointers.
 //   7 unique_ptr<void> should work.
@@ -59,7 +59,7 @@
 
 int main()
 {
-    { // MoveConstructible deleter (C-1)
+    { // MoveConstructable deleter (C-1)
         A* p = new A;
         assert(A::count == 1);
         std::unique_ptr<A, Deleter<A> > s(p, Deleter<A>(5));
@@ -67,7 +67,7 @@
         assert(s.get_deleter().state() == 5);
     }
     assert(A::count == 0);
-    { // CopyConstructible deleter (C-2)
+    { // CopyConstructable deleter (C-2)
         A* p = new A;
         assert(A::count == 1);
         CopyDeleter<A> d(5);
Index: test/std/utilities/utility/utility.swap/swap.pass.cpp
===================================================================
--- test/std/utilities/utility/utility.swap/swap.pass.cpp
+++ test/std/utilities/utility/utility.swap/swap.pass.cpp
@@ -10,7 +10,7 @@
 // <utility>
 
 // template<class T>
-//   requires MoveAssignable<T> && MoveConstructible<T>
+//   requires MoveAssignable<T> && MoveConstructable<T>
 //   void
 //   swap(T& a, T& b);
 
Index: test/support/propagate_const_helpers.h
===================================================================
--- /dev/null
+++ test/support/propagate_const_helpers.h
@@ -0,0 +1,119 @@
+ // A lightweight class, with pointer-like methods, that contains an int
+struct X
+{
+    int i_;
+
+    const int &operator*() const { return i_; }
+    int &operator*() { return i_; }
+    const int *get() const { return &i_; }
+    int *get() { return &i_; }
+    const int *operator->() const { return &i_; }
+    int *operator->() { return &i_; }
+
+    constexpr X(int i) : i_(i) {}
+};
+
+struct XWithImplicitIntStarConversion
+{
+    int i_;
+
+    const int &operator*() const { return i_; }
+    int &operator*() { return i_; }
+    const int *get() const { return &i_; }
+    int *get() { return &i_; }
+    const int *operator->() const { return &i_; }
+    int *operator->() { return &i_; }
+    operator int* () { return &i_; }
+
+    constexpr XWithImplicitIntStarConversion(int i) : i_(i) {}
+};
+
+struct XWithImplicitConstIntStarConversion
+{
+    int i_;
+
+    const int &operator*() const { return i_; }
+    int &operator*() { return i_; }
+    const int *get() const { return &i_; }
+    int *get() { return &i_; }
+    const int *operator->() const { return &i_; }
+    int *operator->() { return &i_; }
+    operator int* () { return &i_; }
+
+    constexpr XWithImplicitConstIntStarConversion(int i) : i_(i) {}
+};
+
+struct ExplicitX
+{
+    int i_;
+
+    const int &operator*() const { return i_; }
+    int &operator*() { return i_; }
+    const int *get() const { return &i_; }
+    int *get() { return &i_; }
+    const int *operator->() const { return &i_; }
+    int *operator->() { return &i_; }
+
+    constexpr explicit ExplicitX(int i) : i_(i) {}
+};
+
+struct MoveConstructableFromX
+{
+    int i_;
+
+    const int &operator*() const { return i_; }
+    int &operator*() { return i_; }
+    const int *get() const { return &i_; }
+    int *get() { return &i_; }
+    const int *operator->() const { return &i_; }
+    int *operator->() { return &i_; }
+
+    constexpr MoveConstructableFromX(int i) : i_(i) {}
+    constexpr MoveConstructableFromX(X&& x) : i_(x.i_) {}
+};
+
+struct ExplicitMoveConstructableFromX
+{
+    int i_;
+
+    const int &operator*() const { return i_; }
+    int &operator*() { return i_; }
+    const int *get() const { return &i_; }
+    int *get() { return &i_; }
+    const int *operator->() const { return &i_; }
+    int *operator->() { return &i_; }
+
+    constexpr ExplicitMoveConstructableFromX(int i) : i_(i) {}
+    constexpr explicit ExplicitMoveConstructableFromX(X&& x) : i_(x.i_) {}
+};
+
+struct CopyConstructableFromX
+{
+    int i_;
+
+    const int &operator*() const { return i_; }
+    int &operator*() { return i_; }
+    const int *get() const { return &i_; }
+    int *get() { return &i_; }
+    const int *operator->() const { return &i_; }
+    int *operator->() { return &i_; }
+
+    constexpr CopyConstructableFromX(int i) : i_(i) {}
+    constexpr CopyConstructableFromX(const X& x) : i_(x.i_) {}
+};
+
+struct ExplicitCopyConstructableFromX
+{
+    int i_;
+
+    const int &operator*() const { return i_; }
+    int &operator*() { return i_; }
+    const int *get() const { return &i_; }
+    int *get() { return &i_; }
+    const int *operator->() const { return &i_; }
+    int *operator->() { return &i_; }
+
+    constexpr ExplicitCopyConstructableFromX(int i) : i_(i) {}
+    constexpr explicit ExplicitCopyConstructableFromX(const X& x) : i_(x.i_) {}
+};
+