libcxx/test/std/re/re.regex/re.regex.construct/deduct.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // <regex>
  10 // UNSUPPORTED: c++03, c++11, c++14
  11 // UNSUPPORTED: libcpp-no-deduction-guides
  12
  13
  14 // template<class ForwardIterator>
  15 // basic_regex(ForwardIterator, ForwardIterator,
  16 //             regex_constants::syntax_option_type = regex_constants::ECMAScript)
  17 // -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>;
  18
  19
  20 #include <regex>
  21 #include <string>
  22 #include <iterator>
  23 #include <cassert>
  24 #include <cstddef>
  25
  26 #include "test_macros.h"
  27 #include "test_iterators.h"
  28 #include "test_allocator.h"
  29
  30 using namespace std::literals;
  31
  32 struct A {};
  33
  34 int main(int, char**)
  35 {
  36
  37 //  Test the explicit deduction guides
  38     {
  39 //  basic_regex(ForwardIterator, ForwardIterator)
  40     std::string s1("\\(a\\)");
  41     std::basic_regex re(s1.begin(), s1.end());
  42
  43     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
  44     assert(re.flags() == std::regex_constants::ECMAScript);
  45     assert(re.mark_count() == 0);
  46     }
  47
  48     {
  49     std::wstring s1(L"\\(a\\)");
  50     std::basic_regex re(s1.begin(), s1.end(), std::regex_constants::basic);
  51
  52     static_assert(std::is_same_v<decltype(re), std::basic_regex<wchar_t>>, "");
  53     assert(re.flags() == std::regex_constants::basic);
  54     assert(re.mark_count() == 1);
  55     }
  56
  57 //  Test the implicit deduction guides
  58     {
  59 //  basic_regex(string);
  60     std::basic_regex re("(a([bc]))"s);
  61     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
  62     assert(re.flags() == std::regex_constants::ECMAScript);
  63     assert(re.mark_count() == 2);
  64     }
  65
  66     {
  67 //  basic_regex(string, flag_type);
  68     std::basic_regex re(L"(a([bc]))"s, std::regex_constants::awk);
  69     static_assert(std::is_same_v<decltype(re), std::basic_regex<wchar_t>>, "");
  70     assert(re.flags() == std::regex_constants::awk);
  71     assert(re.mark_count() == 2);
  72     }
  73
  74     {
  75 //  basic_regex(const charT*);
  76     std::basic_regex re("ABCDE");
  77     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
  78     assert(re.flags() == std::regex_constants::ECMAScript);
  79     assert(re.mark_count() == 0);
  80     }
  81
  82     {
  83 //  basic_regex(const charT*, flag_type);
  84     std::basic_regex re(L"ABCDE", std::regex_constants::grep);
  85     static_assert(std::is_same_v<decltype(re), std::basic_regex<wchar_t>>, "");
  86     assert(re.flags() == std::regex_constants::grep);
  87     assert(re.mark_count() == 0);
  88     }
  89
  90     {
  91 //  basic_regex(const charT*, size_t);
  92     std::basic_regex re("ABCDEDEF", 7);
  93     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
  94     assert(re.flags() == std::regex_constants::ECMAScript);
  95     assert(re.mark_count() == 0);
  96     }
  97
  98     {
  99 //  basic_regex(const charT*, size_t, flag_type);
 100     std::basic_regex re(L"ABCDEDEF", 8, std::regex_constants::awk);
 101     static_assert(std::is_same_v<decltype(re), std::basic_regex<wchar_t>>, "");
 102     assert(re.flags() == std::regex_constants::awk);
 103     assert(re.mark_count() == 0);
 104     }
 105
 106     {
 107 //  basic_regex(const basic_regex &);
 108     std::basic_regex<char> source;
 109     std::basic_regex re(source);
 110     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
 111     assert(re.flags() == source.flags());
 112     assert(re.mark_count() == source.mark_count());
 113     }
 114
 115     {
 116 //  template<class ST, class SA>
 117 //         explicit basic_regex(const basic_string<charT, ST, SA>& p,
 118 //                              flag_type f = regex_constants::ECMAScript);
 119     }
 120
 121     {
 122 //  basic_regex(initializer_list);
 123     std::basic_regex re({'A', 'B', 'F', 'E', 'D'});
 124     static_assert(std::is_same_v<decltype(re), std::basic_regex<char>>, "");
 125     assert(re.flags() == std::regex_constants::ECMAScript);
 126     assert(re.mark_count() == 0);
 127     }
 128
 129     {
 130 //  basic_regex(initializer_list, flag_type);
 131     std::basic_regex re({L'A', L'B', L'F', L'E', L'D'}, std::regex_constants::grep);
 132     static_assert(std::is_same_v<decltype(re), std::basic_regex<wchar_t>>, "");
 133     assert(re.flags() == std::regex_constants::grep);
 134     assert(re.mark_count() == 0);
 135     }
 136
 137   return 0;
 138 }