[libcxx] [test] Fix the new alloc tests for Windows

[mstorsjo]

Summary

Use ASSERT_WITH_OPERATOR_NEW_FALLBACKS where relevant to waive
the known cases where operator new isn't overridden as expected,
in MinGW DLL configurations.

Clarify the reason for why the fallback in
new.delete.array/new.size_align_nothrow.replace.indirect doesn't
work as expected (which could be considered a vcruntime bug).

[mstorsjo]

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_nothrow.replace.indirect.pass.cpp

18

FWIW, I reported this issue to vcruntime as https://developercommunity.visualstudio.com/t/vcruntime-nothrow-array-operator-new-fal/10373274.

[ldionne]

Thanks for the diligence!

LGTM with a small comment.

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_nothrow.replace.indirect.pass.cpp

18

Can you add a link to the bug report in the comment?

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align.replace.indirect.pass.cpp

 
 // We get availability markup errors when aligned allocation is missing
 // XFAIL: availability-aligned_allocation-missing
 
 // Libc++ when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
-// TODO: Investigate why this fails on MinGW-shared
-// UNSUPPORTED: target={{.+}}-windows-gnu
-
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cstdint>
 #include <cassert>
 #include <limits>
 
 #include "test_macros.h"
void operator delete(void*, std::align_val_t) noexcept {
     // nothing to delete, we didn't actually allocate in `operator new`
 }
 
 int main(int, char**) {
     // Test with an overaligned type
     {
         new_called = delete_called = 0;
         OverAligned* x = new OverAligned[3];
-        assert(static_cast<void*>(x) == DummyData);
-        assert(new_called == 1);
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(static_cast<void*>(x) == DummyData);
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 1);
 
         delete[] x;
-        assert(delete_called == 1);
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
     }
 
     // Test with a type that is right on the verge of being overaligned
     {
         new_called = delete_called = 0;
         MaxAligned* x = new MaxAligned[3];
         assert(x != nullptr);
         assert(new_called == 0);

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_align_nothrow.replace.indirect.pass.cpp

 
 // We get availability markup errors when aligned allocation is missing
 // XFAIL: availability-aligned_allocation-missing
 
 // Libc++ when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
-// TODO: Investigate why this fails on MinGW-shared
-// UNSUPPORTED: target={{.+}}-windows-gnu
-
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 #include <limits>
 
 #include "test_macros.h"
 #include "../types.h"
void operator delete[](void*, std::align_val_t) noexcept {
     // nothing to delete, we didn't actually allocate in `operator new`
 }
 
 int main(int, char**) {
     // Test with an overaligned type
     {
         new_called = delete_called = 0;
         OverAligned* x = new (std::nothrow) OverAligned[3];
-        assert(static_cast<void*>(x) == DummyData);
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(static_cast<void*>(x) == DummyData);
         ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 1);
 
         delete[] x;
         ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
     }
 
     // Test with a type that is right on the verge of being overaligned
     {

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new.size_nothrow.replace.indirect.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // void* operator new[](std::size_t, std::nothrow_t const&);
 
 // Test that we can replace the operator by replacing `operator new[](std::size_t)` (the throwing version).
 
 // UNSUPPORTED: sanitizer-new-delete
 // XFAIL: libcpp-no-vcruntime
 // XFAIL: LIBCXX-AIX-FIXME
 
-// TODO: Investigate why this fails on Windows
+// MSVC/vcruntime falls back from the nothrow array new to the nothrow
+// scalar new, instead of falling back on the throwing array new.
+// https://developercommunity.visualstudio.com/t/vcruntime-nothrow-array-operator-new-fal/10373274
 // XFAIL: target={{.+}}-windows-msvc
 
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new.size_align_nothrow.replace.indirect.pass.cpp

 
 // We get availability markup errors when aligned allocation is missing
 // XFAIL: availability-aligned_allocation-missing
 
 // Libc++ when built for z/OS doesn't contain the aligned allocation functions,
 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
-// TODO: Investigate why this fails on MinGW-shared
-// UNSUPPORTED: target={{.+}}-windows-gnu
-
 #include <new>
 #include <cstddef>
 #include <cstdlib>
 #include <cassert>
 #include <limits>
 
 #include "test_macros.h"
 #include "../types.h"
void operator delete(void*, std::align_val_t) noexcept {
     // nothing to delete, we didn't actually allocate in `operator new`
 }
 
 int main(int, char**) {
     // Test with an overaligned type
     {
         new_called = delete_called = 0;
         OverAligned* x = new (std::nothrow) OverAligned;
-        assert(static_cast<void*>(x) == DummyData);
+        ASSERT_WITH_OPERATOR_NEW_FALLBACKS(static_cast<void*>(x) == DummyData);
         ASSERT_WITH_OPERATOR_NEW_FALLBACKS(new_called == 1);
 
         delete x;
         ASSERT_WITH_OPERATOR_NEW_FALLBACKS(delete_called == 1);
     }
 
     // Test with a type that is right on the verge of being overaligned
     {