[libc++] Enable deprecation warnings by default

[ldionne]

Summary

In r342843, I added deprecation warnings to some facilities that were
deprectated in C++14 and C++17. However, those deprecation warnings
were not enabled by default.

After discussing this on IRC, we had finally gotten consensus to enable
those warnings by default, and I'm getting around to doing that only
now.

[ldionne]

I'd like to enable this early in the LLVM 9 cycle.

[ldionne]

Added missing #defines in tests

[aaron.ballman]

This seems sensible to me, but I leave it to the libc++ maintainers to sign off on the review. Thank you for working on this!

[ldionne]

Ping.

[ldionne]

Last ping. We discussed this on the IRC months ago and other maintainers were fine with it. I'll commit this at the end of the week unless somebody changed their mind.

[mclow.lists]

Go for it. I'm curious to see how it works out :-)

libcxx/trunk/docs/UsingLibcxx.rst

**_LIBCPP_ENABLE_NODISCARD**:
   See :ref:`Extended Applications of [[nodiscard]] <nodiscard extension>` for
   more information.
 
 **_LIBCPP_DISABLE_NODISCARD_EXT**:
   This macro prevents the library from applying ``[[nodiscard]]`` to entities
   purely as an extension. See :ref:`Extended Applications of [[nodiscard]] <nodiscard extension>`
   for more information.
 
-**_LIBCPP_ENABLE_DEPRECATION_WARNINGS**:
-  This macro enables warnings when using deprecated components. For example,
-  when compiling in C++11 mode, using `std::auto_ptr` with the macro defined
-  will trigger a warning saying that `std::auto_ptr` is deprecated. By default,
-  this macro is not defined.
+**_LIBCPP_DISABLE_DEPRECATION_WARNINGS**:
+  This macro disables warnings when using deprecated components. For example,
+  using `std::auto_ptr` when compiling in C++11 mode will normally trigger a
+  warning saying that `std::auto_ptr` is deprecated. If the macro is defined,
+  no warning will be emitted. By default, this macro is not defined.
 
 C++17 Specific Configuration Macros
 -----------------------------------
 **_LIBCPP_ENABLE_CXX17_REMOVED_FEATURES**:
   This macro is used to re-enable all the features removed in C++17. The effect
   is equivalent to manually defining each macro listed below.
 
 **_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS**:

libcxx/trunk/include/__config

 #define _LIBCPP_WCTYPE_IS_MASK
 #endif
 
 #if _LIBCPP_STD_VER <= 17 || !defined(__cpp_char8_t)
 #define _LIBCPP_NO_HAS_CHAR8_T
 #endif
 
 // Deprecation macros.
-// Deprecations warnings are only enabled when _LIBCPP_ENABLE_DEPRECATION_WARNINGS is defined.
-#if defined(_LIBCPP_ENABLE_DEPRECATION_WARNINGS)
+//
+// Deprecations warnings are always enabled, except when users explicitly opt-out
+// by defining _LIBCPP_DISABLE_DEPRECATION_WARNINGS.
+#if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
 #  if __has_attribute(deprecated)
 #    define _LIBCPP_DEPRECATED __attribute__ ((deprecated))
 #  elif _LIBCPP_STD_VER > 11
 #    define _LIBCPP_DEPRECATED [[deprecated]]
 #  else
 #    define _LIBCPP_DEPRECATED
 #  endif
 #else

libcxx/trunk/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp

 //  In C++17, random_shuffle has been removed.
 //  However, for backwards compatibility, if _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
 //  is defined before including <algorithm>, then random_shuffle will be restored.
 
 // REQUIRES: verify-support
 
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
 #define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <algorithm>
 #include <vector>
 
 struct gen
 {
     std::ptrdiff_t operator()(std::ptrdiff_t n)
     {

libcxx/trunk/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp

 //     void
 //     random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
 //                    RandomNumberGenerator& rand);
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03, c++11
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
 
 #include <algorithm>
 #include <cstddef>
 
 #include "test_macros.h"
 
 struct gen

libcxx/trunk/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp

 // template <class X>
 // class auto_ptr;
 //
 //  In C++17, auto_ptr has been removed.
 //  However, for backwards compatibility, if _LIBCPP_NO_REMOVE_AUTOPTR
 //  is defined before including <memory>, then auto_ptr will be restored.
 
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
-
 #define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <memory>
 #include <type_traits>
 
 int main(int, char**)
 {
     std::auto_ptr<int> p;
 
   return 0;
 }

libcxx/trunk/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp

 // class auto_ptr_ref;
 //
 // Deprecated in C++11
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
 
 #include <memory>
 #include "test_macros.h"
 
 int main(int, char**)
 {
     typedef std::auto_ptr<int> AP; // expected-error{{'auto_ptr<int>' is deprecated}}
     typedef std::auto_ptr<void> APV; // expected-error{{'auto_ptr<void>' is deprecated}}
     typedef std::auto_ptr_ref<int> APR; // expected-error{{'auto_ptr_ref<int>' is deprecated}}
 
   return 0;
 }

libcxx/trunk/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 #include <cassert>
 #include "test_macros.h"
 
 int identity(int v) { return v; }
 int sum(int a, int b) { return a + b; }

libcxx/trunk/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp

 
 
 //  In C++17, the function adapters mem_fun/mem_fun_ref, etc have been removed.
 //  However, for backwards compatibility, if _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 //  is defined before including <functional>, then they will be restored.
 
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <functional>
 #include <cassert>
 
 int identity(int v) { return v; }
 int sum(int a, int b) { return a + b; }
 
 struct Foo {

libcxx/trunk/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.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
 //
 //===----------------------------------------------------------------------===//
 
 // <algorithm>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<RandomAccessIterator Iter>
 //   requires ShuffleIterator<Iter>
 //   void
 //   random_shuffle(Iter first, Iter last);
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 template <class Iter>
 void

libcxx/trunk/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp

 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<RandomAccessIterator Iter, Callable<auto, Iter::difference_type> Rand>
 //   requires ShuffleIterator<Iter>
 //         && Convertible<Rand::result_type, Iter::difference_type>
 //   void
 //   random_shuffle(Iter first, Iter last, Rand&& rand);
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/assignment.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // auto_ptr& operator=(auto_ptr& a) throw();
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../A.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // auto_ptr(auto_ptr& a) throw();
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../AB.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // template<class Y> auto_ptr& operator=(auto_ptr<Y>& a) throw();
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../AB.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/convert_assignment.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // template<class Y> auto_ptr& operator=(auto_ptr<Y>& a) throw();
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../AB.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // auto_ptr(auto_ptr& a) throw();
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../A.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // auto_ptr(auto_ptr& a) throw();
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../A.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/explicit.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // explicit auto_ptr(X* p =0) throw();
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../A.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.cons/pointer.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // explicit auto_ptr(X* p =0) throw();
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../A.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/assign_from_auto_ptr_ref.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // auto_ptr& operator=(auto_ptr_ref<X> r) throw()
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../A.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_from_auto_ptr_ref.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // auto_ptr(auto_ptr_ref<X> r) throw();
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../AB.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // template<class Y> operator auto_ptr<Y>() throw();
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../AB.h"
 
 std::auto_ptr<B>
 source()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.conv/convert_to_auto_ptr_ref.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // template<class Y> operator auto_ptr_ref<Y>() throw();
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../AB.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/arrow.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // X& operator*() const throw();
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../A.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/deref.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // X& operator*() const throw();
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "../A.h"
 
 void
 test()
 {

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/release.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // X* release() throw();
 
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
-// REQUIRES: c++98 || c++03 || c++11 || c++14
-
 #include "../A.h"
 
 void
 test()
 {
     {
     A* p = new A(1);
     std::auto_ptr<A> ap(p);

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/auto.ptr.members/reset.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class X> class auto_ptr;
 
 // void reset(X* p=0) throw();
 
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
-// REQUIRES: c++98 || c++03 || c++11 || c++14
-
 #include "../A.h"
 
 void
 test()
 {
     {
     A* p = new A(1);
     std::auto_ptr<A> ap(p);

libcxx/trunk/test/std/depr/depr.auto.ptr/auto.ptr/element_type.pass.cpp

 // {
 // public:
 //   typedef X element_type;
 //   ...
 // };
 
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <type_traits>
 
 template <class T>
 void
 test()
 {
     static_assert((std::is_same<typename std::auto_ptr<T>::element_type, T>::value), "");

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // pointer_to_binary_function
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 double binary_f(int i, short j) {return i - j + .75;}
 
 int main(int, char**)
 {
     typedef std::pointer_to_binary_function<int, short, double> F;
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_binary_function.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // pointer_to_binary_function
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 double binary_f(int i, short j) {return i - j + .75;}
 
 int main(int, char**)
 {
     typedef std::pointer_to_binary_function<int, short, double> F;
     static_assert((std::is_base_of<std::binary_function<int, short, double>, F>::value), "");
     const F f(binary_f);
     assert(f(36, 27) == 9.75);
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // pointer_to_unary_function
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 double unary_f(int i) {return 0.5 - i;}
 
 int main(int, char**)
 {
     typedef std::pointer_to_unary_function<int, double> F;
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/pointer_to_unary_function.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // pointer_to_unary_function
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 double unary_f(int i) {return 0.5 - i;}
 
 int main(int, char**)
 {
     typedef std::pointer_to_unary_function<int, double> F;
     static_assert((std::is_base_of<std::unary_function<int, double>, F>::value), "");
     const F f(unary_f);
     assert(f(36) == -35.5);
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template <CopyConstructible Arg, Returnable Result>
 // pointer_to_unary_function<Arg, Result>
 // ptr_fun(Result (*f)(Arg));
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 double unary_f(int i) {return 0.5 - i;}
 
 int main(int, char**)
 {
     assert(std::ptr_fun(unary_f)(36) == -35.5);
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun1.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template <CopyConstructible Arg, Returnable Result>
 // pointer_to_unary_function<Arg, Result>
 // ptr_fun(Result (*f)(Arg));
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 double unary_f(int i) {return 0.5 - i;}
 
 int main(int, char**)
 {
     assert(std::ptr_fun(unary_f)(36) == -35.5);
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template <CopyConstructible Arg1, CopyConstructible Arg2, Returnable Result>
 // pointer_to_binary_function<Arg1,Arg2,Result>
 // ptr_fun(Result (*f)(Arg1, Arg2));
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 double binary_f(int i, short j) {return i - j + .75;}
 
 int main(int, char**)
 {
     assert(std::ptr_fun(binary_f)(36, 27) == 9.75);
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.function.pointer.adaptors/ptr_fun2.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template <CopyConstructible Arg1, CopyConstructible Arg2, Returnable Result>
 // pointer_to_binary_function<Arg1,Arg2,Result>
 // ptr_fun(Result (*f)(Arg1, Arg2));
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 double binary_f(int i, short j) {return i - j + .75;}
 
 int main(int, char**)
 {
     assert(std::ptr_fun(binary_f)(36, 27) == 9.75);
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template<cReturnable S, ClassType T>
 //   const_mem_fun_t<S,T>
 //   mem_fun(S (T::*f)() const);
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {
     char a1() {return 5;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<cReturnable S, ClassType T>
 //   const_mem_fun_t<S,T>
 //   mem_fun(S (T::*f)() const);
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}
     int a3() const {return 1;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   const_mem_fun1_t<S,T,A>
 //   mem_fun(S (T::*f)(A) const);
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {
     char a1() {return 5;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   const_mem_fun1_t<S,T,A>
 //   mem_fun(S (T::*f)(A) const);
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}
     int a3() const {return 1;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // const_mem_fun1_ref_t
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // const_mem_fun1_ref_t
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // const_mem_fun1_t
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // const_mem_fun1_t
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template<Returnable S, ClassType T>
 //   const_mem_fun_ref_t<S,T>
 //   mem_fun_ref(S (T::*f)() const);
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {
     char a1() {return 5;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<Returnable S, ClassType T>
 //   const_mem_fun_ref_t<S,T>
 //   mem_fun_ref(S (T::*f)() const);
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}
     int a3() const {return 1;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   const_mem_fun1_ref_t<S,T,A>
 //   mem_fun_ref(S (T::*f)(A) const);
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {
     char a1() {return 5;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   const_mem_fun1_ref_t<S,T,A>
 //   mem_fun_ref(S (T::*f)(A) const);
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}
     int a3() const {return 1;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // const_mem_fun_ref_t
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // const_mem_fun_ref_t
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // const_mem_fun_t
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // const_mem_fun_t
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template<Returnable S, ClassType T>
 //   mem_fun_t<S,T>
 //   mem_fun(S (T::*f)());
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {
     char a1() {return 5;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<Returnable S, ClassType T>
 //   mem_fun_t<S,T>
 //   mem_fun(S (T::*f)());
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}
     int a3() const {return 1;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   mem_fun1_t<S,T,A>
 //   mem_fun(S (T::*f)(A));
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {
     char a1() {return 5;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   mem_fun1_t<S,T,A>
 //   mem_fun(S (T::*f)(A));
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}
     int a3() const {return 1;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // mem_fun1_ref_t
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // mem_fun1_ref_t
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // mem_fun1_t
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // mem_fun1_t
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template<Returnable S, ClassType T>
 //   mem_fun_ref_t<S,T>
 //   mem_fun_ref(S (T::*f)());
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {
     char a1() {return 5;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<Returnable S, ClassType T>
 //   mem_fun_ref_t<S,T>
 //   mem_fun_ref(S (T::*f)());
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}
     int a3() const {return 1;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   mem_fun1_ref_t<S,T,A>
 //   mem_fun_ref(S (T::*f)(A));
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {
     char a1() {return 5;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   mem_fun1_ref_t<S,T,A>
 //   mem_fun_ref(S (T::*f)(A));
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}
     int a3() const {return 1;}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // mem_fun_ref_t
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // mem_fun_ref_t
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // mem_fun_t
 // Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {

libcxx/trunk/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // mem_fun_t
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 struct A
 {
     char a1() {return 5;}
     short a2(int i) {return short(i+1);}

libcxx/trunk/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // bind1st
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::bind1st(test_func(1), 5); // expected-error{{'bind1st<test_func, int>' is deprecated}}
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template <class Fn, class T>
 //   binder1st<Fn>
 //   bind1st(const Fn& fn, const T& x);
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 #include "../test_func.h"
 
 int main(int, char**)
 {
     assert(std::bind1st(test_func(1), 5)(10.) == -5.);
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // bind2nd
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::bind2nd(test_func(1), 5); // expected-error{{'bind2nd<test_func, int>' is deprecated}}
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template <class Fn, class T>
 //   binder2nd<Fn>
 //   bind2nd(const Fn& op, const T& x);
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 #include "../test_func.h"
 
 int main(int, char**)
 {
     assert(std::bind2nd(test_func(1), 5)(10) == 5.);
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // binder1st
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
     typedef std::binder1st<test_func> B1ST; // expected-error{{'binder1st<test_func>' is deprecated}}
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.pass.cpp

 //   typename Fn::first_argument_type value;
 // public:
 //   binder2nd(const Fn& x, const typename Fn::second_argument_type& y);
 //
 //   typename Fn::result_type operator()(const typename Fn::first_argument_type& x) const;
 //   typename Fn::result_type operator()(typename Fn::first_argument_type& x) const;
 // };
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "../test_func.h"
 
 class test
     : public std::binder1st<test_func>

libcxx/trunk/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // binder2nd
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 
 #include <functional>
 
 #include "../test_func.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
     typedef std::binder2nd<test_func> B2ND; // expected-error{{'binder2nd<test_func>' is deprecated}}
 
   return 0;
 }

libcxx/trunk/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.pass.cpp

 //   typename Fn::second_argument_type value;
 // public:
 //   binder2nd(const Fn& x, const typename Fn::second_argument_type& y);
 //
 //   typename Fn::result_type operator()(const typename Fn::first_argument_type& x) const;
 //   typename Fn::result_type operator()(typename Fn::first_argument_type& x) const;
 // };
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 #include "../test_func.h"
 
 class test
     : public std::binder2nd<test_func>

libcxx/trunk/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp

 
 // binary_negate
 //  deprecated in C++17
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
-
 #include <functional>
 
 #include "test_macros.h"
 
 struct Predicate {
     typedef int first_argument_type;
     typedef int second_argument_type;
     bool operator()(first_argument_type, second_argument_type) const { return true; }
 };
 
 int main(int, char**) {
     std::binary_negate<Predicate> f((Predicate())); // expected-error{{'binary_negate<Predicate>' is deprecated}}
     (void)f;
 
   return 0;
 }

libcxx/trunk/test/std/utilities/function.objects/negators/binary_negate.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // binary_negate
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 int main(int, char**)
 {
     typedef std::binary_negate<std::logical_and<int> > F;
     const F f = F(std::logical_and<int>());

libcxx/trunk/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp

 
 // not1
 //  deprecated in C++17
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
-
 #include <functional>
 
 #include "test_macros.h"
 
 struct Predicate {
     typedef int argument_type;
     bool operator()(argument_type) const { return true; }
 };
 
 int main(int, char**) {
     std::not1(Predicate()); // expected-error{{'not1<Predicate>' is deprecated}}
 
   return 0;
 }

libcxx/trunk/test/std/utilities/function.objects/negators/not1.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // not1
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 int main(int, char**)
 {
     typedef std::logical_not<int> F;
     assert(std::not1(F())(36));
     assert(!std::not1(F())(0));
 
   return 0;
 }

libcxx/trunk/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp

 
 // not2
 //  deprecated in C++17
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
-
 #include <functional>
 
 #include "test_macros.h"
 
 struct Predicate {
     typedef int first_argument_type;
     typedef int second_argument_type;
     bool operator()(first_argument_type, second_argument_type) const { return true; }
 };
 
 int main(int, char**) {
     std::not2(Predicate()); // expected-error{{'not2<Predicate>' is deprecated}}
 
   return 0;
 }

libcxx/trunk/test/std/utilities/function.objects/negators/not2.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // not2
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 int main(int, char**)
 {
     typedef std::logical_and<int> F;
     assert(!std::not2(F())(36, 36));
     assert( std::not2(F())(36, 0));
     assert( std::not2(F())(0, 36));
     assert( std::not2(F())(0, 0));
 
   return 0;
 }

libcxx/trunk/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp

 
 // unary_negate
 //  deprecated in C++17
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // REQUIRES: verify-support
 
-// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
-#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
-
 #include <functional>
 
 #include "test_macros.h"
 
 struct Predicate {
     typedef int argument_type;
     bool operator()(argument_type) const { return true; }
 };
 
 int main(int, char**) {
     std::unary_negate<Predicate> f((Predicate())); // expected-error{{'unary_negate<Predicate>' is deprecated}}
     (void)f;
 
   return 0;
 }

libcxx/trunk/test/std/utilities/function.objects/negators/unary_negate.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // unary_negate
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 int main(int, char**)
 {
     typedef std::unary_negate<std::logical_not<int> > F;
     const F f = F(std::logical_not<int>());
     static_assert((std::is_same<F::argument_type, int>::value), "" );
     static_assert((std::is_same<F::result_type, bool>::value), "" );
     assert(f(36));
     assert(!f(0));
 
   return 0;
 }

libcxx/trunk/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/auto_ptr_Y.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // shared_ptr
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r);
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <type_traits>
 #include <cassert>
 
 struct B
 {
     static int count;
 

libcxx/trunk/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/shared_ptr.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // shared_ptr
 
 // shared_ptr& operator=(const shared_ptr& r);
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <type_traits>
 #include <cassert>
 
 struct B
 {
     static int count;
 

libcxx/trunk/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/auto_ptr.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template<class Y> explicit shared_ptr(auto_ptr<Y>&& r);
 // REQUIRES: c++98 || c++03 || c++11 || c++14
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.hpp"

libcxx/trunk/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/auto_pointer.pass.cpp

 // REQUIRES: c++11 || c++14
 
 // <memory>
 
 // unique_ptr
 
 // template <class U> unique_ptr(auto_ptr<U>&&) noexcept
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A {
   static int count;