111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//===----------------------------------------------------------------------===// 211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The LLVM Compiler Infrastructure 411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This file is dual licensed under the MIT and the University of Illinois Open 611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Source Licenses. See LICENSE.TXT for details. 711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//===----------------------------------------------------------------------===// 911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// <unordered_map> 1111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, 1311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// class Alloc = allocator<pair<const Key, T>>> 1411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// class unordered_multimap 1511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// void swap(unordered_multimap& __u); 1711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <unordered_map> 1911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <string> 2011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <cassert> 2111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "../../../test_compare.h" 2311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "../../../test_hash.h" 2411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "test_allocator.h" 2511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "min_allocator.h" 2611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint main() 2811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 2911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 3011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 3111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 3211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_allocator<std::pair<const int, std::string> > Alloc; 3311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 3411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 3511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(0, Hash(1), Compare(1), Alloc(1)); 3611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(0, Hash(2), Compare(2), Alloc(2)); 3711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 3811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 3911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() == 0); 4111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 0); 4211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 4311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 4411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc(1)); 4511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 4611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 4711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 4811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() == 0); 5011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 0); 5111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 5211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 5311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc(2)); 5411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 5511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 5611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 5711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 5811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 5911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 6011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 6111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_allocator<std::pair<const int, std::string> > Alloc; 6211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 6311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 6411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a2[] = 6511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 6611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(10, "ten"), 6711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(20, "twenty"), 6811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(30, "thirty"), 6911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(40, "forty"), 7011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(50, "fifty"), 7111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(60, "sixty"), 7211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(70, "seventy"), 7311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(80, "eighty"), 7411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 7511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(0, Hash(1), Compare(1), Alloc(1)); 7611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 7711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 7811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 7911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() >= 11); 8111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 8); 8211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(10)->second == "ten"); 8311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(20)->second == "twenty"); 8411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(30)->second == "thirty"); 8511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(40)->second == "forty"); 8611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(50)->second == "fifty"); 8711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(60)->second == "sixty"); 8811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(70)->second == "seventy"); 8911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(80)->second == "eighty"); 9011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 9111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 9211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc(1)); 9311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 9411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 9511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 9611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() == 0); 9811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 0); 9911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 10011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 10111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc(2)); 10211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 10311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 10411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 10511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 10611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 10711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 10811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 10911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_allocator<std::pair<const int, std::string> > Alloc; 11011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 11111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 11211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a1[] = 11311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 11411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "one"), 11511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "two"), 11611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(3, "three"), 11711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(4, "four"), 11811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "four"), 11911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "four"), 12011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 12111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 12211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(0, Hash(2), Compare(2), Alloc(2)); 12311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 12411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 12511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() == 0); 12711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 0); 12811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 12911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 13011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc(1)); 13111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 13211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 13311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 13411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() >= 7); 13611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 6); 13711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(1)->second == "one"); 13811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(1))->second == "four"); 13911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(2)->second == "two"); 14011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(2))->second == "four"); 14111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(3)->second == "three"); 14211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(4)->second == "four"); 14311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 14411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 14511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc(2)); 14611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 14711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 14811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 14911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 15011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 15111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 15211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 15311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_allocator<std::pair<const int, std::string> > Alloc; 15411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 15511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 15611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a1[] = 15711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 15811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "one"), 15911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "two"), 16011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(3, "three"), 16111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(4, "four"), 16211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "four"), 16311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "four"), 16411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 16511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a2[] = 16611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 16711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(10, "ten"), 16811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(20, "twenty"), 16911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(30, "thirty"), 17011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(40, "forty"), 17111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(50, "fifty"), 17211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(60, "sixty"), 17311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(70, "seventy"), 17411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(80, "eighty"), 17511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 17611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 17711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 17811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 17911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 18011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 18111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() >= 11); 18211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 8); 18311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(10)->second == "ten"); 18411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(20)->second == "twenty"); 18511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(30)->second == "thirty"); 18611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(40)->second == "forty"); 18711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(50)->second == "fifty"); 18811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(60)->second == "sixty"); 18911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(70)->second == "seventy"); 19011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(80)->second == "eighty"); 19111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 19211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 19311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc(1)); 19411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 19511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 19611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 19711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() >= 7); 19911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 6); 20011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(1)->second == "one"); 20111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(1))->second == "four"); 20211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(2)->second == "two"); 20311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(2))->second == "four"); 20411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(3)->second == "three"); 20511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(4)->second == "four"); 20611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 20711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 20811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc(2)); 20911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 21011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 21111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 21211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 21311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 21511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 21611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 21711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef other_allocator<std::pair<const int, std::string> > Alloc; 21811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 21911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 22011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(0, Hash(1), Compare(1), Alloc(1)); 22111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(0, Hash(2), Compare(2), Alloc(2)); 22211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 22311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 22411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() == 0); 22611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 0); 22711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 22811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 22911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc(2)); 23011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 23111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 23211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 23311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 23411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() == 0); 23511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 0); 23611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 23711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 23811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc(1)); 23911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 24011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 24111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 24211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 24311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 24411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 24511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 24611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef other_allocator<std::pair<const int, std::string> > Alloc; 24711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 24811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 24911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a2[] = 25011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 25111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(10, "ten"), 25211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(20, "twenty"), 25311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(30, "thirty"), 25411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(40, "forty"), 25511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(50, "fifty"), 25611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(60, "sixty"), 25711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(70, "seventy"), 25811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(80, "eighty"), 25911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 26011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(0, Hash(1), Compare(1), Alloc(1)); 26111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 26211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 26311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 26411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 26511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() >= 11); 26611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 8); 26711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(10)->second == "ten"); 26811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(20)->second == "twenty"); 26911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(30)->second == "thirty"); 27011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(40)->second == "forty"); 27111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(50)->second == "fifty"); 27211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(60)->second == "sixty"); 27311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(70)->second == "seventy"); 27411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(80)->second == "eighty"); 27511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 27611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 27711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc(2)); 27811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 27911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 28011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 28111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 28211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() == 0); 28311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 0); 28411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 28511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 28611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc(1)); 28711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 28811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 28911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 29011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 29111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 29211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 29311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 29411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef other_allocator<std::pair<const int, std::string> > Alloc; 29511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 29611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 29711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a1[] = 29811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 29911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "one"), 30011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "two"), 30111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(3, "three"), 30211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(4, "four"), 30311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "four"), 30411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "four"), 30511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 30611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 30711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(0, Hash(2), Compare(2), Alloc(2)); 30811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 30911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 31011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() == 0); 31211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 0); 31311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 31411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 31511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc(2)); 31611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 31711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 31811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 31911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() >= 7); 32111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 6); 32211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(1)->second == "one"); 32311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(1))->second == "four"); 32411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(2)->second == "two"); 32511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(2))->second == "four"); 32611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(3)->second == "three"); 32711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(4)->second == "four"); 32811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 32911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 33011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc(1)); 33111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 33211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 33311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 33411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 33511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 33611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 33711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 33811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef other_allocator<std::pair<const int, std::string> > Alloc; 33911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 34011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 34111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a1[] = 34211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 34311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "one"), 34411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "two"), 34511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(3, "three"), 34611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(4, "four"), 34711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "four"), 34811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "four"), 34911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 35011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a2[] = 35111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 35211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(10, "ten"), 35311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(20, "twenty"), 35411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(30, "thirty"), 35511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(40, "forty"), 35611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(50, "fifty"), 35711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(60, "sixty"), 35811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(70, "seventy"), 35911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(80, "eighty"), 36011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 36111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); 36211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(2)); 36311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 36411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 36511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 36611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() >= 11); 36711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 8); 36811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(10)->second == "ten"); 36911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(20)->second == "twenty"); 37011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(30)->second == "thirty"); 37111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(40)->second == "forty"); 37211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(50)->second == "fifty"); 37311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(60)->second == "sixty"); 37411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(70)->second == "seventy"); 37511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(80)->second == "eighty"); 37611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 37711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 37811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc(2)); 37911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 38011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 38111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 38211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() >= 7); 38411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 6); 38511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(1)->second == "one"); 38611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(1))->second == "four"); 38711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(2)->second == "two"); 38811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(2))->second == "four"); 38911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(3)->second == "three"); 39011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(4)->second == "four"); 39111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 39211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 39311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc(1)); 39411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 39511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 39611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 39711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 39811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if __cplusplus >= 201103L 39911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 40011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 40111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 40211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef min_allocator<std::pair<const int, std::string> > Alloc; 40311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 40411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 40511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(0, Hash(1), Compare(1), Alloc()); 40611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(0, Hash(2), Compare(2), Alloc()); 40711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 40811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 40911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() == 0); 41111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 0); 41211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 41311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 41411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc()); 41511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 41611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 41711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 41811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() == 0); 42011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 0); 42111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 42211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 42311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc()); 42411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 42511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 42611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 42711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 42811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 42911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 43011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 43111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef min_allocator<std::pair<const int, std::string> > Alloc; 43211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 43311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 43411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a2[] = 43511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 43611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(10, "ten"), 43711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(20, "twenty"), 43811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(30, "thirty"), 43911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(40, "forty"), 44011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(50, "fifty"), 44111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(60, "sixty"), 44211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(70, "seventy"), 44311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(80, "eighty"), 44411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 44511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(0, Hash(1), Compare(1), Alloc()); 44611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); 44711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 44811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 44911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() >= 11); 45111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 8); 45211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(10)->second == "ten"); 45311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(20)->second == "twenty"); 45411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(30)->second == "thirty"); 45511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(40)->second == "forty"); 45611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(50)->second == "fifty"); 45711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(60)->second == "sixty"); 45811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(70)->second == "seventy"); 45911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(80)->second == "eighty"); 46011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 46111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 46211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc()); 46311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 46411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 46511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 46611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() == 0); 46811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 0); 46911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 47011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 47111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc()); 47211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 47311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 47411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 47511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 47611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 47711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 47811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 47911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef min_allocator<std::pair<const int, std::string> > Alloc; 48011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 48111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 48211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a1[] = 48311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 48411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "one"), 48511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "two"), 48611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(3, "three"), 48711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(4, "four"), 48811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "four"), 48911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "four"), 49011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 49111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); 49211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(0, Hash(2), Compare(2), Alloc()); 49311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 49411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 49511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() == 0); 49711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 0); 49811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 49911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 50011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc()); 50111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 50211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 50311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 50411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() >= 7); 50611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 6); 50711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(1)->second == "one"); 50811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(1))->second == "four"); 50911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(2)->second == "two"); 51011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(2))->second == "four"); 51111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(3)->second == "three"); 51211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(4)->second == "four"); 51311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 51411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 51511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc()); 51611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 51711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 51811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 51911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 52011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 52111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_hash<std::hash<int> > Hash; 52211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef test_compare<std::equal_to<int> > Compare; 52311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef min_allocator<std::pair<const int, std::string> > Alloc; 52411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; 52511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::pair<int, std::string> P; 52611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a1[] = 52711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 52811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "one"), 52911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "two"), 53011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(3, "three"), 53111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(4, "four"), 53211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(1, "four"), 53311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(2, "four"), 53411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 53511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P a2[] = 53611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 53711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(10, "ten"), 53811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(20, "twenty"), 53911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(30, "thirty"), 54011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(40, "forty"), 54111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(50, "fifty"), 54211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(60, "sixty"), 54311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(70, "seventy"), 54411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert P(80, "eighty"), 54511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 54611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); 54711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc()); 54811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert c2.max_load_factor(2); 54911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert swap(c1, c2); 55011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.bucket_count() >= 11); 55211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.size() == 8); 55311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(10)->second == "ten"); 55411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(20)->second == "twenty"); 55511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(30)->second == "thirty"); 55611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(40)->second == "forty"); 55711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(50)->second == "fifty"); 55811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(60)->second == "sixty"); 55911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(70)->second == "seventy"); 56011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.find(80)->second == "eighty"); 56111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.hash_function() == Hash(2)); 56211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.key_eq() == Compare(2)); 56311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.get_allocator() == Alloc()); 56411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.begin(), c1.end()) == c1.size()); 56511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); 56611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c1.max_load_factor() == 2); 56711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.bucket_count() >= 7); 56911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.size() == 6); 57011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(1)->second == "one"); 57111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(1))->second == "four"); 57211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(2)->second == "two"); 57311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(next(c2.find(2))->second == "four"); 57411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(3)->second == "three"); 57511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.find(4)->second == "four"); 57611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.hash_function() == Hash(1)); 57711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.key_eq() == Compare(1)); 57811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.get_allocator() == Alloc()); 57911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.begin(), c2.end()) == c2.size()); 58011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); 58111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert assert(c2.max_load_factor() == 1); 58211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 58311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 58411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 585