CaseyCarter updated this revision to Diff 224092. CaseyCarter edited the summary of this revision. CaseyCarter added a comment.
Avoid rather than suppress truncation warnings in `unordered_meow` deduction guide tests. CHANGES SINCE LAST ACTION https://reviews.llvm.org/D68681/new/ https://reviews.llvm.org/D68681 Files: test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.pass.cpp test/std/containers/unord/unord.set/unord.set.cnstr/deduct.pass.cpp test/std/numerics/c.math/abs.pass.cpp test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp
Index: test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp =================================================================== --- test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp +++ test/std/utilities/meta/meta.trans/meta.trans.other/underlying_type.pass.cpp @@ -42,7 +42,7 @@ ASSERT_SAME_TYPE(Expected, typename std::underlying_type<T>::type); #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(Expected, typename std::underlying_type_t<T>); -#endif +#endif } enum E { V = INT_MIN }; @@ -79,7 +79,9 @@ // SFINAE-able underlying_type #if TEST_STD_VER > 17 static_assert( has_type_member<E>::value, ""); +#ifdef TEST_UNSIGNED_UNDERLYING_TYPE static_assert( has_type_member<F>::value, ""); +#endif // TEST_UNSIGNED_UNDERLYING_TYPE static_assert( has_type_member<G>::value, ""); static_assert(!has_type_member<void>::value, ""); Index: test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp =================================================================== --- test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp +++ test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp @@ -41,7 +41,7 @@ constexpr T maxV = std::numeric_limits<T>::max(); constexpr T minV = std::numeric_limits<T>::min(); - + // Things that can be compared exactly static_assert((std::midpoint(T(0), T(0)) == T(0)), ""); static_assert((std::midpoint(T(2), T(4)) == T(3)), ""); @@ -58,7 +58,7 @@ assert((fptest_close_pct(std::midpoint(T(0.1), T(0.4)), T(0.25), pct))); assert((fptest_close_pct(std::midpoint(T(11.2345), T(14.5432)), T(12.88885), pct))); - + // From e to pi assert((fptest_close_pct(std::midpoint(T(2.71828182845904523536028747135266249775724709369995), T(3.14159265358979323846264338327950288419716939937510)), @@ -86,7 +86,7 @@ // TODO // Check two values "close to each other" - T d1 = 3.14; + T d1 = T(3.14); T d0 = std::nextafter(d1, T(2)); T d2 = std::nextafter(d1, T(5)); assert(d0 < d1); // sanity checking Index: test/std/numerics/c.math/abs.pass.cpp =================================================================== --- test/std/numerics/c.math/abs.pass.cpp +++ test/std/numerics/c.math/abs.pass.cpp @@ -9,6 +9,7 @@ #include <assert.h> #include <cmath> #include <cstdint> +#include <limits> #include <type_traits> #include "test_macros.h" @@ -75,4 +76,3 @@ return 0; } - Index: test/std/containers/unord/unord.set/unord.set.cnstr/deduct.pass.cpp =================================================================== --- test/std/containers/unord/unord.set/unord.set.cnstr/deduct.pass.cpp +++ test/std/containers/unord/unord.set/unord.set.cnstr/deduct.pass.cpp @@ -78,37 +78,37 @@ { const int arr[] = { 1, 2, 1, INT_MAX, 3 }; - std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<short>()); + std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<long long>()); - ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); } { const int arr[] = { 1, 2, 1, INT_MAX, 3 }; - std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<int>(0, 40)); + std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<long long>(), test_allocator<int>(0, 40)); - ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); assert(s.get_allocator().get_id() == 40); } { - std::unordered_set<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source; + std::unordered_set<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source; std::unordered_set s(source); ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s.size() == 0); } { - std::unordered_set<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source; + std::unordered_set<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source; std::unordered_set s{source}; // braces instead of parens ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s.size() == 0); } { - std::unordered_set<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source; + std::unordered_set<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source; std::unordered_set s(source, test_allocator<int>(0, 41)); ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s.size() == 0); @@ -116,7 +116,7 @@ } { - std::unordered_set<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source; + std::unordered_set<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source; std::unordered_set s{source, test_allocator<int>(0, 42)}; // braces instead of parens ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s.size() == 0); @@ -138,23 +138,23 @@ } { - std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>()); + std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>()); - ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); } { - std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), std::equal_to<>()); + std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), std::equal_to<>()); - ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>, std::equal_to<>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>, std::equal_to<>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); } { - std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<int>(0, 43)); + std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), std::equal_to<>(), test_allocator<int>(0, 43)); - ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>, std::equal_to<>, test_allocator<int>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>, std::equal_to<>, test_allocator<int>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); assert(s.get_allocator().get_id() == 43); } @@ -170,9 +170,9 @@ { const int arr[] = { 1, 2, 1, INT_MAX, 3 }; - std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<int>(0, 44)); + std::unordered_set s(std::begin(arr), std::end(arr), 42, std::hash<long long>(), test_allocator<int>(0, 44)); - ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); assert(s.get_allocator().get_id() == 44); } @@ -186,9 +186,9 @@ } { - std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), test_allocator<int>(0, 42)); + std::unordered_set s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), test_allocator<int>(0, 42)); - ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_set<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); assert(s.get_allocator().get_id() == 42); } Index: test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.pass.cpp =================================================================== --- test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.pass.cpp +++ test/std/containers/unord/unord.multiset/unord.multiset.cnstr/deduct.pass.cpp @@ -78,37 +78,37 @@ { const int arr[] = { 1, 2, 1, INT_MAX, 3 }; - std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<short>()); + std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<long long>()); - ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); } { const int arr[] = { 1, 2, 1, INT_MAX, 3 }; - std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<int>(0, 40)); + std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<long long>(), test_allocator<int>(0, 40)); - ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); assert(s.get_allocator().get_id() == 40); } { - std::unordered_multiset<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source; + std::unordered_multiset<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source; std::unordered_multiset s(source); ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s.size() == 0); } { - std::unordered_multiset<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source; + std::unordered_multiset<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source; std::unordered_multiset s{source}; // braces instead of parens ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s.size() == 0); } { - std::unordered_multiset<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source; + std::unordered_multiset<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source; std::unordered_multiset s(source, test_allocator<int>(0, 41)); ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s.size() == 0); @@ -116,7 +116,7 @@ } { - std::unordered_multiset<int, std::hash<short>, std::equal_to<>, test_allocator<int>> source; + std::unordered_multiset<int, std::hash<long long>, std::equal_to<>, test_allocator<int>> source; std::unordered_multiset s{source, test_allocator<int>(0, 42)}; // braces instead of parens ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s.size() == 0); @@ -138,23 +138,23 @@ } { - std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>()); + std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>()); - ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); } { - std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), std::equal_to<>()); + std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), std::equal_to<>()); - ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>, std::equal_to<>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>, std::equal_to<>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); } { - std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<int>(0, 43)); + std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), std::equal_to<>(), test_allocator<int>(0, 43)); - ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>, std::equal_to<>, test_allocator<int>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>, std::equal_to<>, test_allocator<int>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); assert(s.get_allocator().get_id() == 43); } @@ -170,9 +170,9 @@ { const int arr[] = { 1, 2, 1, INT_MAX, 3 }; - std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<int>(0, 44)); + std::unordered_multiset s(std::begin(arr), std::end(arr), 42, std::hash<long long>(), test_allocator<int>(0, 44)); - ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); assert(s.get_allocator().get_id() == 44); } @@ -186,9 +186,9 @@ } { - std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<short>(), test_allocator<int>(0, 42)); + std::unordered_multiset s({ 1, 2, 1, INT_MAX, 3 }, 42, std::hash<long long>(), test_allocator<int>(0, 42)); - ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<short>, std::equal_to<int>, test_allocator<int>>); + ASSERT_SAME_TYPE(decltype(s), std::unordered_multiset<int, std::hash<long long>, std::equal_to<int>, test_allocator<int>>); assert(std::is_permutation(s.begin(), s.end(), std::begin(expected_s), std::end(expected_s))); assert(s.get_allocator().get_id() == 42); } Index: test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp =================================================================== --- test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp +++ test/std/containers/unord/unord.map/unord.map.cnstr/deduct.pass.cpp @@ -87,22 +87,22 @@ { const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} }; - std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>()); - ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>>); + std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<long long>()); + ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<int>>); assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m))); } { const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} }; - std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), std::equal_to<>()); - ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>>); + std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<long long>(), std::equal_to<>()); + ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<>>); assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m))); } { const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} }; - std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), std::equal_to<>(), test_allocator<PC>(0, 41)); - ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>); + std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<long long>(), std::equal_to<>(), test_allocator<PC>(0, 41)); + ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<>, test_allocator<PC>>); assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m))); assert(m.get_allocator().get_id() == 41); } @@ -122,7 +122,7 @@ } { - std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>> source; + std::unordered_map<int, long, std::hash<long long>, std::equal_to<>, test_allocator<PC>> source; test_allocator<PC> a(0, 42); std::unordered_map m(source, a); ASSERT_SAME_TYPE(decltype(m), decltype(source)); @@ -131,7 +131,7 @@ } { - std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>> source; + std::unordered_map<int, long, std::hash<long long>, std::equal_to<>, test_allocator<PC>> source; test_allocator<PC> a(0, 43); std::unordered_map m{source, a}; // braces instead of parens ASSERT_SAME_TYPE(decltype(m), decltype(source)); @@ -152,20 +152,20 @@ } { - std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>()); - ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>>); + std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<long long>()); + ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>>); assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m))); } { - std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), std::equal_to<>()); - ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>>); + std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<long long>(), std::equal_to<>()); + ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<>>); assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m))); } { - std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), std::equal_to<>(), test_allocator<PC>(0, 44)); - ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<>, test_allocator<PC>>); + std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<long long>(), std::equal_to<>(), test_allocator<PC>(0, 44)); + ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<>, test_allocator<PC>>); assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m))); assert(m.get_allocator().get_id() == 44); } @@ -180,8 +180,8 @@ { const P arr[] = { {1,1}, {2,2}, {1,1}, {INT_MAX,1}, {3,1} }; - std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<short>(), test_allocator<PC>(0, 46)); - ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>); + std::unordered_map m(std::begin(arr), std::end(arr), 42, std::hash<long long>(), test_allocator<PC>(0, 46)); + ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<int>, test_allocator<PC>>); assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m))); assert(m.get_allocator().get_id() == 46); } @@ -194,8 +194,8 @@ } { - std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<short>(), test_allocator<PC>(0, 48)); - ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<short>, std::equal_to<int>, test_allocator<PC>>); + std::unordered_map m({ P{1,1L}, P{2,2L}, P{1,1L}, P{INT_MAX,1L}, P{3,1L} }, 42, std::hash<long long>(), test_allocator<PC>(0, 48)); + ASSERT_SAME_TYPE(decltype(m), std::unordered_map<int, long, std::hash<long long>, std::equal_to<int>, test_allocator<PC>>); assert(std::is_permutation(m.begin(), m.end(), std::begin(expected_m), std::end(expected_m))); assert(m.get_allocator().get_id() == 48); } Index: test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp =================================================================== --- test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp +++ test/std/containers/associative/set/set.cons/assign_initializer_list.pass.cpp @@ -57,17 +57,16 @@ void duplicate_keys_test() { typedef std::set<int, std::less<int>, test_allocator<int> > Set; - typedef test_alloc_base AllocBase; { - LIBCPP_ASSERT(AllocBase::alloc_count == 0); + LIBCPP_ASSERT(test_alloc_base::alloc_count == 0); Set s = {1, 2, 3}; - LIBCPP_ASSERT(AllocBase::alloc_count == 3); + LIBCPP_ASSERT(test_alloc_base::alloc_count == 3); s = {4, 4, 4, 4, 4}; - LIBCPP_ASSERT(AllocBase::alloc_count == 1); + LIBCPP_ASSERT(test_alloc_base::alloc_count == 1); assert(s.size() == 1); assert(*s.begin() == 4); } - LIBCPP_ASSERT(AllocBase::alloc_count == 0); + LIBCPP_ASSERT(test_alloc_base::alloc_count == 0); } int main(int, char**) { Index: test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp =================================================================== --- test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp +++ test/std/containers/associative/map/map.cons/assign_initializer_list.pass.cpp @@ -75,23 +75,22 @@ void duplicate_keys_test() { typedef std::map<int, int, std::less<int>, test_allocator<std::pair<const int, int> > > Map; - typedef test_alloc_base AllocBase; { - LIBCPP_ASSERT(AllocBase::alloc_count == 0); + LIBCPP_ASSERT(test_alloc_base::alloc_count == 0); Map s = {{1, 0}, {2, 0}, {3, 0}}; - LIBCPP_ASSERT(AllocBase::alloc_count == 3); + LIBCPP_ASSERT(test_alloc_base::alloc_count == 3); s = {{4, 0}, {4, 0}, {4, 0}, {4, 0}}; - LIBCPP_ASSERT(AllocBase::alloc_count == 1); + LIBCPP_ASSERT(test_alloc_base::alloc_count == 1); assert(s.size() == 1); assert(s.begin()->first == 4); } - LIBCPP_ASSERT(AllocBase::alloc_count == 0); + LIBCPP_ASSERT(test_alloc_base::alloc_count == 0); } int main(int, char**) { - test_basic(); - duplicate_keys_test(); + test_basic(); + duplicate_keys_test(); return 0; }
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits