This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[v3] chapter 20 conformance tweaks
- To: gcc-patches at gcc dot gnu dot org
- Subject: [v3] chapter 20 conformance tweaks
- From: Benjamin Kosnik <bkoz at redhat dot com>
- Date: Mon, 18 Jun 2001 18:50:25 -0700
Expect to see similar iterator type tests for checking inheritance in
the next couple of days.
tested x86/linux
2001-06-18 Benjamin Kosnik <bkoz@redhat.com>
* include/bits/stl_raw_storage_iter.h: Format. Correct derivation.
* testsuite/20_util/raw_storage_iterator.cc: Same.
* include/bits/stl_alloc.h (_S_chunk_alloc): Change malloc to
operator new.
(__mem_interface): New typedef for switching between malloc and new.
* testsuite/20_util/allocator_members.cc: New file.
* testsuite/20_util/comparisons.cc: New file.
* testsuite/20_util/pairs.cc: New file.
Index: include/bits/stl_alloc.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_alloc.h,v
retrieving revision 1.3
diff -c -p -r1.3 stl_alloc.h
*** stl_alloc.h 2001/03/04 21:34:01 1.3
--- stl_alloc.h 2001/06/19 01:49:04
***************
*** 67,151 ****
namespace std
{
!
! // Malloc-based allocator. Typically slower than default alloc below.
! // Typically thread-safe and more storage efficient.
! template <int __inst>
! class __malloc_alloc_template {
!
! private:
!
! static void* _S_oom_malloc(size_t);
! static void* _S_oom_realloc(void*, size_t);
! static void (* __malloc_alloc_oom_handler)();
!
! public:
!
! static void* allocate(size_t __n)
! {
! void* __result = malloc(__n);
! if (0 == __result) __result = _S_oom_malloc(__n);
! return __result;
! }
!
! static void deallocate(void* __p, size_t /* __n */)
{
! free(__p);
! }
!
! static void* reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
! {
! void* __result = realloc(__p, __new_sz);
! if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);
! return __result;
! }
!
! static void (* __set_malloc_handler(void (*__f)()))()
! {
! void (* __old)() = __malloc_alloc_oom_handler;
! __malloc_alloc_oom_handler = __f;
! return(__old);
! }
!
! };
!
! // malloc_alloc out-of-memory handling
!
! template <int __inst>
! void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;
! template <int __inst>
! void*
! __malloc_alloc_template<__inst>::_S_oom_malloc(size_t __n)
! {
! void (* __my_malloc_handler)();
! void* __result;
! for (;;) {
! __my_malloc_handler = __malloc_alloc_oom_handler;
! if (0 == __my_malloc_handler) { std::__throw_bad_alloc(); }
! (*__my_malloc_handler)();
! __result = malloc(__n);
! if (__result) return(__result);
}
! }
!
! template <int __inst>
! void* __malloc_alloc_template<__inst>::_S_oom_realloc(void* __p, size_t __n)
! {
! void (* __my_malloc_handler)();
! void* __result;
!
! for (;;) {
! __my_malloc_handler = __malloc_alloc_oom_handler;
! if (0 == __my_malloc_handler) { std::__throw_bad_alloc(); }
! (*__my_malloc_handler)();
! __result = realloc(__p, __n);
! if (__result) return(__result);
}
- }
! typedef __malloc_alloc_template<0> malloc_alloc;
template<class _Tp, class _Alloc>
class simple_alloc {
--- 67,172 ----
namespace std
{
! // A new-based allocator, as required by the standard.
! class __new_alloc
{
! public:
! static void*
! allocate(size_t __n)
! { return ::operator new(__n); }
!
! static void
! deallocate(void* __p, size_t)
! { ::operator delete(__p); }
! };
!
! // Malloc-based allocator. Typically slower than default alloc below.
! // Typically thread-safe and more storage efficient.
! template <int __inst>
! class __malloc_alloc_template
! {
! private:
! static void* _S_oom_malloc(size_t);
! static void* _S_oom_realloc(void*, size_t);
! static void (* __malloc_alloc_oom_handler)();
!
! public:
! static void*
! allocate(size_t __n)
! {
! void* __result = malloc(__n);
! if (0 == __result) __result = _S_oom_malloc(__n);
! return __result;
! }
! static void
! deallocate(void* __p, size_t /* __n */)
! { free(__p); }
!
! static void*
! reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
! {
! void* __result = realloc(__p, __new_sz);
! if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);
! return __result;
! }
!
! static void (* __set_malloc_handler(void (*__f)()))()
! {
! void (* __old)() = __malloc_alloc_oom_handler;
! __malloc_alloc_oom_handler = __f;
! return(__old);
! }
! };
! // malloc_alloc out-of-memory handling
! template <int __inst>
! void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;
!
! template <int __inst>
! void*
! __malloc_alloc_template<__inst>::_S_oom_malloc(size_t __n)
! {
! void (* __my_malloc_handler)();
! void* __result;
!
! for (;;)
! {
! __my_malloc_handler = __malloc_alloc_oom_handler;
! if (0 == __my_malloc_handler)
! std::__throw_bad_alloc();
! (*__my_malloc_handler)();
! __result = malloc(__n);
! if (__result)
! return(__result);
! }
}
!
! template <int __inst>
! void*
! __malloc_alloc_template<__inst>::_S_oom_realloc(void* __p, size_t __n)
! {
! void (* __my_malloc_handler)();
! void* __result;
!
! for (;;)
! {
! __my_malloc_handler = __malloc_alloc_oom_handler;
! if (0 == __my_malloc_handler)
! std::__throw_bad_alloc();
! (*__my_malloc_handler)();
! __result = realloc(__p, __n);
! if (__result)
! return(__result);
! }
}
! // Determines the underlying allocator choice.
! # ifdef __USE_MALLOC
! typedef __malloc_alloc_template<0> __mem_interface;
! #else
! typedef __new_alloc __mem_interface;
! #endif
template<class _Tp, class _Alloc>
class simple_alloc {
*************** public:
*** 295,322 ****
{
void* __ret = 0;
! if (__n > (size_t) _MAX_BYTES) {
! __ret = malloc_alloc::allocate(__n);
! }
! else {
! _Obj* __STL_VOLATILE* __my_free_list
! = _S_free_list + _S_freelist_index(__n);
! // Acquire the lock here with a constructor call.
! // This ensures that it is released in exit or during stack
! // unwinding.
# ifndef _NOTHREADS
! /*REFERENCED*/
! _Lock __lock_instance;
# endif
! _Obj* __RESTRICT __result = *__my_free_list;
! if (__result == 0)
! __ret = _S_refill(_S_round_up(__n));
! else {
! *__my_free_list = __result -> _M_free_list_link;
! __ret = __result;
}
! }
!
return __ret;
};
--- 316,343 ----
{
void* __ret = 0;
! if (__n > (size_t) _MAX_BYTES)
! __ret = __mem_interface::allocate(__n);
! else
! {
! _Obj* __STL_VOLATILE* __my_free_list = _S_free_list + _S_freelist_index(__n);
! // Acquire the lock here with a constructor call.
! // This ensures that it is released in exit or during stack
! // unwinding.
# ifndef _NOTHREADS
! /*REFERENCED*/
! _Lock __lock_instance;
# endif
! _Obj* __RESTRICT __result = *__my_free_list;
! if (__result == 0)
! __ret = _S_refill(_S_round_up(__n));
! else
! {
! *__my_free_list = __result -> _M_free_list_link;
! __ret = __result;
! }
}
!
return __ret;
};
*************** public:
*** 324,349 ****
static void deallocate(void* __p, size_t __n)
{
if (__n > (size_t) _MAX_BYTES)
! malloc_alloc::deallocate(__p, __n);
! else {
! _Obj* __STL_VOLATILE* __my_free_list
= _S_free_list + _S_freelist_index(__n);
! _Obj* __q = (_Obj*)__p;
!
! // acquire lock
# ifndef _NOTHREADS
! /*REFERENCED*/
! _Lock __lock_instance;
# endif /* _NOTHREADS */
! __q -> _M_free_list_link = *__my_free_list;
! *__my_free_list = __q;
! // lock is released here
! }
}
!
static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz);
!
! } ;
typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
typedef __default_alloc_template<false, 0> single_client_alloc;
--- 345,370 ----
static void deallocate(void* __p, size_t __n)
{
if (__n > (size_t) _MAX_BYTES)
! __mem_interface::deallocate(__p, __n);
! else
! {
! _Obj* __STL_VOLATILE* __my_free_list
= _S_free_list + _S_freelist_index(__n);
! _Obj* __q = (_Obj*)__p;
!
! // acquire lock
# ifndef _NOTHREADS
! /*REFERENCED*/
! _Lock __lock_instance;
# endif /* _NOTHREADS */
! __q -> _M_free_list_link = *__my_free_list;
! *__my_free_list = __q;
! // lock is released here
! }
}
!
static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz);
! };
typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
typedef __default_alloc_template<false, 0> single_client_alloc;
*************** __default_alloc_template<__threads, __in
*** 377,435 ****
size_t __total_bytes = __size * __nobjs;
size_t __bytes_left = _S_end_free - _S_start_free;
! if (__bytes_left >= __total_bytes) {
__result = _S_start_free;
_S_start_free += __total_bytes;
return(__result);
! } else if (__bytes_left >= __size) {
__nobjs = (int)(__bytes_left/__size);
__total_bytes = __size * __nobjs;
__result = _S_start_free;
_S_start_free += __total_bytes;
return(__result);
! } else {
size_t __bytes_to_get =
2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
// Try to make use of the left-over piece.
! if (__bytes_left > 0) {
! _Obj* __STL_VOLATILE* __my_free_list =
! _S_free_list + _S_freelist_index(__bytes_left);
!
! ((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list;
! *__my_free_list = (_Obj*)_S_start_free;
! }
! _S_start_free = (char*)malloc(__bytes_to_get);
! if (0 == _S_start_free) {
size_t __i;
_Obj* __STL_VOLATILE* __my_free_list;
_Obj* __p;
! // Try to make do with what we have. That can't
! // hurt. We do not try smaller requests, since that tends
! // to result in disaster on multi-process machines.
! for (__i = __size;
! __i <= (size_t) _MAX_BYTES;
! __i += (size_t) _ALIGN) {
__my_free_list = _S_free_list + _S_freelist_index(__i);
__p = *__my_free_list;
! if (0 != __p) {
! *__my_free_list = __p -> _M_free_list_link;
! _S_start_free = (char*)__p;
_S_end_free = _S_start_free + __i;
return(_S_chunk_alloc(__size, __nobjs));
// Any leftover piece will eventually make it to the
// right free list.
! }
! }
_S_end_free = 0; // In case of exception.
! _S_start_free = (char*)malloc_alloc::allocate(__bytes_to_get);
// This should either throw an
// exception or remedy the situation. Thus we assume it
// succeeded.
! }
_S_heap_size += __bytes_to_get;
_S_end_free = _S_start_free + __bytes_to_get;
return(_S_chunk_alloc(__size, __nobjs));
! }
}
--- 398,464 ----
size_t __total_bytes = __size * __nobjs;
size_t __bytes_left = _S_end_free - _S_start_free;
! if (__bytes_left >= __total_bytes)
! {
__result = _S_start_free;
_S_start_free += __total_bytes;
return(__result);
! }
! else if (__bytes_left >= __size)
! {
__nobjs = (int)(__bytes_left/__size);
__total_bytes = __size * __nobjs;
__result = _S_start_free;
_S_start_free += __total_bytes;
return(__result);
! }
! else
! {
size_t __bytes_to_get =
2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
// Try to make use of the left-over piece.
! if (__bytes_left > 0)
! {
! _Obj* __STL_VOLATILE* __my_free_list =
! _S_free_list + _S_freelist_index(__bytes_left);
!
! ((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list;
! *__my_free_list = (_Obj*)_S_start_free;
! }
! _S_start_free = (char*) __mem_interface::allocate(__bytes_to_get);
! if (0 == _S_start_free)
! {
size_t __i;
_Obj* __STL_VOLATILE* __my_free_list;
_Obj* __p;
! // Try to make do with what we have. That can't hurt. We
! // do not try smaller requests, since that tends to result
! // in disaster on multi-process machines.
! __i = __size;
! for (; __i <= (size_t) _MAX_BYTES; __i += (size_t) _ALIGN)
! {
__my_free_list = _S_free_list + _S_freelist_index(__i);
__p = *__my_free_list;
! if (0 != __p)
! {
! *__my_free_list = __p -> _M_free_list_link;
! _S_start_free = (char*)__p;
_S_end_free = _S_start_free + __i;
return(_S_chunk_alloc(__size, __nobjs));
// Any leftover piece will eventually make it to the
// right free list.
! }
! }
_S_end_free = 0; // In case of exception.
! _S_start_free = (char*)__mem_interface::allocate(__bytes_to_get);
// This should either throw an
// exception or remedy the situation. Thus we assume it
// succeeded.
! }
_S_heap_size += __bytes_to_get;
_S_end_free = _S_start_free + __bytes_to_get;
return(_S_chunk_alloc(__size, __nobjs));
! }
}
Index: include/bits/stl_raw_storage_iter.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_raw_storage_iter.h,v
retrieving revision 1.2
diff -c -p -r1.2 stl_raw_storage_iter.h
*** stl_raw_storage_iter.h 2001/03/04 21:34:01 1.2
--- stl_raw_storage_iter.h 2001/06/19 01:49:04
***************
*** 33,71 ****
namespace std
{
! template <class _ForwardIterator, class _Tp>
! class raw_storage_iterator {
! protected:
! _ForwardIterator _M_iter;
! public:
! typedef output_iterator_tag iterator_category;
! typedef void value_type;
! typedef void difference_type;
! typedef void pointer;
! typedef void reference;
!
! explicit raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {}
! raw_storage_iterator& operator*() { return *this; }
! raw_storage_iterator& operator=(const _Tp& __element) {
! construct(&*_M_iter, __element);
! return *this;
! }
! raw_storage_iterator<_ForwardIterator, _Tp>& operator++() {
! ++_M_iter;
! return *this;
! }
! raw_storage_iterator<_ForwardIterator, _Tp> operator++(int) {
! raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
! ++_M_iter;
! return __tmp;
! }
! };
} // namespace std
! #endif /* _CPP_BITS_STL_RAW_STORAGE_ITERATOR_H */
// Local Variables:
// mode:C++
--- 33,77 ----
namespace std
{
+ template <class _ForwardIterator, class _Tp>
+ class raw_storage_iterator
+ : public iterator<output_iterator_tag, void, void, void, void>
+ {
+ protected:
+ _ForwardIterator _M_iter;
! public:
! explicit
! raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {}
+ raw_storage_iterator&
+ operator*() { return *this; }
+ raw_storage_iterator&
+ operator=(const _Tp& __element)
+ {
+ construct(&*_M_iter, __element);
+ return *this;
+ }
+
+ raw_storage_iterator<_ForwardIterator, _Tp>&
+ operator++()
+ {
+ ++_M_iter;
+ return *this;
+ }
+
+ raw_storage_iterator<_ForwardIterator, _Tp>
+ operator++(int)
+ {
+ raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
+ ++_M_iter;
+ return __tmp;
+ }
+ };
} // namespace std
! #endif
// Local Variables:
// mode:C++
Index: testsuite/20_util/allocator_members.cc
===================================================================
RCS file: allocator_members.cc
diff -N allocator_members.cc
*** /dev/null Tue May 5 13:32:27 1998
--- allocator_members.cc Mon Jun 18 18:49:05 2001
***************
*** 0 ****
--- 1,60 ----
+ // 2001-06-14 Benjamin Kosnik <bkoz@redhat.com>
+
+ // Copyright (C) 2001 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.
+
+ // 20.4.1.1 allocator members
+
+ #include <memory>
+ #include <cstdlib>
+ #include <debug_assert.h>
+
+ struct gnu { };
+
+ bool check_new = false;
+ bool check_delete = false;
+
+ void*
+ operator new(std::size_t n) throw(std::bad_alloc)
+ {
+ check_new = true;
+ return std::malloc(n);
+ }
+
+ void operator delete(void *v) throw()
+ {
+ check_delete = true;
+ return std::free(v);
+ }
+
+ int main(void)
+ {
+ bool test = true;
+ std::allocator<gnu> obj;
+
+ // XXX These should work for various size allocation and
+ // deallocations. Currently, they only work as expected for sizes >
+ // _MAX_BYTES as defined in stl_alloc.h, which happes to be 128.
+ gnu* pobj = obj.allocate(256);
+ VERIFY( check_new );
+
+ obj.deallocate(pobj, 256);
+ VERIFY( check_delete );
+
+ return 0;
+ }
Index: testsuite/20_util/comparisons.cc
===================================================================
RCS file: comparisons.cc
diff -N comparisons.cc
*** /dev/null Tue May 5 13:32:27 1998
--- comparisons.cc Mon Jun 18 18:49:05 2001
***************
*** 0 ****
--- 1,53 ----
+ // 2001-06-18 Benjamin Kosnik <bkoz@redhat.com>
+
+ // Copyright (C) 2001 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.
+
+ // 20.3.3 Comparisons
+
+ #include <functional>
+
+ class gnu_obj
+ {
+ int i;
+ public:
+ gnu_obj(int arg = 0): i(arg) { }
+ bool operator==(const gnu_obj& rhs) const { return i == rhs.i; }
+ bool operator!=(const gnu_obj& rhs) const { return i != rhs.i; }
+ bool operator<(const gnu_obj& rhs) const { return i < rhs.i; }
+ };
+
+ template<typename T>
+ struct gnu_t
+ {
+ bool b;
+ public:
+ gnu_t(bool arg = 0): b(arg) { }
+ bool operator==(const gnu_t& rhs) const { return b == rhs.b; }
+ bool operator!=(const gnu_t& rhs) const { return b != rhs.b; }
+ bool operator<(const gnu_t& rhs) const { return b == rhs.b; }
+ };
+
+ template struct std::not_equal_to<void*>;
+ template struct std::not_equal_to<gnu_obj>;
+ template struct std::not_equal_to<gnu_t<long> >;
+
+ int main()
+ {
+ return 0;
+ }
Index: testsuite/20_util/pairs.cc
===================================================================
RCS file: pairs.cc
diff -N pairs.cc
*** /dev/null Tue May 5 13:32:27 1998
--- pairs.cc Mon Jun 18 18:49:06 2001
***************
*** 0 ****
--- 1,140 ----
+ // 2001-06-18 Benjamin Kosnik <bkoz@redhat.com>
+
+ // Copyright (C) 2001 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.
+
+ // 20.2.2 Pairs
+
+ #include <utility>
+ #include <debug_assert.h>
+
+ class gnu_obj
+ {
+ int i;
+ public:
+ gnu_obj(int arg = 0): i(arg) { }
+ bool operator==(const gnu_obj& rhs) const { return i == rhs.i; }
+ bool operator<(const gnu_obj& rhs) const { return i < rhs.i; }
+ };
+
+ template<typename T>
+ struct gnu_t
+ {
+ bool b;
+ public:
+ gnu_t(bool arg = 0): b(arg) { }
+ bool operator==(const gnu_t& rhs) const { return b == rhs.b; }
+ bool operator<(const gnu_t& rhs) const { return int(b) < int(rhs.b); }
+ };
+
+
+ // heterogeneous
+ void test01()
+ {
+ bool test = true;
+
+ std::pair<bool, long> p_bl_1(true, 433);
+ std::pair<bool, long> p_bl_2 = std::make_pair(true, 433);
+ VERIFY( p_bl_1 == p_bl_2 );
+ VERIFY( !(p_bl_1 < p_bl_2) );
+
+ std::pair<const char*, float> p_sf_1("total enlightenment", 433.00);
+ std::pair<const char*, float> p_sf_2 = std::make_pair("total enlightenment",
+ 433.00);
+ VERIFY( p_sf_1 == p_sf_2 );
+ VERIFY( !(p_sf_1 < p_sf_2) );
+
+ std::pair<const char*, gnu_obj> p_sg_1("enlightenment", gnu_obj(5));
+ std::pair<const char*, gnu_obj> p_sg_2 = std::make_pair("enlightenment",
+ gnu_obj(5));
+ VERIFY( p_sg_1 == p_sg_2 );
+ VERIFY( !(p_sg_1 < p_sg_2) );
+
+ std::pair<gnu_t<long>, gnu_obj> p_st_1(gnu_t<long>(false), gnu_obj(5));
+ std::pair<gnu_t<long>, gnu_obj> p_st_2 = std::make_pair(gnu_t<long>(false),
+ gnu_obj(5));
+ VERIFY( p_st_1 == p_st_2 );
+ VERIFY( !(p_st_1 < p_st_2) );
+ }
+
+ // homogeneous
+ void test02()
+ {
+ bool test = true;
+
+ std::pair<bool, bool> p_bb_1(true, false);
+ std::pair<bool, bool> p_bb_2 = std::make_pair(true, false);
+ VERIFY( p_bb_1 == p_bb_2 );
+ VERIFY( !(p_bb_1 < p_bb_2) );
+ }
+
+
+ // const
+ void test03()
+ {
+ bool test = true;
+
+ const std::pair<bool, long> p_bl_1(true, 433);
+ const std::pair<bool, long> p_bl_2 = std::make_pair(true, 433);
+ VERIFY( p_bl_1 == p_bl_2 );
+ VERIFY( !(p_bl_1 < p_bl_2) );
+
+ const std::pair<const char*, float> p_sf_1("total enlightenment", 433.00);
+ const std::pair<const char*, float> p_sf_2 =
+ std::make_pair("total enlightenment", 433.00);
+ VERIFY( p_sf_1 == p_sf_2 );
+ VERIFY( !(p_sf_1 < p_sf_2) );
+
+ const std::pair<const char*, gnu_obj> p_sg_1("enlightenment", gnu_obj(5));
+ const std::pair<const char*, gnu_obj> p_sg_2 =
+ std::make_pair("enlightenment", gnu_obj(5));
+ VERIFY( p_sg_1 == p_sg_2 );
+ VERIFY( !(p_sg_1 < p_sg_2) );
+
+ const std::pair<gnu_t<long>, gnu_obj> p_st_1(gnu_t<long>(false), gnu_obj(5));
+ const std::pair<gnu_t<long>, gnu_obj> p_st_2 =
+ std::make_pair(gnu_t<long>(false), gnu_obj(5));
+ VERIFY( p_st_1 == p_st_2 );
+ VERIFY( !(p_st_1 < p_st_2) );
+ }
+
+ // const&
+ void test04()
+ {
+ bool test = true;
+ const gnu_obj& obj1 = gnu_obj(5);
+ const std::pair<const char*, gnu_obj> p_sg_1("enlightenment", obj1);
+ const std::pair<const char*, gnu_obj> p_sg_2 =
+ std::make_pair("enlightenment", obj1);
+ VERIFY( p_sg_1 == p_sg_2 );
+ VERIFY( !(p_sg_1 < p_sg_2) );
+
+ const gnu_t<long>& tmpl1 = gnu_t<long>(false);
+ const std::pair<gnu_t<long>, gnu_obj> p_st_1(tmpl1, obj1);
+ const std::pair<gnu_t<long>, gnu_obj> p_st_2 = std::make_pair(tmpl1, obj1);
+ VERIFY( p_st_1 == p_st_2 );
+ VERIFY( !(p_st_1 < p_st_2) );
+ }
+
+ int main()
+ {
+ test01();
+ test02();
+ test03();
+ test04();
+ }
Index: testsuite/20_util/raw_storage_iterator.cc
===================================================================
RCS file: raw_storage_iterator.cc
diff -N raw_storage_iterator.cc
*** /dev/null Tue May 5 13:32:27 1998
--- raw_storage_iterator.cc Mon Jun 18 18:49:06 2001
***************
*** 0 ****
--- 1,47 ----
+ // 2001-06-18 Benjamin Kosnik <bkoz@redhat.com>
+
+ // Copyright (C) 2001 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.
+
+ // 20.4.2 raw storage iterator
+
+ #include <memory>
+
+ void test01()
+ {
+ using namespace std;
+
+ // Check for required base class.
+ long l;
+ raw_storage_iterator<long*, long> rs_it(&l);
+ iterator<output_iterator_tag, void, void, void, void>* base = &rs_it;
+
+ // Check for required typedefs
+ typedef raw_storage_iterator<long*, long>::value_type value_type;
+ typedef raw_storage_iterator<long*, long>::difference_type difference_type;
+ typedef raw_storage_iterator<long*, long>::pointer pointer;
+ typedef raw_storage_iterator<long*, long>::reference reference;
+ typedef raw_storage_iterator<long*, long>::iterator_category iteratory_category;
+
+ }
+
+ int main()
+ {
+ test01();
+ return 0;
+ }