[libcxx] r321847 - Fix nonstandard bits in transform_reduce_iter_iter_init_bop_uop.

[Billy Robert O'Neal III via cfe-commits]

Author: bion
Date: Thu Jan  4 17:31:47 2018
New Revision: 321847

URL: http://llvm.org/viewvc/llvm-project?rev=321847&view=rev
Log:
Fix nonstandard bits in transform_reduce_iter_iter_init_bop_uop.

* _VSTD should be std.
* <utility> is needed for forward.
* unary_function is no longer standard (and unnecessary for this, a C++17-only test)

Modified:
    libcxx/trunk/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp

Modified: libcxx/trunk/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp?rev=321847&r1=321846&r2=321847&view=diff
==============================================================================
--- libcxx/trunk/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp (original)
+++ libcxx/trunk/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp Thu Jan  4 17:31:47 2018
@@ -18,40 +18,24 @@
 
 #include <numeric>
 #include <cassert>
+#include <utility>
 
 #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>
@@ -70,23 +54,23 @@ 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>
@@ -94,7 +78,7 @@ 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()))> );
 }
 
 int main()
@@ -118,7 +102,7 @@ int main()
 //  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
     }
 }