Move test into test/std subdirectory.

llvm-svn: 224658

1 files changed, 96 insertions, 0 deletions

diff --git a/libcxx/test/std/re/re.badexp/regex_error.pass.cpp b/libcxx/test/std/re/re.badexp/regex_error.pass.cpp
new file mode 100644
index 00000000000..02fecbda2d9
--- /dev/null
+++ b/libcxx/test/std/re/re.badexp/regex_error.pass.cpp
@@ -0,0 +1,96 @@
+// -*- 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."));
+    }
+}