Move test into test/std subdirectory.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@224658 91177308-0d34-0410-b5e6-96231b3b80d8

test/std/re/re.regex/re.regex.assign/assign.il.pass.cpp

@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex&
+//    assign(initializer_list<charT> il,
+//           flag_type f = regex_constants::ECMAScript);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    std::regex r2;
+    r2.assign({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'});
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+
+    r2.assign({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex::extended);
+    assert(r2.flags() == std::regex::extended);
+    assert(r2.mark_count() == 2);
+#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+}

test/std/re/re.regex/re.regex.assign/assign.pass.cpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex& assign(const basic_regex& that);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    std::regex r1("(a([bc]))");
+    std::regex r2;
+    r2.assign(r1);
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp

@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// template <class InputIterator>
+//    basic_regex&
+//    assign(InputIterator first, InputIterator last,
+//           flag_type f = regex_constants::ECMAScript);
+
+#include <regex>
+#include <cassert>
+
+#include "test_iterators.h"
+
+int main()
+{
+    typedef input_iterator<std::string::const_iterator> I;
+    typedef forward_iterator<std::string::const_iterator> F;
+    std::string s4("(a([bc]))");
+    std::regex r2;
+
+    r2.assign(I(s4.begin()), I(s4.end()));
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+
+    r2.assign(I(s4.begin()), I(s4.end()), std::regex::extended);
+    assert(r2.flags() == std::regex::extended);
+    assert(r2.mark_count() == 2);
+
+    r2.assign(F(s4.begin()), F(s4.end()));
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+
+    r2.assign(F(s4.begin()), F(s4.end()), std::regex::extended);
+    assert(r2.flags() == std::regex::extended);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/re.regex.assign/assign_ptr_flag.pass.cpp

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    std::regex r2;
+    r2.assign("(a([bc]))");
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+
+    r2.assign("(a([bc]))", std::regex::extended);
+    assert(r2.flags() == std::regex::extended);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/re.regex.assign/assign_ptr_size_flag.pass.cpp

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex& assign(const charT* ptr, size_t len, flag_type f);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    std::regex r2;
+    r2.assign("(a([bc]))", 9, std::regex::extended);
+    assert(r2.flags() == std::regex::extended);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/re.regex.assign/assign_string_flag.pass.cpp

@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// template <class string_traits, class A>
+//   basic_regex& assign(const basic_string<charT, string_traits, A>& s,
+//                       flag_type f = regex_constants::ECMAScript);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    std::regex r2;
+    r2.assign(std::string("(a([bc]))"));
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+
+    r2.assign(std::string("(a([bc]))"), std::regex::extended);
+    assert(r2.flags() == std::regex::extended);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/re.regex.assign/copy.pass.cpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex& operator=(const basic_regex& e);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    std::regex r1("(a([bc]))");
+    std::regex r2;
+    r2 = r1;
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/re.regex.assign/il.pass.cpp

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex& operator=(initializer_list<charT> il);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    std::regex r2;
+    r2 = {'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'};
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+}

test/std/re/re.regex/re.regex.assign/ptr.pass.cpp

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex& operator=(const charT* ptr);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    std::regex r2;
+    r2 = "(a([bc]))";
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/re.regex.assign/string.pass.cpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// template <class ST, class SA>
+//    basic_regex& operator=(const basic_string<charT, ST, SA>& p);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    std::regex r2;
+    r2 = std::string("(a([bc]))");
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/re.regex.const/constants.pass.cpp

@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>>
+// class basic_regex
+// {
+// public:
+//     // constants:
+//     static constexpr regex_constants::syntax_option_type icase = regex_constants::icase;
+//     static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
+//     static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize;
+//     static constexpr regex_constants::syntax_option_type collate = regex_constants::collate;
+//     static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
+//     static constexpr regex_constants::syntax_option_type basic = regex_constants::basic;
+//     static constexpr regex_constants::syntax_option_type extended = regex_constants::extended;
+//     static constexpr regex_constants::syntax_option_type awk = regex_constants::awk;
+//     static constexpr regex_constants::syntax_option_type grep = regex_constants::grep;
+//     static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep;
+
+#include <regex>
+#include <type_traits>
+
+template <class _Tp>
+void where(const _Tp &) {}
+
+template <class CharT>
+void
+test()
+{
+    typedef std::basic_regex<CharT> BR;
+    static_assert((BR::icase == std::regex_constants::icase), "");
+    static_assert((BR::nosubs == std::regex_constants::nosubs), "");
+    static_assert((BR::optimize == std::regex_constants::optimize), "");
+    static_assert((BR::collate == std::regex_constants::collate), "");
+    static_assert((BR::ECMAScript == std::regex_constants::ECMAScript), "");
+    static_assert((BR::basic == std::regex_constants::basic), "");
+    static_assert((BR::extended == std::regex_constants::extended), "");
+    static_assert((BR::awk == std::regex_constants::awk), "");
+    static_assert((BR::grep == std::regex_constants::grep), "");
+    static_assert((BR::egrep == std::regex_constants::egrep), "");
+    where(BR::icase);
+    where(BR::nosubs);
+    where(BR::optimize);
+    where(BR::collate);
+    where(BR::ECMAScript);
+    where(BR::basic);
+    where(BR::extended);
+    where(BR::awk);
+    where(BR::grep);
+    where(BR::egrep);
+}
+
+int main()
+{
+    test<char>();
+    test<wchar_t>();
+}

test/std/re/re.regex/re.regex.construct/awk_oct.pass.cpp

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// template <class ST, class SA>
+//    basic_regex(const basic_string<charT, ST, SA>& s);
+
+#include <regex>
+#include <cassert>
+
+int main() 
+{
+    using std::regex_constants::awk;
+
+    assert(std::regex_match("\4", std::regex("\\4", awk)));
+    assert(std::regex_match("\41", std::regex("\\41", awk)));
+    assert(std::regex_match("\141", std::regex("\\141", awk)));
+    assert(std::regex_match("\1411", std::regex("\\1411", awk)));
+}

test/std/re/re.regex/re.regex.construct/bad_escape.pass.cpp

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// template <class ST, class SA>
+//    basic_regex(const basic_string<charT, ST, SA>& s);
+
+#include <regex>
+#include <cassert>
+
+static bool error_escape_thrown(const char *pat) 
+{
+    bool result = false;
+    try {
+        std::regex re(pat);
+    } catch (std::regex_error &ex) {
+        result = (ex.code() == std::regex_constants::error_escape);
+    }
+    return result;
+}
+
+int main() 
+{
+    assert(error_escape_thrown("[\\a]"));
+    assert(error_escape_thrown("\\a"));
+
+    assert(error_escape_thrown("[\\e]"));
+    assert(error_escape_thrown("\\e"));
+
+    assert(error_escape_thrown("[\\c:]"));
+    assert(error_escape_thrown("\\c:"));
+    assert(error_escape_thrown("\\c"));
+    assert(!error_escape_thrown("[\\cA]"));
+    assert(!error_escape_thrown("\\cA"));
+
+}

test/std/re/re.regex/re.regex.construct/copy.pass.cpp

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex(const basic_regex& e);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    std::regex r1("(a([bc]))");
+    std::regex r2 = r1;
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/re.regex.construct/default.pass.cpp

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex();
+
+#include <regex>
+#include <cassert>
+
+template <class CharT>
+void
+test()
+{
+    std::basic_regex<CharT> r;
+    assert(r.flags() == 0);
+    assert(r.mark_count() == 0);
+}
+
+int main()
+{
+    test<char>();
+    test<wchar_t>();
+}

test/std/re/re.regex/re.regex.construct/il_flg.pass.cpp

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex(initializer_list<charT> il,
+//             flag_type f = regex_constants::ECMAScript);
+
+#include <regex>
+#include <cassert>
+
+#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+
+void
+test(std::initializer_list<char> il, std::regex_constants::syntax_option_type f, unsigned mc)
+{
+    std::basic_regex<char> r(il, f);
+    assert(r.flags() == f);
+    assert(r.mark_count() == mc);
+}
+
+#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+
+int main()
+{
+#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+    std::string s1("\\(a\\)");
+    std::string s2("\\(a[bc]\\)");
+    std::string s3("\\(a\\([bc]\\)\\)");
+    std::string s4("(a([bc]))");
+
+    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::basic, 1);
+    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::basic, 1);
+    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::basic, 2);
+    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::basic, 0);
+
+    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::extended, 0);
+    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::extended, 0);
+    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::extended, 0);
+    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::extended, 2);
+
+    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::ECMAScript, 0);
+    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::ECMAScript, 0);
+    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::ECMAScript, 0);
+    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::ECMAScript, 2);
+
+    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::awk, 0);
+    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::awk, 0);
+    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::awk, 0);
+    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::awk, 2);
+
+    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::grep, 1);
+    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::grep, 1);
+    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::grep, 2);
+    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::grep, 0);
+
+    test({'\\', '(', 'a', '\\', ')'}, std::regex_constants::egrep, 0);
+    test({'\\', '(', 'a', '[', 'b', 'c', ']', '\\', ')'}, std::regex_constants::egrep, 0);
+    test({'\\', '(', 'a', '\\', '(', '[', 'b', 'c', ']', '\\', ')', '\\', ')'}, std::regex_constants::egrep, 0);
+    test({'(', 'a', '(', '[', 'b', 'c', ']', ')', ')'}, std::regex_constants::egrep, 2);
+#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+}

test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp

@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// template <class ForwardIterator>
+//    basic_regex(ForwardIterator first, ForwardIterator last);
+
+#include <regex>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter>
+void
+test(Iter first, Iter last, unsigned mc)
+{
+    std::basic_regex<typename std::iterator_traits<Iter>::value_type> r(first, last);
+    assert(r.flags() == std::regex_constants::ECMAScript);
+    assert(r.mark_count() == mc);
+}
+
+int main()
+{
+    typedef forward_iterator<std::string::const_iterator> F;
+    std::string s1("\\(a\\)");
+    std::string s2("\\(a[bc]\\)");
+    std::string s3("\\(a\\([bc]\\)\\)");
+    std::string s4("(a([bc]))");
+
+    test(F(s1.begin()), F(s1.end()), 0);
+    test(F(s2.begin()), F(s2.end()), 0);
+    test(F(s3.begin()), F(s3.end()), 0);
+    test(F(s4.begin()), F(s4.end()), 2);
+}

test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp

@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// template <class ForwardIterator>
+//    basic_regex(ForwardIterator first, ForwardIterator last,
+//                flag_type f = regex_constants::ECMAScript);
+
+#include <regex>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter>
+void
+test(Iter first, Iter last, std::regex_constants::syntax_option_type f, unsigned mc)
+{
+    std::basic_regex<typename std::iterator_traits<Iter>::value_type> r(first, last, f);
+    assert(r.flags() == f);
+    assert(r.mark_count() == mc);
+}
+
+int main()
+{
+    typedef forward_iterator<std::string::const_iterator> F;
+    std::string s1("\\(a\\)");
+    std::string s2("\\(a[bc]\\)");
+    std::string s3("\\(a\\([bc]\\)\\)");
+    std::string s4("(a([bc]))");
+
+    test(F(s1.begin()), F(s1.end()), std::regex_constants::basic, 1);
+    test(F(s2.begin()), F(s2.end()), std::regex_constants::basic, 1);
+    test(F(s3.begin()), F(s3.end()), std::regex_constants::basic, 2);
+    test(F(s4.begin()), F(s4.end()), std::regex_constants::basic, 0);
+
+    test(F(s1.begin()), F(s1.end()), std::regex_constants::extended, 0);
+    test(F(s2.begin()), F(s2.end()), std::regex_constants::extended, 0);
+    test(F(s3.begin()), F(s3.end()), std::regex_constants::extended, 0);
+    test(F(s4.begin()), F(s4.end()), std::regex_constants::extended, 2);
+
+    test(F(s1.begin()), F(s1.end()), std::regex_constants::ECMAScript, 0);
+    test(F(s2.begin()), F(s2.end()), std::regex_constants::ECMAScript, 0);
+    test(F(s3.begin()), F(s3.end()), std::regex_constants::ECMAScript, 0);
+    test(F(s4.begin()), F(s4.end()), std::regex_constants::ECMAScript, 2);
+
+    test(F(s1.begin()), F(s1.end()), std::regex_constants::awk, 0);
+    test(F(s2.begin()), F(s2.end()), std::regex_constants::awk, 0);
+    test(F(s3.begin()), F(s3.end()), std::regex_constants::awk, 0);
+    test(F(s4.begin()), F(s4.end()), std::regex_constants::awk, 2);
+
+    test(F(s1.begin()), F(s1.end()), std::regex_constants::grep, 1);
+    test(F(s2.begin()), F(s2.end()), std::regex_constants::grep, 1);
+    test(F(s3.begin()), F(s3.end()), std::regex_constants::grep, 2);
+    test(F(s4.begin()), F(s4.end()), std::regex_constants::grep, 0);
+
+    test(F(s1.begin()), F(s1.end()), std::regex_constants::egrep, 0);
+    test(F(s2.begin()), F(s2.end()), std::regex_constants::egrep, 0);
+    test(F(s3.begin()), F(s3.end()), std::regex_constants::egrep, 0);
+    test(F(s4.begin()), F(s4.end()), std::regex_constants::egrep, 2);
+}

test/std/re/re.regex/re.regex.construct/ptr.pass.cpp

@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex(const charT* p);
+
+#include <regex>
+#include <cassert>
+
+template <class CharT>
+void
+test(const CharT* p, unsigned mc)
+{
+    std::basic_regex<CharT> r(p);
+    assert(r.flags() == std::regex_constants::ECMAScript);
+    assert(r.mark_count() == mc);
+}
+
+int main()
+{
+    test("\\(a\\)", 0);
+    test("\\(a[bc]\\)", 0);
+    test("\\(a\\([bc]\\)\\)", 0);
+    test("(a([bc]))", 2);
+}

test/std/re/re.regex/re.regex.construct/ptr_flg.pass.cpp

@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
+
+#include <regex>
+#include <cassert>
+
+template <class CharT>
+void
+test(const CharT* p, std::regex_constants::syntax_option_type f, unsigned mc)
+{
+    std::basic_regex<CharT> r(p, f);
+    assert(r.flags() == f);
+    assert(r.mark_count() == mc);
+}
+
+int main()
+{
+    test("\\(a\\)", std::regex_constants::basic, 1);
+    test("\\(a[bc]\\)", std::regex_constants::basic, 1);
+    test("\\(a\\([bc]\\)\\)", std::regex_constants::basic, 2);
+    test("(a([bc]))", std::regex_constants::basic, 0);
+
+    test("\\(a\\)", std::regex_constants::extended, 0);
+    test("\\(a[bc]\\)", std::regex_constants::extended, 0);
+    test("\\(a\\([bc]\\)\\)", std::regex_constants::extended, 0);
+    test("(a([bc]))", std::regex_constants::extended, 2);
+
+    test("\\(a\\)", std::regex_constants::ECMAScript, 0);
+    test("\\(a[bc]\\)", std::regex_constants::ECMAScript, 0);
+    test("\\(a\\([bc]\\)\\)", std::regex_constants::ECMAScript, 0);
+    test("(a([bc]))", std::regex_constants::ECMAScript, 2);
+
+    test("\\(a\\)", std::regex_constants::awk, 0);
+    test("\\(a[bc]\\)", std::regex_constants::awk, 0);
+    test("\\(a\\([bc]\\)\\)", std::regex_constants::awk, 0);
+    test("(a([bc]))", std::regex_constants::awk, 2);
+
+    test("\\(a\\)", std::regex_constants::grep, 1);
+    test("\\(a[bc]\\)", std::regex_constants::grep, 1);
+    test("\\(a\\([bc]\\)\\)", std::regex_constants::grep, 2);
+    test("(a([bc]))", std::regex_constants::grep, 0);
+
+    test("\\(a\\)", std::regex_constants::egrep, 0);
+    test("\\(a[bc]\\)", std::regex_constants::egrep, 0);
+    test("\\(a\\([bc]\\)\\)", std::regex_constants::egrep, 0);
+    test("(a([bc]))", std::regex_constants::egrep, 2);
+}

test/std/re/re.regex/re.regex.construct/ptr_size_flg.pass.cpp

@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// basic_regex(const charT* p, size_t len, flag_type f);
+
+#include <regex>
+#include <cassert>
+
+template <class CharT>
+void
+test(const CharT* p, std::size_t len, std::regex_constants::syntax_option_type f,
+     unsigned mc)
+{
+    std::basic_regex<CharT> r(p, len, f);
+    assert(r.flags() == f);
+    assert(r.mark_count() == mc);
+}
+
+int main()
+{
+    test("\\(a\\)", 5, std::regex_constants::basic, 1);
+    test("\\(a[bc]\\)", 9, std::regex_constants::basic, 1);
+    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::basic, 2);
+    test("(a([bc]))", 9, std::regex_constants::basic, 0);
+
+    test("\\(a\\)", 5, std::regex_constants::extended, 0);
+    test("\\(a[bc]\\)", 9, std::regex_constants::extended, 0);
+    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::extended, 0);
+    test("(a([bc]))", 9, std::regex_constants::extended, 2);
+
+    test("\\(a\\)", 5, std::regex_constants::ECMAScript, 0);
+    test("\\(a[bc]\\)", 9, std::regex_constants::ECMAScript, 0);
+    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::ECMAScript, 0);
+    test("(a([bc]))", 9, std::regex_constants::ECMAScript, 2);
+
+    test("\\(a\\)", 5, std::regex_constants::awk, 0);
+    test("\\(a[bc]\\)", 9, std::regex_constants::awk, 0);
+    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::awk, 0);
+    test("(a([bc]))", 9, std::regex_constants::awk, 2);
+
+    test("\\(a\\)", 5, std::regex_constants::grep, 1);
+    test("\\(a[bc]\\)", 9, std::regex_constants::grep, 1);
+    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::grep, 2);
+    test("(a([bc]))", 9, std::regex_constants::grep, 0);
+
+    test("\\(a\\)", 5, std::regex_constants::egrep, 0);
+    test("\\(a[bc]\\)", 9, std::regex_constants::egrep, 0);
+    test("\\(a\\([bc]\\)\\)", 13, std::regex_constants::egrep, 0);
+    test("(a([bc]))", 9, std::regex_constants::egrep, 2);
+}

test/std/re/re.regex/re.regex.construct/string.pass.cpp

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// template <class ST, class SA>
+//    basic_regex(const basic_string<charT, ST, SA>& s);
+
+#include <regex>
+#include <cassert>
+
+template <class String>
+void
+test(const String& p, unsigned mc)
+{
+    std::basic_regex<typename String::value_type> r(p);
+    assert(r.flags() == std::regex_constants::ECMAScript);
+    assert(r.mark_count() == mc);
+}
+
+int main()
+{
+    test(std::string("\\(a\\)"), 0);
+    test(std::string("\\(a[bc]\\)"), 0);
+    test(std::string("\\(a\\([bc]\\)\\)"), 0);
+    test(std::string("(a([bc]))"), 2);
+}

test/std/re/re.regex/re.regex.construct/string_flg.pass.cpp

@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// template <class ST, class SA>
+//    basic_regex(const basic_string<charT, ST, SA>& s,
+//                flag_type f = regex_constants::ECMAScript);
+
+#include <regex>
+#include <cassert>
+
+template <class String>
+void
+test(const String& p, std::regex_constants::syntax_option_type f, unsigned mc)
+{
+    std::basic_regex<typename String::value_type> r(p, f);
+    assert(r.flags() == f);
+    assert(r.mark_count() == mc);
+}
+
+int main()
+{
+    test(std::string("\\(a\\)"), std::regex_constants::basic, 1);
+    test(std::string("\\(a[bc]\\)"), std::regex_constants::basic, 1);
+    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::basic, 2);
+    test(std::string("(a([bc]))"), std::regex_constants::basic, 0);
+
+    test(std::string("\\(a\\)"), std::regex_constants::extended, 0);
+    test(std::string("\\(a[bc]\\)"), std::regex_constants::extended, 0);
+    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::extended, 0);
+    test(std::string("(a([bc]))"), std::regex_constants::extended, 2);
+
+    test(std::string("\\(a\\)"), std::regex_constants::ECMAScript, 0);
+    test(std::string("\\(a[bc]\\)"), std::regex_constants::ECMAScript, 0);
+    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::ECMAScript, 0);
+    test(std::string("(a([bc]))"), std::regex_constants::ECMAScript, 2);
+
+    test(std::string("\\(a\\)"), std::regex_constants::awk, 0);
+    test(std::string("\\(a[bc]\\)"), std::regex_constants::awk, 0);
+    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::awk, 0);
+    test(std::string("(a([bc]))"), std::regex_constants::awk, 2);
+
+    test(std::string("\\(a\\)"), std::regex_constants::grep, 1);
+    test(std::string("\\(a[bc]\\)"), std::regex_constants::grep, 1);
+    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::grep, 2);
+    test(std::string("(a([bc]))"), std::regex_constants::grep, 0);
+
+    test(std::string("\\(a\\)"), std::regex_constants::egrep, 0);
+    test(std::string("\\(a[bc]\\)"), std::regex_constants::egrep, 0);
+    test(std::string("\\(a\\([bc]\\)\\)"), std::regex_constants::egrep, 0);
+    test(std::string("(a([bc]))"), std::regex_constants::egrep, 2);
+}

test/std/re/re.regex/re.regex.locale/imbue.pass.cpp

@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// locale_type imbue(locale_type loc);
+
+#include <regex>
+#include <locale>
+#include <cassert>
+
+#include "platform_support.h" // locale name macros
+
+int main()
+{
+    std::regex r;
+    std::locale loc = r.imbue(std::locale(LOCALE_en_US_UTF_8));
+    assert(loc.name() == "C");
+    assert(r.getloc().name() == LOCALE_en_US_UTF_8);
+    loc = r.imbue(std::locale("C"));
+    assert(loc.name() == LOCALE_en_US_UTF_8);
+    assert(r.getloc().name() == "C");
+}

test/std/re/re.regex/re.regex.nonmemb/nothing_to_do.pass.cpp

@@ -0,0 +1,12 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+int main()
+{
+}

test/std/re/re.regex/re.regex.nonmemb/re.regex.nmswap/swap.pass.cpp

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// template <class charT, class traits>
+//   void swap(basic_regex<charT, traits>& lhs, basic_regex<charT, traits>& rhs);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    std::regex r1("(a([bc]))");
+    std::regex r2;
+    swap(r2, r1);
+    assert(r1.flags() == std::regex::ECMAScript);
+    assert(r1.mark_count() == 0);
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/re.regex.operations/tested_elsewhere.pass.cpp

@@ -0,0 +1,12 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+int main()
+{
+}

test/std/re/re.regex/re.regex.swap/swap.pass.cpp

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>> class basic_regex;
+
+// void swap(basic_regex& e);
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    std::regex r1("(a([bc]))");
+    std::regex r2;
+    r2.swap(r1);
+    assert(r1.flags() == std::regex::ECMAScript);
+    assert(r1.mark_count() == 0);
+    assert(r2.flags() == std::regex::ECMAScript);
+    assert(r2.mark_count() == 2);
+}

test/std/re/re.regex/types.pass.cpp

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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>
+
+// template <class charT, class traits = regex_traits<charT>>
+// class basic_regex
+// {
+// public:
+//     // types:
+//     typedef charT                               value_type;
+//     typedef regex_constants::syntax_option_type flag_type;
+//     typedef typename traits::locale_type        locale_type;
+
+#include <regex>
+#include <type_traits>
+
+int main()
+{
+    static_assert((std::is_same<std::basic_regex<char>::value_type, char>::value), "");
+    static_assert((std::is_same<std::basic_regex<char>::flag_type,
+                                std::regex_constants::syntax_option_type>::value), "");
+    static_assert((std::is_same<std::basic_regex<char>::locale_type, std::locale>::value), "");
+
+    static_assert((std::is_same<std::basic_regex<wchar_t>::value_type, wchar_t>::value), "");
+    static_assert((std::is_same<std::basic_regex<wchar_t>::flag_type,
+                                std::regex_constants::syntax_option_type>::value), "");
+    static_assert((std::is_same<std::basic_regex<wchar_t>::locale_type, std::locale>::value), "");
+}