1 files changed, 113 insertions, 0 deletions
diff --git a/libstdc++-v3/testsuite/util/replacement_memory_operators.h b/libstdc++-v3/testsuite/util/replacement_memory_operators.h
new file mode 100644
index 000000000..b7d3a3b10
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/replacement_memory_operators.h
@@ -0,0 +1,113 @@
+//
+// Copyright (C) 2007, 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <exception>
+#include <stdexcept>
+#include <cstdlib>
+#include <cstdio>
+
+namespace __gnu_test
+{
+  struct counter_error : public std::exception { };
+
+  struct counter
+  {
+    std::size_t _M_count;
+    bool	_M_throw;
+
+    counter() : _M_count(0), _M_throw(true) { }
+    
+    ~counter()
+    {
+      if (_M_throw && _M_count != 0)
+	throw counter_error();
+    }
+
+    static void
+    increment() { get()._M_count++; }
+
+    static void
+    decrement() { get()._M_count--; }
+
+    static counter&
+    get() 
+    {
+      static counter g;
+      return g;
+    }
+  
+    static std::size_t
+    count() { return get()._M_count; }
+
+    static void
+    exceptions(bool __b) { get()._M_throw = __b; }
+  };
+
+  template<typename Alloc, bool uses_global_new>
+    bool 
+    check_new(Alloc a = Alloc())
+    {
+      __gnu_test::counter::exceptions(false);
+      a.allocate(10);
+      const bool __b((__gnu_test::counter::count() > 0) == uses_global_new);
+      if (!__b)
+	throw std::logic_error("counter not incremented");
+      return __b;
+    }
+
+  template<typename Alloc, bool uses_global_delete>
+    bool 
+    check_delete(Alloc a = Alloc())
+    {
+      __gnu_test::counter::exceptions(false);
+      typename Alloc::pointer p = a.allocate(10);
+      const std::size_t count1 = __gnu_test::counter::count();
+      a.deallocate(p, 10);
+      const std::size_t count2 = __gnu_test::counter::count();
+      const bool __b((count2 < count1) == uses_global_delete);
+      if (!__b)
+	throw std::logic_error("counter not decremented");
+      return __b;
+    }
+} // namespace __gnu_test
+
+void* operator new(std::size_t size) throw(std::bad_alloc)
+{
+  std::printf("operator new is called \n");
+  void* p = std::malloc(size);
+  if (!p)
+    throw std::bad_alloc();
+  __gnu_test::counter::increment();
+  return p;
+}
+ 
+void operator delete(void* p) throw()
+{
+  std::printf("operator delete is called \n");
+  if (p)
+    {
+      std::free(p);
+      __gnu_test::counter::decrement();
+
+      std::size_t count = __gnu_test::counter::count(); 
+      if (count == 0)
+	std::printf("All memory released \n");
+      else
+	std::printf("%lu allocations to be released \n", (unsigned long)count);
+    }
+}