This is an archive of the discontinued LLVM Phabricator instance.

Differential D22157

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

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

Details

Reviewers
mclow.lists
EricWF
Summary

Mark bucket() assertions as nonportable.

The Standard doesn't guarantee what bucket an element will land in, even if you control the hash. All such assertions are inherently nonportable and should be marked accordingly.

Diff Detail

Event Timeline

STL_MSFT updated this revision to Diff 63285.Jul 8 2016, 12:22 PM
STL_MSFT retitled this revision from to [libcxx] [test] Mark bucket() 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:41 PM
EricWF edited edge metadata.
This revision is now accepted and ready to land.Jul 24 2016, 4:41 PM
EricWF closed this revision.Jul 24 2016, 4:41 PM

r276584.

Revision Contents

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

Diff 63285

test/std/containers/unord/unord.map/bucket.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));
size_t bc = c.bucket_count(); size_t bc = c.bucket_count();
assert(bc >= 5); assert(bc >= 5);
for (size_t i = 0; i < 13; ++i) for (size_t i = 0; i < 13; ++i)
assert(c.bucket(i) == i % bc); LIBCPP_ASSERT(c.bucket(i) == i % bc);
} }
#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));
size_t bc = c.bucket_count(); size_t bc = c.bucket_count();
assert(bc >= 5); assert(bc >= 5);
for (size_t i = 0; i < 13; ++i) for (size_t i = 0; i < 13; ++i)
assert(c.bucket(i) == i % bc); LIBCPP_ASSERT(c.bucket(i) == i % bc);
} }
#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(3); C::size_type i = c.bucket(3);
assert(false); assert(false);
} }
#endif #endif
} }

test/std/containers/unord/unord.multimap/bucket.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));
size_t bc = c.bucket_count(); size_t bc = c.bucket_count();
assert(bc >= 7); assert(bc >= 7);
for (size_t i = 0; i < 13; ++i) for (size_t i = 0; i < 13; ++i)
assert(c.bucket(i) == i % bc); LIBCPP_ASSERT(c.bucket(i) == i % bc);
} }
#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));
size_t bc = c.bucket_count(); size_t bc = c.bucket_count();
assert(bc >= 7); assert(bc >= 7);
for (size_t i = 0; i < 13; ++i) for (size_t i = 0; i < 13; ++i)
assert(c.bucket(i) == i % bc); LIBCPP_ASSERT(c.bucket(i) == i % bc);
} }
#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(3); C::size_type i = c.bucket(3);
assert(false); assert(false);
} }
#endif #endif
} }

test/std/containers/unord/unord.multiset/bucket.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));
size_t bc = c.bucket_count(); size_t bc = c.bucket_count();
assert(bc >= 7); assert(bc >= 7);
for (size_t i = 0; i < 13; ++i) for (size_t i = 0; i < 13; ++i)
assert(c.bucket(i) == i % bc); LIBCPP_ASSERT(c.bucket(i) == i % bc);
} }
#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));
size_t bc = c.bucket_count(); size_t bc = c.bucket_count();
assert(bc >= 7); assert(bc >= 7);
for (size_t i = 0; i < 13; ++i) for (size_t i = 0; i < 13; ++i)
assert(c.bucket(i) == i % bc); LIBCPP_ASSERT(c.bucket(i) == i % bc);
} }
#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(3); C::size_type i = c.bucket(3);
assert(false); assert(false);
} }
#endif #endif
} }

test/std/containers/unord/unord.set/bucket.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));
size_t bc = c.bucket_count(); size_t bc = c.bucket_count();
assert(bc >= 5); assert(bc >= 5);
for (size_t i = 0; i < 13; ++i) for (size_t i = 0; i < 13; ++i)
assert(c.bucket(i) == i % bc); LIBCPP_ASSERT(c.bucket(i) == i % bc);
} }
#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));
size_t bc = c.bucket_count(); size_t bc = c.bucket_count();
assert(bc >= 5); assert(bc >= 5);
for (size_t i = 0; i < 13; ++i) for (size_t i = 0; i < 13; ++i)
assert(c.bucket(i) == i % bc); LIBCPP_ASSERT(c.bucket(i) == i % bc);
} }
#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(3); C::size_type i = c.bucket(3);
assert(false); assert(false);
} }
#endif #endif
} }