[libcxx] [test] Update for C++17 feature removals.

[STL_MSFT]

Summary

[libcxx] [test] Update for C++17 feature removals.

test/std/containers/Emplaceable.h
test/std/containers/NotConstructible.h
test/support/counting_predicates.hpp
Replace unary_function/binary_function inheritance with typedefs.

test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
test/std/utilities/function.objects/func.require/binary_function.pass.cpp
test/std/utilities/function.objects/func.require/unary_function.pass.cpp
Mark these tests as requiring 98/03/11/14 because 17 removed unary_function/binary_function.

test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
Mark these tests as requiring 11/14 because 17 removed packaged_task allocator support.

test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
This test doesn't need to be skipped in C++17 mode. Only the construction of
std::function from an allocator needs to be skipped in C++17 mode.

test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
When testing these reference_wrapper features, unary_function inheritance is totally irrelevant.

test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
Define and use my_unary_function/my_binary_function to test the weak result type machinery
(which is still present in C++17, although deprecated).

test/support/msvc_stdlib_force_include.hpp
Now we can test C++17 strictly, without enabling removed features.

[STL_MSFT]

Ping?

[STL_MSFT]

It's been two weeks - if there are no objections, I'd like to commit this soon. Thanks!

[STL_MSFT]

Looks good to myself.

test/std/containers/Emplaceable.h

public:
 
     int get() const {return int_;}
 };
 
 namespace std {
 
 template <>
 struct hash<Emplaceable>
-    : public std::unary_function<Emplaceable, std::size_t>
 {
+    typedef Emplaceable argument_type;
+    typedef std::size_t result_type;
+
     std::size_t operator()(const Emplaceable& x) const {return x.get();}
 };
 
 }
 
 #endif  // TEST_STD_VER >= 11
 #endif  // EMPLACEABLE_H

test/std/containers/NotConstructible.h

 operator==(const NotConstructible&, const NotConstructible&)
 {return true;}
 
 namespace std
 {
 
 template <>
 struct hash<NotConstructible>
-    : public std::unary_function<NotConstructible, std::size_t>
 {
+    typedef NotConstructible argument_type;
+    typedef std::size_t result_type;
+
     std::size_t operator()(const NotConstructible&) const {return 0;}
 };
 
 }
 
 #endif  // NOTCONSTRUCTIBLE_H

test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// binary_function was removed in C++17
 
 // template <class Arg1, class Arg2, class Result>
 // struct binary_function
 // {
 //     typedef Arg1   first_argument_type;
 //     typedef Arg2   second_argument_type;
 //     typedef Result result_type;
 // };

test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// unary_function was removed in C++17
 
 // template <class Arg, class Result>
 // struct unary_function
 // {
 //     typedef Arg    argument_type;
 //     typedef Result result_type;
 // };
 
 #include <functional>
 #include <type_traits>
 
 int main()
 {
     static_assert((std::is_same<std::unary_function<unsigned, char>::argument_type, unsigned>::value), "");
     static_assert((std::is_same<std::unary_function<unsigned, char>::result_type, char>::value), "");
 }

test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
+// REQUIRES: c++11 || c++14
+// packaged_task allocator support was removed in C++17 (LWG 2921)
 
 // <future>
 
 // class packaged_task<R(ArgTypes...)>
 
 // template <class F, class Allocator>
 //     explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f);
 

test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp

 
 // This test is marked XFAIL and not UNSUPPORTED because the non-variadic
 // declaration of packaged_task is available in C++03. Therefore the test
 // should fail because the static_assert fires and not because std::packaged_task
 // in undefined.
 // XFAIL: c++98, c++03
 
 // <future>
+// REQUIRES: c++11 || c++14
+// packaged_task allocator support was removed in C++17 (LWG 2976)
 
 // class packaged_task<R(ArgTypes...)>
 
 // template <class Callable, class Alloc>
 //   struct uses_allocator<packaged_task<Callable>, Alloc>
 //      : true_type { };
 
 #include <future>
 #include "test_allocator.h"
 
 int main()
 {
     static_assert((std::uses_allocator<std::packaged_task<double(int, char)>, test_allocator<int> >::value), "");
 }

test/std/utilities/function.objects/func.require/binary_function.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// binary_function was removed in C++17
 
 // binary_function
 
 #include <functional>
 #include <type_traits>
 
 int main()
 {
     typedef std::binary_function<int, short, bool> bf;
     static_assert((std::is_same<bf::first_argument_type, int>::value), "");
     static_assert((std::is_same<bf::second_argument_type, short>::value), "");
     static_assert((std::is_same<bf::result_type, bool>::value), "");
 }

test/std/utilities/function.objects/func.require/unary_function.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// unary_function was removed in C++17
 
 // unary_function
 
 #include <functional>
 #include <type_traits>
 
 int main()
 {
     typedef std::unary_function<int, bool> uf;
     static_assert((std::is_same<uf::argument_type, int>::value), "");
     static_assert((std::is_same<uf::result_type, bool>::value), "");
 }

test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
-// REQUIRES: c++11 || c++14
 
 // <functional>
 
 // See https://bugs.llvm.org/show_bug.cgi?id=20002
 
 #include <functional>
 #include <type_traits>
 
 #include "test_macros.h"
 
 using Fn = std::function<void()>;
 struct S : public std::function<void()> { using function::function; };
 
 int main() {
     S s( [](){} );
     S f1( s );
+#if TEST_STD_VER <= 14
     S f2(std::allocator_arg, std::allocator<int>{}, s);
+#endif
 }

test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp

 // reference_wrapper
 
 // operator T& () const;
 
 #include <functional>
 #include <cassert>
 
 class functor1
-    : public std::unary_function<int, char>
 {
 };
 
 template <class T>
 void
 test(T& t)
 {
     std::reference_wrapper<T> r(t);

test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp

 // reference_wrapper
 
 // reference_wrapper& operator=(const reference_wrapper<T>& x);
 
 #include <functional>
 #include <cassert>
 
 class functor1
-    : public std::unary_function<int, char>
 {
 };
 
 template <class T>
 void
 test(T& t)
 {
     std::reference_wrapper<T> r(t);

test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp

 // reference_wrapper
 
 // reference_wrapper(const reference_wrapper<T>& x);
 
 #include <functional>
 #include <cassert>
 
 class functor1
-    : public std::unary_function<int, char>
 {
 };
 
 template <class T>
 void
 test(T& t)
 {
     std::reference_wrapper<T> r(t);

test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp

 // reference_wrapper
 
 // reference_wrapper(T& t);
 
 #include <functional>
 #include <cassert>
 
 class functor1
-    : public std::unary_function<int, char>
 {
 };
 
 template <class T>
 void
 test(T& t)
 {
     std::reference_wrapper<T> r(t);

test/std/utilities/function.objects/refwrap/weak_result.pass.cpp

 
 // reference_wrapper
 
 // has weak result type
 
 #include <functional>
 #include <type_traits>
 
+template <class Arg, class Result>
+struct my_unary_function
+{ // std::unary_function was removed in C++17
+    typedef Arg argument_type;
+    typedef Result result_type;
+};
+
+template <class Arg1, class Arg2, class Result>
+struct my_binary_function
+{ // std::binary_function was removed in C++17
+    typedef Arg1 first_argument_type;
+    typedef Arg2 second_argument_type;
+    typedef Result result_type;
+};
+
 class functor1
-    : public std::unary_function<int, char>
+    : public my_unary_function<int, char>
 {
 };
 
 class functor2
-    : public std::binary_function<char, int, double>
+    : public my_binary_function<char, int, double>
 {
 };
 
 class functor3
-    : public std::unary_function<char, int>,
-      public std::binary_function<char, int, double>
+    : public my_unary_function<char, int>,
+      public my_binary_function<char, int, double>
 {
 public:
     typedef float result_type;
 };
 
 class functor4
-    : public std::unary_function<char, int>,
-      public std::binary_function<char, int, double>
+    : public my_unary_function<char, int>,
+      public my_binary_function<char, int, double>
 {
 public:
 };
 
 class C {};
 
 template <class T>
 struct has_result_type

test/support/counting_predicates.hpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __COUNTING_PREDICATES_H
 #define __COUNTING_PREDICATES_H
 
 
 template <typename Predicate, typename Arg>
-struct unary_counting_predicate : public std::unary_function<Arg, bool>  {
+struct unary_counting_predicate {
 public:
+    typedef Arg argument_type;
+    typedef bool result_type;
+
     unary_counting_predicate(Predicate p) : p_(p), count_(0) {}
     ~unary_counting_predicate() {}
 
     bool operator () (const Arg &a) const { ++count_; return p_(a); }
     size_t count() const { return count_; }
     void reset() { count_ = 0; }
 
 private:
     Predicate p_;
     mutable size_t count_;
     };
 
 
 template <typename Predicate, typename Arg1, typename Arg2=Arg1>
-struct binary_counting_predicate : public std::binary_function<Arg1, Arg2, bool> {
+struct binary_counting_predicate {
 public:
+    typedef Arg1 first_argument_type;
+    typedef Arg2 second_argument_type;
+    typedef bool result_type;
 
     binary_counting_predicate ( Predicate p ) : p_(p), count_(0) {}
     ~binary_counting_predicate() {}
 
     bool operator () (const Arg1 &a1, const Arg2 &a2) const { ++count_; return p_(a1, a2); }
     size_t count() const { return count_; }
     void reset() { count_ = 0; }
 
 private:
     Predicate p_;
     mutable size_t count_;
     };
 
 #endif // __COUNTING_PREDICATES_H

test/support/msvc_stdlib_force_include.hpp

 
 // MSVC has quick_exit() and at_quick_exit().
 #define _LIBCPP_HAS_QUICK_EXIT
 
 #ifndef _LIBCXX_IN_DEVCRT
     // atomic_is_lock_free.pass.cpp needs this VS 2015 Update 2 fix.
     #define _ENABLE_ATOMIC_ALIGNMENT_FIX
 
-    // Enable features that /std:c++latest removes by default.
-    #define _HAS_AUTO_PTR_ETC               1
-    #define _HAS_FUNCTION_ALLOCATOR_SUPPORT 1
-    #define _HAS_OLD_IOSTREAMS_MEMBERS      1
-    #define _HAS_UNEXPECTED                 1
-
     // Silence warnings about raw pointers and other unchecked iterators.
     #define _SCL_SECURE_NO_WARNINGS
 
     // Silence warnings about features that are deprecated in C++17.
     #define _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
 #endif // _LIBCXX_IN_DEVCRT
 
 #include <ciso646>
 
 #if _HAS_CXX17
     #define TEST_STD_VER 17
 #else // _HAS_CXX17
     #define TEST_STD_VER 14
 #endif // _HAS_CXX17
 
 #endif // SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_HPP