gcc/libstdc++-v3/testsuite/testsuite_iterators.h
Chris Jefferson 8b5bc374b1 mt_allocator.h (__mt_alloc::__mt_alloc): Remove name of unused parameter.
2005-12-26  Chris Jefferson  <chris@bubblescope.net>

	* include/ext/mt_allocator.h (__mt_alloc::__mt_alloc): Remove
	name of unused parameter.
	* include/bits/stream_iterator.h (istream_iterator::istream_iterator):
	Construct _M_value.
	* include/debug/functions.h (__check_valid_range): Add
	__attribute__((unused)).
	* include/tr1/hashtable (hashtable::end): Remove name of unused
	parameter.
	* include/tr1/tuple_iterate.h (tuple::tuple): Likewise.
	(tuple::operator=): Add __attribute__((unused)).
	* include/tr1/functional (Fnv_hash<4>::hash): Add static_cast.
	(Fnv_hash<8>::hash): Likewise.

	* testsuite/25_algorithms/iter_swap/20577.cc (swap): Remove name of
	unused parameter.
	* testsuite/25_algorithms/unique_copy/check_type.cc (S2::S2,X2::X2):
	Likewise.
	* testsuite/22_locale/ctype/narrow/char/19955.cc (do_narrow): Likewise.
	* testsuite/22_locale/ctype/is/char/9858.cc (Derived::do_is, 
	Derived::do_scan_is, Derived::do_scan_not, Derived2::do_is,
	Derived2::do_scan_is, Derived2::do_scan_not): Likewise.
	* testsuite/22_locale/time_put/put/wchar_t/12439_1.cc (TP::do_put):
	Likewise.
	* testsuite/22_locale/time_put/put/wchar_t/12439_3.cc (TP::do_put):
	Likewise.
	* testsuite/22_locale/time_put/put/char/12439_1.cc (TP::do_put):
	Likewise.
	* testsuite/22_locale/time_put/put/char/12439_3.cc (TP::do_put):
	Likewise.
	* testsuite/testsuite_io.h (fail_num_get::do_get, fail_num_put::do_put):
	Likewise.
	* testsuite/25_algorithms/find/17441.cc (find): Likewise.
	* testsuite/23_containers/vector/cons/clear_allocator.cc
	(clear_alloc::clear_alloc): Likewise.
	* testsuite/23_containers/vector/bool/clear_allocator.cc
	(clear_alloc::clear_alloc): Likewise.
	* testsuite/23_containers/list/cons/clear_allocator.cc
	(clear_alloc::clear_alloc): Likewise.
	* testsuite/23_containers/set/modifiers/16728.cc (test_container):
	Likewise.
	* testsuite/27_io/basic_ios/cons/char/3.cc (char_traits::to_char_type,
	to_int_type): Likewise.
	* testsuite/27_io/basic_filebuf/imbue/12206.cc (codecvt::do_out, do_in,
	do_unshift, do_length): Likewise.
	* testsuite/21_strings/basic_string/capacity/1.cc 
	(operator==(A<T>,A<T>), operator<(A<T>,A<T>),
	char_traits::to_char_type, char_traits::to_int_type): Likewise
	* testsuite/testsuite_character.h (ctype::do_is, ctype::do_scan_is,
	ctype::do_scan_not, do_toupper, do_tolower): Likewise.
	* testsuite/25_algorithms/replace_copy/check_type.cc (Z::operator=):
	Add missing return statement.
	* testsuite/25_algorithms/replace_copy_if/check_type.cc (Z::operator=):
	Likewise.
	* testsuite/testsuite_iterators.h (output_iterator_wrapper::operator=,
	random_access_iterator_wrapper::operator==): Likewise.
	* testsuite/20_util/functional/binders/1.cc (s::f_int_int_const,
	s::f_int_int, s::f_int_void_const, s::f_int_void): Likewise.
	* testsuite/27_io/types/1.cc (test01): Likewise.
	* testsuite/27_io/basic_ostream/write/wchar_t/1.cc (test01): Likewise.
	* testsuite/27_io/basic_ostream/write/char/1.cc (test01): Likewise.
	* testsuite/21_strings/c_strings/wchar_t/24559.cc (main): Likewise.
	* testsuite/27_io/basic_istream/ignore/wchar_t/2.cc (check): Add static
	cast.
	* testsuite/27_io/basic_istream/ignore/char/2.cc (check): Likewise.
	* testsuite/27_io/basic_istream/getline/wchar_t/5.cc (check): Likewise.
	* testsuite/27_io/basic_istream/getline/char/5.cc (check): Likewise.
	* testsuite/testsuite_allocator.h (check_new): Likewise.
	(check_deallocate_null): Add missing return value.
	* testsuite/ext/pool_allocator/allocate_chunk.cc (test01):
	Make variable unsigned.
	* testsuite/23_containers/vector/modifiers/erase/1.cc (N,N1,N2,N3,N4,
	N5,test01): Likewise.
	* testsuite/26_numerics/valarray/valarray_subset_assignment.cc
	(check_array): Likewise.
	(main): Removed unused variable.
	* testsuite/27_io/basic_streambuf/in_avail/wchar_t/1.cc (test05):
	Removed unused variable.
	* testsuite/27_io/basic_ostream/flush/wchar_t/1.cc (test01): Likewise.
	* testsuite/27_io/basic_ostream/flush/char/1.cc (test01): Likewise.
	* testsuite/27_io/basic_ostream/endl/wchar_t/1.cc (test01): Likewise.
	* testsuite/27_io/basic_ostream/endl/char/1.cc (test01): Likewise.
	* testsuite/27_io/basic_ostream/ends/wchar_t/1.cc (test01): Likewise.
	* testsuite/27_io/basic_ostream/ends/char/1.cc (test01): Likewise.
	* testsuite/tr1/2_general_utilities/memory/shared_ptr/
	assign/shared_ptr.cc (test01): Correct return type.	
	* testsuite/27_io/basic_filebuf/close/char/2.cc (test_02):
	Add default value to close_num.

From-SVN: r109062
2005-12-26 10:53:42 +00:00

546 lines
14 KiB
C++

// -*- C++ -*-
// Iterator Wrappers for the C++ library testsuite.
//
// Copyright (C) 2004, 2005 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.
// This file provides the following:
//
// input_iterator_wrapper, output_iterator_wrapper
// forward_iterator_wrapper, bidirectional_iterator_wrapper and
// random_access_wrapper, which attempt to exactly perform the requirements
// of these types of iterators. These are constructed from the class
// test_container, which is given two pointers to T and an iterator type.
#include <testsuite_hooks.h>
#include <iterator>
#ifndef _TESTSUITE_ITERATORS
#define _TESTSUITE_ITERATORS
#ifdef DISABLE_ITERATOR_DEBUG
#define ITERATOR_VERIFY(x)
#else
#define ITERATOR_VERIFY(x) VERIFY(x)
#endif
namespace __gnu_test
{
/**
* @brief Simple container for holding two pointers.
*
* Note that input_iterator_wrapper changes first to denote
* how the valid range of == , ++, etc. change as the iterators are used.
*/
template<typename T>
struct BoundsContainer
{
T* first;
T* last;
BoundsContainer(T* _first, T* _last)
: first(_first), last(_last)
{ }
};
// Simple container for holding state of a set of output iterators.
template<typename T>
struct OutputContainer : public BoundsContainer<T>
{
T* incrementedto;
bool* writtento;
OutputContainer(T* _first, T* _last)
: BoundsContainer<T>(_first, _last), incrementedto(_first)
{
writtento = new bool[this->last - this->first];
for(int i = 0; i < this->last - this->first; i++)
writtento[i] = false;
}
~OutputContainer()
{ delete[] writtento; }
};
// Produced by output_iterator to allow limited writing to pointer
template<class T>
class WritableObject
{
T* ptr;
public:
OutputContainer<T>* SharedInfo;
WritableObject(T* ptr_in,OutputContainer<T>* SharedInfo_in):
ptr(ptr_in), SharedInfo(SharedInfo_in)
{ }
template<class U>
void
operator=(const U& new_val)
{
ITERATOR_VERIFY(SharedInfo->writtento[ptr - SharedInfo->first] == 0);
SharedInfo->writtento[ptr - SharedInfo->first] = 1;
*ptr = new_val;
}
};
/**
* @brief output_iterator wrapper for pointer
*
* This class takes a pointer and wraps it to provide exactly
* the requirements of a output_iterator. It should not be
* instansiated directly, but generated from a test_container
*/
template<class T>
struct output_iterator_wrapper: public std::iterator
<std::output_iterator_tag, T, ptrdiff_t, T*, T&>
{
typedef OutputContainer<T> ContainerType;
T* ptr;
ContainerType* SharedInfo;
output_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
:ptr(_ptr), SharedInfo(SharedInfo_in)
{
ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last);
}
output_iterator_wrapper(const output_iterator_wrapper& in)
:ptr(in.ptr), SharedInfo(in.SharedInfo)
{ }
WritableObject<T>
operator*() const
{
ITERATOR_VERIFY(ptr < SharedInfo->last);
ITERATOR_VERIFY(SharedInfo->writtento[ptr - SharedInfo->first] == false);
return WritableObject<T>(ptr, SharedInfo);
}
output_iterator_wrapper&
operator=(const output_iterator_wrapper& in)
{
ptr = in.ptr;
SharedInfo = in.SharedInfo;
return *this;
}
output_iterator_wrapper&
operator++()
{
ITERATOR_VERIFY(SharedInfo && ptr < SharedInfo->last);
ITERATOR_VERIFY(ptr>=SharedInfo->incrementedto);
ptr++;
SharedInfo->incrementedto=ptr;
return *this;
}
output_iterator_wrapper
operator++(int)
{
output_iterator_wrapper<T> tmp = *this;
++*this;
return tmp;
}
};
/**
* @brief input_iterator wrapper for pointer
*
* This class takes a pointer and wraps it to provide exactly
* the requirements of a input_iterator. It should not be
* instansiated directly, but generated from a test_container
*/
template<class T>
class input_iterator_wrapper:public std::iterator
<std::input_iterator_tag, T, ptrdiff_t, T*, T&>
{
protected:
input_iterator_wrapper()
{ }
public:
typedef BoundsContainer<T> ContainerType;
T* ptr;
ContainerType* SharedInfo;
input_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
: ptr(_ptr), SharedInfo(SharedInfo_in)
{ ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last); }
input_iterator_wrapper(const input_iterator_wrapper& in)
: ptr(in.ptr), SharedInfo(in.SharedInfo)
{ }
bool
operator==(const input_iterator_wrapper& in) const
{
ITERATOR_VERIFY(SharedInfo != NULL && SharedInfo == in.SharedInfo);
ITERATOR_VERIFY(ptr>=SharedInfo->first && in.ptr>=SharedInfo->first);
return ptr == in.ptr;
}
bool
operator!=(const input_iterator_wrapper& in) const
{
return !(*this == in);
}
T&
operator*() const
{
ITERATOR_VERIFY(SharedInfo && ptr < SharedInfo->last);
ITERATOR_VERIFY(ptr >= SharedInfo->first);
return *ptr;
}
T*
operator->() const
{
return &**this;
}
input_iterator_wrapper&
operator=(const input_iterator_wrapper& in)
{
ptr = in.ptr;
SharedInfo = in.SharedInfo;
return *this;
}
input_iterator_wrapper&
operator++()
{
ITERATOR_VERIFY(SharedInfo && ptr < SharedInfo->last);
ITERATOR_VERIFY(ptr>=SharedInfo->first);
ptr++;
SharedInfo->first=ptr;
return *this;
}
void
operator++(int)
{
++*this;
}
};
/**
* @brief forward_iterator wrapper for pointer
*
* This class takes a pointer and wraps it to provide exactly
* the requirements of a forward_iterator. It should not be
* instansiated directly, but generated from a test_container
*/
template<class T>
struct forward_iterator_wrapper:public input_iterator_wrapper<T>
{
typedef BoundsContainer<T> ContainerType;
typedef std::forward_iterator_tag iterator_category;
forward_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
:input_iterator_wrapper<T>(_ptr, SharedInfo_in)
{ }
forward_iterator_wrapper(const forward_iterator_wrapper& in)
:input_iterator_wrapper<T>(in)
{ }
forward_iterator_wrapper()
{
this->ptr = NULL;
this->SharedInfo = NULL;
}
T&
operator*() const
{
ITERATOR_VERIFY(this->SharedInfo && this->ptr < this->SharedInfo->last);
return *(this->ptr);
}
T*
operator->() const
{ return &**this; }
forward_iterator_wrapper&
operator++()
{
ITERATOR_VERIFY(this->SharedInfo && this->ptr < this->SharedInfo->last);
this->ptr++;
return *this;
}
forward_iterator_wrapper
operator++(int)
{
forward_iterator_wrapper<T> tmp = *this;
++*this;
return tmp;
}
};
/**
* @brief bidirectional_iterator wrapper for pointer
*
* This class takes a pointer and wraps it to provide exactly
* the requirements of a forward_iterator. It should not be
* instansiated directly, but generated from a test_container
*/
template<class T>
struct bidirectional_iterator_wrapper:public forward_iterator_wrapper<T>
{
typedef BoundsContainer<T> ContainerType;
typedef std::bidirectional_iterator_tag iterator_category;
bidirectional_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
:forward_iterator_wrapper<T>(_ptr, SharedInfo_in)
{ }
bidirectional_iterator_wrapper(const bidirectional_iterator_wrapper& in)
:forward_iterator_wrapper<T>(in)
{ }
bidirectional_iterator_wrapper(): forward_iterator_wrapper<T>()
{ }
bidirectional_iterator_wrapper&
operator=(const bidirectional_iterator_wrapper& in)
{
this->ptr = in.ptr;
this->SharedInfo = in.SharedInfo;
return *this;
}
bidirectional_iterator_wrapper&
operator++()
{
ITERATOR_VERIFY(this->SharedInfo && this->ptr < this->SharedInfo->last);
this->ptr++;
return *this;
}
bidirectional_iterator_wrapper
operator++(int)
{
bidirectional_iterator_wrapper<T> tmp = *this;
++*this;
return tmp;
}
bidirectional_iterator_wrapper&
operator--()
{
ITERATOR_VERIFY(this->SharedInfo && this->ptr > this->SharedInfo->first);
this->ptr--;
return *this;
}
bidirectional_iterator_wrapper
operator--(int)
{
bidirectional_iterator_wrapper<T> tmp = *this;
--*this;
return tmp;
}
};
/**
* @brief random_access_iterator wrapper for pointer
*
* This class takes a pointer and wraps it to provide exactly
* the requirements of a forward_iterator. It should not be
* instansiated directly, but generated from a test_container
*/
template<class T>
struct random_access_iterator_wrapper:public bidirectional_iterator_wrapper<T>
{
typedef BoundsContainer<T> ContainerType;
typedef std::random_access_iterator_tag iterator_category;
random_access_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
: bidirectional_iterator_wrapper<T>(_ptr, SharedInfo_in)
{ }
random_access_iterator_wrapper(const random_access_iterator_wrapper<T>& in)
: bidirectional_iterator_wrapper<T>(in)
{ }
random_access_iterator_wrapper():bidirectional_iterator_wrapper<T>()
{ }
random_access_iterator_wrapper&
operator=(const random_access_iterator_wrapper& in)
{
this->ptr = in.ptr;
this->SharedInfo = in.SharedInfo;
return *this;
}
random_access_iterator_wrapper&
operator++()
{
ITERATOR_VERIFY(this->SharedInfo && this->ptr < this->SharedInfo->last);
this->ptr++;
return *this;
}
random_access_iterator_wrapper
operator++(int)
{
random_access_iterator_wrapper<T> tmp = *this;
++*this;
return tmp;
}
random_access_iterator_wrapper&
operator--()
{
ITERATOR_VERIFY(this->SharedInfo && this->ptr > this->SharedInfo->first);
this->ptr--;
return *this;
}
random_access_iterator_wrapper
operator--(int)
{
random_access_iterator_wrapper<T> tmp = *this;
--*this;
return tmp;
}
random_access_iterator_wrapper&
operator+=(ptrdiff_t n)
{
if(n > 0)
{
ITERATOR_VERIFY(n <= this->SharedInfo->last - this->ptr);
this->ptr += n;
}
else
{
ITERATOR_VERIFY(n <= this->ptr - this->SharedInfo->first);
this->ptr += n;
}
return *this;
}
random_access_iterator_wrapper&
operator-=(ptrdiff_t n)
{ return *this += -n; }
random_access_iterator_wrapper
operator-(ptrdiff_t n) const
{
random_access_iterator_wrapper<T> tmp = *this;
return tmp -= n;
}
ptrdiff_t
operator-(const random_access_iterator_wrapper<T>& in) const
{
ITERATOR_VERIFY(this->SharedInfo == in.SharedInfo);
return this->ptr - in.ptr;
}
T&
operator[](ptrdiff_t n) const
{ return *(*this + n); }
bool
operator<(const random_access_iterator_wrapper<T>& in) const
{
ITERATOR_VERIFY(this->SharedInfo == in.SharedInfo);
return this->ptr < in.ptr;
}
bool
operator>(const random_access_iterator_wrapper<T>& in) const
{
return in < *this;
}
bool
operator>=(const random_access_iterator_wrapper<T>& in) const
{
return !(*this < in);
}
bool
operator<=(const random_access_iterator_wrapper<T>& in) const
{
return !(*this > in);
}
};
template<typename T>
random_access_iterator_wrapper<T>
operator+(random_access_iterator_wrapper<T> it, ptrdiff_t n)
{ return it += n; }
template<typename T>
random_access_iterator_wrapper<T>
operator+(ptrdiff_t n, random_access_iterator_wrapper<T> it)
{ return it += n; }
/**
* @brief A container-type class for holding iterator wrappers
* test_container takes two parameters, a class T and an iterator
* wrapper templated by T (for example forward_iterator_wrapper<T>.
* It takes two pointers representing a range and presents them as
* a container of iterators.
*/
template <class T, template<class T> class ItType>
struct test_container
{
typename ItType<T>::ContainerType bounds;
test_container(T* _first, T* _last):bounds(_first, _last)
{ }
ItType<T>
it(int pos)
{
ITERATOR_VERIFY(pos >= 0 && pos <= (bounds.last - bounds.first));
return ItType<T>(bounds.first + pos, &bounds);
}
ItType<T>
it(T* pos)
{
ITERATOR_VERIFY(pos >= bounds.first && pos <= bounds.last);
return ItType<T>(pos, &bounds);
}
ItType<T>
begin()
{ return it(bounds.first); }
ItType<T>
end()
{ return it(bounds.last); }
};
}
#endif