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.const/nothing_to_do.pass.cpp

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

test/std/re/re.const/re.err/error_type.pass.cpp

@@ -0,0 +1,143 @@
+// -*- 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>
+
+// namespace regex_constants
+// {
+//
+// enum error_type
+// {
+//     error_collate    = unspecified,
+//     error_ctype      = unspecified,
+//     error_escape     = unspecified,
+//     error_backref    = unspecified,
+//     error_brack      = unspecified,
+//     error_paren      = unspecified,
+//     error_brace      = unspecified,
+//     error_badbrace   = unspecified,
+//     error_range      = unspecified,
+//     error_space      = unspecified,
+//     error_badrepeat  = unspecified,
+//     error_complexity = unspecified,
+//     error_stack      = unspecified
+// };
+//
+// }
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    assert(std::regex_constants::error_collate != 0);
+    assert(std::regex_constants::error_ctype != 0);
+    assert(std::regex_constants::error_escape != 0);
+    assert(std::regex_constants::error_backref != 0);
+    assert(std::regex_constants::error_brack != 0);
+    assert(std::regex_constants::error_paren != 0);
+    assert(std::regex_constants::error_brace != 0);
+    assert(std::regex_constants::error_badbrace != 0);
+    assert(std::regex_constants::error_range != 0);
+    assert(std::regex_constants::error_space != 0);
+    assert(std::regex_constants::error_badrepeat != 0);
+    assert(std::regex_constants::error_complexity != 0);
+    assert(std::regex_constants::error_stack != 0);
+
+    assert(std::regex_constants::error_collate != std::regex_constants::error_ctype);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_escape);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_backref);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_brack);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_paren);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_brace);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_badbrace);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_range);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_space);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_badrepeat);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_collate != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_escape);
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_backref);
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_brack);
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_paren);
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_brace);
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_badbrace);
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_range);
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_space);
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_badrepeat);
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_ctype != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_escape != std::regex_constants::error_backref);
+    assert(std::regex_constants::error_escape != std::regex_constants::error_brack);
+    assert(std::regex_constants::error_escape != std::regex_constants::error_paren);
+    assert(std::regex_constants::error_escape != std::regex_constants::error_brace);
+    assert(std::regex_constants::error_escape != std::regex_constants::error_badbrace);
+    assert(std::regex_constants::error_escape != std::regex_constants::error_range);
+    assert(std::regex_constants::error_escape != std::regex_constants::error_space);
+    assert(std::regex_constants::error_escape != std::regex_constants::error_badrepeat);
+    assert(std::regex_constants::error_escape != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_escape != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_backref != std::regex_constants::error_brack);
+    assert(std::regex_constants::error_backref != std::regex_constants::error_paren);
+    assert(std::regex_constants::error_backref != std::regex_constants::error_brace);
+    assert(std::regex_constants::error_backref != std::regex_constants::error_badbrace);
+    assert(std::regex_constants::error_backref != std::regex_constants::error_range);
+    assert(std::regex_constants::error_backref != std::regex_constants::error_space);
+    assert(std::regex_constants::error_backref != std::regex_constants::error_badrepeat);
+    assert(std::regex_constants::error_backref != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_backref != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_brack != std::regex_constants::error_paren);
+    assert(std::regex_constants::error_brack != std::regex_constants::error_brace);
+    assert(std::regex_constants::error_brack != std::regex_constants::error_badbrace);
+    assert(std::regex_constants::error_brack != std::regex_constants::error_range);
+    assert(std::regex_constants::error_brack != std::regex_constants::error_space);
+    assert(std::regex_constants::error_brack != std::regex_constants::error_badrepeat);
+    assert(std::regex_constants::error_brack != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_brack != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_paren != std::regex_constants::error_brace);
+    assert(std::regex_constants::error_paren != std::regex_constants::error_badbrace);
+    assert(std::regex_constants::error_paren != std::regex_constants::error_range);
+    assert(std::regex_constants::error_paren != std::regex_constants::error_space);
+    assert(std::regex_constants::error_paren != std::regex_constants::error_badrepeat);
+    assert(std::regex_constants::error_paren != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_paren != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_brace != std::regex_constants::error_badbrace);
+    assert(std::regex_constants::error_brace != std::regex_constants::error_range);
+    assert(std::regex_constants::error_brace != std::regex_constants::error_space);
+    assert(std::regex_constants::error_brace != std::regex_constants::error_badrepeat);
+    assert(std::regex_constants::error_brace != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_brace != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_badbrace != std::regex_constants::error_range);
+    assert(std::regex_constants::error_badbrace != std::regex_constants::error_space);
+    assert(std::regex_constants::error_badbrace != std::regex_constants::error_badrepeat);
+    assert(std::regex_constants::error_badbrace != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_badbrace != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_range != std::regex_constants::error_space);
+    assert(std::regex_constants::error_range != std::regex_constants::error_badrepeat);
+    assert(std::regex_constants::error_range != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_range != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_space != std::regex_constants::error_badrepeat);
+    assert(std::regex_constants::error_space != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_space != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_badrepeat != std::regex_constants::error_complexity);
+    assert(std::regex_constants::error_badrepeat != std::regex_constants::error_stack);
+
+    assert(std::regex_constants::error_complexity != std::regex_constants::error_stack);
+}

test/std/re/re.const/re.matchflag/match_flag_type.pass.cpp

@@ -0,0 +1,128 @@
+// -*- 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>
+
+// namespace regex_constants
+// {
+//
+// emum match_flag_type  // bitmask type
+// {
+//     match_default     = 0,
+//     match_not_bol     = unspecified,
+//     match_not_eol     = unspecified,
+//     match_not_bow     = unspecified,
+//     match_not_eow     = unspecified,
+//     match_any         = unspecified,
+//     match_not_null    = unspecified,
+//     match_continuous  = unspecified,
+//     match_prev_avail  = unspecified,
+//     format_default    = 0,
+//     format_sed        = unspecified,
+//     format_no_copy    = unspecified,
+//     format_first_only = unspecified
+// };
+//
+// }
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    assert(std::regex_constants::match_default == 0);
+    assert(std::regex_constants::match_not_bol != 0);
+    assert(std::regex_constants::match_not_eol != 0);
+    assert(std::regex_constants::match_not_bow != 0);
+    assert(std::regex_constants::match_not_eow != 0);
+    assert(std::regex_constants::match_any != 0);
+    assert(std::regex_constants::match_not_null != 0);
+    assert(std::regex_constants::match_continuous != 0);
+    assert(std::regex_constants::match_prev_avail != 0);
+    assert(std::regex_constants::format_default == 0);
+    assert(std::regex_constants::format_sed != 0);
+    assert(std::regex_constants::format_no_copy != 0);
+    assert(std::regex_constants::format_first_only != 0);
+
+    assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_eol) == 0);
+    assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_bow) == 0);
+    assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_eow) == 0);
+    assert((std::regex_constants::match_not_bol & std::regex_constants::match_any) == 0);
+    assert((std::regex_constants::match_not_bol & std::regex_constants::match_not_null) == 0);
+    assert((std::regex_constants::match_not_bol & std::regex_constants::match_continuous) == 0);
+    assert((std::regex_constants::match_not_bol & std::regex_constants::match_prev_avail) == 0);
+    assert((std::regex_constants::match_not_bol & std::regex_constants::format_sed) == 0);
+    assert((std::regex_constants::match_not_bol & std::regex_constants::format_no_copy) == 0);
+    assert((std::regex_constants::match_not_bol & std::regex_constants::format_first_only) == 0);
+
+    assert((std::regex_constants::match_not_eol & std::regex_constants::match_not_bow) == 0);
+    assert((std::regex_constants::match_not_eol & std::regex_constants::match_not_eow) == 0);
+    assert((std::regex_constants::match_not_eol & std::regex_constants::match_any) == 0);
+    assert((std::regex_constants::match_not_eol & std::regex_constants::match_not_null) == 0);
+    assert((std::regex_constants::match_not_eol & std::regex_constants::match_continuous) == 0);
+    assert((std::regex_constants::match_not_eol & std::regex_constants::match_prev_avail) == 0);
+    assert((std::regex_constants::match_not_eol & std::regex_constants::format_sed) == 0);
+    assert((std::regex_constants::match_not_eol & std::regex_constants::format_no_copy) == 0);
+    assert((std::regex_constants::match_not_eol & std::regex_constants::format_first_only) == 0);
+
+    assert((std::regex_constants::match_not_bow & std::regex_constants::match_not_eow) == 0);
+    assert((std::regex_constants::match_not_bow & std::regex_constants::match_any) == 0);
+    assert((std::regex_constants::match_not_bow & std::regex_constants::match_not_null) == 0);
+    assert((std::regex_constants::match_not_bow & std::regex_constants::match_continuous) == 0);
+    assert((std::regex_constants::match_not_bow & std::regex_constants::match_prev_avail) == 0);
+    assert((std::regex_constants::match_not_bow & std::regex_constants::format_sed) == 0);
+    assert((std::regex_constants::match_not_bow & std::regex_constants::format_no_copy) == 0);
+    assert((std::regex_constants::match_not_bow & std::regex_constants::format_first_only) == 0);
+
+    assert((std::regex_constants::match_not_eow & std::regex_constants::match_any) == 0);
+    assert((std::regex_constants::match_not_eow & std::regex_constants::match_not_null) == 0);
+    assert((std::regex_constants::match_not_eow & std::regex_constants::match_continuous) == 0);
+    assert((std::regex_constants::match_not_eow & std::regex_constants::match_prev_avail) == 0);
+    assert((std::regex_constants::match_not_eow & std::regex_constants::format_sed) == 0);
+    assert((std::regex_constants::match_not_eow & std::regex_constants::format_no_copy) == 0);
+    assert((std::regex_constants::match_not_eow & std::regex_constants::format_first_only) == 0);
+
+    assert((std::regex_constants::match_any & std::regex_constants::match_not_null) == 0);
+    assert((std::regex_constants::match_any & std::regex_constants::match_continuous) == 0);
+    assert((std::regex_constants::match_any & std::regex_constants::match_prev_avail) == 0);
+    assert((std::regex_constants::match_any & std::regex_constants::format_sed) == 0);
+    assert((std::regex_constants::match_any & std::regex_constants::format_no_copy) == 0);
+    assert((std::regex_constants::match_any & std::regex_constants::format_first_only) == 0);
+
+    assert((std::regex_constants::match_not_null & std::regex_constants::match_continuous) == 0);
+    assert((std::regex_constants::match_not_null & std::regex_constants::match_prev_avail) == 0);
+    assert((std::regex_constants::match_not_null & std::regex_constants::format_sed) == 0);
+    assert((std::regex_constants::match_not_null & std::regex_constants::format_no_copy) == 0);
+    assert((std::regex_constants::match_not_null & std::regex_constants::format_first_only) == 0);
+
+    assert((std::regex_constants::match_continuous & std::regex_constants::match_prev_avail) == 0);
+    assert((std::regex_constants::match_continuous & std::regex_constants::format_sed) == 0);
+    assert((std::regex_constants::match_continuous & std::regex_constants::format_no_copy) == 0);
+    assert((std::regex_constants::match_continuous & std::regex_constants::format_first_only) == 0);
+
+    assert((std::regex_constants::match_prev_avail & std::regex_constants::format_sed) == 0);
+    assert((std::regex_constants::match_prev_avail & std::regex_constants::format_no_copy) == 0);
+    assert((std::regex_constants::match_prev_avail & std::regex_constants::format_first_only) == 0);
+
+    assert((std::regex_constants::format_sed & std::regex_constants::format_no_copy) == 0);
+    assert((std::regex_constants::format_sed & std::regex_constants::format_first_only) == 0);
+
+    assert((std::regex_constants::format_no_copy & std::regex_constants::format_first_only) == 0);
+
+    std::regex_constants::match_flag_type e1 = std::regex_constants::match_not_bol;
+    std::regex_constants::match_flag_type e2 = std::regex_constants::match_not_eol;
+    e1 = ~e1;
+    e1 = e1 & e2;
+    e1 = e1 | e2;
+    e1 = e1 ^ e2;
+    e1 &= e2;
+    e1 |= e2;
+    e1 ^= e2;
+}

test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp

@@ -0,0 +1,114 @@
+// -*- 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>
+
+// namespace regex_constants
+// {
+//
+// emum syntax_option_type  // bitmask type
+// {
+//     icase      = unspecified,
+//     nosubs     = unspecified,
+//     optimize   = unspecified,
+//     collate    = unspecified,
+//     ECMAScript = unspecified,
+//     basic      = unspecified,
+//     extended   = unspecified,
+//     awk        = unspecified,
+//     grep       = unspecified,
+//     egrep      = unspecified
+// };
+//
+// }
+
+#include <regex>
+#include <cassert>
+
+int main()
+{
+    assert(std::regex_constants::icase != 0);
+    assert(std::regex_constants::nosubs != 0);
+    assert(std::regex_constants::optimize != 0);
+    assert(std::regex_constants::collate != 0);
+    assert(std::regex_constants::ECMAScript == 0);
+    assert(std::regex_constants::basic != 0);
+    assert(std::regex_constants::extended != 0);
+    assert(std::regex_constants::awk != 0);
+    assert(std::regex_constants::grep != 0);
+    assert(std::regex_constants::egrep != 0);
+
+    assert((std::regex_constants::icase & std::regex_constants::nosubs) == 0);
+    assert((std::regex_constants::icase & std::regex_constants::optimize) == 0);
+    assert((std::regex_constants::icase & std::regex_constants::collate) == 0);
+    assert((std::regex_constants::icase & std::regex_constants::ECMAScript) == 0);
+    assert((std::regex_constants::icase & std::regex_constants::basic) == 0);
+    assert((std::regex_constants::icase & std::regex_constants::extended) == 0);
+    assert((std::regex_constants::icase & std::regex_constants::awk) == 0);
+    assert((std::regex_constants::icase & std::regex_constants::grep) == 0);
+    assert((std::regex_constants::icase & std::regex_constants::egrep) == 0);
+
+    assert((std::regex_constants::nosubs & std::regex_constants::optimize) == 0);
+    assert((std::regex_constants::nosubs & std::regex_constants::collate) == 0);
+    assert((std::regex_constants::nosubs & std::regex_constants::ECMAScript) == 0);
+    assert((std::regex_constants::nosubs & std::regex_constants::basic) == 0);
+    assert((std::regex_constants::nosubs & std::regex_constants::extended) == 0);
+    assert((std::regex_constants::nosubs & std::regex_constants::awk) == 0);
+    assert((std::regex_constants::nosubs & std::regex_constants::grep) == 0);
+    assert((std::regex_constants::nosubs & std::regex_constants::egrep) == 0);
+
+    assert((std::regex_constants::optimize & std::regex_constants::collate) == 0);
+    assert((std::regex_constants::optimize & std::regex_constants::ECMAScript) == 0);
+    assert((std::regex_constants::optimize & std::regex_constants::basic) == 0);
+    assert((std::regex_constants::optimize & std::regex_constants::extended) == 0);
+    assert((std::regex_constants::optimize & std::regex_constants::awk) == 0);
+    assert((std::regex_constants::optimize & std::regex_constants::grep) == 0);
+    assert((std::regex_constants::optimize & std::regex_constants::egrep) == 0);
+
+    assert((std::regex_constants::collate & std::regex_constants::ECMAScript) == 0);
+    assert((std::regex_constants::collate & std::regex_constants::basic) == 0);
+    assert((std::regex_constants::collate & std::regex_constants::extended) == 0);
+    assert((std::regex_constants::collate & std::regex_constants::awk) == 0);
+    assert((std::regex_constants::collate & std::regex_constants::grep) == 0);
+    assert((std::regex_constants::collate & std::regex_constants::egrep) == 0);
+
+    assert((std::regex_constants::ECMAScript & std::regex_constants::basic) == 0);
+    assert((std::regex_constants::ECMAScript & std::regex_constants::extended) == 0);
+    assert((std::regex_constants::ECMAScript & std::regex_constants::awk) == 0);
+    assert((std::regex_constants::ECMAScript & std::regex_constants::grep) == 0);
+    assert((std::regex_constants::ECMAScript & std::regex_constants::egrep) == 0);
+
+    assert((std::regex_constants::basic & std::regex_constants::extended) == 0);
+    assert((std::regex_constants::basic & std::regex_constants::awk) == 0);
+    assert((std::regex_constants::basic & std::regex_constants::grep) == 0);
+    assert((std::regex_constants::basic & std::regex_constants::egrep) == 0);
+
+    assert((std::regex_constants::extended & std::regex_constants::awk) == 0);
+    assert((std::regex_constants::extended & std::regex_constants::grep) == 0);
+    assert((std::regex_constants::extended & std::regex_constants::egrep) == 0);
+
+    assert((std::regex_constants::awk & std::regex_constants::grep) == 0);
+    assert((std::regex_constants::awk & std::regex_constants::egrep) == 0);
+
+    assert((std::regex_constants::grep & std::regex_constants::egrep) == 0);
+
+    assert((std::regex_constants::icase | std::regex_constants::nosubs) != 0);
+    assert((std::regex_constants::icase ^ std::regex_constants::nosubs) != 0);
+
+    std::regex_constants::syntax_option_type e1 = std::regex_constants::icase;
+    std::regex_constants::syntax_option_type e2 = std::regex_constants::nosubs;
+    e1 = ~e1;
+    e1 = e1 & e2;
+    e1 = e1 | e2;
+    e1 = e1 ^ e2;
+    e1 &= e2;
+    e1 |= e2;
+    e1 ^= e2;
+}