Move more tests to globalMemCounter and reset.

[danalbert]

Summary

Android's libc uses new/delete internally and these are counted, so
the counter needs to be reset to zero at the start of the test.

[EricWF]

Some of the changes in this patch are not correct. Please revert them in a follow up commit.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp

33

This change isn't correct.

The test was looking to ensure a *specific* overload of new/delete was replaceable and getting called.
It now checks that *any* overload is called.

Please revert this change.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp

35

This change isn't correct.

The test was looking to ensure a *specific* overload of new/delete was replaceable and getting called.
It now checks that *any* overload is called.

Please revert this change.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp

34

This change isn't correct.

The test was looking to ensure a *specific* overload of new/delete was replaceable and getting called.
It now checks that *any* overload is called.

Please revert this change.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp

21

This change isn't correct.

The test was looking to ensure a *specific* overload of new/delete was replaceable and getting called.
It now checks that *any* overload is called.

Please revert this change.

[danalbert]

In D76091#1922250, @EricWF wrote:

Some of the changes in this patch are not correct. Please revert them in a follow up commit.

Thanks for spotting that. Reverted the whole patch and will follow up soon.

[ldionne]

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp

33

Wait, how's that true? The only operator new that modifies the result of globalMemCounter.checkOutstandingNewEq in count_new.h is void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc), which is the same as here, no?

Other overloads of new have different counters, don't they?

[danalbert]

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp

33

I think the problem is that this test is trying to make sure this replacement is called by the implementation if the array variant is not _also_ replaced. Including count_new.hpp causes all of the replacements to be used, so the behavior of the actual array new implementation isn't what ends up being tested.

This was in fact covering up a failing test on Android (albeit not one I can do anything about, since we fixed it ages ago but still affects older devices that I support), so the test definitely is doing its job :)

Repushed this in 9c5d0ea6784bf08337bd20d44911ebf6bfbd2822, with these tests fixed.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp

 // XFAIL: libcpp-no-vcruntime
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 #include <limits>
 
+#include "count_new.h"
 #include "test_macros.h"
 
-int new_called = 0;
-
-void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-{
-    ++new_called;
-    void* ret = std::malloc(s);
-    if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
-    return  ret;
-}
-
-void  operator delete(void* p) TEST_NOEXCEPT
-{
-    --new_called;
-    std::free(p);
-}
-
 int A_constructed = 0;
 
 struct A
 {
     A() {++A_constructed;}
     ~A() {--A_constructed;}
 };
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     A *ap = new (std::nothrow) A[3];
     DoNotOptimize(ap);
     assert(ap);
     assert(A_constructed == 3);
-    assert(new_called);
+    assert(globalMemCounter.checkOutstandingNewNotEq(0));
     delete [] ap;
     DoNotOptimize(ap);
     assert(A_constructed == 0);
-    assert(!new_called);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 
   return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp

 
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 #include <limits>
 
+#include "count_new.h"
 #include "test_macros.h"
 
-int new_called = 0;
-
-void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-{
-    ++new_called;
-    void* ret = std::malloc(s);
-    if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
-    return  ret;
-}
-
-void  operator delete(void* p) TEST_NOEXCEPT
-{
-    --new_called;
-    std::free(p);
-}
-
 int A_constructed = 0;
 
 struct A
 {
     A() {++A_constructed;}
     ~A() {--A_constructed;}
 };
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     A *ap = new A[3];
     DoNotOptimize(ap);
     assert(ap);
     assert(A_constructed == 3);
-    assert(new_called == 1);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     delete [] ap;
     DoNotOptimize(ap);
     assert(A_constructed == 0);
-    assert(new_called == 0);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 
   return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp

 // XFAIL: libcpp-no-vcruntime
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 #include <limits>
 
+#include "count_new.h"
 #include "test_macros.h"
 
-int new_called = 0;
-
-void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-{
-    ++new_called;
-    void* ret = std::malloc(s);
-    if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
-    return ret;
-}
-
-void  operator delete(void* p) TEST_NOEXCEPT
-{
-    --new_called;
-    std::free(p);
-}
-
 bool A_constructed = false;
 
 struct A
 {
     A() {A_constructed = true;}
     ~A() {A_constructed = false;}
 };
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     A *ap = new (std::nothrow) A;
     DoNotOptimize(ap);
     assert(ap);
     assert(A_constructed);
-    assert(new_called);
+    assert(globalMemCounter.checkOutstandingNewNotEq(0));
     delete ap;
     DoNotOptimize(ap);
     assert(!A_constructed);
-    assert(!new_called);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 
   return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_replace.pass.cpp

 // UNSUPPORTED: sanitizer-new-delete
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 #include <limits>
 
+#include "count_new.h"
 #include "test_macros.h"
 
-int new_called = 0;
-
-void* operator new(std::size_t s) TEST_THROW_SPEC(std::bad_alloc)
-{
-    ++new_called;
-    void* ret = std::malloc(s);
-    if (!ret) std::abort(); // placate MSVC's unchecked malloc warning
-    return ret;
-}
-
-void  operator delete(void* p) TEST_NOEXCEPT
-{
-    --new_called;
-    std::free(p);
-}
-
 bool A_constructed = false;
 
 struct A
 {
     A() {A_constructed = true;}
     ~A() {A_constructed = false;}
 };
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
+    assert(globalMemCounter.checkOutstandingNewEq(0));
     A *ap = new A;
     DoNotOptimize(ap);
     assert(ap);
     assert(A_constructed);
-    assert(new_called);
+    assert(globalMemCounter.checkOutstandingNewEq(1));
     delete ap;
     DoNotOptimize(ap);
     assert(!A_constructed);
-    assert(!new_called);
+    assert(globalMemCounter.checkOutstandingNewEq(0));
 
   return 0;
 }

libcxx/test/std/localization/locale.stdcvt/codecvt_utf16.pass.cpp

 #include <cassert>
 
 #include "count_new.h"
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
         typedef std::codecvt_utf16<wchar_t> C;
         C c;
         assert(globalMemCounter.checkOutstandingNewEq(0));
     }
     {
         typedef std::codecvt_utf16<wchar_t> C;
         std::locale loc(std::locale::classic(), new C);
         assert(globalMemCounter.checkOutstandingNewNotEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
 
   return 0;
 }

libcxx/test/std/localization/locale.stdcvt/codecvt_utf8.pass.cpp

 #include <cassert>
 
 #include "count_new.h"
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
         typedef std::codecvt_utf8<wchar_t> C;
         C c;
         assert(globalMemCounter.checkOutstandingNewEq(0));
     }
     {
         typedef std::codecvt_utf8<wchar_t> C;
         std::locale loc(std::locale::classic(), new C);
         assert(globalMemCounter.checkOutstandingNewNotEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
 
   return 0;
 }

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp

 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
 #if TEST_STD_VER > 11
     static_assert(!std::is_convertible<std::streambuf*, B>::value, "");
     static_assert( std::is_constructible<B, std::streambuf*>::value, "");
 #endif
     {
         B b;
         assert(b.rdbuf() == nullptr);

libcxx/test/std/localization/locales/locale/locale.members/combine.pass.cpp

struct my_facet
     static std::locale::id id;
 };
 
 std::locale::id my_facet::id;
 
 int main(int, char**)
 {
 {
+    globalMemCounter.reset();
     {
         std::locale loc;
         std::locale loc2(loc, new my_facet);
         std::locale loc3 = loc.combine<my_facet>(loc2);
         check(loc3);
         assert(loc3.name() == "*");
         assert((std::has_facet<my_facet>(loc3)));
         const my_facet& f = std::use_facet<my_facet>(loc3);

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.cpp

 
 int A::count = 0;
 
 int g(int) {return 0;}
 int h(int) {return 1;}
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = A(2);
 #if TEST_STD_VER >= 11
     static_assert(noexcept(swap(f1, f2)), "" );
 #endif
     assert(A::count == 2);

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.cpp

 struct LValueCallable {
     template <class ...Args>
     void operator()(Args&&...) & {}
 };
 #endif
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp

 struct LValueCallable {
     template <class ...Args>
     void operator()(Args&&...) & {}
 };
 #endif
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f;
     f = A();
     assert(A::count == 1);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp

 int A::count = 0;
 
 int g0() { return 0; }
 int g(int) { return 0; }
 int g2(int, int) { return 2; }
 int g3(int, int, int) { return 3; }
 
 int main(int, char**) {
+  globalMemCounter.reset();
   assert(globalMemCounter.checkOutstandingNewEq(0));
   {
     std::function<int(int)> f = A();
     assert(A::count == 1);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int (*)(int)>() == 0);
     std::function<int(int)> f2;

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp

 };
 
 int A::count = 0;
 
 int g(int) {return 0;}
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     std::function<int(int)> f2 = f;

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.cpp

 };
 
 int A::count = 0;
 
 int g(int) {return 0;}
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
     std::function<int(int)> f = A();
     assert(A::count == 1);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(f.target<A>());
     f = nullptr;
     assert(A::count == 0);

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.cpp

 
 int g0() { return 0; }
 int g(int) { return 0; }
 int h(int) { return 1; }
 int g2(int, int) { return 2; }
 int g3(int, int, int) { return 3; }
 
 int main(int, char**) {
+  globalMemCounter.reset();
   assert(globalMemCounter.checkOutstandingNewEq(0));
   {
     std::function<int(int)> f1 = A(1);
     std::function<int(int)> f2 = A(2);
     assert(A::count == 2);
     assert(globalMemCounter.checkOutstandingNewEq(2));
     assert(f1.target<A>()->id() == 1);
     assert(f2.target<A>()->id() == 2);

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp

 
 
 struct PrivateBase : private std::enable_shared_from_this<PrivateBase> {
 };
 
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     {  // https://bugs.llvm.org/show_bug.cgi?id=18843
     std::shared_ptr<T const> t1(new T);
     std::shared_ptr<T const> t2(std::make_shared<T>());
     }
     { // https://bugs.llvm.org/show_bug.cgi?id=27115
     int x = 42;
     std::shared_ptr<Bar> t1(new Bar(42));
     assert(t1->shared_from_this() == t1);

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_throw.pass.cpp

struct A
     A(const A&) {++count;}
     ~A() {--count;}
 };
 
 int A::count = 0;
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     A* ptr = new A;
     globalMemCounter.throw_after = 0;
     try
     {
         std::shared_ptr<A> p(ptr, test_deleter<A>(3));
         assert(false);
     }
     catch (std::bad_alloc&)

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_throw.pass.cpp

struct A
     ~A() {--count;}
 };
 
 int A::count = 0;
 
 
 int main(int, char**)
 {
+    globalMemCounter.reset();
     A* ptr = new A;
     assert(A::count == 1);
     globalMemCounter.throw_after = 0;
     try
     {
         std::shared_ptr<A> p(ptr);
         assert(false);
     }
     catch (std::bad_alloc&)
     {
         assert(A::count == 0);
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
 
   return 0;
 }