std_memory.h: Fix formatting.

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

8 files changed, 401 insertions, 345 deletions

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index d54ffa1..d2ddff2 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -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>
 	 
 	PR libstdc++/7057
diff --git a/libstdc++-v3/include/std/std_memory.h b/libstdc++-v3/include/std/std_memory.h
index 5850eb2..47c3ede 100644
--- a/libstdc++-v3/include/std/std_memory.h
+++ b/libstdc++-v3/include/std/std_memory.h
@@ -58,314 +58,301 @@
 #include <bits/stl_uninitialized.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
 {
-/**
- *  @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 <typename _Tp>
-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<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.
-   *  @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  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<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.
+   *  @if maint
+   *  This is a helper function.  The unused second parameter exists to
+   *  permit the real get_temporary_buffer to use template parameter deduction.
    *
-   *  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()
+   *  XXX This should perhaps use the pool.
+   *  @endif
+   */
+  template<typename _Tp>
+    pair<_Tp*, ptrdiff_t>
+    __get_temporary_buffer(ptrdiff_t __len, _Tp*)
     {
-      reset(__a.release());
-      return *this;
+      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  %auto_ptr assignment operator.
-   *  @param  a  Another %auto_ptr of a different but related type.
+   *  @brief This is a mostly-useless wrapper around malloc().
+   *  @param  len  The number of objects of type Tp.
+   *  @return   See full description.
    *
-   *  A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.
+   *  Reinventing the wheel, but this time with prettier spokes!
    *
-   *  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()
-    {
-      reset(__a.release());
-      return *this;
-    }
+   *  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); }
 
   /**
-   *  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.
+   *  @brief The companion to get_temporary_buffer().
+   *  @param  p  A buffer previously allocated by get_temporary_buffer.
+   *  @return   None.
    *
-   *  @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; }
+   *  Frees the memory pointed to by p.
+   */
+  template<typename _Tp>
+    void
+    return_temporary_buffer(_Tp* __p)
+    { std::free(__p); }
 
   /**
-   *  @brief  Smart pointer dereferencing.
+   *  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.
    *
-   *  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; }
+   *  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  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.
+   *  @brief  A simple smart pointer providing strict ownership semantics.
    *
-   *  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.
+   *  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.
    *
-   *  @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.
+   *  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.
    *
-   *  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.
+   *  Good examples of what can and cannot be done with auto_ptr can be found
+   *  in the libstdc++ testsuite.
    *
-   *  @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 maint
+   *  _GLIBCPP_RESOLVE_LIB_DEFECTS
+   *  127.  auto_ptr<> conversion issues
+   *  These resolutions have all been incorporated.
+   *  @endif
+   */
+  template<typename _Tp>
+    class auto_ptr
     {
-      if (__ref._M_ptr != this->get())
+    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  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<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;
-          _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()); }
-  /** @}  */
-};
-
+	  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.
+       *
+       *  @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<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
 
-#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 cf0d37b..a6dd1c6 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<Derived> conversiontest08()
-  { return std::auto_ptr<Derived>(new Derived); }
+struct Base { };
+struct Derived : public Base { };
+
+std::auto_ptr<Derived> 
+conversiontest08() { return std::auto_ptr<Derived>(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 0000000..ff39a0d
--- /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 <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;
+}
diff --git a/libstdc++-v3/testsuite/23_containers/map_operators.cc b/libstdc++-v3/testsuite/23_containers/map_operators.cc
index 2ef5764..47604de 100644
--- a/libstdc++-v3/testsuite/23_containers/map_operators.cc
+++ b/libstdc++-v3/testsuite/23_containers/map_operators.cc
@@ -24,25 +24,7 @@
 #include <string>
 #include <iostream>
 
-// { 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" } 
-}
- 
+// 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 0000000..75b604c
--- /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 <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;
+}
diff --git a/libstdc++-v3/testsuite/23_containers/set_operators.cc b/libstdc++-v3/testsuite/23_containers/set_operators_neg.cc
index f166ab9..c3c2374 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 <set>
 #include <string>
diff --git a/libstdc++-v3/testsuite/README b/libstdc++-v3/testsuite/README
index 11c7f54..07ff9fe 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