This is an archive of the discontinued LLVM Phabricator instance.

Differential D22159

[libcxx] [test] Mark bucket_size() assertions as nonportable.
ClosedPublic

Authored by STL_MSFT on Jul 8 2016, 12:25 PM.

Details

Reviewers
mclow.lists
EricWF
Summary

Mark bucket_size() assertions as nonportable.

Even if you control the hash, the Standard doesn't guarantee what the bucket population sizes will be. All of these assertions are nonportable and should be marked accordingly.

Diff Detail

Event Timeline

STL_MSFT updated this revision to Diff 63290.Jul 8 2016, 12:25 PM
STL_MSFT retitled this revision from to [libcxx] [test] Mark bucket_size() assertions as nonportable..
STL_MSFT updated this object.
STL_MSFT added reviewers: EricWF, mclow.lists.
STL_MSFT added a subscriber: cfe-commits.
EricWF accepted this revision.Jul 24 2016, 4:20 PM
EricWF edited edge metadata.
This revision is now accepted and ready to land.Jul 24 2016, 4:20 PM
EricWF closed this revision.Jul 24 2016, 4:21 PM

r276578.

Revision Contents

PathSize
test/
std/
containers/
unord/
unord.map/
21 lines
unord.multimap/
29 lines
unord.multiset/
29 lines
unord.set/
21 lines

Diff 63290

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

Show All 17 Lines
#ifdef _LIBCPP_DEBUG #ifdef _LIBCPP_DEBUG
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#endif #endif
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_map<int, std::string> C; typedef std::unordered_map<int, std::string> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
const C c(std::begin(a), std::end(a)); const C c(std::begin(a), std::end(a));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.bucket_size(0) == 0); LIBCPP_ASSERT(c.bucket_size(0) == 0);
assert(c.bucket_size(1) == 1); LIBCPP_ASSERT(c.bucket_size(1) == 1);
assert(c.bucket_size(2) == 1); LIBCPP_ASSERT(c.bucket_size(2) == 1);
assert(c.bucket_size(3) == 1); LIBCPP_ASSERT(c.bucket_size(3) == 1);
assert(c.bucket_size(4) == 1); LIBCPP_ASSERT(c.bucket_size(4) == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C; min_allocator<std::pair<const int, std::string>>> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
const C c(std::begin(a), std::end(a)); const C c(std::begin(a), std::end(a));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.bucket_size(0) == 0); LIBCPP_ASSERT(c.bucket_size(0) == 0);
assert(c.bucket_size(1) == 1); LIBCPP_ASSERT(c.bucket_size(1) == 1);
assert(c.bucket_size(2) == 1); LIBCPP_ASSERT(c.bucket_size(2) == 1);
assert(c.bucket_size(3) == 1); LIBCPP_ASSERT(c.bucket_size(3) == 1);
assert(c.bucket_size(4) == 1); LIBCPP_ASSERT(c.bucket_size(4) == 1);
} }
#endif #endif
#if _LIBCPP_DEBUG_LEVEL >= 1 #if _LIBCPP_DEBUG_LEVEL >= 1
{ {
typedef std::unordered_map<int, std::string> C; typedef std::unordered_map<int, std::string> C;
C c; C c;
C::size_type i = c.bucket_size(3); C::size_type i = c.bucket_size(3);
assert(false); assert(false);
} }
#endif #endif
} }

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

Show All 17 Lines
#ifdef _LIBCPP_DEBUG #ifdef _LIBCPP_DEBUG
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#endif #endif
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
const C c(std::begin(a), std::end(a)); const C c(std::begin(a), std::end(a));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.bucket_size(0) == 0); LIBCPP_ASSERT(c.bucket_size(0) == 0);
assert(c.bucket_size(1) == 2); LIBCPP_ASSERT(c.bucket_size(1) == 2);
assert(c.bucket_size(2) == 2); LIBCPP_ASSERT(c.bucket_size(2) == 2);
assert(c.bucket_size(3) == 1); LIBCPP_ASSERT(c.bucket_size(3) == 1);
assert(c.bucket_size(4) == 1); LIBCPP_ASSERT(c.bucket_size(4) == 1);
assert(c.bucket_size(5) == 0); LIBCPP_ASSERT(c.bucket_size(5) == 0);
assert(c.bucket_size(6) == 0); LIBCPP_ASSERT(c.bucket_size(6) == 0);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C; min_allocator<std::pair<const int, std::string>>> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
P(3, "three"), P(3, "three"),
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
const C c(std::begin(a), std::end(a)); const C c(std::begin(a), std::end(a));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.bucket_size(0) == 0); LIBCPP_ASSERT(c.bucket_size(0) == 0);
assert(c.bucket_size(1) == 2); LIBCPP_ASSERT(c.bucket_size(1) == 2);
assert(c.bucket_size(2) == 2); LIBCPP_ASSERT(c.bucket_size(2) == 2);
assert(c.bucket_size(3) == 1); LIBCPP_ASSERT(c.bucket_size(3) == 1);
assert(c.bucket_size(4) == 1); LIBCPP_ASSERT(c.bucket_size(4) == 1);
assert(c.bucket_size(5) == 0); LIBCPP_ASSERT(c.bucket_size(5) == 0);
assert(c.bucket_size(6) == 0); LIBCPP_ASSERT(c.bucket_size(6) == 0);
} }
#endif #endif
#if _LIBCPP_DEBUG_LEVEL >= 1 #if _LIBCPP_DEBUG_LEVEL >= 1
{ {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> C;
C c; C c;
C::size_type i = c.bucket_size(3); C::size_type i = c.bucket_size(3);
assert(false); assert(false);
} }
#endif #endif
} }

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

Show All 16 Lines
#ifdef _LIBCPP_DEBUG #ifdef _LIBCPP_DEBUG
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#endif #endif
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
const C c(std::begin(a), std::end(a)); const C c(std::begin(a), std::end(a));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.bucket_size(0) == 0); LIBCPP_ASSERT(c.bucket_size(0) == 0);
assert(c.bucket_size(1) == 2); LIBCPP_ASSERT(c.bucket_size(1) == 2);
assert(c.bucket_size(2) == 2); LIBCPP_ASSERT(c.bucket_size(2) == 2);
assert(c.bucket_size(3) == 1); LIBCPP_ASSERT(c.bucket_size(3) == 1);
assert(c.bucket_size(4) == 1); LIBCPP_ASSERT(c.bucket_size(4) == 1);
assert(c.bucket_size(5) == 0); LIBCPP_ASSERT(c.bucket_size(5) == 0);
assert(c.bucket_size(6) == 0); LIBCPP_ASSERT(c.bucket_size(6) == 0);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, std::hash<int>, typedef std::unordered_multiset<int, std::hash<int>,
std::equal_to<int>, min_allocator<int>> C; std::equal_to<int>, min_allocator<int>> C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
const C c(std::begin(a), std::end(a)); const C c(std::begin(a), std::end(a));
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
assert(c.bucket_size(0) == 0); LIBCPP_ASSERT(c.bucket_size(0) == 0);
assert(c.bucket_size(1) == 2); LIBCPP_ASSERT(c.bucket_size(1) == 2);
assert(c.bucket_size(2) == 2); LIBCPP_ASSERT(c.bucket_size(2) == 2);
assert(c.bucket_size(3) == 1); LIBCPP_ASSERT(c.bucket_size(3) == 1);
assert(c.bucket_size(4) == 1); LIBCPP_ASSERT(c.bucket_size(4) == 1);
assert(c.bucket_size(5) == 0); LIBCPP_ASSERT(c.bucket_size(5) == 0);
assert(c.bucket_size(6) == 0); LIBCPP_ASSERT(c.bucket_size(6) == 0);
} }
#endif #endif
#if _LIBCPP_DEBUG_LEVEL >= 1 #if _LIBCPP_DEBUG_LEVEL >= 1
{ {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> C;
C c; C c;
C::size_type i = c.bucket_size(3); C::size_type i = c.bucket_size(3);
assert(false); assert(false);
} }
#endif #endif
} }

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

Show All 16 Lines
#ifdef _LIBCPP_DEBUG #ifdef _LIBCPP_DEBUG
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
#endif #endif
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_set<int> C; typedef std::unordered_set<int> C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
const C c(std::begin(a), std::end(a)); const C c(std::begin(a), std::end(a));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.bucket_size(0) == 0); LIBCPP_ASSERT(c.bucket_size(0) == 0);
assert(c.bucket_size(1) == 1); LIBCPP_ASSERT(c.bucket_size(1) == 1);
assert(c.bucket_size(2) == 1); LIBCPP_ASSERT(c.bucket_size(2) == 1);
assert(c.bucket_size(3) == 1); LIBCPP_ASSERT(c.bucket_size(3) == 1);
assert(c.bucket_size(4) == 1); LIBCPP_ASSERT(c.bucket_size(4) == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
const C c(std::begin(a), std::end(a)); const C c(std::begin(a), std::end(a));
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
assert(c.bucket_size(0) == 0); LIBCPP_ASSERT(c.bucket_size(0) == 0);
assert(c.bucket_size(1) == 1); LIBCPP_ASSERT(c.bucket_size(1) == 1);
assert(c.bucket_size(2) == 1); LIBCPP_ASSERT(c.bucket_size(2) == 1);
assert(c.bucket_size(3) == 1); LIBCPP_ASSERT(c.bucket_size(3) == 1);
assert(c.bucket_size(4) == 1); LIBCPP_ASSERT(c.bucket_size(4) == 1);
} }
#endif #endif
#if _LIBCPP_DEBUG_LEVEL >= 1 #if _LIBCPP_DEBUG_LEVEL >= 1
{ {
typedef std::unordered_set<int> C; typedef std::unordered_set<int> C;
C c; C c;
C::size_type i = c.bucket_size(3); C::size_type i = c.bucket_size(3);
assert(false); assert(false);
} }
#endif #endif
} }