[libcxx] [test] Add LIBCPP_ASSERT_NOEXCEPT/LIBCPP_ASSERT_NOT_NOEXCEPT, remove an unused variable.

[STL_MSFT]

Summary

[libcxx] [test] Add LIBCPP_ASSERT_NOEXCEPT/LIBCPP_ASSERT_NOT_NOEXCEPT, remove an unused variable.

test/support/test_macros.h
For convenience/greppability, add macros for libcxx-specific static_asserts about noexceptness.

(Moving the definitions of ASSERT_NOEXCEPT/ASSERT_NOT_NOEXCEPT isn't technically necessary
because they're macros, but I think it's better style to define stuff before using it.)

test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp
There was a completely unused TrackedCallable obj;.

apply() isn't depicted with conditional noexcept in C++17.

test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
Now that we have LIBCPP_ASSERT_NOEXCEPT, use it.

test/std/utilities/tuple/tuple.tuple/tuple.apply/apply.pass.cpp

TrackedCallable const& cobj = obj;
         assert(ret.quals == CQ_ConstRValue);
         assert(ret.arg_types == expect_args);
         assert(ret.args == t);
     }
 }
 
 void test_call_quals_and_arg_types()
 {
-    TrackedCallable obj;
     using Tup = std::tuple<int, int const&, unsigned&&>;
     const int x = 42;
     unsigned y = 101;
     Tup t(-1, x, std::move(y));
     Tup const& ct = t;
     check_apply_quals_and_types<int&, int const&, unsigned&>(t);
     check_apply_quals_and_types<int const&, int const&, unsigned&>(ct);
     check_apply_quals_and_types<int&&, int const&, unsigned&&>(std::move(t));

 void test_noexcept()
 {
     TestNoexceptCallable<true> nec;
     TestNoexceptCallable<false> tc;
     {
         // test that the functions noexcept-ness is propagated
         using Tup = std::tuple<int, const char*, long>;
         Tup t;
-        ASSERT_NOEXCEPT(std::apply(nec, t));
+        LIBCPP_ASSERT_NOEXCEPT(std::apply(nec, t));
         ASSERT_NOT_NOEXCEPT(std::apply(tc, t));
     }
     {
         // test that the noexcept-ness of the argument conversions is checked.
         using Tup = std::tuple<NothrowMoveable, int>;
         Tup t;
         ASSERT_NOT_NOEXCEPT(std::apply(nec, t));
-        ASSERT_NOEXCEPT(std::apply(nec, std::move(t)));
+        LIBCPP_ASSERT_NOEXCEPT(std::apply(nec, std::move(t)));
     }
 }
 
 namespace ReturnTypeTest {
     static int my_int = 42;
 
     template <int N> struct index {};
 

test/std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp

struct TestType {
       TestType(int, int, int) noexcept(false) {}
       TestType(long, long, long) noexcept {}
     };
     {
         using Tuple = std::tuple<int, NothrowMoveable>;
         Tuple tup; ((void)tup);
         Tuple const& ctup = tup; ((void)ctup);
         ASSERT_NOT_NOEXCEPT(std::make_from_tuple<TestType>(ctup));
-        LIBCPP_ONLY(ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(std::move(tup))));
+        LIBCPP_ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(std::move(tup)));
     }
     {
         using Tuple = std::pair<int, NothrowMoveable>;
         Tuple tup; ((void)tup);
         Tuple const& ctup = tup; ((void)ctup);
         ASSERT_NOT_NOEXCEPT(std::make_from_tuple<TestType>(ctup));
-        LIBCPP_ONLY(ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(std::move(tup))));
+        LIBCPP_ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(std::move(tup)));
     }
     {
         using Tuple = std::tuple<int, int, int>;
         Tuple tup; ((void)tup);
         ASSERT_NOT_NOEXCEPT(std::make_from_tuple<TestType>(tup));
     }
     {
         using Tuple = std::tuple<long, long, long>;
         Tuple tup; ((void)tup);
-        LIBCPP_ONLY(ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(tup)));
+        LIBCPP_ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(tup));
     }
     {
         using Tuple = std::array<int, 3>;
         Tuple tup; ((void)tup);
         ASSERT_NOT_NOEXCEPT(std::make_from_tuple<TestType>(tup));
     }
     {
         using Tuple = std::array<long, 3>;
         Tuple tup; ((void)tup);
-        LIBCPP_ONLY(ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(tup)));
+        LIBCPP_ASSERT_NOEXCEPT(std::make_from_tuple<TestType>(tup));
     }
 }
 
 int main()
 {
     test_constexpr_construction();
     test_perfect_forwarding();
     test_noexcept();
 }

test/support/test_macros.h

 #endif
 
 #if defined(_LIBCPP_NORETURN)
 #define TEST_NORETURN _LIBCPP_NORETURN
 #else
 #define TEST_NORETURN [[noreturn]]
 #endif
 
+#define ASSERT_NOEXCEPT(...) \
+    static_assert(noexcept(__VA_ARGS__), "Operation must be noexcept")
+
+#define ASSERT_NOT_NOEXCEPT(...) \
+    static_assert(!noexcept(__VA_ARGS__), "Operation must NOT be noexcept")
+
 /* Macros for testing libc++ specific behavior and extensions */
 #if defined(_LIBCPP_VERSION)
 #define LIBCPP_ASSERT(...) assert(__VA_ARGS__)
 #define LIBCPP_STATIC_ASSERT(...) static_assert(__VA_ARGS__)
+#define LIBCPP_ASSERT_NOEXCEPT(...) ASSERT_NOEXCEPT(__VA_ARGS__)
+#define LIBCPP_ASSERT_NOT_NOEXCEPT(...) ASSERT_NOT_NOEXCEPT(__VA_ARGS__)
 #define LIBCPP_ONLY(...) __VA_ARGS__
 #else
 #define LIBCPP_ASSERT(...) ((void)0)
 #define LIBCPP_STATIC_ASSERT(...) ((void)0)
+#define LIBCPP_ASSERT_NOEXCEPT(...) ((void)0)
+#define LIBCPP_ASSERT_NOT_NOEXCEPT(...) ((void)0)
 #define LIBCPP_ONLY(...) ((void)0)
 #endif
 
-#define ASSERT_NOEXCEPT(...) \
-    static_assert(noexcept(__VA_ARGS__), "Operation must be noexcept")
-
-#define ASSERT_NOT_NOEXCEPT(...) \
-    static_assert(!noexcept(__VA_ARGS__), "Operation must NOT be noexcept")
-
 namespace test_macros_detail {
 template <class T, class U>
 struct is_same { enum { value = 0};} ;
 template <class T>
 struct is_same<T, T> { enum {value = 1}; };
 } // namespace test_macros_detail
 
 #define ASSERT_SAME_TYPE(...) \