[libcxx] [test] Fix non-Standard assumptions when testing sample().

[STL_MSFT]

Summary

[libcxx] [test] Fix non-Standard assumptions when testing sample().

sample() isn't specified with a reproducible algorithm, so expecting
exact output is non-Standard. Mark those tests with LIBCPP_ASSERT.

In test_small_population(), we're guaranteed to get all of the elements,
but not necessarily in their original order. When PopulationCategory is
forward, we're guaranteed stability (and can therefore test equal()).
Otherwise, we can only test is_permutation(). (As it happens, both libcxx
and MSVC's STL provide stability in this scenario for input-only iterators.)

[EricWF]

LGTM.

test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp

74

Please add a comment here explaining that the algorithm is non-reproducable.

[STL_MSFT]

Added the requested comment, will commit.

test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp

74

Adding:

// sample() is deterministic but non-reproducible;
// its results can vary between implementations.

[STL_MSFT]

Thanks, r287383 (including the requested comment).

test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp

 // 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 "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};
void test() {
   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(end.base() - oa == std::min(os, is));
-  assert(std::equal(oa, oa + os, oa1));
+  LIBCPP_ASSERT(std::equal(oa, oa + os, oa1));
   end = std::sample(PopulationIterator(ia),
                                   PopulationIterator(ia + is),
                                   SampleIterator(oa), os, std::move(g));
   assert(end.base() - oa == std::min(os, is));
-  assert(std::equal(oa, oa + os, oa2));
+  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};
void test_small_population() {
   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(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>();