/// Map between pixel co-ordinates and world co-ordinates point2d< extents_type > operator() ( resolution_type x, resolution_type y) const { return inner_camera(x, y) + point2d< extents_type >( jitter(generator) * inner_camera.pixel_width(), jitter(generator) * inner_camera.pixel_height()); }
int main() { { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; P a[] = { P(10, "ten"), P(20, "twenty"), P(30, "thirty"), P(40, "fourty"), P(50, "fifty"), P(60, "sixty"), P(70, "seventy"), P(80, "eighty"), }; const C c(std::begin(a), std::end(a)); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); } { typedef std::unordered_map<int, std::string> C; typedef std::pair<int, std::string> P; const C c; assert(c.load_factor() == 0); } }
int main() { { typedef std::unordered_map<int, std::string> C; typedef C::const_iterator I; typedef std::pair<int, std::string> P; const C c; assert(c.bucket_count() == 0); } { typedef std::unordered_map<int, std::string> C; typedef C::const_iterator I; typedef std::pair<int, std::string> P; P a[] = { P(10, "ten"), P(20, "twenty"), P(30, "thirty"), P(40, "fourty"), 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); } }
int main() { { typedef std::unordered_multiset<int> C; typedef int P; P a[] = { P(10), P(20), P(30), P(40), P(50), P(60), P(70), P(80) }; const C c(std::begin(a), std::end(a)); assert(c.load_factor() == (float)c.size() / c.bucket_count()); } { typedef std::unordered_multiset<int> C; typedef int P; const C c; assert(c.load_factor() == 0); } }
int tc_libcxx_containers_unord_multimap_bucket_count(void) { { typedef std::unordered_multimap<int, std::string> C; const C c; LIBCPP_ASSERT(c.bucket_count() == 0); } { typedef std::unordered_multimap<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)); TC_ASSERT_EXPR(c.bucket_count() >= 8); } TC_SUCCESS_RESULT(); return 0; }
int main() { { typedef std::unordered_multimap<int, std::string> C; typedef std::pair<int, std::string> P; const C c; assert(c.max_load_factor() == 1); } { typedef std::unordered_multimap<int, std::string> C; typedef std::pair<int, std::string> P; C c; assert(c.max_load_factor() == 1); c.max_load_factor(2.5); assert(c.max_load_factor() == 2.5); } #if __cplusplus >= 201103L { typedef std::unordered_multimap<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; const C c; assert(c.max_load_factor() == 1); } { typedef std::unordered_multimap<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; C c; assert(c.max_load_factor() == 1); c.max_load_factor(2.5); assert(c.max_load_factor() == 2.5); } #endif }
int main() { C c; c.p(); const C cc; cc.p(); const char * * const * const * * * const guessWhatIAmPtr = 0; }
void main() { { typedef unordered_map<int, std::string> C; typedef C::const_iterator I; typedef std::pair<int, std::string> P; const C c; assert(c.bucket_count() == 0); } { typedef unordered_map<int, std::string> C; typedef C::const_iterator I; 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); } //#if __cplusplus >= 201103L #ifdef LIBCPP_TEST_MIN_ALLOCATOR { typedef unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef C::const_iterator I; typedef std::pair<int, std::string> P; const C c; assert(c.bucket_count() == 0); } { typedef unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef C::const_iterator I; 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); } #endif }
int main() { { typedef std::unordered_multiset<int> C; typedef C::const_iterator I; typedef int P; const C c; assert(c.bucket_count() == 0); } { typedef std::unordered_multiset<int> C; typedef C::const_iterator I; typedef int P; P a[] = { P(10), P(20), 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); } #if __cplusplus >= 201103L { 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; assert(c.bucket_count() == 0); } { typedef std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef C::const_iterator I; typedef int P; P a[] = { P(10), P(20), 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); } #endif }
int main() { { typedef std::unordered_multimap<int, std::string> C; typedef std::pair<int, std::string> P; P a[] = { P(10, "ten"), P(20, "twenty"), P(30, "thirty"), P(40, "fourty"), P(50, "fifty"), P(60, "sixty"), P(70, "seventy"), P(80, "eighty"), }; const C c(std::begin(a), std::end(a)); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); } { typedef std::unordered_multimap<int, std::string> C; typedef std::pair<int, std::string> P; const C c; assert(c.load_factor() == 0); } #if __cplusplus >= 201103L { typedef std::unordered_multimap<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, "fourty"), P(50, "fifty"), P(60, "sixty"), P(70, "seventy"), P(80, "eighty"), }; const C c(std::begin(a), std::end(a)); assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); } { typedef std::unordered_multimap<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; const C c; assert(c.load_factor() == 0); } #endif }
int main() { { typedef std::unordered_set<int> C; typedef int P; P a[] = { P(10), P(20), P(30), P(40), P(50), P(60), P(70), P(80) }; const C c(std::begin(a), std::end(a)); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); } { typedef std::unordered_set<int> C; typedef int P; const C c; assert(c.load_factor() == 0); } #if TEST_STD_VER >= 11 { typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; P a[] = { P(10), P(20), P(30), P(40), P(50), P(60), P(70), P(80) }; const C c(std::begin(a), std::end(a)); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); } { typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; const C c; assert(c.load_factor() == 0); } #endif }
int main(int, char**) { { typedef std::unordered_map<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(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); } { typedef std::unordered_map<int, std::string> C; const C c; assert(c.load_factor() == 0); } #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; 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(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); } { 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; assert(c.load_factor() == 0); } #endif return 0; }
int main() { { typedef double T; typedef boost::enums::enum_array<T, EC3> C; const C c = {{1, 2, 3.5}}; const T* p = c.data(); BOOST_TEST(p[0] == 1); BOOST_TEST(p[1] == 2); BOOST_TEST(p[2] == 3.5); } return boost::report_errors(); }
void main() { { typedef unordered_set<int> C; typedef int P; const C c; #ifdef LIBCPP_HAS_BAD_NEWS_FOR_MOMO assert(c.max_load_factor() == 1); #endif } { typedef unordered_set<int> C; typedef int P; C c; #ifdef LIBCPP_HAS_BAD_NEWS_FOR_MOMO assert(c.max_load_factor() == 1); c.max_load_factor(2.5); assert(c.max_load_factor() == 2.5); #else c.max_load_factor(0.5); assert(c.max_load_factor() == 0.5); #endif } //#if __cplusplus >= 201103L #ifdef LIBCPP_TEST_MIN_ALLOCATOR { typedef unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; const C c; assert(c.max_load_factor() == 1); } { typedef unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; C c; assert(c.max_load_factor() == 1); c.max_load_factor(2.5); assert(c.max_load_factor() == 2.5); } #endif #if _LIBCPP_DEBUG_LEVEL >= 1 { typedef unordered_set<int> C; C c; LIBCPP_CATCH(c.max_load_factor(-0.5f)); //assert(false); } #endif }
int main() { { typedef double T; typedef std::array<T, 3> C; const C c = {1, 2, 3.5}; const T* p = c.data(); assert(p[0] == 1); assert(p[1] == 2); assert(p[2] == 3.5); } { typedef double T; typedef std::array<T, 0> C; const C c = {}; const T* p = c.data(); (void)p; // to placate scan-build } #if TEST_STD_VER > 14 { typedef std::array<int, 5> C; constexpr C c1{0,1,2,3,4}; constexpr const C c2{0,1,2,3,4}; static_assert ( c1.data() == &c1[0], ""); static_assert ( *c1.data() == c1[0], ""); static_assert ( c2.data() == &c2[0], ""); static_assert ( *c2.data() == c2[0], ""); } #endif }
int main(int argc, char* argv[]) { C c(1); const C c_const(10); std::cout << c.f() << std::endl; std::cout << c_const.f() << std::endl; c.f()++; // won't work: //c_const.f()++; std::cout << c.f() << std::endl; std::cout << c_const.f() << std::endl; }
int main() { { typedef std::unordered_multiset<int> C; const C c; assert(c.max_bucket_count() > 0); } #if __cplusplus >= 201103L { typedef std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; const C c; assert(c.max_bucket_count() > 0); } #endif }
int main(int, char**) { { typedef double T; typedef std::array<T, 3> C; C c = {1, 2, 3.5}; T* p = c.data(); assert(p[0] == 1); assert(p[1] == 2); assert(p[2] == 3.5); } { typedef double T; typedef std::array<T, 0> C; C c = {}; T* p = c.data(); LIBCPP_ASSERT(p != nullptr); } { typedef double T; typedef std::array<const T, 0> C; C c = {{}}; const T* p = c.data(); static_assert((std::is_same<decltype(c.data()), const T*>::value), ""); LIBCPP_ASSERT(p != nullptr); } { typedef std::max_align_t T; typedef std::array<T, 0> C; const C c = {}; const T* p = c.data(); LIBCPP_ASSERT(p != nullptr); std::uintptr_t pint = reinterpret_cast<std::uintptr_t>(p); assert(pint % TEST_ALIGNOF(std::max_align_t) == 0); } { typedef NoDefault T; typedef std::array<T, 0> C; C c = {}; T* p = c.data(); LIBCPP_ASSERT(p != nullptr); } return 0; }
int main(int, char**) { { typedef std::unordered_map<int, std::string> C; const C c; assert(c.max_bucket_count() > 0); } #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; assert(c.max_bucket_count() > 0); } #endif return 0; }
int main() { { typedef int T; typedef std::vector<T> C; const C c; assert(c.back() == 0); assert(false); } #if __cplusplus >= 201103L { typedef int T; typedef std::vector<T, min_allocator<T>> C; const C c; assert(c.back() == 0); assert(false); } #endif }
int main() { { typedef std::unordered_set<int> C; typedef int P; const C c; assert(c.max_load_factor() == 1); } { typedef std::unordered_set<int> C; typedef int P; C c; assert(c.max_load_factor() == 1); c.max_load_factor(2.5); assert(c.max_load_factor() == 2.5); } #if __cplusplus >= 201103L { typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; const C c; assert(c.max_load_factor() == 1); } { typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef int P; C c; assert(c.max_load_factor() == 1); c.max_load_factor(2.5); assert(c.max_load_factor() == 2.5); } #endif #if _LIBCPP_DEBUG_LEVEL >= 1 { typedef std::unordered_set<int> C; C c; c.max_load_factor(-0.5f); assert(false); } #endif }
int main() { { typedef int T; typedef std::list<T> C; const C c; assert(c.front() == 0); assert(false); } #if __cplusplus >= 201103L || defined(_LIBCPP_MSVC) { typedef int T; typedef std::list<T, min_allocator<T>> C; const C c; assert(c.front() == 0); assert(false); } #endif }
int main() { { typedef std::unordered_multimap<int, std::string> C; typedef C::const_iterator I; typedef std::pair<int, std::string> P; const C c; assert(c.max_bucket_count() > 0); } #if TEST_STD_VER >= 11 { typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef C::const_iterator I; typedef std::pair<int, std::string> P; const C c; assert(c.max_bucket_count() > 0); } #endif }
int main() { { typedef std::unordered_multimap<int, std::string> C; typedef C::const_iterator I; typedef std::pair<int, std::string> P; const C c; assert(c.max_bucket_count() > 0); } #if __cplusplus >= 201103L || defined(_LIBCPP_MSVC) { typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; typedef C::const_iterator I; typedef std::pair<int, std::string> P; const C c; assert(c.max_bucket_count() > 0); } #endif }
int main(int, char**) { { typedef std::unordered_multimap<int, std::string> C; const C c; assert(c.max_load_factor() == 1); } { typedef std::unordered_multimap<int, std::string> C; C c; assert(c.max_load_factor() == 1); c.max_load_factor(2.5); assert(c.max_load_factor() == 2.5); } #if TEST_STD_VER >= 11 { typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; const C c; assert(c.max_load_factor() == 1); } { typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; C c; assert(c.max_load_factor() == 1); c.max_load_factor(2.5); assert(c.max_load_factor() == 2.5); } #endif #if _LIBCPP_DEBUG_LEVEL >= 1 { typedef std::unordered_multimap<int, std::string> C; C c; c.max_load_factor(0); assert(false); } #endif return 0; }
int main() { { typedef std::unordered_multiset<int> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() == 7); assert(c.size() == 6); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); C::iterator i = c.begin(); assert(*i == 1); *i = 2; } { typedef std::unordered_multiset<int> C; typedef int P; P a[] = { P(1), P(2), P(3), P(4), P(1), P(2) }; const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.bucket_count() == 7); assert(c.size() == 6); assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size()); } }
void test_array_interface() { C c; c.replace( 0, new T ); c.replace( 1, new B ); c.replace( 9, new T ); c.replace( 0, std::auto_ptr<T>( new T ) ); const C c2( c.clone() ); BOOST_DEDUCED_TYPENAME C::iterator i = c.begin(); BOOST_DEDUCED_TYPENAME C::const_iterator ci = c2.begin(); BOOST_DEDUCED_TYPENAME C::iterator i2 = c.end(); BOOST_DEDUCED_TYPENAME C::const_iterator ci2 = c2.begin(); BOOST_DEDUCED_TYPENAME C::reverse_iterator ri = c.rbegin(); BOOST_DEDUCED_TYPENAME C::const_reverse_iterator cri = c2.rbegin(); BOOST_DEDUCED_TYPENAME C::reverse_iterator rv2 = c.rend(); BOOST_DEDUCED_TYPENAME C::const_reverse_iterator cvr2 = c2.rend(); BOOST_MESSAGE( "finished iterator test" ); BOOST_CHECK_EQUAL( c.empty(), false ); BOOST_CHECK_EQUAL( c.size(), c.max_size() ); BOOST_MESSAGE( "finished capacity test" ); BOOST_CHECK_EQUAL( c.is_null(0), false ); BOOST_CHECK_EQUAL( c.is_null(1), false ); BOOST_CHECK_EQUAL( c.is_null(2), true ); c.front(); c.back(); c2.front(); c2.back(); C c3; c.swap( c3 ); C c4; swap(c4,c3); c3.swap(c4); BOOST_CHECK_EQUAL( c.is_null(0), true ); BOOST_CHECK_EQUAL( c3.is_null(0), false ); c.replace( 5, new T ); BOOST_CHECK_EQUAL( c.is_null(5), false ); c = c3.release(); for( size_t i = 0; i < c3.size(); ++i ) BOOST_CHECK_EQUAL( c3.is_null(i), true ); BOOST_MESSAGE( "finished element access test" ); }
int main() { { typedef double T; typedef std::array<T, 3> C; C c = {1, 2, 3.5}; C::reference r1 = c.at(0); assert(r1 == 1); r1 = 5.5; assert(c.front() == 5.5); C::reference r2 = c.at(2); assert(r2 == 3.5); r2 = 7.5; assert(c.back() == 7.5); try { (void) c.at(3); } catch (const std::out_of_range &) {} } { typedef double T; typedef std::array<T, 3> C; const C c = {1, 2, 3.5}; C::const_reference r1 = c.at(0); assert(r1 == 1); C::const_reference r2 = c.at(2); assert(r2 == 3.5); try { (void) c.at(3); } catch (const std::out_of_range &) {} } #if TEST_STD_VER > 11 { typedef double T; typedef std::array<T, 3> C; constexpr C c = {1, 2, 3.5}; constexpr T t1 = c.at(0); static_assert (t1 == 1, ""); constexpr T t2 = c.at(2); static_assert (t2 == 3.5, ""); } #endif }
int main() { { typedef double T; typedef std::array<T, 3> C; C c = {1, 2, 3.5}; assert(c.size() == 3); assert(c.max_size() == 3); assert(!c.empty()); } { typedef double T; typedef std::array<T, 0> C; C c = {}; assert(c.size() == 0); assert(c.max_size() == 0); assert(c.empty()); } #ifndef _LIBCPP_HAS_NO_CONSTEXPR { typedef double T; typedef std::array<T, 3> C; constexpr C c = {1, 2, 3.5}; static_assert(c.size() == 3, ""); static_assert(c.max_size() == 3, ""); static_assert(!c.empty(), ""); } { typedef double T; typedef std::array<T, 0> C; constexpr C c = {}; static_assert(c.size() == 0, ""); static_assert(c.max_size() == 0, ""); static_assert(c.empty(), ""); } #endif }
int main() { { typedef double T; typedef std::array<T, 3> C; C c = {1, 2, 3.5}; C::reference r1 = c.front(); assert(r1 == 1); r1 = 5.5; assert(c[0] == 5.5); C::reference r2 = c.back(); assert(r2 == 3.5); r2 = 7.5; assert(c[2] == 7.5); } { typedef double T; typedef std::array<T, 3> C; const C c = {1, 2, 3.5}; C::const_reference r1 = c.front(); assert(r1 == 1); C::const_reference r2 = c.back(); assert(r2 == 3.5); } #if TEST_STD_VER > 11 { typedef double T; typedef std::array<T, 3> C; constexpr C c = {1, 2, 3.5}; constexpr T t1 = c.front(); static_assert (t1 == 1, ""); constexpr T t2 = c.back(); static_assert (t2 == 3.5, ""); } #endif }