Skip to content

R
riscv-gcc-1
Commit 2b5ab1e4 by Michael Brune Committed by Jonathan Wakely
Options

enable_special_members.h: New. 

2013-10-31  Michael Brune  <lucdanton@free.fr>

	* include/bits/enable_special_members.h: New.
	* include/experimental/optional: New.
	* include/Makefile.am: Handle include/experimental.
	* include/Makefile.in: Regenerate.
	* testsuite/libstdc++-dg/conformance.exp: Run tests from
	testsuite/experimental sub-directory.
	* testsuite/experimental/optional/assignment/1.cc: New.
	* testsuite/experimental/optional/assignment/2.cc: New.
	* testsuite/experimental/optional/assignment/3.cc: New.
	* testsuite/experimental/optional/assignment/4.cc: New.
	* testsuite/experimental/optional/assignment/5.cc: New.
	* testsuite/experimental/optional/assignment/6.cc: New.
	* testsuite/experimental/optional/cons/copy.cc: New.
	* testsuite/experimental/optional/cons/default.cc: New.
	* testsuite/experimental/optional/cons/move.cc: New.
	* testsuite/experimental/optional/cons/value.cc: New.
	* testsuite/experimental/optional/constexpr/cons/default.cc: New.
	* testsuite/experimental/optional/constexpr/cons/value.cc: New.
	* testsuite/experimental/optional/constexpr/in_place.cc: New.
	* testsuite/experimental/optional/constexpr/make_optional.cc: New.
	* testsuite/experimental/optional/constexpr/nullopt.cc: New.
	* testsuite/experimental/optional/constexpr/observers/1.cc: New.
	* testsuite/experimental/optional/constexpr/observers/2.cc: New.
	* testsuite/experimental/optional/constexpr/observers/3.cc: New.
	* testsuite/experimental/optional/constexpr/observers/4.cc: New.
	* testsuite/experimental/optional/constexpr/observers/5.cc: New.
	* testsuite/experimental/optional/constexpr/relops/1.cc: New.
	* testsuite/experimental/optional/constexpr/relops/2.cc: New.
	* testsuite/experimental/optional/constexpr/relops/3.cc: New.
	* testsuite/experimental/optional/constexpr/relops/4.cc: New.
	* testsuite/experimental/optional/constexpr/relops/5.cc: New.
	* testsuite/experimental/optional/constexpr/relops/6.cc: New.
	* testsuite/experimental/optional/in_place.cc: New.
	* testsuite/experimental/optional/make_optional.cc: New.
	* testsuite/experimental/optional/nullopt.cc: New.
	* testsuite/experimental/optional/observers/1.cc: New.
	* testsuite/experimental/optional/observers/2.cc: New.
	* testsuite/experimental/optional/observers/3.cc: New.
	* testsuite/experimental/optional/observers/4.cc: New.
	* testsuite/experimental/optional/observers/5.cc: New.
	* testsuite/experimental/optional/relops/1.cc: New.
	* testsuite/experimental/optional/relops/2.cc: New.
	* testsuite/experimental/optional/relops/3.cc: New.
	* testsuite/experimental/optional/relops/4.cc: New.
	* testsuite/experimental/optional/relops/5.cc: New.
	* testsuite/experimental/optional/relops/6.cc: New.
	* testsuite/experimental/optional/requirements.cc: New.
	* testsuite/experimental/optional/swap/1.cc: New.

From-SVN: r204299
parent a7920263
Showing with 3679 additions and 6 deletions
libstdc++-v3/ChangeLog
2013-10-31 Michael Brune <lucdanton@free.fr>
* include/bits/enable_special_members.h: New.
* include/experimental/optional: New.
* include/Makefile.am: Handle include/experimental.
* include/Makefile.in: Regenerate.
* testsuite/libstdc++-dg/conformance.exp: Run tests from
testsuite/experimental sub-directory.
* testsuite/experimental/optional/assignment/1.cc: New.
* testsuite/experimental/optional/assignment/2.cc: New.
* testsuite/experimental/optional/assignment/3.cc: New.
* testsuite/experimental/optional/assignment/4.cc: New.
* testsuite/experimental/optional/assignment/5.cc: New.
* testsuite/experimental/optional/assignment/6.cc: New.
* testsuite/experimental/optional/cons/copy.cc: New.
* testsuite/experimental/optional/cons/default.cc: New.
* testsuite/experimental/optional/cons/move.cc: New.
* testsuite/experimental/optional/cons/value.cc: New.
* testsuite/experimental/optional/constexpr/cons/default.cc: New.
* testsuite/experimental/optional/constexpr/cons/value.cc: New.
* testsuite/experimental/optional/constexpr/in_place.cc: New.
* testsuite/experimental/optional/constexpr/make_optional.cc: New.
* testsuite/experimental/optional/constexpr/nullopt.cc: New.
* testsuite/experimental/optional/constexpr/observers/1.cc: New.
* testsuite/experimental/optional/constexpr/observers/2.cc: New.
* testsuite/experimental/optional/constexpr/observers/3.cc: New.
* testsuite/experimental/optional/constexpr/observers/4.cc: New.
* testsuite/experimental/optional/constexpr/observers/5.cc: New.
* testsuite/experimental/optional/constexpr/relops/1.cc: New.
* testsuite/experimental/optional/constexpr/relops/2.cc: New.
* testsuite/experimental/optional/constexpr/relops/3.cc: New.
* testsuite/experimental/optional/constexpr/relops/4.cc: New.
* testsuite/experimental/optional/constexpr/relops/5.cc: New.
* testsuite/experimental/optional/constexpr/relops/6.cc: New.
* testsuite/experimental/optional/in_place.cc: New.
* testsuite/experimental/optional/make_optional.cc: New.
* testsuite/experimental/optional/nullopt.cc: New.
* testsuite/experimental/optional/observers/1.cc: New.
* testsuite/experimental/optional/observers/2.cc: New.
* testsuite/experimental/optional/observers/3.cc: New.
* testsuite/experimental/optional/observers/4.cc: New.
* testsuite/experimental/optional/observers/5.cc: New.
* testsuite/experimental/optional/relops/1.cc: New.
* testsuite/experimental/optional/relops/2.cc: New.
* testsuite/experimental/optional/relops/3.cc: New.
* testsuite/experimental/optional/relops/4.cc: New.
* testsuite/experimental/optional/relops/5.cc: New.
* testsuite/experimental/optional/relops/6.cc: New.
* testsuite/experimental/optional/requirements.cc: New.
* testsuite/experimental/optional/swap/1.cc: New.
2013-11-01 Jonathan Wakely <jwakely.gcc@gmail.com>
* include/bits/stl_function.h (logical_not<void>): Add noexcept.
......
libstdc++-v3/include/Makefile.am
......@@ -94,6 +94,7 @@ bits_headers = \
${bits_srcdir}/concept_check.h \
${bits_srcdir}/cpp_type_traits.h \
${bits_srcdir}/deque.tcc \
${bits_srcdir}/enable_special_members.h \
${bits_srcdir}/forward_list.h \
${bits_srcdir}/forward_list.tcc \
${bits_srcdir}/fstream.tcc \
......@@ -633,6 +634,12 @@ decimal_headers = \
${decimal_srcdir}/decimal \
${decimal_srcdir}/decimal.h
# Post-C++11 TS's
experimental_srcdir = ${glibcxx_srcdir}/include/experimental
experimental_builddir = ./experimental
experimental_headers = \
${experimental_srcdir}/optional
# This is the common subset of C++ files that all three "C" header models use.
c_base_srcdir = $(C_INCLUDE_DIR)
c_base_builddir = .
......@@ -910,8 +917,8 @@ endif
allstamped = \
stamp-std stamp-bits stamp-bits-sup stamp-c_base stamp-c_compatibility \
stamp-backward stamp-ext stamp-pb stamp-tr1 stamp-tr2 stamp-decimal \
stamp-debug stamp-parallel stamp-profile stamp-profile-impl \
stamp-host
stamp-experimental stamp-debug stamp-parallel stamp-profile \
stamp-profile-impl stamp-host
# List of all files that are created by explicit building, editing, or
# catenation.
......@@ -1034,6 +1041,11 @@ stamp-decimal: ${decimal_headers}
@-cd ${decimal_builddir} && $(LN_S) $? . 2>/dev/null
@$(STAMP) stamp-decimal
stamp-experimental: ${experimental_headers}
@-mkdir -p ${experimental_builddir}
@-cd ${experimental_builddir} && $(LN_S) $? . 2>/dev/null
@$(STAMP) stamp-experimental
stamp-debug: ${debug_headers}
@-mkdir -p ${debug_builddir}
@-cd ${debug_builddir} && $(LN_S) $? . 2>/dev/null
......@@ -1277,6 +1289,9 @@ install-headers:
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${decimal_builddir}
for file in ${decimal_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${decimal_builddir}; done
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${experimental_builddir}
for file in ${experimental_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${experimental_builddir}; done
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
for file in ${c_base_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
......@@ -1322,9 +1337,10 @@ clean-local:
# directory. (This is more of an example of how this kind of rule can
# be made.)
.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(tr2_headers)
$(decimal_headers) $(ext_headers)
$(decimal_headers) $(ext_headers) $(experimental_headers)
$(std_headers): ; @:
$(c_base_headers): ; @:
$(tr1_headers): ; @:
$(decimal_headers): ; @:
$(ext_headers): ; @:
$(experimental_headers): ; @:
libstdc++-v3/include/Makefile.in
......@@ -361,6 +361,7 @@ bits_headers = \
${bits_srcdir}/concept_check.h \
${bits_srcdir}/cpp_type_traits.h \
${bits_srcdir}/deque.tcc \
${bits_srcdir}/enable_special_members.h \
${bits_srcdir}/forward_list.h \
${bits_srcdir}/forward_list.tcc \
${bits_srcdir}/fstream.tcc \
......@@ -899,6 +900,13 @@ decimal_headers = \
${decimal_srcdir}/decimal.h
# Post-C++11 TS's
experimental_srcdir = ${glibcxx_srcdir}/include/experimental
experimental_builddir = ./experimental
experimental_headers = \
${experimental_srcdir}/optional
# This is the common subset of C++ files that all three "C" header models use.
c_base_srcdir = $(C_INCLUDE_DIR)
c_base_builddir = .
......@@ -1166,8 +1174,8 @@ PCHFLAGS = -x c++-header -nostdinc++ $(CXXFLAGS) $(VTV_PCH_CXXFLAGS)
allstamped = \
stamp-std stamp-bits stamp-bits-sup stamp-c_base stamp-c_compatibility \
stamp-backward stamp-ext stamp-pb stamp-tr1 stamp-tr2 stamp-decimal \
stamp-debug stamp-parallel stamp-profile stamp-profile-impl \
stamp-host
stamp-experimental stamp-debug stamp-parallel stamp-profile \
stamp-profile-impl stamp-host
# List of all files that are created by explicit building, editing, or
......@@ -1452,6 +1460,11 @@ stamp-decimal: ${decimal_headers}
@-cd ${decimal_builddir} && $(LN_S) $? . 2>/dev/null
@$(STAMP) stamp-decimal
stamp-experimental: ${experimental_headers}
@-mkdir -p ${experimental_builddir}
@-cd ${experimental_builddir} && $(LN_S) $? . 2>/dev/null
@$(STAMP) stamp-experimental
stamp-debug: ${debug_headers}
@-mkdir -p ${debug_builddir}
@-cd ${debug_builddir} && $(LN_S) $? . 2>/dev/null
......@@ -1680,6 +1693,9 @@ install-headers:
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${decimal_builddir}
for file in ${decimal_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${decimal_builddir}; done
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${experimental_builddir}
for file in ${experimental_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${experimental_builddir}; done
$(mkinstalldirs) $(DESTDIR)${gxx_include_dir}/${c_base_builddir}
for file in ${c_base_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${gxx_include_dir}/${c_base_builddir}; done
......@@ -1722,12 +1738,13 @@ clean-local:
# directory. (This is more of an example of how this kind of rule can
# be made.)
.PRECIOUS: $(std_headers) $(c_base_headers) $(tr1_headers) $(tr2_headers)
$(decimal_headers) $(ext_headers)
$(decimal_headers) $(ext_headers) $(experimental_headers)
$(std_headers): ; @:
$(c_base_headers): ; @:
$(tr1_headers): ; @:
$(decimal_headers): ; @:
$(ext_headers): ; @:
$(experimental_headers): ; @:
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
......
libstdc++-v3/testsuite/experimental/optional/assignment/1.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct exception {};
int counter = 0;
struct mixin_counter
{
mixin_counter() { ++counter; }
mixin_counter(mixin_counter const&) { ++counter; }
~mixin_counter() { --counter; }
};
struct value_type : private mixin_counter
{
enum state_type
{
zero,
moved_from,
throwing_construction,
throwing_copy,
throwing_copy_assignment,
throwing_move,
throwing_move_assignment,
threw,
};
value_type() = default;
explicit value_type(state_type state_)
: state(state_)
{
throw_if(throwing_construction);
}
value_type(value_type const& other)
: state(other.state)
{
throw_if(throwing_copy);
}
value_type&
operator=(value_type const& other)
{
state = other.state;
throw_if(throwing_copy_assignment);
return *this;
}
value_type(value_type&& other)
: state(other.state)
{
other.state = moved_from;
throw_if(throwing_move);
}
value_type&
operator=(value_type&& other)
{
state = other.state;
other.state = moved_from;
throw_if(throwing_move_assignment);
return *this;
}
void throw_if(state_type match)
{
if(state == match)
{
state = threw;
throw exception {};
}
}
state_type state = zero;
};
int main()
{
using O = std::experimental::optional<value_type>;
using S = value_type::state_type;
auto const make = [](S s = S::zero) { return O { std::experimental::in_place, s }; };
enum outcome_type { nothrow, caught, bad_catch };
// Check copy/move assignment for disengaged optional
// From disengaged optional
{
O o;
VERIFY( !o );
O p;
o = p;
VERIFY( !o );
VERIFY( !p );
}
{
O o;
VERIFY( !o );
O p;
o = std::move(p);
VERIFY( !o );
VERIFY( !p );
}
{
O o;
VERIFY( !o );
o = {};
VERIFY( !o );
}
// From engaged optional
{
O o;
VERIFY( !o );
O p = make(S::throwing_copy_assignment);
o = p;
VERIFY( o && o->state == S::throwing_copy_assignment );
VERIFY( p && p->state == S::throwing_copy_assignment );
}
{
O o;
VERIFY( !o );
O p = make(S::throwing_move_assignment);
o = std::move(p);
VERIFY( o && o->state == S::throwing_move_assignment );
VERIFY( p && p->state == S::moved_from );
}
{
outcome_type outcome {};
O o;
VERIFY( !o );
O p = make(S::throwing_copy);
try
{
o = p;
}
catch(exception const&)
{ outcome = caught; }
catch(...)
{ outcome = bad_catch; }
VERIFY( outcome == caught );
VERIFY( !o );
VERIFY( p && p->state == S::throwing_copy );
}
{
outcome_type outcome {};
O o;
VERIFY( !o );
O p = make(S::throwing_move);
try
{
o = std::move(p);
}
catch(exception const&)
{ outcome = caught; }
catch(...)
{ outcome = bad_catch; }
VERIFY( outcome == caught );
VERIFY( !o );
VERIFY( p && p->state == S::moved_from );
}
VERIFY( counter == 0 );
}
libstdc++-v3/testsuite/experimental/optional/assignment/2.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct exception {};
int counter = 0;
struct mixin_counter
{
mixin_counter() { ++counter; }
mixin_counter(mixin_counter const&) { ++counter; }
~mixin_counter() { --counter; }
};
struct value_type : private mixin_counter
{
enum state_type
{
zero,
moved_from,
throwing_construction,
throwing_copy,
throwing_copy_assignment,
throwing_move,
throwing_move_assignment,
threw,
};
value_type() = default;
explicit value_type(state_type state_)
: state(state_)
{
throw_if(throwing_construction);
}
value_type(value_type const& other)
: state(other.state)
{
throw_if(throwing_copy);
}
value_type&
operator=(value_type const& other)
{
state = other.state;
throw_if(throwing_copy_assignment);
return *this;
}
value_type(value_type&& other)
: state(other.state)
{
other.state = moved_from;
throw_if(throwing_move);
}
value_type&
operator=(value_type&& other)
{
state = other.state;
other.state = moved_from;
throw_if(throwing_move_assignment);
return *this;
}
void throw_if(state_type match)
{
if(state == match)
{
state = threw;
throw exception {};
}
}
state_type state = zero;
};
int main()
{
using O = std::experimental::optional<value_type>;
using S = value_type::state_type;
auto const make = [](S s = S::zero) { return O { std::experimental::in_place, s }; };
enum outcome_type { nothrow, caught, bad_catch };
// Check copy/move assignment for engaged optional
// From disengaged optional
{
O o = make(S::zero);
VERIFY( o );
O p;
o = p;
VERIFY( !o );
VERIFY( !p );
}
{
O o = make(S::zero);
VERIFY( o );
O p;
o = std::move(p);
VERIFY( !o );
VERIFY( !p );
}
{
O o = make(S::zero);
VERIFY( o );
o = {};
VERIFY( !o );
}
// From engaged optional
{
O o = make(S::zero);
VERIFY( o );
O p = make(S::throwing_copy);
o = p;
VERIFY( o && o->state == S::throwing_copy);
VERIFY( p && p->state == S::throwing_copy);
}
{
O o = make(S::zero);
VERIFY( o );
O p = make(S::throwing_move);
o = std::move(p);
VERIFY( o && o->state == S::throwing_move);
VERIFY( p && p->state == S::moved_from);
}
{
outcome_type outcome {};
O o = make(S::zero);
VERIFY( o );
O p = make(S::throwing_copy_assignment);
try
{
o = p;
}
catch(exception const&)
{ outcome = caught; }
catch(...)
{ outcome = bad_catch; }
VERIFY( o && o->state == S::threw);
VERIFY( p && p->state == S::throwing_copy_assignment);
}
{
outcome_type outcome {};
O o = make(S::zero);
VERIFY( o );
O p = make(S::throwing_move_assignment);
try
{
o = std::move(p);
}
catch(exception const&)
{ outcome = caught; }
catch(...)
{ outcome = bad_catch; }
VERIFY( o && o->state == S::threw);
VERIFY( p && p->state == S::moved_from);
}
VERIFY( counter == 0 );
}
libstdc++-v3/testsuite/experimental/optional/assignment/3.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct exception {};
int counter = 0;
struct mixin_counter
{
mixin_counter() { ++counter; }
mixin_counter(mixin_counter const&) { ++counter; }
~mixin_counter() { --counter; }
};
struct value_type : private mixin_counter
{
enum state_type
{
zero,
moved_from,
throwing_construction,
throwing_copy,
throwing_copy_assignment,
throwing_move,
throwing_move_assignment,
threw,
};
value_type() = default;
explicit value_type(state_type state_)
: state(state_)
{
throw_if(throwing_construction);
}
value_type(value_type const& other)
: state(other.state)
{
throw_if(throwing_copy);
}
value_type&
operator=(value_type const& other)
{
state = other.state;
throw_if(throwing_copy_assignment);
return *this;
}
value_type(value_type&& other)
: state(other.state)
{
other.state = moved_from;
throw_if(throwing_move);
}
value_type&
operator=(value_type&& other)
{
state = other.state;
other.state = moved_from;
throw_if(throwing_move_assignment);
return *this;
}
void throw_if(state_type match)
{
if(state == match)
{
state = threw;
throw exception {};
}
}
state_type state = zero;
};
int main()
{
using O = std::experimental::optional<value_type>;
using S = value_type::state_type;
auto const make = [](S s = S::zero) { return value_type { s }; };
enum outcome_type { nothrow, caught, bad_catch };
// Check value assignment for disengaged optional
{
O o;
value_type v = make(S::throwing_copy_assignment);
o = v;
VERIFY( o && o->state == S::throwing_copy_assignment );
}
{
O o;
value_type v = make(S::throwing_move_assignment);
o = std::move(v);
VERIFY( o && o->state == S::throwing_move_assignment );
}
{
outcome_type outcome {};
O o;
value_type v = make(S::throwing_copy);
try
{
o = v;
}
catch(exception const&)
{ outcome = caught; }
catch(...)
{ outcome = bad_catch; }
VERIFY( !o );
}
{
outcome_type outcome {};
O o;
value_type v = make(S::throwing_move);
try
{
o = std::move(v);
}
catch(exception const&)
{ outcome = caught; }
catch(...)
{ outcome = bad_catch; }
VERIFY( !o );
}
VERIFY( counter == 0 );
}
libstdc++-v3/testsuite/experimental/optional/assignment/4.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct exception {};
int counter = 0;
struct mixin_counter
{
mixin_counter() { ++counter; }
mixin_counter(mixin_counter const&) { ++counter; }
~mixin_counter() { --counter; }
};
struct value_type : private mixin_counter
{
enum state_type
{
zero,
moved_from,
throwing_construction,
throwing_copy,
throwing_copy_assignment,
throwing_move,
throwing_move_assignment,
threw,
};
value_type() = default;
explicit value_type(state_type state_)
: state(state_)
{
throw_if(throwing_construction);
}
value_type(value_type const& other)
: state(other.state)
{
throw_if(throwing_copy);
}
value_type&
operator=(value_type const& other)
{
state = other.state;
throw_if(throwing_copy_assignment);
return *this;
}
value_type(value_type&& other)
: state(other.state)
{
other.state = moved_from;
throw_if(throwing_move);
}
value_type&
operator=(value_type&& other)
{
state = other.state;
other.state = moved_from;
throw_if(throwing_move_assignment);
return *this;
}
void throw_if(state_type match)
{
if(state == match)
{
state = threw;
throw exception {};
}
}
state_type state = zero;
};
int main()
{
using O = std::experimental::optional<value_type>;
using S = value_type::state_type;
auto const make = [](S s = S::zero) { return value_type { s }; };
enum outcome_type { nothrow, caught, bad_catch };
// Check value assignment for engaged optional
{
O o = make();
value_type v = make(S::throwing_copy);
o = v;
VERIFY( o && o->state == S::throwing_copy);
}
{
O o = make();
value_type v = make(S::throwing_move);
o = std::move(v);
VERIFY( o && o->state == S::throwing_move);
}
{
outcome_type outcome {};
O o = make();
value_type v = make(S::throwing_copy_assignment);
try
{
o = v;
}
catch(exception const&)
{ outcome = caught; }
catch(...)
{ outcome = bad_catch; }
VERIFY( o && o->state == S::threw );
}
{
outcome_type outcome {};
O o = make();
value_type v = make(S::throwing_move_assignment);
try
{
o = std::move(v);
}
catch(exception const&)
{ outcome = caught; }
catch(...)
{ outcome = bad_catch; }
VERIFY( o && o->state == S::threw );
}
VERIFY( counter == 0 );
}
libstdc++-v3/testsuite/experimental/optional/assignment/5.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
int counter = 0;
struct mixin_counter
{
mixin_counter() { ++counter; }
mixin_counter(mixin_counter const&) { ++counter; }
~mixin_counter() { --counter; }
};
struct value_type : private mixin_counter { };
int main()
{
using O = std::experimental::optional<value_type>;
// Check std::experimental::nullopt_t and 'default' (= {}) assignment
{
O o;
o = std::experimental::nullopt;
VERIFY( !o );
}
{
O o { std::experimental::in_place };
o = std::experimental::nullopt;
VERIFY( !o );
}
{
O o;
o = {};
VERIFY( !o );
}
{
O o { std::experimental::in_place };
o = {};
VERIFY( !o );
}
VERIFY( counter == 0 );
}
libstdc++-v3/testsuite/experimental/optional/assignment/6.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
int counter = 0;
struct mixin_counter
{
mixin_counter() { ++counter; }
mixin_counter(mixin_counter const&) { ++counter; }
~mixin_counter() { --counter; }
};
struct value_type : private mixin_counter
{
value_type() = default;
value_type(int) : state(1) { }
value_type(std::initializer_list<char>, const char*) : state(2) { }
int state = 0;
};
int main()
{
using O = std::experimental::optional<value_type>;
// Check emplace
{
O o;
o.emplace();
VERIFY( o && o->state == 0 );
}
{
O o { std::experimental::in_place, 0 };
o.emplace();
VERIFY( o && o->state == 0 );
}
{
O o;
o.emplace(0);
VERIFY( o && o->state == 1 );
}
{
O o { std::experimental::in_place };
o.emplace(0);
VERIFY( o && o->state == 1 );
}
{
O o;
o.emplace({ 'a' }, "");
VERIFY( o && o->state == 2 );
}
{
O o { std::experimental::in_place };
o.emplace({ 'a' }, "");
VERIFY( o && o->state == 2 );
}
static_assert( !std::is_constructible<O, std::initializer_list<int>, int>(), "" );
VERIFY( counter == 0 );
}
libstdc++-v3/testsuite/experimental/optional/cons/copy.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct tracker
{
tracker(int value) : value(value) { ++count; }
~tracker() { --count; }
tracker(tracker const& other) : value(other.value) { ++count; }
tracker(tracker&& other) : value(other.value)
{
other.value = -1;
++count;
}
tracker& operator=(tracker const&) = default;
tracker& operator=(tracker&&) = default;
int value;
static int count;
};
int tracker::count = 0;
struct exception { };
struct throwing_copy
{
throwing_copy() = default;
throwing_copy(throwing_copy const&) { throw exception {}; }
};
int main()
{
// [20.5.4.1] Constructors
{
std::experimental::optional<long> o;
auto copy = o;
VERIFY( !copy );
VERIFY( !o );
}
{
std::experimental::optional<long> o { std::experimental::in_place, 0x1234ABCDF1E2D3C4 };
auto copy = o;
VERIFY( copy );
VERIFY( *copy == 0x1234ABCDF1E2D3C4 );
VERIFY( o && o == 0x1234ABCDF1E2D3C4 );
}
{
std::experimental::optional<tracker> o;
auto copy = o;
VERIFY( !copy );
VERIFY( tracker::count == 0 );
VERIFY( !o );
}
{
std::experimental::optional<tracker> o { std::experimental::in_place, 333 };
auto copy = o;
VERIFY( copy );
VERIFY( copy->value == 333 );
VERIFY( tracker::count == 2 );
VERIFY( o && o->value == 333 );
}
enum outcome { nothrow, caught, bad_catch };
{
outcome result = nothrow;
std::experimental::optional<throwing_copy> o;
try
{
auto copy = o;
}
catch(exception const&)
{ result = caught; }
catch(...)
{ result = bad_catch; }
VERIFY( result == nothrow );
}
{
outcome result = nothrow;
std::experimental::optional<throwing_copy> o { std::experimental::in_place };
try
{
auto copy = o;
}
catch(exception const&)
{ result = caught; }
catch(...)
{ result = bad_catch; }
VERIFY( result == caught );
}
VERIFY( tracker::count == 0 );
}
libstdc++-v3/testsuite/experimental/optional/cons/default.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct tracker
{
tracker() { ++count; }
~tracker() { --count; }
tracker(tracker const&) { ++count; }
tracker(tracker&&) { ++count; }
tracker& operator=(tracker const&) = default;
tracker& operator=(tracker&&) = default;
static int count;
};
int tracker::count = 0;
int main()
{
// [20.5.4.1] Constructors
{
std::experimental::optional<tracker> o;
VERIFY( !o );
}
{
std::experimental::optional<tracker> o {};
VERIFY( !o );
}
{
std::experimental::optional<tracker> o = {};
VERIFY( !o );
}
VERIFY( tracker::count == 0 );
}
libstdc++-v3/testsuite/experimental/optional/cons/move.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct tracker
{
tracker(int value) : value(value) { ++count; }
~tracker() { --count; }
tracker(tracker const& other) : value(other.value) { ++count; }
tracker(tracker&& other) : value(other.value)
{
other.value = -1;
++count;
}
tracker& operator=(tracker const&) = default;
tracker& operator=(tracker&&) = default;
int value;
static int count;
};
int tracker::count = 0;
struct exception { };
struct throwing_move
{
throwing_move() = default;
throwing_move(throwing_move const&) { throw exception {}; }
};
int main()
{
// [20.5.4.1] Constructors
{
std::experimental::optional<long> o;
auto moved_to = std::move(o);
VERIFY( !moved_to );
VERIFY( !o );
}
{
std::experimental::optional<long> o { std::experimental::in_place, 0x1234ABCDF1E2D3C4 };
auto moved_to = std::move(o);
VERIFY( moved_to );
VERIFY( *moved_to == 0x1234ABCDF1E2D3C4 );
VERIFY( o && *o == 0x1234ABCDF1E2D3C4 );
}
{
std::experimental::optional<tracker> o;
auto moved_to = std::move(o);
VERIFY( !moved_to );
VERIFY( tracker::count == 0 );
VERIFY( !o );
}
{
std::experimental::optional<tracker> o { std::experimental::in_place, 333 };
auto moved_to = std::move(o);
VERIFY( moved_to );
VERIFY( moved_to->value == 333 );
VERIFY( tracker::count == 2 );
VERIFY( o && o->value == -1 );
}
enum outcome { nothrow, caught, bad_catch };
{
outcome result = nothrow;
std::experimental::optional<throwing_move> o;
try
{
auto moved_to = std::move(o);
}
catch(exception const&)
{ result = caught; }
catch(...)
{ result = bad_catch; }
VERIFY( result == nothrow );
}
{
outcome result = nothrow;
std::experimental::optional<throwing_move> o { std::experimental::in_place };
try
{
auto moved_to = std::move(o);
}
catch(exception const&)
{ result = caught; }
catch(...)
{ result = bad_catch; }
VERIFY( result == caught );
}
VERIFY( tracker::count == 0 );
}
libstdc++-v3/testsuite/experimental/optional/cons/value.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
#include <vector>
struct tracker
{
tracker(int value) : value(value) { ++count; }
~tracker() { --count; }
tracker(tracker const& other) : value(other.value) { ++count; }
tracker(tracker&& other) : value(other.value)
{
other.value = -1;
++count;
}
tracker& operator=(tracker const&) = default;
tracker& operator=(tracker&&) = default;
int value;
static int count;
};
int tracker::count = 0;
struct exception { };
struct throwing_construction
{
explicit throwing_construction(bool propagate) : propagate(propagate) { }
throwing_construction(throwing_construction const& other)
: propagate(other.propagate)
{
if(propagate)
throw exception {};
}
bool propagate;
};
int main()
{
// [20.5.4.1] Constructors
{
auto i = 0x1234ABCDF1E2D3C4;
std::experimental::optional<long> o { i };
VERIFY( o );
VERIFY( *o == 0x1234ABCDF1E2D3C4 );
VERIFY( i == 0x1234ABCDF1E2D3C4 );
}
{
auto i = 0x1234ABCDF1E2D3C4;
std::experimental::optional<long> o = i;
VERIFY( o );
VERIFY( *o == 0x1234ABCDF1E2D3C4 );
VERIFY( i == 0x1234ABCDF1E2D3C4 );
}
{
auto i = 0x1234ABCDF1E2D3C4;
std::experimental::optional<long> o = { i };
VERIFY( o );
VERIFY( *o == 0x1234ABCDF1E2D3C4 );
VERIFY( i == 0x1234ABCDF1E2D3C4 );
}
{
auto i = 0x1234ABCDF1E2D3C4;
std::experimental::optional<long> o { std::move(i) };
VERIFY( o );
VERIFY( *o == 0x1234ABCDF1E2D3C4 );
VERIFY( i == 0x1234ABCDF1E2D3C4 );
}
{
auto i = 0x1234ABCDF1E2D3C4;
std::experimental::optional<long> o = std::move(i);
VERIFY( o );
VERIFY( *o == 0x1234ABCDF1E2D3C4 );
VERIFY( i == 0x1234ABCDF1E2D3C4 );
}
{
auto i = 0x1234ABCDF1E2D3C4;
std::experimental::optional<long> o = { std::move(i) };
VERIFY( o );
VERIFY( *o == 0x1234ABCDF1E2D3C4 );
VERIFY( i == 0x1234ABCDF1E2D3C4 );
}
{
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
std::experimental::optional<std::vector<int>> o { v };
VERIFY( !v.empty() );
VERIFY( o->size() == 6 );
}
{
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
std::experimental::optional<std::vector<int>> o = v;
VERIFY( !v.empty() );
VERIFY( o->size() == 6 );
}
{
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
std::experimental::optional<std::vector<int>> o { v };
VERIFY( !v.empty() );
VERIFY( o->size() == 6 );
}
{
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
std::experimental::optional<std::vector<int>> o { std::move(v) };
VERIFY( v.empty() );
VERIFY( o->size() == 6 );
}
{
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
std::experimental::optional<std::vector<int>> o = std::move(v);
VERIFY( v.empty() );
VERIFY( o->size() == 6 );
}
{
std::vector<int> v = { 0, 1, 2, 3, 4, 5 };
std::experimental::optional<std::vector<int>> o { std::move(v) };
VERIFY( v.empty() );
VERIFY( o->size() == 6 );
}
{
tracker t { 333 };
std::experimental::optional<tracker> o = t;
VERIFY( o->value == 333 );
VERIFY( tracker::count == 2 );
VERIFY( t.value == 333 );
}
{
tracker t { 333 };
std::experimental::optional<tracker> o = std::move(t);
VERIFY( o->value == 333 );
VERIFY( tracker::count == 2 );
VERIFY( t.value == -1 );
}
enum outcome { nothrow, caught, bad_catch };
{
outcome result = nothrow;
throwing_construction t { false };
try
{
std::experimental::optional<throwing_construction> o { t };
}
catch(exception const&)
{ result = caught; }
catch(...)
{ result = bad_catch; }
VERIFY( result == nothrow );
}
{
outcome result = nothrow;
throwing_construction t { true };
try
{
std::experimental::optional<throwing_construction> o { t };
}
catch(exception const&)
{ result = caught; }
catch(...)
{ result = bad_catch; }
VERIFY( result == caught );
}
{
outcome result = nothrow;
throwing_construction t { false };
try
{
std::experimental::optional<throwing_construction> o { std::move(t) };
}
catch(exception const&)
{ result = caught; }
catch(...)
{ result = bad_catch; }
VERIFY( result == nothrow );
}
{
outcome result = nothrow;
throwing_construction t { true };
try
{
std::experimental::optional<throwing_construction> o { std::move(t) };
}
catch(exception const&)
{ result = caught; }
catch(...)
{ result = bad_catch; }
VERIFY( result == caught );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/cons/default.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
int main()
{
// [20.5.4.1] Constructors
{
constexpr std::experimental::optional<int> o;
static_assert( !o, "" );
}
{
constexpr std::experimental::optional<int> o {};
static_assert( !o, "" );
}
{
constexpr std::experimental::optional<int> o = {};
static_assert( !o, "" );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/cons/value.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
int main()
{
// [20.5.4.1] Constructors
{
constexpr auto i = 0x1234ABCDF1E2D3C4;
constexpr std::experimental::optional<long> o { i };
static_assert( o, "" );
static_assert( *o == 0x1234ABCDF1E2D3C4, "" );
}
{
constexpr auto i = 0x1234ABCDF1E2D3C4;
constexpr std::experimental::optional<long> o = i;
static_assert( o, "" );
static_assert( *o == 0x1234ABCDF1E2D3C4, "" );
}
{
constexpr auto i = 0x1234ABCDF1E2D3C4;
constexpr std::experimental::optional<long> o = { i };
static_assert( o, "" );
static_assert( *o == 0x1234ABCDF1E2D3C4, "" );
}
{
constexpr auto i = 0x1234ABCDF1E2D3C4;
constexpr std::experimental::optional<long> o { std::move(i) };
static_assert( o, "" );
static_assert( *o == 0x1234ABCDF1E2D3C4, "" );
}
{
constexpr auto i = 0x1234ABCDF1E2D3C4;
constexpr std::experimental::optional<long> o = std::move(i);
static_assert( o, "" );
static_assert( *o == 0x1234ABCDF1E2D3C4, "" );
}
{
constexpr auto i = 0x1234ABCDF1E2D3C4;
constexpr std::experimental::optional<long> o = { std::move(i) };
static_assert( o, "" );
static_assert( *o == 0x1234ABCDF1E2D3C4, "" );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/in_place.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
int main()
{
// [20.5.5] In-place construction
static_assert( std::is_same<decltype(std::experimental::in_place), const std::experimental::in_place_t>(), "" );
static_assert( std::is_empty<std::experimental::in_place_t>(), "" );
{
constexpr std::experimental::optional<int> o { std::experimental::in_place };
static_assert( o, "" );
static_assert( *o == int {}, "" );
static_assert( !std::is_convertible<std::experimental::in_place_t, std::experimental::optional<int>>(), "" );
}
{
constexpr std::experimental::optional<int> o { std::experimental::in_place, 42 };
static_assert( o, "" );
static_assert( *o == 42, "" );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/make_optional.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// XFAIL pending resolution of PR libstdc++/58777
// { dg-do compile { xfail *-*-* } }
// { dg-excess-errors "" }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
int main()
{
constexpr int i = 42;
constexpr auto o = std::experimental::make_optional(i);
static_assert( std::is_same<decltype(o), const std::experimental::optional<int>>(), "" );
static_assert( o && *o == 42, "" );
static_assert( &*o != &i, "" );
}
libstdc++-v3/testsuite/experimental/optional/constexpr/nullopt.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
int main()
{
// [20.5.6] Disengaged state indicator
static_assert( std::is_same<decltype(std::experimental::nullopt), const std::experimental::nullopt_t>(), "" );
static_assert( std::is_empty<std::experimental::nullopt_t>(), "" );
static_assert( std::is_literal_type<std::experimental::nullopt_t>(), "" );
static_assert( !std::is_default_constructible<std::experimental::nullopt_t>(), "" );
{
constexpr std::experimental::optional<int> o = std::experimental::nullopt;
static_assert( !o, "" );
}
{
constexpr std::experimental::optional<int> o = { std::experimental::nullopt };
static_assert( !o, "" );
}
{
constexpr std::experimental::optional<int> o { std::experimental::nullopt };
static_assert( !o, "" );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/observers/1.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct value_type
{
int i;
};
int main()
{
constexpr std::experimental::optional<value_type> o { value_type { 51 } };
static_assert( (*o).i == 51, "" );
}
libstdc++-v3/testsuite/experimental/optional/constexpr/observers/2.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// XFAIL pending resolution of PR libstdc++/58777
// { dg-do compile { xfail *-*-* } }
// { dg-excess-errors "" }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct value_type
{
int i;
};
int main()
{
constexpr std::experimental::optional<value_type> o { value_type { 51 } };
static_assert( o->i == 51, "" );
static_assert( o->i == (*o).i, "" );
static_assert( &o->i == &(*o).i, "" );
}
libstdc++-v3/testsuite/experimental/optional/constexpr/observers/3.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// XFAIL pending resolution of PR libstdc++/58777
// { dg-do compile { xfail *-*-* } }
// { dg-excess-errors "" }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct value_type
{
int i;
};
int main()
{
constexpr std::experimental::optional<value_type> o { value_type { 51 } };
static_assert( o.value().i == 51, "" );
static_assert( o.value().i == (*o).i, "" );
static_assert( &o.value().i == &(*o).i, "" );
}
libstdc++-v3/testsuite/experimental/optional/constexpr/observers/4.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct value_type
{
int i;
};
int main()
{
constexpr std::experimental::optional<value_type> o { value_type { 51 } };
constexpr value_type fallback { 3 };
static_assert( o.value_or(fallback).i == 51, "" );
static_assert( o.value_or(fallback).i == (*o).i, "" );
}
libstdc++-v3/testsuite/experimental/optional/constexpr/observers/5.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct value_type
{
int i;
};
int main()
{
{
constexpr std::experimental::optional<value_type> o = std::experimental::nullopt;
static_assert( !o, "" );
}
{
constexpr std::experimental::optional<value_type> o { value_type { 51 } };
static_assert( o, "" );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/relops/1.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
namespace ns
{
struct value_type
{
int i;
const char* s;
};
constexpr bool
strcmp(const char* lhs, const char* rhs)
{
return *lhs == *rhs && (!*lhs || strcmp(lhs + 1, rhs + 1));
}
constexpr bool
strrel(const char* lhs, const char* rhs)
{
return (*rhs && (!*lhs || (*lhs < *rhs)))
|| ((*lhs && *rhs && !(*rhs < *lhs)) && strrel(lhs + 1, rhs + 1));
}
constexpr bool
operator==(value_type const& lhs, value_type const& rhs)
{ return (lhs.i == rhs.i) && strcmp(lhs.s, rhs.s); }
constexpr bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
constexpr bool
operator<(value_type const& lhs, value_type const& rhs)
{ return (lhs.i < rhs.i) || (!(rhs.i < lhs.i) && strrel(lhs.s, rhs.s)); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
{
constexpr O o, p;
static_assert( o == p, "" );
static_assert( !(o != p), "" );
}
{
constexpr O o { value_type { 42, "forty-two" } }, p;
static_assert( !(o == p), "" );
static_assert( o != p, "" );
}
{
constexpr O o, p { value_type { 42, "forty-two" } };
static_assert( !(o == p), "" );
static_assert( o != p, "" );
}
{
constexpr O o { value_type { 11, "eleventy" } }, p { value_type { 42, "forty-two" } };
static_assert( !(o == p), "" );
static_assert( o != p, "" );
}
{
constexpr O o { value_type { 42, "forty-two" } }, p { value_type { 11, "eleventy" } };
static_assert( !(o == p), "" );
static_assert( o != p, "" );
}
{
constexpr O o { value_type { 42, "forty-two" } }, p { value_type { 42, "forty-two" } };
static_assert( o == p, "" );
static_assert( !(o != p), "" );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/relops/2.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
namespace ns
{
struct value_type
{
int i;
const char* s;
};
constexpr bool
strcmp(const char* lhs, const char* rhs)
{
return *lhs == *rhs && (!*lhs || strcmp(lhs + 1, rhs + 1));
}
constexpr bool
strrel(const char* lhs, const char* rhs)
{
return (*rhs && (!*lhs || (*lhs < *rhs)))
|| ((*lhs && *rhs && !(*rhs < *lhs)) && strrel(lhs + 1, rhs + 1));
}
constexpr bool
operator==(value_type const& lhs, value_type const& rhs)
{ return (lhs.i == rhs.i) && strcmp(lhs.s, rhs.s); }
constexpr bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
constexpr bool
operator<(value_type const& lhs, value_type const& rhs)
{ return (lhs.i < rhs.i) || (!(rhs.i < lhs.i) && strrel(lhs.s, rhs.s)); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
{
constexpr O o, p;
static_assert( !(o < p), "" );
static_assert( !(o > p), "" );
static_assert( o <= p, "" );
static_assert( o >= p, "" );
}
{
constexpr O o { value_type { 42, "forty-two" } }, p;
static_assert( !(o < p), "" );
static_assert( o > p, "" );
static_assert( !(o <= p), "" );
static_assert( o >= p, "" );
}
{
constexpr O o, p { value_type { 42, "forty-two" } };
static_assert( o < p, "" );
static_assert( !(o > p), "" );
static_assert( o <= p, "" );
static_assert( !(o >= p), "" );
}
{
constexpr O o { value_type { 11, "eleventy" } }, p { value_type { 42, "forty-two" } };
static_assert( o < p, "" );
static_assert( !(o > p), "" );
static_assert( o <= p, "" );
static_assert( !(o >= p), "" );
}
{
constexpr O o { value_type { 42, "forty-two" } }, p { value_type { 11, "eleventy" } };
static_assert( !(o < p), "" );
static_assert( o > p, "" );
static_assert( !(o <= p), "" );
static_assert( o >= p, "" );
}
{
constexpr O o { value_type { 42, "forty-two" } }, p { value_type { 42, "forty-two" } };
static_assert( !(o < p), "" );
static_assert( !(o > p), "" );
static_assert( o <= p, "" );
static_assert( o >= p, "" );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/relops/3.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
namespace ns
{
struct value_type
{
int i;
const char* s;
};
constexpr bool
strcmp(const char* lhs, const char* rhs)
{
return *lhs == *rhs && (!*lhs || strcmp(lhs + 1, rhs + 1));
}
constexpr bool
strrel(const char* lhs, const char* rhs)
{
return (*rhs && (!*lhs || (*lhs < *rhs)))
|| ((*lhs && *rhs && !(*rhs < *lhs)) && strrel(lhs + 1, rhs + 1));
}
constexpr bool
operator==(value_type const& lhs, value_type const& rhs)
{ return (lhs.i == rhs.i) && strcmp(lhs.s, rhs.s); }
constexpr bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
constexpr bool
operator<(value_type const& lhs, value_type const& rhs)
{ return (lhs.i < rhs.i) || (!(rhs.i < lhs.i) && strrel(lhs.s, rhs.s)); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
constexpr value_type reference { 42, "forty-two" };
{
constexpr O o;
static_assert( !(o == reference), "" );
static_assert( !(reference == o), "" );
static_assert( o != reference, "" );
static_assert( reference != o, "" );
}
{
constexpr O o { value_type { 11, "eleventy" } };
static_assert( !(o == reference), "" );
static_assert( !(reference == o), "" );
static_assert( o != reference, "" );
static_assert( reference != o, "" );
}
{
constexpr O o { value_type { 42, "forty-two" } };
static_assert( o == reference, "" );
static_assert( reference == o, "" );
static_assert( !(o != reference), "" );
static_assert( !(reference != o), "" );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/relops/4.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
namespace ns
{
struct value_type
{
int i;
const char* s;
};
constexpr bool
strcmp(const char* lhs, const char* rhs)
{
return *lhs == *rhs && (!*lhs || strcmp(lhs + 1, rhs + 1));
}
constexpr bool
strrel(const char* lhs, const char* rhs)
{
return (*rhs && (!*lhs || (*lhs < *rhs)))
|| ((*lhs && *rhs && !(*rhs < *lhs)) && strrel(lhs + 1, rhs + 1));
}
constexpr bool
operator==(value_type const& lhs, value_type const& rhs)
{ return (lhs.i == rhs.i) && strcmp(lhs.s, rhs.s); }
constexpr bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
constexpr bool
operator<(value_type const& lhs, value_type const& rhs)
{ return (lhs.i < rhs.i) || (!(rhs.i < lhs.i) && strrel(lhs.s, rhs.s)); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
constexpr value_type reference { 42, "forty-two" };
{
constexpr O o;
static_assert( o < reference, "" );
static_assert( !(reference < o), "" );
static_assert( !(o > reference), "" );
static_assert( reference > o, "" );
static_assert( o <= reference, "" );
static_assert( !(reference <= o), "" );
static_assert( !(o >= reference), "" );
static_assert( reference >= o, "" );
}
{
constexpr O o { value_type { 11, "eleventy" } };
static_assert( o < reference, "" );
static_assert( !(reference < o), "" );
static_assert( !(o > reference), "" );
static_assert( reference > o, "" );
static_assert( o <= reference, "" );
static_assert( !(reference <= o), "" );
static_assert( !(o >= reference), "" );
static_assert( reference >= o, "" );
}
{
constexpr O o { value_type { 42, "forty-two" } };
static_assert( !(o < reference), "" );
static_assert( !(reference < o), "" );
static_assert( !(o > reference), "" );
static_assert( !(reference > o), "" );
static_assert( o <= reference, "" );
static_assert( reference <= o, "" );
static_assert( o >= reference, "" );
static_assert( reference >= o, "" );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/relops/5.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
namespace ns
{
struct value_type
{
int i;
const char* s;
};
constexpr bool
strcmp(const char* lhs, const char* rhs)
{
return *lhs == *rhs && (!*lhs || strcmp(lhs + 1, rhs + 1));
}
constexpr bool
strrel(const char* lhs, const char* rhs)
{
return (*rhs && (!*lhs || (*lhs < *rhs)))
|| ((*lhs && *rhs && !(*rhs < *lhs)) && strrel(lhs + 1, rhs + 1));
}
constexpr bool
operator==(value_type const& lhs, value_type const& rhs)
{ return (lhs.i == rhs.i) && strcmp(lhs.s, rhs.s); }
constexpr bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
constexpr bool
operator<(value_type const& lhs, value_type const& rhs)
{ return (lhs.i < rhs.i) || (!(rhs.i < lhs.i) && strrel(lhs.s, rhs.s)); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
using std::experimental::nullopt;
{
constexpr O o;
static_assert( o == nullopt, "" );
static_assert( nullopt == o, "" );
static_assert( !(o != nullopt), "" );
static_assert( !(nullopt != o), "" );
}
{
constexpr O o { std::experimental::in_place };
static_assert( !(o == nullopt), "" );
static_assert( !(nullopt == o), "" );
static_assert( o != nullopt, "" );
static_assert( nullopt != o, "" );
}
}
libstdc++-v3/testsuite/experimental/optional/constexpr/relops/6.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do compile }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
namespace ns
{
struct value_type
{
int i;
const char* s;
};
constexpr bool
strcmp(const char* lhs, const char* rhs)
{
return *lhs == *rhs && (!*lhs || strcmp(lhs + 1, rhs + 1));
}
constexpr bool
strrel(const char* lhs, const char* rhs)
{
return (*rhs && (!*lhs || (*lhs < *rhs)))
|| ((*lhs && *rhs && !(*rhs < *lhs)) && strrel(lhs + 1, rhs + 1));
}
constexpr bool
operator==(value_type const& lhs, value_type const& rhs)
{ return (lhs.i == rhs.i) && strcmp(lhs.s, rhs.s); }
constexpr bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
constexpr bool
operator<(value_type const& lhs, value_type const& rhs)
{ return (lhs.i < rhs.i) || (!(rhs.i < lhs.i) && strrel(lhs.s, rhs.s)); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
using std::experimental::nullopt;
{
constexpr O o;
static_assert( !(o < nullopt), "" );
static_assert( !(nullopt < o), "" );
static_assert( !(o > nullopt), "" );
static_assert( !(nullopt > o), "" );
static_assert( o <= nullopt, "" );
static_assert( nullopt <= o, "" );
static_assert( o >= nullopt, "" );
static_assert( nullopt >= o, "" );
}
{
constexpr O o { std::experimental::in_place };
static_assert( !(o < nullopt), "" );
static_assert( nullopt < o, "" );
static_assert( o > nullopt, "" );
static_assert( !(nullopt > o), "" );
static_assert( !(o <= nullopt), "" );
static_assert( nullopt <= o, "" );
static_assert( o >= nullopt, "" );
static_assert( !(nullopt >= o), "" );
}
}
libstdc++-v3/testsuite/experimental/optional/in_place.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
#include <vector>
int main()
{
// [20.5.5] In-place construction
static_assert( std::is_same<decltype(std::experimental::in_place), const std::experimental::in_place_t>(), "" );
static_assert( std::is_empty<std::experimental::in_place_t>(), "" );
{
std::experimental::optional<int> o { std::experimental::in_place };
VERIFY( o );
VERIFY( *o == int() );
static_assert( !std::is_convertible<std::experimental::in_place_t, std::experimental::optional<int>>(), "" );
}
{
std::experimental::optional<int> o { std::experimental::in_place, 42 };
VERIFY( o );
VERIFY( *o == 42 );
}
{
std::experimental::optional<std::vector<int>> o { std::experimental::in_place, 18, 4 };
VERIFY( o );
VERIFY( o->size() == 18 );
VERIFY( (*o)[17] == 4 );
}
{
std::experimental::optional<std::vector<int>> o { std::experimental::in_place, { 18, 4 } };
VERIFY( o );
VERIFY( o->size() == 2 );
VERIFY( (*o)[0] == 18 );
}
{
std::experimental::optional<std::vector<int>> o { std::experimental::in_place, { 18, 4 }, std::allocator<int> {} };
VERIFY( o );
VERIFY( o->size() == 2 );
VERIFY( (*o)[0] == 18 );
}
}
libstdc++-v3/testsuite/experimental/optional/make_optional.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
int main()
{
const int i = 42;
auto o = std::experimental::make_optional(i);
static_assert( std::is_same<decltype(o), std::experimental::optional<int>>(), "" );
VERIFY( o && *o == 42 );
VERIFY( &*o != &i );
}
libstdc++-v3/testsuite/experimental/optional/nullopt.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
int main()
{
// [20.5.6] Disengaged state indicator
static_assert( std::is_same<decltype(std::experimental::nullopt), const std::experimental::nullopt_t>(), "" );
static_assert( std::is_empty<std::experimental::nullopt_t>(), "" );
static_assert( std::is_literal_type<std::experimental::nullopt_t>(), "" );
static_assert( !std::is_default_constructible<std::experimental::nullopt_t>(), "" );
{
std::experimental::optional<int> o = std::experimental::nullopt;
VERIFY( !o );
}
{
std::experimental::optional<int> o = { std::experimental::nullopt };
VERIFY( !o );
}
{
std::experimental::optional<int> o { std::experimental::nullopt };
VERIFY( !o );
}
}
libstdc++-v3/testsuite/experimental/optional/observers/1.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct value_type
{
int i;
};
int main()
{
std::experimental::optional<value_type> o { value_type { 51 } };
VERIFY( (*o).i == 51 );
}
libstdc++-v3/testsuite/experimental/optional/observers/2.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct value_type
{
int i;
};
int main()
{
std::experimental::optional<value_type> o { value_type { 51 } };
VERIFY( o->i == 51 );
VERIFY( o->i == (*o).i );
VERIFY( &o->i == &(*o).i );
}
libstdc++-v3/testsuite/experimental/optional/observers/3.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct value_type
{
int i;
};
int main()
{
{
std::experimental::optional<value_type> o { value_type { 51 } };
VERIFY( o.value().i == 51 );
VERIFY( o.value().i == (*o).i );
VERIFY( &o.value().i == &(*o).i );
}
{
enum outcome_type { nothrow, caught, bad_catch };
outcome_type outcome {};
std::experimental::optional<value_type> o = std::experimental::nullopt;
bool called = false;
auto const eat = [&called](int) { called = true; };
try
{
eat(o.value().i);
}
catch(std::experimental::bad_optional_access const&)
{ outcome = caught; }
catch(...)
{ outcome = bad_catch; }
VERIFY( outcome == caught );
VERIFY( !called );
}
}
libstdc++-v3/testsuite/experimental/optional/observers/4.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct value_type
{
int i;
};
int main()
{
std::experimental::optional<value_type> o { value_type { 51 } };
value_type fallback { 3 };
VERIFY( o.value_or(fallback).i == 51 );
VERIFY( o.value_or(fallback).i == (*o).i );
}
libstdc++-v3/testsuite/experimental/optional/observers/5.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct value_type
{
int i;
};
int main()
{
{
std::experimental::optional<value_type> o = std::experimental::nullopt;
VERIFY( !o );
}
{
std::experimental::optional<value_type> o { value_type { 51 } };
VERIFY( o );
}
}
libstdc++-v3/testsuite/experimental/optional/relops/1.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
#include <tuple>
#include <string>
namespace ns
{
struct value_type
{
int i;
std::string s;
};
bool
operator==(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) == std::tie(rhs.i, rhs.s); }
bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
bool
operator<(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) < std::tie(rhs.i, rhs.s); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
{
O o, p;
VERIFY( o == p );
VERIFY( !(o != p) );
}
{
O o { value_type { 42, "forty-two" } }, p;
VERIFY( !(o == p) );
VERIFY( o != p );
}
{
O o, p { value_type { 42, "forty-two" } };
VERIFY( !(o == p) );
VERIFY( o != p );
}
{
O o { value_type { 11, "eleventy" } }, p { value_type { 42, "forty-two" } };
VERIFY( !(o == p) );
VERIFY( o != p );
}
{
O o { value_type { 42, "forty-two" } }, p { value_type { 11, "eleventy" } };
VERIFY( !(o == p) );
VERIFY( o != p );
}
{
O o { value_type { 42, "forty-two" } }, p { value_type { 42, "forty-two" } };
VERIFY( o == p );
VERIFY( !(o != p) );
}
}
libstdc++-v3/testsuite/experimental/optional/relops/2.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
#include <tuple>
#include <string>
namespace ns
{
struct value_type
{
int i;
std::string s;
};
bool
operator==(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) == std::tie(rhs.i, rhs.s); }
bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
bool
operator<(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) < std::tie(rhs.i, rhs.s); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
{
O o, p;
VERIFY( !(o < p) );
VERIFY( !(o > p) );
VERIFY( o <= p );
VERIFY( o >= p );
}
{
O o { value_type { 42, "forty-two" } }, p;
VERIFY( !(o < p) );
VERIFY( o > p );
VERIFY( !(o <= p) );
VERIFY( o >= p );
}
{
O o, p { value_type { 42, "forty-two" } };
VERIFY( o < p );
VERIFY( !(o > p) );
VERIFY( o <= p );
VERIFY( !(o >= p) );
}
{
O o { value_type { 11, "eleventy" } }, p { value_type { 42, "forty-two" } };
VERIFY( o < p );
VERIFY( !(o > p) );
VERIFY( o <= p );
VERIFY( !(o >= p) );
}
{
O o { value_type { 42, "forty-two" } }, p { value_type { 11, "eleventy" } };
VERIFY( !(o < p) );
VERIFY( o > p );
VERIFY( !(o <= p) );
VERIFY( o >= p );
}
{
O o { value_type { 42, "forty-two" } }, p { value_type { 42, "forty-two" } };
VERIFY( !(o < p) );
VERIFY( !(o > p) );
VERIFY( o <= p );
VERIFY( o >= p );
}
}
libstdc++-v3/testsuite/experimental/optional/relops/3.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
#include <tuple>
#include <string>
namespace ns
{
struct value_type
{
int i;
std::string s;
};
bool
operator==(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) == std::tie(rhs.i, rhs.s); }
bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
bool
operator<(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) < std::tie(rhs.i, rhs.s); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
value_type const reference { 42, "forty-two" };
{
O o;
VERIFY( !(o == reference) );
VERIFY( !(reference == o) );
VERIFY( o != reference );
VERIFY( reference != o );
}
{
O o { value_type { 11, "eleventy" } };
VERIFY( !(o == reference) );
VERIFY( !(reference == o) );
VERIFY( o != reference );
VERIFY( reference != o );
}
{
O o { value_type { 42, "forty-two" } };
VERIFY( o == reference );
VERIFY( reference == o );
VERIFY( !(o != reference) );
VERIFY( !(reference != o) );
}
}
libstdc++-v3/testsuite/experimental/optional/relops/4.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
#include <tuple>
#include <string>
namespace ns
{
struct value_type
{
int i;
std::string s;
};
bool
operator==(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) == std::tie(rhs.i, rhs.s); }
bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
bool
operator<(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) < std::tie(rhs.i, rhs.s); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
value_type const reference { 42, "forty-two" };
{
O o;
VERIFY( o < reference );
VERIFY( !(reference < o) );
VERIFY( !(o > reference) );
VERIFY( reference > o );
VERIFY( o <= reference );
VERIFY( !(reference <= o) );
VERIFY( !(o >= reference) );
VERIFY( reference >= o );
}
{
O o { value_type { 11, "eleventy" } };
VERIFY( o < reference );
VERIFY( !(reference < o) );
VERIFY( !(o > reference) );
VERIFY( reference > o );
VERIFY( o <= reference );
VERIFY( !(reference <= o) );
VERIFY( !(o >= reference) );
VERIFY( reference >= o );
}
{
O o { value_type { 42, "forty-two" } };
VERIFY( !(o < reference) );
VERIFY( !(reference < o) );
VERIFY( !(o > reference) );
VERIFY( !(reference > o) );
VERIFY( o <= reference );
VERIFY( reference <= o );
VERIFY( o >= reference );
VERIFY( reference >= o );
}
}
libstdc++-v3/testsuite/experimental/optional/relops/5.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
#include <tuple>
#include <string>
namespace ns
{
struct value_type
{
int i;
std::string s;
};
bool
operator==(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) == std::tie(rhs.i, rhs.s); }
bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
bool
operator<(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) < std::tie(rhs.i, rhs.s); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
using std::experimental::nullopt;
{
O o;
VERIFY( o == nullopt );
VERIFY( nullopt == o );
VERIFY( !(o != nullopt) );
VERIFY( !(nullopt != o) );
}
{
O o { std::experimental::in_place };
VERIFY( !(o == nullopt) );
VERIFY( !(nullopt == o) );
VERIFY( o != nullopt );
VERIFY( nullopt != o );
}
}
libstdc++-v3/testsuite/experimental/optional/relops/6.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
#include <tuple>
#include <string>
namespace ns
{
struct value_type
{
int i;
std::string s;
};
bool
operator==(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) == std::tie(rhs.i, rhs.s); }
bool
operator!=(value_type const& lhs, value_type const& rhs)
{ return !(lhs == rhs); }
bool
operator<(value_type const& lhs, value_type const& rhs)
{ return std::tie(lhs.i, lhs.s) < std::tie(rhs.i, rhs.s); }
} // namespace ns
int main()
{
using ns::value_type;
using O = std::experimental::optional<value_type>;
using std::experimental::nullopt;
{
O o;
VERIFY( !(o < nullopt) );
VERIFY( !(nullopt < o) );
VERIFY( !(o > nullopt) );
VERIFY( !(nullopt > o) );
VERIFY( o <= nullopt );
VERIFY( nullopt <= o );
VERIFY( o >= nullopt );
VERIFY( nullopt >= o );
}
{
O o { std::experimental::in_place };
VERIFY( !(o < nullopt) );
VERIFY( nullopt < o );
VERIFY( o > nullopt );
VERIFY( !(nullopt > o) );
VERIFY( !(o <= nullopt) );
VERIFY( nullopt <= o );
VERIFY( o >= nullopt );
VERIFY( !(nullopt >= o) );
}
}
libstdc++-v3/testsuite/experimental/optional/requirements.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
#include <tuple>
struct trivially_destructible
{
trivially_destructible() = delete;
trivially_destructible(trivially_destructible const&) = delete;
trivially_destructible& operator=(trivially_destructible const&) = delete;
trivially_destructible(trivially_destructible&&) = delete;
trivially_destructible& operator=(trivially_destructible&&) = delete;
~trivially_destructible() noexcept = default;
};
static_assert( std::is_trivially_destructible<trivially_destructible>(), "" );
struct no_default_constructor
{
no_default_constructor() = delete;
};
struct no_copy_constructor
{
no_copy_constructor() = default;
no_copy_constructor(no_copy_constructor const&) = delete;
no_copy_constructor& operator=(no_copy_constructor const&) = default;
no_copy_constructor(no_copy_constructor&&) = default;
no_copy_constructor& operator=(no_copy_constructor&&) = default;
};
struct no_copy_assignment
{
no_copy_assignment() = default;
no_copy_assignment(no_copy_assignment const&) = default;
no_copy_assignment(no_copy_assignment&&) = default;
no_copy_assignment& operator=(no_copy_assignment&&) = default;
};
struct no_move_constructor
{
no_move_constructor() = default;
no_move_constructor(no_move_constructor const&) = default;
no_move_constructor& operator=(no_move_constructor const&) = default;
no_move_constructor(no_move_constructor&&) = delete;
no_move_constructor& operator=(no_move_constructor&&) = default;
};
struct no_move_assignment
{
no_move_assignment() = default;
no_move_assignment(no_move_assignment const&) = default;
no_move_assignment& operator=(no_move_assignment const&) = default;
no_move_assignment(no_move_assignment&&) = default;
no_move_assignment& operator=(no_move_assignment&&) = delete;
};
struct no_copy : no_copy_constructor, no_copy_assignment { };
struct no_move : no_move_constructor, no_move_assignment { };
// Laxest possible model of a value type for optional
struct only_destructible
{
only_destructible(only_destructible&&) = delete;
};
int main()
{
{
static_assert( std::is_trivially_destructible<std::experimental::optional<trivially_destructible>>(), "" );
}
{
using T = no_default_constructor;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( std::is_copy_constructible<O>(), "" );
{ O o; auto copy = o; }
static_assert( std::is_copy_assignable<O>(), "" );
{ O o, p; p = o; }
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_copy_constructor;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( !std::is_copy_constructible<O>(), "" );
static_assert( !std::is_copy_assignable<O>(), "" );
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_copy_assignment;
using O = std::experimental::optional<T>;
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( std::is_copy_constructible<O>(), "" );
{ O o; auto copy = o; }
static_assert( !std::is_copy_assignable<O>(), "" );
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_copy;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( !std::is_copy_constructible<O>(), "" );
static_assert( !std::is_copy_assignable<O>(), "" );
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_move_constructor;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( std::is_copy_constructible<O>(), "" );
{ O o; auto copy = o; }
static_assert( std::is_copy_assignable<O>(), "" );
/*
* T should be move constructible due to [12.8/11], which is a new rule in C++1y
* not yet implemented by GCC. Because there is already a special exception in C++11
* for the generation of the special members that GCC implements (at least some of the
* time), this does not affect the std::experimental::optional implementation however. So the assertion
* for T should be changed (or removed altogether) when the time comes, but the rest
* should however remain correct and unchanged.
*/
static_assert( !std::is_move_constructible<T>(), "" );
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_move_assignment;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( std::is_copy_constructible<O>(), "" );
{ O o; auto copy = o; }
static_assert( std::is_copy_assignable<O>(), "" );
{ O o, p; p = o; }
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
/*
* Paragraph 23 of same leads to a similar situation but with respect to move
* assignment.
*/
static_assert( !std::is_move_assignable<T>(), "" );
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_move;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( std::is_copy_constructible<O>(), "" );
{ O o; auto copy = o; }
static_assert( std::is_copy_assignable<O>(), "" );
{ O o, p; p = o; }
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = only_destructible;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( !std::is_copy_constructible<O>(), "" );
static_assert( !std::is_copy_assignable<O>(), "" );
static_assert( !std::is_move_constructible<O>(), "" );
static_assert( !std::is_move_assignable<O>(), "" );
}
{
/*
* Should not complain about 'invalid' specializations as long as
* they're not instantiated.
*/
using A = std::experimental::optional<int&>;
using B = std::experimental::optional<int&&>;
using C1 = std::experimental::optional<std::experimental::in_place_t>;
using C2 = std::experimental::optional<std::experimental::in_place_t const>;
using C3 = std::experimental::optional<std::experimental::in_place_t volatile>;
using C4 = std::experimental::optional<std::experimental::in_place_t const volatile>;
using D1 = std::experimental::optional<std::experimental::nullopt_t>;
using D2 = std::experimental::optional<std::experimental::nullopt_t const>;
using D3 = std::experimental::optional<std::experimental::nullopt_t volatile>;
using D4 = std::experimental::optional<std::experimental::nullopt_t const volatile>;
using X = std::tuple<A, B, C1, C2, C3, C4, D1, D2, D3, D4>;
}
{
std::experimental::optional<const int> o { 42 };
static_assert( std::is_same<decltype(o)::value_type, const int>(), "" );
VERIFY( o );
VERIFY( *o == 42 );
}
{
constexpr std::experimental::optional<const int> o { 33 };
static_assert( std::is_same<decltype(o)::value_type, const int>(), "" );
static_assert( o, "" );
static_assert( *o == 33, "" );
}
}
libstdc++-v3/testsuite/experimental/optional/swap/1.cc 0 → 100644
// { dg-options "-std=gnu++1y" }
// { dg-do run }
// Copyright (C) 2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a moved_to of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
struct exception {};
int counter = 0;
struct mixin_counter
{
mixin_counter() { ++counter; }
mixin_counter(mixin_counter const&) { ++counter; }
~mixin_counter() { --counter; }
};
namespace ns
{
struct value_type : private mixin_counter
{
explicit value_type(int state) : state(state) { }
int state;
};
int swaps = 0;
void
swap(value_type& lhs, value_type& rhs)
{
++swaps;
using std::swap;
swap(lhs.state, rhs.state);
}
} // namespace ns
int main()
{
using O = std::experimental::optional<ns::value_type>;
VERIFY( ns::swaps == 0 );
{
O o, p;
swap(o, p);
VERIFY( !o );
VERIFY( !p );
}
{
O o { std::experimental::in_place, 45 }, p;
swap(o, p);
VERIFY( !o );
VERIFY( p && p->state == 45 );
}
{
O o, p { std::experimental::in_place, 45 };
swap(o, p);
VERIFY( o && o->state == 45 );
VERIFY( !p );
}
{
O o { std::experimental::in_place, 167 }, p { std::experimental::in_place, 999 };
VERIFY( ns::swaps == 0 );
swap(o, p);
VERIFY( o && o->state == 999 );
VERIFY( p && p->state == 167 );
VERIFY( ns::swaps == 1 );
}
VERIFY( counter == 0 );
}
libstdc++-v3/testsuite/libstdc++-dg/conformance.exp
......@@ -60,6 +60,7 @@ if {[info exists tests_file] && [file exists $tests_file]} {
lappend subdirs "$srcdir/tr1"
lappend subdirs "$srcdir/tr2"
lappend subdirs "$srcdir/decimal"
lappend subdirs "$srcdir/experimental"
verbose "subdirs are $subdirs"
# Find all the tests.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment