Home | History | Annotate | Download | only in unord.map
      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_map
     15 
     16 // size_type bucket_count() const;
     17 
     18 #include <unordered_map>
     19 #include <string>
     20 #include <cassert>
     21 
     22 #include "test_macros.h"
     23 #include "min_allocator.h"
     24 
     25 int main()
     26 {
     27     {
     28         typedef std::unordered_map<int, std::string> C;
     29         const C c;
     30         LIBCPP_ASSERT(c.bucket_count() == 0);
     31     }
     32     {
     33         typedef std::unordered_map<int, std::string> C;
     34         typedef std::pair<int, std::string> P;
     35         P a[] =
     36         {
     37             P(10, "ten"),
     38             P(20, "twenty"),
     39             P(30, "thirty"),
     40             P(40, "forty"),
     41             P(50, "fifty"),
     42             P(60, "sixty"),
     43             P(70, "seventy"),
     44             P(80, "eighty"),
     45         };
     46         const C c(std::begin(a), std::end(a));
     47         assert(c.bucket_count() >= 8);
     48     }
     49 #if TEST_STD_VER >= 11
     50     {
     51         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
     52                             min_allocator<std::pair<const int, std::string>>> C;
     53         const C c;
     54         LIBCPP_ASSERT(c.bucket_count() == 0);
     55     }
     56     {
     57         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
     58                             min_allocator<std::pair<const int, std::string>>> C;
     59         typedef std::pair<int, std::string> P;
     60         P a[] =
     61         {
     62             P(10, "ten"),
     63             P(20, "twenty"),
     64             P(30, "thirty"),
     65             P(40, "forty"),
     66             P(50, "fifty"),
     67             P(60, "sixty"),
     68             P(70, "seventy"),
     69             P(80, "eighty"),
     70         };
     71         const C c(std::begin(a), std::end(a));
     72         assert(c.bucket_count() >= 8);
     73     }
     74 #endif
     75 }
     76