libstdc++: Fix tests relying on operator new/delete overload

Fix tests that are checking for an expected allocation plan. They are failing if
an allocation is taking place outside the test main.

libstdc++-v3/ChangeLog

	* testsuite/util/replacement_memory_operators.h
	(counter::scope): New, capture and reset counter count at construction and
	restore it at destruction.
	(counter::check_new): Add scope instantiation.
	* testsuite/23_containers/unordered_map/96088.cc (main):
	Add counter::scope instantiation.
	* testsuite/23_containers/unordered_multimap/96088.cc (main): Likewise.
	* testsuite/23_containers/unordered_multiset/96088.cc (main): Likewise.
	* testsuite/23_containers/unordered_set/96088.cc (main): Likewise.
	* testsuite/ext/malloc_allocator/deallocate_local.cc (main): Likewise.
	* testsuite/ext/new_allocator/deallocate_local.cc (main): Likewise.
	* testsuite/ext/throw_allocator/deallocate_local.cc (main): Likewise.
	* testsuite/ext/pool_allocator/allocate_chunk.cc (started): New global.
	(operator new(size_t)): Check started.
	(main): Set/Unset started.
	* testsuite/17_intro/no_library_allocation.cc: New test case.

libstdc++-v3/testsuite/17_intro/no_library_allocation.cc

@@ -0,0 +1,8 @@
+#include <testsuite_hooks.h>
+#include <replacement_memory_operators.h>
+
+int main()
+{
+  VERIFY( __gnu_test::counter::count() == 0 );
+  return 0;
+}

libstdc++-v3/testsuite/23_containers/unordered_map/96088.cc

@@ -268,6 +268,7 @@ test03()
 int
 main()
 {
+  __gnu_test::counter::scope s;
   test01();
   test02();
   test11();

libstdc++-v3/testsuite/23_containers/unordered_multimap/96088.cc

@@ -61,6 +61,7 @@ test02()
 int
 main()
 {
+  __gnu_test::counter::scope s;
   test01();
   test02();
   return 0;

libstdc++-v3/testsuite/23_containers/unordered_multiset/96088.cc

@@ -61,6 +61,7 @@ test02()
 int
 main()
 {
+  __gnu_test::counter::scope s;
   test01();
   test02();
   return 0;

libstdc++-v3/testsuite/23_containers/unordered_set/96088.cc

@@ -269,6 +269,7 @@ test03()
 int
 main()
 {
+  __gnu_test::counter::scope s;
   test01();
   test02();
   test11();

libstdc++-v3/testsuite/ext/malloc_allocator/deallocate_local.cc

@@ -27,6 +27,7 @@ typedef std::basic_string<char_t, traits_t, allocator_t> string_t;
 
 int main()
 {
+  __gnu_test::counter::scope s;
   {
     string_t s;
     s += "bayou bend";
@@ -34,5 +35,6 @@ int main()
 
   if (__gnu_test::counter::count() != 0)
     throw std::runtime_error("count not zero");
+
   return 0;
 }

libstdc++-v3/testsuite/ext/new_allocator/deallocate_local.cc

@@ -27,6 +27,7 @@ typedef std::basic_string<char_t, traits_t, allocator_t> string_t;
 
 int main()
 {
+  __gnu_test::counter::scope s;
   {
     string_t s;
     s += "bayou bend";
@@ -34,5 +35,6 @@ int main()
 
   if (__gnu_test::counter::count() != 0)
     throw std::runtime_error("count not zero");
+
   return 0;
 }

libstdc++-v3/testsuite/ext/pool_allocator/allocate_chunk.cc

@@ -32,16 +32,29 @@ struct big
   char c[64];
 };
 
+bool started = false;
+
 void*
 operator new(size_t n) THROW(std::bad_alloc)
 {
-  static bool first = true;
-  if (!first)
-    throw std::bad_alloc();
-  first = false;
+  if (started)
+    {
+      static bool first = true;
+      if (!first)
+	throw std::bad_alloc();
+      first = false;
+    }
+
   return std::malloc(n);
 }
 
+void
+operator delete(void* p) throw()
+{
+  if (p)
+    std::free(p);
+}
+
 // http://gcc.gnu.org/ml/libstdc++/2004-10/msg00098.html
 void test01()
 {
@@ -59,5 +72,7 @@ void test01()
 
 int main()
 {
+  started = true;
   test01();
+  started = false;
 }

libstdc++-v3/testsuite/ext/throw_allocator/deallocate_local.cc

@@ -30,6 +30,7 @@ typedef std::basic_string<char_t, traits_t, allocator_t> string_t;
 
 int main()
 {
+  __gnu_test::counter::scope s;
   {
     string_t s;
     s += "bayou bend";

libstdc++-v3/testsuite/util/replacement_memory_operators.h

@@ -75,12 +75,32 @@ namespace __gnu_test
       counter& cntr = get();
       cntr._M_increments = cntr._M_decrements = 0;
     }
+
+    struct scope
+    {
+      scope() : _M_count(counter::count())
+      { counter::get()._M_count = 0; }
+      ~scope()
+      { counter::get()._M_count = _M_count; }
+
+    private:
+      std::size_t _M_count;
+
+#if __cplusplus >= 201103L
+      scope(const scope&) = delete;
+      scope& operator=(const scope&) = delete;
+#else
+      scope(const scope&);
+      scope& operator=(const scope&);
+#endif
+    };
   };
 
   template<typename Alloc, bool uses_global_new>
     bool
     check_new(Alloc a = Alloc())
     {
+      __gnu_test::counter::scope s;
       __gnu_test::counter::exceptions(false);
       (void) a.allocate(10);
       const bool __b((__gnu_test::counter::count() > 0) == uses_global_new);