vendor/libc++/libc++-trunk-r290819

11 files changed, 354 insertions, 81 deletions

diff --git a/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
index b56d31b9d0db..f39436048aef 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
@@ -81,7 +81,7 @@ test_int_array_struct_source()
 
 struct test1 {
     test1() : c(0) { }
-    test1(char c) : c(c + 1) { }
+    test1(char xc) : c(xc + 1) { }
     char c;
 };
 
diff --git a/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
index 43234be5d3b8..9a954d934c4e 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp
@@ -53,7 +53,7 @@ test1()
     OutIter r = std::move(InIter(ia), InIter(ia+N), OutIter(ib));
     assert(base(r) == ib+N);
     for (unsigned i = 0; i < N; ++i)
-        assert(*ib[i] == i);
+        assert(*ib[i] == static_cast<int>(i));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
diff --git a/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
index 02b6b16eca0c..c5f9d3ac7b6b 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp
@@ -53,7 +53,7 @@ test1()
     OutIter r = std::move_backward(InIter(ia), InIter(ia+N), OutIter(ib+N));
     assert(base(r) == ib);
     for (unsigned i = 0; i < N; ++i)
-        assert(*ib[i] == i);
+        assert(*ib[i] == static_cast<int>(i));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
index aa23d19a8a3b..8597b08da8cf 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
@@ -14,64 +14,70 @@
 //     is_partitioned(InputIterator first, InputIterator last, Predicate pred);
 
 #include <algorithm>
+#include <functional>
+#include <cstddef>
 #include <cassert>
 
 #include "test_iterators.h"
 #include "counting_predicates.hpp"
 
-struct is_odd
-{
-    bool operator()(const int& i) const {return i & 1;}
+struct is_odd {
+  bool operator()(const int &i) const { return i & 1; }
 };
 
-int main()
-{
-    {
-        const int ia[] = {1, 2, 3, 4, 5, 6};
-        unary_counting_predicate<is_odd, int> pred((is_odd()));
-        assert(!std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
-                                    input_iterator<const int*>(std::end(ia)),
-                                    std::ref(pred)));
-        assert(pred.count() <= std::distance(std::begin(ia), std::end(ia)));
-    }
-    {
-        const int ia[] = {1, 3, 5, 2, 4, 6};
-        unary_counting_predicate<is_odd, int> pred((is_odd()));
-        assert( std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
-                                    input_iterator<const int*>(std::end(ia)),
-                                    std::ref(pred)));
-        assert(pred.count() <= std::distance(std::begin(ia), std::end(ia)));
-    }
-    {
-        const int ia[] = {2, 4, 6, 1, 3, 5};
-        unary_counting_predicate<is_odd, int> pred((is_odd()));
-        assert(!std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
-                                    input_iterator<const int*>(std::end(ia)),
-                                    std::ref(pred)));
-        assert(pred.count() <= std::distance(std::begin(ia), std::end(ia)));
-    }
-    {
-        const int ia[] = {1, 3, 5, 2, 4, 6, 7};
-        unary_counting_predicate<is_odd, int> pred((is_odd()));
-        assert(!std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
-                                    input_iterator<const int*>(std::end(ia)),
-                                    std::ref(pred)));
-        assert(pred.count() <= std::distance(std::begin(ia), std::end(ia)));
-    }
-    {
-        const int ia[] = {1, 3, 5, 2, 4, 6, 7};
-        unary_counting_predicate<is_odd, int> pred((is_odd()));
-        assert( std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
-                                    input_iterator<const int*>(std::begin(ia)),
-                                    std::ref(pred)));
-        assert(pred.count() <= std::distance(std::begin(ia), std::begin(ia)));
-    }
-    {
-        const int ia[] = {1, 3, 5, 7, 9, 11, 2};
-        unary_counting_predicate<is_odd, int> pred((is_odd()));
-        assert( std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
-                                    input_iterator<const int*>(std::end(ia)),
-                                    std::ref(pred)));
-        assert(pred.count() <= std::distance(std::begin(ia), std::end(ia)));
-    }
+int main() {
+  {
+    const int ia[] = {1, 2, 3, 4, 5, 6};
+    unary_counting_predicate<is_odd, int> pred((is_odd()));
+    assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
+                                input_iterator<const int *>(std::end(ia)),
+                                std::ref(pred)));
+    assert(static_cast<std::ptrdiff_t>(pred.count()) <=
+           std::distance(std::begin(ia), std::end(ia)));
+  }
+  {
+    const int ia[] = {1, 3, 5, 2, 4, 6};
+    unary_counting_predicate<is_odd, int> pred((is_odd()));
+    assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
+                               input_iterator<const int *>(std::end(ia)),
+                               std::ref(pred)));
+    assert(static_cast<std::ptrdiff_t>(pred.count()) <=
+           std::distance(std::begin(ia), std::end(ia)));
+  }
+  {
+    const int ia[] = {2, 4, 6, 1, 3, 5};
+    unary_counting_predicate<is_odd, int> pred((is_odd()));
+    assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
+                                input_iterator<const int *>(std::end(ia)),
+                                std::ref(pred)));
+    assert(static_cast<std::ptrdiff_t>(pred.count()) <=
+           std::distance(std::begin(ia), std::end(ia)));
+  }
+  {
+    const int ia[] = {1, 3, 5, 2, 4, 6, 7};
+    unary_counting_predicate<is_odd, int> pred((is_odd()));
+    assert(!std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
+                                input_iterator<const int *>(std::end(ia)),
+                                std::ref(pred)));
+    assert(static_cast<std::ptrdiff_t>(pred.count()) <=
+           std::distance(std::begin(ia), std::end(ia)));
+  }
+  {
+    const int ia[] = {1, 3, 5, 2, 4, 6, 7};
+    unary_counting_predicate<is_odd, int> pred((is_odd()));
+    assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
+                               input_iterator<const int *>(std::begin(ia)),
+                               std::ref(pred)));
+    assert(static_cast<std::ptrdiff_t>(pred.count()) <=
+           std::distance(std::begin(ia), std::begin(ia)));
+  }
+  {
+    const int ia[] = {1, 3, 5, 7, 9, 11, 2};
+    unary_counting_predicate<is_odd, int> pred((is_odd()));
+    assert(std::is_partitioned(input_iterator<const int *>(std::begin(ia)),
+                               input_iterator<const int *>(std::end(ia)),
+                               std::ref(pred)));
+    assert(static_cast<std::ptrdiff_t>(pred.count()) <=
+           std::distance(std::begin(ia), std::end(ia)));
+  }
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
new file mode 100644
index 000000000000..d769ad850c31
--- /dev/null
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++14
+
+// <algorithm>
+
+// template <class PopulationIterator, class SampleIterator, class Distance,
+//           class UniformRandomNumberGenerator>
+// SampleIterator sample(PopulationIterator first, PopulationIterator last,
+//                       SampleIterator out, Distance n,
+//                       UniformRandomNumberGenerator &&g);
+
+#include <algorithm>
+#include <random>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class PopulationIterator, class SampleIterator> void test() {
+  int ia[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+  const unsigned is = sizeof(ia) / sizeof(ia[0]);
+  const unsigned os = 4;
+  int oa[os];
+  std::minstd_rand g;
+  std::sample(PopulationIterator(ia), PopulationIterator(ia + is),
+                            SampleIterator(oa), os, g);
+}
+
+int main() {
+  // expected-error@algorithm:* {{static_assert failed "SampleIterator must meet the requirements of RandomAccessIterator"}}
+  // expected-error@algorithm:* 2 {{does not provide a subscript operator}}
+  // expected-error@algorithm:* {{invalid operands}}
+  test<input_iterator<int *>, output_iterator<int *> >();
+}
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
new file mode 100644
index 000000000000..0a14c6695b06
--- /dev/null
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp
@@ -0,0 +1,160 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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, c++14
+
+// <algorithm>
+
+// template <class PopulationIterator, class SampleIterator, class Distance,
+//           class UniformRandomNumberGenerator>
+// SampleIterator sample(PopulationIterator first, PopulationIterator last,
+//                       SampleIterator out, Distance n,
+//                       UniformRandomNumberGenerator &&g);
+
+#include <algorithm>
+#include <random>
+#include <type_traits>
+#include <cassert>
+#include <cstddef>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+struct ReservoirSampleExpectations {
+  enum { os = 4 };
+  static int oa1[os];
+  static int oa2[os];
+};
+
+int ReservoirSampleExpectations::oa1[] = {10, 5, 9, 4};
+int ReservoirSampleExpectations::oa2[] = {5, 2, 10, 4};
+
+struct SelectionSampleExpectations {
+  enum { os = 4 };
+  static int oa1[os];
+  static int oa2[os];
+};
+
+int SelectionSampleExpectations::oa1[] = {1, 4, 6, 7};
+int SelectionSampleExpectations::oa2[] = {1, 2, 6, 8};
+
+template <class IteratorCategory> struct TestExpectations
+    : public SelectionSampleExpectations {};
+
+template <>
+struct TestExpectations<std::input_iterator_tag>
+    : public ReservoirSampleExpectations {};
+
+template <template<class...> class PopulationIteratorType, class PopulationItem,
+          template<class...> class SampleIteratorType, class SampleItem>
+void test() {
+  typedef PopulationIteratorType<PopulationItem *> PopulationIterator;
+  typedef SampleIteratorType<SampleItem *> SampleIterator;
+  PopulationItem ia[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+  const unsigned is = sizeof(ia) / sizeof(ia[0]);
+  typedef TestExpectations<typename std::iterator_traits<
+      PopulationIterator>::iterator_category> Expectations;
+  const unsigned os = Expectations::os;
+  SampleItem oa[os];
+  const int *oa1 = Expectations::oa1;
+  ((void)oa1); // Prevent unused warning
+  const int *oa2 = Expectations::oa2;
+  ((void)oa2); // Prevent unused warning
+  std::minstd_rand g;
+  SampleIterator end;
+  end = std::sample(PopulationIterator(ia),
+                                  PopulationIterator(ia + is),
+                                  SampleIterator(oa), os, g);
+  assert(static_cast<std::size_t>(end.base() - oa) == std::min(os, is));
+  // sample() is deterministic but non-reproducible;
+  // its results can vary between implementations.
+  LIBCPP_ASSERT(std::equal(oa, oa + os, oa1));
+  end = std::sample(PopulationIterator(ia),
+                                  PopulationIterator(ia + is),
+                                  SampleIterator(oa), os, std::move(g));
+  assert(static_cast<std::size_t>(end.base() - oa) == std::min(os, is));
+  LIBCPP_ASSERT(std::equal(oa, oa + os, oa2));
+}
+
+template <template<class...> class PopulationIteratorType, class PopulationItem,
+          template<class...> class SampleIteratorType, class SampleItem>
+void test_empty_population() {
+  typedef PopulationIteratorType<PopulationItem *> PopulationIterator;
+  typedef SampleIteratorType<SampleItem *> SampleIterator;
+  PopulationItem ia[] = {42};
+  const unsigned os = 4;
+  SampleItem oa[os];
+  std::minstd_rand g;
+  SampleIterator end =
+      std::sample(PopulationIterator(ia), PopulationIterator(ia),
+                                SampleIterator(oa), os, g);
+  assert(end.base() == oa);
+}
+
+template <template<class...> class PopulationIteratorType, class PopulationItem,
+          template<class...> class SampleIteratorType, class SampleItem>
+void test_empty_sample() {
+  typedef PopulationIteratorType<PopulationItem *> PopulationIterator;
+  typedef SampleIteratorType<SampleItem *> SampleIterator;
+  PopulationItem ia[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+  const unsigned is = sizeof(ia) / sizeof(ia[0]);
+  SampleItem oa[1];
+  std::minstd_rand g;
+  SampleIterator end =
+      std::sample(PopulationIterator(ia), PopulationIterator(ia + is),
+                                SampleIterator(oa), 0, g);
+  assert(end.base() == oa);
+}
+
+template <template<class...> class PopulationIteratorType, class PopulationItem,
+          template<class...> class SampleIteratorType, class SampleItem>
+void test_small_population() {
+  // The population size is less than the sample size.
+  typedef PopulationIteratorType<PopulationItem *> PopulationIterator;
+  typedef SampleIteratorType<SampleItem *> SampleIterator;
+  PopulationItem ia[] = {1, 2, 3, 4, 5};
+  const unsigned is = sizeof(ia) / sizeof(ia[0]);
+  const unsigned os = 8;
+  SampleItem oa[os];
+  const SampleItem oa1[] = {1, 2, 3, 4, 5};
+  std::minstd_rand g;
+  SampleIterator end;
+  end = std::sample(PopulationIterator(ia),
+                                  PopulationIterator(ia + is),
+                                  SampleIterator(oa), os, g);
+  assert(static_cast<std::size_t>(end.base() - oa) == std::min(os, is));
+  typedef typename std::iterator_traits<PopulationIterator>::iterator_category PopulationCategory;
+  if (std::is_base_of<std::forward_iterator_tag, PopulationCategory>::value) {
+    assert(std::equal(oa, end.base(), oa1));
+  } else {
+    assert(std::is_permutation(oa, end.base(), oa1));
+  }
+}
+
+int main() {
+  test<input_iterator, int, random_access_iterator, int>();
+  test<forward_iterator, int, output_iterator, int>();
+  test<forward_iterator, int, random_access_iterator, int>();
+
+  test<input_iterator, int, random_access_iterator, double>();
+  test<forward_iterator, int, output_iterator, double>();
+  test<forward_iterator, int, random_access_iterator, double>();
+
+  test_empty_population<input_iterator, int, random_access_iterator, int>();
+  test_empty_population<forward_iterator, int, output_iterator, int>();
+  test_empty_population<forward_iterator, int, random_access_iterator, int>();
+
+  test_empty_sample<input_iterator, int, random_access_iterator, int>();
+  test_empty_sample<forward_iterator, int, output_iterator, int>();
+  test_empty_sample<forward_iterator, int, random_access_iterator, int>();
+
+  test_small_population<input_iterator, int, random_access_iterator, int>();
+  test_small_population<forward_iterator, int, output_iterator, int>();
+  test_small_population<forward_iterator, int, random_access_iterator, int>();
+}
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp
new file mode 100644
index 000000000000..db484238c95f
--- /dev/null
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.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, c++14
+
+// <algorithm>
+
+// template <class PopulationIterator, class SampleIterator, class Distance,
+//           class UniformRandomNumberGenerator>
+// SampleIterator sample(PopulationIterator first, PopulationIterator last,
+//                       SampleIterator out, Distance n,
+//                       UniformRandomNumberGenerator &&g);
+
+#include <algorithm>
+#include <random>
+#include <cassert>
+
+#include "test_iterators.h"
+
+// Stable if and only if PopulationIterator meets the requirements of a
+// ForwardIterator type.
+template <class PopulationIterator, class SampleIterator>
+void test_stability(bool expect_stable) {
+  const unsigned kPopulationSize = 100;
+  int ia[kPopulationSize];
+  for (unsigned i = 0; i < kPopulationSize; ++i)
+    ia[i] = i;
+  PopulationIterator first(ia);
+  PopulationIterator last(ia + kPopulationSize);
+
+  const unsigned kSampleSize = 20;
+  int oa[kPopulationSize];
+  SampleIterator out(oa);
+
+  std::minstd_rand g;
+
+  const int kIterations = 1000;
+  bool unstable = false;
+  for (int i = 0; i < kIterations; ++i) {
+    std::sample(first, last, out, kSampleSize, g);
+    unstable |= !std::is_sorted(oa, oa + kSampleSize);
+  }
+  assert(expect_stable == !unstable);
+}
+
+int main() {
+  test_stability<forward_iterator<int *>, output_iterator<int *> >(true);
+  test_stability<input_iterator<int *>, random_access_iterator<int *> >(false);
+}
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
index a14ccf9e5e6c..e24598a9bc12 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp
@@ -17,6 +17,8 @@
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     int ia[] = {1, 2, 3, 4};
@@ -24,7 +26,9 @@ int main()
     int ia2[] = {4, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     std::random_shuffle(ia, ia+sa);
-    assert(std::equal(ia, ia+sa, ia1));
+    LIBCPP_ASSERT(std::equal(ia, ia+sa, ia1));
+    assert(std::is_permutation(ia, ia+sa, ia1));
     std::random_shuffle(ia, ia+sa);
-    assert(std::equal(ia, ia+sa, ia2));
+    LIBCPP_ASSERT(std::equal(ia, ia+sa, ia2));
+    assert(std::is_permutation(ia, ia+sa, ia2));
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
index b944c89e3519..c923d847f11e 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp
@@ -17,10 +17,13 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstddef>
+
+#include "test_macros.h"
 
 struct gen
 {
-    int operator()(int n)
+    std::ptrdiff_t operator()(std::ptrdiff_t n)
     {
         return n-1;
     }
@@ -33,5 +36,6 @@ int main()
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     gen r;
     std::random_shuffle(ia, ia+sa, r);
-    assert(std::equal(ia, ia+sa, ia1));
+    LIBCPP_ASSERT(std::equal(ia, ia+sa, ia1));
+    assert(std::is_permutation(ia, ia+sa, ia1));
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
index 343ae90101ff..512acc392de8 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp
@@ -17,6 +17,8 @@
 #include <random>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     int ia[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
@@ -25,7 +27,9 @@ int main()
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     std::minstd_rand g;
     std::shuffle(ia, ia+sa, g);
-    assert(std::equal(ia, ia+sa, ia1));
-    std::shuffle(ia, ia+sa, g);
-    assert(std::equal(ia, ia+sa, ia2));
+    LIBCPP_ASSERT(std::equal(ia, ia+sa, ia1));
+    assert(std::is_permutation(ia, ia+sa, ia1));
+    std::shuffle(ia, ia+sa, std::move(g));
+    LIBCPP_ASSERT(std::equal(ia, ia+sa, ia2));
+    assert(std::is_permutation(ia, ia+sa, ia2));
 }
diff --git a/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
index b7da7354ca25..515c79761ee8 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
@@ -15,10 +15,9 @@
 
 #include <algorithm>
 #include <cassert>
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #include <memory>
-#endif
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class Iter>
@@ -26,7 +25,7 @@ void
 test()
 {
     int ia[] = {0};
-    const unsigned sa = sizeof(ia)/sizeof(ia[0]);
+    const int sa = static_cast<int>(sizeof(ia)/sizeof(ia[0]));
     Iter r = std::rotate(Iter(ia), Iter(ia), Iter(ia));
     assert(base(r) == ia);
     assert(ia[0] == 0);
@@ -38,7 +37,7 @@ test()
     assert(ia[0] == 0);
 
     int ib[] = {0, 1};
-    const unsigned sb = sizeof(ib)/sizeof(ib[0]);
+    const int sb = static_cast<int>(sizeof(ib)/sizeof(ib[0]));
     r = std::rotate(Iter(ib), Iter(ib), Iter(ib+sb));
     assert(base(r) == ib+sb);
     assert(ib[0] == 0);
@@ -53,7 +52,7 @@ test()
     assert(ib[1] == 0);
 
     int ic[] = {0, 1, 2};
-    const unsigned sc = sizeof(ic)/sizeof(ic[0]);
+    const int sc = static_cast<int>(sizeof(ic)/sizeof(ic[0]));
     r = std::rotate(Iter(ic), Iter(ic), Iter(ic+sc));
     assert(base(r) == ic+sc);
     assert(ic[0] == 0);
@@ -76,7 +75,7 @@ test()
     assert(ic[2] == 2);
 
     int id[] = {0, 1, 2, 3};
-    const unsigned sd = sizeof(id)/sizeof(id[0]);
+    const int sd = static_cast<int>(sizeof(id)/sizeof(id[0]));
     r = std::rotate(Iter(id), Iter(id), Iter(id+sd));
     assert(base(r) == id+sd);
     assert(id[0] == 0);
@@ -109,7 +108,7 @@ test()
     assert(id[3] == 1);
 
     int ie[] = {0, 1, 2, 3, 4};
-    const unsigned se = sizeof(ie)/sizeof(ie[0]);
+    const int se = static_cast<int>(sizeof(ie)/sizeof(ie[0]));
     r = std::rotate(Iter(ie), Iter(ie), Iter(ie+se));
     assert(base(r) == ie+se);
     assert(ie[0] == 0);
@@ -154,7 +153,7 @@ test()
     assert(ie[4] == 4);
 
     int ig[] = {0, 1, 2, 3, 4, 5};
-    const unsigned sg = sizeof(ig)/sizeof(ig[0]);
+    const int sg = static_cast<int>(sizeof(ig)/sizeof(ig[0]));
     r = std::rotate(Iter(ig), Iter(ig), Iter(ig+sg));
     assert(base(r) == ig+sg);
     assert(ig[0] == 0);
@@ -213,14 +212,14 @@ test()
     assert(ig[5] == 2);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
 
 template <class Iter>
 void
 test1()
 {
     std::unique_ptr<int> ia[1];
-    const unsigned sa = sizeof(ia)/sizeof(ia[0]);
+    const int sa = static_cast<int>(sizeof(ia)/sizeof(ia[0]));
     for (int i = 0; i < sa; ++i)
         ia[i].reset(new int(i));
     Iter r = std::rotate(Iter(ia), Iter(ia), Iter(ia));
@@ -234,7 +233,7 @@ test1()
     assert(*ia[0] == 0);
 
     std::unique_ptr<int> ib[2];
-    const unsigned sb = sizeof(ib)/sizeof(ib[0]);
+    const int sb = static_cast<int>(sizeof(ib)/sizeof(ib[0]));
     for (int i = 0; i < sb; ++i)
         ib[i].reset(new int(i));
     r = std::rotate(Iter(ib), Iter(ib), Iter(ib+sb));
@@ -251,7 +250,7 @@ test1()
     assert(*ib[1] == 0);
 
     std::unique_ptr<int> ic[3];
-    const unsigned sc = sizeof(ic)/sizeof(ic[0]);
+    const int sc = static_cast<int>(sizeof(ic)/sizeof(ic[0]));
     for (int i = 0; i < sc; ++i)
         ic[i].reset(new int(i));
     r = std::rotate(Iter(ic), Iter(ic), Iter(ic+sc));
@@ -276,7 +275,7 @@ test1()
     assert(*ic[2] == 2);
 
     std::unique_ptr<int> id[4];
-    const unsigned sd = sizeof(id)/sizeof(id[0]);
+    const int sd = static_cast<int>(sizeof(id)/sizeof(id[0]));
     for (int i = 0; i < sd; ++i)
         id[i].reset(new int(i));
     r = std::rotate(Iter(id), Iter(id), Iter(id+sd));
@@ -311,7 +310,7 @@ test1()
     assert(*id[3] == 1);
 
     std::unique_ptr<int> ie[5];
-    const unsigned se = sizeof(ie)/sizeof(ie[0]);
+    const int se = static_cast<int>(sizeof(ie)/sizeof(ie[0]));
     for (int i = 0; i < se; ++i)
         ie[i].reset(new int(i));
     r = std::rotate(Iter(ie), Iter(ie), Iter(ie+se));
@@ -358,7 +357,7 @@ test1()
     assert(*ie[4] == 4);
 
     std::unique_ptr<int> ig[6];
-    const unsigned sg = sizeof(ig)/sizeof(ig[0]);
+    const int sg = static_cast<int>(sizeof(ig)/sizeof(ig[0]));
     for (int i = 0; i < sg; ++i)
         ig[i].reset(new int(i));
     r = std::rotate(Iter(ig), Iter(ig), Iter(ig+sg));
@@ -419,7 +418,7 @@ test1()
     assert(*ig[5] == 2);
 }
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif  // TEST_STD_VER >= 11
 
 int main()
 {
@@ -428,12 +427,12 @@ int main()
     test<random_access_iterator<int*> >();
     test<int*>();
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
 
     test1<forward_iterator<std::unique_ptr<int>*> >();
     test1<bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*>();
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 }