[libcxx] [test] Mark tests that require specific allocation behaviours as libcpp only

[mstorsjo]

Summary

This fixes/silences a few failures on libstdc++ on linux.

Or does the standard actually mandate these strict allocation behaviours here, and libstdc++ violates the standard in this aspect?

[ldionne]

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.pass.cpp

9

It's a nit, but can you please instead use // REQUIRES: libc++ above the c++03 requirement -- I find it easier to read that way.

[mstorsjo]

Using REQUIRES: libc++ instead of UNSUPPORTED: !libc++.

libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp

for (auto const & TC : Cases) {
       assert(&Res == &LHS);
     }
     doAppendSourceTest<char>    (TC);
     doAppendSourceTest<wchar_t> (TC);
     doAppendSourceTest<char16_t>(TC);
     doAppendSourceTest<char32_t>(TC);
   }
   for (auto const & TC : LongLHSCases) {
-    doAppendSourceAllocTest<char>(TC);
-    doAppendSourceAllocTest<wchar_t>(TC);
+    LIBCPP_ONLY(doAppendSourceAllocTest<char>(TC));
+    LIBCPP_ONLY(doAppendSourceAllocTest<wchar_t>(TC));
   }
   test_sfinae();
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp

int main(int, char**)
   for (auto const & TC : LongLHSCases) {
     // Do path test
     {
       path LHS((const char*)TC.lhs);
       path RHS((const char*)TC.rhs);
       const char* E = TC.expect;
       PathReserve(LHS, StrLen(E) + 5);
       {
-        DisableAllocationGuard g;
+        LIBCPP_ONLY(DisableAllocationGuard g);
         path& Ref = (LHS += RHS);
         assert(&Ref == &LHS);
       }
       assert(LHS == E);
     }
     {
       path LHS((const char*)TC.lhs);
       std::string_view RHS((const char*)TC.rhs);
       const char* E = TC.expect;
       PathReserve(LHS, StrLen(E) + 5);
       {
-        DisableAllocationGuard g;
+        LIBCPP_ONLY(DisableAllocationGuard g);
         path& Ref = (LHS += RHS);
         assert(&Ref == &LHS);
       }
       assert(LHS == E);
     }
-    doConcatSourceAllocTest<char>(TC);
-    doConcatSourceAllocTest<wchar_t>(TC);
+    LIBCPP_ONLY(doConcatSourceAllocTest<char>(TC));
+    LIBCPP_ONLY(doConcatSourceAllocTest<wchar_t>(TC));
   }
   for (auto const& TC : CharTestCases) {
     doConcatECharTest<char>(TC);
     doConcatECharTest<wchar_t>(TC);
     doConcatECharTest<char16_t>(TC);
     doConcatECharTest<char32_t>(TC);
   }
   test_sfinae();
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03
+// UNSUPPORTED: c++03, !libc++
 
 // <filesystem>
 
 // class path
 
 // template <class ECharT, class Traits = char_traits<ECharT>,
 //           class Allocator = allocator<ECharT>>
 // basic_string<ECharT, Traits, Allocator>