[libcxx] [test] Make bucket_count() greater-equal assertions portable.

[STL_MSFT]

Summary

Make bucket_count() greater-equal assertions portable.

The Standard provides a guarantee here, but these assertions were going beyond that guarantee. These containers have 8 elements, so the bucket count is guaranteed to be at least 8, but may not be as large as 11 (and isn't in MSVC's implementation).

[EricWF]

r276580.

test/std/containers/unord/unord.map/bucket_count.pass.cpp

int main()
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c(std::begin(a), std::end(a));
-        assert(c.bucket_count() >= 11);
+        assert(c.bucket_count() >= 8);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         const C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c(std::begin(a), std::end(a));
-        assert(c.bucket_count() >= 11);
+        assert(c.bucket_count() >= 8);
     }
 #endif
 }

test/std/containers/unord/unord.multimap/bucket_count.pass.cpp

int main()
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c(std::begin(a), std::end(a));
-        assert(c.bucket_count() >= 11);
+        assert(c.bucket_count() >= 8);
     }
 }

test/std/containers/unord/unord.multiset/bucket_count.pass.cpp

int main()
             P(30),
             P(40),
             P(50),
             P(60),
             P(70),
             P(80)
         };
         const C c(std::begin(a), std::end(a));
-        assert(c.bucket_count() >= 11);
+        assert(c.bucket_count() >= 8);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<int, std::hash<int>,
                                       std::equal_to<int>, min_allocator<int>> C;
         typedef C::const_iterator I;
         typedef int P;
         const C c;
#if TEST_STD_VER >= 11
             P(30),
             P(40),
             P(50),
             P(60),
             P(70),
             P(80)
         };
         const C c(std::begin(a), std::end(a));
-        assert(c.bucket_count() >= 11);
+        assert(c.bucket_count() >= 8);
     }
 #endif
 }

test/std/containers/unord/unord.set/bucket_count.pass.cpp

int main()
             P(30),
             P(40),
             P(50),
             P(60),
             P(70),
             P(80)
         };
         const C c(std::begin(a), std::end(a));
-        assert(c.bucket_count() >= 11);
+        assert(c.bucket_count() >= 8);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
         typedef C::const_iterator I;
         typedef int P;
         const C c;
         LIBCPP_ASSERT(c.bucket_count() == 0);
#if TEST_STD_VER >= 11
             P(30),
             P(40),
             P(50),
             P(60),
             P(70),
             P(80)
         };
         const C c(std::begin(a), std::end(a));
-        assert(c.bucket_count() >= 11);
+        assert(c.bucket_count() >= 8);
     }
 #endif
 }