/// 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
}
