1 files changed, 0 insertions, 96 deletions
diff --git a/libcxx/test/re/re.badexp/regex_error.pass.cpp b/libcxx/test/re/re.badexp/regex_error.pass.cpp
deleted file mode 100644
index 02fecbda2d9..00000000000
--- a/libcxx/test/re/re.badexp/regex_error.pass.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-
-// <regex>
-
-// class regex_error
-//     : public runtime_error
-// {
-// public:
-//     explicit regex_error(regex_constants::error_type ecode);
-//     regex_constants::error_type code() const;
-// };
-
-#include <regex>
-#include <cassert>
-
-int main()
-{
-    {
-        std::regex_error e(std::regex_constants::error_collate);
-        assert(e.code() == std::regex_constants::error_collate);
-        assert(e.what() == std::string("The expression contained an invalid collating element name."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_ctype);
-        assert(e.code() == std::regex_constants::error_ctype);
-        assert(e.what() == std::string("The expression contained an invalid character class name."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_escape);
-        assert(e.code() == std::regex_constants::error_escape);
-        assert(e.what() == std::string("The expression contained an invalid escaped character, or a "
-               "trailing escape."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_backref);
-        assert(e.code() == std::regex_constants::error_backref);
-        assert(e.what() == std::string("The expression contained an invalid back reference."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_brack);
-        assert(e.code() == std::regex_constants::error_brack);
-        assert(e.what() == std::string("The expression contained mismatched [ and ]."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_paren);
-        assert(e.code() == std::regex_constants::error_paren);
-        assert(e.what() == std::string("The expression contained mismatched ( and )."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_brace);
-        assert(e.code() == std::regex_constants::error_brace);
-        assert(e.what() == std::string("The expression contained mismatched { and }."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_badbrace);
-        assert(e.code() == std::regex_constants::error_badbrace);
-        assert(e.what() == std::string("The expression contained an invalid range in a {} expression."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_range);
-        assert(e.code() == std::regex_constants::error_range);
-        assert(e.what() == std::string("The expression contained an invalid character range, "
-               "such as [b-a] in most encodings."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_space);
-        assert(e.code() == std::regex_constants::error_space);
-        assert(e.what() == std::string("There was insufficient memory to convert the expression into "
-               "a finite state machine."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_badrepeat);
-        assert(e.code() == std::regex_constants::error_badrepeat);
-        assert(e.what() == std::string("One of *?+{ was not preceded by a valid regular expression."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_complexity);
-        assert(e.code() == std::regex_constants::error_complexity);
-        assert(e.what() == std::string("The complexity of an attempted match against a regular "
-               "expression exceeded a pre-set level."));
-    }
-    {
-        std::regex_error e(std::regex_constants::error_stack);
-        assert(e.code() == std::regex_constants::error_stack);
-        assert(e.what() == std::string("There was insufficient memory to determine whether the regular "
-               "expression could match the specified character sequence."));
-    }
-}