1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // <unordered_map> 11 12 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 13 // class Alloc = allocator<pair<const Key, T>>> 14 // class unordered_multimap 15 16 // template <class InputIterator> 17 // unordered_multimap(InputIterator first, InputIterator last, size_type n, 18 // const hasher& hf, const key_equal& eql, 19 // const allocator_type& a); 20 21 #include <unordered_map> 22 #include <string> 23 #include <cassert> 24 #include <cfloat> 25 26 #include "test_iterators.h" 27 #include "../../../NotConstructible.h" 28 #include "../../../test_compare.h" 29 #include "../../../test_hash.h" 30 #include "test_allocator.h" 31 #include "min_allocator.h" 32 33 int main() 34 { 35 { 36 typedef std::unordered_multimap<int, std::string, 37 test_hash<std::hash<int> >, 38 test_compare<std::equal_to<int> >, 39 test_allocator<std::pair<const int, std::string> > 40 > C; 41 typedef std::pair<int, std::string> P; 42 P a[] = 43 { 44 P(1, "one"), 45 P(2, "two"), 46 P(3, "three"), 47 P(4, "four"), 48 P(1, "four"), 49 P(2, "four"), 50 }; 51 C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), 52 7, 53 test_hash<std::hash<int> >(8), 54 test_compare<std::equal_to<int> >(9), 55 test_allocator<std::pair<const int, std::string> >(10) 56 ); 57 assert(c.bucket_count() == 7); 58 assert(c.size() == 6); 59 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 60 Eq eq = c.equal_range(1); 61 assert(std::distance(eq.first, eq.second) == 2); 62 C::const_iterator i = eq.first; 63 assert(i->first == 1); 64 assert(i->second == "one"); 65 ++i; 66 assert(i->first == 1); 67 assert(i->second == "four"); 68 eq = c.equal_range(2); 69 assert(std::distance(eq.first, eq.second) == 2); 70 i = eq.first; 71 assert(i->first == 2); 72 assert(i->second == "two"); 73 ++i; 74 assert(i->first == 2); 75 assert(i->second == "four"); 76 77 eq = c.equal_range(3); 78 assert(std::distance(eq.first, eq.second) == 1); 79 i = eq.first; 80 assert(i->first == 3); 81 assert(i->second == "three"); 82 eq = c.equal_range(4); 83 assert(std::distance(eq.first, eq.second) == 1); 84 i = eq.first; 85 assert(i->first == 4); 86 assert(i->second == "four"); 87 assert(std::distance(c.begin(), c.end()) == c.size()); 88 assert(std::distance(c.cbegin(), c.cend()) == c.size()); 89 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 90 assert(c.max_load_factor() == 1); 91 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 92 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 93 assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10))); 94 } 95 #if __cplusplus >= 201103L 96 { 97 typedef std::unordered_multimap<int, std::string, 98 test_hash<std::hash<int> >, 99 test_compare<std::equal_to<int> >, 100 min_allocator<std::pair<const int, std::string> > 101 > C; 102 typedef std::pair<int, std::string> P; 103 P a[] = 104 { 105 P(1, "one"), 106 P(2, "two"), 107 P(3, "three"), 108 P(4, "four"), 109 P(1, "four"), 110 P(2, "four"), 111 }; 112 C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), 113 7, 114 test_hash<std::hash<int> >(8), 115 test_compare<std::equal_to<int> >(9), 116 min_allocator<std::pair<const int, std::string> >() 117 ); 118 assert(c.bucket_count() == 7); 119 assert(c.size() == 6); 120 typedef std::pair<C::const_iterator, C::const_iterator> Eq; 121 Eq eq = c.equal_range(1); 122 assert(std::distance(eq.first, eq.second) == 2); 123 C::const_iterator i = eq.first; 124 assert(i->first == 1); 125 assert(i->second == "one"); 126 ++i; 127 assert(i->first == 1); 128 assert(i->second == "four"); 129 eq = c.equal_range(2); 130 assert(std::distance(eq.first, eq.second) == 2); 131 i = eq.first; 132 assert(i->first == 2); 133 assert(i->second == "two"); 134 ++i; 135 assert(i->first == 2); 136 assert(i->second == "four"); 137 138 eq = c.equal_range(3); 139 assert(std::distance(eq.first, eq.second) == 1); 140 i = eq.first; 141 assert(i->first == 3); 142 assert(i->second == "three"); 143 eq = c.equal_range(4); 144 assert(std::distance(eq.first, eq.second) == 1); 145 i = eq.first; 146 assert(i->first == 4); 147 assert(i->second == "four"); 148 assert(std::distance(c.begin(), c.end()) == c.size()); 149 assert(std::distance(c.cbegin(), c.cend()) == c.size()); 150 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); 151 assert(c.max_load_factor() == 1); 152 assert(c.hash_function() == test_hash<std::hash<int> >(8)); 153 assert(c.key_eq() == test_compare<std::equal_to<int> >(9)); 154 assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >())); 155 } 156 #endif 157 } 158
