[libcxx] [test] Fix Clang -Wunused-local-typedef, MSVC C4800, missing cassert.

[STL_MSFT]

Summary

[libcxx] [test] Fix Clang -Wunused-local-typedef, MSVC C4800, missing cassert.

test/std/containers/sequences/vector.bool/move.pass.cpp
Fix MSVC warning C4800. This was implicitly converting [1, 3] to bool, which triggers an MSVC warning. The test should just pass true, which is simpler, has the same behavior, and avoids the warning. (This is a library test, not a compiler test, and the conversion happens before calling push_back, so passing [1, 3] isn't interesting in any way. This resembles a previous change to stop passing 1 == 1 in the vector<bool> tests.)

test/std/containers/associative/map/map.modifiers/merge.pass.cpp
test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp
test/std/containers/associative/multiset/merge.pass.cpp
test/std/containers/associative/set/merge.pass.cpp
test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
test/std/containers/unord/unord.multiset/merge.pass.cpp
test/std/containers/unord/unord.set/merge.pass.cpp
Include <cassert> for assert(). This fixes compiler errors with MSVC's STL.

test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp
test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp
test/std/containers/unord/unord.multiset/merge.pass.cpp
test/std/containers/unord/unord.set/merge.pass.cpp
Fix Clang -Wunused-local-typedef warnings. C++11's [hash.requirements] never required these typedefs from users.

[EricWF]

Remind me once this lands to turn on -Wunused-local-typedef so we don't regress.

[STL_MSFT]

Committed as rCXX346910, rCXX346911, and rCXX346912.

test/std/containers/associative/map/map.modifiers/merge.pass.cpp

 // template <class C2>
 //   void merge(map<key_type, value_type, C2, allocator_type>&& source);
 // template <class C2>
 //   void merge(multimap<key_type, value_type, C2, allocator_type>& source);
 // template <class C2>
 //   void merge(multimap<key_type, value_type, C2, allocator_type>&& source);
 
 #include <map>
+#include <cassert>
 #include "test_macros.h"
 #include "Counter.h"
 
 template <class Map>
 bool map_equal(const Map& map, Map other)
 {
     return map == other;
 }

test/std/containers/associative/multimap/multimap.modifiers/merge.pass.cpp

 // template <class C2>
 //   void merge(map<key_type, value_type, C2, allocator_type>&& source);
 // template <class C2>
 //   void merge(multimap<key_type, value_type, C2, allocator_type>& source);
 // template <class C2>
 //   void merge(multimap<key_type, value_type, C2, allocator_type>&& source);
 
 #include <map>
+#include <cassert>
 #include "test_macros.h"
 #include "Counter.h"
 
 template <class Map>
 bool map_equal(const Map& map, Map other)
 {
     return map == other;
 }

test/std/containers/associative/multiset/merge.pass.cpp

 // template <class C2>
 //   void merge(set<Key, C2, Allocator>&& source);
 // template <class C2>
 //   void merge(multiset<Key, C2, Allocator>& source);
 // template <class C2>
 //   void merge(multiset<Key, C2, Allocator>&& source);
 
 #include <set>
+#include <cassert>
 #include "test_macros.h"
 #include "Counter.h"
 
 template <class Set>
 bool set_equal(const Set& set, Set other)
 {
     return set == other;
 }

test/std/containers/associative/set/merge.pass.cpp

 // template <class C2>
 //   void merge(set<key_type, C2, allocator_type>&& source);
 // template <class C2>
 //   void merge(multiset<key_type, C2, allocator_type>& source);
 // template <class C2>
 //   void merge(multiset<key_type, C2, allocator_type>&& source);
 
 #include <set>
+#include <cassert>
 #include "test_macros.h"
 #include "Counter.h"
 
 template <class Set>
 bool set_equal(const Set& set, Set other)
 {
     return set == other;
 }

test/std/containers/sequences/vector.bool/move.pass.cpp

 
 int main()
 {
     {
         std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
         std::vector<bool, test_allocator<bool> > lo(test_allocator<bool>(5));
         for (int i = 1; i <= 3; ++i)
         {
-            l.push_back(i);
-            lo.push_back(i);
+            l.push_back(true);
+            lo.push_back(true);
         }
         std::vector<bool, test_allocator<bool> > l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
     {
         std::vector<bool, other_allocator<bool> > l(other_allocator<bool>(5));
         std::vector<bool, other_allocator<bool> > lo(other_allocator<bool>(5));
         for (int i = 1; i <= 3; ++i)
         {
-            l.push_back(i);
-            lo.push_back(i);
+            l.push_back(true);
+            lo.push_back(true);
         }
         std::vector<bool, other_allocator<bool> > l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
     {
         std::vector<bool, min_allocator<bool> > l(min_allocator<bool>{});
         std::vector<bool, min_allocator<bool> > lo(min_allocator<bool>{});
         for (int i = 1; i <= 3; ++i)
         {
-            l.push_back(i);
-            lo.push_back(i);
+            l.push_back(true);
+            lo.push_back(true);
         }
         std::vector<bool, min_allocator<bool> > l2 = std::move(l);
         assert(l2 == lo);
         assert(l.empty());
         assert(l2.get_allocator() == lo.get_allocator());
     }
     {
       test_alloc_base::clear();

test/std/containers/unord/unord.map/unord.map.modifiers/merge.pass.cpp

 // template <class H2, class P2>
 //   void merge(unordered_map<key_type, value_type, H2, P2, allocator_type>&& source);
 // template <class H2, class P2>
 //   void merge(unordered_multimap<key_type, value_type, H2, P2, allocator_type>& source);
 // template <class H2, class P2>
 //   void merge(unordered_multimap<key_type, value_type, H2, P2, allocator_type>&& source);
 
 #include <unordered_map>
+#include <cassert>
 #include "test_macros.h"
 #include "Counter.h"
 
 template <class Map>
 bool map_equal(const Map& map, Map other)
 {
     return map == other;
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 template <class T>
 struct throw_hasher
 {
     bool& should_throw_;
 
     throw_hasher(bool& should_throw) : should_throw_(should_throw) {}
 
-    typedef size_t result_type;
-    typedef T argument_type;
-
     size_t operator()(const T& p) const
     {
         if (should_throw_)
             throw 0;
         return std::hash<T>()(p);
     }
 };
 #endif
struct equal
         bool operator()(const Counter<int>& lhs, const Counter<int>& rhs) const
         {
             return lhs == rhs;
         }
     };
     struct hasher
     {
         hasher() = default;
-        typedef Counter<int> argument_type;
-        typedef size_t result_type;
         size_t operator()(const Counter<int>& p) const
         {
             return std::hash<Counter<int>>()(p);
         }
     };
     {
         typedef std::unordered_map<Counter<int>, int, std::hash<Counter<int>>, std::equal_to<Counter<int>>> first_map_type;
         typedef std::unordered_map<Counter<int>, int, hasher, equal> second_map_type;

test/std/containers/unord/unord.multimap/unord.multimap.modifiers/merge.pass.cpp

 // template <class H2, class P2>
 //   void merge(unordered_map<key_type, value_type, H2, P2, allocator_type>&& source);
 // template <class H2, class P2>
 //   void merge(unordered_multimap<key_type, value_type, H2, P2, allocator_type>& source);
 // template <class H2, class P2>
 //   void merge(unordered_multimap<key_type, value_type, H2, P2, allocator_type>&& source);
 
 #include <unordered_map>
+#include <cassert>
 #include "test_macros.h"
 #include "Counter.h"
 
 template <class Map>
 bool map_equal(const Map& map, Map other)
 {
     return map == other;
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 template <class T>
 struct throw_hasher
 {
     bool& should_throw_;
 
     throw_hasher(bool& should_throw) : should_throw_(should_throw) {}
 
-    typedef size_t result_type;
-    typedef T argument_type;
-
     size_t operator()(const T& p) const
     {
         if (should_throw_)
             throw 0;
         return std::hash<T>()(p);
     }
 };
 #endif
struct equal
         bool operator()(const Counter<int>& lhs, const Counter<int>& rhs) const
         {
             return lhs == rhs;
         }
     };
     struct hasher
     {
         hasher() = default;
-        typedef Counter<int> argument_type;
-        typedef size_t result_type;
         size_t operator()(const Counter<int>& p) const
         {
             return std::hash<Counter<int>>()(p);
         }
     };
     {
         typedef std::unordered_multimap<Counter<int>, int, std::hash<Counter<int>>, std::equal_to<Counter<int>>> first_map_type;
         typedef std::unordered_multimap<Counter<int>, int, hasher, equal> second_map_type;

test/std/containers/unord/unord.multiset/merge.pass.cpp

 // template <class H2, class P2>
 //   void merge(unordered_set<key_type, H2, P2, allocator_type>&& source);
 // template <class H2, class P2>
 //   void merge(unordered_multiset<key_type, H2, P2, allocator_type>& source);
 // template <class H2, class P2>
 //   void merge(unordered_multiset<key_type, H2, P2, allocator_type>&& source);
 
 #include <unordered_set>
+#include <cassert>
 #include "test_macros.h"
 #include "Counter.h"
 
 template <class Set>
 bool set_equal(const Set& set, Set other)
 {
     return set == other;
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 template <class T>
 struct throw_hasher
 {
     bool& should_throw_;
 
     throw_hasher(bool& should_throw) : should_throw_(should_throw) {}
 
-    typedef size_t result_type;
-    typedef T argument_type;
-
     size_t operator()(const T& p) const
     {
         if (should_throw_)
             throw 0;
         return std::hash<T>()(p);
     }
 };
 #endif
struct equal
         bool operator()(const Counter<int>& lhs, const Counter<int>& rhs) const
         {
             return lhs == rhs;
         }
     };
     struct hasher
     {
         hasher() = default;
-        typedef Counter<int> argument_type;
-        typedef size_t result_type;
         size_t operator()(const Counter<int>& p) const { return std::hash<Counter<int>>()(p); }
     };
     {
         typedef std::unordered_multiset<Counter<int>, std::hash<Counter<int>>, std::equal_to<Counter<int>>> first_set_type;
         typedef std::unordered_multiset<Counter<int>, hasher, equal> second_set_type;
         typedef std::unordered_set<Counter<int>, hasher, equal> third_set_type;
 
         {

test/std/containers/unord/unord.set/merge.pass.cpp

 // template <class H2, class P2>
 //   void merge(unordered_set<key_type, H2, P2, allocator_type>&& source);
 // template <class H2, class P2>
 //   void merge(unordered_multiset<key_type, H2, P2, allocator_type>& source);
 // template <class H2, class P2>
 //   void merge(unordered_multiset<key_type, H2, P2, allocator_type>&& source);
 
 #include <unordered_set>
+#include <cassert>
 #include "test_macros.h"
 #include "Counter.h"
 
 template <class Set>
 bool set_equal(const Set& set, Set other)
 {
     return set == other;
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 template <class T>
 struct throw_hasher
 {
     bool& should_throw_;
 
     throw_hasher(bool& should_throw) : should_throw_(should_throw) {}
 
-    typedef size_t result_type;
-    typedef T argument_type;
-
     size_t operator()(const T& p) const
     {
         if (should_throw_)
             throw 0;
         return std::hash<T>()(p);
     }
 };
 #endif
struct equal
         bool operator()(const Counter<int>& lhs, const Counter<int>& rhs) const
         {
             return lhs == rhs;
         }
     };
     struct hasher
     {
         hasher() = default;
-        typedef Counter<int> argument_type;
-        typedef size_t result_type;
         size_t operator()(const Counter<int>& p) const { return std::hash<Counter<int>>()(p); }
     };
     {
         typedef std::unordered_set<Counter<int>, std::hash<Counter<int>>, std::equal_to<Counter<int>>> first_set_type;
         typedef std::unordered_set<Counter<int>, hasher, equal> second_set_type;
         typedef std::unordered_multiset<Counter<int>, hasher, equal> third_set_type;
 
         {