[libc++] Addresses LWG3764.

[Mordante]

Summary

LWG3764 reference_wrapper::operator() should propagate noexcept

As drive-by adds constexpr to the synopsis, since it has already been
implemented.

libcxx/docs/Status/Cxx2bIssues.csv

 "`3753 <https://wg21.link/LWG3753>`__","Clarify entity vs. freestanding entity", "November 2022","","",""
 "`3754 <https://wg21.link/LWG3754>`__","Class template expected synopsis contains declarations that do not match the detailed description", "November 2022","|Nothing to do|","",""
 "`3755 <https://wg21.link/LWG3755>`__","``tuple-for-each`` can call ``user-defined`` ``operator,``", "November 2022","","",""
 "`3757 <https://wg21.link/LWG3757>`__","What's the effect of ``std::forward_like<void>(x)``?", "November 2022","","",""
 "`3759 <https://wg21.link/LWG3759>`__","``ranges::rotate_copy`` should use ``std::move``", "November 2022","","","|ranges|"
 "`3760 <https://wg21.link/LWG3760>`__","``cartesian_product_view::iterator``'s ``parent_`` is never valid", "November 2022","","","|ranges|"
 "`3761 <https://wg21.link/LWG3761>`__","``cartesian_product_view::iterator::operator-`` should pass by reference", "November 2022","","","|ranges|"
 "`3762 <https://wg21.link/LWG3762>`__","``generator::iterator::operator==`` should pass by reference", "November 2022","","",""
-"`3764 <https://wg21.link/LWG3764>`__","``reference_wrapper::operator()`` should propagate noexcept", "November 2022","","",""
+"`3764 <https://wg21.link/LWG3764>`__","``reference_wrapper::operator()`` should propagate noexcept", "November 2022","17.0","|Complete|",""
 "`3765 <https://wg21.link/LWG3765>`__","``const_sentinel`` should be constrained", "November 2022","","","|ranges|"
 "`3766 <https://wg21.link/LWG3766>`__","``view_interface::cbegin`` is underconstrained", "November 2022","","","|ranges|"
 "`3770 <https://wg21.link/LWG3770>`__","``const_sentinel_t`` is missing", "November 2022","","","|ranges|"
 "`3773 <https://wg21.link/LWG3773>`__","``views::zip_transform`` still requires ``F`` to be ``copy_constructible`` when empty pack", "November 2022","","","|ranges|"
 "`3774 <https://wg21.link/LWG3774>`__","``<flat_set>`` should include ``<compare>``", "November 2022","","","|flat_containers|"
 "`3775 <https://wg21.link/LWG3775>`__","Broken dependencies in the ``Cpp17Allocator`` requirements", "November 2022","","",""
 "`3778 <https://wg21.link/LWG3778>`__","``vector<bool>`` missing exception specifications", "November 2022","","",""
 "`3781 <https://wg21.link/LWG3781>`__","The exposition-only alias templates ``cont-key-type`` and ``cont-mapped-type`` should be removed", "November 2022","","",""

libcxx/include/__functional/reference_wrapper.h

public:
     operator type&() const _NOEXCEPT {return *__f_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     type& get() const _NOEXCEPT {return *__f_;}
 
     // invoke
     template <class... _ArgTypes>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
     typename __invoke_of<type&, _ArgTypes...>::type
-    operator() (_ArgTypes&&... __args) const {
+    operator() (_ArgTypes&&... __args) const
+#if _LIBCPP_STD_VER > 14
+        // Since is_nothrow_invocable requires C++17 LWG3764 is not backported
+        // to earlier versions.
+        noexcept(is_nothrow_invocable_v<_Tp&, _ArgTypes...>)
+#endif
+    {
         return std::__invoke(get(), std::forward<_ArgTypes>(__args)...);
     }
 };
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
 #endif

libcxx/include/functional

 {
 public:
     // types
     typedef T type;
     typedef see below result_type; // Not always defined
 
     // construct/copy/destroy
     template<class U>
-      reference_wrapper(U&&);
-    reference_wrapper(const reference_wrapper<T>& x) noexcept;
+      constexpr reference_wrapper(U&&);                                   // constexpr since C++20
+    constexpr reference_wrapper(const reference_wrapper<T>& x) noexcept;  // constexpr since C++20
 
     // assignment
-    reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
+    constexpr reference_wrapper&
+    operator=(const reference_wrapper<T>& x) noexcept;                    // constexpr since C++20
 
     // access
-    operator T& () const noexcept;
-    T& get() const noexcept;
+    constexpr operator T& () const noexcept;                              // constexpr since C++20
+    constexpr T& get() const noexcept;                                    // constexpr since C++20
 
     // invoke
     template <class... ArgTypes>
-      typename result_of<T&(ArgTypes&&...)>::type
-          operator() (ArgTypes&&...) const;
+      constexpr typename result_of<T&(ArgTypes&&...)>::type               // constexpr since C++20
+          operator() (ArgTypes&&...) const
+              noexcept(is_nothrow_invocable_v<T&, ArgTypes...>);          // noexcept since C++17
 };
 
 template <class T>
   reference_wrapper(T&) -> reference_wrapper<T>;
 
 template <class T> reference_wrapper<T> ref(T& t) noexcept;
 template <class T> void ref(const T&& t) = delete;
 template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;

libcxx/test/std/utilities/function.objects/refwrap/refwrap.invoke/invoke.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // reference_wrapper
 
-// template <class... ArgTypes>
-//   requires Callable<T, ArgTypes&&...>
-//   Callable<T, ArgTypes&&...>::result_type
-//   operator()(ArgTypes&&... args) const;
+//  template <class... ArgTypes>
+//    constexpr typename result_of<T&(ArgTypes&&...)>::type               // constexpr since C++20
+//        operator() (ArgTypes&&...) const
+//            noexcept(is_nothrow_invocable_v<T&, ArgTypes...>);          // noexcept since C++17
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
+#if TEST_STD_VER > 14
+#  define INVOKE_NOEXCEPT(expected, ...) static_assert(noexcept(__VA_ARGS__) == expected)
+#else
+#  define INVOKE_NOEXCEPT(expected, ...)
+#endif
+
 int count = 0;
 
 // 1 arg, return void
 
 void f_void_1(int i)
 {
     count += i;
 }

 test_void_1()
 {
     int save_count = count;
     // function
     {
     std::reference_wrapper<void (int)> r1(f_void_1);
     int i = 2;
     r1(i);
+    INVOKE_NOEXCEPT(false, r1(i));
     assert(count == save_count+2);
     save_count = count;
     }
     // function pointer
     {
     void (*fp)(int) = f_void_1;
     std::reference_wrapper<void (*)(int)> r1(fp);
     int i = 3;
     r1(i);
+    INVOKE_NOEXCEPT(false, r1(i));
     assert(count == save_count+3);
     save_count = count;
     }
     // functor
     {
     A_void_1 a0;
     std::reference_wrapper<A_void_1> r1(a0);
     int i = 4;
     r1(i);
+    INVOKE_NOEXCEPT(false, r1(i));
     assert(count == save_count+4);
     save_count = count;
     }
     // member function pointer
     {
     void (A_void_1::*fp)() = &A_void_1::mem1;
     std::reference_wrapper<void (A_void_1::*)()> r1(fp);
     A_void_1 a;
     r1(a);
+    INVOKE_NOEXCEPT(false, r1(a));
     assert(count == save_count+1);
     save_count = count;
     A_void_1* ap = &a;
     r1(ap);
+    INVOKE_NOEXCEPT(false, r1(ap));
     assert(count == save_count+1);
     save_count = count;
     }
     // const member function pointer
     {
     void (A_void_1::*fp)() const = &A_void_1::mem2;
     std::reference_wrapper<void (A_void_1::*)() const> r1(fp);
     A_void_1 a;
     r1(a);
+    INVOKE_NOEXCEPT(false, r1(a));
     assert(count == save_count+1);
     save_count = count;
     A_void_1* ap = &a;
     r1(ap);
+    INVOKE_NOEXCEPT(false, r1(ap));
     assert(count == save_count+1);
     save_count = count;
     }
 }
 
 // 1 arg, return int
 
 int f_int_1(int i)

 void
 test_int_1()
 {
     // function
     {
     std::reference_wrapper<int (int)> r1(f_int_1);
     int i = 2;
     assert(r1(i) == 3);
+    INVOKE_NOEXCEPT(false, r1(i));
     }
     // function pointer
     {
     int (*fp)(int) = f_int_1;
     std::reference_wrapper<int (*)(int)> r1(fp);
     int i = 3;
     assert(r1(i) == 4);
+    INVOKE_NOEXCEPT(false, r1(i));
     }
     // functor
     {
     A_int_1 a0;
     std::reference_wrapper<A_int_1> r1(a0);
     int i = 4;
     assert(r1(i) == 3);
+    INVOKE_NOEXCEPT(false, r1(i));
     }
     // member function pointer
     {
     int (A_int_1::*fp)() = &A_int_1::mem1;
     std::reference_wrapper<int (A_int_1::*)()> r1(fp);
     A_int_1 a;
     assert(r1(a) == 3);
+    INVOKE_NOEXCEPT(false, r1(a));
     A_int_1* ap = &a;
     assert(r1(ap) == 3);
+    INVOKE_NOEXCEPT(false, r1(ap));
     }
     // const member function pointer
     {
     int (A_int_1::*fp)() const = &A_int_1::mem2;
     std::reference_wrapper<int (A_int_1::*)() const> r1(fp);
     A_int_1 a;
     assert(r1(a) == 4);
+    INVOKE_NOEXCEPT(false, r1(a));
     A_int_1* ap = &a;
     assert(r1(ap) == 4);
+    INVOKE_NOEXCEPT(false, r1(ap));
     }
     // member data pointer
     {
     int A_int_1::*fp = &A_int_1::data_;
     std::reference_wrapper<int A_int_1::*> r1(fp);
     A_int_1 a;
     assert(r1(a) == 5);
+    INVOKE_NOEXCEPT(true, r1(a));
     r1(a) = 6;
     assert(r1(a) == 6);
     A_int_1* ap = &a;
     assert(r1(ap) == 6);
     r1(ap) = 7;
     assert(r1(ap) == 7);
+    INVOKE_NOEXCEPT(true, r1(ap));
     }
 }
 
 // 2 arg, return void
 
 void f_void_2(int i, int j)
 {
     count += i+j;

 {
     int save_count = count;
     // function
     {
     std::reference_wrapper<void (int, int)> r1(f_void_2);
     int i = 2;
     int j = 3;
     r1(i, j);
+    INVOKE_NOEXCEPT(false, r1(i, j));
     assert(count == save_count+5);
     save_count = count;
     }
     // function pointer
     {
     void (*fp)(int, int) = f_void_2;
     std::reference_wrapper<void (*)(int, int)> r1(fp);
     int i = 3;
     int j = 4;
     r1(i, j);
+    INVOKE_NOEXCEPT(false, r1(i, j));
     assert(count == save_count+7);
     save_count = count;
     }
     // functor
     {
     A_void_2 a0;
     std::reference_wrapper<A_void_2> r1(a0);
     int i = 4;
     int j = 5;
     r1(i, j);
+    INVOKE_NOEXCEPT(false, r1(i, j));
     assert(count == save_count+9);
     save_count = count;
     }
     // member function pointer
     {
     void (A_void_2::*fp)(int) = &A_void_2::mem1;
     std::reference_wrapper<void (A_void_2::*)(int)> r1(fp);
     A_void_2 a;
     int i = 3;
     r1(a, i);
     assert(count == save_count+3);
     save_count = count;
     A_void_2* ap = &a;
     r1(ap, i);
+    INVOKE_NOEXCEPT(false, r1(ap, i));
     assert(count == save_count+3);
     save_count = count;
     }
     // const member function pointer
     {
     void (A_void_2::*fp)(int) const = &A_void_2::mem2;
     std::reference_wrapper<void (A_void_2::*)(int) const> r1(fp);
     A_void_2 a;
     int i = 4;
     r1(a, i);
+    INVOKE_NOEXCEPT(false, r1(a, i));
     assert(count == save_count+4);
     save_count = count;
     A_void_2* ap = &a;
     r1(ap, i);
+    INVOKE_NOEXCEPT(false, r1(ap, i));
     assert(count == save_count+4);
     save_count = count;
     }
 }
 
 // 2 arg, return int
 
 int f_int_2(int i, int j)
 {
     return i+j;
 }
 
 struct A_int_2
 {
     int operator()(int i, int j)
     {
         return i+j;
     }
 
     int mem1(int i) {return i+1;}
     int mem2(int i) const {return i+2;}
 };
 
 void
-testint_2()
+test_int_2()
 {
     // function
     {
     std::reference_wrapper<int (int, int)> r1(f_int_2);
     int i = 2;
     int j = 3;
     assert(r1(i, j) == i+j);
+    INVOKE_NOEXCEPT(false, r1(i, j));
     }
     // function pointer
     {
     int (*fp)(int, int) = f_int_2;
     std::reference_wrapper<int (*)(int, int)> r1(fp);
     int i = 3;
     int j = 4;
     assert(r1(i, j) == i+j);
+    INVOKE_NOEXCEPT(false, r1(i, j));
     }
     // functor
     {
     A_int_2 a0;
     std::reference_wrapper<A_int_2> r1(a0);
     int i = 4;
     int j = 5;
     assert(r1(i, j) == i+j);
+    INVOKE_NOEXCEPT(false, r1(i, j));
     }
     // member function pointer
     {
     int(A_int_2::*fp)(int) = &A_int_2::mem1;
     std::reference_wrapper<int (A_int_2::*)(int)> r1(fp);
     A_int_2 a;
     int i = 3;
     assert(r1(a, i) == i+1);
+    INVOKE_NOEXCEPT(false, r1(a, i));
     A_int_2* ap = &a;
     assert(r1(ap, i) == i+1);
+    INVOKE_NOEXCEPT(false, r1(ap, i));
     }
     // const member function pointer
     {
     int (A_int_2::*fp)(int) const = &A_int_2::mem2;
     std::reference_wrapper<int (A_int_2::*)(int) const> r1(fp);
     A_int_2 a;
     int i = 4;
     assert(r1(a, i) == i+2);
+    INVOKE_NOEXCEPT(false, r1(a, i));
     A_int_2* ap = &a;
     assert(r1(ap, i) == i+2);
+    INVOKE_NOEXCEPT(false, r1(ap, i));
+    }
+}
+
+#if TEST_STD_VER >= 11
+
+// 1 arg, return void, noexcept
+
+void f_void_1_noexcept(int i) noexcept
+{
+    count += i;
+}
+
+struct A_void_1_noexcept
+{
+    void operator()(int i) noexcept
+    {
+        count += i;
+    }
+
+    void mem1() noexcept {++count;}
+    void mem2() const noexcept {++count;}
+};
+
+void
+test_void_1_noexcept()
+{
+    int save_count = count;
+    // function
+    {
+    std::reference_wrapper<void (int) noexcept> r1(f_void_1_noexcept);
+    int i = 2;
+    r1(i);
+    INVOKE_NOEXCEPT(true, r1(i));
+    assert(count == save_count+2);
+    save_count = count;
+    }
+    // function pointer
+    {
+    void (*fp)(int) noexcept = f_void_1_noexcept;
+    std::reference_wrapper<void (*)(int) noexcept> r1(fp);
+    int i = 3;
+    r1(i);
+    INVOKE_NOEXCEPT(true, r1(i));
+    assert(count == save_count+3);
+    save_count = count;
+    }
+    // functor
+    {
+    A_void_1_noexcept a0;
+    std::reference_wrapper<A_void_1_noexcept> r1(a0);
+    int i = 4;
+    r1(i);
+    INVOKE_NOEXCEPT(true, r1(i));
+    assert(count == save_count+4);
+    save_count = count;
+    }
+    // member function pointer
+    {
+    void (A_void_1_noexcept::*fp)() noexcept = &A_void_1_noexcept::mem1;
+    std::reference_wrapper<void (A_void_1_noexcept::*)() noexcept> r1(fp);
+    A_void_1_noexcept a;
+    r1(a);
+    INVOKE_NOEXCEPT(true, r1(a));
+    assert(count == save_count+1);
+    save_count = count;
+    A_void_1_noexcept* ap = &a;
+    r1(ap);
+    INVOKE_NOEXCEPT(true, r1(ap));
+    assert(count == save_count+1);
+    save_count = count;
+    }
+    // const member function pointer
+    {
+    void (A_void_1_noexcept::*fp)() const noexcept = &A_void_1_noexcept::mem2;
+    std::reference_wrapper<void (A_void_1_noexcept::*)() const noexcept> r1(fp);
+    A_void_1_noexcept a;
+    r1(a);
+    INVOKE_NOEXCEPT(true, r1(a));
+    assert(count == save_count+1);
+    save_count = count;
+    A_void_1_noexcept* ap = &a;
+    r1(ap);
+    INVOKE_NOEXCEPT(true, r1(ap));
+    assert(count == save_count+1);
+    save_count = count;
+    }
+}
+
+// 1 arg, return int, noexcept
+
+int f_int_1_noexcept(int i) noexcept
+{
+    return i + 1;
+}
+
+struct A_int_1_noexcept
+{
+    A_int_1_noexcept() : data_(5) {}
+    int operator()(int i) noexcept
+    {
+        return i - 1;
+    }
+
+    int mem1() noexcept {return 3;}
+    int mem2() const noexcept {return 4;}
+    int data_;
+};
+
+void
+test_int_1_noexcept()
+{
+    // function
+    {
+    std::reference_wrapper<int (int) noexcept> r1(f_int_1_noexcept);
+    int i = 2;
+    assert(r1(i) == 3);
+    INVOKE_NOEXCEPT(true, r1(i));
+    }
+    // function pointer
+    {
+    int (*fp)(int) noexcept = f_int_1_noexcept;
+    std::reference_wrapper<int (*)(int) noexcept> r1(fp);
+    int i = 3;
+    assert(r1(i) == 4);
+    INVOKE_NOEXCEPT(true, r1(i));
+    }
+    // functor
+    {
+    A_int_1_noexcept a0;
+    std::reference_wrapper<A_int_1_noexcept> r1(a0);
+    int i = 4;
+    assert(r1(i) == 3);
+    INVOKE_NOEXCEPT(true, r1(i));
+    }
+    // member function pointer
+    {
+    int (A_int_1_noexcept::*fp)() noexcept = &A_int_1_noexcept::mem1;
+    std::reference_wrapper<int (A_int_1_noexcept::*)() noexcept> r1(fp);
+    A_int_1_noexcept a;
+    assert(r1(a) == 3);
+    INVOKE_NOEXCEPT(true, r1(a));
+    A_int_1_noexcept* ap = &a;
+    assert(r1(ap) == 3);
+    INVOKE_NOEXCEPT(true, r1(ap));
+    }
+    // const member function pointer
+    {
+    int (A_int_1_noexcept::*fp)() const noexcept = &A_int_1_noexcept::mem2;
+    std::reference_wrapper<int (A_int_1_noexcept::*)() const noexcept> r1(fp);
+    A_int_1_noexcept a;
+    assert(r1(a) == 4);
+    INVOKE_NOEXCEPT(true, r1(a));
+    A_int_1_noexcept* ap = &a;
+    assert(r1(ap) == 4);
+    INVOKE_NOEXCEPT(true, r1(ap));
+    }
+    // member data pointer
+    {
+    int A_int_1_noexcept::*fp = &A_int_1_noexcept::data_;
+    std::reference_wrapper<int A_int_1_noexcept::*> r1(fp);
+    A_int_1_noexcept a;
+    assert(r1(a) == 5);
+    INVOKE_NOEXCEPT(true, r1(a));
+    r1(a) = 6;
+    assert(r1(a) == 6);
+    A_int_1_noexcept* ap = &a;
+    assert(r1(ap) == 6);
+    r1(ap) = 7;
+    assert(r1(ap) == 7);
+    INVOKE_NOEXCEPT(true, r1(ap));
     }
 }
 
+// 2 arg, return void, noexcept
+
+void f_void_2_noexcept(int i, int j) noexcept
+{
+    count += i+j;
+}
+
+struct A_void_2_noexcept
+{
+    void operator()(int i, int j) noexcept
+    {
+        count += i+j;
+    }
+
+    void mem1(int i) noexcept {count += i;}
+    void mem2(int i) const noexcept {count += i;}
+};
+
+void
+test_void_2_noexcept()
+{
+    int save_count = count;
+    // function
+    {
+    std::reference_wrapper<void (int, int) noexcept> r1(f_void_2_noexcept);
+    int i = 2;
+    int j = 3;
+    r1(i, j);
+    INVOKE_NOEXCEPT(true, r1(i, j));
+    assert(count == save_count+5);
+    save_count = count;
+    }
+    // function pointer
+    {
+    void (*fp)(int, int) noexcept = f_void_2_noexcept;
+    std::reference_wrapper<void (*)(int, int) noexcept> r1(fp);
+    int i = 3;
+    int j = 4;
+    r1(i, j);
+    INVOKE_NOEXCEPT(true, r1(i, j));
+    assert(count == save_count+7);
+    save_count = count;
+    }
+    // functor
+    {
+    A_void_2_noexcept a0;
+    std::reference_wrapper<A_void_2_noexcept> r1(a0);
+    int i = 4;
+    int j = 5;
+    r1(i, j);
+    INVOKE_NOEXCEPT(true, r1(i, j));
+    assert(count == save_count+9);
+    save_count = count;
+    }
+    // member function pointer
+    {
+    void (A_void_2_noexcept::*fp)(int) noexcept = &A_void_2_noexcept::mem1;
+    std::reference_wrapper<void (A_void_2_noexcept::*)(int) noexcept> r1(fp);
+    A_void_2_noexcept a;
+    int i = 3;
+    r1(a, i);
+    assert(count == save_count+3);
+    save_count = count;
+    A_void_2_noexcept* ap = &a;
+    r1(ap, i);
+    INVOKE_NOEXCEPT(true, r1(ap, i));
+    assert(count == save_count+3);
+    save_count = count;
+    }
+    // const member function pointer
+    {
+    void (A_void_2_noexcept::*fp)(int) const noexcept = &A_void_2_noexcept::mem2;
+    std::reference_wrapper<void (A_void_2_noexcept::*)(int) const noexcept> r1(fp);
+    A_void_2_noexcept a;
+    int i = 4;
+    r1(a, i);
+    INVOKE_NOEXCEPT(true, r1(a, i));
+    assert(count == save_count+4);
+    save_count = count;
+    A_void_2_noexcept* ap = &a;
+    r1(ap, i);
+    INVOKE_NOEXCEPT(true, r1(ap, i));
+    assert(count == save_count+4);
+    save_count = count;
+    }
+}
+
+// 2 arg, return int, noexcept
+
+int f_int_2_noexcept(int i, int j) noexcept
+{
+    return i+j;
+}
+
+struct A_int_2_noexcept
+{
+    int operator()(int i, int j) noexcept
+    {
+        return i+j;
+    }
+
+    int mem1(int i) noexcept {return i+1;}
+    int mem2(int i) const noexcept {return i+2;}
+};
+
+void
+test_int_2_noexcept()
+{
+    // function
+    {
+    std::reference_wrapper<int (int, int) noexcept> r1(f_int_2_noexcept);
+    int i = 2;
+    int j = 3;
+    assert(r1(i, j) == i+j);
+    INVOKE_NOEXCEPT(true, r1(i, j));
+    }
+    // function pointer
+    {
+    int (*fp)(int, int) noexcept = f_int_2_noexcept;
+    std::reference_wrapper<int (*)(int, int) noexcept> r1(fp);
+    int i = 3;
+    int j = 4;
+    assert(r1(i, j) == i+j);
+    INVOKE_NOEXCEPT(true, r1(i, j));
+    }
+    // functor
+    {
+    A_int_2_noexcept a0;
+    std::reference_wrapper<A_int_2_noexcept> r1(a0);
+    int i = 4;
+    int j = 5;
+    assert(r1(i, j) == i+j);
+    INVOKE_NOEXCEPT(true, r1(i, j));
+    }
+    // member function pointer
+    {
+    int(A_int_2_noexcept::*fp)(int) noexcept = &A_int_2_noexcept::mem1;
+    std::reference_wrapper<int (A_int_2_noexcept::*)(int) noexcept> r1(fp);
+    A_int_2_noexcept a;
+    int i = 3;
+    assert(r1(a, i) == i+1);
+    INVOKE_NOEXCEPT(true, r1(a, i));
+    A_int_2_noexcept* ap = &a;
+    assert(r1(ap, i) == i+1);
+    INVOKE_NOEXCEPT(true, r1(ap, i));
+    }
+    // const member function pointer
+    {
+    int (A_int_2_noexcept::*fp)(int) const noexcept = &A_int_2_noexcept::mem2;
+    std::reference_wrapper<int (A_int_2_noexcept::*)(int) const noexcept> r1(fp);
+    A_int_2_noexcept a;
+    int i = 4;
+    assert(r1(a, i) == i+2);
+    INVOKE_NOEXCEPT(true, r1(a, i));
+    A_int_2_noexcept* ap = &a;
+    assert(r1(ap, i) == i+2);
+    INVOKE_NOEXCEPT(true, r1(ap, i));
+    }
+}
+
+#endif // TEST_STD_VER >= 11
+
 int main(int, char**)
 {
     test_void_1();
     test_int_1();
     test_void_2();
-    testint_2();
+    test_int_2();
+#if TEST_STD_VER >= 11
+    test_void_1_noexcept();
+    test_int_1_noexcept();
+    test_void_2_noexcept();
+    test_int_2_noexcept();
+#endif // TEST_STD_VER >= 11
 
   return 0;
 }