1 files changed, 0 insertions, 115 deletions
diff --git a/libcxx/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp b/libcxx/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
deleted file mode 100644
index eefa6d1f22b..00000000000
--- a/libcxx/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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, c++11, c++14
-
-// type_traits
-
-// is_nothrow_callable
-
-#include <type_traits>
-#include <functional>
-
-#include "test_macros.h"
-
-struct Tag {};
-
-struct Implicit {
-  Implicit(int) noexcept {}
-};
-
-struct ThrowsImplicit {
-  ThrowsImplicit(int) {}
-};
-
-struct Explicit {
-  explicit Explicit(int) noexcept {}
-};
-
-template <bool IsNoexcept, class Ret, class ...Args>
-struct CallObject {
-  Ret operator()(Args&&...) const noexcept(IsNoexcept);
-};
-
-template <class Fn>
-constexpr bool throws_callable() {
-    return std::is_callable<Fn>::value &&
-        !std::is_nothrow_callable<Fn>::value;
-}
-
-template <class Fn, class Ret>
-constexpr bool throws_callable() {
-    return std::is_callable<Fn, Ret>::value &&
-        !std::is_nothrow_callable<Fn, Ret>::value;
-}
-
-// FIXME(EricWF) Don't test the where noexcept is *not* part of the type system
-// once implementations have caught up.
-void test_noexcept_function_pointers()
-{
-    struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
-#if !defined(__cpp_noexcept_function_type)
-    {
-        // Check that PMF's and function pointers *work*. is_nothrow_callable will always
-        // return false because 'noexcept' is not part of the function type.
-        static_assert(throws_callable<decltype(&Dummy::foo)(Dummy&)>(), "");
-        static_assert(throws_callable<decltype(&Dummy::bar)()>(), "");
-    }
-#else
-    {
-        // Check that PMF's and function pointers actually work and that
-        // is_nothrow_callable returns true for noexcept PMF's and function
-        // pointers.
-        static_assert(std::is_nothrow_callable<decltype(&Dummy::foo)(Dummy&)>::value, "");
-        static_assert(std::is_nothrow_callable<decltype(&Dummy::bar)()>::value, "");
-    }
-#endif
-}
-
-int main()
-{
-    {
-        // Check that the conversion to the return type is properly checked
-        using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_callable<Fn(), Implicit>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(), double>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(), const volatile void>::value, "");
-        static_assert(throws_callable<Fn(), ThrowsImplicit>(), "");
-        static_assert(!std::is_nothrow_callable<Fn(), Explicit>(), "");
-    }
-    {
-        // Check that the conversion to the parameters is properly checked
-        using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
-        static_assert(std::is_nothrow_callable<Fn(Implicit&, ThrowsImplicit&)>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(int, ThrowsImplicit&)>::value, "");
-        static_assert(throws_callable<Fn(int, int)>(), "");
-        static_assert(!std::is_nothrow_callable<Fn()>::value, "");
-    }
-    {
-        // Check that the noexcept-ness of function objects is checked.
-        using Fn = CallObject<true, void>;
-        using Fn2 = CallObject<false, void>;
-        static_assert(std::is_nothrow_callable<Fn()>::value, "");
-        static_assert(throws_callable<Fn2()>(), "");
-    }
-    {
-        // Check that PMD derefs are noexcept
-        using Fn = int (Tag::*);
-        static_assert(std::is_nothrow_callable<Fn(Tag&)>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(Tag&), Implicit>::value, "");
-        static_assert(throws_callable<Fn(Tag&), ThrowsImplicit>(), "");
-    }
-    {
-        // Check for is_nothrow_callable_v
-        using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_callable_v<Fn()>, "");
-        static_assert(!std::is_nothrow_callable_v<Fn(int)>, "");
-    }
-    test_noexcept_function_pointers();
-}