Enable the -Wsign-compare warning to better support MSVC

llvm-svn: 289363

1 files changed, 58 insertions, 53 deletions

diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
index df9e350f36c..8597b08da8c 100644
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
@@ -15,64 +15,69 @@
 
 #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)));
+  }
 }