Enable the -Wsign-compare warning to better support MSVC
authorEric Fiselier <eric@efcs.ca>
Sun, 11 Dec 2016 05:31:00 +0000 (05:31 +0000)
committerEric Fiselier <eric@efcs.ca>
Sun, 11 Dec 2016 05:31:00 +0000 (05:31 +0000)
llvm-svn: 289363

67 files changed:
libcxx/include/vector
libcxx/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp
libcxx/test/libcxx/test/config.py
libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp
libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.sort/stable.sort/stable_sort.pass.cpp
libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace_back.pass.cpp
libcxx/test/std/containers/sequences/deque/deque.modifiers/emplace_front.pass.cpp
libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp
libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp
libcxx/test/std/diagnostics/syserr/syserr.hash/error_code.pass.cpp
libcxx/test/std/diagnostics/syserr/syserr.hash/error_condition.pass.cpp
libcxx/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy/copy.pass.cpp
libcxx/test/std/experimental/string.view/string.view.iterators/end.pass.cpp
libcxx/test/std/experimental/string.view/string.view.iterators/rend.pass.cpp
libcxx/test/std/input.output/file.streams/fstreams/filebuf.virtuals/underflow.pass.cpp
libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.pass.cpp
libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.pass.cpp
libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.access/access.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.access/const_access.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.assign/copy_assign.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.assign/initializer_list_assign.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.assign/move_assign.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.cons/copy.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.cons/initializer_list.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.cons/move.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.cons/pointer_size.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.unary/bit_not.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.unary/negate.pass.cpp
libcxx/test/std/numerics/numarray/template.valarray/valarray.unary/plus.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval_param.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval_param.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval_param.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval_param.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/eval_param.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
libcxx/test/std/utilities/function.objects/comparisons/pointer_comparison_test_helper.hpp
libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp

index f5bd7d072451183eb77b383dcc44d750ffb0175e..f175e47be9af6b2e8b7f54696cacba80717fbf6d 100644 (file)
@@ -3093,7 +3093,9 @@ typename enable_if
 >::type
 vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
 {
-    difference_type __n = _VSTD::distance(__first, __last);
+    const difference_type __n_signed = _VSTD::distance(__first, __last);
+    _LIBCPP_ASSERT(__n_signed >= 0, "invalid range specified");
+    const size_type __n = static_cast<size_type>(__n_signed);
     iterator __r;
     size_type __c = capacity();
     if (__n <= __c && size() <= __c - __n)
index fe425b7e8c185c079698a4f91b622c7015fd65db..38aefdfbaf47612379f44cee84a6634d78c1072e 100644 (file)
@@ -29,6 +29,7 @@
 #include <__config>
 
 #include <experimental/dynarray>
+#include <cstddef>
 #include <cassert>
 
 #include <algorithm>
@@ -46,10 +47,11 @@ void dyn_test_const ( const dynarray<T> &dyn ) {
     assert ( data + dyn.size() - 1 == &*dyn.rbegin ());
     assert ( data + dyn.size() - 1 == &*dyn.crbegin ());
 
-    assert ( dyn.size () == std::distance ( dyn.begin(), dyn.end()));
-    assert ( dyn.size () == std::distance ( dyn.cbegin(), dyn.cend()));
-    assert ( dyn.size () == std::distance ( dyn.rbegin(), dyn.rend()));
-    assert ( dyn.size () == std::distance ( dyn.crbegin(), dyn.crend()));
+    std::ptrdiff_t ds = static_cast<std::ptrdiff_t>(dyn.size());
+    assert (ds == std::distance ( dyn.begin(), dyn.end()));
+    assert (ds == std::distance ( dyn.cbegin(), dyn.cend()));
+    assert (ds == std::distance ( dyn.rbegin(), dyn.rend()));
+    assert (ds == std::distance ( dyn.crbegin(), dyn.crend()));
 
     assert (   dyn.begin ()  ==   dyn.cbegin ());
     assert ( &*dyn.begin ()  == &*dyn.cbegin ());
@@ -68,10 +70,11 @@ void dyn_test ( dynarray<T> &dyn ) {
     assert ( data + dyn.size() - 1 == &*dyn.rbegin ());
     assert ( data + dyn.size() - 1 == &*dyn.crbegin ());
 
-    assert ( dyn.size () == std::distance ( dyn.begin(), dyn.end()));
-    assert ( dyn.size () == std::distance ( dyn.cbegin(), dyn.cend()));
-    assert ( dyn.size () == std::distance ( dyn.rbegin(), dyn.rend()));
-    assert ( dyn.size () == std::distance ( dyn.crbegin(), dyn.crend()));
+    std::ptrdiff_t ds = static_cast<std::ptrdiff_t>(dyn.size());
+    assert (ds == std::distance ( dyn.begin(), dyn.end()));
+    assert (ds == std::distance ( dyn.cbegin(), dyn.cend()));
+    assert (ds == std::distance ( dyn.rbegin(), dyn.rend()));
+    assert (ds == std::distance ( dyn.crbegin(), dyn.crend()));
 
     assert (   dyn.begin ()  ==   dyn.cbegin ());
     assert ( &*dyn.begin ()  == &*dyn.cbegin ());
index fa84ddebad9540096479389569cba06211eeacd1..0bd775d7afb1a0c93eed39a560f1d9582ba7084c 100644 (file)
@@ -656,12 +656,16 @@ class Configuration(object):
             self.cxx.addWarningFlagIfSupported('-Wno-pessimizing-move')
             self.cxx.addWarningFlagIfSupported('-Wno-c++11-extensions')
             self.cxx.addWarningFlagIfSupported('-Wno-user-defined-literals')
+            # These warnings should be enabled in order to support the MSVC
+            # team using the test suite; They enable the warnings below and
+            # expect the test suite to be clean.
+            self.cxx.addWarningFlagIfSupported('-Wsign-compare')
+            # FIXME: Enable the two warnings below.
+            self.cxx.addWarningFlagIfSupported('-Wno-unused-variable')
+            self.cxx.addWarningFlagIfSupported('-Wno-unused-parameter')
             # TODO(EricWF) Remove the unused warnings once the test suite
             # compiles clean with them.
-            self.cxx.addWarningFlagIfSupported('-Wno-sign-compare')
             self.cxx.addWarningFlagIfSupported('-Wno-unused-local-typedef')
-            self.cxx.addWarningFlagIfSupported('-Wno-unused-variable')
-            self.cxx.addWarningFlagIfSupported('-Wno-unused-parameter')
             std = self.get_lit_conf('std', None)
             if std in ['c++98', 'c++03']:
                 # The '#define static_assert' provided by libc++ in C++03 mode
index df9e350f36c7c7df29f3a5debee2749d781fa872..8597b08da8cf59064d24a9c8505963cbfed8359a 100644 (file)
 
 #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)));
+  }
 }
index b7da7354ca2562d1979d73bea4ce203473d83c30..515c79761ee83a1f3ce821acb8b29e1c0c51e2fe 100644 (file)
 
 #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
 }
index 802d897670c70c6811cee1e74287ea7fa79537ec..e0b148499ca8212fc79fb7d0260ad031cca7a3a4 100644 (file)
@@ -35,7 +35,7 @@ void
 test()
 {
     const unsigned N = 1000;
-    const unsigned M = 10;
+    const int M = 10;
     std::vector<int> v(N);
     int x = 0;
     for (std::size_t i = 0; i < v.size(); ++i)
index 8c2b60819b07c4f53f1e4cdb2a4f5b69bcf33ad9..bc968f5b2aabc225041dc6d32c8e72cbd9c1bf5e 100644 (file)
@@ -42,7 +42,7 @@ void
 test()
 {
     const unsigned N = 1000;
-    const unsigned M = 10;
+    const int M = 10;
     std::vector<int> v(N);
     int x = 0;
     for (std::size_t i = 0; i < v.size(); ++i)
index c2d92d92081db04cbf00e5eb79356c4c05030e89..de0bbf25613e7706b66cb014cd99d19c00a848e0 100644 (file)
@@ -43,7 +43,7 @@ void
 test()
 {
     const unsigned N = 1000;
-    const unsigned M = 10;
+    const int M = 10;
     std::vector<int> v(N);
     int x = 0;
     for (std::size_t i = 0; i < v.size(); ++i)
index 2608104fca7b9e1f3033f6e2c44d273fc8c725c5..1fff1d7f5b6302a01cc1980142cf1c836d0c3737 100644 (file)
@@ -37,7 +37,7 @@ void
 test()
 {
     const unsigned N = 1000;
-    const unsigned M = 10;
+    const int M = 10;
     std::vector<int> v(N);
     int x = 0;
     for (std::size_t i = 0; i < v.size(); ++i)
index 6a5463246c7d0ed8fd57b4abbb02e2cd4e529a42..4ec5f6c000d681f6e437ddc3c94b35d6b2d8cb22 100644 (file)
@@ -38,7 +38,7 @@ void
 test()
 {
     const unsigned N = 1000;
-    const unsigned M = 10;
+    const int M = 10;
     std::vector<int> v(N);
     int x = 0;
     for (std::size_t i = 0; i < v.size(); ++i)
index 106f1499e990786f06d729e948bf1a013d4ee30b..710edb61c9b6e0b010db59459db6e89616551aa5 100644 (file)
@@ -37,7 +37,7 @@ void
 test()
 {
     const unsigned N = 1000;
-    const unsigned M = 10;
+    const int M = 10;
     std::vector<int> v(N);
     int x = 0;
     for (std::size_t i = 0; i < v.size(); ++i)
index 3fa346131ac6a0a66451e5c72d3b2f1a56a6884e..3268075b1b0bb75059f5d273a16a687978a33852 100644 (file)
@@ -38,7 +38,7 @@ void
 test()
 {
     const unsigned N = 1000;
-    const unsigned M = 10;
+    const int M = 10;
     std::vector<int> v(N);
     int x = 0;
     for (std::size_t i = 0; i < v.size(); ++i)
index 0e16d9bd17c71d4f8b5cfc7737039ae555d56d19..9d0545f0d9c50cefd801858a0f336f4efaa3544b 100644 (file)
 
 #include <algorithm>
 #include <functional>
+#include <memory>
 #include <cassert>
 
+#include "test_macros.h"
 #include "counting_predicates.hpp"
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#include <memory>
-
 struct indirect_less
 {
     template <class P>
@@ -30,9 +29,8 @@ struct indirect_less
         {return *x < *y;}
 };
 
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
-void test(unsigned N)
+void test(int N)
 {
     int* ia = new int [N];
     {
@@ -49,7 +47,7 @@ void test(unsigned N)
     for (int i = 0; i < N; ++i)
         ia[i] = i;
     std::make_heap(ia, ia+N, std::ref(pred));
-    assert(pred.count() <= 3*N);
+    assert(pred.count() <= 3u*N);
     assert(std::is_heap(ia, ia+N, pred));
     }
 
@@ -59,7 +57,7 @@ void test(unsigned N)
     for (int i = 0; i < N; ++i)
         ia[N-1-i] = i;
     std::make_heap(ia, ia+N, std::ref(pred));
-    assert(pred.count() <= 3*N);
+    assert(pred.count() <= 3u*N);
     assert(std::is_heap(ia, ia+N, pred));
     }
 
@@ -68,7 +66,7 @@ void test(unsigned N)
     binary_counting_predicate<std::greater<int>, int, int> pred ((std::greater<int>()));
     std::random_shuffle(ia, ia+N);
     std::make_heap(ia, ia+N, std::ref(pred));
-    assert(pred.count() <= 3*N);
+    assert(pred.count() <= 3u*N);
     assert(std::is_heap(ia, ia+N, pred));
     }
 
@@ -86,7 +84,7 @@ int main()
     test(10000);
     test(100000);
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#if TEST_STD_VER >= 11
     {
     const int N = 1000;
     std::unique_ptr<int>* ia = new std::unique_ptr<int> [N];
@@ -97,5 +95,5 @@ int main()
     assert(std::is_heap(ia, ia+N, indirect_less()));
     delete [] ia;
     }
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#endif
 }
index b4d25a93e50e5a612ec1e9d05358e4e4ee8cc5be..fd9e5f13c26a48944b7ce534c57a8e94614644b5 100644 (file)
@@ -74,7 +74,7 @@ test_one(unsigned N, unsigned M)
     std::inplace_merge(Iter(ia), Iter(ia+M), Iter(ia+N), std::ref(pred));
     if(N > 0)
     {
-        assert(ia[0] == N-1);
+        assert(ia[0] == static_cast<int>(N)-1);
         assert(ia[N-1] == 0);
         assert(std::is_sorted(ia, ia+N, std::greater<value_type>()));
         assert(pred.count() <= (N-1));
@@ -125,10 +125,10 @@ int main()
     test<S*>();
 
     {
-    unsigned N = 100;
+    int N = 100;
     unsigned M = 50;
     std::unique_ptr<int>* ia = new std::unique_ptr<int>[N];
-    for (unsigned i = 0; i < N; ++i)
+    for (int i = 0; i < N; ++i)
         ia[i].reset(new int(i));
     std::random_shuffle(ia, ia+N);
     std::sort(ia, ia+M, indirect_less());
index 2e8e0c30d94357ef3a15e630cc355e6665a501df..e60e156455f3142d67ee132d78afec0e66491a73 100644 (file)
@@ -18,6 +18,7 @@
 #include <functional>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class Iter>
@@ -66,7 +67,7 @@ void test_eq0(Iter first, Iter last, Pred p)
 
 void test_eq()
 {
-    const size_t N = 10;
+    const int N = 10;
     int* a = new int[N];
     for (int i = 0; i < N; ++i)
         a[i] = 10; // all the same
index 0f5c80c0d2598a435a2800edc8a1bb9ab5ed9c3b..c4c6e31eb6dd7b02938cde9d5ecd5e831f0b8913 100644 (file)
@@ -18,6 +18,7 @@
 #include <functional>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class Iter>
@@ -66,7 +67,7 @@ void test_eq0(Iter first, Iter last, Pred p)
 
 void test_eq()
 {
-    const size_t N = 10;
+    const int N = 10;
     int* a = new int[N];
     for (int i = 0; i < N; ++i)
         a[i] = 10; // all the same
index fc97778347bb45e8f348ef4716637483a2309fe5..c2805a656137f77b1d7c326e1556f1d737e18856 100644 (file)
@@ -62,7 +62,7 @@ test()
     test<Iter>(10);
     test<Iter>(1000);
     {
-    const unsigned N = 100;
+    const int N = 100;
     int* a = new int[N];
     for (int i = 0; i < N; ++i)
         a[i] = 5;
index a39512f2e634b411e112723f0a2290573c4b3244..7840638f742c9511983087195233bd14fd97a975 100644 (file)
@@ -18,6 +18,7 @@
 #include <functional>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 
 template <class Iter>
@@ -65,7 +66,7 @@ test()
     test<Iter>(10);
     test<Iter>(1000);
     {
-    const unsigned N = 100;
+    const int N = 100;
     int* a = new int[N];
     for (int i = 0; i < N; ++i)
         a[i] = 5;
index ea1e7dfe9faf1a6d6e8dd72470dfbbd9fdc41ab9..689433f9e45ba3395f5c7c48370e926b37bfc7f0 100644 (file)
@@ -63,7 +63,7 @@ test_sort_driver(RI f, RI l, int start)
     test_sort_driver_driver(f, l, start, l);
 }
 
-template <unsigned sa>
+template <int sa>
 void
 test_sort_()
 {
index 74a876cee19c271a574b7002994ec17377764401..336fcd0b3ddec50bf226ebda8cdfb87b2d7feac3 100644 (file)
@@ -63,7 +63,7 @@ test_sort_driver(RI f, RI l, int start)
     test_sort_driver_driver(f, l, start, l);
 }
 
-template <unsigned sa>
+template <int sa>
 void
 test_sort_()
 {
index f81cdf904193fa0ea2386aabbe2c9ee18cdcc364..e3a35362b186d9a8d9fa80d2ca546379f49606e3 100644 (file)
 // template <class... Args> reference emplace_back(Args&&... args);
 
 #include <deque>
+#include <cstddef>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
@@ -51,7 +53,8 @@ test(C& c1)
     std::size_t c1_osize = c1.size();
     Ref ref = c1.emplace_back(Emplaceable(1, 2.5));
     assert(c1.size() == c1_osize + 1);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(distance(c1.begin(), c1.end())
+               == static_cast<std::ptrdiff_t>(c1.size()));
     I i = c1.end();
     assert(*--i == Emplaceable(1, 2.5));
     assert(&(*i) == &ref);
index 668062d4af351f8f5ba04e3683d3401ff3572388..26c700de725342ae578bfb748fe12cd3fe97b00e 100644 (file)
 // template <class... Args> reference emplace_front(Args&&... args);
 
 #include <deque>
+#include <cstddef>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../Emplaceable.h"
 #include "min_allocator.h"
 
@@ -50,7 +52,8 @@ test(C& c1)
     std::size_t c1_osize = c1.size();
     Ref res_ref = c1.emplace_front(Emplaceable(1, 2.5));
     assert(c1.size() == c1_osize + 1);
-    assert(distance(c1.begin(), c1.end()) == c1.size());
+    assert(distance(c1.begin(), c1.end())
+               == static_cast<std::ptrdiff_t>(c1.size()));
     I i = c1.begin();
     assert(*i == Emplaceable(1, 2.5));
     assert(&res_ref == &(*i));
index 55884daf4f7a445cc814b43f1c9c610212ba8fa4..dc4fe44d5a3909750035a4540f39a6bb48d8cc79 100644 (file)
@@ -16,6 +16,8 @@
 #include <vector>
 #include <cassert>
 #include <cstddef>
+
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
@@ -32,7 +34,7 @@ int main()
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
@@ -48,7 +50,7 @@ int main()
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
@@ -66,7 +68,7 @@ int main()
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
@@ -85,7 +87,7 @@ int main()
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
@@ -102,7 +104,7 @@ int main()
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
@@ -118,7 +120,7 @@ int main()
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
index e4079426a16872bbf8f1a3ce70cd143074adcb15..4c1d20a9454c87815cbb5a61e5db9a4c74dda057 100644 (file)
@@ -19,6 +19,7 @@
 #include <vector>
 #include <cassert>
 #include <cstddef>
+#include "test_macros.h"
 #include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
@@ -38,7 +39,7 @@ int main()
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
@@ -55,7 +56,7 @@ int main()
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
@@ -73,7 +74,7 @@ int main()
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
@@ -91,7 +92,7 @@ int main()
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
@@ -108,7 +109,7 @@ int main()
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
@@ -125,7 +126,7 @@ int main()
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
@@ -154,7 +155,7 @@ int main()
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
@@ -171,7 +172,7 @@ int main()
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
-        for (int k = 0; k < N; ++j, ++k)
+        for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
index c8b3d98103c4da8461b7df89609dc0adad379ec1..04606e805e4ed488dbbe568cbf833ff4798716db 100644 (file)
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 
 void
-test(int i)
+test(std::size_t i)
 {
     typedef std::error_code T;
     typedef std::hash<T> H;
index eb3c06f2ed069912d3bea4e728fe7fc067216dd5..e520b54879afb2befb9351d5bdebacd2772081db 100644 (file)
@@ -23,7 +23,7 @@
 #include "test_macros.h"
 
 void
-test(int i)
+test(std::size_t i)
 {
     typedef std::error_condition T;
     typedef std::hash<T> H;
index 6e10ce51ce3a4ad1dc3d3128d868f91286c5884f..db10da092ef55adfd7418ab0bf31206f91da0058 100644 (file)
@@ -19,6 +19,7 @@
 
 #include <experimental/filesystem>
 #include <type_traits>
+#include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
@@ -196,7 +197,7 @@ TEST_CASE(from_is_directory)
 {
     struct FileInfo {
         path filename;
-        int size;
+        std::size_t size;
     };
     const FileInfo files[] = {
         {"file1", 0},
index 0eeafac4939c0e621ef2206cbdb2c37ede4ee904..1f22b3fbe4ba1219adc1aeda082e81e4bd5a1f0c 100644 (file)
@@ -12,6 +12,7 @@
 // constexpr const_iterator end() const;
 
 #include <experimental/string_view>
+#include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
@@ -38,9 +39,9 @@ test(S s)
         assert(ce2 !=  s.begin());
     }
 
-    assert(  e -  s.begin() == s.size());
-    assert(ce1 - cs.begin() == cs.size());
-    assert(ce2 - s.cbegin() == s.size());
+    assert(  e -  s.begin() == static_cast<std::ptrdiff_t>(s.size()));
+    assert(ce1 - cs.begin() == static_cast<std::ptrdiff_t>(cs.size()));
+    assert(ce2 - s.cbegin() == static_cast<std::ptrdiff_t>(s.size()));
 
     assert(  e == ce1);
     assert(  e == ce2);
index 55e28a2669486c2f05c3e57562cc5632b9aca63f..bd24c327e090526edada05fa9b240bb3f1139490 100644 (file)
@@ -12,6 +12,7 @@
 // constexpr const_iterator rend() const;
 
 #include <experimental/string_view>
+#include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
@@ -38,9 +39,9 @@ test(S s)
         assert(ce2 !=  s.rbegin());
     }
 
-    assert(  e -  s.rbegin() == s.size());
-    assert(ce1 - cs.rbegin() == cs.size());
-    assert(ce2 - s.crbegin() == s.size());
+    assert(  e -  s.rbegin() == static_cast<std::ptrdiff_t>(s.size()));
+    assert(ce1 - cs.rbegin() == static_cast<std::ptrdiff_t>(cs.size()));
+    assert(ce2 - s.crbegin() == static_cast<std::ptrdiff_t>(s.size()));
 
     assert(  e == ce1);
     assert(  e == ce2);
index 9ada23b454688d2bf14c83a928c30067bc17d3e9..0c5138063039a49ed63291e0616cfcf2a7d9af4c 100644 (file)
@@ -16,6 +16,7 @@
 // This test is not entirely portable
 
 #include <fstream>
+#include <cstddef>
 #include <cassert>
 
 #include "platform_support.h" // locale name macros
@@ -118,6 +119,6 @@ int main()
         assert(f.sbumpc() == 0x4E51);
         assert(f.sbumpc() == 0x4E52);
         assert(f.sbumpc() == 0x4E53);
-        assert(f.sbumpc() == -1);
+        assert(f.sbumpc() == static_cast<unsigned>(-1));
     }
 }
index 8f9d1e6cd1f089316d0c93d66b38dec023131eec..f645b32f26910509dbb2878ea8d83275afd8661d 100644 (file)
@@ -36,5 +36,5 @@ int main()
     assert(from_next - from == 9);
     assert(to_next - to == 9);
     for (unsigned i = 0; i < 9; ++i)
-        assert(to[i] == from[i]);
+        assert(to[i] == static_cast<char32_t>(from[i]));
 }
index 4e0f600097a0ab6a4c85a02c601f815b24b75c82..05a90d33d318405e171bc1b8ad311a3ecc6fb96b 100644 (file)
@@ -40,6 +40,6 @@ int main()
         assert(from_next - from == 9);
         assert(to_next - to == 9);
         for (unsigned i = 0; i < 9; ++i)
-            assert(to[i] == from[i]);
+            assert(static_cast<char32_t>(to[i]) == from[i]);
     }
 }
index fe00876251cb397755e619182bb316a8568a412e..86e64e6222b30a7e60f1eb0e6bc7f6b45a6777e9 100644 (file)
@@ -100,6 +100,7 @@ int main()
                   ios, err, v);
         assert(iter.base() == str+sizeof(str)-1);
         assert(err == ios.goodbit);
-        assert(v == 0x8000000000000000LL);
+        const long long expect = 0x8000000000000000LL;
+        assert(v == expect);
     }
 }
index 7bf164aafc2029309b40f9de548e13d923dfe39c..2e3b83ec7d73130deed5ee0adc8d8a696b7d2f3b 100644 (file)
@@ -23,11 +23,11 @@ int main()
         T a[] = {5, 4, 3, 2, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::valarray<T> v(a, N);
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v[i] == a[i]);
             v[i] = i;
-            assert(v[i] == i);
+            assert(v[i] == static_cast<int>(i));
         }
     }
 }
index b9736eedd73bfcddedabfd7ab3c979ae98f2c16b..8d5630516c06cd7c0e1118459e1c24cc7202636f 100644 (file)
@@ -23,7 +23,7 @@ int main()
         T a[] = {5, 4, 3, 2, 1};
         const unsigned N = sizeof(a)/sizeof(a[0]);
         const std::valarray<T> v(a, N);
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v[i] == a[i]);
         }
index a65a28209d432159bb724d29603b5219559d8fdb..3803489c30380ccf55d81ec056c557000fee49e3 100644 (file)
@@ -49,7 +49,7 @@ int main()
         std::valarray<T> v2(a, N-2);
         v2 = v;
         assert(v2.size() == v.size());
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v2[i].size() == v[i].size());
             for (std::size_t j = 0; j < v[i].size(); ++j)
index 42dc68dabef31508fbf064f396f1543415684bea..7a671a73eee62ebdf75dab74db8687dea0a1e2bc 100644 (file)
@@ -47,7 +47,7 @@ int main()
         std::valarray<T> v2(a, N-2);
         v2 = {T(1), T(2), T(3), T(4), T(5)};
         assert(v2.size() == N);
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v2[i].size() == a[i].size());
             for (std::size_t j = 0; j < a[i].size(); ++j)
index 9ed4849faff497f7aa9124e388db6c3b209316c4..d34ff1c64d83be6a840a1e68fa3be5633d1df297 100644 (file)
@@ -53,7 +53,7 @@ int main()
         v2 = std::move(v);
         assert(v2.size() == N);
         assert(v.size() == 0);
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v2[i].size() == a[i].size());
             for (std::size_t j = 0; j < a[i].size(); ++j)
index d0417333a40940b3ae4dc389d36ab17a1658102f..6ebff7256498ccdc2cc979800c270f7d18337820 100644 (file)
@@ -46,7 +46,7 @@ int main()
         std::valarray<T> v(a, N);
         std::valarray<T> v2 = v;
         assert(v2.size() == v.size());
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v2[i].size() == v[i].size());
             for (std::size_t j = 0; j < v[i].size(); ++j)
index 1ab460f1b9d5fb51d021ee980d68abac2f1af22a..4dfbe11bde9ca4dc8747c9c6fee564e96d7b3b56 100644 (file)
@@ -25,7 +25,7 @@ int main()
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::valarray<T> v = {1, 2, 3, 4, 5};
         assert(v.size() == N);
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
             assert(v[i] == a[i]);
     }
     {
@@ -34,7 +34,7 @@ int main()
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::valarray<T> v = {1, 2, 3, 4, 5};
         assert(v.size() == N);
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
             assert(v[i] == a[i]);
     }
 #endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
index 81eb7e40d48bf88a98c0b14b609fc146875b4d73..a9692618e75f797253725377f2300c4078bfd343 100644 (file)
@@ -51,7 +51,7 @@ int main()
         std::valarray<T> v2 = std::move(v);
         assert(v2.size() == N);
         assert(v.size() == 0);
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v2[i].size() == a[i].size());
             for (std::size_t j = 0; j < v2[i].size(); ++j)
index 73f29a13614f19604f0aaa43c4f7a4ebf49fea6e..f98230f47dd9a169a785407be92c2707bbbe9d94 100644 (file)
@@ -25,7 +25,7 @@ int main()
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::valarray<T> v(a, N);
         assert(v.size() == N);
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
             assert(v[i] == a[i]);
     }
     {
@@ -34,7 +34,7 @@ int main()
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::valarray<T> v(a, N);
         assert(v.size() == N);
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
             assert(v[i] == a[i]);
     }
     {
@@ -43,7 +43,7 @@ int main()
         const unsigned N = sizeof(a)/sizeof(a[0]);
         std::valarray<T> v(a, N);
         assert(v.size() == N);
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v[i].size() == a[i].size());
             for (std::size_t j = 0; j < v[i].size(); ++j)
index 272ec4f70462c391f58c90aa45088ce4bf4a11fd..5b2501f7e3573bf4f5184e0ac29e6a78a6e0e4dc 100644 (file)
@@ -36,7 +36,7 @@ int main()
         std::valarray<T> v(a, N);
         std::valarray<T> v2 = ~v;
         assert(v2.size() == v.size());
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v2[i].size() == v[i].size());
             for (std::size_t j = 0; j < v[i].size(); ++j)
index 6cbccd08f622f461f9a864a0dad8ef3d65b604ed..f4a83427cd2be1260a139e16cc1bc86a876d386d 100644 (file)
@@ -46,7 +46,7 @@ int main()
         std::valarray<T> v(a, N);
         std::valarray<T> v2 = -v;
         assert(v2.size() == v.size());
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v2[i].size() == v[i].size());
             for (std::size_t j = 0; j < v[i].size(); ++j)
index df6fccc38c8ce7dac663d4976ce3bb95b50a32e1..8df0494552d38cd166a7aaa3041f9155bd927c16 100644 (file)
@@ -46,7 +46,7 @@ int main()
         std::valarray<T> v(a, N);
         std::valarray<T> v2 = +v;
         assert(v2.size() == v.size());
-        for (int i = 0; i < N; ++i)
+        for (unsigned i = 0; i < N; ++i)
         {
             assert(v2[i].size() == v[i].size());
             for (std::size_t j = 0; j < v[i].size(); ++j)
index 88004ba4a741f0de942dccc3ef1a62f24240437c..9e46c6e4360b3e269557ba3e3262af6b6e374150 100644 (file)
@@ -49,7 +49,7 @@ test1()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -92,7 +92,7 @@ test2()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -135,7 +135,7 @@ test3()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -178,7 +178,7 @@ test4()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -227,7 +227,7 @@ test5()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -276,7 +276,7 @@ test6()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -319,7 +319,7 @@ test7()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -352,8 +352,12 @@ test8()
     std::binomial_distribution<>         dist1(5, 0.1);
     std::binomial_distribution<unsigned> dist2(5, 0.1);
 
-    for(int i = 0; i < N; ++i)
-        assert(dist1(gen1) == dist2(gen2));
+    for(int i = 0; i < N; ++i) {
+        int r1 = dist1(gen1);
+        unsigned r2 = dist2(gen2);
+        assert(r1 >= 0);
+        assert(static_cast<unsigned>(r1) == r2);
+    }
 }
 
 void
@@ -376,7 +380,7 @@ test9()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -425,7 +429,7 @@ test10()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -474,7 +478,7 @@ test11()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
index 092a69778513975e64953aa0cc7d4f93e2ce13e9..5ce0cb412cb2681d4a9603a696b27c2ec6bc792c 100644 (file)
@@ -51,7 +51,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -93,7 +93,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -135,7 +135,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
index 4e9f9d3c044dc17201e0d4c40b93d00a96c8cd3f..6e6072a4faf90fc2a49d779d2019055c2ab606cc 100644 (file)
@@ -49,7 +49,7 @@ test1()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -92,7 +92,7 @@ test2()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -135,7 +135,7 @@ test3()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -178,7 +178,7 @@ test4()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -221,7 +221,7 @@ test5()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -264,7 +264,7 @@ test6()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
index c451f0130904a22fcd490e2d5ce482b3addb01a5..254c347b3d25972d7c911291f2610b565c26b371 100644 (file)
@@ -51,7 +51,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -93,7 +93,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -135,7 +135,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
index 929e6e7e6c3b1a80766cc6f7671f58d67745fa11..d9aaec38e3880f69f60aad9bb7877cb7ce6c4af4 100644 (file)
@@ -49,7 +49,7 @@ test1()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -92,7 +92,7 @@ test2()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -135,7 +135,7 @@ test3()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -178,7 +178,7 @@ test4()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -219,7 +219,7 @@ test5()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -262,7 +262,7 @@ test6()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
index 2710061a1a05d7658bb5d42f8d1706f2fa8feb94..6467dbf5754de60cfb10728d8a6f5af1e7eafffd 100644 (file)
@@ -51,7 +51,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -93,7 +93,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -135,7 +135,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
index 2ad6784cd878319e5cb067876ed1742053fa0ad6..cfaddb73f0b8b6f1edafece4aa85f8191d3086b9 100644 (file)
@@ -49,7 +49,7 @@ test1()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -94,7 +94,7 @@ test2()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -139,7 +139,7 @@ test3()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -184,7 +184,7 @@ test4()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -229,7 +229,7 @@ test5()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
index 8f397fcab096f5ab4f494b5ab483df1a10186de8..35596a0d7df5c44d0d43430d1121da461006822d 100644 (file)
@@ -50,7 +50,7 @@ test1()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -96,7 +96,7 @@ test2()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -142,7 +142,7 @@ test3()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -188,7 +188,7 @@ test4()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -234,7 +234,7 @@ test5()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
index 9210e8a8d3500bf091539075b722eee5be7c38c2..b207eece67d002e67c41b8cd2d2fc0e661f5fca7 100644 (file)
@@ -45,7 +45,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -81,7 +81,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -117,7 +117,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
index 93053f0a36b7171300ec0c2acc8a776f3bd8fc26..983a2d24374443a669efc823037094322c15f6d1 100644 (file)
@@ -46,7 +46,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -83,7 +83,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -120,7 +120,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
index 3f1b331889e549da870a55916e4c6374401742f4..3999cbeccbb765a01996d75d59126aef98897662 100644 (file)
@@ -48,7 +48,7 @@ test1()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -90,7 +90,7 @@ test2()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -132,7 +132,7 @@ test3()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -174,7 +174,7 @@ test4()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
index 21bf774228f88bdb7fb0984153ab5068ee5dfa2e..b69a04cc17555d327323a101fdb0c7ddf54f2564 100644 (file)
@@ -49,7 +49,7 @@ test1()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -92,7 +92,7 @@ test2()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -135,7 +135,7 @@ test3()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
@@ -178,7 +178,7 @@ test4()
     double var = 0;
     double skew = 0;
     double kurtosis = 0;
-    for (int i = 0; i < u.size(); ++i)
+    for (unsigned i = 0; i < u.size(); ++i)
     {
         double dbl = (u[i] - mean);
         double d2 = sqr(dbl);
index 7c23630ed1e1c34663aaefae06c1d0be2d526ace..d0ac16298e425caac89152689fd6cd5932fc2cd2 100644 (file)
@@ -49,7 +49,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -89,7 +89,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -129,7 +129,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
index 54a89b6b3f4088b85325a7428b0289790313732d..12167c54f737b3ac9a2eb8c7d23a6fb113b60a2a 100644 (file)
@@ -50,7 +50,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -91,7 +91,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -132,7 +132,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
index a475624a58a8a0fffc8d694fe366a23df32f356d..12fcfa354fd37899b8a181d30ea789a1a8dc6a7c 100644 (file)
@@ -48,7 +48,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -87,7 +87,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -126,7 +126,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
index d24fbd9f9cf5e7f3865a8b1dfa8c577333e36fab..caa56eaab4ad60cf7994d34d96b0fbde686a7899 100644 (file)
@@ -50,7 +50,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -91,7 +91,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
@@ -132,7 +132,7 @@ int main()
         double var = 0;
         double skew = 0;
         double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
         {
             double dbl = (u[i] - mean);
             double d2 = sqr(dbl);
index 3111912ec29ced185d26792665720624415538a7..14a59621fa5d7e3d73489931b6dfe82dcabf98dd 100644 (file)
@@ -51,10 +51,10 @@ test1()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
@@ -114,10 +114,10 @@ test2()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
@@ -177,10 +177,10 @@ test3()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
@@ -240,10 +240,10 @@ test4()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
@@ -303,10 +303,10 @@ test5()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
@@ -366,10 +366,10 @@ test6()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
@@ -429,10 +429,10 @@ test7()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
@@ -492,10 +492,10 @@ test8()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
@@ -555,10 +555,10 @@ test9()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
@@ -618,10 +618,10 @@ test10()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
@@ -681,10 +681,10 @@ test11()
     }
     std::vector<double> prob(std::begin(p), std::end(p));
     double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-    for (int i = 0; i < prob.size(); ++i)
+    for (std::size_t i = 0; i < prob.size(); ++i)
         prob[i] /= s;
     std::sort(u.begin(), u.end());
-    for (int i = 0; i < Np; ++i)
+    for (std::size_t i = 0; i < Np; ++i)
     {
         typedef std::vector<D::result_type>::iterator I;
         I lb = std::lower_bound(u.begin(), u.end(), b[i]);
index 3353ab6427e8ae3bcd6e53ece8d708d36135a052..b374c5ec22dea6af019fd3726eb671f9ba85bcd7 100644 (file)
@@ -57,7 +57,7 @@ int main()
         for (std::size_t i = 0; i < prob.size(); ++i)
             prob[i] /= s;
         std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
+        for (std::size_t i = 0; i < Np; ++i)
         {
             typedef std::vector<D::result_type>::iterator I;
             I lb = std::lower_bound(u.begin(), u.end(), b[i]);
index 03da9b8960e48295fe26de65a8159469b5db0d47..7da4b9bfb1e51858640ce881992de31eaed6a7b5 100644 (file)
@@ -53,7 +53,7 @@ test1()
     D d(b, b+Np+1, p);
     const int N = 1000000;
     std::vector<D::result_type> u;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
         assert(d.min() <= v && v < d.max());
@@ -67,16 +67,16 @@ test1()
     double c = std::numeric_limits<double>::quiet_NaN();
     std::vector<double> areas(Np);
     double S = 0;
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t i = 0; i < areas.size(); ++i)
     {
         areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
         S += areas[i];
     }
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t i = 0; i < areas.size(); ++i)
         areas[i] /= S;
-    for (int i = 0; i < Np+1; ++i)
+    for (size_t i = 0; i < Np+1; ++i)
         p[i] /= S;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
         if (k != kp)
@@ -106,7 +106,7 @@ test2()
     D d(b, b+Np+1, p);
     const int N = 1000000;
     std::vector<D::result_type> u;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
         assert(d.min() <= v && v < d.max());
@@ -120,16 +120,16 @@ test2()
     double c = std::numeric_limits<double>::quiet_NaN();
     std::vector<double> areas(Np);
     double S = 0;
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t i = 0; i < areas.size(); ++i)
     {
         areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
         S += areas[i];
     }
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t i = 0; i < areas.size(); ++i)
         areas[i] /= S;
-    for (int i = 0; i < Np+1; ++i)
+    for (size_t i = 0; i < Np+1; ++i)
         p[i] /= S;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
         if (k != kp)
@@ -157,9 +157,9 @@ test3()
     double p[] = {1, 0, 0, 0};
     const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
     D d(b, b+Np+1, p);
-    const int N = 1000000;
+    const size_t N = 1000000;
     std::vector<D::result_type> u;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
         assert(d.min() <= v && v < d.max());
@@ -173,16 +173,16 @@ test3()
     double c = std::numeric_limits<double>::quiet_NaN();
     std::vector<double> areas(Np);
     double S = 0;
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t i = 0; i < areas.size(); ++i)
     {
         areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
         S += areas[i];
     }
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t i = 0; i < areas.size(); ++i)
         areas[i] /= S;
-    for (int i = 0; i < Np+1; ++i)
+    for (size_t i = 0; i < Np+1; ++i)
         p[i] /= S;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
         if (k != kp)
@@ -212,7 +212,7 @@ test4()
     D d(b, b+Np+1, p);
     const int N = 1000000;
     std::vector<D::result_type> u;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
         assert(d.min() <= v && v < d.max());
@@ -226,16 +226,16 @@ test4()
     double c = std::numeric_limits<double>::quiet_NaN();
     std::vector<double> areas(Np);
     double S = 0;
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t i = 0; i < areas.size(); ++i)
     {
         areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
         S += areas[i];
     }
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t i = 0; i < areas.size(); ++i)
         areas[i] /= S;
-    for (int i = 0; i < Np+1; ++i)
+    for (size_t i = 0; i < Np+1; ++i)
         p[i] /= S;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
         if (k != kp)
@@ -243,7 +243,7 @@ test4()
             a = 0;
             for (int j = 0; j < k; ++j)
                 a += areas[j];
-            assert(k < Np);
+            assert(k < static_cast<int>(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]);
@@ -266,7 +266,7 @@ test5()
     D d(b, b+Np+1, p);
     const int N = 1000000;
     std::vector<D::result_type> u;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
         assert(d.min() <= v && v < d.max());
@@ -280,17 +280,17 @@ test5()
     double c = std::numeric_limits<double>::quiet_NaN();
     std::vector<double> areas(Np);
     double S = 0;
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t 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)
+    for (size_t i = 0; i < areas.size(); ++i)
         areas[i] /= S;
-    for (int i = 0; i < Np+1; ++i)
+    for (size_t i = 0; i < Np+1; ++i)
         p[i] /= S;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
         if (k != kp)
@@ -298,7 +298,7 @@ test5()
             a = 0;
             for (int j = 0; j < k; ++j)
                 a += areas[j];
-            assert(k < Np);
+            assert(k < static_cast<int>(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]);
@@ -321,7 +321,7 @@ test6()
     D d(b, b+Np+1, p);
     const int N = 1000000;
     std::vector<D::result_type> u;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         D::result_type v = d(g);
         assert(d.min() <= v && v < d.max());
@@ -335,16 +335,16 @@ test6()
     double c = std::numeric_limits<double>::quiet_NaN();
     std::vector<double> areas(Np);
     double S = 0;
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t i = 0; i < areas.size(); ++i)
     {
         areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
         S += areas[i];
     }
-    for (int i = 0; i < areas.size(); ++i)
+    for (size_t i = 0; i < areas.size(); ++i)
         areas[i] /= S;
-    for (int i = 0; i < Np+1; ++i)
+    for (size_t i = 0; i < Np+1; ++i)
         p[i] /= S;
-    for (int i = 0; i < N; ++i)
+    for (size_t i = 0; i < N; ++i)
     {
         int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
         if (k != kp)
index 8054a69fed8743adaf4e5a9e5bf2fa43ef8704e6..f455dcff900e01769e48df0f1c9a9dee8741982a 100644 (file)
@@ -50,9 +50,9 @@ int main()
         const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
         D d;
         P pa(b, b+Np+1, p);
-        const int N = 1000000;
+        const size_t N = 1000000;
         std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
+        for (size_t i = 0; i < N; ++i)
         {
             D::result_type v = d(g, pa);
             assert(10 <= v && v < 17);
@@ -66,16 +66,16 @@ int main()
         double c = std::numeric_limits<double>::quiet_NaN();
         std::vector<double> areas(Np);
         double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
+        for (size_t i = 0; i < areas.size(); ++i)
         {
             areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
             S += areas[i];
         }
-        for (int i = 0; i < areas.size(); ++i)
+        for (size_t i = 0; i < areas.size(); ++i)
             areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
+        for (size_t i = 0; i < Np+1; ++i)
             p[i] /= S;
-        for (int i = 0; i < N; ++i)
+        for (size_t i = 0; i < N; ++i)
         {
             int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
             if (k != kp)
index 66d783a6e3577349cf8400aef087912f86248942..b23d4e8bb478c9914cea7c4065828fed2b857f11 100644 (file)
@@ -19,13 +19,13 @@ void do_pointer_comparison_test() {
 #endif
     std::vector<std::shared_ptr<T> > pointers;
     const std::size_t test_size = 100;
-    for (int i=0; i < test_size; ++i)
+    for (size_t i=0; i < test_size; ++i)
         pointers.push_back(std::shared_ptr<T>(new T()));
     Compare comp;
     UIntCompare ucomp;
     VoidCompare vcomp;
-    for (int i=0; i < test_size; ++i) {
-        for (int j=0; j < test_size; ++j) {
+    for (size_t i=0; i < test_size; ++i) {
+        for (size_t j=0; j < test_size; ++j) {
             T* lhs = pointers[i].get();
             T* rhs = pointers[j].get();
             std::uintptr_t lhs_uint = reinterpret_cast<std::uintptr_t>(lhs);
index 234c30981f2fdd29b391a4b74cd053d632066dd9..2f3f9bee4bc3608b462319d62ba888b18e0903d7 100644 (file)
@@ -39,7 +39,7 @@ test()
         if (sizeof(T) <= sizeof(std::size_t))
         {
             const std::size_t result = h(t);
-            LIBCPP_ASSERT(result == t);
+            LIBCPP_ASSERT(result == static_cast<size_t>(t));
             ((void)result); // Prevent unused warning
         }
     }