[libcxx] [test] Add assertions to quiet analysis warnings about array bounds.

[STL_MSFT]

Summary

Add assertions to quiet analysis warnings about array bounds.

In the partial_sort tests, the N >= M assertion is just a good sanity check, to detect bogus testcases. MSVC's /analyze needs to see the i < N assertion explicitly, otherwise it worries that array[i] might be out-of-bounds. I gave those ones comments because they are technically redundant.

In eval.pass.cpp, the assertions simply say that we aren't going to try to access arrays out-of-bounds, which I assume is guaranteed by the logic of the test, but this is far from obvious, so the assertions are valuable in their own right.

Fixes MSVC warnings of the form:
warning C6385: Reading invalid data from 'array': the readable size is 'N*4' bytes, but '8' bytes may be read.
These warnings are valuable, so I'd prefer to suppress them locally instead of globally, especially given that so few places are affected.

[EricWF]

r273820.

test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp

 
 #include <algorithm>
 #include <cassert>
 
 void
 test_larger_sorts(unsigned N, unsigned M)
 {
     assert(N != 0);
+    assert(N >= M);
     int* array = new int[N];
     for (int i = 0; i < N; ++i)
         array[i] = i;
     std::random_shuffle(array, array+N);
     std::partial_sort(array, array+M, array+N);
     for (int i = 0; i < M; ++i)
+    {
+        assert(i < N); // quiet analysis warnings
         assert(array[i] == i);
+    }
     delete [] array;
 }
 
 void
 test_larger_sorts(unsigned N)
 {
     test_larger_sorts(N, 0);
     test_larger_sorts(N, 1);

test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp

 };
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 void
 test_larger_sorts(unsigned N, unsigned M)
 {
     assert(N != 0);
+    assert(N >= M);
     int* array = new int[N];
     for (int i = 0; i < N; ++i)
         array[i] = i;
     std::random_shuffle(array, array+N);
     std::partial_sort(array, array+M, array+N, std::greater<int>());
     for (int i = 0; i < M; ++i)
+    {
+        assert(i < N); // quiet analysis warnings
         assert(array[i] == N-i-1);
+    }
     delete [] array;
 }
 
 void
 test_larger_sorts(unsigned N)
 {
     test_larger_sorts(N, 0);
     test_larger_sorts(N, 1);

test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp

test4()
     for (int i = 0; i < N; ++i)
     {
         int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
         if (k != kp)
         {
             a = 0;
             for (int j = 0; j < k; ++j)
                 a += areas[j];
+            assert(k < Np);
             m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
             bk = b[k];
             c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
             kp = k;
         }
         assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
     }
 }
test5()
     double a = std::numeric_limits<double>::quiet_NaN();
     double m = std::numeric_limits<double>::quiet_NaN();
     double bk = std::numeric_limits<double>::quiet_NaN();
     double c = std::numeric_limits<double>::quiet_NaN();
     std::vector<double> areas(Np);
     double S = 0;
     for (int i = 0; i < areas.size(); ++i)
     {
+        assert(i < Np);
         areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
         S += areas[i];
     }
     for (int i = 0; i < areas.size(); ++i)
         areas[i] /= S;
     for (int i = 0; i < Np+1; ++i)
         p[i] /= S;
     for (int i = 0; i < N; ++i)
     {
         int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
         if (k != kp)
         {
             a = 0;
             for (int j = 0; j < k; ++j)
                 a += areas[j];
+            assert(k < Np);
             m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
             bk = b[k];
             c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
             kp = k;
         }
         assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
     }
 }