ceph/src/boost/libs/spirit/classic/test/escape_char_parser_tests.cpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2003 Daniel Nuffer
   3     Copyright (c) 2001-2003 Hartmut Kaiser
   4     http://spirit.sourceforge.net/
   5
   6     Use, modification and distribution is subject to the Boost Software
   7     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   8     http://www.boost.org/LICENSE_1_0.txt)
   9 =============================================================================*/
  10 #include <boost/spirit/include/classic_core.hpp>
  11 #include <boost/spirit/include/classic_assign_actor.hpp>
  12 #include <boost/spirit/include/classic_escape_char.hpp>
  13
  14 #include <iostream>
  15 #include <boost/core/ignore_unused.hpp>
  16 #include <boost/detail/lightweight_test.hpp>
  17 #include <cstdio>       // for sprintf
  18
  19 #if !defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF)
  20 # include <cwchar>      // for swprintf
  21 #endif
  22
  23 ///////////////////////////////////////////////////////////////////////////////
  24 using namespace std;
  25 using namespace BOOST_SPIRIT_CLASSIC_NS;
  26
  27 ///////////////////////////////////////////////////////////////////////////////
  28 int
  29 main()
  30 {
  31     char c;
  32
  33     // testing good C escapes
  34     BOOST_TEST(parse("a", c_escape_ch_p[assign_a(c)]).full);
  35     BOOST_TEST(c == 'a');
  36     BOOST_TEST(parse("\\b", c_escape_ch_p[assign_a(c)]).full);
  37     BOOST_TEST(c == '\b');
  38     BOOST_TEST(parse("\\t", c_escape_ch_p[assign_a(c)]).full);
  39     BOOST_TEST(c == '\t');
  40     BOOST_TEST(parse("\\n", c_escape_ch_p[assign_a(c)]).full);
  41     BOOST_TEST(c == '\n');
  42     BOOST_TEST(parse("\\f", c_escape_ch_p[assign_a(c)]).full);
  43     BOOST_TEST(c == '\f');
  44     BOOST_TEST(parse("\\r", c_escape_ch_p[assign_a(c)]).full);
  45     BOOST_TEST(c == '\r');
  46     BOOST_TEST(parse("\\\"", c_escape_ch_p[assign_a(c)]).full);
  47     BOOST_TEST(c == '\"');
  48     BOOST_TEST(parse("\\'", c_escape_ch_p[assign_a(c)]).full);
  49     BOOST_TEST(c == '\'');
  50     BOOST_TEST(parse("\\\\", c_escape_ch_p[assign_a(c)]).full);
  51     BOOST_TEST(c == '\\');
  52     BOOST_TEST(parse("\\120", c_escape_ch_p[assign_a(c)]).full);
  53     BOOST_TEST(c == '\120');
  54     BOOST_TEST(parse("\\x2e", c_escape_ch_p[assign_a(c)]).full);
  55     BOOST_TEST(c == '\x2e');
  56
  57     // test bad C escapes
  58     BOOST_TEST(!parse("\\z", c_escape_ch_p[assign_a(c)]).hit);
  59
  60     // testing good lex escapes
  61     BOOST_TEST(parse("a", lex_escape_ch_p[assign_a(c)]).full);
  62     BOOST_TEST(c == 'a');
  63     BOOST_TEST(parse("\\b", lex_escape_ch_p[assign_a(c)]).full);
  64     BOOST_TEST(c == '\b');
  65     BOOST_TEST(parse("\\t", lex_escape_ch_p[assign_a(c)]).full);
  66     BOOST_TEST(c == '\t');
  67     BOOST_TEST(parse("\\n", lex_escape_ch_p[assign_a(c)]).full);
  68     BOOST_TEST(c == '\n');
  69     BOOST_TEST(parse("\\f", lex_escape_ch_p[assign_a(c)]).full);
  70     BOOST_TEST(c == '\f');
  71     BOOST_TEST(parse("\\r", lex_escape_ch_p[assign_a(c)]).full);
  72     BOOST_TEST(c == '\r');
  73     BOOST_TEST(parse("\\\"", lex_escape_ch_p[assign_a(c)]).full);
  74     BOOST_TEST(c == '\"');
  75     BOOST_TEST(parse("\\'", lex_escape_ch_p[assign_a(c)]).full);
  76     BOOST_TEST(c == '\'');
  77     BOOST_TEST(parse("\\\\", lex_escape_ch_p[assign_a(c)]).full);
  78     BOOST_TEST(c == '\\');
  79     BOOST_TEST(parse("\\120", lex_escape_ch_p[assign_a(c)]).full);
  80     BOOST_TEST(c == '\120');
  81     BOOST_TEST(parse("\\x2e", lex_escape_ch_p[assign_a(c)]).full);
  82     BOOST_TEST(c == '\x2e');
  83     BOOST_TEST(parse("\\z", lex_escape_ch_p[assign_a(c)]).full);
  84     BOOST_TEST(c == 'z');
  85     BOOST_TEST(parse("\\a", lex_escape_ch_p[assign_a(c)]).full);
  86     BOOST_TEST(c == 'a');
  87
  88     // test bad lex escapes
  89     BOOST_TEST(!parse("\\xz", lex_escape_ch_p[assign_a(c)]).hit);
  90
  91     // test out of range octal escape
  92     BOOST_TEST(!parse("\\777", lex_escape_ch_p[assign_a(c)]).hit);
  93
  94 #if CHAR_MAX == 127
  95     BOOST_TEST(!parse("\\200", lex_escape_ch_p[assign_a(c)]).hit);
  96
  97     BOOST_TEST(parse("\\177", lex_escape_ch_p[assign_a(c)]).full);
  98     BOOST_TEST(c == '\177');
  99 #elif CHAR_MAX == 255
 100     BOOST_TEST(!parse("\\400", lex_escape_ch_p[assign_a(c)]).hit);
 101
 102     BOOST_TEST(parse("\\377", lex_escape_ch_p[assign_a(c)]).full);
 103     BOOST_TEST(c == '\377');
 104 #endif
 105
 106     // test out of range hex escape
 107     BOOST_TEST(!parse("\\xFFF", lex_escape_ch_p[assign_a(c)]).hit);
 108
 109 #if CHAR_MAX == 127
 110     BOOST_TEST(!parse("\\X80", lex_escape_ch_p[assign_a(c)]).hit);
 111
 112     BOOST_TEST(parse("\\X7F", lex_escape_ch_p[assign_a(c)]).full);
 113     BOOST_TEST(c == '\x7f');
 114 #elif CHAR_MAX == 255
 115     BOOST_TEST(!parse("\\X100", lex_escape_ch_p[assign_a(c)]).hit);
 116
 117     BOOST_TEST(parse("\\XFf", lex_escape_ch_p[assign_a(c)]).full);
 118     BOOST_TEST(c == '\xff');
 119 #endif
 120
 121 #ifndef BOOST_NO_CWCHAR
 122
 123     // test wide chars
 124     typedef escape_char_parser<lex_escapes, wchar_t> wlep_t;
 125     wlep_t wlep = wlep_t();
 126
 127     typedef escape_char_parser<c_escapes, wchar_t> wcep_t;
 128     wcep_t wcep = wcep_t();
 129
 130     //wchar_t const* wstr = L"a\\b\\t\\n\\f\\r\\\"\\'\\\\\\120\\x2e";
 131     //wchar_t const* wend(wstr + wcslen(wstr));
 132
 133     wchar_t wc;
 134     BOOST_TEST(parse(L"a", wcep[assign_a(wc)]).hit);
 135     BOOST_TEST(wc == L'a');
 136     BOOST_TEST(parse(L"\\b", wcep[assign_a(wc)]).full);
 137     BOOST_TEST(wc == L'\b');
 138     BOOST_TEST(parse(L"\\t", wcep[assign_a(wc)]).full);
 139     BOOST_TEST(wc == L'\t');
 140     BOOST_TEST(parse(L"\\n", wcep[assign_a(wc)]).full);
 141     BOOST_TEST(wc == L'\n');
 142     BOOST_TEST(parse(L"\\f", wcep[assign_a(wc)]).full);
 143     BOOST_TEST(wc == L'\f');
 144     BOOST_TEST(parse(L"\\r", wcep[assign_a(wc)]).full);
 145     BOOST_TEST(wc == L'\r');
 146     BOOST_TEST(parse(L"\\\"", wcep[assign_a(wc)]).full);
 147     BOOST_TEST(wc == L'\"');
 148     BOOST_TEST(parse(L"\\'", wcep[assign_a(wc)]).full);
 149     BOOST_TEST(wc == L'\'');
 150     BOOST_TEST(parse(L"\\\\", wcep[assign_a(wc)]).full);
 151     BOOST_TEST(wc == L'\\');
 152     BOOST_TEST(parse(L"\\120", wcep[assign_a(wc)]).full);
 153     BOOST_TEST(wc == L'\120');
 154     BOOST_TEST(parse(L"\\x2e", wcep[assign_a(wc)]).full);
 155     BOOST_TEST(wc == L'\x2e');
 156
 157     // test bad wc escapes
 158     BOOST_TEST(!parse(L"\\z", wcep[assign_a(wc)]).hit);
 159
 160 #if !defined(BOOST_NO_SWPRINTF)
 161     unsigned long ulwcmax(WCHAR_MAX);
 162
 163     // test out of range octal escape
 164     size_t const octmax_size = 16;
 165     wchar_t octmax[octmax_size];
 166
 167     swprintf(octmax, octmax_size,
 168       L"\\%lo", (unsigned long)(std::numeric_limits<wchar_t>::max)());
 169     BOOST_TEST(parse(octmax, wlep[assign_a(wc)]).full);
 170     //BOOST_TEST(lex_escape_ch_p[assign_a(wc)].parse(str, end));
 171     BOOST_TEST(wc == (std::numeric_limits<wchar_t>::max)());
 172
 173     // WCHAR_MAX + 1
 174     swprintf(octmax, octmax_size,
 175       L"\\%lo%lo", ulwcmax / 8 + (ulwcmax % 8 == 7), (ulwcmax - 7) % 8);
 176     BOOST_TEST(!parse(octmax, wlep[assign_a(wc)]).hit);
 177
 178     // test out of range hex escape
 179     size_t const hexmax_size = 16;
 180     wchar_t hexmax[hexmax_size];
 181
 182     swprintf(hexmax, hexmax_size,
 183       L"\\x%lx", (unsigned long)(std::numeric_limits<wchar_t>::max)());
 184     BOOST_TEST(parse(hexmax, wlep[assign_a(wc)]).full);
 185     BOOST_TEST(wc == (std::numeric_limits<wchar_t>::max)());
 186
 187     // WCHAR_MAX + 1
 188     swprintf(hexmax, hexmax_size,
 189       L"\\x%lx%lx", ulwcmax / 16 + (ulwcmax % 16 == 15), (ulwcmax - 15) % 16);
 190     BOOST_TEST(!parse(hexmax, wlep[assign_a(wc)]).hit);
 191 #else
 192     boost::ignore_unused(wlep);
 193 #endif // !defined(BOOST_NO_SWPRINTF)
 194
 195 #endif
 196
 197     return boost::report_errors();
 198 }