src/third_party/libc++/trunk/test/localization/locale.categories/__scan_keyword.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // <locale>
  11
  12 // Not a portable test
  13
  14 // __scan_keyword
  15 // Scans [__b, __e) until a match is found in the basic_strings range
  16 //  [__kb, __ke) or until it can be shown that there is no match in [__kb, __ke).
  17 //  __b will be incremented (visibly), consuming CharT until a match is found
  18 //  or proved to not exist.  A keyword may be "", in which will match anything.
  19 //  If one keyword is a prefix of another, and the next CharT in the input
  20 //  might match another keyword, the algorithm will attempt to find the longest
  21 //  matching keyword.  If the longer matching keyword ends up not matching, then
  22 //  no keyword match is found.  If no keyword match is found, __ke is returned.
  23 //  Else an iterator pointing to the matching keyword is found.  If more than
  24 //  one keyword matches, an iterator to the first matching keyword is returned.
  25 //  If on exit __b == __e, eofbit is set in __err.  If __case_sensitive is false,
  26 //  __ct is used to force to lower case before comparing characters.
  27 //  Examples:
  28 //  Keywords:  "a", "abb"
  29 //  If the input is "a", the first keyword matches and eofbit is set.
  30 //  If the input is "abc", no match is found and "ab" are consumed.
  31 //
  32 // template <class _InputIterator, class _ForwardIterator, class _Ctype>
  33 // _ForwardIterator
  34 // __scan_keyword(_InputIterator& __b, _InputIterator __e,
  35 //                _ForwardIterator __kb, _ForwardIterator __ke,
  36 //                const _Ctype& __ct, ios_base::iostate& __err,
  37 //                bool __case_sensitive = true);
  38
  39 #include <locale>
  40 #include <cassert>
  41
  42 int main()
  43 {
  44     const std::ctype<char>& ct = std::use_facet<std::ctype<char> >(std::locale::classic());
  45     std::ios_base::iostate err = std::ios_base::goodbit;
  46     {
  47         const char input[] = "a";
  48         const char* in = input;
  49         std::string keys[] = {"a", "abb"};
  50         err = std::ios_base::goodbit;
  51         std::string* k = std::__scan_keyword(in, input+sizeof(input)-1,
  52                                              keys, keys+sizeof(keys)/sizeof(keys[0]),
  53                                              ct, err);
  54         assert(k - keys == 0);
  55         assert(in == input+1);
  56         assert(err == std::ios_base::eofbit);
  57     }
  58     {
  59         const char input[] = "abc";
  60         const char* in = input;
  61         std::string keys[] = {"a", "abb"};
  62         err = std::ios_base::goodbit;
  63         std::string* k = std::__scan_keyword(in, input+sizeof(input)-1,
  64                                              keys, keys+sizeof(keys)/sizeof(keys[0]),
  65                                              ct, err);
  66         assert(k - keys == 2);
  67         assert(in == input+2);
  68         assert(err == std::ios_base::failbit);
  69     }
  70     {
  71         const char input[] = "abb";
  72         const char* in = input;
  73         std::string keys[] = {"a", "abb"};
  74         err = std::ios_base::goodbit;
  75         std::string* k = std::__scan_keyword(in, input+sizeof(input)-1,
  76                                              keys, keys+sizeof(keys)/sizeof(keys[0]),
  77                                              ct, err);
  78         assert(k - keys == 1);
  79         assert(in == input+3);
  80         assert(err == std::ios_base::eofbit);
  81     }
  82     {
  83         const char input[] = "Tue ";
  84         const char* in = input;
  85         std::string keys[] = {"Mon", "Monday", "Tue", "Tuesday"};
  86         err = std::ios_base::goodbit;
  87         std::string* k = std::__scan_keyword(in, input+sizeof(input)-1,
  88                                              keys, keys+sizeof(keys)/sizeof(keys[0]),
  89                                              ct, err);
  90         assert(k - keys == 2);
  91         assert(in == input+3);
  92         assert(err == std::ios_base::goodbit);
  93     }
  94     {
  95         const char input[] = "tue ";
  96         const char* in = input;
  97         std::string keys[] = {"Mon", "Monday", "Tue", "Tuesday"};
  98         err = std::ios_base::goodbit;
  99         std::string* k = std::__scan_keyword(in, input+sizeof(input)-1,
 100                                              keys, keys+sizeof(keys)/sizeof(keys[0]),
 101                                              ct, err);
 102         assert(k - keys == 4);
 103         assert(in == input+0);
 104         assert(err == std::ios_base::failbit);
 105     }
 106     {
 107         const char input[] = "tue ";
 108         const char* in = input;
 109         std::string keys[] = {"Mon", "Monday", "Tue", "Tuesday"};
 110         err = std::ios_base::goodbit;
 111         std::string* k = std::__scan_keyword(in, input+sizeof(input)-1,
 112                                              keys, keys+sizeof(keys)/sizeof(keys[0]),
 113                                              ct, err, false);
 114         assert(k - keys == 2);
 115         assert(in == input+3);
 116         assert(err == std::ios_base::goodbit);
 117     }
 118 }