BillyONeal created this revision.
BillyONeal added reviewers: mclow.lists, EricWF.
- These tests use function objects from functional, back_inserter from
iterator, and equal from algorithm, so add those headers.
- The use of iota targeting vector<unsigned char> with an int parameter
triggers warnings on MSVC++ assigning an into a unsigned char&; so change the
parameter to unsigned char with a static_cast.
- Avoid naming unary_function in identity here as that is removed in '17. (This
also fixes naming _VSTD, _NOEXCEPT_, and other libcxx-isms)
https://reviews.llvm.org/D41748
Files:
test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
Index: test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
+++ test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
@@ -20,26 +20,15 @@
#include <numeric>
-#include <vector>
+#include <algorithm>
#include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
#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>
-{
- 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); }
-};
+const auto identity = [](auto&& x) { return std::forward<decltype(x)>(x); };
template <class Iter1, class BOp, class UOp, class T, class Iter2>
void
@@ -82,12 +71,12 @@
static_assert(sa == sizeof(mResN2) / sizeof(mResN2[0])); // just to be sure
for (unsigned int i = 0; i < sa; ++i ) {
- test(Iter(ia), Iter(ia + i), std::plus<>(), identity<>(), 0, pResI0, pResI0 + i);
- test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(), 0, mResI0, mResI0 + i);
+ test(Iter(ia), Iter(ia + i), std::plus<>(), identity, 0, pResI0, pResI0 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity, 0, mResI0, mResI0 + i);
test(Iter(ia), Iter(ia + i), std::plus<>(), std::negate<>(), 0, pResN0, pResN0 + i);
test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 0, mResN0, mResN0 + i);
- test(Iter(ia), Iter(ia + i), std::plus<>(), identity<>(), 2, pResI2, pResI2 + i);
- test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(), 2, mResI2, mResI2 + i);
+ test(Iter(ia), Iter(ia + i), std::plus<>(), identity, 2, pResI2, pResI2 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity, 2, mResI2, mResI2 + i);
test(Iter(ia), Iter(ia + i), std::plus<>(), std::negate<>(), 2, pResN2, pResN2 + i);
test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i);
}
@@ -101,39 +90,39 @@
{
std::vector<int> v(10);
std::fill(v.begin(), v.end(), 3);
- std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>(), 50);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity, 50);
for (size_t i = 0; i < v.size(); ++i)
assert(v[i] == 50 + (int) (i + 1) * 3);
}
{
std::vector<int> v(10);
std::iota(v.begin(), v.end(), 0);
- std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>(), 30);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity, 30);
for (size_t i = 0; i < v.size(); ++i)
assert(v[i] == 30 + triangle(i));
}
{
std::vector<int> v(10);
std::iota(v.begin(), v.end(), 1);
- std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>(), 40);
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity, 40);
for (size_t i = 0; i < v.size(); ++i)
assert(v[i] == 40 + triangle(i + 1));
}
{
std::vector<int> v, res;
- std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), identity<>(), 1);
+ std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), identity, 1);
assert(res.empty());
}
// Make sure that the calculations are done using the init typedef
{
std::vector<unsigned char> v(10);
- std::iota(v.begin(), v.end(), 1);
+ std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
std::vector<int> res;
- std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::multiplies<>(), identity<>(), 1);
+ std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::multiplies<>(), identity, 1);
assert(res.size() == 10);
int j = 1;
Index: test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
+++ test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
@@ -20,27 +20,16 @@
#include <numeric>
-#include <vector>
+#include <algorithm>
#include <cassert>
+#include <functional>
#include <iostream>
+#include <iterator>
+#include <vector>
#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>
-{
- 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); }
-};
+const auto identity = [](auto&& x) { return std::forward<decltype(x)>(x); };
template <class Iter1, class BOp, class UOp, class Iter2>
void
@@ -75,8 +64,8 @@
static_assert(sa == sizeof(mResN0) / sizeof(mResN0[0])); // just to be sure
for (unsigned int i = 0; i < sa; ++i ) {
- test(Iter(ia), Iter(ia + i), std::plus<>(), identity<>(), pResI0, pResI0 + i);
- test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(), mResI0, mResI0 + i);
+ test(Iter(ia), Iter(ia + i), std::plus<>(), identity, pResI0, pResI0 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity, mResI0, mResI0 + i);
test(Iter(ia), Iter(ia + i), std::plus<>(), std::negate<>(), pResN0, pResN0 + i);
test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), mResN0, mResN0 + i);
}
@@ -90,7 +79,7 @@
{
std::vector<int> v(10);
std::fill(v.begin(), v.end(), 3);
- std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>());
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity);
std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
for (size_t i = 0; i < v.size(); ++i)
@@ -100,22 +89,22 @@
{
std::vector<int> v(10);
std::iota(v.begin(), v.end(), 0);
- std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>());
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity);
for (size_t i = 0; i < v.size(); ++i)
assert(v[i] == triangle(i));
}
{
std::vector<int> v(10);
std::iota(v.begin(), v.end(), 1);
- std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>());
+ std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity);
for (size_t i = 0; i < v.size(); ++i)
assert(v[i] == triangle(i + 1));
}
{
std::vector<int> v, res;
- std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), identity<>());
+ std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), identity);
assert(res.empty());
}
}
Index: test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
+++ test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
@@ -19,27 +19,16 @@
#include <numeric>
-#include <vector>
+#include <algorithm>
#include <cassert>
+#include <functional>
#include <iostream>
+#include <iterator>
+#include <vector>
#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>
-{
- 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); }
-};
+const auto identity = [](auto&& x) { return std::forward<decltype(x)>(x); };
template <class Iter1, class BOp, class UOp, class T, class Iter2>
void
@@ -82,12 +71,12 @@
static_assert(sa == sizeof(mResN2) / sizeof(mResN2[0])); // just to be sure
for (unsigned int i = 0; i < sa; ++i ) {
- test(Iter(ia), Iter(ia + i), std::plus<>(), identity<>(), 0, pResI0, pResI0 + i);
- test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(), 0, mResI0, mResI0 + i);
+ test(Iter(ia), Iter(ia + i), std::plus<>(), identity, 0, pResI0, pResI0 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity, 0, mResI0, mResI0 + i);
test(Iter(ia), Iter(ia + i), std::plus<>(), std::negate<>(), 0, pResN0, pResN0 + i);
test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 0, mResN0, mResN0 + i);
- test(Iter(ia), Iter(ia + i), std::plus<>(), identity<>(), 2, pResI2, pResI2 + i);
- test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(), 2, mResI2, mResI2 + i);
+ test(Iter(ia), Iter(ia + i), std::plus<>(), identity, 2, pResI2, pResI2 + i);
+ test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity, 2, mResI2, mResI2 + i);
test(Iter(ia), Iter(ia + i), std::plus<>(), std::negate<>(), 2, pResN2, pResN2 + i);
test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i);
}
@@ -101,39 +90,39 @@
{
std::vector<int> v(10);
std::fill(v.begin(), v.end(), 3);
- std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 50, std::plus<>(), identity<>());
+ std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 50, std::plus<>(), identity);
for (size_t i = 0; i < v.size(); ++i)
assert(v[i] == 50 + (int) i * 3);
}
{
std::vector<int> v(10);
std::iota(v.begin(), v.end(), 0);
- std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 30, std::plus<>(), identity<>());
+ std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 30, std::plus<>(), identity);
for (size_t i = 0; i < v.size(); ++i)
assert(v[i] == 30 + triangle(i-1));
}
{
std::vector<int> v(10);
std::iota(v.begin(), v.end(), 1);
- std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 40, std::plus<>(), identity<>());
+ std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 40, std::plus<>(), identity);
for (size_t i = 0; i < v.size(); ++i)
assert(v[i] == 40 + triangle(i));
}
{
std::vector<int> v, res;
- std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 40, std::plus<>(), identity<>());
+ std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 40, std::plus<>(), identity);
assert(res.empty());
}
// Make sure that the calculations are done using the init typedef
{
std::vector<unsigned char> v(10);
- std::iota(v.begin(), v.end(), 1);
+ std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
std::vector<int> res;
- std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 1, std::multiplies<>(), identity<>());
+ std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 1, std::multiplies<>(), identity);
assert(res.size() == 10);
int j = 1;
Index: test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
+++ test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
@@ -17,8 +17,11 @@
// BinaryOperation binary_op, T init); // C++17
#include <numeric>
-#include <vector>
+#include <algorithm>
#include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
#include "test_iterators.h"
@@ -95,7 +98,7 @@
// Make sure that the calculations are done using the init typedef
{
std::vector<unsigned char> v(10);
- std::iota(v.begin(), v.end(), 1);
+ std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
std::vector<int> res;
std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::multiplies<>(), 1);
Index: test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
+++ test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
@@ -17,9 +17,12 @@
// BinaryOperation binary_op); // C++17
#include <numeric>
-#include <vector>
+#include <algorithm>
#include <cassert>
+#include <functional>
#include <iostream>
+#include <iterator>
+#include <vector>
#include "test_iterators.h"
Index: test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
+++ test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
@@ -16,8 +16,11 @@
//
#include <numeric>
-#include <vector>
+#include <algorithm>
#include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
#include "test_iterators.h"
Index: test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
+++ test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp
@@ -17,8 +17,11 @@
// T init, BinaryOperation binary_op); // C++17
#include <numeric>
-#include <vector>
+#include <algorithm>
#include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
#include "test_iterators.h"
@@ -70,7 +73,7 @@
// Make sure that the calculations are done using the init typedef
{
std::vector<unsigned char> v(10);
- std::iota(v.begin(), v.end(), 1);
+ std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
std::vector<int> res;
std::exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 1, std::multiplies<>());
Index: test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
===================================================================
--- test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
+++ test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp
@@ -16,8 +16,11 @@
//
#include <numeric>
-#include <vector>
+#include <algorithm>
#include <cassert>
+#include <functional>
+#include <iterator>
+#include <vector>
#include "test_iterators.h"
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
