Reset more globalMemCounters.

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/construct.cxx2a.pass.cpp

 public:
     int data; // unused other than to make sizeof(move_only) == sizeof(int).
               // but public to suppress "-Wunused-private-field"
 };
 #endif // TEST_STD_VER >= 11
 
 int main(int, char**)
 {
-    {
+  globalMemCounter.reset();
     std::allocator<A> a;
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(A_constructed == 0);
 
     globalMemCounter.last_new_size = 0;
     A* ap = a.allocate(3);
     DoNotOptimize(ap);
     assert(globalMemCounter.checkOutstandingNewEq(1));
globalMemCounter.reset();
     a.destroy(ap);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(A_constructed == 0);
 
     a.deallocate(ap, 3);
     DoNotOptimize(ap);
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(A_constructed == 0);
-    }
 #if TEST_STD_VER >= 11
     {
     std::allocator<move_only> a;
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(move_only_constructed == 0);
 
     globalMemCounter.last_new_size = 0;
     move_only* ap = a.allocate(3);

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

void test_for_alloc(Alloc& alloc) {
 
     test_MemFunClass<int(MemFunClass::*)() const, int(MemFunClass&)>(alloc);
     test_MemFunClass<int(MemFunClass::*)(int) const, int(MemFunClass&, int)>(alloc);
     test_MemFunClass<int(MemFunClass::*)(int, int) const, int(MemFunClass&, int, int)>(alloc);
 }
 
 int main(int, char**)
 {
-    {
-        bare_allocator<DummyClass> bare_alloc;
-        test_for_alloc(bare_alloc);
-    }
+  globalMemCounter.reset();
     {
         non_default_test_allocator<DummyClass> non_default_alloc(42);
         test_for_alloc(non_default_alloc);
     }
 #if TEST_STD_VER >= 11
     {
         using Fn = std::function<void(int, int, int)>;
         static_assert(std::is_constructible<Fn, std::allocator_arg_t, std::allocator<int>, LValueCallable&>::value, "");

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

void test_for_alloc(Alloc& alloc)
     // Member function -- No allocation should occur.
     test_MemFunClass<int(MemFunClass::*)() const, int(MemFunClass&)>(alloc);
     test_MemFunClass<int(MemFunClass::*)(int) const, int(MemFunClass&, int)>(alloc);
     test_MemFunClass<int(MemFunClass::*)(int, int) const, int(MemFunClass&, int, int)>(alloc);
 }
 
 int main(int, char**)
 {
+  globalMemCounter.reset();
   {
     bare_allocator<DummyClass> alloc;
     test_for_alloc(alloc);
   }
   {
     non_default_test_allocator<DummyClass> alloc(42);
     test_for_alloc(alloc);
   }
 
   return 0;
 }

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

 };
 
 int A::count = 0;
 
 int g(int) { return 0; }
 
 int main(int, char**)
 {
-    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(std::allocator_arg, bare_allocator<A>(), std::move(f));
-        assert(A::count == 1);
-        assert(globalMemCounter.checkOutstandingNewEq(1));
-        assert(f2.target<A>());
-        assert(f2.target<int(*)(int)>() == 0);
-        assert(f.target<A>() == 0);
-        assert(f.target<int(*)(int)>() == 0);
-    }
+  globalMemCounter.reset();
+    assert(f.target<int (*)(int)>() == 0);
+    std::function<int(int)> f2(std::allocator_arg, bare_allocator<A>(),
+                               std::move(f));
+    assert(f2.target<int (*)(int)>() == 0);
+    assert(f.target<int (*)(int)>() == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
     {
         // Test that moving a function constructed from a reference wrapper
         // is done without allocating.
         DisableAllocationGuard g;
         using Ref = std::reference_wrapper<A>;
         A a;
         Ref aref(a);

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

struct A
     A(const A&) {++count;}
     ~A() {--count;}
 };
 
 int A::count = 0;
 
 int main(int, char**)
 {
-    {
-        std::auto_ptr<A> ptr(new A);
-        A* raw_ptr = ptr.get();
+  globalMemCounter.reset();
 #if TEST_STD_VER >= 11
         std::shared_ptr<B> p(std::move(ptr));
 #else
         std::shared_ptr<B> p(ptr);
 #endif
         assert(A::count == 1);
         assert(B::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == raw_ptr);
         assert(ptr.get() == 0);
-    }
     assert(A::count == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
 #if !defined(TEST_HAS_NO_EXCEPTIONS) && !defined(DISABLE_NEW_COUNT)
     {
         std::auto_ptr<A> ptr(new A);
         A* raw_ptr = ptr.get();
         globalMemCounter.throw_after = 0;
         try