[libc++][test] _VSTD => std:: in test code

[CaseyCarter]

Summary

No _VSTD allowed in non-libc++-specific test code

[philnik]

No _VSTD allowed in non-libc++-specific test code

Also not in libc++-specific test code :-)

Could you also fix the _VSTD in func.not_fn/not_fn.pass.cpp:399 while you're at it? You can just change that when landing the patch.

libcxx/test/std/language.support/cmp/cmp.alg/compare_strong_order_fallback.pass.cpp

constexpr bool test_1_3()
     assert(std::compare_strong_order_fallback(v[13], v[12]) == std::strong_ordering::greater);
     assert(std::compare_strong_order_fallback(v[13], v[13]) == std::strong_ordering::equal);
 
 
     // There's no way to produce a specifically positive or negative NAN
     // at compile-time, so the NAN-related tests must be runtime-only.
 
     if (!std::is_constant_evaluated()) {
-        F nq = _VSTD::copysign(std::numeric_limits<F>::quiet_NaN(), F(-1));
-        F ns = _VSTD::copysign(std::numeric_limits<F>::signaling_NaN(), F(-1));
-        F ps = _VSTD::copysign(std::numeric_limits<F>::signaling_NaN(), F(+1));
-        F pq = _VSTD::copysign(std::numeric_limits<F>::quiet_NaN(), F(+1));
+        F nq = std::copysign(std::numeric_limits<F>::quiet_NaN(), F(-1));
+        F ns = std::copysign(std::numeric_limits<F>::signaling_NaN(), F(-1));
+        F ps = std::copysign(std::numeric_limits<F>::signaling_NaN(), F(+1));
+        F pq = std::copysign(std::numeric_limits<F>::quiet_NaN(), F(+1));
 
         assert(std::compare_strong_order_fallback(nq, nq) == std::strong_ordering::equal);
 #ifndef TEST_BUGGY_SIGNALING_NAN
         assert(std::compare_strong_order_fallback(nq, ns) == std::strong_ordering::less);
 #endif
         for (int i=0; i < 14; ++i) {
             assert(std::compare_strong_order_fallback(nq, v[i]) == std::strong_ordering::less);
         }

libcxx/test/std/language.support/cmp/cmp.alg/compare_weak_order_fallback.pass.cpp

constexpr bool test_1_3()
     assert(std::compare_weak_order_fallback(v[13], v[12]) == std::weak_ordering::greater);
     assert(std::compare_weak_order_fallback(v[13], v[13]) == std::weak_ordering::equivalent);
 
 
     // There's no way to produce a specifically positive or negative NAN
     // at compile-time, so the NAN-related tests must be runtime-only.
 
     if (!std::is_constant_evaluated()) {
-        F nq = _VSTD::copysign(std::numeric_limits<F>::quiet_NaN(), F(-1));
-        F ns = _VSTD::copysign(std::numeric_limits<F>::signaling_NaN(), F(-1));
-        F ps = _VSTD::copysign(std::numeric_limits<F>::signaling_NaN(), F(+1));
-        F pq = _VSTD::copysign(std::numeric_limits<F>::quiet_NaN(), F(+1));
+        F nq = std::copysign(std::numeric_limits<F>::quiet_NaN(), F(-1));
+        F ns = std::copysign(std::numeric_limits<F>::signaling_NaN(), F(-1));
+        F ps = std::copysign(std::numeric_limits<F>::signaling_NaN(), F(+1));
+        F pq = std::copysign(std::numeric_limits<F>::quiet_NaN(), F(+1));
 
         assert(std::compare_weak_order_fallback(nq, nq) == std::weak_ordering::equivalent);
         assert(std::compare_weak_order_fallback(nq, ns) == std::weak_ordering::equivalent);
         for (int i=0; i < 14; ++i) {
             assert(std::compare_weak_order_fallback(nq, v[i]) == std::weak_ordering::less);
         }
         assert(std::compare_weak_order_fallback(nq, ps) == std::weak_ordering::less);
         assert(std::compare_weak_order_fallback(nq, pq) == std::weak_ordering::less);

libcxx/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp

bool call_operator_noexcept_test()
         static_assert(!noexcept(ret()), "call should not be noexcept");
         auto const& cret = ret;
         static_assert(!noexcept(cret()), "call should not be noexcept");
     }
     {
         using T = NoExceptCallable<bool>;
         T value(true);
         auto ret = std::not_fn(value);
-        LIBCPP_STATIC_ASSERT(noexcept(!_VSTD::__invoke(value)), "");
+        LIBCPP_STATIC_ASSERT(noexcept(!std::__invoke(value)), "");
 #if TEST_STD_VER > 14
         static_assert(noexcept(!std::invoke(value)), "");
 #endif
         static_assert(noexcept(ret()), "call should be noexcept");
         auto const& cret = ret;
         static_assert(noexcept(cret()), "call should be noexcept");
     }
     {