OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

std_memory.h: Fix formatting.

Browse Source 
2002-07-03  Benjamin Kosnik  <bkoz@redhat.com>

	* include/std/std_memory.h: Fix formatting.
	* testsuite/20_util/auto_ptr_neg.cc: New.
	* testsuite/20_util/auto_ptr.cc: Tweaks.
	* testsuite/23_containers/map_operators.cc (test01): Split into..
	* testsuite/23_containers/map_operators_neg.cc (test01): ...this. New.
	* testsuite/23_containers/set_operators.cc: Move to...
	* testsuite/23_containers/set_operators_neg.cc: ...here.
	* testsuite/README: Add some more naming rules.

From-SVN: r55241
This commit is contained in:
Benjamin Kosnik 2002-07-04 07:25:19 +00:00 committed by Benjamin Kosnik
parent 7c0f8bc1f4
commit 5acf59f8e1
8 changed files with 402 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,14 @@
2002-07-03 Benjamin Kosnik <bkoz@redhat.com>
* include/std/std_memory.h: Fix formatting.
* testsuite/20_util/auto_ptr_neg.cc: New.
* testsuite/20_util/auto_ptr.cc: Tweaks.
* testsuite/23_containers/map_operators.cc (test01): Split into..
* testsuite/23_containers/map_operators_neg.cc (test01): ...this. New.
* testsuite/23_containers/set_operators.cc: Move to...
* testsuite/23_containers/set_operators_neg.cc: ...here.
* testsuite/README: Add some more naming rules.
2002-07-03 Steev Wilcox <steev@paradigmds.com> 2002-07-03 Steev Wilcox <steev@paradigmds.com>
PR libstdc++/7057 PR libstdc++/7057

557
libstdc++-v3/include/std/std_memory.h
View File

@ -58,314 +58,301 @@
#include <bits/stl_uninitialized.h> #include <bits/stl_uninitialized.h>
#include <bits/stl_raw_storage_iter.h> #include <bits/stl_raw_storage_iter.h>
// Since this entire file is within namespace std, there's no reason to
// waste two spaces along the left column. Thus the leading indentation is
// slightly violated from here on.
namespace std namespace std
{ {
/** /**
* @if maint * @if maint
* This is a helper function. The unused second parameter exists to * This is a helper function. The unused second parameter exists to
* permit the real get_temporary_buffer to use template parameter deduction. * permit the real get_temporary_buffer to use template parameter deduction.
* *
* XXX This should perhaps use the pool. * XXX This should perhaps use the pool.
* @endif * @endif
*/ */
template <typename _Tp> template<typename _Tp>
pair<_Tp*, ptrdiff_t> pair<_Tp*, ptrdiff_t>
__get_temporary_buffer(ptrdiff_t __len, _Tp*) __get_temporary_buffer(ptrdiff_t __len, _Tp*)
{ {
if (__len > ptrdiff_t(INT_MAX / sizeof(_Tp))) if (__len > ptrdiff_t(INT_MAX / sizeof(_Tp)))
__len = INT_MAX / sizeof(_Tp); __len = INT_MAX / sizeof(_Tp);
while (__len > 0) { while (__len > 0)
_Tp* __tmp = (_Tp*) std::malloc((std::size_t)__len * sizeof(_Tp)); {
if (__tmp != 0) _Tp* __tmp = (_Tp*) std::malloc((std::size_t)__len * sizeof(_Tp));
return pair<_Tp*, ptrdiff_t>(__tmp, __len); if (__tmp != 0)
__len /= 2; return pair<_Tp*, ptrdiff_t>(__tmp, __len);
} __len /= 2;
}
return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0); return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0);
} }
/**
* @brief This is a mostly-useless wrapper around malloc().
* @param len The number of objects of type Tp.
* @return See full description.
*
* Reinventing the wheel, but this time with prettier spokes!
*
* This function tries to obtain storage for @c len adjacent Tp objects.
* The objects themselves are not constructed, of course. A pair<> is
* returned containing "the buffer s address and capacity (in the units of
* sizeof(Tp)), or a pair of 0 values if no storage can be obtained."
* Note that the capacity obtained may be less than that requested if the
* memory is unavailable; you should compare len with the .second return
* value.
*/
template<typename _Tp>
inline pair<_Tp*,ptrdiff_t>
get_temporary_buffer(ptrdiff_t __len)
{
return __get_temporary_buffer(__len, (_Tp*) 0);
}
/**
* @brief The companion to get_temporary_buffer().
* @param p A buffer previously allocated by get_temporary_buffer.
* @return None.
*
* Frees the memory pointed to by p.
*/
template<typename _Tp>
void
return_temporary_buffer(_Tp* __p)
{
std::free(__p);
}
/**
* A wrapper class to provide auto_ptr with reference semantics. For
* example, an auto_ptr can be assigned (or constructed from) the result of
* a function which returns an auto_ptr by value.
*
* All the auto_ptr_ref stuff should happen behind the scenes.
*/
template<typename _Tp1>
struct auto_ptr_ref
{
_Tp1* _M_ptr;
explicit
auto_ptr_ref(_Tp1* __p)
: _M_ptr(__p) {}
};
/**
* @brief A simple smart pointer providing strict ownership semantics.
*
* The Standard says:
* <pre>
* An @c auto_ptr owns the object it holds a pointer to. Copying an
* @c auto_ptr copies the pointer and transfers ownership to the destination.
* If more than one @c auto_ptr owns the same object at the same time the
* behavior of the program is undefined.
*
* The uses of @c auto_ptr include providing temporary exception-safety for
* dynamically allocated memory, passing ownership of dynamically allocated
* memory to a function, and returning dynamically allocated memory from a
* function. @c auto_ptr does not meet the CopyConstructible and Assignable
* requirements for Standard Library <a href="tables.html#65">container</a>
* elements and thus instantiating a Standard Library container with an
* @c auto_ptr results in undefined behavior.
* </pre>
* Quoted from [20.4.5]/3.
*
* Good examples of what can and cannot be done with auto_ptr can be found
* in the libstdc++ testsuite.
*
* @if maint
* _GLIBCPP_RESOLVE_LIB_DEFECTS
* 127. auto_ptr<> conversion issues
* These resolutions have all been incorporated.
* @endif
*/
template<typename _Tp>
class auto_ptr
{
private:
_Tp* _M_ptr;
public:
/// The pointed-to type.
typedef _Tp element_type;
/** /**
* @brief An %auto_ptr is usually constructed from a raw pointer. * @brief This is a mostly-useless wrapper around malloc().
* @param p A pointer (defaults to NULL). * @param len The number of objects of type Tp.
* @return See full description.
* *
* This object now @e owns the object pointed to by @a p. * Reinventing the wheel, but this time with prettier spokes!
*/ *
explicit * This function tries to obtain storage for @c len adjacent Tp objects.
auto_ptr(element_type* __p = 0) throw() * The objects themselves are not constructed, of course. A pair<> is
: _M_ptr(__p) { } * returned containing "the buffer s address and capacity (in the units of
* sizeof(Tp)), or a pair of 0 values if no storage can be obtained."
* Note that the capacity obtained may be less than that requested if the
* memory is unavailable; you should compare len with the .second return
* value.
*/
template<typename _Tp>
inline pair<_Tp*,ptrdiff_t>
get_temporary_buffer(ptrdiff_t __len)
{ return __get_temporary_buffer(__len, (_Tp*) 0); }
/** /**
* @brief An %auto_ptr can be constructed from another %auto_ptr. * @brief The companion to get_temporary_buffer().
* @param a Another %auto_ptr of the same type. * @param p A buffer previously allocated by get_temporary_buffer.
* @return None.
* *
* This object now @e owns the object previously owned by @a a, which has * Frees the memory pointed to by p.
* given up ownsership. */
*/ template<typename _Tp>
auto_ptr(auto_ptr& __a) throw() void
: _M_ptr(__a.release()) { } return_temporary_buffer(_Tp* __p)
{ std::free(__p); }
/** /**
* @brief An %auto_ptr can be constructed from another %auto_ptr. * A wrapper class to provide auto_ptr with reference semantics. For
* @param a Another %auto_ptr of a different but related type. * example, an auto_ptr can be assigned (or constructed from) the result of
* a function which returns an auto_ptr by value.
* *
* A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type. * All the auto_ptr_ref stuff should happen behind the scenes.
* */
* This object now @e owns the object previously owned by @a a, which has
* given up ownsership.
*/
template<typename _Tp1> template<typename _Tp1>
auto_ptr(auto_ptr<_Tp1>& __a) throw() struct auto_ptr_ref
: _M_ptr(__a.release()) { }
/**
* @brief %auto_ptr assignment operator.
* @param a Another %auto_ptr of the same type.
*
* This object now @e owns the object previously owned by @a a, which has
* given up ownsership. The object that this one @e used to own and
* track has been deleted.
*/
auto_ptr&
operator=(auto_ptr& __a) throw()
{ {
reset(__a.release()); _Tp1* _M_ptr;
return *this;
} explicit
auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
};
/** /**
* @brief %auto_ptr assignment operator. * @brief A simple smart pointer providing strict ownership semantics.
* @param a Another %auto_ptr of a different but related type.
* *
* A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type. * The Standard says:
* <pre>
* An @c auto_ptr owns the object it holds a pointer to. Copying an
* @c auto_ptr copies the pointer and transfers ownership to the destination.
* If more than one @c auto_ptr owns the same object at the same time the
* behavior of the program is undefined.
* *
* This object now @e owns the object previously owned by @a a, which has * The uses of @c auto_ptr include providing temporary exception-safety for
* given up ownsership. The object that this one @e used to own and * dynamically allocated memory, passing ownership of dynamically allocated
* track has been deleted. * memory to a function, and returning dynamically allocated memory from a
*/ * function. @c auto_ptr does not meet the CopyConstructible and Assignable
template <typename _Tp1> * requirements for Standard Library <a href="tables.html#65">container</a>
auto_ptr& * elements and thus instantiating a Standard Library container with an
operator=(auto_ptr<_Tp1>& __a) throw() * @c auto_ptr results in undefined behavior.
{ * </pre>
reset(__a.release()); * Quoted from [20.4.5]/3.
return *this; *
} * Good examples of what can and cannot be done with auto_ptr can be found
* in the libstdc++ testsuite.
/**
* When the %auto_ptr goes out of scope, the object it owns is deleted.
* If it no longer owns anything (i.e., @c get() is @c NULL), then this
* has no effect.
* *
* @if maint * @if maint
* The C++ standard says there is supposed to be an empty throw * _GLIBCPP_RESOLVE_LIB_DEFECTS
* specification here, but omitting it is standard conforming. Its * 127. auto_ptr<> conversion issues
* presence can be detected only if _Tp::~_Tp() throws, but this is * These resolutions have all been incorporated.
* prohibited. [17.4.3.6]/2 * @endif
* @end maint */
*/ template<typename _Tp>
~auto_ptr() { delete _M_ptr; } class auto_ptr
/**
* @brief Smart pointer dereferencing.
*
* If this %auto_ptr no longer owns anything, then this operation will
* crash. (For a smart pointer, "no longer owns anything" is the same as
* being a null pointer, and you know what happens when you dereference
* one of those...)
*/
element_type&
operator*() const throw() { return *_M_ptr; }
/**
* @brief Smart pointer dereferencing.
*
* This returns the pointer itself, which the language then will
* automatically cause to be dereferenced.
*/
element_type*
operator->() const throw() { return _M_ptr; }
/**
* @brief Bypassing the smart pointer.
* @return The raw pointer being managed.
*
* You can get a copy of the pointer that this object owns, for
* situations such as passing to a function which only accepts a raw
* pointer.
*
* @note This %auto_ptr still owns the memory.
*/
element_type*
get() const throw() { return _M_ptr; }
/**
* @brief Bypassing the smart pointer.
* @return The raw pointer being managed.
*
* You can get a copy of the pointer that this object owns, for
* situations such as passing to a function which only accepts a raw
* pointer.
*
* @note This %auto_ptr no longer owns the memory. When this object
* goes out of scope, nothing will happen.
*/
element_type*
release() throw()
{ {
element_type* __tmp = _M_ptr; private:
_M_ptr = 0; _Tp* _M_ptr;
return __tmp;
} public:
/// The pointed-to type.
typedef _Tp element_type;
/**
* @brief An %auto_ptr is usually constructed from a raw pointer.
* @param p A pointer (defaults to NULL).
*
* This object now @e owns the object pointed to by @a p.
*/
explicit
auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
/** /**
* @brief Forcibly deletes the managed object. * @brief An %auto_ptr can be constructed from another %auto_ptr.
* @param p A pointer (defaults to NULL). * @param a Another %auto_ptr of the same type.
* *
* This object now @e owns the object pointed to by @a p. The previous * This object now @e owns the object previously owned by @a a,
* object has been deleted. * which has given up ownsership.
*/ */
void auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
reset(element_type* __p = 0) throw()
{ /**
if (__p != _M_ptr) * @brief An %auto_ptr can be constructed from another %auto_ptr.
* @param a Another %auto_ptr of a different but related type.
*
* A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.
*
* This object now @e owns the object previously owned by @a a,
* which has given up ownsership.
*/
template<typename _Tp1>
auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
/**
* @brief %auto_ptr assignment operator.
* @param a Another %auto_ptr of the same type.
*
* This object now @e owns the object previously owned by @a a,
* which has given up ownsership. The object that this one @e
* used to own and track has been deleted.
*/
auto_ptr&
operator=(auto_ptr& __a) throw()
{
reset(__a.release());
return *this;
}
/**
* @brief %auto_ptr assignment operator.
* @param a Another %auto_ptr of a different but related type.
*
* A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.
*
* This object now @e owns the object previously owned by @a a,
* which has given up ownsership. The object that this one @e
* used to own and track has been deleted.
*/
template<typename _Tp1>
auto_ptr&
operator=(auto_ptr<_Tp1>& __a) throw()
{ {
delete _M_ptr; reset(__a.release());
_M_ptr = __p; return *this;
} }
}
/** @{ /**
* @brief Automatic conversions * When the %auto_ptr goes out of scope, the object it owns is deleted.
* * If it no longer owns anything (i.e., @c get() is @c NULL), then this
* These operations convert an %auto_ptr into and from an auto_ptr_ref * has no effect.
* automatically as needed. This allows constructs such as *
* @code * @if maint
* auto_ptr<Derived> func_returning_auto_ptr(.....); * The C++ standard says there is supposed to be an empty throw
* ... * specification here, but omitting it is standard conforming. Its
* auto_ptr<Base> ptr = func_returning_auto_ptr(.....); * presence can be detected only if _Tp::~_Tp() throws, but this is
* @endcode * prohibited. [17.4.3.6]/2
*/ * @end maint
auto_ptr(auto_ptr_ref<element_type> __ref) throw() */
: _M_ptr(__ref._M_ptr) {} ~auto_ptr() { delete _M_ptr; }
auto_ptr& /**
operator=(auto_ptr_ref<element_type> __ref) throw() * @brief Smart pointer dereferencing.
{ *
if (__ref._M_ptr != this->get()) * If this %auto_ptr no longer owns anything, then this
{ * operation will crash. (For a smart pointer, "no longer owns
delete _M_ptr; * anything" is the same as being a null pointer, and you know
_M_ptr = __ref._M_ptr; * what happens when you dereference one of those...)
} */
return *this; element_type&
} operator*() const throw() { return *_M_ptr; }
template<typename _Tp1> /**
operator auto_ptr_ref<_Tp1>() throw() * @brief Smart pointer dereferencing.
{ return auto_ptr_ref<_Tp1>(this->release()); } *
* This returns the pointer itself, which the language then will
template<typename _Tp1> * automatically cause to be dereferenced.
operator auto_ptr<_Tp1>() throw() */
{ return auto_ptr<_Tp1>(this->release()); } element_type*
/** @} */ operator->() const throw() { return _M_ptr; }
};
/**
* @brief Bypassing the smart pointer.
* @return The raw pointer being managed.
*
* You can get a copy of the pointer that this object owns, for
* situations such as passing to a function which only accepts a raw
* pointer.
*
* @note This %auto_ptr still owns the memory.
*/
element_type*
get() const throw() { return _M_ptr; }
/**
* @brief Bypassing the smart pointer.
* @return The raw pointer being managed.
*
* You can get a copy of the pointer that this object owns, for
* situations such as passing to a function which only accepts a raw
* pointer.
*
* @note This %auto_ptr no longer owns the memory. When this object
* goes out of scope, nothing will happen.
*/
element_type*
release() throw()
{
element_type* __tmp = _M_ptr;
_M_ptr = 0;
return __tmp;
}
/**
* @brief Forcibly deletes the managed object.
* @param p A pointer (defaults to NULL).
*
* This object now @e owns the object pointed to by @a p. The previous
* object has been deleted.
*/
void
reset(element_type* __p = 0) throw()
{
if (__p != _M_ptr)
{
delete _M_ptr;
_M_ptr = __p;
}
}
/** @{
* @brief Automatic conversions
*
* These operations convert an %auto_ptr into and from an auto_ptr_ref
* automatically as needed. This allows constructs such as
* @code
* auto_ptr<Derived> func_returning_auto_ptr(.....);
* ...
* auto_ptr<Base> ptr = func_returning_auto_ptr(.....);
* @endcode
*/
auto_ptr(auto_ptr_ref<element_type> __ref) throw()
: _M_ptr(__ref._M_ptr) { }
auto_ptr&
operator=(auto_ptr_ref<element_type> __ref) throw()
{
if (__ref._M_ptr != this->get())
{
delete _M_ptr;
_M_ptr = __ref._M_ptr;
}
return *this;
}
template<typename _Tp1>
operator auto_ptr_ref<_Tp1>() throw()
{ return auto_ptr_ref<_Tp1>(this->release()); }
template<typename _Tp1>
operator auto_ptr<_Tp1>() throw()
{ return auto_ptr<_Tp1>(this->release()); }
/** @} */
};
} // namespace std } // namespace std
#endif /* _CPP_MEMORY */ #endif

42
libstdc++-v3/testsuite/20_util/auto_ptr.cc
View File

@ -84,10 +84,6 @@ test01()
VERIFY( B::ctor_count == 1 ); VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 ); VERIFY( B::dtor_count == 0 );
#ifdef DEBUG_ASSERT
assert(test);
#endif
return 0; return 0;
} }
@ -112,10 +108,6 @@ test02()
VERIFY( B::ctor_count == 1 ); VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 ); VERIFY( B::dtor_count == 0 );
#ifdef DEBUG_ASSERT
assert(test);
#endif
return 0; return 0;
} }
@ -142,10 +134,6 @@ test03()
VERIFY( B::ctor_count == 1 ); VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 0 ); VERIFY( B::dtor_count == 0 );
#ifdef DEBUG_ASSERT
assert(test);
#endif
return 0; return 0;
} }
@ -167,10 +155,6 @@ test04()
VERIFY( B::ctor_count == 2 ); VERIFY( B::ctor_count == 2 );
VERIFY( B::dtor_count == 2 ); VERIFY( B::dtor_count == 2 );
#ifdef DEBUG_ASSERT
assert(test);
#endif
return 0; return 0;
} }
@ -196,11 +180,6 @@ test05()
VERIFY( A::dtor_count == 2 ); VERIFY( A::dtor_count == 2 );
VERIFY( B::ctor_count == 1 ); VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 1 ); VERIFY( B::dtor_count == 1 );
#ifdef DEBUG_ASSERT
assert(test);
#endif
return 0; return 0;
} }
@ -232,11 +211,6 @@ test06()
VERIFY( A_from_A_ptr.get() != A_ptr ); VERIFY( A_from_A_ptr.get() != A_ptr );
VERIFY( A_from_A_ptr->ctor_count == 2 ); VERIFY( A_from_A_ptr->ctor_count == 2 );
VERIFY( (*A_from_A_ptr).dtor_count == 1 ); VERIFY( (*A_from_A_ptr).dtor_count == 1 );
#ifdef DEBUG_ASSERT
assert(test);
#endif
return 0; return 0;
} }
@ -268,20 +242,16 @@ test07()
VERIFY( A::dtor_count == 2 ); VERIFY( A::dtor_count == 2 );
VERIFY( B::ctor_count == 1 ); VERIFY( B::ctor_count == 1 );
VERIFY( B::dtor_count == 1 ); VERIFY( B::dtor_count == 1 );
#ifdef DEBUG_ASSERT
assert(test);
#endif
return 0; return 0;
} }
// libstdc++/3946
// http://gcc.gnu.org/ml/libstdc++/2002-07/msg00024.html // http://gcc.gnu.org/ml/libstdc++/2002-07/msg00024.html
struct Base{}; struct Base { };
struct Derived : public Base {}; struct Derived : public Base { };
std::auto_ptr<Derived> conversiontest08()
{ return std::auto_ptr<Derived>(new Derived); } std::auto_ptr<Derived>
conversiontest08() { return std::auto_ptr<Derived>(new Derived); }
void void
test08() test08()

50
libstdc++-v3/testsuite/20_util/auto_ptr_neg.cc Normal file
View File

@ -0,0 +1,50 @@
// Copyright (C) 2002 Free Software Foundation
//
// 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.5 Template class auto_ptr negative tests [lib.auto.ptr]
#include <memory>
#include <testsuite_hooks.h>
// { dg-do compile }
// { dg-excess-errors "" }
// via Jack Reeves <jack_reeves@hispeed.ch>
// libstdc++/3946
// http://gcc.gnu.org/ml/libstdc++/2002-07/msg00024.html
struct Base { };
struct Derived : public Base { };
std::auto_ptr<Derived>
foo() { return std::auto_ptr<Derived>(new Derived); }
int
test01()
{
std::auto_ptr<Base> ptr2;
ptr2 = new Base; // { dg-error "no" "candidates" "auto_ptr"}
return 0;
}
int
main()
{
test01();
return 0;
}

26
libstdc++-v3/testsuite/23_containers/map_operators.cc
View File

@ -24,25 +24,7 @@
#include <string> #include <string>
#include <iostream> #include <iostream>
// { dg-do compile } // libstdc++/737
// libstdc++/86: map & set iterator comparisons are not type-safe
void test01()
{
bool test = true;
std::map<unsigned int, int> mapByIndex;
std::map<std::string, unsigned> mapByName;
mapByIndex.insert(std::pair<unsigned, int>(0, 1));
mapByIndex.insert(std::pair<unsigned, int>(6, 5));
std::map<unsigned, int>::iterator itr(mapByIndex.begin());
// NB: notice, it's not mapByIndex!!
test &= itr != mapByName.end(); // { dg-error "no" }
test &= itr == mapByName.end(); // { dg-error "no" }
}
// http://gcc.gnu.org/ml/libstdc++/2000-11/msg00093.html // http://gcc.gnu.org/ml/libstdc++/2000-11/msg00093.html
void test02() void test02()
{ {
@ -53,17 +35,15 @@ void test02()
for (unsigned i=0;i<10;++i) for (unsigned i=0;i<10;++i)
m.insert(MapInt::value_type(i,i)); m.insert(MapInt::value_type(i,i));
for (MapInt::const_iterator i=m.begin();i!=m.end();++i) for (MapInt::const_iterator i = m.begin(); i != m.end(); ++i)
std::cerr << i->second << ' '; std::cerr << i->second << ' ';
for (MapInt::const_iterator i=m.begin();m.end()!=i;++i) for (MapInt::const_iterator i = m.begin(); m.end() != i; ++i)
std::cerr << i->second << ' '; std::cerr << i->second << ' ';
} }
int main() int main()
{ {
test01();
test02(); test02();
return 0; return 0;
} }

49
libstdc++-v3/testsuite/23_containers/map_operators_neg.cc Normal file
View File

@ -0,0 +1,49 @@
// 2000-09-07 bgarcia@laurelnetworks.com
// Copyright (C) 2000, 2001, 2002 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.
// 23.3.4 template class multiset negative tests
#include <map>
#include <string>
// { dg-do compile }
// libstdc++/86: map & set iterator comparisons are not type-safe
void test01()
{
bool test = true;
std::map<unsigned int, int> mapByIndex;
std::map<std::string, unsigned> mapByName;
mapByIndex.insert(std::pair<unsigned, int>(0, 1));
mapByIndex.insert(std::pair<unsigned, int>(6, 5));
std::map<unsigned, int>::iterator itr(mapByIndex.begin());
// NB: notice, it's not mapByIndex!!
test &= itr != mapByName.end(); // { dg-error "no" }
test &= itr == mapByName.end(); // { dg-error "no" }
}
int main()
{
test01();
return 0;
}

4
libstdc++-v3/testsuite/23_containers/set_operators.cc → libstdc++-v3/testsuite/23_containers/set_operators_neg.cc
View File

@ -1,6 +1,6 @@
// 2000-09-07 bgarcia@laurelnetworks.com // 2000-09-07 bgarcia@laurelnetworks.com
// Copyright (C) 2000, 2001 Free Software Foundation, Inc. // Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
// //
// This file is part of the GNU ISO C++ Library. This library is free // 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 // software; you can redistribute it and/or modify it under the
@ -18,7 +18,7 @@
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA. // USA.
// 23.3.4 template class multiset // 23.3.4 template class multiset negative tests
#include <set> #include <set>
#include <string> #include <string>

9
libstdc++-v3/testsuite/README
View File

@ -24,6 +24,15 @@ that, the naming seems mostly consistent. If the file exists, add a
test to it. If it does not, then create a new file. All files are test to it. If it does not, then create a new file. All files are
copyright the FSF, and GPL'd: this is very important. copyright the FSF, and GPL'd: this is very important.
In addition, some of the locale and io code tests different
instantiating types: thus, 'char' or 'wchar_t' is appended to the name
as constructed above.
Also, some test files are negative tests. That is, they are supposed
to fail (usually this involves making sure some kind of construct gets
an error when it's compiled.) These test files have 'neg' appended to
the name as constructed above.
Inside a test file, the plan is to test the relevant parts of the Inside a test file, the plan is to test the relevant parts of the
standard, and then add specific regressions as additional test standard, and then add specific regressions as additional test
functions, ie test04() can represent a specific regression noted in functions, ie test04() can represent a specific regression noted in