From 5acf59f8e1443be34413cfcbdfd69283cfe59806 Mon Sep 17 00:00:00 2001 From: Benjamin Kosnik Date: Thu, 4 Jul 2002 07:25:19 +0000 Subject: [PATCH] std_memory.h: Fix formatting. 2002-07-03 Benjamin Kosnik * 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 --- libstdc++-v3/ChangeLog | 11 + libstdc++-v3/include/std/std_memory.h | 557 +++++++++--------- libstdc++-v3/testsuite/20_util/auto_ptr.cc | 42 +- .../testsuite/20_util/auto_ptr_neg.cc | 50 ++ .../testsuite/23_containers/map_operators.cc | 26 +- .../23_containers/map_operators_neg.cc | 49 ++ ...{set_operators.cc => set_operators_neg.cc} | 4 +- libstdc++-v3/testsuite/README | 9 + 8 files changed, 402 insertions(+), 346 deletions(-) create mode 100644 libstdc++-v3/testsuite/20_util/auto_ptr_neg.cc create mode 100644 libstdc++-v3/testsuite/23_containers/map_operators_neg.cc rename libstdc++-v3/testsuite/23_containers/{set_operators.cc => set_operators_neg.cc} (91%) diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index d54ffa1fb41..d2ddff24217 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,14 @@ +2002-07-03 Benjamin Kosnik + + * 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 PR libstdc++/7057 diff --git a/libstdc++-v3/include/std/std_memory.h b/libstdc++-v3/include/std/std_memory.h index 5850eb2a007..47c3ede8995 100644 --- a/libstdc++-v3/include/std/std_memory.h +++ b/libstdc++-v3/include/std/std_memory.h @@ -58,314 +58,301 @@ #include #include -// 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 { -/** - * @if maint - * This is a helper function. The unused second parameter exists to - * permit the real get_temporary_buffer to use template parameter deduction. - * - * XXX This should perhaps use the pool. - * @endif -*/ -template -pair<_Tp*, ptrdiff_t> -__get_temporary_buffer(ptrdiff_t __len, _Tp*) -{ - if (__len > ptrdiff_t(INT_MAX / sizeof(_Tp))) - __len = INT_MAX / sizeof(_Tp); - - while (__len > 0) { - _Tp* __tmp = (_Tp*) std::malloc((std::size_t)__len * sizeof(_Tp)); - if (__tmp != 0) - return pair<_Tp*, ptrdiff_t>(__tmp, __len); - __len /= 2; - } - - 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 - 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 - 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 - 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: - * 
- *  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 container
- *  elements and thus instantiating a Standard Library container with an
- *  @c auto_ptr results in undefined behavior.
- *
- * 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 - class auto_ptr -{ -private: - _Tp* _M_ptr; - -public: - /// The pointed-to type. - typedef _Tp element_type; + /** + * @if maint + * This is a helper function. The unused second parameter exists to + * permit the real get_temporary_buffer to use template parameter deduction. + * + * XXX This should perhaps use the pool. + * @endif + */ + template + pair<_Tp*, ptrdiff_t> + __get_temporary_buffer(ptrdiff_t __len, _Tp*) + { + if (__len > ptrdiff_t(INT_MAX / sizeof(_Tp))) + __len = INT_MAX / sizeof(_Tp); + + while (__len > 0) + { + _Tp* __tmp = (_Tp*) std::malloc((std::size_t)__len * sizeof(_Tp)); + if (__tmp != 0) + return pair<_Tp*, ptrdiff_t>(__tmp, __len); + __len /= 2; + } + return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0); + } /** - * @brief An %auto_ptr is usually constructed from a raw pointer. - * @param p A pointer (defaults to NULL). + * @brief This is a mostly-useless wrapper around malloc(). + * @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. - */ - explicit - auto_ptr(element_type* __p = 0) throw() - : _M_ptr(__p) { } + * 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 + 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. - * @param a Another %auto_ptr of the same type. + * @brief The companion to get_temporary_buffer(). + * @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 - * given up ownsership. - */ - auto_ptr(auto_ptr& __a) throw() - : _M_ptr(__a.release()) { } + * Frees the memory pointed to by p. + */ + template + void + return_temporary_buffer(_Tp* __p) + { std::free(__p); } /** - * @brief An %auto_ptr can be constructed from another %auto_ptr. - * @param a Another %auto_ptr of a different but related type. + * 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. * - * 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. - */ + * All the auto_ptr_ref stuff should happen behind the scenes. + */ template - 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() + struct auto_ptr_ref { - reset(__a.release()); - return *this; - } + _Tp1* _M_ptr; + + explicit + auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { } + }; + /** - * @brief %auto_ptr assignment operator. - * @param a Another %auto_ptr of a different but related type. + * @brief A simple smart pointer providing strict ownership semantics. * - * A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type. + * The Standard says: + * 
+   *  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
-   *  given up ownsership.  The object that this one @e used to own and
-   *  track has been deleted.
-  */
-  template 
-    auto_ptr&
-    operator=(auto_ptr<_Tp1>& __a) throw()
-    {
-      reset(__a.release());
-      return *this;
-    }
-
-  /**
-   *  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.
+   *  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 container
+   *  elements and thus instantiating a Standard Library container with an
+   *  @c auto_ptr results in undefined behavior.
+   *
+ * 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 - * The C++ standard says there is supposed to be an empty throw - * specification here, but omitting it is standard conforming. Its - * presence can be detected only if _Tp::~_Tp() throws, but this is - * prohibited. [17.4.3.6]/2 - * @end maint - */ - ~auto_ptr() { delete _M_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() + * _GLIBCPP_RESOLVE_LIB_DEFECTS + * 127. auto_ptr<> conversion issues + * These resolutions have all been incorporated. + * @endif + */ + template + class auto_ptr { - element_type* __tmp = _M_ptr; - _M_ptr = 0; - return __tmp; - } + private: + _Tp* _M_ptr; + + 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. - * @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) + /** + * @brief An %auto_ptr can be constructed from another %auto_ptr. + * @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. + */ + auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } + + /** + * @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 + 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 + auto_ptr& + operator=(auto_ptr<_Tp1>& __a) throw() { - delete _M_ptr; - _M_ptr = __p; - } - } + reset(__a.release()); + return *this; + } - /** @{ - * @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 func_returning_auto_ptr(.....); - * ... - * auto_ptr ptr = func_returning_auto_ptr(.....); - * @endcode - */ - auto_ptr(auto_ptr_ref __ref) throw() - : _M_ptr(__ref._M_ptr) {} - - auto_ptr& - operator=(auto_ptr_ref __ref) throw() - { - if (__ref._M_ptr != this->get()) - { - delete _M_ptr; - _M_ptr = __ref._M_ptr; - } - return *this; - } - - template - operator auto_ptr_ref<_Tp1>() throw() - { return auto_ptr_ref<_Tp1>(this->release()); } - - template - operator auto_ptr<_Tp1>() throw() - { return auto_ptr<_Tp1>(this->release()); } - /** @} */ -}; + /** + * 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 + * The C++ standard says there is supposed to be an empty throw + * specification here, but omitting it is standard conforming. Its + * presence can be detected only if _Tp::~_Tp() throws, but this is + * prohibited. [17.4.3.6]/2 + * @end maint + */ + ~auto_ptr() { delete _M_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; + _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 func_returning_auto_ptr(.....); + * ... + * auto_ptr ptr = func_returning_auto_ptr(.....); + * @endcode + */ + auto_ptr(auto_ptr_ref __ref) throw() + : _M_ptr(__ref._M_ptr) { } + + auto_ptr& + operator=(auto_ptr_ref __ref) throw() + { + if (__ref._M_ptr != this->get()) + { + delete _M_ptr; + _M_ptr = __ref._M_ptr; + } + return *this; + } + + template + operator auto_ptr_ref<_Tp1>() throw() + { return auto_ptr_ref<_Tp1>(this->release()); } + template + operator auto_ptr<_Tp1>() throw() + { return auto_ptr<_Tp1>(this->release()); } + /** @} */ + }; } // namespace std -#endif /* _CPP_MEMORY */ +#endif diff --git a/libstdc++-v3/testsuite/20_util/auto_ptr.cc b/libstdc++-v3/testsuite/20_util/auto_ptr.cc index cf0d37bfb78..a6dd1c69991 100644 --- a/libstdc++-v3/testsuite/20_util/auto_ptr.cc +++ b/libstdc++-v3/testsuite/20_util/auto_ptr.cc @@ -84,10 +84,6 @@ test01() VERIFY( B::ctor_count == 1 ); VERIFY( B::dtor_count == 0 ); -#ifdef DEBUG_ASSERT - assert(test); -#endif - return 0; } @@ -112,10 +108,6 @@ test02() VERIFY( B::ctor_count == 1 ); VERIFY( B::dtor_count == 0 ); -#ifdef DEBUG_ASSERT - assert(test); -#endif - return 0; } @@ -142,10 +134,6 @@ test03() VERIFY( B::ctor_count == 1 ); VERIFY( B::dtor_count == 0 ); -#ifdef DEBUG_ASSERT - assert(test); -#endif - return 0; } @@ -167,10 +155,6 @@ test04() VERIFY( B::ctor_count == 2 ); VERIFY( B::dtor_count == 2 ); -#ifdef DEBUG_ASSERT - assert(test); -#endif - return 0; } @@ -196,11 +180,6 @@ test05() VERIFY( A::dtor_count == 2 ); VERIFY( B::ctor_count == 1 ); VERIFY( B::dtor_count == 1 ); - -#ifdef DEBUG_ASSERT - assert(test); -#endif - return 0; } @@ -232,11 +211,6 @@ test06() VERIFY( A_from_A_ptr.get() != A_ptr ); VERIFY( A_from_A_ptr->ctor_count == 2 ); VERIFY( (*A_from_A_ptr).dtor_count == 1 ); - -#ifdef DEBUG_ASSERT - assert(test); -#endif - return 0; } @@ -268,20 +242,16 @@ test07() VERIFY( A::dtor_count == 2 ); VERIFY( B::ctor_count == 1 ); VERIFY( B::dtor_count == 1 ); - -#ifdef DEBUG_ASSERT - assert(test); -#endif - return 0; } - +// libstdc++/3946 // http://gcc.gnu.org/ml/libstdc++/2002-07/msg00024.html -struct Base{}; -struct Derived : public Base {}; -std::auto_ptr conversiontest08() - { return std::auto_ptr(new Derived); } +struct Base { }; +struct Derived : public Base { }; + +std::auto_ptr +conversiontest08() { return std::auto_ptr(new Derived); } void test08() diff --git a/libstdc++-v3/testsuite/20_util/auto_ptr_neg.cc b/libstdc++-v3/testsuite/20_util/auto_ptr_neg.cc new file mode 100644 index 00000000000..ff39a0d24d5 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/auto_ptr_neg.cc @@ -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 +#include + +// { dg-do compile } +// { dg-excess-errors "" } + +// via Jack Reeves +// libstdc++/3946 +// http://gcc.gnu.org/ml/libstdc++/2002-07/msg00024.html +struct Base { }; +struct Derived : public Base { }; + +std::auto_ptr +foo() { return std::auto_ptr(new Derived); } + +int +test01() +{ + std::auto_ptr ptr2; + ptr2 = new Base; // { dg-error "no" "candidates" "auto_ptr"} + return 0; +} + +int +main() +{ + test01(); + + return 0; +} diff --git a/libstdc++-v3/testsuite/23_containers/map_operators.cc b/libstdc++-v3/testsuite/23_containers/map_operators.cc index 2ef57649d7f..47604deb4a8 100644 --- a/libstdc++-v3/testsuite/23_containers/map_operators.cc +++ b/libstdc++-v3/testsuite/23_containers/map_operators.cc @@ -24,25 +24,7 @@ #include #include -// { dg-do compile } - -// libstdc++/86: map & set iterator comparisons are not type-safe -void test01() -{ - bool test = true; - std::map mapByIndex; - std::map mapByName; - - mapByIndex.insert(std::pair(0, 1)); - mapByIndex.insert(std::pair(6, 5)); - - std::map::iterator itr(mapByIndex.begin()); - - // NB: notice, it's not mapByIndex!! - test &= itr != mapByName.end(); // { dg-error "no" } - test &= itr == mapByName.end(); // { dg-error "no" } -} - +// libstdc++/737 // http://gcc.gnu.org/ml/libstdc++/2000-11/msg00093.html void test02() { @@ -53,17 +35,15 @@ void test02() for (unsigned i=0;i<10;++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 << ' '; - 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 << ' '; } int main() { - test01(); test02(); - return 0; } diff --git a/libstdc++-v3/testsuite/23_containers/map_operators_neg.cc b/libstdc++-v3/testsuite/23_containers/map_operators_neg.cc new file mode 100644 index 00000000000..75b604c80c2 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/map_operators_neg.cc @@ -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 +#include + +// { dg-do compile } + +// libstdc++/86: map & set iterator comparisons are not type-safe +void test01() +{ + bool test = true; + std::map mapByIndex; + std::map mapByName; + + mapByIndex.insert(std::pair(0, 1)); + mapByIndex.insert(std::pair(6, 5)); + + std::map::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; +} diff --git a/libstdc++-v3/testsuite/23_containers/set_operators.cc b/libstdc++-v3/testsuite/23_containers/set_operators_neg.cc similarity index 91% rename from libstdc++-v3/testsuite/23_containers/set_operators.cc rename to libstdc++-v3/testsuite/23_containers/set_operators_neg.cc index f166ab9406e..c3c23741e2e 100644 --- a/libstdc++-v3/testsuite/23_containers/set_operators.cc +++ b/libstdc++-v3/testsuite/23_containers/set_operators_neg.cc @@ -1,6 +1,6 @@ // 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 // 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, // USA. -// 23.3.4 template class multiset +// 23.3.4 template class multiset negative tests #include #include diff --git a/libstdc++-v3/testsuite/README b/libstdc++-v3/testsuite/README index 11c7f548421..07ff9fef4f8 100644 --- a/libstdc++-v3/testsuite/README +++ b/libstdc++-v3/testsuite/README @@ -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 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 standard, and then add specific regressions as additional test functions, ie test04() can represent a specific regression noted in