FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

forward_list: New.

Browse source 
2008-10-15  Edward Smith-Rowland  <3dw4rd@verizon.net>

	* include/std/forward_list: New.
	* include/bits/forward_list.h: Likewise.
	* include/bits/forward_list.tcc: Likewise.
	* include/precompiled/stdc++.h: Modified to include forward_list.
	* include/Makefile.am: Add forward_list, forward_list.h, and
	forward_list.tcc.
	* include/Makefile.in: Regenerate.
	* testsuite/23_containers/forward_list/modifiers/1.cc: New.
	* testsuite/23_containers/forward_list/modifiers/2.cc: Likewise.
	* testsuite/23_containers/forward_list/modifiers/3.cc: Likewise.
	* testsuite/23_containers/forward_list/modifiers/4.cc: Likewise.
	* testsuite/23_containers/forward_list/modifiers/5.cc: Likewise.
	* testsuite/23_containers/forward_list/cons/1.cc: Likewise.
	* testsuite/23_containers/forward_list/cons/2.cc: Likewise.
	* testsuite/23_containers/forward_list/cons/3.cc: Likewise.
	* testsuite/23_containers/forward_list/cons/4.cc: Likewise.
	* testsuite/23_containers/forward_list/cons/5.cc: Likewise.
	* testsuite/23_containers/forward_list/cons/6.cc: Likewise.
	* testsuite/23_containers/forward_list/cons/7.cc: Likewise.
	* testsuite/23_containers/forward_list/cons/8.cc: Likewise.
	* testsuite/23_containers/forward_list/cons/9.cc: Likewise.
	* testsuite/23_containers/forward_list/requirements/1.cc: Likewise.
	* testsuite/23_containers/forward_list/operations/1.cc: Likewise.
	* testsuite/23_containers/forward_list/operations/2.cc: Likewise.
	* testsuite/23_containers/forward_list/operations/3.cc: Likewise.
	* testsuite/23_containers/forward_list/operations/4.cc: Likewise.
	* testsuite/23_containers/forward_list/operations/5.cc: Likewise.
	* testsuite/23_containers/forward_list/operations/6.cc: Likewise.
	* testsuite/23_containers/forward_list/operations/7.cc: Likewise.
	* testsuite/23_containers/forward_list/capacity/1.cc: Likewise.
	* testsuite/23_containers/forward_list/comparable.cc: Likewise.
	* testsuite/23_containers/forward_list/moveable.cc: Likewise.
	* testsuite/23_containers/headers/forward_list/synopsis.cc: Likewise.
	* testsuite/17_intro/headers/c++200x/all_multiple_inclusion.cc: Update.
	* testsuite/17_intro/headers/c++200x/all: Likewise.

From-SVN: r141146
This commit is contained in:
Edward Smith-Rowland 2008-10-15 16:48:13 +00:00 • committed by Paolo Carlini
parent 21c74256c3
commit 3a63c9cdfc
35 changed files with 3444 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
libstdc++-v3/ChangeLog
View file

@ -1,3 +1,41 @@
2008-10-15 Edward Smith-Rowland <3dw4rd@verizon.net>
* include/std/forward_list: New.
* include/bits/forward_list.h: Likewise.
* include/bits/forward_list.tcc: Likewise.
* include/precompiled/stdc++.h: Modified to include forward_list.
* include/Makefile.am: Add forward_list, forward_list.h, and
forward_list.tcc.
* include/Makefile.in: Regenerate.
* testsuite/23_containers/forward_list/modifiers/1.cc: New.
* testsuite/23_containers/forward_list/modifiers/2.cc: Likewise.
* testsuite/23_containers/forward_list/modifiers/3.cc: Likewise.
* testsuite/23_containers/forward_list/modifiers/4.cc: Likewise.
* testsuite/23_containers/forward_list/modifiers/5.cc: Likewise.
* testsuite/23_containers/forward_list/cons/1.cc: Likewise.
* testsuite/23_containers/forward_list/cons/2.cc: Likewise.
* testsuite/23_containers/forward_list/cons/3.cc: Likewise.
* testsuite/23_containers/forward_list/cons/4.cc: Likewise.
* testsuite/23_containers/forward_list/cons/5.cc: Likewise.
* testsuite/23_containers/forward_list/cons/6.cc: Likewise.
* testsuite/23_containers/forward_list/cons/7.cc: Likewise.
* testsuite/23_containers/forward_list/cons/8.cc: Likewise.
* testsuite/23_containers/forward_list/cons/9.cc: Likewise.
* testsuite/23_containers/forward_list/requirements/1.cc: Likewise.
* testsuite/23_containers/forward_list/operations/1.cc: Likewise.
* testsuite/23_containers/forward_list/operations/2.cc: Likewise.
* testsuite/23_containers/forward_list/operations/3.cc: Likewise.
* testsuite/23_containers/forward_list/operations/4.cc: Likewise.
* testsuite/23_containers/forward_list/operations/5.cc: Likewise.
* testsuite/23_containers/forward_list/operations/6.cc: Likewise.
* testsuite/23_containers/forward_list/operations/7.cc: Likewise.
* testsuite/23_containers/forward_list/capacity/1.cc: Likewise.
* testsuite/23_containers/forward_list/comparable.cc: Likewise.
* testsuite/23_containers/forward_list/moveable.cc: Likewise.
* testsuite/23_containers/headers/forward_list/synopsis.cc: Likewise.
* testsuite/17_intro/headers/c++200x/all_multiple_inclusion.cc: Update.
* testsuite/17_intro/headers/c++200x/all: Likewise.
2008-10-14 Paolo Carlini <paolo.carlini@oracle.com>
* include/bits/stl_list.h (_List_node<>::_List_node<>(_Args&&...)):

3
libstdc++-v3/include/Makefile.am
View file

@ -36,6 +36,7 @@ std_headers = \
${std_srcdir}/complex \
${std_srcdir}/condition_variable \
${std_srcdir}/deque \
${std_srcdir}/forward_list \
${std_srcdir}/fstream \
${std_srcdir}/functional \
${std_srcdir}/iomanip \
@ -87,6 +88,8 @@ bits_headers = \
${bits_srcdir}/concept_check.h \
${bits_srcdir}/cpp_type_traits.h \
${bits_srcdir}/deque.tcc \
${bits_srcdir}/forward_list.h \
${bits_srcdir}/forward_list.tcc \
${bits_srcdir}/fstream.tcc \
${bits_srcdir}/functexcept.h \
${bits_srcdir}/functional_hash.h \

3
libstdc++-v3/include/Makefile.in
View file

@ -302,6 +302,7 @@ std_headers = \
${std_srcdir}/complex \
${std_srcdir}/condition_variable \
${std_srcdir}/deque \
${std_srcdir}/forward_list \
${std_srcdir}/fstream \
${std_srcdir}/functional \
${std_srcdir}/iomanip \
@ -353,6 +354,8 @@ bits_headers = \
${bits_srcdir}/concept_check.h \
${bits_srcdir}/cpp_type_traits.h \
${bits_srcdir}/deque.tcc \
${bits_srcdir}/forward_list.h \
${bits_srcdir}/forward_list.tcc \
${bits_srcdir}/fstream.tcc \
${bits_srcdir}/functexcept.h \
${bits_srcdir}/functional_hash.h \

1342
libstdc++-v3/include/bits/forward_list.h Normal file
View file

File diff suppressed because it is too large Load diff

468
libstdc++-v3/include/bits/forward_list.tcc Normal file
View file

@ -0,0 +1,468 @@
// <forward_list.tcc> -*- C++ -*-
// Copyright (C) 2008 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 2, 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 COPYING. If not, write to
// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
// Boston, MA 02110-1301, USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/** @file forward_list.tcc
* This is a Standard C++ Library header.
*/
#ifndef _FORWARD_LIST_TCC
#define _FORWARD_LIST_TCC 1
_GLIBCXX_BEGIN_NAMESPACE(std)
/**
* @brief Sort the singly linked list starting after this node.
* This node is assumed to be an empty head node (of type
* _Fwd_list_node_base).
*/
template<typename _Tp>
template<typename _Comp>
void
_Fwd_list_node<_Tp>::
_M_sort_after(_Comp __comp)
{
// If `next' is 0, return immediately.
_Fwd_list_node* __list = static_cast<_Fwd_list_node*>(this->_M_next);
if (!__list)
return;
unsigned long __insize = 1;
while (1)
{
_Fwd_list_node* __p = __list;
__list = 0;
_Fwd_list_node* __tail = 0;
// Count number of merges we do in this pass.
unsigned long __nmerges = 0;
while (__p)
{
++__nmerges;
// There exists a merge to be done.
// Step `insize' places along from p.
_Fwd_list_node* __q = __p;
unsigned long __psize = 0;
for (unsigned long __i = 0; __i < __insize; ++__i)
{
++__psize;
__q = static_cast<_Fwd_list_node*>(__q->_M_next);
if (!__q)
break;
}
// If q hasn't fallen off end, we have two lists to merge.
unsigned long __qsize = __insize;
// Now we have two lists; merge them.
while (__psize > 0 || (__qsize > 0 && __q))
{
// Decide whether next node of merge comes from p or q.
_Fwd_list_node<_Tp>* __e;
if (__psize == 0)
{
// p is empty; e must come from q.
__e = __q;
__q = static_cast<_Fwd_list_node*>(__q->_M_next);
--__qsize;
}
else if (__qsize == 0 || !__q)
{
// q is empty; e must come from p.
__e = __p;
__p = static_cast<_Fwd_list_node*>(__p->_M_next);
--__psize;
}
else if (__comp(__p->_M_value, __q->_M_value))
{
// First node of p is lower; e must come from p.
__e = __p;
__p = static_cast<_Fwd_list_node*>(__p->_M_next);
--__psize;
}
else
{
// First node of q is lower; e must come from q.
__e = __q;
__q = static_cast<_Fwd_list_node*>(__q->_M_next);
--__qsize;
}
// Add the next node to the merged list.
if (__tail)
__tail->_M_next = __e;
else
__list = __e;
__tail = __e;
}
// Now p has stepped `insize' places along, and q has too.
__p = __q;
}
__tail->_M_next = 0;
// If we have done only one merge, we're finished.
// Allow for nmerges == 0, the empty list case.
if (__nmerges <= 1)
{
this->_M_next = __list;
return;
}
// Otherwise repeat, merging lists twice the size.
__insize *= 2;
}
}
template<typename _Tp, typename _Alloc>
_Fwd_list_base<_Tp, _Alloc>::
_Fwd_list_base(const _Fwd_list_base& __lst, const _Alloc& __a)
: _M_impl(__a)
{
this->_M_impl._M_head._M_next = 0;
_Fwd_list_node_base* __to = &this->_M_impl._M_head;
_Node* __curr = static_cast<_Node*>(__lst._M_impl._M_head._M_next);
while (__curr)
{
__to->_M_next = _M_create_node(__curr->_M_value);
__to = __to->_M_next;
__curr = static_cast<_Node*>(__curr->_M_next);
}
}
template<typename _Tp, typename _Alloc>
_Fwd_list_node_base*
_Fwd_list_base<_Tp, _Alloc>::
_M_erase_after(_Fwd_list_node_base* __pos)
{
_Node* __curr = static_cast<_Node*>(__pos->_M_next);
if (__curr)
{
_Fwd_list_node_base* __next = __curr->_M_next;
__pos->_M_next = __next;
_M_get_Node_allocator().destroy(__curr);
_M_put_node(__curr);
}
return __pos;
}
template<typename _Tp, typename _Alloc>
_Fwd_list_node_base*
_Fwd_list_base<_Tp, _Alloc>::
_M_erase_after(_Fwd_list_node_base* __pos, _Fwd_list_node_base* __last)
{
_Node* __curr = static_cast<_Node*>(__pos->_M_next);
while (__curr)
{
_Node* __temp = __curr;
__curr = static_cast<_Node*>(__curr->_M_next);
_M_get_Node_allocator().destroy(__temp);
_M_put_node(__temp);
__pos->_M_next = __curr;
if (__temp == __last)
break;
}
return __pos;
}
template<typename _Tp, typename _Alloc>
forward_list<_Tp, _Alloc>::
forward_list(size_type __n)
: _Base()
{
_Fwd_list_node_base* __to = &this->_M_impl._M_head;
for (size_type __i = 0; __i < __n; ++__i)
{
__to->_M_next = _M_create_node(_Tp());
__to = __to->_M_next;
}
}
template<typename _Tp, typename _Alloc>
forward_list<_Tp, _Alloc>::
forward_list(size_type __n, const _Tp& __value, const _Alloc& __al)
: _Base(__al)
{
_Fwd_list_node_base* __to = &this->_M_impl._M_head;
for (size_type __i = 0; __i < __n; ++__i)
{
__to->_M_next = _M_create_node(__value);
__to = __to->_M_next;
}
}
template<typename _Tp, typename _Alloc>
template<typename _InputIterator>
forward_list<_Tp, _Alloc>::
forward_list(_InputIterator __first, _InputIterator __last,
const _Alloc& __al)
: _Base(__al)
{
_Fwd_list_node_base* __to = &this->_M_impl._M_head;
_InputIterator __curr = __first;
while (__curr != __last)
{
__to->_M_next = _M_create_node(*__curr);
__to = __to->_M_next;
++__curr;
}
}
template<typename _Tp, typename _Alloc>
forward_list<_Tp, _Alloc>::
forward_list(const forward_list& __list)
: _Base(__list._M_get_Node_allocator())
{
const _Fwd_list_node_base* __from = &__list._M_impl._M_head;
_Fwd_list_node_base* __to = &this->_M_impl._M_head;
while (__from->_M_next != 0)
{
const _Node* __temp = static_cast<_Node*>(__from->_M_next);
__to->_M_next = _M_create_node(__temp->_M_value);
__from = __from->_M_next;
__to = __to->_M_next;
}
}
template<typename _Tp, typename _Alloc>
forward_list<_Tp, _Alloc>::
forward_list(std::initializer_list<_Tp> __il, const _Alloc& __al)
: _Base(__al)
{
_Fwd_list_node_base* __to = &this->_M_impl._M_head;
for (const _Tp* __item = __il.begin();
__item != __il.end(); ++__item)
{
__to->_M_next = _M_create_node(*__item);
__to = __to->_M_next;
}
}
template<typename _Tp, typename _Alloc>
forward_list<_Tp, _Alloc>&
forward_list<_Tp, _Alloc>::
operator=(const forward_list& __list)
{
if (&__list != this)
{
iterator __prev1 = before_begin();
iterator __curr1 = begin();
iterator __last1 = end();
const_iterator __first2 = __list.cbegin();
const_iterator __last2 = __list.cend();
while (__curr1 != __last1 && __first2 != __last2)
{
*__curr1 = *__first2;
++__prev1;
++__curr1;
++__first2;
}
if (__first2 == __last2)
erase_after(__prev1, __last1);
else
insert_after(__prev1, __first2, __last2);
}
return *this;
}
template<typename _Tp, typename _Alloc>
void
forward_list<_Tp, _Alloc>::
insert_after(const_iterator __pos,
size_type __n, const _Tp& __val)
{
_Fwd_list_node_base* __to
= const_cast<_Fwd_list_node_base* const>(__pos._M_node);
_Fwd_list_node_base* __keep = __to->_M_next;
for (size_type __i = 0; __i < __n; ++__i)
{
__to->_M_next = _M_create_node(__val);
__to = __to->_M_next;
}
__to->_M_next = __keep;
}
template<typename _Tp, typename _Alloc>
template<typename _InputIterator>
void
forward_list<_Tp, _Alloc>::
insert_after(const_iterator __pos,
_InputIterator __first, _InputIterator __last)
{
_Fwd_list_node_base* __to
= const_cast<_Fwd_list_node_base* const>(__pos._M_node);
_Fwd_list_node_base* __keep = __to->_M_next;
_InputIterator __curr = __first;
while (__curr != __last)
{
__to->_M_next = _M_create_node(*__curr);
__to = __to->_M_next;
++__curr;
}
__to->_M_next = __keep;
}
template<typename _Tp, typename _Alloc>
void
forward_list<_Tp, _Alloc>::
insert_after(const_iterator __pos, std::initializer_list<_Tp> __il)
{
_Fwd_list_node_base* __to
= const_cast<_Fwd_list_node_base* const>(__pos._M_node);
_Fwd_list_node_base* __keep = __to->_M_next;
const _Tp* __item = __il.begin();
while (__item != __il.end())
{
__to->_M_next = _M_create_node(*__item);
__to = __to->_M_next;
++__item;
}
__to->_M_next = __keep;
}
template<typename _Tp, typename _Alloc>
void
forward_list<_Tp, _Alloc>::
resize(size_type __sz, value_type __val)
{
iterator __k = before_begin();
size_type __len = 0;
while (__k._M_next() != end() && __len < __sz)
{
++__k;
++__len;
}
if (__len == __sz)
erase_after(__k, end());
else
insert_after(__k, __sz - __len, __val);
}
template<typename _Tp, typename _Alloc>
void
forward_list<_Tp, _Alloc>::
remove(const _Tp& __val)
{
_Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head);
while (_Node* __temp = static_cast<_Node*>(__curr->_M_next))
{
if (__temp->_M_value == __val)
_M_erase_after(__curr);
else
__curr = static_cast<_Node*>(__curr->_M_next);
}
}
template<typename _Tp, typename _Alloc>
template<typename _Pred>
void
forward_list<_Tp, _Alloc>::
remove_if(_Pred __pred)
{
_Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head);
while (_Node* __temp = static_cast<_Node*>(__curr->_M_next))
{
if (__pred(__temp->_M_value))
_M_erase_after(__curr);
else
__curr = static_cast<_Node*>(__curr->_M_next);
}
}
template<typename _Tp, typename _Alloc>
void
forward_list<_Tp, _Alloc>::
unique()
{
iterator __first = begin();
iterator __last = end();
if (__first == __last)
return;
iterator __next = __first;
while (++__next != __last)
{
if (*__first == *__next)
erase_after(__first);
else
__first = __next;
__next = __first;
}
}
template<typename _Tp, typename _Alloc>
template<typename _BinPred>
void
forward_list<_Tp, _Alloc>::
unique(_BinPred __binary_pred)
{
iterator __first = begin();
iterator __last = end();
if (__first == __last)
return;
iterator __next = __first;
while (++__next != __last)
{
if (__binary_pred(*__first, *__next))
erase_after(__first);
else
__first = __next;
__next = __first;
}
}
template<typename _Tp, typename _Alloc>
template<typename _Comp>
void
forward_list<_Tp, _Alloc>::
merge(forward_list&& __list, _Comp __comp)
{
_Fwd_list_node_base* __node = &this->_M_impl._M_head;
while (__node->_M_next && __list._M_impl._M_head._M_next)
{
if (__comp(static_cast<_Node*>
(__list._M_impl._M_head._M_next)->_M_value,
static_cast<_Node*>
(__node->_M_next)->_M_value))
__node->_M_transfer_after(&__list._M_impl._M_head,
__list._M_impl._M_head._M_next);
__node = __node->_M_next;
}
if (__list._M_impl._M_head._M_next)
{
__node->_M_next = __list._M_impl._M_head._M_next;
__list._M_impl._M_head._M_next = 0;
}
}
_GLIBCXX_END_NAMESPACE // namespace std
#endif /* _FORWARD_LIST_TCC */

4
libstdc++-v3/include/precompiled/stdc++.h
View file

@ -1,6 +1,7 @@
// C++ includes used for precompiling -*- C++ -*-
// Copyright (C) 2003, 2007 Free Software Foundation, Inc.
// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
// 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
@ -99,6 +100,7 @@
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <array>
#include <chrono>
#include <forward_list>
#include <random>
#include <ratio>
#include <regex>

51
libstdc++-v3/include/std/forward_list Normal file
View file

@ -0,0 +1,51 @@
// <forward_list> -*- C++ -*-
// Copyright (C) 2008 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 2, 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 COPYING. If not, write to
// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
// Boston, MA 02110-1301, USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
/** @file forward_list
* This is a Standard C++ Library header.
*/
#ifndef _GLIBCXX_FORWARD_LIST
#define _GLIBCXX_FORWARD_LIST 1
#pragma GCC system_header
#ifndef __GXX_EXPERIMENTAL_CXX0X__
# include <c++0x_warning.h>
#else
#include <bits/forward_list.h>
#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include <bits/forward_list.tcc>
#endif
#endif // __GXX_EXPERIMENTAL_CXX0X__
#endif // _GLIBCXX_FORWARD_LIST

1
libstdc++-v3/testsuite/17_intro/headers/c++200x/all.cc
View file

@ -100,6 +100,7 @@
#include <condition_variable>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <iomanip>

2
libstdc++-v3/testsuite/17_intro/headers/c++200x/all_multiple_inclusion.cc
View file

@ -98,6 +98,7 @@
#include <condition_variable>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <iomanip>
@ -213,6 +214,7 @@
#include <condition_variable>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <iomanip>

50
libstdc++-v3/testsuite/23_containers/forward_list/capacity/1.cc Normal file
View file

@ -0,0 +1,50 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list capacity [lib.forward_list.capacity]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following.
//
void
test01()
{
std::forward_list<double> fld;
VERIFY(fld.empty() == true);
fld.push_front(1.0);
VERIFY(fld.empty() == false);
fld.resize(0);
VERIFY(fld.empty() == true);
VERIFY(fld.max_size() == fld.get_allocator().max_size());
}
int
main()
{
test01();
return 0;
}

59
libstdc++-v3/testsuite/23_containers/forward_list/comparable.cc Normal file
View file

@ -0,0 +1,59 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, 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 COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// NOTE: This makes use of the fact that we know how moveable
// is implemented on list (via swap). If the implementation changed
// this test may begin to fail.
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
int main()
{
std::forward_list<double> a = {0.0, 1.0, 2.0, 3.0, 4.0};
std::forward_list<double> b = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
VERIFY((a == b) == false);
VERIFY((a < b) == true);
VERIFY((a != b) == true);
VERIFY((a > b) == false);
VERIFY((a >= b) == false);
VERIFY((a <= b) == true);
VERIFY((b == a) == false);
VERIFY((b < a) == false);
VERIFY((b != a) == true);
VERIFY((b > a) == true);
VERIFY((b >= a) == true);
VERIFY((b <= a) == false);
return 0;
}

41
libstdc++-v3/testsuite/23_containers/forward_list/cons/1.cc Normal file
View file

@ -0,0 +1,41 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// Default construction
void
test01()
{
std::forward_list<double> fld;
}
int
main()
{
test01();
return 0;
}

46
libstdc++-v3/testsuite/23_containers/forward_list/cons/2.cc Normal file
View file

@ -0,0 +1,46 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// Construction from iterator range
// Copy construction with allocator
void
test01()
{
const int ni = 10;
int i[ni] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::forward_list<int> flccin(i, i+ni);
std::forward_list<int> flcc(flccin, std::allocator<int>());
}
int
main()
{
test01();
return 0;
}

44
libstdc++-v3/testsuite/23_containers/forward_list/cons/3.cc Normal file
View file

@ -0,0 +1,44 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// Move construction with allocator
void
test01()
{
const int ni = 10;
int i[ni] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::forward_list<int> flmc(std::forward_list<int>(i, i+ni), std::allocator<int>());
}
int
main()
{
test01();
return 0;
}

41
libstdc++-v3/testsuite/23_containers/forward_list/cons/4.cc Normal file
View file

@ -0,0 +1,41 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// Construction from given number of default item
void
test01()
{
std::forward_list<double> flvd(10);
}
int
main()
{
test01();
return 0;
}

41
libstdc++-v3/testsuite/23_containers/forward_list/cons/5.cc Normal file
View file

@ -0,0 +1,41 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// Construction from given number of given item
void
test01()
{
std::forward_list<float> flv(10, 5.0F);
}
int
main()
{
test01();
return 0;
}

44
libstdc++-v3/testsuite/23_containers/forward_list/cons/6.cc Normal file
View file

@ -0,0 +1,44 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// Construction from iterator range
void
test01()
{
const int ni = 10;
int i[ni] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::forward_list<int> fl(i, i+ni);
}
int
main()
{
test01();
return 0;
}

45
libstdc++-v3/testsuite/23_containers/forward_list/cons/7.cc Normal file
View file

@ -0,0 +1,45 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// Copy construction
void
test01()
{
const int ni = 10;
int i[ni] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::forward_list<int> fl(i, i+ni);
std::forward_list<int> flc(fl);
}
int
main()
{
test01();
return 0;
}

45
libstdc++-v3/testsuite/23_containers/forward_list/cons/8.cc Normal file
View file

@ -0,0 +1,45 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// Move construction
void
test01()
{
const int ni = 10;
int i[ni] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::forward_list<int> fl(i, i+ni);
std::forward_list<int> flm(std::move(fl));
}
int
main()
{
test01();
return 0;
}

41
libstdc++-v3/testsuite/23_containers/forward_list/cons/9.cc Normal file
View file

@ -0,0 +1,41 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following.
// Construction from initializer list
void
test01()
{
std::forward_list<double> flil({1.0, 2.0, 3.0, 4.0, 5.0});
}
int
main()
{
test01();
return 0;
}

73
libstdc++-v3/testsuite/23_containers/forward_list/modifiers/1.cc Normal file
View file

@ -0,0 +1,73 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <array>
bool test __attribute__((unused)) = true;
class PathPoint
{
public:
PathPoint(char t, std::array<double, 3> & c)
: type(t), coord(c) { }
char getType() const { return type; }
private:
char type;
std::array<double, 3> coord;
};
// This test verifies the following.
// emplace_front
// pop_front
// emplace_after
void
test01()
{
std::forward_list<PathPoint> path;
std::array<double, 3> coord1 = { { 0.0, 1.0, 2.0 } };
path.emplace_front('a', coord1);
std::forward_list<PathPoint>::const_iterator pos = path.cbegin();
std::array<double, 3> coord2 = { { 3.0, 4.0, 5.0 } };
path.emplace_after(pos, 'b', coord2);
VERIFY(path.front().getType() == 'a');
path.pop_front();
VERIFY(path.front().getType() == 'b');
path.pop_front();
VERIFY(path.empty() == true);
}
int
main()
{
test01();
return 0;
}

135
libstdc++-v3/testsuite/23_containers/forward_list/modifiers/2.cc Normal file
View file

@ -0,0 +1,135 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <string>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// insert_after single item
// before_begin iterator
void
test01()
{
std::forward_list<int> fl({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
fl.insert_after(fl.before_begin(), 42);
VERIFY(fl.front() == 42);
}
// This test verifies the following:
void
test02()
{
std::forward_list<int> fl({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int>::const_iterator pos = fl.cbegin();
++pos;
VERIFY(*pos == 1);
// Note: Calling l.insert_after(pos, 5, 42); without the long five
// gets resolved to the iterator range version and fails to compile!
fl.insert_after(pos, 5L, 42);
VERIFY(*pos == 1);
++pos;
VERIFY(*pos == 42);
++pos;
++pos;
++pos;
++pos;
VERIFY(*pos == 42);
}
// This test verifies the following:
void
test03()
{
std::forward_list<int> fl({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int>::const_iterator pos = fl.cbegin();
++pos;
VERIFY(*pos == 1);
int i[3] = {666, 777, 888};
fl.insert_after(pos, i, i+3);
VERIFY(*pos == 1);
++pos;
++pos;
++pos;
VERIFY(*pos == 888);
++pos;
VERIFY(*pos == 2);
}
// This test verifies the following:
void
test04()
{
std::forward_list<int> fl({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int>::const_iterator pos = fl.cbegin();
++pos;
VERIFY(*pos == 1);
fl.insert_after(pos, {-1, -2, -3, -4, -5});
VERIFY(*pos == 1);
++pos;
++pos;
++pos;
VERIFY(*pos == -3);
}
// This test verifies the following:
void
test05()
{
std::forward_list<std::string> fl({"AAA", "BBB", "CCC"});
std::forward_list<std::string>::const_iterator pos = fl.cbegin();
++pos;
VERIFY(*pos == "BBB");
std::string x( "XXX" );
fl.insert_after(pos, std::move(x));
VERIFY(*pos == "BBB");
++pos;
VERIFY(*pos == "XXX");
++pos;
VERIFY(*pos == "CCC");
}
int
main()
{
test01();
test02();
test03();
test04();
test05();
return 0;
}

83
libstdc++-v3/testsuite/23_containers/forward_list/modifiers/3.cc Normal file
View file

@ -0,0 +1,83 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// cbegin
// erase_after one iterator
// pos is useable and points to current element
void
test01()
{
std::forward_list<int> fl({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int>::const_iterator pos = fl.cbegin();
++pos;
VERIFY(*pos == 1);
std::forward_list<int>::iterator next = fl.erase_after(pos);
VERIFY(*next == 1);
VERIFY(*pos == 1);
++pos;
VERIFY(*pos == 3);
}
// This test verifies the following:
// cbegin
// erase_after iterator range
// pos is useable and points to current element
void
test02()
{
std::forward_list<int> fl({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int>::const_iterator pos = fl.cbegin();
++pos;
VERIFY(*pos == 1);
std::forward_list<int>::iterator stop = fl.begin();
++stop;
++stop;
++stop;
++stop;
VERIFY(*stop == 4);
std::forward_list<int>::iterator next = fl.erase_after(pos, stop);
VERIFY(*next == 1);
VERIFY(*pos == 1);
++pos;
VERIFY(*pos == 5);
}
int
main()
{
test01();
test02();
return 0;
}

47
libstdc++-v3/testsuite/23_containers/forward_list/modifiers/4.cc Normal file
View file

@ -0,0 +1,47 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// swap
void
test01()
{
std::forward_list<int> fl1({0, 1, 2, 3, 4, 5});
std::forward_list<int> fl2({666, 777, 888});
fl1.swap(fl2);
VERIFY(fl1.front() == 666);
VERIFY(fl2.front() == 0);
}
int
main()
{
test01();
return 0;
}

47
libstdc++-v3/testsuite/23_containers/forward_list/modifiers/5.cc Normal file
View file

@ -0,0 +1,47 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// clear
void
test01()
{
std::forward_list<int> fl({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
VERIFY(fl.empty() == false);
fl.clear();
VERIFY(fl.empty() == true);
}
int
main()
{
test01();
return 0;
}

56
libstdc++-v3/testsuite/23_containers/forward_list/moveable.cc Normal file
View file

@ -0,0 +1,56 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, 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 COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// NOTE: This makes use of the fact that we know how moveable
// is implemented on list (via swap). If the implementation changed
// this test may begin to fail.
#include <forward_list>
#include <utility>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
int main()
{
std::forward_list<int> a, b;
a.push_front(1);
b = std::move(a);
VERIFY(b.empty() == false);
VERIFY(*b.begin() == 1);
VERIFY(a.empty() == true);
std::forward_list<int> c(std::move(b));
VERIFY(c.empty() == false);
(*c.begin() == 1 );
VERIFY( b.empty() == true );
return 0;
}

107
libstdc++-v3/testsuite/23_containers/forward_list/operations/1.cc Normal file
View file

@ -0,0 +1,107 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
//
void
test01()
{
std::forward_list<double> a = {0.0, 1.0, 2.0, 3.0, 4.0};
std::forward_list<double>::const_iterator posa = a.cbefore_begin();
std::forward_list<double> x = {666.0, 777.0, 888.0};
a.splice_after(posa, x);
++posa;
VERIFY(*posa == 666.0);
VERIFY(x.empty() == true);
}
// This test verifies the following:
//
void
test02()
{
std::forward_list<double> a = {0.0, 1.0, 2.0, 3.0, 4.0};
std::forward_list<double>::const_iterator posa = a.cbefore_begin();
++posa;
VERIFY(*posa == 0.0);
std::forward_list<double> y = {10.0, 11.0, 12.0, 13.0, 14.0, 15.0};
std::forward_list<double>::const_iterator befy = y.cbefore_begin();
++befy;
VERIFY(*befy == 10.0);
std::forward_list<double>::const_iterator endy = befy;
++endy;
++endy;
++endy;
++endy;
VERIFY(*endy == 14.0);
a.splice_after(posa, y, befy, endy);
VERIFY(*posa == 0.0);
VERIFY(*befy == 10.0);
++befy;
VERIFY(*befy == 15.0);
}
// This test verifies the following:
//
void
test03()
{
std::forward_list<double> a = {0.0, 1.0, 2.0, 3.0, 4.0};
std::forward_list<double>::const_iterator posa = a.cbefore_begin();
++posa;
++posa;
VERIFY(*posa == 1.0);
std::forward_list<double> z = {42.0, 43.0, 44.0};
std::forward_list<double>::const_iterator posz = z.begin();
VERIFY(*posz == 42.0);
a.splice_after(posa, z, posz);
VERIFY(*posa == 1.0);
++posa;
VERIFY(*posa == 43.0);
VERIFY(*posz == 42.0);
++posz;
VERIFY(*posz == 44.0);
}
int
main()
{
test01();
test02();
test03();
return 0;
}

51
libstdc++-v3/testsuite/23_containers/forward_list/operations/2.cc Normal file
View file

@ -0,0 +1,51 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// remove
void
test01()
{
std::forward_list<int> fl ={0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
fl.remove(7);
std::forward_list<int>::const_iterator pos = fl.cbefore_begin();
for (std::size_t i = 0; i < 7; ++i)
++pos;
VERIFY(*pos == 6);
++pos;
VERIFY(*pos == 8);
}
int
main()
{
test01();
return 0;
}

48
libstdc++-v3/testsuite/23_containers/forward_list/operations/3.cc Normal file
View file

@ -0,0 +1,48 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <algorithm>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// remove_if
void
test01()
{
std::forward_list<int> fl ={0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
fl.remove_if(std::bind2nd(std::less<int>(),5));
std::forward_list<int>::const_iterator pos = fl.cbegin();
VERIFY(*pos == 5);
}
int
main()
{
test01();
return 0;
}

78
libstdc++-v3/testsuite/23_containers/forward_list/operations/4.cc Normal file
View file

@ -0,0 +1,78 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
// unique
void
test01()
{
std::forward_list<int> fl = {99, 5, 99, 6, -5, 666, 777, 888,
42, 42, 42, 42, 42, 7, 0, 0, 0, 9, 9, 9};
fl.unique();
std::forward_list<int> fl2 = {99, 5, 99, 6, -5, 666, 777, 888, 42, 7, 0, 9};
VERIFY(fl == fl2);
}
// Test comparison predicate.
template<typename Num>
class Mod
{
public:
Mod(const Num & mod)
{
m = mod;
}
bool operator()(const Num i, const Num j)
{
return i%m == j%m;
}
private:
Num m;
};
// This test verifies the following:
// unique with predicate
void
test02()
{
std::forward_list<int> fl = {99, 5, 99, 6, -5, 666, 777, 888, 42, 7, 0, 9};
fl.unique(Mod<int>(111));
std::forward_list<int> fl2 = {99, 5, 99, 6, -5, 666, 42, 7, 0, 9};
VERIFY(fl == fl2);
}
int
main()
{
test01();
test02();
return 0;
}

49
libstdc++-v3/testsuite/23_containers/forward_list/operations/5.cc Normal file
View file

@ -0,0 +1,49 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// This test verifies the following:
//
void
test01()
{
std::forward_list<double> a = {0.0, 1.0, 2.0, 3.0, 4.0};
std::forward_list<double> b = {1.0, 2.0, 3.0, 4.0, 4.0, 5.0};
a.merge(b);
std::forward_list<double> r = {0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0,
4.0, 4.0, 4.0, 5.0};
VERIFY(a == r);
}
int
main()
{
test01();
return 0;
}

84
libstdc++-v3/testsuite/23_containers/forward_list/operations/6.cc Normal file
View file

@ -0,0 +1,84 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// Comparison functor.
template<typename Num>
class Comp
{
public:
Comp(const Num & num)
{
n = num;
}
bool operator()(const Num i, const Num j)
{
return (n * i) < (n * j);
}
private:
Num n;
};
// This test verifies the following:
//
void
test01()
{
const unsigned int n = 13;
int order[][n] = {
{ 0,1,2,3,4,5,6,7,8,9,10,11,12 },
{ 6,2,8,4,11,1,12,7,3,9,5,0,10 },
{ 12,11,10,9,8,7,6,5,4,3,2,1,0 },
};
std::forward_list<int> sorted(order[0], order[0] + n);
for (unsigned int i = 0; i < sizeof(order)/sizeof(*order); ++i)
{
std::forward_list<int> head(order[i], order[i] + n);
head.sort();
VERIFY(head == sorted);
}
std::forward_list<int> reversed(order[2], order[2] + n);
for (unsigned int i = 0; i < sizeof(order)/sizeof(*order); ++i)
{
std::forward_list<int> head(order[i], order[i] + n);
Comp<int> comp(-1);
head.sort( comp );
VERIFY(head == reversed);
}
}
int
main()
{
test01();
return 0;
}

55
libstdc++-v3/testsuite/23_containers/forward_list/operations/7.cc Normal file
View file

@ -0,0 +1,55 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
#include <algorithm>
bool test __attribute__((unused)) = true;
// This test verifies the following:
//
void
test01()
{
const unsigned int n = 13;
int order[n] = {0,1,2,3,4,5,6,7,8,9,10,11,12};
std::forward_list<int> fl(order, order + n);
std::forward_list<int> fl2;
for (std::size_t i = 0; i < n; ++i)
fl2.push_front(order[i]);
fl.reverse();
VERIFY(std::lexicographical_compare(fl.begin(), fl.end(),
fl2.begin(), fl2.end()) == false);
}
int
main()
{
test01();
return 0;
}

70
libstdc++-v3/testsuite/23_containers/forward_list/requirements/1.cc Normal file
View file

@ -0,0 +1,70 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without Pred 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
#include <testsuite_hooks.h>
bool test __attribute__((unused)) = true;
// A nontrivial type.
template<typename T>
struct A { };
// Another nontrivial type
struct B { };
// A nontrivial type convertible from an int
struct C
{
C(int i) : i_(i) { }
bool operator==(const C& rhs) { return i_ == rhs.i_; }
int i_;
};
// This test verifies the following.
//
void
test01()
{
std::forward_list< A<B> > lst;
VERIFY(lst.begin() == lst.end());
VERIFY(std::distance(lst.begin(), lst.end()) == 0);
// check type definitions -- will fail compile if missing
typedef std::forward_list< A<B> >::reference reference;
typedef std::forward_list< A<B> >::const_reference const_reference;
typedef std::forward_list< A<B> >::iterator iterator;
typedef std::forward_list< A<B> >::const_iterator const_iterator;
typedef std::forward_list< A<B> >::size_type size_type;
typedef std::forward_list< A<B> >::difference_type difference_type;
typedef std::forward_list< A<B> >::value_type value_type;
typedef std::forward_list< A<B> >::allocator_type allocator_type;
typedef std::forward_list< A<B> >::pointer pointer;
typedef std::forward_list< A<B> >::const_pointer const_pointer;
}
int
main()
{
test01();
return 0;
}

53
libstdc++-v3/testsuite/23_containers/headers/forward_list/synopsis.cc Normal file
View file

@ -0,0 +1,53 @@
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008 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 2, 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 COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
#include <forward_list>
namespace std {
template <class T, class Allocator> class forward_list;
template <class T, class Allocator>
bool operator==(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>&);
template <class T, class Allocator>
bool operator< (const forward_list<T,Allocator>& x, const forward_list<T,Allocator>&);
template <class T, class Allocator>
bool operator!=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>&);
template <class T, class Allocator>
bool operator> (const forward_list<T,Allocator>& x, const forward_list<T,Allocator>&);
template <class T, class Allocator>
bool operator>=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>&);
template <class T, class Allocator>
bool operator<=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>&);
template <class T, class Allocator>
void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
template <class T, class Allocator>
void swap(forward_list<T,Allocator>&& x, forward_list<T,Allocator>& y);
template <class T, class Allocator>
void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>&& y);
}