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 #ifndef SET_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H 10 #define SET_ALLOCATOR_REQUIREMENT_TEST_TEMPLATES_H 11 12 // <set> 13 // <unordered_set> 14 15 // class set 16 // class unordered_set 17 18 // insert(...); 19 // emplace(...); 20 // emplace_hint(...); 21 22 23 #include <cassert> 24 25 #include "test_macros.h" 26 #include "count_new.hpp" 27 #include "container_test_types.h" 28 #include "assert_checkpoint.h" 29 30 31 template <class Container> 32 void testSetInsert() 33 { 34 typedef typename Container::value_type ValueTp; 35 ConstructController* cc = getConstructController(); 36 cc->reset(); 37 { 38 CHECKPOINT("Testing C::insert(const value_type&)"); 39 Container c; 40 const ValueTp v(42); 41 cc->expect<const ValueTp&>(); 42 assert(c.insert(v).second); 43 assert(!cc->unchecked()); 44 { 45 DisableAllocationGuard g; 46 const ValueTp v2(42); 47 assert(c.insert(v2).second == false); 48 } 49 } 50 { 51 CHECKPOINT("Testing C::insert(value_type&)"); 52 Container c; 53 ValueTp v(42); 54 cc->expect<const ValueTp&>(); 55 assert(c.insert(v).second); 56 assert(!cc->unchecked()); 57 { 58 DisableAllocationGuard g; 59 ValueTp v2(42); 60 assert(c.insert(v2).second == false); 61 } 62 } 63 { 64 CHECKPOINT("Testing C::insert(value_type&&)"); 65 Container c; 66 ValueTp v(42); 67 cc->expect<ValueTp&&>(); 68 assert(c.insert(std::move(v)).second); 69 assert(!cc->unchecked()); 70 { 71 DisableAllocationGuard g; 72 ValueTp v2(42); 73 assert(c.insert(std::move(v2)).second == false); 74 } 75 } 76 { 77 CHECKPOINT("Testing C::insert(const value_type&&)"); 78 Container c; 79 const ValueTp v(42); 80 cc->expect<const ValueTp&>(); 81 assert(c.insert(std::move(v)).second); 82 assert(!cc->unchecked()); 83 { 84 DisableAllocationGuard g; 85 const ValueTp v2(42); 86 assert(c.insert(std::move(v2)).second == false); 87 } 88 } 89 { 90 CHECKPOINT("Testing C::insert(std::initializer_list<ValueTp>)"); 91 Container c; 92 std::initializer_list<ValueTp> il = { ValueTp(1), ValueTp(2) }; 93 cc->expect<ValueTp const&>(2); 94 c.insert(il); 95 assert(!cc->unchecked()); 96 { 97 DisableAllocationGuard g; 98 c.insert(il); 99 } 100 } 101 { 102 CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type const&"); 103 Container c; 104 const ValueTp ValueList[] = { ValueTp(1), ValueTp(2), ValueTp(3) }; 105 cc->expect<ValueTp const&>(3); 106 c.insert(std::begin(ValueList), std::end(ValueList)); 107 assert(!cc->unchecked()); 108 { 109 DisableAllocationGuard g; 110 c.insert(std::begin(ValueList), std::end(ValueList)); 111 } 112 } 113 { 114 CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&&"); 115 Container c; 116 ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(3) }; 117 cc->expect<ValueTp&&>(3); 118 c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList)), 119 std::move_iterator<ValueTp*>(std::end(ValueList))); 120 assert(!cc->unchecked()); 121 { 122 DisableAllocationGuard g; 123 ValueTp ValueList2[] = { ValueTp(1), ValueTp(2) , ValueTp(3) }; 124 c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList2)), 125 std::move_iterator<ValueTp*>(std::end(ValueList2))); 126 } 127 } 128 { 129 CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&"); 130 Container c; 131 ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(3) }; 132 cc->expect<ValueTp const&>(3); 133 c.insert(std::begin(ValueList), std::end(ValueList)); 134 assert(!cc->unchecked()); 135 { 136 DisableAllocationGuard g; 137 c.insert(std::begin(ValueList), std::end(ValueList)); 138 } 139 } 140 } 141 142 143 template <class Container> 144 void testSetEmplace() 145 { 146 typedef typename Container::value_type ValueTp; 147 ConstructController* cc = getConstructController(); 148 cc->reset(); 149 { 150 CHECKPOINT("Testing C::emplace(const value_type&)"); 151 Container c; 152 const ValueTp v(42); 153 cc->expect<const ValueTp&>(); 154 assert(c.emplace(v).second); 155 assert(!cc->unchecked()); 156 { 157 DisableAllocationGuard g; 158 const ValueTp v2(42); 159 assert(c.emplace(v2).second == false); 160 } 161 } 162 { 163 CHECKPOINT("Testing C::emplace(value_type&)"); 164 Container c; 165 ValueTp v(42); 166 cc->expect<ValueTp&>(); 167 assert(c.emplace(v).second); 168 assert(!cc->unchecked()); 169 { 170 DisableAllocationGuard g; 171 ValueTp v2(42); 172 assert(c.emplace(v2).second == false); 173 } 174 } 175 { 176 CHECKPOINT("Testing C::emplace(value_type&&)"); 177 Container c; 178 ValueTp v(42); 179 cc->expect<ValueTp&&>(); 180 assert(c.emplace(std::move(v)).second); 181 assert(!cc->unchecked()); 182 { 183 DisableAllocationGuard g; 184 ValueTp v2(42); 185 assert(c.emplace(std::move(v2)).second == false); 186 } 187 } 188 { 189 CHECKPOINT("Testing C::emplace(const value_type&&)"); 190 Container c; 191 const ValueTp v(42); 192 cc->expect<const ValueTp&&>(); 193 assert(c.emplace(std::move(v)).second); 194 assert(!cc->unchecked()); 195 { 196 DisableAllocationGuard g; 197 const ValueTp v2(42); 198 assert(c.emplace(std::move(v2)).second == false); 199 } 200 } 201 } 202 203 204 template <class Container> 205 void testSetEmplaceHint() 206 { 207 typedef typename Container::value_type ValueTp; 208 typedef Container C; 209 typedef typename C::iterator It; 210 ConstructController* cc = getConstructController(); 211 cc->reset(); 212 { 213 CHECKPOINT("Testing C::emplace_hint(p, const value_type&)"); 214 Container c; 215 const ValueTp v(42); 216 cc->expect<const ValueTp&>(); 217 It ret = c.emplace_hint(c.end(), v); 218 assert(ret != c.end()); 219 assert(c.size() == 1); 220 assert(!cc->unchecked()); 221 { 222 DisableAllocationGuard g; 223 const ValueTp v2(42); 224 It ret2 = c.emplace_hint(c.begin(), v2); 225 assert(&(*ret2) == &(*ret)); 226 assert(c.size() == 1); 227 } 228 } 229 { 230 CHECKPOINT("Testing C::emplace_hint(p, value_type&)"); 231 Container c; 232 ValueTp v(42); 233 cc->expect<ValueTp&>(); 234 It ret = c.emplace_hint(c.end(), v); 235 assert(ret != c.end()); 236 assert(c.size() == 1); 237 assert(!cc->unchecked()); 238 { 239 DisableAllocationGuard g; 240 ValueTp v2(42); 241 It ret2 = c.emplace_hint(c.begin(), v2); 242 assert(&(*ret2) == &(*ret)); 243 assert(c.size() == 1); 244 } 245 } 246 { 247 CHECKPOINT("Testing C::emplace_hint(p, value_type&&)"); 248 Container c; 249 ValueTp v(42); 250 cc->expect<ValueTp&&>(); 251 It ret = c.emplace_hint(c.end(), std::move(v)); 252 assert(ret != c.end()); 253 assert(c.size() == 1); 254 assert(!cc->unchecked()); 255 { 256 DisableAllocationGuard g; 257 ValueTp v2(42); 258 It ret2 = c.emplace_hint(c.begin(), std::move(v2)); 259 assert(&(*ret2) == &(*ret)); 260 assert(c.size() == 1); 261 } 262 } 263 { 264 CHECKPOINT("Testing C::emplace_hint(p, const value_type&&)"); 265 Container c; 266 const ValueTp v(42); 267 cc->expect<const ValueTp&&>(); 268 It ret = c.emplace_hint(c.end(), std::move(v)); 269 assert(ret != c.end()); 270 assert(c.size() == 1); 271 assert(!cc->unchecked()); 272 { 273 DisableAllocationGuard g; 274 const ValueTp v2(42); 275 It ret2 = c.emplace_hint(c.begin(), std::move(v2)); 276 assert(&(*ret2) == &(*ret)); 277 assert(c.size() == 1); 278 } 279 } 280 } 281 282 283 template <class Container> 284 void testMultisetInsert() 285 { 286 typedef typename Container::value_type ValueTp; 287 ConstructController* cc = getConstructController(); 288 cc->reset(); 289 { 290 CHECKPOINT("Testing C::insert(const value_type&)"); 291 Container c; 292 const ValueTp v(42); 293 cc->expect<const ValueTp&>(); 294 c.insert(v); 295 assert(!cc->unchecked()); 296 } 297 { 298 CHECKPOINT("Testing C::insert(value_type&)"); 299 Container c; 300 ValueTp v(42); 301 cc->expect<const ValueTp&>(); 302 c.insert(v); 303 assert(!cc->unchecked()); 304 } 305 { 306 CHECKPOINT("Testing C::insert(value_type&&)"); 307 Container c; 308 ValueTp v(42); 309 cc->expect<ValueTp&&>(); 310 c.insert(std::move(v)); 311 assert(!cc->unchecked()); 312 } 313 { 314 CHECKPOINT("Testing C::insert(std::initializer_list<ValueTp>)"); 315 Container c; 316 std::initializer_list<ValueTp> il = { ValueTp(1), ValueTp(2) }; 317 cc->expect<ValueTp const&>(2); 318 c.insert(il); 319 assert(!cc->unchecked()); 320 } 321 { 322 CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type const&"); 323 Container c; 324 const ValueTp ValueList[] = { ValueTp(1), ValueTp(2), ValueTp(3) }; 325 cc->expect<ValueTp const&>(3); 326 c.insert(std::begin(ValueList), std::end(ValueList)); 327 assert(!cc->unchecked()); 328 } 329 { 330 CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&&"); 331 Container c; 332 ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(3) }; 333 cc->expect<ValueTp&&>(3); 334 c.insert(std::move_iterator<ValueTp*>(std::begin(ValueList)), 335 std::move_iterator<ValueTp*>(std::end(ValueList))); 336 assert(!cc->unchecked()); 337 } 338 { 339 CHECKPOINT("Testing C::insert(Iter, Iter) for *Iter = value_type&"); 340 Container c; 341 ValueTp ValueList[] = { ValueTp(1), ValueTp(2) , ValueTp(1) }; 342 cc->expect<ValueTp&>(3); 343 c.insert(std::begin(ValueList), std::end(ValueList)); 344 assert(!cc->unchecked()); 345 } 346 } 347 348 349 template <class Container> 350 void testMultisetEmplace() 351 { 352 typedef typename Container::value_type ValueTp; 353 ConstructController* cc = getConstructController(); 354 cc->reset(); 355 { 356 CHECKPOINT("Testing C::emplace(const value_type&)"); 357 Container c; 358 const ValueTp v(42); 359 cc->expect<const ValueTp&>(); 360 c.emplace(v); 361 assert(!cc->unchecked()); 362 } 363 { 364 CHECKPOINT("Testing C::emplace(value_type&)"); 365 Container c; 366 ValueTp v(42); 367 cc->expect<ValueTp&>(); 368 c.emplace(v); 369 assert(!cc->unchecked()); 370 } 371 { 372 CHECKPOINT("Testing C::emplace(value_type&&)"); 373 Container c; 374 ValueTp v(42); 375 cc->expect<ValueTp&&>(); 376 c.emplace(std::move(v)); 377 assert(!cc->unchecked()); 378 } 379 { 380 CHECKPOINT("Testing C::emplace(const value_type&&)"); 381 Container c; 382 const ValueTp v(42); 383 cc->expect<const ValueTp&&>(); 384 c.emplace(std::move(v)); 385 assert(!cc->unchecked()); 386 } 387 } 388 389 #endif 390
