[libcxx] [test] Fix portability issues in <random> tests.

[STL_MSFT]

Summary

Fix portability issues in <random> tests.

Three tests were asserting equal() after shuffling a sequence, which assumes the exact behavior of libc++'s implementation. To be portable, yet retain some level of validation, I'm marking the equal() checks as libc++ specific, but adding unconditional is_permutation() checks.

Additionally, one test was assuming libc++'s choice of default_random_engine, which isn't guaranteed by the Standard. Mark that assert as libc++ specific.

[EricWF]

r276585.

test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp

 // template<RandomAccessIterator Iter>
 //   requires ShuffleIterator<Iter>
 //   void
 //   random_shuffle(Iter first, Iter last);
 
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     int ia[] = {1, 2, 3, 4};
     int ia1[] = {1, 4, 3, 2};
     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));
 }

test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp

 //   requires ShuffleIterator<Iter>
 //         && Convertible<Rand::result_type, Iter::difference_type>
 //   void
 //   random_shuffle(Iter first, Iter last, Rand&& rand);
 
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
+
 struct gen
 {
     int operator()(int n)
     {
         return n-1;
     }
 };
 
 int main()
 {
     int ia[] = {1, 2, 3, 4};
     int ia1[] = {4, 1, 2, 3};
     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));
 }

test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_urng.pass.cpp

 // template<class RandomAccessIterator, class UniformRandomNumberGenerator>
 //     void shuffle(RandomAccessIterator first, RandomAccessIterator last,
 //                  UniformRandomNumberGenerator& g);
 
 #include <algorithm>
 #include <random>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     int ia[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     int ia1[] = {2, 7, 1, 4, 3, 6, 5, 10, 9, 8};
     int ia2[] = {1, 8, 3, 4, 6, 9, 5, 7, 2, 10};
     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));
+    LIBCPP_ASSERT(std::equal(ia, ia+sa, ia1));
+    assert(std::is_permutation(ia, ia+sa, ia1));
     std::shuffle(ia, ia+sa, g);
-    assert(std::equal(ia, ia+sa, ia2));
+    LIBCPP_ASSERT(std::equal(ia, ia+sa, ia2));
+    assert(std::is_permutation(ia, ia+sa, ia2));
 }

test/std/numerics/rand/rand.predef/default_random_engine.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // typedef minstd_rand0 default_random_engine;
 
 #include <random>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     std::default_random_engine e;
     e.discard(9999);
-    assert(e() == 399268537u);
+    LIBCPP_ASSERT(e() == 399268537u);
 }