libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // <unordered_map>
  10
  11 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
  12 //           class Alloc = allocator<pair<const Key, T>>>
  13 // class unordered_multimap
  14
  15 // unordered_multimap();
  16
  17 #include <unordered_map>
  18 #include <cassert>
  19
  20 #include "test_macros.h"
  21 #include "../../../NotConstructible.h"
  22 #include "../../../test_compare.h"
  23 #include "../../../test_hash.h"
  24 #include "test_allocator.h"
  25 #include "min_allocator.h"
  26
  27 int main(int, char**)
  28 {
  29     {
  30         typedef std::unordered_multimap<NotConstructible, NotConstructible,
  31                                    test_hash<NotConstructible>,
  32                                    test_equal_to<NotConstructible>,
  33                                    test_allocator<std::pair<const NotConstructible,
  34                                                                   NotConstructible> >
  35                                    > C;
  36         C c;
  37         LIBCPP_ASSERT(c.bucket_count() == 0);
  38         assert(c.hash_function() == test_hash<NotConstructible>());
  39         assert(c.key_eq() == test_equal_to<NotConstructible>());
  40         assert(c.get_allocator() ==
  41                (test_allocator<std::pair<const NotConstructible, NotConstructible> >()));
  42         assert(c.size() == 0);
  43         assert(c.empty());
  44         assert(std::distance(c.begin(), c.end()) == 0);
  45         assert(c.load_factor() == 0);
  46         assert(c.max_load_factor() == 1);
  47     }
  48 #if TEST_STD_VER >= 11
  49     {
  50         typedef std::unordered_multimap<NotConstructible, NotConstructible,
  51                                    test_hash<NotConstructible>,
  52                                    test_equal_to<NotConstructible>,
  53                                    min_allocator<std::pair<const NotConstructible,
  54                                                                  NotConstructible> >
  55                                    > C;
  56         C c;
  57         LIBCPP_ASSERT(c.bucket_count() == 0);
  58         assert(c.hash_function() == test_hash<NotConstructible>());
  59         assert(c.key_eq() == test_equal_to<NotConstructible>());
  60         assert(c.get_allocator() ==
  61                (min_allocator<std::pair<const NotConstructible, NotConstructible> >()));
  62         assert(c.size() == 0);
  63         assert(c.empty());
  64         assert(std::distance(c.begin(), c.end()) == 0);
  65         assert(c.load_factor() == 0);
  66         assert(c.max_load_factor() == 1);
  67     }
  68     {
  69         typedef explicit_allocator<std::pair<const NotConstructible, NotConstructible>> A;
  70         typedef std::unordered_multimap<NotConstructible, NotConstructible,
  71                                    test_hash<NotConstructible>,
  72                                    test_equal_to<NotConstructible>,
  73                                    A
  74                                    > C;
  75         {
  76         C c;
  77         LIBCPP_ASSERT(c.bucket_count() == 0);
  78         assert(c.hash_function() == test_hash<NotConstructible>());
  79         assert(c.key_eq() == test_equal_to<NotConstructible>());
  80         assert(c.get_allocator() == A());
  81         assert(c.size() == 0);
  82         assert(c.empty());
  83         assert(std::distance(c.begin(), c.end()) == 0);
  84         assert(c.load_factor() == 0);
  85         assert(c.max_load_factor() == 1);
  86         }
  87         {
  88         A a;
  89         C c(a);
  90         LIBCPP_ASSERT(c.bucket_count() == 0);
  91         assert(c.hash_function() == test_hash<NotConstructible>());
  92         assert(c.key_eq() == test_equal_to<NotConstructible>());
  93         assert(c.get_allocator() == a);
  94         assert(c.size() == 0);
  95         assert(c.empty());
  96         assert(std::distance(c.begin(), c.end()) == 0);
  97         assert(c.load_factor() == 0);
  98         assert(c.max_load_factor() == 1);
  99         }
 100     }
 101     {
 102         std::unordered_multimap<int, int> c = {};
 103         LIBCPP_ASSERT(c.bucket_count() == 0);
 104         assert(c.size() == 0);
 105         assert(c.empty());
 106         assert(std::distance(c.begin(), c.end()) == 0);
 107         assert(c.load_factor() == 0);
 108         assert(c.max_load_factor() == 1);
 109     }
 110 #endif
 111
 112   return 0;
 113 }