This is an archive of the discontinued LLVM Phabricator instance.

Differential D20730

[libcxx] Prefer UNSUPPORTED over conditional compilation for tests
ClosedPublic

Authored by rmaprath on May 27 2016, 7:41 AM.

Details

Reviewers
mclow.lists
EricWF
Commits
rG6edc12c8867f: [libcxx] Improve tests to use the UNSUPPORTED lit directive
rCXX271108: [libcxx] Improve tests to use the UNSUPPORTED lit directive
rL271108: [libcxx] Improve tests to use the UNSUPPORTED lit directive
Summary

We seem to have quite a few tests where an entire test is conditionalized over some range of _LIBCPP_STD_VER. We should consider getting rid of these and using the UNSUPPORTED lit directive instead.

This is mostly cosmetic, but sometimes can create problems if there are also XFAIL conditions on the same test. The test will be reported as an unexpected-pass when run with a std= option not compatible with the _LIBCPP_STD_VER check (because the test is trivially empty, it will pass rather than XFAIL).

I've attached a sample patch for one of the cases. If this looks OK, I can commit the whole hog.

Diff Detail

Repository
rL LLVM

Event Timeline

rmaprath updated this revision to Diff 58781.May 27 2016, 7:41 AM
rmaprath retitled this revision from to [libcxx] Prefer UNSUPPORTED over conditional compilation for tests.
rmaprath updated this object.
rmaprath added a reviewer: EricWF.
rmaprath added a subscriber: cfe-commits.
bcraig added subscribers: mclow.lists, bcraig.May 27 2016, 10:20 AM

LGTM. Add @mclow.lists as a reviewer.

EricWF accepted this revision.May 27 2016, 10:21 AM
EricWF edited edge metadata.
This revision is now accepted and ready to land.May 27 2016, 10:21 AM
mclow.lists accepted this revision.May 27 2016, 9:51 PM
mclow.lists added a reviewer: mclow.lists.

LGTM.

Closed by commit rL271108: [libcxx] Improve tests to use the UNSUPPORTED lit directive (authored by asiri). · Explain WhyMay 28 2016, 2:04 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
libcxx/
trunk/
test/
libcxx/
experimental/
containers/
sequences/
dynarray/
dynarray.cons/
7 lines
dynarray.mutate/
7 lines
dynarray.overview/
7 lines
7 lines
7 lines
7 lines
dynarray.traits/
7 lines
dynarray.zero/
7 lines
utilities/
ratio/
header.ratio.synop/
7 lines
syserror/
header.system_error.synop/
7 lines
time/
header.chrono.synop/
7 lines
tuple/
header.tuple.synop/
9 lines
std/
containers/
sequences/
list/
3 lines
vector.bool/
3 lines
3 lines
diagnostics/
syserr/
syserr.errcat/
syserr.errcat.nonvirtuals/
7 lines
experimental/
optional/
optional.hash/
3 lines
optional.bad_optional_access/
4 lines
4 lines
optional.comp_with_t/
7 lines
8 lines
8 lines
8 lines
8 lines
7 lines
optional.inplace/
8 lines
optional.nullops/
4 lines
4 lines
4 lines
4 lines
4 lines
optional.nullopt/
7 lines
optional.object/
optional.object.assign/
7 lines
7 lines
7 lines
7 lines
7 lines
7 lines
optional.object.ctor/
7 lines
7 lines
8 lines
8 lines
7 lines
optional.object.dtor/
7 lines
optional.object.observe/
3 lines
7 lines
7 lines
7 lines
7 lines
7 lines
9 lines
7 lines
7 lines
7 lines
optional.object.swap/
8 lines
5 lines
9 lines
9 lines
5 lines
7 lines
optional.relops/
7 lines
7 lines
7 lines
7 lines
7 lines
7 lines
optional.specalg/
3 lines
8 lines
optional.syn/
5 lines
5 lines
5 lines
5 lines
3 lines
5 lines
5 lines
5 lines
string.view/
string.view.comparison/
7 lines
utilities/
meta/
meta.type.synop/
7 lines
7 lines
7 lines
7 lines
7 lines
6 lines
input.output/
file.streams/
c.files/
5 lines
iterators/
predef.iterators/
reverse.iterators/
reverse.iter.ops/
reverse.iter.make/
7 lines
language.support/
support.dynamic/
alloc.errors/
new.badlength/
3 lines
numerics/
complex.number/
complex.literals/
4 lines
6 lines
4 lines
4 lines
strings/
basic.string.literals/
5 lines
7 lines
5 lines
7 lines
5 lines
5 lines
basic.string/
string.iterators/
4 lines
thread/
futures/
futures.promise/
3 lines
thread.mutex/
thread.lock/
thread.lock.shared/
thread.lock.shared.cons/
9 lines
7 lines
thread.mutex.requirements/
thread.sharedtimedmutex.requirements/
thread.sharedtimedmutex.class/
5 lines
5 lines
utilities/
function.objects/
arithmetic.operations/
10 lines
bitwise.operations/
3 lines
7 lines
comparisons/
10 lines
logical.operations/
10 lines
intseq/
intseq.general/
8 lines
intseq.intseq/
5 lines
memory/
unique.ptr/
unique.ptr.create/
3 lines
3 lines
meta/
meta.trans/
meta.trans.other/
5 lines
meta.unary/
meta.unary.prop/
6 lines
time/
time.duration/
time.duration.literals/
3 lines
6 lines
4 lines
6 lines
3 lines
tuple/
tuple.tuple/
tuple.elem/
4 lines
4 lines
4 lines
4 lines
utility/
exchange/
4 lines
pairs/
pair.astuple/
5 lines
5 lines
5 lines

Diff 58886

libcxx/trunk/test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// dynarray.cons // dynarray.cons
// template <class Alloc> // template <class Alloc>
// dynarray(size_type c, const Alloc& alloc); // dynarray(size_type c, const Alloc& alloc);
// template <class Alloc> // template <class Alloc>
// dynarray(size_type c, const T& v, const Alloc& alloc); // dynarray(size_type c, const T& v, const Alloc& alloc);
// template <class Alloc> // template <class Alloc>
// dynarray(const dynarray& d, const Alloc& alloc); // dynarray(const dynarray& d, const Alloc& alloc);
// template <class Alloc> // template <class Alloc>
// dynarray(initializer_list<T>, const Alloc& alloc); // dynarray(initializer_list<T>, const Alloc& alloc);
// ~dynarray(); // ~dynarray();
#include <__config> #include <__config>
#if _LIBCPP_STD_VER > 11
#include <experimental/dynarray> #include <experimental/dynarray>
#include <cassert> #include <cassert>
#include <algorithm> #include <algorithm>
#include <complex> #include <complex>
#include <string> #include <string>
#include "test_allocator.h" #include "test_allocator.h"
Show All 40 Lines
{ {
// This test is waiting on the resolution of LWG issue #2235 // This test is waiting on the resolution of LWG issue #2235
// typedef test_allocator<char> Alloc; // typedef test_allocator<char> Alloc;
// typedef std::basic_string<char, std::char_traits<char>, Alloc> nstr; // typedef std::basic_string<char, std::char_traits<char>, Alloc> nstr;
// //
// test ( nstr("fourteen"), Alloc(3), Alloc(4) ); // test ( nstr("fourteen"), Alloc(3), Alloc(4) );
// test ( { nstr("1"), nstr("1"), nstr("2"), nstr("3"), nstr("5"), nstr("8")}, Alloc(6)); // test ( { nstr("1"), nstr("1"), nstr("2"), nstr("3"), nstr("5"), nstr("8")}, Alloc(6));
} }
#else
int main() {}
#endif

libcxx/trunk/test/libcxx/experimental/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// dynarray.data // dynarray.data
// void fill(const T& v); // void fill(const T& v);
// const T* data() const noexcept; // const T* data() const noexcept;
#include <__config> #include <__config>
#if _LIBCPP_STD_VER > 11
#include <experimental/dynarray> #include <experimental/dynarray>
#include <cassert> #include <cassert>
#include <algorithm> #include <algorithm>
#include <complex> #include <complex>
#include <string> #include <string>
using std::experimental::dynarray; using std::experimental::dynarray;
Show All 10 Lines
int main() int main()
{ {
test<int> ( 14 ); test<int> ( 14 );
test<double> ( 14.0 ); test<double> ( 14.0 );
test<std::complex<double>> ( std::complex<double> ( 14, 0 )); test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
test<std::string> ( "fourteen" ); test<std::string> ( "fourteen" );
} }
#else
int main() {}
#endif

libcxx/trunk/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/at.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// dynarray.overview // dynarray.overview
// const_reference at(size_type n) const; // const_reference at(size_type n) const;
// reference at(size_type n); // reference at(size_type n);
#include <__config> #include <__config>
#if _LIBCPP_STD_VER > 11
#include <experimental/dynarray> #include <experimental/dynarray>
#include <cassert> #include <cassert>
#include <algorithm> #include <algorithm>
#include <complex> #include <complex>
#include <string> #include <string>
using std::experimental::dynarray; using std::experimental::dynarray;
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesint main()
test ( { 1., 1., 2., 3., 5., 8. } ); test ( { 1., 1., 2., 3., 5., 8. } );
test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
std::string("5"), std::string("8")} ); std::string("5"), std::string("8")} );
test<int> ( {} ); test<int> ( {} );
test<std::complex<double>> ( {} ); test<std::complex<double>> ( {} );
test<std::string> ( {} ); test<std::string> ( {} );
} }
#else
int main() {}
#endif

libcxx/trunk/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// dynarray.overview // dynarray.overview
// iterator begin() noexcept; // iterator begin() noexcept;
// const_iterator begin() const noexcept; // const_iterator begin() const noexcept;
// const_iterator cbegin() const noexcept; // const_iterator cbegin() const noexcept;
// iterator end() noexcept; // iterator end() noexcept;
// const_iterator end() const noexcept; // const_iterator end() const noexcept;
// const_iterator cend() const noexcept; // const_iterator cend() const noexcept;
// //
// reverse_iterator rbegin() noexcept; // reverse_iterator rbegin() noexcept;
// const_reverse_iterator rbegin() const noexcept; // const_reverse_iterator rbegin() const noexcept;
// const_reverse_iterator crbegin() const noexcept; // const_reverse_iterator crbegin() const noexcept;
// reverse_iterator rend() noexcept; // reverse_iterator rend() noexcept;
// const_reverse_iterator rend() const noexcept; // const_reverse_iterator rend() const noexcept;
// const_reverse_iterator crend() const noexcept; // const_reverse_iterator crend() const noexcept;
#include <__config> #include <__config>
#if _LIBCPP_STD_VER > 11
#include <experimental/dynarray> #include <experimental/dynarray>
#include <cassert> #include <cassert>
#include <algorithm> #include <algorithm>
#include <complex> #include <complex>
#include <string> #include <string>
using std::experimental::dynarray; using std::experimental::dynarray;
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
int main() int main()
{ {
test<int> ( 14 ); test<int> ( 14 );
test<double> ( 14.0 ); test<double> ( 14.0 );
test<std::complex<double>> ( std::complex<double> ( 14, 0 )); test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
test<std::string> ( "fourteen" ); test<std::string> ( "fourteen" );
} }
#else
int main() {}
#endif

libcxx/trunk/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// dynarray.overview // dynarray.overview
// size_type size() const noexcept; // size_type size() const noexcept;
// size_type max_size() const noexcept; // size_type max_size() const noexcept;
// bool empty() const noexcept; // bool empty() const noexcept;
#include <__config> #include <__config>
#if _LIBCPP_STD_VER > 11
#include <experimental/dynarray> #include <experimental/dynarray>
#include <cassert> #include <cassert>
#include <algorithm> #include <algorithm>
#include <complex> #include <complex>
#include <string> #include <string>
using std::experimental::dynarray; using std::experimental::dynarray;
Show All 19 Linesint main()
test ( { 1., 1., 2., 3., 5., 8. } ); test ( { 1., 1., 2., 3., 5., 8. } );
test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
std::string("5"), std::string("8")} ); std::string("5"), std::string("8")} );
test<int> ( {} ); test<int> ( {} );
test<std::complex<double>> ( {} ); test<std::complex<double>> ( {} );
test<std::string> ( {} ); test<std::string> ( {} );
} }
#else
int main() {}
#endif

libcxx/trunk/test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// dynarray.overview // dynarray.overview
// const_reference at(size_type n) const; // const_reference at(size_type n) const;
// reference at(size_type n); // reference at(size_type n);
#include <__config> #include <__config>
#if _LIBCPP_STD_VER > 11
#include <experimental/dynarray> #include <experimental/dynarray>
#include <cassert> #include <cassert>
#include <algorithm> #include <algorithm>
#include <complex> #include <complex>
#include <string> #include <string>
using std::experimental::dynarray; using std::experimental::dynarray;
Show All 34 Linesint main()
test ( { 1., 1., 2., 3., 5., 8. } ); test ( { 1., 1., 2., 3., 5., 8. } );
test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"), test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
std::string("5"), std::string("8")} ); std::string("5"), std::string("8")} );
test<int> ( {} ); test<int> ( {} );
test<std::complex<double>> ( {} ); test<std::complex<double>> ( {} );
test<std::string> ( {} ); test<std::string> ( {} );
} }
#else
int main() {}
#endif

libcxx/trunk/test/libcxx/experimental/containers/sequences/dynarray/dynarray.traits/default.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// dynarray.data // dynarray.data
// template <class Type, class Alloc> // template <class Type, class Alloc>
// struct uses_allocator<dynarray<Type>, Alloc> : true_type { }; // struct uses_allocator<dynarray<Type>, Alloc> : true_type { };
#include <__config> #include <__config>
#if _LIBCPP_STD_VER > 11
#include <experimental/dynarray> #include <experimental/dynarray>
#include "test_allocator.h" #include "test_allocator.h"
using std::experimental::dynarray; using std::experimental::dynarray;
int main() int main()
{ {
static_assert ( std::uses_allocator<dynarray<int>, test_allocator<int>>::value, "" ); static_assert ( std::uses_allocator<dynarray<int>, test_allocator<int>>::value, "" );
} }
#else
int main() {}
#endif

libcxx/trunk/test/libcxx/experimental/containers/sequences/dynarray/dynarray.zero/default.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// dynarray.zero // dynarray.zero
// dynarray shall provide support for the special case of construction with a size of zero. // dynarray shall provide support for the special case of construction with a size of zero.
// In the case that the size is zero, begin() == end() == unique value. // In the case that the size is zero, begin() == end() == unique value.
// The return value of data() is unspecified. // The return value of data() is unspecified.
// The effect of calling front() or back() for a zero-sized dynarray is undefined. // The effect of calling front() or back() for a zero-sized dynarray is undefined.
#include <__config> #include <__config>
#if _LIBCPP_STD_VER > 11
#include <experimental/dynarray> #include <experimental/dynarray>
#include <cassert> #include <cassert>
#include <algorithm> #include <algorithm>
#include <complex> #include <complex>
#include <string> #include <string>
using std::experimental::dynarray; using std::experimental::dynarray;
Show All 9 Lines
int main() int main()
{ {
test<int> (); test<int> ();
test<double> (); test<double> ();
test<std::complex<double>> (); test<std::complex<double>> ();
test<std::string> (); test<std::string> ();
} }
#else
int main() {}
#endif

libcxx/trunk/test/libcxx/experimental/utilities/ratio/header.ratio.synop/includes.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/ratio> // <experimental/ratio>
// Test that <ratio> is included. // Test that <ratio> is included.
#include <experimental/ratio> #include <experimental/ratio>
#if _LIBCPP_STD_VER > 11
# ifndef _LIBCPP_RATIO #ifndef _LIBCPP_RATIO
# error " <experimental/ratio> must include <ratio>" # error " <experimental/ratio> must include <ratio>"
# endif #endif
#endif
int main() int main()
{ {
} }

libcxx/trunk/test/libcxx/experimental/utilities/syserror/header.system_error.synop/includes.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/system_error> // <experimental/system_error>
#include <experimental/system_error> #include <experimental/system_error>
#if _LIBCPP_STD_VER > 11
# ifndef _LIBCPP_SYSTEM_ERROR #ifndef _LIBCPP_SYSTEM_ERROR
# error "<experimental/system_error> must include <system_error>" # error "<experimental/system_error> must include <system_error>"
# endif #endif
#endif
int main() int main()
{ {
} }

libcxx/trunk/test/libcxx/experimental/utilities/time/header.chrono.synop/includes.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/chrono> // <experimental/chrono>
#include <experimental/chrono> #include <experimental/chrono>
#if _LIBCPP_STD_VER > 11
# ifndef _LIBCPP_CHRONO #ifndef _LIBCPP_CHRONO
# error "<experimental/chrono> must include <chrono>" # error "<experimental/chrono> must include <chrono>"
# endif #endif
#endif
int main() int main()
{ {
} }

libcxx/trunk/test/libcxx/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/tuple> // <experimental/tuple>
#include <experimental/tuple> #include <experimental/tuple>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
# ifndef _LIBCPP_TUPLE #ifndef _LIBCPP_TUPLE
# error "<experimental/tuple> must include <tuple>" # error "<experimental/tuple> must include <tuple>"
# endif #endif
#endif /* _LIBCPP_STD_VER > 11 */
} }

libcxx/trunk/test/std/containers/sequences/list/db_iterators_9.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <list> // <list>
// Operations on "NULL" iterators // Operations on "NULL" iterators
#if _LIBCPP_DEBUG >= 1 #if _LIBCPP_DEBUG >= 1
#define _LIBCPP_ASSERT(x, m) do { if (!x) throw 1; } while(0) #define _LIBCPP_ASSERT(x, m) do { if (!x) throw 1; } while(0)
#include <list> #include <list>
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <exception> #include <exception>
#include <cstdlib> #include <cstdlib>
struct S { int val; }; struct S { int val; };
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
unsigned lib_asserts; unsigned lib_asserts;
typedef S T; typedef S T;
typedef std::list<T> C; typedef std::list<T> C;
C::iterator i{}; C::iterator i{};
C::const_iterator ci{}; C::const_iterator ci{};
Show All 13 Linesint main()
lib_asserts = 0; lib_asserts = 0;
try { *i; } catch (int) { ++lib_asserts; } try { *i; } catch (int) { ++lib_asserts; }
try { *ci; } catch (int) { ++lib_asserts; } try { *ci; } catch (int) { ++lib_asserts; }
try { (void) i->val; } catch (int) { ++lib_asserts; } try { (void) i->val; } catch (int) { ++lib_asserts; }
try { (void) ci->val; } catch (int) { ++lib_asserts; } try { (void) ci->val; } catch (int) { ++lib_asserts; }
assert(lib_asserts == 4); assert(lib_asserts == 4);
} }
#endif
} }
#else #else
int main() int main()
{ {
} }
#endif #endif

libcxx/trunk/test/std/containers/sequences/vector.bool/emplace.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <vector> // <vector>
// vector<bool> // vector<bool>
// template <class... Args> iterator emplace(const_iterator pos, Args&&... args); // template <class... Args> iterator emplace(const_iterator pos, Args&&... args);
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef std::vector<bool> C; typedef std::vector<bool> C;
C c; C c;
C::iterator i = c.emplace(c.cbegin()); C::iterator i = c.emplace(c.cbegin());
assert(i == c.begin()); assert(i == c.begin());
assert(c.size() == 1); assert(c.size() == 1);
assert(c.front() == false); assert(c.front() == false);
Show All 29 Linesint main()
i = c.emplace(c.cbegin()+1, 1 == 1); i = c.emplace(c.cbegin()+1, 1 == 1);
assert(i == c.begin()+1); assert(i == c.begin()+1);
assert(c.size() == 3); assert(c.size() == 3);
assert(c.size() == 3); assert(c.size() == 3);
assert(c.front() == false); assert(c.front() == false);
assert(c[1] == true); assert(c[1] == true);
assert(c.back() == true); assert(c.back() == true);
} }
#endif
} }

libcxx/trunk/test/std/containers/sequences/vector.bool/emplace_back.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <vector> // <vector>
// vector.bool // vector.bool
// template <class... Args> void emplace_back(Args&&... args); // template <class... Args> void emplace_back(Args&&... args);
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef std::vector<bool> C; typedef std::vector<bool> C;
C c; C c;
c.emplace_back(); c.emplace_back();
assert(c.size() == 1); assert(c.size() == 1);
assert(c.front() == false); assert(c.front() == false);
c.emplace_back(true); c.emplace_back(true);
assert(c.size() == 2); assert(c.size() == 2);
Show All 17 Linesint main()
assert(c.front() == false); assert(c.front() == false);
assert(c.back() == true); assert(c.back() == true);
c.emplace_back(1 == 1); c.emplace_back(1 == 1);
assert(c.size() == 3); assert(c.size() == 3);
assert(c.front() == false); assert(c.front() == false);
assert(c[1] == true); assert(c[1] == true);
assert(c.back() == true); assert(c.back() == true);
} }
#endif
} }

libcxx/trunk/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.nonvirtuals/default_ctor.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <system_error> // <system_error>
// class error_category // class error_category
// constexpr error_category() noexcept; // constexpr error_category() noexcept;
#include <system_error> #include <system_error>
#include <type_traits> #include <type_traits>
#include <string> #include <string>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
class test1 class test1
: public std::error_category : public std::error_category
{ {
public: public:
constexpr test1() = default; // won't compile if error_category() is not constexpr constexpr test1() = default; // won't compile if error_category() is not constexpr
virtual const char* name() const noexcept {return nullptr;} virtual const char* name() const noexcept {return nullptr;}
virtual std::string message(int) const {return std::string();} virtual std::string message(int) const {return std::string();}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
static_assert(std::is_nothrow_default_constructible<test1>::value, static_assert(std::is_nothrow_default_constructible<test1>::value,
"error_category() must exist and be noexcept"); "error_category() must exist and be noexcept");
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.hash/hash.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> struct hash<optional<T>>; // template <class T> struct hash<optional<T>>;
#include <experimental/optional> #include <experimental/optional>
#include <string> #include <string>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
{ {
typedef int T; typedef int T;
optional<T> opt; optional<T> opt;
assert(std::hash<optional<T>>{}(opt) == 0); assert(std::hash<optional<T>>{}(opt) == 0);
opt = 2; opt = 2;
assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt)); assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt));
} }
{ {
typedef std::string T; typedef std::string T;
optional<T> opt; optional<T> opt;
assert(std::hash<optional<T>>{}(opt) == 0); assert(std::hash<optional<T>>{}(opt) == 0);
opt = std::string("123"); opt = std::string("123");
assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt)); assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt));
} }
{ {
typedef std::unique_ptr<int> T; typedef std::unique_ptr<int> T;
optional<T> opt; optional<T> opt;
assert(std::hash<optional<T>>{}(opt) == 0); assert(std::hash<optional<T>>{}(opt) == 0);
opt = std::unique_ptr<int>(new int(3)); opt = std::unique_ptr<int>(new int(3));
assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt)); assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt));
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.bad_optional_access/default.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// class bad_optional_access is default constructible // class bad_optional_access is default constructible
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::bad_optional_access; using std::experimental::bad_optional_access;
bad_optional_access ex; bad_optional_access ex;
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.bad_optional_access/derive.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// class bad_optional_access : public logic_error // class bad_optional_access : public logic_error
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::bad_optional_access; using std::experimental::bad_optional_access;
static_assert(std::is_base_of<std::logic_error, bad_optional_access>::value, ""); static_assert(std::is_base_of<std::logic_error, bad_optional_access>::value, "");
static_assert(std::is_convertible<bad_optional_access*, std::logic_error*>::value, ""); static_assert(std::is_convertible<bad_optional_access*, std::logic_error*>::value, "");
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.comp_with_t/equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator==(const optional<T>& x, const T& v); // template <class T> constexpr bool operator==(const optional<T>& x, const T& v);
// template <class T> constexpr bool operator==(const T& v, const optional<T>& x); // template <class T> constexpr bool operator==(const T& v, const optional<T>& x);
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator == ( const X &lhs, const X &rhs ) constexpr bool operator == ( const X &lhs, const X &rhs )
{ return lhs.i_ == rhs.i_ ; } { return lhs.i_ == rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef X T; typedef X T;
typedef optional<T> O; typedef optional<T> O;
constexpr T val(2); constexpr T val(2);
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged constexpr O o3{val}; // engaged
static_assert ( !(o1 == T(1)), "" ); static_assert ( !(o1 == T(1)), "" );
static_assert ( (o2 == T(1)), "" ); static_assert ( (o2 == T(1)), "" );
static_assert ( !(o3 == T(1)), "" ); static_assert ( !(o3 == T(1)), "" );
static_assert ( (o3 == T(2)), "" ); static_assert ( (o3 == T(2)), "" );
static_assert ( (o3 == val), "" ); static_assert ( (o3 == val), "" );
static_assert ( !(T(1) == o1), "" ); static_assert ( !(T(1) == o1), "" );
static_assert ( (T(1) == o2), "" ); static_assert ( (T(1) == o2), "" );
static_assert ( !(T(1) == o3), "" ); static_assert ( !(T(1) == o3), "" );
static_assert ( (T(2) == o3), "" ); static_assert ( (T(2) == o3), "" );
static_assert ( (val == o3), "" ); static_assert ( (val == o3), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.comp_with_t/greater.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator>(const optional<T>& x, const T& v); // template <class T> constexpr bool operator>(const optional<T>& x, const T& v);
// template <class T> constexpr bool operator>(const T& v, const optional<T>& x); // template <class T> constexpr bool operator>(const T& v, const optional<T>& x);
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator < ( const X &lhs, const X &rhs ) constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; } { return lhs.i_ < rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef X T; typedef X T;
typedef optional<T> O; typedef optional<T> O;
constexpr T val(2); constexpr T val(2);
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged constexpr O o3{val}; // engaged
static_assert ( !(o1 > T(1)), "" ); static_assert ( !(o1 > T(1)), "" );
static_assert ( !(o2 > T(1)), "" ); // equal static_assert ( !(o2 > T(1)), "" ); // equal
static_assert ( (o3 > T(1)), "" ); static_assert ( (o3 > T(1)), "" );
static_assert ( !(o2 > val), "" ); static_assert ( !(o2 > val), "" );
static_assert ( !(o3 > val), "" ); // equal static_assert ( !(o3 > val), "" ); // equal
static_assert ( !(o3 > T(3)), "" ); static_assert ( !(o3 > T(3)), "" );
static_assert ( (T(1) > o1), "" ); static_assert ( (T(1) > o1), "" );
static_assert ( !(T(1) > o2), "" ); // equal static_assert ( !(T(1) > o2), "" ); // equal
static_assert ( !(T(1) > o3), "" ); static_assert ( !(T(1) > o3), "" );
static_assert ( (val > o2), "" ); static_assert ( (val > o2), "" );
static_assert ( !(val > o3), "" ); // equal static_assert ( !(val > o3), "" ); // equal
static_assert ( (T(3) > o3), "" ); static_assert ( (T(3) > o3), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.comp_with_t/greater_equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator>=(const optional<T>& x, const T& v); // template <class T> constexpr bool operator>=(const optional<T>& x, const T& v);
// template <class T> constexpr bool operator>=(const T& v, const optional<T>& x); // template <class T> constexpr bool operator>=(const T& v, const optional<T>& x);
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator < ( const X &lhs, const X &rhs ) constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; } { return lhs.i_ < rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef X T; typedef X T;
typedef optional<T> O; typedef optional<T> O;
constexpr T val(2); constexpr T val(2);
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged constexpr O o3{val}; // engaged
static_assert ( !(o1 >= T(1)), "" ); static_assert ( !(o1 >= T(1)), "" );
static_assert ( (o2 >= T(1)), "" ); // equal static_assert ( (o2 >= T(1)), "" ); // equal
static_assert ( (o3 >= T(1)), "" ); static_assert ( (o3 >= T(1)), "" );
static_assert ( !(o2 >= val), "" ); static_assert ( !(o2 >= val), "" );
static_assert ( (o3 >= val), "" ); // equal static_assert ( (o3 >= val), "" ); // equal
static_assert ( !(o3 >= T(3)), "" ); static_assert ( !(o3 >= T(3)), "" );
static_assert ( (T(1) >= o1), "" ); static_assert ( (T(1) >= o1), "" );
static_assert ( (T(1) >= o2), "" ); // equal static_assert ( (T(1) >= o2), "" ); // equal
static_assert ( !(T(1) >= o3), "" ); static_assert ( !(T(1) >= o3), "" );
static_assert ( (val >= o2), "" ); static_assert ( (val >= o2), "" );
static_assert ( (val >= o3), "" ); // equal static_assert ( (val >= o3), "" ); // equal
static_assert ( (T(3) >= o3), "" ); static_assert ( (T(3) >= o3), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.comp_with_t/less_equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator<=(const optional<T>& x, const T& v); // template <class T> constexpr bool operator<=(const optional<T>& x, const T& v);
// template <class T> constexpr bool operator<=(const T& v, const optional<T>& x); // template <class T> constexpr bool operator<=(const T& v, const optional<T>& x);
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator < ( const X &lhs, const X &rhs ) constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; } { return lhs.i_ < rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef X T; typedef X T;
typedef optional<T> O; typedef optional<T> O;
constexpr T val(2); constexpr T val(2);
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged constexpr O o3{val}; // engaged
static_assert ( (o1 <= T(1)), "" ); static_assert ( (o1 <= T(1)), "" );
static_assert ( (o2 <= T(1)), "" ); // equal static_assert ( (o2 <= T(1)), "" ); // equal
static_assert ( !(o3 <= T(1)), "" ); static_assert ( !(o3 <= T(1)), "" );
static_assert ( (o2 <= val), "" ); static_assert ( (o2 <= val), "" );
static_assert ( (o3 <= val), "" ); // equal static_assert ( (o3 <= val), "" ); // equal
static_assert ( (o3 <= T(3)), "" ); static_assert ( (o3 <= T(3)), "" );
static_assert ( !(T(1) <= o1), "" ); static_assert ( !(T(1) <= o1), "" );
static_assert ( (T(1) <= o2), "" ); // equal static_assert ( (T(1) <= o2), "" ); // equal
static_assert ( (T(1) <= o3), "" ); static_assert ( (T(1) <= o3), "" );
static_assert ( !(val <= o2), "" ); static_assert ( !(val <= o2), "" );
static_assert ( (val <= o3), "" ); // equal static_assert ( (val <= o3), "" ); // equal
static_assert ( !(T(3) <= o3), "" ); static_assert ( !(T(3) <= o3), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.comp_with_t/less_than.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator<(const optional<T>& x, const T& v); // template <class T> constexpr bool operator<(const optional<T>& x, const T& v);
// template <class T> constexpr bool operator<(const T& v, const optional<T>& x); // template <class T> constexpr bool operator<(const T& v, const optional<T>& x);
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator < ( const X &lhs, const X &rhs ) constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; } { return lhs.i_ < rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef X T; typedef X T;
typedef optional<T> O; typedef optional<T> O;
constexpr T val(2); constexpr T val(2);
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged constexpr O o3{val}; // engaged
static_assert ( (o1 < T(1)), "" ); static_assert ( (o1 < T(1)), "" );
static_assert ( !(o2 < T(1)), "" ); // equal static_assert ( !(o2 < T(1)), "" ); // equal
static_assert ( !(o3 < T(1)), "" ); static_assert ( !(o3 < T(1)), "" );
static_assert ( (o2 < val), "" ); static_assert ( (o2 < val), "" );
static_assert ( !(o3 < val), "" ); // equal static_assert ( !(o3 < val), "" ); // equal
static_assert ( (o3 < T(3)), "" ); static_assert ( (o3 < T(3)), "" );
static_assert ( !(T(1) < o1), "" ); static_assert ( !(T(1) < o1), "" );
static_assert ( !(T(1) < o2), "" ); // equal static_assert ( !(T(1) < o2), "" ); // equal
static_assert ( (T(1) < o3), "" ); static_assert ( (T(1) < o3), "" );
static_assert ( !(val < o2), "" ); static_assert ( !(val < o2), "" );
static_assert ( !(val < o3), "" ); // equal static_assert ( !(val < o3), "" ); // equal
static_assert ( !(T(3) < o3), "" ); static_assert ( !(T(3) < o3), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.comp_with_t/not_equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator!=(const optional<T>& x, const T& v); // template <class T> constexpr bool operator!=(const optional<T>& x, const T& v);
// template <class T> constexpr bool operator!=(const T& v, const optional<T>& x); // template <class T> constexpr bool operator!=(const T& v, const optional<T>& x);
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator == ( const X &lhs, const X &rhs ) constexpr bool operator == ( const X &lhs, const X &rhs )
{ return lhs.i_ == rhs.i_ ; } { return lhs.i_ == rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef X T; typedef X T;
typedef optional<T> O; typedef optional<T> O;
constexpr T val(2); constexpr T val(2);
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
constexpr O o3{val}; // engaged constexpr O o3{val}; // engaged
static_assert ( (o1 != T(1)), "" ); static_assert ( (o1 != T(1)), "" );
static_assert ( !(o2 != T(1)), "" ); static_assert ( !(o2 != T(1)), "" );
static_assert ( (o3 != T(1)), "" ); static_assert ( (o3 != T(1)), "" );
static_assert ( !(o3 != T(2)), "" ); static_assert ( !(o3 != T(2)), "" );
static_assert ( !(o3 != val), "" ); static_assert ( !(o3 != val), "" );
static_assert ( (T(1) != o1), "" ); static_assert ( (T(1) != o1), "" );
static_assert ( !(T(1) != o2), "" ); static_assert ( !(T(1) != o2), "" );
static_assert ( (T(1) != o3), "" ); static_assert ( (T(1) != o3), "" );
static_assert ( !(T(2) != o3), "" ); static_assert ( !(T(2) != o3), "" );
static_assert ( !(val != o3), "" ); static_assert ( !(val != o3), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.inplace/in_place_t.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// struct in_place_t{}; // struct in_place_t{};
// constexpr in_place_t in_place{}; // constexpr in_place_t in_place{};
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::in_place_t; using std::experimental::in_place_t;
using std::experimental::in_place; using std::experimental::in_place;
constexpr constexpr
int int
test(const in_place_t&) test(const in_place_t&)
{ {
return 3; return 3;
} }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
static_assert((std::is_class<in_place_t>::value), ""); static_assert((std::is_class<in_place_t>::value), "");
static_assert((std::is_empty<in_place_t>::value), ""); static_assert((std::is_empty<in_place_t>::value), "");
static_assert(test(in_place) == 3, ""); static_assert(test(in_place) == 3, "");
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.nullops/equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept; // template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept;
// template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept; // template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept;
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
{ {
typedef int T; typedef int T;
typedef optional<T> O; typedef optional<T> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
static_assert ( (nullopt == o1), "" ); static_assert ( (nullopt == o1), "" );
static_assert ( !(nullopt == o2), "" ); static_assert ( !(nullopt == o2), "" );
static_assert ( (o1 == nullopt), "" ); static_assert ( (o1 == nullopt), "" );
static_assert ( !(o2 == nullopt), "" ); static_assert ( !(o2 == nullopt), "" );
static_assert (noexcept(nullopt == o1), ""); static_assert (noexcept(nullopt == o1), "");
static_assert (noexcept(o1 == nullopt), ""); static_assert (noexcept(o1 == nullopt), "");
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.nullops/greater.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept; // template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept;
// template <class T> constexpr bool operator>(nullopt_t, const optional<T>& x) noexcept; // template <class T> constexpr bool operator>(nullopt_t, const optional<T>& x) noexcept;
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
{ {
typedef int T; typedef int T;
typedef optional<T> O; typedef optional<T> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
static_assert ( !(nullopt > o1), "" ); static_assert ( !(nullopt > o1), "" );
static_assert ( !(nullopt > o2), "" ); static_assert ( !(nullopt > o2), "" );
static_assert ( !(o1 > nullopt), "" ); static_assert ( !(o1 > nullopt), "" );
static_assert ( (o2 > nullopt), "" ); static_assert ( (o2 > nullopt), "" );
static_assert (noexcept(nullopt > o1), ""); static_assert (noexcept(nullopt > o1), "");
static_assert (noexcept(o1 > nullopt), ""); static_assert (noexcept(o1 > nullopt), "");
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.nullops/greater_equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator>=(const optional<T>& x, nullopt_t) noexcept; // template <class T> constexpr bool operator>=(const optional<T>& x, nullopt_t) noexcept;
// template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept; // template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept;
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
{ {
typedef int T; typedef int T;
typedef optional<T> O; typedef optional<T> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
static_assert ( (nullopt >= o1), "" ); static_assert ( (nullopt >= o1), "" );
static_assert ( !(nullopt >= o2), "" ); static_assert ( !(nullopt >= o2), "" );
static_assert ( (o1 >= nullopt), "" ); static_assert ( (o1 >= nullopt), "" );
static_assert ( (o2 >= nullopt), "" ); static_assert ( (o2 >= nullopt), "" );
static_assert (noexcept(nullopt >= o1), ""); static_assert (noexcept(nullopt >= o1), "");
static_assert (noexcept(o1 >= nullopt), ""); static_assert (noexcept(o1 >= nullopt), "");
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.nullops/less_than.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator<(const optional<T>& x, nullopt_t) noexcept; // template <class T> constexpr bool operator<(const optional<T>& x, nullopt_t) noexcept;
// template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept; // template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept;
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
{ {
typedef int T; typedef int T;
typedef optional<T> O; typedef optional<T> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
static_assert ( !(nullopt < o1), "" ); static_assert ( !(nullopt < o1), "" );
static_assert ( (nullopt < o2), "" ); static_assert ( (nullopt < o2), "" );
static_assert ( !(o1 < nullopt), "" ); static_assert ( !(o1 < nullopt), "" );
static_assert ( !(o2 < nullopt), "" ); static_assert ( !(o2 < nullopt), "" );
static_assert (noexcept(nullopt < o1), ""); static_assert (noexcept(nullopt < o1), "");
static_assert (noexcept(o1 < nullopt), ""); static_assert (noexcept(o1 < nullopt), "");
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.nullops/not_equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept; // template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept;
// template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept; // template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept;
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
{ {
typedef int T; typedef int T;
typedef optional<T> O; typedef optional<T> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2{1}; // engaged constexpr O o2{1}; // engaged
static_assert ( !(nullopt != o1), "" ); static_assert ( !(nullopt != o1), "" );
static_assert ( (nullopt != o2), "" ); static_assert ( (nullopt != o2), "" );
static_assert ( !(o1 != nullopt), "" ); static_assert ( !(o1 != nullopt), "" );
static_assert ( (o2 != nullopt), "" ); static_assert ( (o2 != nullopt), "" );
static_assert (noexcept(nullopt != o1), ""); static_assert (noexcept(nullopt != o1), "");
static_assert (noexcept(o1 != nullopt), ""); static_assert (noexcept(o1 != nullopt), "");
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.nullopt/nullopt_t.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// struct nullopt_t{see below}; // struct nullopt_t{see below};
// constexpr nullopt_t nullopt(unspecified); // constexpr nullopt_t nullopt(unspecified);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
constexpr constexpr
int int
test(const nullopt_t&) test(const nullopt_t&)
{ {
return 3; return 3;
} }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
static_assert((std::is_class<nullopt_t>::value), ""); static_assert((std::is_class<nullopt_t>::value), "");
static_assert((std::is_empty<nullopt_t>::value), ""); static_assert((std::is_empty<nullopt_t>::value), "");
static_assert((std::is_literal_type<nullopt_t>::value), ""); static_assert((std::is_literal_type<nullopt_t>::value), "");
static_assert((!std::is_default_constructible<nullopt_t>::value), ""); static_assert((!std::is_default_constructible<nullopt_t>::value), "");
static_assert(test(nullopt) == 3, ""); static_assert(test(nullopt) == 3, "");
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.assign/assign_value.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class U> optional<T>& operator=(U&& v); // template <class U> optional<T>& operator=(U&& v);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <memory> #include <memory>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
static_assert(std::is_assignable<optional<int>, int>::value, ""); static_assert(std::is_assignable<optional<int>, int>::value, "");
static_assert(std::is_assignable<optional<int>, int&>::value, ""); static_assert(std::is_assignable<optional<int>, int&>::value, "");
static_assert(std::is_assignable<optional<int>&, int>::value, ""); static_assert(std::is_assignable<optional<int>&, int>::value, "");
static_assert(std::is_assignable<optional<int>&, int&>::value, ""); static_assert(std::is_assignable<optional<int>&, int&>::value, "");
static_assert(std::is_assignable<optional<int>&, const int&>::value, ""); static_assert(std::is_assignable<optional<int>&, const int&>::value, "");
static_assert(!std::is_assignable<const optional<int>&, const int&>::value, ""); static_assert(!std::is_assignable<const optional<int>&, const int&>::value, "");
static_assert(!std::is_assignable<optional<int>, X>::value, ""); static_assert(!std::is_assignable<optional<int>, X>::value, "");
{ {
Show All 23 Lines static_assert(!std::is_assignable<optional<int>, X>::value, "");
assert(**opt == 3); assert(**opt == 3);
} }
{ {
optional<std::unique_ptr<int>> opt(std::unique_ptr<int>(new int(2))); optional<std::unique_ptr<int>> opt(std::unique_ptr<int>(new int(2)));
opt = std::unique_ptr<int>(new int(3)); opt = std::unique_ptr<int>(new int(3));
assert(static_cast<bool>(opt) == true); assert(static_cast<bool>(opt) == true);
assert(**opt == 3); assert(**opt == 3);
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.assign/copy.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// optional<T>& operator=(const optional<T>& rhs); // optional<T>& operator=(const optional<T>& rhs);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
static bool throw_now; static bool throw_now;
X() = default; X() = default;
X(const X&) X(const X&)
{ {
if (throw_now) if (throw_now)
throw 6; throw 6;
} }
}; };
bool X::throw_now = false; bool X::throw_now = false;
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
optional<int> opt; optional<int> opt;
constexpr optional<int> opt2; constexpr optional<int> opt2;
opt = opt2; opt = opt2;
static_assert(static_cast<bool>(opt2) == false, ""); static_assert(static_cast<bool>(opt2) == false, "");
assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); assert(static_cast<bool>(opt) == static_cast<bool>(opt2));
} }
{ {
Show All 32 Linesint main()
assert(false); assert(false);
} }
catch (int i) catch (int i)
{ {
assert(i == 6); assert(i == 6);
assert(static_cast<bool>(opt) == false); assert(static_cast<bool>(opt) == false);
} }
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.assign/emplace.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// template <class... Args> void optional<T>::emplace(Args&&... args); // template <class... Args> void optional<T>::emplace(Args&&... args);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <memory> #include <memory>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
class X class X
{ {
int i_; int i_;
int j_ = 0; int j_ = 0;
public: public:
X() : i_(0) {} X() : i_(0) {}
Show All 20 Linespublic:
static bool dtor_called; static bool dtor_called;
Z() = default; Z() = default;
Z(int) {throw 6;} Z(int) {throw 6;}
~Z() {dtor_called = true;} ~Z() {dtor_called = true;}
}; };
bool Z::dtor_called = false; bool Z::dtor_called = false;
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
optional<int> opt; optional<int> opt;
opt.emplace(); opt.emplace();
assert(static_cast<bool>(opt) == true); assert(static_cast<bool>(opt) == true);
assert(*opt == 0); assert(*opt == 0);
} }
{ {
optional<int> opt; optional<int> opt;
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Linesint main()
} }
catch (int i) catch (int i)
{ {
assert(i == 6); assert(i == 6);
assert(static_cast<bool>(opt) == false); assert(static_cast<bool>(opt) == false);
assert(Z::dtor_called == true); assert(Z::dtor_called == true);
} }
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// template <class U, class... Args> // template <class U, class... Args>
// void optional<T>::emplace(initializer_list<U> il, Args&&... args); // void optional<T>::emplace(initializer_list<U> il, Args&&... args);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#include <vector> #include <vector>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
class X class X
{ {
int i_; int i_;
int j_ = 0; int j_ = 0;
public: public:
static bool dtor_called; static bool dtor_called;
Show All 34 Linespublic:
~Z() {dtor_called = true;} ~Z() {dtor_called = true;}
friend constexpr bool operator==(const Z& x, const Z& y) friend constexpr bool operator==(const Z& x, const Z& y)
{return x.i_ == y.i_ && x.j_ == y.j_;} {return x.i_ == y.i_ && x.j_ == y.j_;}
}; };
bool Z::dtor_called = false; bool Z::dtor_called = false;
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
X x; X x;
{ {
optional<X> opt(x); optional<X> opt(x);
assert(X::dtor_called == false); assert(X::dtor_called == false);
opt.emplace({1, 2}); opt.emplace({1, 2});
assert(X::dtor_called == true); assert(X::dtor_called == true);
assert(*opt == X({1, 2})); assert(*opt == X({1, 2}));
Show All 22 Linesint main()
} }
catch (int i) catch (int i)
{ {
assert(i == 6); assert(i == 6);
assert(static_cast<bool>(opt) == false); assert(static_cast<bool>(opt) == false);
assert(Z::dtor_called == true); assert(Z::dtor_called == true);
} }
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.assign/move.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// optional<T>& operator=(optional<T>&& rhs) // optional<T>& operator=(optional<T>&& rhs)
// noexcept(is_nothrow_move_assignable<T>::value && // noexcept(is_nothrow_move_assignable<T>::value &&
// is_nothrow_move_constructible<T>::value); // is_nothrow_move_constructible<T>::value);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
static bool throw_now; static bool throw_now;
X() = default; X() = default;
X(X&&) X(X&&)
{ {
if (throw_now) if (throw_now)
throw 6; throw 6;
} }
X& operator=(X&&) noexcept X& operator=(X&&) noexcept
{ {
return *this; return *this;
} }
}; };
struct Y {}; struct Y {};
bool X::throw_now = false; bool X::throw_now = false;
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
static_assert(std::is_nothrow_move_assignable<optional<int>>::value, ""); static_assert(std::is_nothrow_move_assignable<optional<int>>::value, "");
optional<int> opt; optional<int> opt;
constexpr optional<int> opt2; constexpr optional<int> opt2;
opt = std::move(opt2); opt = std::move(opt2);
static_assert(static_cast<bool>(opt2) == false, ""); static_assert(static_cast<bool>(opt2) == false, "");
assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); assert(static_cast<bool>(opt) == static_cast<bool>(opt2));
} }
Show All 37 Linesint main()
{ {
assert(i == 6); assert(i == 6);
assert(static_cast<bool>(opt) == false); assert(static_cast<bool>(opt) == false);
} }
} }
{ {
static_assert(std::is_nothrow_move_assignable<optional<Y>>::value, ""); static_assert(std::is_nothrow_move_assignable<optional<Y>>::value, "");
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// optional<T>& operator=(nullopt_t) noexcept; // optional<T>& operator=(nullopt_t) noexcept;
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
struct X struct X
{ {
static bool dtor_called; static bool dtor_called;
~X() {dtor_called = true;} ~X() {dtor_called = true;}
}; };
bool X::dtor_called = false; bool X::dtor_called = false;
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
optional<int> opt; optional<int> opt;
static_assert(noexcept(opt = nullopt) == true, ""); static_assert(noexcept(opt = nullopt) == true, "");
opt = nullopt; opt = nullopt;
assert(static_cast<bool>(opt) == false); assert(static_cast<bool>(opt) == false);
} }
{ {
optional<int> opt(3); optional<int> opt(3);
Show All 13 Linesint main()
{ {
optional<X> opt(x); optional<X> opt(x);
assert(X::dtor_called == false); assert(X::dtor_called == false);
opt = nullopt; opt = nullopt;
assert(X::dtor_called == true); assert(X::dtor_called == true);
assert(static_cast<bool>(opt) == false); assert(static_cast<bool>(opt) == false);
} }
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.ctor/copy.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// optional(const optional<T>& rhs); // optional(const optional<T>& rhs);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
template <class T> template <class T>
void void
test(const optional<T>& rhs, bool is_going_to_throw = false) test(const optional<T>& rhs, bool is_going_to_throw = false)
{ {
bool rhs_engaged = static_cast<bool>(rhs); bool rhs_engaged = static_cast<bool>(rhs);
try try
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines Z(const Z&)
if (++count == 2) if (++count == 2)
throw 6; throw 6;
} }
friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;} friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef int T; typedef int T;
optional<T> rhs; optional<T> rhs;
test(rhs); test(rhs);
} }
{ {
typedef int T; typedef int T;
optional<T> rhs(3); optional<T> rhs(3);
Show All 24 Linesint main()
optional<T> rhs; optional<T> rhs;
test(rhs); test(rhs);
} }
{ {
typedef Z T; typedef Z T;
optional<T> rhs(Z(3)); optional<T> rhs(Z(3));
test(rhs, true); test(rhs, true);
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.ctor/default.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// constexpr optional() noexcept; // constexpr optional() noexcept;
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
template <class Opt> template <class Opt>
void void
test_constexpr() test_constexpr()
{ {
static_assert(std::is_nothrow_default_constructible<Opt>::value, ""); static_assert(std::is_nothrow_default_constructible<Opt>::value, "");
constexpr Opt opt; constexpr Opt opt;
Show All 22 Linestest()
}; };
} }
struct X struct X
{ {
X(); X();
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
test_constexpr<optional<int>>(); test_constexpr<optional<int>>();
test_constexpr<optional<int*>>(); test_constexpr<optional<int*>>();
test<optional<X>>(); test<optional<X>>();
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// template <class U, class... Args> // template <class U, class... Args>
// constexpr // constexpr
// explicit optional(in_place_t, initializer_list<U> il, Args&&... args); // explicit optional(in_place_t, initializer_list<U> il, Args&&... args);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::in_place_t; using std::experimental::in_place_t;
using std::experimental::in_place; using std::experimental::in_place;
class X class X
{ {
int i_; int i_;
int j_ = 0; int j_ = 0;
Show All 30 Linespublic:
constexpr Z(int i) : i_(i) {} constexpr Z(int i) : i_(i) {}
constexpr Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) constexpr Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
{throw 6;} {throw 6;}
friend constexpr bool operator==(const Z& x, const Z& y) friend constexpr bool operator==(const Z& x, const Z& y)
{return x.i_ == y.i_ && x.j_ == y.j_;} {return x.i_ == y.i_ && x.j_ == y.j_;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
static_assert(!std::is_constructible<X, std::initializer_list<int>&>::value, ""); static_assert(!std::is_constructible<X, std::initializer_list<int>&>::value, "");
static_assert(!std::is_constructible<optional<X>, std::initializer_list<int>&>::value, ""); static_assert(!std::is_constructible<optional<X>, std::initializer_list<int>&>::value, "");
} }
{ {
optional<std::vector<int>> opt(in_place, {3, 1}); optional<std::vector<int>> opt(in_place, {3, 1});
assert(static_cast<bool>(opt) == true); assert(static_cast<bool>(opt) == true);
assert((*opt == std::vector<int>{3, 1})); assert((*opt == std::vector<int>{3, 1}));
Show All 34 Linesint main()
struct test_constexpr_ctor struct test_constexpr_ctor
: public optional<Z> : public optional<Z>
{ {
constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i) constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i)
: optional<Z>(in_place, i) {} : optional<Z>(in_place, i) {}
}; };
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.ctor/move.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// optional(optional<T>&& rhs) noexcept(is_nothrow_move_constructible<T>::value); // optional(optional<T>&& rhs) noexcept(is_nothrow_move_constructible<T>::value);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
template <class T> template <class T>
void void
test(optional<T>& rhs, bool is_going_to_throw = false) test(optional<T>& rhs, bool is_going_to_throw = false)
{ {
static_assert(std::is_nothrow_move_constructible<optional<T>>::value == static_assert(std::is_nothrow_move_constructible<optional<T>>::value ==
std::is_nothrow_move_constructible<T>::value, ""); std::is_nothrow_move_constructible<T>::value, "");
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linespublic:
{ {
if (++count == 2) if (++count == 2)
throw 6; throw 6;
} }
friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;} friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef int T; typedef int T;
optional<T> rhs; optional<T> rhs;
test(rhs); test(rhs);
} }
{ {
typedef int T; typedef int T;
optional<T> rhs(3); optional<T> rhs(3);
Show All 24 Linesint main()
optional<T> rhs; optional<T> rhs;
test(rhs); test(rhs);
} }
{ {
typedef Z T; typedef Z T;
optional<T> rhs(Z(3)); optional<T> rhs(Z(3));
test(rhs, true); test(rhs, true);
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// constexpr optional(nullopt_t) noexcept; // constexpr optional(nullopt_t) noexcept;
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
template <class Opt> template <class Opt>
void void
test_constexpr() test_constexpr()
{ {
Show All 23 Linestest()
}; };
} }
struct X struct X
{ {
X(); X();
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
test_constexpr<optional<int>>(); test_constexpr<optional<int>>();
test_constexpr<optional<int*>>(); test_constexpr<optional<int*>>();
test<optional<X>>(); test<optional<X>>();
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.dtor/dtor.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// ~optional(); // ~optional();
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
class X class X
{ {
public: public:
static bool dtor_called; static bool dtor_called;
X() = default; X() = default;
~X() {dtor_called = true;} ~X() {dtor_called = true;}
}; };
bool X::dtor_called = false; bool X::dtor_called = false;
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef int T; typedef int T;
static_assert(std::is_trivially_destructible<T>::value, ""); static_assert(std::is_trivially_destructible<T>::value, "");
static_assert(std::is_trivially_destructible<optional<T>>::value, ""); static_assert(std::is_trivially_destructible<optional<T>>::value, "");
} }
{ {
typedef double T; typedef double T;
static_assert(std::is_trivially_destructible<T>::value, ""); static_assert(std::is_trivially_destructible<T>::value, "");
static_assert(std::is_trivially_destructible<optional<T>>::value, ""); static_assert(std::is_trivially_destructible<optional<T>>::value, "");
} }
{ {
typedef X T; typedef X T;
static_assert(!std::is_trivially_destructible<T>::value, ""); static_assert(!std::is_trivially_destructible<T>::value, "");
static_assert(!std::is_trivially_destructible<optional<T>>::value, ""); static_assert(!std::is_trivially_destructible<optional<T>>::value, "");
{ {
X x; X x;
optional<X> opt{x}; optional<X> opt{x};
assert(X::dtor_called == false); assert(X::dtor_called == false);
} }
assert(X::dtor_called == true); assert(X::dtor_called == true);
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.observe/bool.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// constexpr explicit optional<T>::operator bool() const noexcept; // constexpr explicit optional<T>::operator bool() const noexcept;
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
{ {
constexpr optional<int> opt; constexpr optional<int> opt;
static_assert(!opt, ""); static_assert(!opt, "");
} }
{ {
constexpr optional<int> opt(0); constexpr optional<int> opt(0);
static_assert(opt, ""); static_assert(opt, "");
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.observe/dereference.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// T& optional<T>::operator*(); // T& optional<T>::operator*();
#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 <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
constexpr int test() const {return 3;} constexpr int test() const {return 3;}
int test() {return 4;} int test() {return 4;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
optional<X> opt(X{}); optional<X> opt(X{});
assert((*opt).test() == 4); assert((*opt).test() == 4);
} }
#ifdef _LIBCPP_DEBUG #ifdef _LIBCPP_DEBUG
{ {
optional<X> opt; optional<X> opt;
assert((*opt).test() == 3); assert((*opt).test() == 3);
assert(false); assert(false);
} }
#endif // _LIBCPP_DEBUG #endif // _LIBCPP_DEBUG
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.observe/dereference_const.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// constexpr const T& optional<T>::operator*() const; // constexpr const T& optional<T>::operator*() const;
#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 <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
constexpr int test() const {return 3;} constexpr int test() const {return 3;}
}; };
struct Y struct Y
{ {
int test() const {return 2;} int test() const {return 2;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
constexpr optional<X> opt(X{}); constexpr optional<X> opt(X{});
static_assert((*opt).test() == 3, ""); static_assert((*opt).test() == 3, "");
} }
{ {
constexpr optional<Y> opt(Y{}); constexpr optional<Y> opt(Y{});
assert((*opt).test() == 2); assert((*opt).test() == 2);
} }
#ifdef _LIBCPP_DEBUG #ifdef _LIBCPP_DEBUG
{ {
const optional<X> opt; const optional<X> opt;
assert((*opt).test() == 3); assert((*opt).test() == 3);
assert(false); assert(false);
} }
#endif // _LIBCPP_DEBUG #endif // _LIBCPP_DEBUG
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.observe/op_arrow.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// constexpr T* optional<T>::operator->(); // constexpr T* optional<T>::operator->();
#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 <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
constexpr int test() const {return 3;} constexpr int test() const {return 3;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
constexpr optional<X> opt(X{}); constexpr optional<X> opt(X{});
static_assert(opt->test() == 3, ""); static_assert(opt->test() == 3, "");
} }
#ifdef _LIBCPP_DEBUG #ifdef _LIBCPP_DEBUG
{ {
optional<X> opt; optional<X> opt;
assert(opt->test() == 3); assert(opt->test() == 3);
assert(false); assert(false);
} }
#endif // _LIBCPP_DEBUG #endif // _LIBCPP_DEBUG
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// constexpr const T* optional<T>::operator->() const; // constexpr const T* optional<T>::operator->() const;
#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 <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
constexpr int test() const {return 3;} constexpr int test() const {return 3;}
}; };
struct Y struct Y
{ {
int test() const {return 2;} int test() const {return 2;}
}; };
struct Z struct Z
{ {
const Z* operator&() const {return this;} const Z* operator&() const {return this;}
constexpr int test() const {return 1;} constexpr int test() const {return 1;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
constexpr optional<X> opt(X{}); constexpr optional<X> opt(X{});
static_assert(opt->test() == 3, ""); static_assert(opt->test() == 3, "");
} }
{ {
constexpr optional<Y> opt(Y{}); constexpr optional<Y> opt(Y{});
assert(opt->test() == 2); assert(opt->test() == 2);
} }
{ {
constexpr optional<Z> opt(Z{}); constexpr optional<Z> opt(Z{});
assert(opt->test() == 1); assert(opt->test() == 1);
} }
#ifdef _LIBCPP_DEBUG #ifdef _LIBCPP_DEBUG
{ {
const optional<X> opt; const optional<X> opt;
assert(opt->test() == 3); assert(opt->test() == 3);
assert(false); assert(false);
} }
#endif // _LIBCPP_DEBUG #endif // _LIBCPP_DEBUG
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.observe/value.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// T& optional<T>::value(); // T& optional<T>::value();
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::bad_optional_access; using std::experimental::bad_optional_access;
struct X struct X
{ {
X() = default; X() = default;
X(const X&) = delete; X(const X&) = delete;
constexpr int test() const {return 3;} constexpr int test() const {return 3;}
int test() {return 4;} int test() {return 4;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
optional<X> opt; optional<X> opt;
opt.emplace(); opt.emplace();
assert(opt.value().test() == 4); assert(opt.value().test() == 4);
} }
{ {
optional<X> opt; optional<X> opt;
try try
{ {
opt.value(); opt.value();
assert(false); assert(false);
} }
catch (const bad_optional_access&) catch (const bad_optional_access&)
{ {
} }
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.observe/value_const.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// constexpr const T& optional<T>::value() const; // constexpr const T& optional<T>::value() const;
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
constexpr int test() const {return 3;} constexpr int test() const {return 3;}
int test() {return 4;} int test() {return 4;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
constexpr optional<X> opt; constexpr optional<X> opt;
static_assert(opt.value().test() == 3, ""); static_assert(opt.value().test() == 3, "");
} }
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.observe/value_const.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// constexpr const T& optional<T>::value() const; // constexpr const T& optional<T>::value() const;
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::in_place_t; using std::experimental::in_place_t;
using std::experimental::in_place; using std::experimental::in_place;
using std::experimental::bad_optional_access; using std::experimental::bad_optional_access;
struct X struct X
{ {
X() = default; X() = default;
X(const X&) = delete; X(const X&) = delete;
constexpr int test() const {return 3;} constexpr int test() const {return 3;}
int test() {return 4;} int test() {return 4;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
constexpr optional<X> opt(in_place); constexpr optional<X> opt(in_place);
static_assert(opt.value().test() == 3, ""); static_assert(opt.value().test() == 3, "");
} }
{ {
const optional<X> opt(in_place); const optional<X> opt(in_place);
assert(opt.value().test() == 3); assert(opt.value().test() == 3);
} }
{ {
const optional<X> opt; const optional<X> opt;
try try
{ {
opt.value(); opt.value();
assert(false); assert(false);
} }
catch (const bad_optional_access&) catch (const bad_optional_access&)
{ {
} }
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.observe/value_or.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class U> T optional<T>::value_or(U&& v) &&; // template <class U> T optional<T>::value_or(U&& v) &&;
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::in_place_t; using std::experimental::in_place_t;
using std::experimental::in_place; using std::experimental::in_place;
struct Y struct Y
{ {
int i_; int i_;
Y(int i) : i_(i) {} Y(int i) : i_(i) {}
}; };
struct X struct X
{ {
int i_; int i_;
X(int i) : i_(i) {} X(int i) : i_(i) {}
X(X&& x) : i_(x.i_) {x.i_ = 0;} X(X&& x) : i_(x.i_) {x.i_ = 0;}
X(const Y& y) : i_(y.i_) {} X(const Y& y) : i_(y.i_) {}
X(Y&& y) : i_(y.i_+1) {} X(Y&& y) : i_(y.i_+1) {}
friend constexpr bool operator==(const X& x, const X& y) friend constexpr bool operator==(const X& x, const X& y)
{return x.i_ == y.i_;} {return x.i_ == y.i_;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
optional<X> opt(in_place, 2); optional<X> opt(in_place, 2);
Y y(3); Y y(3);
assert(std::move(opt).value_or(y) == 2); assert(std::move(opt).value_or(y) == 2);
assert(*opt == 0); assert(*opt == 0);
} }
{ {
optional<X> opt(in_place, 2); optional<X> opt(in_place, 2);
assert(std::move(opt).value_or(Y(3)) == 2); assert(std::move(opt).value_or(Y(3)) == 2);
assert(*opt == 0); assert(*opt == 0);
} }
{ {
optional<X> opt; optional<X> opt;
Y y(3); Y y(3);
assert(std::move(opt).value_or(y) == 3); assert(std::move(opt).value_or(y) == 3);
assert(!opt); assert(!opt);
} }
{ {
optional<X> opt; optional<X> opt;
assert(std::move(opt).value_or(Y(3)) == 4); assert(std::move(opt).value_or(Y(3)) == 4);
assert(!opt); assert(!opt);
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.observe/value_or_const.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class U> constexpr T optional<T>::value_or(U&& v) const&; // template <class U> constexpr T optional<T>::value_or(U&& v) const&;
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct Y struct Y
{ {
int i_; int i_;
constexpr Y(int i) : i_(i) {} constexpr Y(int i) : i_(i) {}
}; };
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
constexpr X(const Y& y) : i_(y.i_) {} constexpr X(const Y& y) : i_(y.i_) {}
constexpr X(Y&& y) : i_(y.i_+1) {} constexpr X(Y&& y) : i_(y.i_+1) {}
friend constexpr bool operator==(const X& x, const X& y) friend constexpr bool operator==(const X& x, const X& y)
{return x.i_ == y.i_;} {return x.i_ == y.i_;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
constexpr optional<X> opt(2); constexpr optional<X> opt(2);
constexpr Y y(3); constexpr Y y(3);
static_assert(opt.value_or(y) == 2, ""); static_assert(opt.value_or(y) == 2, "");
} }
{ {
constexpr optional<X> opt(2); constexpr optional<X> opt(2);
static_assert(opt.value_or(Y(3)) == 2, ""); static_assert(opt.value_or(Y(3)) == 2, "");
Show All 20 Linesint main()
const optional<X> opt; const optional<X> opt;
const Y y(3); const Y y(3);
assert(opt.value_or(y) == 3); assert(opt.value_or(y) == 3);
} }
{ {
const optional<X> opt; const optional<X> opt;
assert(opt.value_or(Y(3)) == 4); assert(opt.value_or(Y(3)) == 4);
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional.object.swap/swap.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// void swap(optional&) // void swap(optional&)
// noexcept(is_nothrow_move_constructible<T>::value && // noexcept(is_nothrow_move_constructible<T>::value &&
// noexcept(swap(declval<T&>(), declval<T&>()))); // noexcept(swap(declval<T&>(), declval<T&>())));
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
class X class X
{ {
int i_; int i_;
public: public:
static unsigned dtor_called; static unsigned dtor_called;
X(int i) : i_(i) {} X(int i) : i_(i) {}
Show All 27 Lines
public: public:
Z(int i) : i_(i) {} Z(int i) : i_(i) {}
Z(Z&&) {throw 7;} Z(Z&&) {throw 7;}
friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;} friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
friend void swap(Z& x, Z& y) {throw 6;} friend void swap(Z& x, Z& y) {throw 6;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
optional<int> opt1; optional<int> opt1;
optional<int> opt2; optional<int> opt2;
static_assert(noexcept(opt1.swap(opt2)) == true, ""); static_assert(noexcept(opt1.swap(opt2)) == true, "");
assert(static_cast<bool>(opt1) == false); assert(static_cast<bool>(opt1) == false);
assert(static_cast<bool>(opt2) == false); assert(static_cast<bool>(opt2) == false);
opt1.swap(opt2); opt1.swap(opt2);
assert(static_cast<bool>(opt1) == false); assert(static_cast<bool>(opt1) == false);
▲ Show 20 Lines • Show All 218 Lines • ▼ Show 20 Linesint main()
{ {
assert(i == 6); assert(i == 6);
} }
assert(static_cast<bool>(opt1) == true); assert(static_cast<bool>(opt1) == true);
assert(*opt1 == 1); assert(*opt1 == 1);
assert(static_cast<bool>(opt2) == true); assert(static_cast<bool>(opt2) == true);
assert(*opt2 == 2); assert(*opt2 == 2);
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional_const_void.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// T shall be an object type and shall satisfy the requirements of Destructible // T shall be an object type and shall satisfy the requirements of Destructible
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
optional<const void> opt; optional<const void> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional_not_destructible.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// T shall be an object type and shall satisfy the requirements of Destructible // T shall be an object type and shall satisfy the requirements of Destructible
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
private: private:
~X() {} ~X() {}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
optional<X> opt; optional<X> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional_not_noexcept_destructible.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// T shall be an object type and shall satisfy the requirements of Destructible // T shall be an object type and shall satisfy the requirements of Destructible
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
~X() noexcept(false) {} ~X() noexcept(false) {}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
optional<X> opt; optional<X> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/optional_void.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// T shall be an object type and shall satisfy the requirements of Destructible // T shall be an object type and shall satisfy the requirements of Destructible
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
optional<void> opt; optional<void> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.object/types.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> // template <class T>
// class optional // class optional
// { // {
// public: // public:
// typedef T value_type; // typedef T value_type;
// ... // ...
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
template <class Opt, class T> template <class Opt, class T>
void void
test() test()
{ {
static_assert(std::is_same<typename Opt::value_type, T>::value, ""); static_assert(std::is_same<typename Opt::value_type, T>::value, "");
} }
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
test<optional<int>, int>(); test<optional<int>, int>();
test<optional<const int>, const int>(); test<optional<const int>, const int>();
test<optional<double>, double>(); test<optional<double>, double>();
test<optional<const double>, const double>(); test<optional<const double>, const double>();
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.relops/equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y); // template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator == ( const X &lhs, const X &rhs ) constexpr bool operator == ( const X &lhs, const X &rhs )
{ return lhs.i_ == rhs.i_ ; } { return lhs.i_ == rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef X T; typedef X T;
typedef optional<T> O; typedef optional<T> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2; // disengaged constexpr O o2; // disengaged
constexpr O o3{1}; // engaged constexpr O o3{1}; // engaged
constexpr O o4{2}; // engaged constexpr O o4{2}; // engaged
Show All 25 Linesint main()
static_assert ( !(o5 == o1), "" ); static_assert ( !(o5 == o1), "" );
static_assert ( !(o5 == o2), "" ); static_assert ( !(o5 == o2), "" );
static_assert ( o5 == o3 , "" ); static_assert ( o5 == o3 , "" );
static_assert ( !(o5 == o4), "" ); static_assert ( !(o5 == o4), "" );
static_assert ( o5 == o5 , "" ); static_assert ( o5 == o5 , "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.relops/greater_equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator>= (const optional<T>& x, const optional<T>& y); // template <class T> constexpr bool operator>= (const optional<T>& x, const optional<T>& y);
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator < ( const X &lhs, const X &rhs ) constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; } { return lhs.i_ < rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef optional<X> O; typedef optional<X> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2; // disengaged constexpr O o2; // disengaged
constexpr O o3{1}; // engaged constexpr O o3{1}; // engaged
constexpr O o4{2}; // engaged constexpr O o4{2}; // engaged
constexpr O o5{1}; // engaged constexpr O o5{1}; // engaged
Show All 23 Linesint main()
static_assert ( (o4 >= o5), "" ); static_assert ( (o4 >= o5), "" );
static_assert ( (o5 >= o1), "" ); static_assert ( (o5 >= o1), "" );
static_assert ( (o5 >= o2), "" ); static_assert ( (o5 >= o2), "" );
static_assert ( (o5 >= o3), "" ); static_assert ( (o5 >= o3), "" );
static_assert ( !(o5 >= o4), "" ); static_assert ( !(o5 >= o4), "" );
static_assert ( (o5 >= o5), "" ); static_assert ( (o5 >= o5), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.relops/greater_than.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator> (const optional<T>& x, const optional<T>& y); // template <class T> constexpr bool operator> (const optional<T>& x, const optional<T>& y);
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator < ( const X &lhs, const X &rhs ) constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; } { return lhs.i_ < rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef optional<X> O; typedef optional<X> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2; // disengaged constexpr O o2; // disengaged
constexpr O o3{1}; // engaged constexpr O o3{1}; // engaged
constexpr O o4{2}; // engaged constexpr O o4{2}; // engaged
constexpr O o5{1}; // engaged constexpr O o5{1}; // engaged
Show All 23 Linesint main()
static_assert ( (o4 > o5), "" ); static_assert ( (o4 > o5), "" );
static_assert ( (o5 > o1), "" ); static_assert ( (o5 > o1), "" );
static_assert ( (o5 > o2), "" ); static_assert ( (o5 > o2), "" );
static_assert ( !(o5 > o3), "" ); static_assert ( !(o5 > o3), "" );
static_assert ( !(o5 > o4), "" ); static_assert ( !(o5 > o4), "" );
static_assert ( !(o5 > o5), "" ); static_assert ( !(o5 > o5), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.relops/less_equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator<= (const optional<T>& x, const optional<T>& y); // template <class T> constexpr bool operator<= (const optional<T>& x, const optional<T>& y);
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator < ( const X &lhs, const X &rhs ) constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; } { return lhs.i_ < rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef optional<X> O; typedef optional<X> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2; // disengaged constexpr O o2; // disengaged
constexpr O o3{1}; // engaged constexpr O o3{1}; // engaged
constexpr O o4{2}; // engaged constexpr O o4{2}; // engaged
constexpr O o5{1}; // engaged constexpr O o5{1}; // engaged
Show All 23 Linesint main()
static_assert ( !(o4 <= o5), "" ); static_assert ( !(o4 <= o5), "" );
static_assert ( !(o5 <= o1), "" ); static_assert ( !(o5 <= o1), "" );
static_assert ( !(o5 <= o2), "" ); static_assert ( !(o5 <= o2), "" );
static_assert ( (o5 <= o3), "" ); static_assert ( (o5 <= o3), "" );
static_assert ( (o5 <= o4), "" ); static_assert ( (o5 <= o4), "" );
static_assert ( (o5 <= o5), "" ); static_assert ( (o5 <= o5), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.relops/less_than.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator< (const optional<T>& x, const optional<T>& y); // template <class T> constexpr bool operator< (const optional<T>& x, const optional<T>& y);
#include <experimental/optional> #include <experimental/optional>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator < ( const X &lhs, const X &rhs ) constexpr bool operator < ( const X &lhs, const X &rhs )
{ return lhs.i_ < rhs.i_ ; } { return lhs.i_ < rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef optional<X> O; typedef optional<X> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2; // disengaged constexpr O o2; // disengaged
constexpr O o3{1}; // engaged constexpr O o3{1}; // engaged
constexpr O o4{2}; // engaged constexpr O o4{2}; // engaged
constexpr O o5{1}; // engaged constexpr O o5{1}; // engaged
Show All 23 Linesint main()
static_assert ( !(o4 < o5), "" ); static_assert ( !(o4 < o5), "" );
static_assert ( !(o5 < o1), "" ); static_assert ( !(o5 < o1), "" );
static_assert ( !(o5 < o2), "" ); static_assert ( !(o5 < o2), "" );
static_assert ( !(o5 < o3), "" ); static_assert ( !(o5 < o3), "" );
static_assert ( (o5 < o4), "" ); static_assert ( (o5 < o4), "" );
static_assert ( !(o5 < o5), "" ); static_assert ( !(o5 < o5), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.relops/not_equal.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y); // template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y);
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
struct X struct X
{ {
int i_; int i_;
constexpr X(int i) : i_(i) {} constexpr X(int i) : i_(i) {}
}; };
constexpr bool operator == ( const X &lhs, const X &rhs ) constexpr bool operator == ( const X &lhs, const X &rhs )
{ return lhs.i_ == rhs.i_ ; } { return lhs.i_ == rhs.i_ ; }
#endif
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
typedef X T; typedef X T;
typedef optional<T> O; typedef optional<T> O;
constexpr O o1; // disengaged constexpr O o1; // disengaged
constexpr O o2; // disengaged constexpr O o2; // disengaged
constexpr O o3{1}; // engaged constexpr O o3{1}; // engaged
constexpr O o4{2}; // engaged constexpr O o4{2}; // engaged
Show All 25 Linesint main()
static_assert ( (o5 != o1), "" ); static_assert ( (o5 != o1), "" );
static_assert ( (o5 != o2), "" ); static_assert ( (o5 != o2), "" );
static_assert ( !(o5 != o3), "" ); static_assert ( !(o5 != o3), "" );
static_assert ( (o5 != o4), "" ); static_assert ( (o5 != o4), "" );
static_assert ( !(o5 != o5), "" ); static_assert ( !(o5 != o5), "" );
} }
#endif
} }

libcxx/trunk/test/std/experimental/optional/optional.specalg/make_optional.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// template <class T> // template <class T>
// constexpr // constexpr
// optional<typename decay<T>::type> // optional<typename decay<T>::type>
// make_optional(T&& v); // make_optional(T&& v);
#include <experimental/optional> #include <experimental/optional>
#include <string> #include <string>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::make_optional; using std::experimental::make_optional;
{ {
optional<int> opt = make_optional(2); optional<int> opt = make_optional(2);
assert(*opt == 2); assert(*opt == 2);
} }
{ {
std::string s("123"); std::string s("123");
optional<std::string> opt = make_optional(s); optional<std::string> opt = make_optional(s);
assert(*opt == s); assert(*opt == s);
} }
{ {
std::string s("123"); std::string s("123");
optional<std::string> opt = make_optional(std::move(s)); optional<std::string> opt = make_optional(std::move(s));
assert(*opt == "123"); assert(*opt == "123");
assert(s.empty()); assert(s.empty());
} }
{ {
std::unique_ptr<int> s(new int(3)); std::unique_ptr<int> s(new int(3));
optional<std::unique_ptr<int>> opt = make_optional(std::move(s)); optional<std::unique_ptr<int>> opt = make_optional(std::move(s));
assert(**opt == 3); assert(**opt == 3);
assert(s == nullptr); assert(s == nullptr);
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.specalg/swap.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: libcpp-no-exceptions // XFAIL: libcpp-no-exceptions
// <optional> // <optional>
// template <class T> void swap(optional<T>& x, optional<T>& y) // template <class T> void swap(optional<T>& x, optional<T>& y)
// noexcept(noexcept(x.swap(y))); // noexcept(noexcept(x.swap(y)));
#include <experimental/optional> #include <experimental/optional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
class X class X
{ {
int i_; int i_;
public: public:
static unsigned dtor_called; static unsigned dtor_called;
X(int i) : i_(i) {} X(int i) : i_(i) {}
Show All 27 Lines
public: public:
Z(int i) : i_(i) {} Z(int i) : i_(i) {}
Z(Z&&) {throw 7;} Z(Z&&) {throw 7;}
friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;} friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
friend void swap(Z& x, Z& y) {throw 6;} friend void swap(Z& x, Z& y) {throw 6;}
}; };
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
optional<int> opt1; optional<int> opt1;
optional<int> opt2; optional<int> opt2;
static_assert(noexcept(swap(opt1, opt2)) == true, ""); static_assert(noexcept(swap(opt1, opt2)) == true, "");
assert(static_cast<bool>(opt1) == false); assert(static_cast<bool>(opt1) == false);
assert(static_cast<bool>(opt2) == false); assert(static_cast<bool>(opt2) == false);
swap(opt1, opt2); swap(opt1, opt2);
assert(static_cast<bool>(opt1) == false); assert(static_cast<bool>(opt1) == false);
▲ Show 20 Lines • Show All 218 Lines • ▼ Show 20 Linesint main()
{ {
assert(i == 6); assert(i == 6);
} }
assert(static_cast<bool>(opt1) == true); assert(static_cast<bool>(opt1) == true);
assert(*opt1 == 1); assert(*opt1 == 1);
assert(static_cast<bool>(opt2) == true); assert(static_cast<bool>(opt2) == true);
assert(*opt2 == 2); assert(*opt2 == 2);
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.syn/optional_const_in_place_t.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// A program that necessitates the instantiation of template optional for // A program that necessitates the instantiation of template optional for
// (possibly cv-qualified) in_place_t is ill-formed. // (possibly cv-qualified) in_place_t is ill-formed.
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::in_place_t; using std::experimental::in_place_t;
using std::experimental::in_place; using std::experimental::in_place;
optional<const in_place_t> opt; optional<const in_place_t> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.syn/optional_const_lvalue_ref.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// A program that necessitates the instantiation of template optional for a // A program that necessitates the instantiation of template optional for a
// reference type is ill-formed. // reference type is ill-formed.
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
optional<const int&> opt; optional<const int&> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.syn/optional_const_nullopt_t.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// A program that necessitates the instantiation of template optional for // A program that necessitates the instantiation of template optional for
// (possibly cv-qualified) null_opt_t is ill-formed. // (possibly cv-qualified) null_opt_t is ill-formed.
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
optional<const nullopt_t> opt; optional<const nullopt_t> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.syn/optional_in_place_t.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// A program that necessitates the instantiation of template optional for // A program that necessitates the instantiation of template optional for
// (possibly cv-qualified) in_place_t is ill-formed. // (possibly cv-qualified) in_place_t is ill-formed.
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::in_place_t; using std::experimental::in_place_t;
using std::experimental::in_place; using std::experimental::in_place;
optional<in_place_t> opt; optional<in_place_t> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.syn/optional_includes_initializer_list.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// #include <initializer_list> // #include <initializer_list>
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
std::initializer_list<int> list; std::initializer_list<int> list;
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.syn/optional_lvalue_ref.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// A program that necessitates the instantiation of template optional for a // A program that necessitates the instantiation of template optional for a
// reference type is ill-formed. // reference type is ill-formed.
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
optional<int&> opt; optional<int&> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.syn/optional_nullopt_t.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// A program that necessitates the instantiation of template optional for // A program that necessitates the instantiation of template optional for
// (possibly cv-qualified) null_opt_t is ill-formed. // (possibly cv-qualified) null_opt_t is ill-formed.
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
using std::experimental::nullopt_t; using std::experimental::nullopt_t;
using std::experimental::nullopt; using std::experimental::nullopt;
optional<nullopt_t> opt; optional<nullopt_t> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/optional/optional.syn/optional_rvalue_ref.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <optional> // <optional>
// A program that necessitates the instantiation of template optional for a // A program that necessitates the instantiation of template optional for a
// reference type is ill-formed. // reference type is ill-formed.
#include <experimental/optional> #include <experimental/optional>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::experimental::optional; using std::experimental::optional;
optional<int&&> opt; optional<int&&> opt;
#else
#error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/experimental/string.view/string.view.comparison/opeq.string_view.string.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <string> // <string>
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator==(const charT* lhs, const basic_string<charT,traits> rhs); // bool operator==(const charT* lhs, const basic_string<charT,traits> rhs);
// template<class charT, class traits, class Allocator> // template<class charT, class traits, class Allocator>
// bool operator==(const basic_string_view<charT,traits> lhs, const CharT* rhs); // bool operator==(const basic_string_view<charT,traits> lhs, const CharT* rhs);
#include <experimental/string_view> #include <experimental/string_view>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
template <class S> template <class S>
void void
test(const std::string &lhs, S rhs, bool x) test(const std::string &lhs, S rhs, bool x)
{ {
assert((lhs == rhs) == x); assert((lhs == rhs) == x);
assert((rhs == lhs) == x); assert((rhs == lhs) == x);
} }
Show All 14 Linesint main()
test("abcdefghij", S("abcdefghij"), true); test("abcdefghij", S("abcdefghij"), true);
test("abcdefghij", S("abcdefghijklmnopqrst"), false); test("abcdefghij", S("abcdefghijklmnopqrst"), false);
test("abcdefghijklmnopqrst", S(""), false); test("abcdefghijklmnopqrst", S(""), false);
test("abcdefghijklmnopqrst", S("abcde"), false); test("abcdefghijklmnopqrst", S("abcde"), false);
test("abcdefghijklmnopqrst", S("abcdefghij"), false); test("abcdefghijklmnopqrst", S("abcdefghij"), false);
test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true); test("abcdefghijklmnopqrst", S("abcdefghijklmnopqrst"), true);
} }
} }
#else
int main () {}
#endif

libcxx/trunk/test/std/experimental/utilities/meta/meta.type.synop/includes.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits> // <experimental/type_traits>
#include <experimental/type_traits> #include <experimental/type_traits>
#if _LIBCPP_STD_VER > 11
# ifndef _LIBCPP_TYPE_TRAITS #ifndef _LIBCPP_TYPE_TRAITS
# error "<experimental/type_traits> must include <type_traits>" # error "<experimental/type_traits> must include <type_traits>"
# endif #endif
#endif
int main() int main()
{ {
} }

libcxx/trunk/test/std/experimental/utilities/meta/meta.type.synop/meta.rel.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits> // <experimental/type_traits>
#include <experimental/type_traits> #include <experimental/type_traits>
#if _LIBCPP_STD_VER > 11
namespace ex = std::experimental; namespace ex = std::experimental;
struct base_type {}; struct base_type {};
struct derived_type : base_type {}; struct derived_type : base_type {};
int main() int main()
{ {
{ {
Show All 31 Linesint main()
} }
{ {
typedef void T; typedef void T;
typedef int U; typedef int U;
static_assert(!ex::is_convertible_v<T, U>, ""); static_assert(!ex::is_convertible_v<T, U>, "");
static_assert(ex::is_convertible_v<T, U> == std::is_convertible<T, U>::value, ""); static_assert(ex::is_convertible_v<T, U> == std::is_convertible<T, U>::value, "");
} }
} }
#else /* _LIBCPP_STD_VER <= 11 */
int main() {}
#endif /* _LIBCPP_STD_VER > 11 */

libcxx/trunk/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.cat.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits> // <experimental/type_traits>
#include <experimental/type_traits> #include <experimental/type_traits>
#if _LIBCPP_STD_VER > 11
namespace ex = std::experimental; namespace ex = std::experimental;
struct class_type {}; struct class_type {};
enum enum_type {}; enum enum_type {};
union union_type {}; union union_type {};
int main() int main()
{ {
▲ Show 20 Lines • Show All 147 Lines • ▼ Show 20 Linesint main()
static_assert(ex::is_function_v<T> == std::is_function<T>::value, ""); static_assert(ex::is_function_v<T> == std::is_function<T>::value, "");
} }
{ {
typedef int T; typedef int T;
static_assert(!ex::is_function_v<T>, ""); static_assert(!ex::is_function_v<T>, "");
static_assert(ex::is_function_v<T> == std::is_function<T>::value, ""); static_assert(ex::is_function_v<T> == std::is_function<T>::value, "");
} }
} }
#else /* _LIBCPP_STD_VER <= 11 */
int main() {}
#endif /* _LIBCPP_STD_VER > 11 */

libcxx/trunk/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.comp.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits> // <experimental/type_traits>
#include <experimental/type_traits> #include <experimental/type_traits>
#if _LIBCPP_STD_VER > 11
namespace ex = std::experimental; namespace ex = std::experimental;
struct class_type {}; struct class_type {};
int main() int main()
{ {
{ {
typedef int & T; typedef int & T;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesint main()
static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, ""); static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, "");
} }
{ {
typedef int T; typedef int T;
static_assert(!ex::is_member_pointer_v<T>, ""); static_assert(!ex::is_member_pointer_v<T>, "");
static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, ""); static_assert(ex::is_member_pointer_v<T> == std::is_member_pointer<T>::value, "");
} }
} }
#else /* _LIBCPP_STD_VER <= 11 */
int main() {}
#endif /* _LIBCPP_STD_VER > 11 */

libcxx/trunk/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits> // <experimental/type_traits>
#include <experimental/type_traits> #include <experimental/type_traits>
#if _LIBCPP_STD_VER > 11
namespace ex = std::experimental; namespace ex = std::experimental;
struct non_literal_type { non_literal_type() {} }; struct non_literal_type { non_literal_type() {} };
struct empty_type {}; struct empty_type {};
struct polymorphic_type struct polymorphic_type
{ {
virtual void foo() {} virtual void foo() {}
▲ Show 20 Lines • Show All 455 Lines • ▼ Show 20 Lines is_nothrow_constructible_and_assignable_test();
static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, ""); static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, "");
} }
{ {
typedef int T; typedef int T;
static_assert(!ex::has_virtual_destructor_v<T>, ""); static_assert(!ex::has_virtual_destructor_v<T>, "");
static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, ""); static_assert(ex::has_virtual_destructor_v<T> == std::has_virtual_destructor<T>::value, "");
} }
} }
#else /* _LIBCPP_STD_VER <= 11 */
int main() {}
#endif /* _LIBCPP_STD_VER > 11 */

libcxx/trunk/test/std/experimental/utilities/meta/meta.type.synop/meta.unary.prop.query.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <experimental/type_traits> // <experimental/type_traits>
#include <experimental/type_traits> #include <experimental/type_traits>
#if _LIBCPP_STD_VER > 11
namespace ex = std::experimental; namespace ex = std::experimental;
int main() int main()
{ {
{ {
typedef char T; typedef char T;
static_assert(ex::alignment_of_v<T> == 1, ""); static_assert(ex::alignment_of_v<T> == 1, "");
static_assert(std::is_same<decltype(ex::alignment_of_v<T>), const std::size_t>::value, ""); static_assert(std::is_same<decltype(ex::alignment_of_v<T>), const std::size_t>::value, "");
Show All 32 Linesint main()
static_assert(ex::extent_v<T, 5> == std::extent<T, 5>::value, ""); static_assert(ex::extent_v<T, 5> == std::extent<T, 5>::value, "");
} }
{ {
typedef void T; typedef void T;
static_assert(ex::extent_v<T, 0> == 0, ""); static_assert(ex::extent_v<T, 0> == 0, "");
static_assert(ex::extent_v<T, 0> == std::extent<T, 0>::value, ""); static_assert(ex::extent_v<T, 0> == std::extent<T, 0>::value, "");
} }
} }
#else /* _LIBCPP_STD_VER <= 11 */
int main() {}
#endif /* _LIBCPP_STD_VER > 11 */

libcxx/trunk/test/std/input.output/file.streams/c.files/gets.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// test <cstdio> // test <cstdio>
// gets // gets
#include <cstdio> #include <cstdio>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
(void) std::gets((char *) NULL); (void) std::gets((char *) NULL);
#else
#error
#endif
} }

libcxx/trunk/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <iterator> // <iterator>
// reverse_iterator // reverse_iterator
// template <class Iterator> reverse_iterator<Iterator> // template <class Iterator> reverse_iterator<Iterator>
// make_reverse_iterator(Iterator i); // make_reverse_iterator(Iterator i);
#include <iterator> #include <iterator>
#include <cassert> #include <cassert>
#include "test_iterators.h" #include "test_iterators.h"
#if _LIBCPP_STD_VER > 11
template <class It> template <class It>
void void
test(It i) test(It i)
{ {
const std::reverse_iterator<It> r = std::make_reverse_iterator(i); const std::reverse_iterator<It> r = std::make_reverse_iterator(i);
assert(r.base() == i); assert(r.base() == i);
} }
int main() int main()
{ {
const char* s = "1234567890"; const char* s = "1234567890";
random_access_iterator<const char*>b(s); random_access_iterator<const char*>b(s);
random_access_iterator<const char*>e(s+10); random_access_iterator<const char*>e(s+10);
while ( b != e ) while ( b != e )
test ( b++ ); test ( b++ );
} }
#else
int main () {}
#endif

libcxx/trunk/test/std/language.support/support.dynamic/alloc.errors/new.badlength/bad_array_length.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// test bad_array_length // test bad_array_length
#include <new> #include <new>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if __LIBCPP_STD_VER > 11
static_assert((std::is_base_of<std::bad_alloc, std::bad_array_length>::value), static_assert((std::is_base_of<std::bad_alloc, std::bad_array_length>::value),
"std::is_base_of<std::bad_alloc, std::bad_array_length>::value"); "std::is_base_of<std::bad_alloc, std::bad_array_length>::value");
static_assert(std::is_polymorphic<std::bad_array_length>::value, static_assert(std::is_polymorphic<std::bad_array_length>::value,
"std::is_polymorphic<std::bad_array_length>::value"); "std::is_polymorphic<std::bad_array_length>::value");
std::bad_array_length b; std::bad_array_length b;
std::bad_array_length b2 = b; std::bad_array_length b2 = b;
b2 = b; b2 = b;
const char* w = b2.what(); const char* w = b2.what();
assert(w); assert(w);
#endif
} }

libcxx/trunk/test/std/numerics/complex.number/complex.literals/literals.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <chrono> // <chrono>
#include <complex> #include <complex>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using namespace std::literals::complex_literals; using namespace std::literals::complex_literals;
// Make sure the types are right // Make sure the types are right
static_assert ( std::is_same<decltype( 3.0il ), std::complex<long double>>::value, "" ); static_assert ( std::is_same<decltype( 3.0il ), std::complex<long double>>::value, "" );
static_assert ( std::is_same<decltype( 3il ), std::complex<long double>>::value, "" ); static_assert ( std::is_same<decltype( 3il ), std::complex<long double>>::value, "" );
static_assert ( std::is_same<decltype( 3.0i ), std::complex<double>>::value, "" ); static_assert ( std::is_same<decltype( 3.0i ), std::complex<double>>::value, "" );
static_assert ( std::is_same<decltype( 3i ), std::complex<double>>::value, "" ); static_assert ( std::is_same<decltype( 3i ), std::complex<double>>::value, "" );
static_assert ( std::is_same<decltype( 3.0if ), std::complex<float>>::value, "" ); static_assert ( std::is_same<decltype( 3.0if ), std::complex<float>>::value, "" );
Show All 14 Lines// Make sure the types are right
} }
{ {
std::complex<float> c1 = 3.0if; std::complex<float> c1 = 3.0if;
assert ( c1 == std::complex<float>(0, 3.0)); assert ( c1 == std::complex<float>(0, 3.0));
auto c2 = 3if; auto c2 = 3if;
assert ( c1 == c2 ); assert ( c1 == c2 );
} }
#endif
} }

libcxx/trunk/test/std/numerics/complex.number/complex.literals/literals1.fail.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <complex> #include <complex>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
std::complex<float> foo = 1.0if; // should fail w/conversion operator not found std::complex<float> foo = 1.0if; // should fail w/conversion operator not found
#else
#error
#endif
} }

libcxx/trunk/test/std/numerics/complex.number/complex.literals/literals1.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <chrono> // <chrono>
#include <complex> #include <complex>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using namespace std::literals; using namespace std::literals;
{ {
std::complex<long double> c1 = 3.0il; std::complex<long double> c1 = 3.0il;
assert ( c1 == std::complex<long double>(0, 3.0)); assert ( c1 == std::complex<long double>(0, 3.0));
auto c2 = 3il; auto c2 = 3il;
assert ( c1 == c2 ); assert ( c1 == c2 );
} }
{ {
std::complex<double> c1 = 3.0i; std::complex<double> c1 = 3.0i;
assert ( c1 == std::complex<double>(0, 3.0)); assert ( c1 == std::complex<double>(0, 3.0));
auto c2 = 3i; auto c2 = 3i;
assert ( c1 == c2 ); assert ( c1 == c2 );
} }
{ {
std::complex<float> c1 = 3.0if; std::complex<float> c1 = 3.0if;
assert ( c1 == std::complex<float>(0, 3.0)); assert ( c1 == std::complex<float>(0, 3.0));
auto c2 = 3if; auto c2 = 3if;
assert ( c1 == c2 ); assert ( c1 == c2 );
} }
#endif
} }

libcxx/trunk/test/std/numerics/complex.number/complex.literals/literals2.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <chrono> // <chrono>
#include <complex> #include <complex>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using namespace std; using namespace std;
{ {
std::complex<long double> c1 = 3.0il; std::complex<long double> c1 = 3.0il;
assert ( c1 == std::complex<long double>(0, 3.0)); assert ( c1 == std::complex<long double>(0, 3.0));
auto c2 = 3il; auto c2 = 3il;
assert ( c1 == c2 ); assert ( c1 == c2 );
} }
{ {
std::complex<double> c1 = 3.0i; std::complex<double> c1 = 3.0i;
assert ( c1 == std::complex<double>(0, 3.0)); assert ( c1 == std::complex<double>(0, 3.0));
auto c2 = 3i; auto c2 = 3i;
assert ( c1 == c2 ); assert ( c1 == c2 );
} }
{ {
std::complex<float> c1 = 3.0if; std::complex<float> c1 = 3.0if;
assert ( c1 == std::complex<float>(0, 3.0)); assert ( c1 == std::complex<float>(0, 3.0));
auto c2 = 3if; auto c2 = 3if;
assert ( c1 == c2 ); assert ( c1 == c2 );
} }
#endif
} }

libcxx/trunk/test/std/strings/basic.string.literals/literal.pass.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <string> #include <string>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using namespace std::literals::string_literals; using namespace std::literals::string_literals;
static_assert ( std::is_same<decltype( "Hi"s), std::string>::value, "" ); static_assert ( std::is_same<decltype( "Hi"s), std::string>::value, "" );
static_assert ( std::is_same<decltype( u8"Hi"s), std::string>::value, "" ); static_assert ( std::is_same<decltype( u8"Hi"s), std::string>::value, "" );
static_assert ( std::is_same<decltype( L"Hi"s), std::wstring>::value, "" ); static_assert ( std::is_same<decltype( L"Hi"s), std::wstring>::value, "" );
static_assert ( std::is_same<decltype( u"Hi"s), std::u16string>::value, "" ); static_assert ( std::is_same<decltype( u"Hi"s), std::u16string>::value, "" );
static_assert ( std::is_same<decltype( U"Hi"s), std::u32string>::value, "" ); static_assert ( std::is_same<decltype( U"Hi"s), std::u32string>::value, "" );
Show All 14 Linesint main()
ufoo = u" "s; assert(ufoo.size() == 1); ufoo = u" "s; assert(ufoo.size() == 1);
Ufoo = U" "s; assert(Ufoo.size() == 1); Ufoo = U" "s; assert(Ufoo.size() == 1);
foo = "ABC"s; assert( foo == "ABC"); assert( foo == std::string ( "ABC")); foo = "ABC"s; assert( foo == "ABC"); assert( foo == std::string ( "ABC"));
foo = u8"ABC"s; assert( foo == u8"ABC"); assert( foo == std::string (u8"ABC")); foo = u8"ABC"s; assert( foo == u8"ABC"); assert( foo == std::string (u8"ABC"));
Lfoo = L"ABC"s; assert(Lfoo == L"ABC"); assert(Lfoo == std::wstring ( L"ABC")); Lfoo = L"ABC"s; assert(Lfoo == L"ABC"); assert(Lfoo == std::wstring ( L"ABC"));
ufoo = u"ABC"s; assert(ufoo == u"ABC"); assert(ufoo == std::u16string( u"ABC")); ufoo = u"ABC"s; assert(ufoo == u"ABC"); assert(ufoo == std::u16string( u"ABC"));
Ufoo = U"ABC"s; assert(Ufoo == U"ABC"); assert(Ufoo == std::u32string( U"ABC")); Ufoo = U"ABC"s; assert(Ufoo == U"ABC"); assert(Ufoo == std::u32string( U"ABC"));
#endif
} }

libcxx/trunk/test/std/strings/basic.string.literals/literal1.fail.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <string> #include <string>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::string; using std::string;
string foo = ""s; // should fail w/conversion operator not found string foo = ""s; // should fail w/conversion operator not found
#else
#error
#endif
} }

libcxx/trunk/test/std/strings/basic.string.literals/literal1.pass.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <string> #include <string>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using namespace std::literals; using namespace std::literals;
std::string foo = ""s; std::string foo = ""s;
#endif
} }

libcxx/trunk/test/std/strings/basic.string.literals/literal2.fail.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <string> #include <string>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
std::string foo = ""s; // should fail w/conversion operator not found std::string foo = ""s; // should fail w/conversion operator not found
#else
#error
#endif
} }

libcxx/trunk/test/std/strings/basic.string.literals/literal2.pass.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <string> #include <string>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using namespace std::literals::string_literals; using namespace std::literals::string_literals;
std::string foo = ""s; std::string foo = ""s;
#endif
} }

libcxx/trunk/test/std/strings/basic.string.literals/literal3.pass.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <string> #include <string>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using namespace std; using namespace std;
string foo = ""s; string foo = ""s;
#endif
} }

libcxx/trunk/test/std/strings/basic.string/string.iterators/iterators.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <string> // <string>
// iterator begin(); // iterator begin();
// iterator end(); // iterator end();
// const_iterator begin() const; // const_iterator begin() const;
// const_iterator end() const; // const_iterator end() const;
// const_iterator cbegin() const; // const_iterator cbegin() const;
// const_iterator cend() const; // const_iterator cend() const;
#include <string> #include <string>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ // N3644 testing { // N3644 testing
typedef std::string C; typedef std::string C;
C::iterator ii1{}, ii2{}; C::iterator ii1{}, ii2{};
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
assert ( ii1 == cii ); assert ( ii1 == cii );
Show All 31 Linesint main()
C::iterator ii4 = ii1; C::iterator ii4 = ii1;
C::const_iterator cii{}; C::const_iterator cii{};
assert ( ii1 == ii2 ); assert ( ii1 == ii2 );
assert ( ii1 == ii4 ); assert ( ii1 == ii4 );
assert ( ii1 == cii ); assert ( ii1 == cii );
assert ( !(ii1 != ii2 )); assert ( !(ii1 != ii2 ));
assert ( !(ii1 != cii )); assert ( !(ii1 != cii ));
} }
#endif
} }

libcxx/trunk/test/std/thread/futures/futures.promise/set_rvalue.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// XFAIL: libcpp-no-exceptions // UNSUPPORTED: libcpp-has-no-threads, libcpp-no-exceptions
// UNSUPPORTED: libcpp-has-no-threads
// <future> // <future>
// class promise<R> // class promise<R>
// void promise::set_value(R&& r); // void promise::set_value(R&& r);
#include <future> #include <future>
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_assign.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// shared_lock& operator=(shared_lock const&) = delete; // shared_lock& operator=(shared_lock const&) = delete;
#include <shared_mutex> #include <shared_mutex>
#if _LIBCPP_STD_VER > 11
std::shared_timed_mutex m0; std::shared_timed_mutex m0;
std::shared_timed_mutex m1; std::shared_timed_mutex m1;
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
std::shared_lock<std::shared_timed_mutex> lk0(m0); std::shared_lock<std::shared_timed_mutex> lk0(m0);
std::shared_lock<std::shared_timed_mutex> lk1(m1); std::shared_lock<std::shared_timed_mutex> lk1(m1);
lk1 = lk0; lk1 = lk0;
#else
# error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/copy_ctor.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <shared_mutex> // <shared_mutex>
// template <class Mutex> class shared_lock; // template <class Mutex> class shared_lock;
// shared_lock(shared_lock const&) = delete; // shared_lock(shared_lock const&) = delete;
#include <shared_mutex> #include <shared_mutex>
#if _LIBCPP_STD_VER > 11
std::shared_timed_mutex m; std::shared_timed_mutex m;
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
std::shared_lock<std::shared_timed_mutex> lk0(m); std::shared_lock<std::shared_timed_mutex> lk0(m);
std::shared_lock<std::shared_timed_mutex> lk = lk0; std::shared_lock<std::shared_timed_mutex> lk = lk0;
#else
# error
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/assign.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
// shared_timed_mutex& operator=(const shared_timed_mutex&) = delete; // shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
#include <shared_mutex> #include <shared_mutex>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
std::shared_timed_mutex m0; std::shared_timed_mutex m0;
std::shared_timed_mutex m1; std::shared_timed_mutex m1;
m1 = m0; m1 = m0;
#else
# error
#endif
} }

libcxx/trunk/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/copy.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <shared_mutex> // <shared_mutex>
// class shared_timed_mutex; // class shared_timed_mutex;
// shared_timed_mutex(const shared_timed_mutex&) = delete; // shared_timed_mutex(const shared_timed_mutex&) = delete;
#include <shared_mutex> #include <shared_mutex>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
std::shared_timed_mutex m0; std::shared_timed_mutex m0;
std::shared_timed_mutex m1(m0); std::shared_timed_mutex m1(m0);
#else
# error
#endif
} }

libcxx/trunk/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <functional> #include <functional>
#include <string> #include <string>
template <class _Tp> template <class _Tp>
struct is_transparent struct is_transparent
{ {
private: private:
struct __two {char __lx; char __lxx;}; struct __two {char __lx; char __lxx;};
template <class _Up> static __two __test(...); template <class _Up> static __two __test(...);
template <class _Up> static char __test(typename _Up::is_transparent* = 0); template <class _Up> static char __test(typename _Up::is_transparent* = 0);
public: public:
static const bool value = sizeof(__test<_Tp>(0)) == 1; static const bool value = sizeof(__test<_Tp>(0)) == 1;
}; };
int main () { int main ()
#if _LIBCPP_STD_VER > 11 {
static_assert ( !is_transparent<std::plus<int>>::value, "" ); static_assert ( !is_transparent<std::plus<int>>::value, "" );
static_assert ( !is_transparent<std::plus<std::string>>::value, "" ); static_assert ( !is_transparent<std::plus<std::string>>::value, "" );
static_assert ( is_transparent<std::plus<void>>::value, "" ); static_assert ( is_transparent<std::plus<void>>::value, "" );
static_assert ( is_transparent<std::plus<>>::value, "" ); static_assert ( is_transparent<std::plus<>>::value, "" );
static_assert ( !is_transparent<std::minus<int>>::value, "" ); static_assert ( !is_transparent<std::minus<int>>::value, "" );
static_assert ( !is_transparent<std::minus<std::string>>::value, "" ); static_assert ( !is_transparent<std::minus<std::string>>::value, "" );
static_assert ( is_transparent<std::minus<void>>::value, "" ); static_assert ( is_transparent<std::minus<void>>::value, "" );
Show All 14 Linesint main ()
static_assert ( is_transparent<std::modulus<void>>::value, "" ); static_assert ( is_transparent<std::modulus<void>>::value, "" );
static_assert ( is_transparent<std::modulus<>>::value, "" ); static_assert ( is_transparent<std::modulus<>>::value, "" );
static_assert ( !is_transparent<std::negate<int>>::value, "" ); static_assert ( !is_transparent<std::negate<int>>::value, "" );
static_assert ( !is_transparent<std::negate<std::string>>::value, "" ); static_assert ( !is_transparent<std::negate<std::string>>::value, "" );
static_assert ( is_transparent<std::negate<void>>::value, "" ); static_assert ( is_transparent<std::negate<void>>::value, "" );
static_assert ( is_transparent<std::negate<>>::value, "" ); static_assert ( is_transparent<std::negate<>>::value, "" );
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/function.objects/bitwise.operations/bit_not.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <functional> // <functional>
// bit_not // bit_not
#include <functional> #include <functional>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
typedef std::bit_not<int> F; typedef std::bit_not<int> F;
const F f = F(); const F f = F();
static_assert((std::is_same<F::argument_type, int>::value), "" ); static_assert((std::is_same<F::argument_type, int>::value), "" );
static_assert((std::is_same<F::result_type, int>::value), "" ); static_assert((std::is_same<F::result_type, int>::value), "" );
assert((f(0xEA95) & 0xFFFF ) == 0x156A); assert((f(0xEA95) & 0xFFFF ) == 0x156A);
assert((f(0x58D3) & 0xFFFF ) == 0xA72C); assert((f(0x58D3) & 0xFFFF ) == 0xA72C);
assert((f(0) & 0xFFFF ) == 0xFFFF); assert((f(0) & 0xFFFF ) == 0xFFFF);
assert((f(0xFFFF) & 0xFFFF ) == 0); assert((f(0xFFFF) & 0xFFFF ) == 0);
Show All 9 Linesint main()
assert((f2(0xFFFF) & 0xFFFF ) == 0); assert((f2(0xFFFF) & 0xFFFF ) == 0);
assert((f2(0xFFFFL) & 0xFFFF ) == 0); assert((f2(0xFFFFL) & 0xFFFF ) == 0);
constexpr int foo = std::bit_not<int> () (0xEA95) & 0xFFFF; constexpr int foo = std::bit_not<int> () (0xEA95) & 0xFFFF;
static_assert ( foo == 0x156A, "" ); static_assert ( foo == 0x156A, "" );
constexpr int bar = std::bit_not<> () (0xEA95) & 0xFFFF; constexpr int bar = std::bit_not<> () (0xEA95) & 0xFFFF;
static_assert ( bar == 0x156A, "" ); static_assert ( bar == 0x156A, "" );
#endif
} }

libcxx/trunk/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <functional> #include <functional>
#include <string> #include <string>
template <class _Tp> template <class _Tp>
struct is_transparent struct is_transparent
{ {
private: private:
struct __two {char __lx; char __lxx;}; struct __two {char __lx; char __lxx;};
template <class _Up> static __two __test(...); template <class _Up> static __two __test(...);
template <class _Up> static char __test(typename _Up::is_transparent* = 0); template <class _Up> static char __test(typename _Up::is_transparent* = 0);
public: public:
static const bool value = sizeof(__test<_Tp>(0)) == 1; static const bool value = sizeof(__test<_Tp>(0)) == 1;
}; };
int main () { int main () {
#if _LIBCPP_STD_VER > 11
static_assert ( !is_transparent<std::bit_and<int>>::value, "" ); static_assert ( !is_transparent<std::bit_and<int>>::value, "" );
static_assert ( !is_transparent<std::bit_and<std::string>>::value, "" ); static_assert ( !is_transparent<std::bit_and<std::string>>::value, "" );
static_assert ( is_transparent<std::bit_and<void>>::value, "" ); static_assert ( is_transparent<std::bit_and<void>>::value, "" );
static_assert ( is_transparent<std::bit_and<>>::value, "" ); static_assert ( is_transparent<std::bit_and<>>::value, "" );
static_assert ( !is_transparent<std::bit_or<int>>::value, "" ); static_assert ( !is_transparent<std::bit_or<int>>::value, "" );
static_assert ( !is_transparent<std::bit_or<std::string>>::value, "" ); static_assert ( !is_transparent<std::bit_or<std::string>>::value, "" );
static_assert ( is_transparent<std::bit_or<void>>::value, "" ); static_assert ( is_transparent<std::bit_or<void>>::value, "" );
static_assert ( is_transparent<std::bit_or<>>::value, "" ); static_assert ( is_transparent<std::bit_or<>>::value, "" );
static_assert ( !is_transparent<std::bit_xor<int>>::value, "" ); static_assert ( !is_transparent<std::bit_xor<int>>::value, "" );
static_assert ( !is_transparent<std::bit_xor<std::string>>::value, "" ); static_assert ( !is_transparent<std::bit_xor<std::string>>::value, "" );
static_assert ( is_transparent<std::bit_xor<void>>::value, "" ); static_assert ( is_transparent<std::bit_xor<void>>::value, "" );
static_assert ( is_transparent<std::bit_xor<>>::value, "" ); static_assert ( is_transparent<std::bit_xor<>>::value, "" );
static_assert ( !is_transparent<std::bit_not<int>>::value, "" ); static_assert ( !is_transparent<std::bit_not<int>>::value, "" );
static_assert ( !is_transparent<std::bit_not<std::string>>::value, "" ); static_assert ( !is_transparent<std::bit_not<std::string>>::value, "" );
static_assert ( is_transparent<std::bit_not<void>>::value, "" ); static_assert ( is_transparent<std::bit_not<void>>::value, "" );
static_assert ( is_transparent<std::bit_not<>>::value, "" ); static_assert ( is_transparent<std::bit_not<>>::value, "" );
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/function.objects/comparisons/transparent.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <functional> #include <functional>
#include <string> #include <string>
template <class _Tp> template <class _Tp>
struct is_transparent struct is_transparent
{ {
private: private:
struct __two {char __lx; char __lxx;}; struct __two {char __lx; char __lxx;};
template <class _Up> static __two __test(...); template <class _Up> static __two __test(...);
template <class _Up> static char __test(typename _Up::is_transparent* = 0); template <class _Up> static char __test(typename _Up::is_transparent* = 0);
public: public:
static const bool value = sizeof(__test<_Tp>(0)) == 1; static const bool value = sizeof(__test<_Tp>(0)) == 1;
}; };
int main () { int main ()
#if _LIBCPP_STD_VER > 11 {
static_assert ( !is_transparent<std::less<int>>::value, "" ); static_assert ( !is_transparent<std::less<int>>::value, "" );
static_assert ( !is_transparent<std::less<std::string>>::value, "" ); static_assert ( !is_transparent<std::less<std::string>>::value, "" );
static_assert ( is_transparent<std::less<void>>::value, "" ); static_assert ( is_transparent<std::less<void>>::value, "" );
static_assert ( is_transparent<std::less<>>::value, "" ); static_assert ( is_transparent<std::less<>>::value, "" );
static_assert ( !is_transparent<std::less_equal<int>>::value, "" ); static_assert ( !is_transparent<std::less_equal<int>>::value, "" );
static_assert ( !is_transparent<std::less_equal<std::string>>::value, "" ); static_assert ( !is_transparent<std::less_equal<std::string>>::value, "" );
static_assert ( is_transparent<std::less_equal<void>>::value, "" ); static_assert ( is_transparent<std::less_equal<void>>::value, "" );
Show All 14 Linesint main ()
static_assert ( is_transparent<std::greater<void>>::value, "" ); static_assert ( is_transparent<std::greater<void>>::value, "" );
static_assert ( is_transparent<std::greater<>>::value, "" ); static_assert ( is_transparent<std::greater<>>::value, "" );
static_assert ( !is_transparent<std::greater_equal<int>>::value, "" ); static_assert ( !is_transparent<std::greater_equal<int>>::value, "" );
static_assert ( !is_transparent<std::greater_equal<std::string>>::value, "" ); static_assert ( !is_transparent<std::greater_equal<std::string>>::value, "" );
static_assert ( is_transparent<std::greater_equal<void>>::value, "" ); static_assert ( is_transparent<std::greater_equal<void>>::value, "" );
static_assert ( is_transparent<std::greater_equal<>>::value, "" ); static_assert ( is_transparent<std::greater_equal<>>::value, "" );
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <functional> #include <functional>
#include <string> #include <string>
template <class _Tp> template <class _Tp>
struct is_transparent struct is_transparent
{ {
private: private:
struct __two {char __lx; char __lxx;}; struct __two {char __lx; char __lxx;};
template <class _Up> static __two __test(...); template <class _Up> static __two __test(...);
template <class _Up> static char __test(typename _Up::is_transparent* = 0); template <class _Up> static char __test(typename _Up::is_transparent* = 0);
public: public:
static const bool value = sizeof(__test<_Tp>(0)) == 1; static const bool value = sizeof(__test<_Tp>(0)) == 1;
}; };
int main () { int main ()
#if _LIBCPP_STD_VER > 11 {
static_assert ( !is_transparent<std::logical_and<int>>::value, "" ); static_assert ( !is_transparent<std::logical_and<int>>::value, "" );
static_assert ( !is_transparent<std::logical_and<std::string>>::value, "" ); static_assert ( !is_transparent<std::logical_and<std::string>>::value, "" );
static_assert ( is_transparent<std::logical_and<void>>::value, "" ); static_assert ( is_transparent<std::logical_and<void>>::value, "" );
static_assert ( is_transparent<std::logical_and<>>::value, "" ); static_assert ( is_transparent<std::logical_and<>>::value, "" );
static_assert ( !is_transparent<std::logical_or<int>>::value, "" ); static_assert ( !is_transparent<std::logical_or<int>>::value, "" );
static_assert ( !is_transparent<std::logical_or<std::string>>::value, "" ); static_assert ( !is_transparent<std::logical_or<std::string>>::value, "" );
static_assert ( is_transparent<std::logical_or<void>>::value, "" ); static_assert ( is_transparent<std::logical_or<void>>::value, "" );
static_assert ( is_transparent<std::logical_or<>>::value, "" ); static_assert ( is_transparent<std::logical_or<>>::value, "" );
static_assert ( !is_transparent<std::logical_not<int>>::value, "" ); static_assert ( !is_transparent<std::logical_not<int>>::value, "" );
static_assert ( !is_transparent<std::logical_not<std::string>>::value, "" ); static_assert ( !is_transparent<std::logical_not<std::string>>::value, "" );
static_assert ( is_transparent<std::logical_not<void>>::value, "" ); static_assert ( is_transparent<std::logical_not<void>>::value, "" );
static_assert ( is_transparent<std::logical_not<>>::value, "" ); static_assert ( is_transparent<std::logical_not<>>::value, "" );
#endif
return 0; return 0;
} }

libcxx/trunk/test/std/utilities/intseq/intseq.general/integer_seq.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <utility> // <utility>
// class make_integer_sequence // class make_integer_sequence
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
#if _LIBCPP_STD_VER > 11
template <typename AtContainer, typename T, T... I> template <typename AtContainer, typename T, T... I>
auto extract ( const AtContainer &t, const std::integer_sequence<T, I...> ) auto extract ( const AtContainer &t, const std::integer_sequence<T, I...> )
-> decltype ( std::make_tuple ( std::get<I>(t)... )) -> decltype ( std::make_tuple ( std::get<I>(t)... ))
{ return std::make_tuple ( std::get<I>(t)... ); } { return std::make_tuple ( std::get<I>(t)... ); }
#endif // _LIBCPP_STD_VER > 11
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
// Make a couple of sequences // Make a couple of sequences
using int3 = std::make_integer_sequence<int, 3>; // generates int: 0,1,2 using int3 = std::make_integer_sequence<int, 3>; // generates int: 0,1,2
using size7 = std::make_integer_sequence<size_t, 7>; // generates size_t: 0,1,2,3,4,5,6 using size7 = std::make_integer_sequence<size_t, 7>; // generates size_t: 0,1,2,3,4,5,6
using size4 = std::make_index_sequence<4>; // generates size_t: 0,1,2,3 using size4 = std::make_index_sequence<4>; // generates size_t: 0,1,2,3
using size2 = std::index_sequence_for<int, size_t>; // generates size_t: 0,1 using size2 = std::index_sequence_for<int, size_t>; // generates size_t: 0,1
using intmix = std::integer_sequence<int, 9, 8, 7, 2>; // generates int: 9,8,7,2 using intmix = std::integer_sequence<int, 9, 8, 7, 2>; // generates int: 9,8,7,2
using sizemix = std::index_sequence<1, 1, 2, 3, 5>; // generates size_t: 1,1,2,3,5 using sizemix = std::index_sequence<1, 1, 2, 3, 5>; // generates size_t: 1,1,2,3,5
Show All 37 Lines// Use them
auto tintmix = extract ( tup, intmix ()); auto tintmix = extract ( tup, intmix ());
static_assert ( std::tuple_size<decltype(tintmix)>::value == intmix::size (), "tintmix size wrong"); static_assert ( std::tuple_size<decltype(tintmix)>::value == intmix::size (), "tintmix size wrong");
assert ( tintmix == std::make_tuple ( 19, 18, 17, 12 )); assert ( tintmix == std::make_tuple ( 19, 18, 17, 12 ));
auto tsizemix = extract ( tup, sizemix ()); auto tsizemix = extract ( tup, sizemix ());
static_assert ( std::tuple_size<decltype(tsizemix)>::value == sizemix::size (), "tsizemix size wrong"); static_assert ( std::tuple_size<decltype(tsizemix)>::value == sizemix::size (), "tsizemix size wrong");
assert ( tsizemix == std::make_tuple ( 11, 11, 12, 13, 15 )); assert ( tsizemix == std::make_tuple ( 11, 11, 12, 13, 15 ));
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/utilities/intseq/intseq.intseq/integer_seq.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <utility> // <utility>
// template<class T, T... I> // template<class T, T... I>
// struct integer_sequence // struct integer_sequence
// { // {
// typedef T type; // typedef T type;
// //
// static constexpr size_t size() noexcept; // static constexpr size_t size() noexcept;
// }; // };
#include <utility> #include <utility>
#include <type_traits> #include <type_traits>
#include <cstddef> #include <cstddef>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
// Make a few of sequences // Make a few of sequences
using int3 = std::integer_sequence<int, 3, 2, 1>; using int3 = std::integer_sequence<int, 3, 2, 1>;
using size1 = std::integer_sequence<std::size_t, 7>; using size1 = std::integer_sequence<std::size_t, 7>;
using ushort2 = std::integer_sequence<unsigned short, 4, 6>; using ushort2 = std::integer_sequence<unsigned short, 4, 6>;
using bool0 = std::integer_sequence<bool>; using bool0 = std::integer_sequence<bool>;
// Make sure they're what we expect // Make sure they're what we expect
static_assert ( std::is_same<int3::value_type, int>::value, "int3 type wrong" ); static_assert ( std::is_same<int3::value_type, int>::value, "int3 type wrong" );
static_assert ( int3::size() == 3, "int3 size wrong" ); static_assert ( int3::size() == 3, "int3 size wrong" );
static_assert ( std::is_same<size1::value_type, std::size_t>::value, "size1 type wrong" ); static_assert ( std::is_same<size1::value_type, std::size_t>::value, "size1 type wrong" );
static_assert ( size1::size() == 1, "size1 size wrong" ); static_assert ( size1::size() == 1, "size1 size wrong" );
static_assert ( std::is_same<ushort2::value_type, unsigned short>::value, "ushort2 type wrong" ); static_assert ( std::is_same<ushort2::value_type, unsigned short>::value, "ushort2 type wrong" );
static_assert ( ushort2::size() == 2, "ushort2 size wrong" ); static_assert ( ushort2::size() == 2, "ushort2 size wrong" );
static_assert ( std::is_same<bool0::value_type, bool>::value, "bool0 type wrong" ); static_assert ( std::is_same<bool0::value_type, bool>::value, "bool0 type wrong" );
static_assert ( bool0::size() == 0, "bool0 size wrong" ); static_assert ( bool0::size() == 0, "bool0 size wrong" );
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.array.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <memory> #include <memory>
#include <string> #include <string>
#include <cassert> #include <cassert>
// The only way to create an unique_ptr<T[]> is to default construct them. // The only way to create an unique_ptr<T[]> is to default construct them.
class foo { class foo {
public: public:
foo () : val_(3) {} foo () : val_(3) {}
int get () const { return val_; } int get () const { return val_; }
private: private:
int val_; int val_;
}; };
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
auto p1 = std::make_unique<int[]>(5); auto p1 = std::make_unique<int[]>(5);
for ( int i = 0; i < 5; ++i ) for ( int i = 0; i < 5; ++i )
assert ( p1[i] == 0 ); assert ( p1[i] == 0 );
} }
{ {
auto p2 = std::make_unique<std::string[]>(5); auto p2 = std::make_unique<std::string[]>(5);
for ( int i = 0; i < 5; ++i ) for ( int i = 0; i < 5; ++i )
assert ( p2[i].size () == 0 ); assert ( p2[i].size () == 0 );
} }
{ {
auto p3 = std::make_unique<foo[]>(7); auto p3 = std::make_unique<foo[]>(7);
for ( int i = 0; i < 7; ++i ) for ( int i = 0; i < 7; ++i )
assert ( p3[i].get () == 3 ); assert ( p3[i].get () == 3 );
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/utilities/memory/unique.ptr/unique.ptr.create/make_unique.single.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <memory> #include <memory>
#include <string> #include <string>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
std::unique_ptr<int> p1 = std::make_unique<int>(1); std::unique_ptr<int> p1 = std::make_unique<int>(1);
assert ( *p1 == 1 ); assert ( *p1 == 1 );
p1 = std::make_unique<int> (); p1 = std::make_unique<int> ();
assert ( *p1 == 0 ); assert ( *p1 == 0 );
} }
{ {
std::unique_ptr<std::string> p2 = std::make_unique<std::string> ( "Meow!" ); std::unique_ptr<std::string> p2 = std::make_unique<std::string> ( "Meow!" );
assert ( *p2 == "Meow!" ); assert ( *p2 == "Meow!" );
p2 = std::make_unique<std::string> (); p2 = std::make_unique<std::string> ();
assert ( *p2 == "" ); assert ( *p2 == "" );
p2 = std::make_unique<std::string> ( 6, 'z' ); p2 = std::make_unique<std::string> ( 6, 'z' );
assert ( *p2 == "zzzzzz" ); assert ( *p2 == "zzzzzz" );
} }
#endif // _LIBCPP_STD_VER > 11
} }

libcxx/trunk/test/std/utilities/meta/meta.trans/meta.trans.other/enable_if2.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// type_traits // type_traits
// enable_if // enable_if
#include <type_traits> #include <type_traits>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
typedef std::enable_if_t<false> A; typedef std::enable_if_t<false> A;
#else
static_assert ( false, "" );
#endif
} }

libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_final.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// type_traits // type_traits
// is_final // is_final
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
#if _LIBCPP_STD_VER > 11
struct P final { }; struct P final { };
union U1 { }; union U1 { };
union U2 final { }; union U2 final { };
template <class T> template <class T>
void test_is_final() void test_is_final()
{ {
static_assert( std::is_final<T>::value, ""); static_assert( std::is_final<T>::value, "");
Show All 29 Linesint main ()
test_is_not_final<int*>(); test_is_not_final<int*>();
test_is_final <P>(); test_is_final <P>();
test_is_not_final<P*>(); test_is_not_final<P*>();
test_is_not_final<U1>(); test_is_not_final<U1>();
test_is_not_final<U1*>(); test_is_not_final<U1*>();
test_is_final <U2>(); test_is_final <U2>();
test_is_not_final<U2*>(); test_is_not_final<U2*>();
} }
#else
int main () {}
#endif

libcxx/trunk/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <chrono> // <chrono>
#include <chrono> #include <chrono>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using namespace std::literals::chrono_literals; using namespace std::literals::chrono_literals;
// Make sure the types are right // Make sure the types are right
static_assert ( std::is_same<decltype( 3h ), std::chrono::hours>::value, "" ); static_assert ( std::is_same<decltype( 3h ), std::chrono::hours>::value, "" );
static_assert ( std::is_same<decltype( 3min ), std::chrono::minutes>::value, "" ); static_assert ( std::is_same<decltype( 3min ), std::chrono::minutes>::value, "" );
static_assert ( std::is_same<decltype( 3s ), std::chrono::seconds>::value, "" ); static_assert ( std::is_same<decltype( 3s ), std::chrono::seconds>::value, "" );
static_assert ( std::is_same<decltype( 3ms ), std::chrono::milliseconds>::value, "" ); static_assert ( std::is_same<decltype( 3ms ), std::chrono::milliseconds>::value, "" );
static_assert ( std::is_same<decltype( 3us ), std::chrono::microseconds>::value, "" ); static_assert ( std::is_same<decltype( 3us ), std::chrono::microseconds>::value, "" );
Show All 23 Lines// Make sure the types are right
assert ( us == std::chrono::microseconds(867)); assert ( us == std::chrono::microseconds(867));
auto us2 = 867.0us; auto us2 = 867.0us;
assert ( us == us2 ); assert ( us == us2 );
std::chrono::nanoseconds ns = 645ns; std::chrono::nanoseconds ns = 645ns;
assert ( ns == std::chrono::nanoseconds(645)); assert ( ns == std::chrono::nanoseconds(645));
auto ns2 = 645.ns; auto ns2 = 645.ns;
assert ( ns == ns2 ); assert ( ns == ns2 );
#endif
} }

libcxx/trunk/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
std::chrono::hours h = 4h; // should fail w/conversion operator not found std::chrono::hours h = 4h; // should fail w/conversion operator not found
#else
#error
#endif
} }

libcxx/trunk/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using namespace std::chrono; using namespace std::chrono;
hours h = 4h; hours h = 4h;
assert ( h == hours(4)); assert ( h == hours(4));
auto h2 = 4.0h; auto h2 = 4.0h;
assert ( h == h2 ); assert ( h == h2 );
minutes min = 36min; minutes min = 36min;
Show All 15 Linesint main()
assert ( us == microseconds(867)); assert ( us == microseconds(867));
auto us2 = 867.0us; auto us2 = 867.0us;
assert ( us == us2 ); assert ( us == us2 );
nanoseconds ns = 645ns; nanoseconds ns = 645ns;
assert ( ns == nanoseconds(645)); assert ( ns == nanoseconds(645));
auto ns2 = 645.ns; auto ns2 = 645.ns;
assert ( ns == ns2 ); assert ( ns == ns2 );
#endif
} }

libcxx/trunk/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <chrono> #include <chrono>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using std::chrono::hours; using std::chrono::hours;
hours foo = 4h; // should fail w/conversion operator not found hours foo = 4h; // should fail w/conversion operator not found
#else
#error
#endif
} }

libcxx/trunk/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// <chrono> // <chrono>
#include <chrono> #include <chrono>
#include <type_traits> #include <type_traits>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
using namespace std::literals; using namespace std::literals;
std::chrono::hours h = 4h; std::chrono::hours h = 4h;
assert ( h == std::chrono::hours(4)); assert ( h == std::chrono::hours(4));
auto h2 = 4.0h; auto h2 = 4.0h;
assert ( h == h2 ); assert ( h == h2 );
std::chrono::minutes min = 36min; std::chrono::minutes min = 36min;
Show All 15 Linesint main()
assert ( us == std::chrono::microseconds(867)); assert ( us == std::chrono::microseconds(867));
auto us2 = 867.0us; auto us2 = 867.0us;
assert ( us == us2 ); assert ( us == us2 );
std::chrono::nanoseconds ns = 645ns; std::chrono::nanoseconds ns = 645ns;
assert ( ns == std::chrono::nanoseconds(645)); assert ( ns == std::chrono::nanoseconds(645));
auto ns2 = 645.ns; auto ns2 = 645.ns;
assert ( ns == ns2 ); assert ( ns == ns2 );
#endif
} }

libcxx/trunk/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type1.fail.cpp

Show All 11 Lines
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <complex> #include <complex>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
typedef std::complex<float> cf; typedef std::complex<float> cf;
auto t1 = std::make_tuple<int, std::string> ( 42, "Hi" ); auto t1 = std::make_tuple<int, std::string> ( 42, "Hi" );
assert (( std::get<cf>(t1) == cf {1,2} )); // no such type assert (( std::get<cf>(t1) == cf {1,2} )); // no such type
#else
#error
#endif
} }

libcxx/trunk/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type2.fail.cpp

Show All 11 Lines
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <complex> #include <complex>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
typedef std::complex<float> cf; typedef std::complex<float> cf;
auto t1 = std::make_tuple<int, int, std::string, cf> ( 42, 21, "Hi", { 1,2 } ); auto t1 = std::make_tuple<int, int, std::string, cf> ( 42, 21, "Hi", { 1,2 } );
assert ( std::get<int>(t1) == 42 ); // two ints here assert ( std::get<int>(t1) == 42 ); // two ints here
#else
#error
#endif
} }

libcxx/trunk/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type3.fail.cpp

Show All 11 Lines
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <complex> #include <complex>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
typedef std::complex<float> cf; typedef std::complex<float> cf;
auto t1 = std::make_tuple<double, int, std::string, cf, int> ( 42, 21, "Hi", { 1,2 } ); auto t1 = std::make_tuple<double, int, std::string, cf, int> ( 42, 21, "Hi", { 1,2 } );
assert ( std::get<int>(t1) == 42 ); // two ints here (one at the end) assert ( std::get<int>(t1) == 42 ); // two ints here (one at the end)
#else
#error
#endif
} }

libcxx/trunk/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type4.fail.cpp

Show All 11 Lines
#include <tuple> #include <tuple>
#include <string> #include <string>
#include <memory> #include <memory>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
typedef std::unique_ptr<int> upint; typedef std::unique_ptr<int> upint;
std::tuple<upint> t(upint(new int(4))); std::tuple<upint> t(upint(new int(4)));
upint p = std::get<upint>(t); upint p = std::get<upint>(t);
#else
#error
#endif
} }

libcxx/trunk/test/std/utilities/utility/exchange/exchange.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// utilities // utilities
// exchange // exchange
#include <utility> #include <utility>
#include <cassert> #include <cassert>
#include <string> #include <string>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
{ {
int v = 12; int v = 12;
assert ( std::exchange ( v, 23 ) == 12 ); assert ( std::exchange ( v, 23 ) == 12 );
assert ( v == 23 ); assert ( v == 23 );
assert ( std::exchange ( v, 67.2 ) == 23 ); assert ( std::exchange ( v, 67.2 ) == 23 );
assert ( v == 67 ); assert ( v == 67 );
assert ((std::exchange<int, float> ( v, {} )) == 67 ); assert ((std::exchange<int, float> ( v, {} )) == 67 );
Show All 19 Linesint main()
s3 = s2; // Dad s3 = s2; // Dad
assert ( std::exchange ( s3, {} ) == s2 ); assert ( std::exchange ( s3, {} ) == s2 );
assert ( s3.size () == 0 ); assert ( s3.size () == 0 );
s3 = s2; // Dad s3 = s2; // Dad
assert ( std::exchange ( s3, "" ) == s2 ); assert ( std::exchange ( s3, "" ) == s2 );
assert ( s3.size () == 0 ); assert ( s3.size () == 0 );
} }
#endif
} }

libcxx/trunk/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type1.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <utility> #include <utility>
#include <complex> #include <complex>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
typedef std::complex<float> cf; typedef std::complex<float> cf;
auto t1 = std::make_pair<int, double> ( 42, 3.4 ); auto t1 = std::make_pair<int, double> ( 42, 3.4 );
assert (( std::get<cf>(t1) == cf {1,2} )); // no such type assert (( std::get<cf>(t1) == cf {1,2} )); // no such type
#else
#error
#endif
} }

libcxx/trunk/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type2.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <utility> #include <utility>
#include <complex> #include <complex>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
typedef std::complex<float> cf; typedef std::complex<float> cf;
auto t1 = std::make_pair<int, int> ( 42, 43 ); auto t1 = std::make_pair<int, int> ( 42, 43 );
assert ( std::get<int>(t1) == 42 ); // two ints assert ( std::get<int>(t1) == 42 ); // two ints
#else
#error
#endif
} }

libcxx/trunk/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type3.fail.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is dual licensed under the MIT and the University of Illinois Open // This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details. // Source Licenses. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
#include <utility> #include <utility>
#include <complex> #include <complex>
#include <cassert> #include <cassert>
int main() int main()
{ {
#if _LIBCPP_STD_VER > 11
typedef std::unique_ptr<int> upint; typedef std::unique_ptr<int> upint;
std::pair<upint, int> t(upint(new int(4)), 23); std::pair<upint, int> t(upint(new int(4)), 23);
upint p = std::get<upint>(t); upint p = std::get<upint>(t);
#else
#error
#endif
} }