[libcxx] Fix transform_reduce mishandling move-only types, and nonstandard macro use in tests.

[BillyONeal]

Summary

• Remove _VSTD use and remove C++03-isms in C++17 tests for transform_reduce.
• Add tests for all the transform_reduce overloads that pass in a move-only type.
• Repair missing move in libc++ product code.

[BillyONeal]

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp

61

Should these go in MoveOnly.h ?

[BillyONeal]

include/numeric

245

It's arguable that this should be _VSTD::move(__init); I asked SG1 / LEWG about that. (After all, if they're going to make inner_product do that this should too)

[mclow.lists]

The rest of this LGTM.

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp

61

I think so. While you're at it, you can remove the friend declaration in MoveOnly - that's a remnant.

[BillyONeal]

Do you folks want me to port this test case for move-only T into libcxx? (I added this to our test harness) Note that discussion on validity is ongoing on lists.

#define _SILENCE_PARALLEL_ALGORITHMS_EXPERIMENTAL_WARNING
#include <stdlib.h>
#include <algorithm>
#include <execution>
#include <memory>
#include <iterator>
#include <numeric>
#include <utility>
#include <vector>
#include <parallel_algorithms_utilities.hpp>
#include <pmretvals.h>

using namespace std;
using namespace std::execution;

void verify(const bool b) {
    if (!b) {
        exit(PM_TEST_FAIL);
    }
}

vector<unique_ptr<vector<unsigned int>>> get_move_only_test_data(const size_t testSize) {
    vector<unique_ptr<vector<unsigned int>>> testData;
    testData.reserve(testSize);
    for (size_t idx = 0; idx < testSize; ++idx) {
        testData.emplace_back(make_unique<vector<unsigned int>>(1, static_cast<unsigned int>(idx)));
    }

    return testData;
}

template<class ExPo>
void test_case_move_only(const size_t testSize, ExPo&& exec) {
    auto testData = get_move_only_test_data(testSize);
    unique_ptr<vector<unsigned int>> result = transform_reduce(std::forward<ExPo>(exec),
        make_move_iterator(testData.begin()), make_move_iterator(testData.end()),
        make_unique<vector<unsigned int>>(),
        [](unique_ptr<vector<unsigned int>> lhs, unique_ptr<vector<unsigned int>> rhs) {
            lhs->insert(lhs->end(), rhs->begin(), rhs->end());
            return lhs;
        },
        [](unique_ptr<vector<unsigned int>> target) {
            verify(target->size() == 1); // should only be called directly on the input sequence
            target->back() *= 10;
            return target;
        });

    sort(result->begin(), result->end());
    for (size_t idx = 0; idx < testSize; ++idx) {
        verify((*result)[idx] == idx * 10);
    }
}

int main() {
    parallel_test_case(test_case_move_only<const sequenced_policy&>, seq);
    parallel_test_case(test_case_move_only<const parallel_policy&>, par);
    return PM_TEST_PASS;
}

include/numeric

245

Any comment on whether these should have extra moves added @mclow.lists ?

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp

61

Should I also add op== and op< while I'm in there for testing things like sort?

[BillyONeal]

Moved things to MoveOnly.h.

include/numeric

template <class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2>
     inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
                   T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
 
 
 template<class InputIterator1, class InputIterator2, class T>
     T
     transform_reduce(InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, T init);  // C++17
-                     
 template<class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2>
     T
     transform_reduce(InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, T init,
                      BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);  // C++17
 
 template<class InputIterator, class T, class BinaryOperation, class UnaryOperation>
     T
     transform_reduce(InputIterator first, InputIterator last, T init,
                      BinaryOperation binary_op, UnaryOperation unary_op);  // C++17
 
 template <class InputIterator, class OutputIterator>
     OutputIterator
     partial_sum(InputIterator first, InputIterator last, OutputIterator result);
 
 template <class InputIterator, class OutputIterator, class BinaryOperation>
     OutputIterator
     partial_sum(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op);
 
 template<class InputIterator, class OutputIterator, class T>
     OutputIterator
     exclusive_scan(InputIterator first, InputIterator last,
                    OutputIterator result, T init); // C++17
-                           
 template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
     OutputIterator
-    exclusive_scan(InputIterator first, InputIterator last, 
+    exclusive_scan(InputIterator first, InputIterator last,
                    OutputIterator result, T init, BinaryOperation binary_op); // C++17
 
 template<class InputIterator, class OutputIterator>
     OutputIterator
     inclusive_scan(InputIterator first, InputIterator last, OutputIterator result);  // C++17
 
 template<class InputIterator, class OutputIterator, class BinaryOperation>
     OutputIterator
transform_exclusive_scan(InputIterator first, InputIterator last,
                              BinaryOperation binary_op, UnaryOperation unary_op);  // C++17
 
 template<class InputIterator, class OutputIterator,
          class BinaryOperation, class UnaryOperation>
   OutputIterator
   transform_inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
                              BinaryOperation binary_op, UnaryOperation unary_op);  // C++17
-                                          
 template<class InputIterator, class OutputIterator,
          class BinaryOperation, class UnaryOperation, class T>
   OutputIterator
   transform_inclusive_scan(InputIterator first, InputIterator last,
                              OutputIterator result,
                              BinaryOperation binary_op, UnaryOperation unary_op,
                              T init);  // C++17
 
reduce(_InputIterator __first, _InputIterator __last, _Tp __init)
     return _VSTD::reduce(__first, __last, __init, _VSTD::plus<>());
 }
 
 template <class _InputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 typename iterator_traits<_InputIterator>::value_type
 reduce(_InputIterator __first, _InputIterator __last)
 {
-    return _VSTD::reduce(__first, __last, 
+    return _VSTD::reduce(__first, __last,
        typename iterator_traits<_InputIterator>::value_type{});
 }
 #endif
 
 template <class _InputIterator1, class _InputIterator2, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init)
for (; __first1 != __last1; ++__first1, (void) ++__first2)
         __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
     return __init;
 }
 
 #if _LIBCPP_STD_VER > 14
 template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
-transform_reduce(_InputIterator __first, _InputIterator __last, 
+transform_reduce(_InputIterator __first, _InputIterator __last,
            _Tp __init,  _BinaryOp __b, _UnaryOp __u)
 {
     for (; __first != __last; ++__first)
         __init = __b(__init, __u(*__first));
     return __init;
 }
 
-template <class _InputIterator1, class _InputIterator2, 
+template <class _InputIterator1, class _InputIterator2,
           class _Tp, class _BinaryOp1, class _BinaryOp2>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
                  _InputIterator2 __first2, _Tp __init,  _BinaryOp1 __b1, _BinaryOp2 __b2)
 {
     for (; __first1 != __last1; ++__first1, (void) ++__first2)
         __init = __b1(__init, __b2(*__first1, *__first2));
     return __init;
 }
 
 template <class _InputIterator1, class _InputIterator2, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
-transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1, 
+transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
                  _InputIterator2 __first2, _Tp __init)
 {
-    return _VSTD::transform_reduce(__first1, __last1, __first2, __init, 
+    return _VSTD::transform_reduce(__first1, __last1, __first2, _VSTD::move(__init),
                                    _VSTD::plus<>(), _VSTD::multiplies<>());
 }
 #endif
 
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
 partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
     }
     return __result;
 }
 
 #if _LIBCPP_STD_VER > 14
 template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
-exclusive_scan(_InputIterator __first, _InputIterator __last, 
+exclusive_scan(_InputIterator __first, _InputIterator __last,
                _OutputIterator __result, _Tp __init, _BinaryOp __b)
 {
     if (__first != __last)
     {
         _Tp __saved = __init;
         do
         {
             __init = __b(__init, *__first);
             *__result = __saved;
             __saved = __init;
             ++__result;
         } while (++__first != __last);
     }
     return __result;
 }
 
 template <class _InputIterator, class _OutputIterator, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
-exclusive_scan(_InputIterator __first, _InputIterator __last, 
+exclusive_scan(_InputIterator __first, _InputIterator __last,
                _OutputIterator __result, _Tp __init)
 {
     return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>());
 }
 
 template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
-_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last, 
+_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
                                _OutputIterator __result, _BinaryOp __b,  _Tp __init)
 {
     for (; __first != __last; ++__first, (void) ++__result) {
         __init = __b(__init, *__first);
         *__result = __init;
         }
     return __result;
 }
 
 template <class _InputIterator, class _OutputIterator, class _BinaryOp>
-_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last, 
+_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
                                _OutputIterator __result, _BinaryOp __b)
 {
     if (__first != __last) {
         typename std::iterator_traits<_InputIterator>::value_type __init = *__first;
         *__result++ = __init;
         if (++__first != __last)
             return _VSTD::inclusive_scan(__first, __last, __result, __b, __init);
         }
 
     return __result;
 }
 
 template <class _InputIterator, class _OutputIterator>
-_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last, 
+_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
                                _OutputIterator __result)
 {
     return _VSTD::inclusive_scan(__first, __last, __result, std::plus<>());
 }
 
-template <class _InputIterator, class _OutputIterator, class _Tp, 
+template <class _InputIterator, class _OutputIterator, class _Tp,
           class _BinaryOp, class _UnaryOp>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
-transform_exclusive_scan(_InputIterator __first, _InputIterator __last, 
+transform_exclusive_scan(_InputIterator __first, _InputIterator __last,
                            _OutputIterator __result, _Tp __init,
                            _BinaryOp __b, _UnaryOp __u)
 {
     if (__first != __last)
     {
         _Tp __saved = __init;
         do
         {
             __init = __b(__init, __u(*__first));
             *__result = __saved;
             __saved = __init;
             ++__result;
         } while (++__first != __last);
     }
     return __result;
 }
 
 template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
-_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last, 
+_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
                            _OutputIterator __result, _BinaryOp __b, _UnaryOp __u, _Tp __init)
 {
     for (; __first != __last; ++__first, (void) ++__result) {
         __init = __b(__init, __u(*__first));
         *__result = __init;
         }
 
     return __result;
 }
 
 template <class _InputIterator, class _OutputIterator, class _BinaryOp, class _UnaryOp>
-_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last, 
+_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
                                _OutputIterator __result, _BinaryOp __b, _UnaryOp __u)
 {
     if (__first != __last) {
         typename std::iterator_traits<_InputIterator>::value_type __init = __u(*__first);
         *__result++ = __init;
         if (++__first != __last)
             return _VSTD::transform_inclusive_scan(__first, __last, __result, __b, __u, __init);
         }
-    
     return __result;
 }
 #endif
 
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
 adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result)

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp

 // template <class InputIterator1, class T,
 //           class BinaryOperation, class UnaryOperation>
 //    T transform_reduce(InputIterator1 first1, InputIterator1 last1,
 //                       T init, BinaryOperation binary_op, UnaryOperation unary_op);
 //
 
 #include <numeric>
 #include <cassert>
+#include <utility>
+#include <iterator>
 
+#include "MoveOnly.h"
 #include "test_iterators.h"
 
-template <class T = void>
-struct identity : std::unary_function<T, T>
-{
-    constexpr const T& operator()(const T& x) const { return x;}
-};
-
-template <>
-struct identity<void>
+struct identity
 {
     template <class T>
-    constexpr auto operator()(T&& x) const
-    _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
-    -> decltype        (_VSTD::forward<T>(x))
-        { return        _VSTD::forward<T>(x); }
+    constexpr decltype(auto) operator()(T&& x) const {
+        return std::forward<T>(x);
+    }
 };
 
-
-template <class T = void>
 struct twice
 {
-    constexpr const T operator()(const T& x) const noexcept { return 2 * x; }
-};
-
-template <>
-struct twice<void>
-{
     template <class T>
-    constexpr auto operator()(const T& x) const
-    _NOEXCEPT_(noexcept(2 * x))
-    -> decltype        (2 * x)
-        { return        2 * x; }
+    constexpr auto operator()(const T& x) const {
+        return 2 * x;
+    }
 };
 
 template <class Iter1, class T, class BOp, class UOp>
 void
 test(Iter1 first1, Iter1 last1, T init, BOp bOp, UOp uOp, T x)
 {
     static_assert( std::is_same_v<T,
                     decltype(std::transform_reduce(first1, last1, init, bOp, uOp))> );
     assert(std::transform_reduce(first1, last1, init, bOp, uOp) == x);
 }
 
 template <class Iter>
 void
 test()
 {
     int ia[]          = {1, 2, 3, 4, 5, 6};
     unsigned sa = sizeof(ia) / sizeof(ia[0]);
 
-    test(Iter(ia), Iter(ia),    0, std::plus<>(),       identity<>(),       0);
-    test(Iter(ia), Iter(ia),    1, std::multiplies<>(), identity<>(),       1);
-    test(Iter(ia), Iter(ia+1),  0, std::multiplies<>(), identity<>(),       0);
-    test(Iter(ia), Iter(ia+1),  2, std::plus<>(),       identity<>(),       3);
-    test(Iter(ia), Iter(ia+2),  0, std::plus<>(),       identity<>(),       3);
-    test(Iter(ia), Iter(ia+2),  3, std::multiplies<>(), identity<>(),       6);
-    test(Iter(ia), Iter(ia+sa), 4, std::multiplies<>(), identity<>(),    2880);
-    test(Iter(ia), Iter(ia+sa), 4, std::plus<>(),       identity<>(),      25);
-
-    test(Iter(ia), Iter(ia),    0, std::plus<>(),       twice<>(),       0);
-    test(Iter(ia), Iter(ia),    1, std::multiplies<>(), twice<>(),       1);
-    test(Iter(ia), Iter(ia+1),  0, std::multiplies<>(), twice<>(),       0);
-    test(Iter(ia), Iter(ia+1),  2, std::plus<>(),       twice<>(),       4);
-    test(Iter(ia), Iter(ia+2),  0, std::plus<>(),       twice<>(),       6);
-    test(Iter(ia), Iter(ia+2),  3, std::multiplies<>(), twice<>(),      24);
-    test(Iter(ia), Iter(ia+sa), 4, std::multiplies<>(), twice<>(),  184320); // 64 * 2880
-    test(Iter(ia), Iter(ia+sa), 4, std::plus<>(),       twice<>(),      46);
+    test(Iter(ia), Iter(ia),    0, std::plus<>(),       identity(),       0);
+    test(Iter(ia), Iter(ia),    1, std::multiplies<>(), identity(),       1);
+    test(Iter(ia), Iter(ia+1),  0, std::multiplies<>(), identity(),       0);
+    test(Iter(ia), Iter(ia+1),  2, std::plus<>(),       identity(),       3);
+    test(Iter(ia), Iter(ia+2),  0, std::plus<>(),       identity(),       3);
+    test(Iter(ia), Iter(ia+2),  3, std::multiplies<>(), identity(),       6);
+    test(Iter(ia), Iter(ia+sa), 4, std::multiplies<>(), identity(),    2880);
+    test(Iter(ia), Iter(ia+sa), 4, std::plus<>(),       identity(),      25);
+
+    test(Iter(ia), Iter(ia),    0, std::plus<>(),       twice(),       0);
+    test(Iter(ia), Iter(ia),    1, std::multiplies<>(), twice(),       1);
+    test(Iter(ia), Iter(ia+1),  0, std::multiplies<>(), twice(),       0);
+    test(Iter(ia), Iter(ia+1),  2, std::plus<>(),       twice(),       4);
+    test(Iter(ia), Iter(ia+2),  0, std::plus<>(),       twice(),       6);
+    test(Iter(ia), Iter(ia+2),  3, std::multiplies<>(), twice(),      24);
+    test(Iter(ia), Iter(ia+sa), 4, std::multiplies<>(), twice(),  184320); // 64 * 2880
+    test(Iter(ia), Iter(ia+sa), 4, std::plus<>(),       twice(),      46);
 }
 
 template <typename T, typename Init>
 void test_return_type()
 {
     T *p = nullptr;
     static_assert( std::is_same_v<Init,
-         decltype(std::transform_reduce(p, p, Init{}, std::plus<>(), identity<>()))> );
+         decltype(std::transform_reduce(p, p, Init{}, std::plus<>(), identity()))> );
+}
+
+void test_move_only_types()
+{
+    MoveOnly ia[] = {{1}, {2}, {3}};
+    assert(60 ==
+        std::transform_reduce(std::begin(ia), std::end(ia), MoveOnly{0},
+        [](const MoveOnly& lhs, const MoveOnly& rhs) { return MoveOnly{lhs.get() + rhs.get()}; },
+        [](const MoveOnly& target) { return MoveOnly{target.get() * 10}; }).get());
 }
 
 int main()
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
     test_return_type<int, unsigned long>();
     test_return_type<float, int>();
     test_return_type<short, float>();
     test_return_type<double, char>();
     test_return_type<char, double>();
 
 //  All the iterator categories
     test<input_iterator        <const int*> >();
     test<forward_iterator      <const int*> >();
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
 //  Make sure the math is done using the correct type
     {
     auto v = {1, 2, 3, 4, 5, 6};
-    unsigned res = std::transform_reduce(v.begin(), v.end(), 1U, std::multiplies<>(), twice<>());
+    unsigned res = std::transform_reduce(v.begin(), v.end(), 1U, std::multiplies<>(), twice());
     assert(res == 46080);       // 6! * 64 will not fit into a char
     }
+
+    test_move_only_types();
 }

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp

 
 // template <class InputIterator1, class InputIterator2, class T>
 //   T transform_reduce(InputIterator1 first1, InputIterator1 last1,
 //                      InputIterator2 first2, T init);
 
 
 #include <numeric>
 #include <cassert>
+#include <iterator>
 
+#include "MoveOnly.h"
 #include "test_iterators.h"
 
 template <class Iter1, class Iter2, class T>
 void
 test(Iter1 first1, Iter1 last1, Iter2 first2, T init, T x)
 {
     static_assert( std::is_same_v<T,
             decltype(std::transform_reduce(first1, last1, first2, init))> );

 template <typename T, typename Init>
 void test_return_type()
 {
     T *p = nullptr;
     static_assert( std::is_same_v<Init,
                        decltype(std::transform_reduce(p, p, p, Init{}))> );
 }
 
+void test_move_only_types()
+{
+    MoveOnly ia[] = {{1}, {2}, {3}};
+    MoveOnly ib[] = {{1}, {2}, {3}};
+    assert(14 ==
+        std::transform_reduce(std::begin(ia), std::end(ia), std::begin(ib), MoveOnly{0}).get());
+}
+
 int main()
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
     test_return_type<int, unsigned long>();
     test_return_type<float, int>();
     test_return_type<short, float>();
     test_return_type<double, char>();
//  All the iterator categories
     test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
 
 //  just plain pointers (const vs. non-const, too)
     test<const int*, const unsigned int *>();
     test<const int*,       unsigned int *>();
     test<      int*, const unsigned int *>();
     test<      int*,       unsigned int *>();
+
+    test_move_only_types();
 }

test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp

 //           class BinaryOperation1, class BinaryOperation2>
 //    T transform_reduce(InputIterator1 first1, InputIterator1 last1,
 //                       InputIterator2 first2, T init,
 //                       BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);
 //
 
 #include <numeric>
 #include <cassert>
+#include <iterator>
 
+#include "MoveOnly.h"
 #include "test_iterators.h"
 
 template <class Iter1, class Iter2, class T, class Op1, class Op2>
 void
 test(Iter1 first1, Iter1 last1, Iter2 first2, T init, Op1 op1, Op2 op2, T x)
 {
     static_assert( std::is_same_v<T,
          decltype(std::transform_reduce(first1, last1, first2, init, op1, op2))> );

 template <typename T, typename Init>
 void test_return_type()
 {
     T *p = nullptr;
     static_assert( std::is_same_v<Init,
        decltype(std::transform_reduce(p, p, p, Init{}, std::plus<>(), std::multiplies<>()))> );
 }
 
+void test_move_only_types()
+{
+    MoveOnly ia[] = {{1}, {2}, {3}};
+    MoveOnly ib[] = {{1}, {2}, {3}};
+    assert(14 ==
+        std::transform_reduce(std::begin(ia), std::end(ia), std::begin(ib), MoveOnly{0},
+        [](const MoveOnly& lhs, const MoveOnly& rhs) { return MoveOnly{lhs.get() + rhs.get()}; },
+        [](const MoveOnly& lhs, const MoveOnly& rhs) { return MoveOnly{lhs.get() * rhs.get()}; }).get());
+}
+
 int main()
 {
     test_return_type<char, int>();
     test_return_type<int, int>();
     test_return_type<int, unsigned long>();
     test_return_type<float, int>();
     test_return_type<short, float>();
     test_return_type<double, char>();
//  All the iterator categories
     test<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
     test<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
 
 //  just plain pointers (const vs. non-const, too)
     test<const int*, const unsigned int *>();
     test<const int*,       unsigned int *>();
     test<      int*, const unsigned int *>();
     test<      int*,       unsigned int *>();
+
+    test_move_only_types();
 }

test/support/MoveOnly.h

 
 #if TEST_STD_VER >= 11
 
 #include <cstddef>
 #include <functional>
 
 class MoveOnly
 {
-    friend class MoveOnly2;
     MoveOnly(const MoveOnly&);
     MoveOnly& operator=(const MoveOnly&);
 
     int data_;
 public:
     MoveOnly(int data = 1) : data_(data) {}
     MoveOnly(MoveOnly&& x)
         : data_(x.data_) {x.data_ = 0;}
     MoveOnly& operator=(MoveOnly&& x)
         {data_ = x.data_; x.data_ = 0; return *this;}
 
     int get() const {return data_;}
 
     bool operator==(const MoveOnly& x) const {return data_ == x.data_;}
     bool operator< (const MoveOnly& x) const {return data_ <  x.data_;}
+    MoveOnly operator+(const MoveOnly& x) const { return MoveOnly{data_ + x.data_}; }
+    MoveOnly operator*(const MoveOnly& x) const { return MoveOnly{data_ * x.data_}; }
 };
 
 namespace std {
 
 template <>
 struct hash<MoveOnly>
 {
     typedef MoveOnly argument_type;