tests/regex/regextest.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        tests/regex/regex.cpp
   3 // Purpose:     Test the built-in regex lib and wxRegEx
   4 // Author:      Mike Wetherell
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 2004 Mike Wetherell
   7 // Licence:     wxWidgets licence
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 //
  11 // Notes:
  12 //
  13 // To run just one section, say wx_1, do this:
  14 //  test regex.wx_1
  15 //
  16 // To run all the regex tests:
  17 //  test regex
  18 //
  19 // Some tests must be skipped since they use features which we do not make
  20 // available through wxRegEx. To see the list of tests that have been skipped
  21 // turn on verbose logging, e.g.:
  22 //  test --verbose regex
  23 //
  24 // The tests here are for the builtin library, tests for wxRegEx in general
  25 // should go in wxregex.cpp
  26 //
  27 // The tests are generated from Henry Spencer's reg.test, additional test
  28 // can be added in wxreg.test. These test files are then turned into a C++
  29 // include file 'regex.inc' (included below) using a script 'regex.pl'.
  30 //
  31
  32 // For compilers that support precompilation, includes "wx/wx.h".
  33 #include "testprec.h"
  34
  35 #ifdef __BORLANDC__
  36     #pragma hdrstop
  37 #endif
  38
  39 // for all others, include the necessary headers
  40 #ifndef WX_PRECOMP
  41     #include "wx/wx.h"
  42 #endif
  43
  44
  45 // many of the tests are specific to the builtin regex lib, so only attempts
  46 // to do them when using the builtin regex lib.
  47 //
  48 #ifdef wxHAS_REGEX_ADVANCED
  49
  50 #include "wx/regex.h"
  51 #include <string>
  52 #include <vector>
  53
  54 using CppUnit::Test;
  55 using CppUnit::TestCase;
  56 using CppUnit::TestSuite;
  57 using CppUnit::Exception;
  58
  59 using std::string;
  60 using std::vector;
  61
  62 ///////////////////////////////////////////////////////////////////////////////
  63 // The test case - an instance represents a single test
  64
  65 class RegExTestCase : public TestCase
  66 {
  67 public:
  68     // constructor - create a single testcase
  69     RegExTestCase(
  70         const string& name,
  71         const char *mode,
  72         const char *id,
  73         const char *flags,
  74         const char *pattern,
  75         const char *data,
  76         const vector<const char *>& expected);
  77
  78 protected:
  79     // run this testcase
  80     void runTest();
  81
  82 private:
  83     // workers
  84     wxString Conv(const char *str);
  85     void parseFlags(const wxString& flags);
  86     void doTest(int flavor);
  87     static wxString quote(const wxString& arg);
  88     const wxChar *convError() const { return _T("<cannot convert>"); }
  89
  90     // assertions - adds some information about the test that failed
  91     void fail(const wxString& msg) const;
  92     void failIf(bool condition, const wxString& msg) const
  93         { if (condition) fail(msg); }
  94
  95     // mode, id, flags, pattern, test data, expected results...
  96     int m_mode;
  97     wxString m_id;
  98     wxString m_flags;
  99     wxString m_pattern;
 100     wxString m_data;
 101     wxArrayString m_expected;
 102
 103     // the flag decoded
 104     int m_compileFlags;
 105     int m_matchFlags;
 106     bool m_basic;
 107     bool m_extended;
 108     bool m_advanced;
 109 };
 110
 111 // constructor - throws Exception on failure
 112 //
 113 RegExTestCase::RegExTestCase(
 114     const string& name,
 115     const char *mode,
 116     const char *id,
 117     const char *flags,
 118     const char *pattern,
 119     const char *data,
 120     const vector<const char *>& expected)
 121   :
 122     TestCase(name),
 123     m_mode(mode[0]),
 124     m_id(Conv(id)),
 125     m_flags(Conv(flags)),
 126     m_pattern(Conv(pattern)),
 127     m_data(Conv(data)),
 128     m_compileFlags(0),
 129     m_matchFlags(0),
 130     m_basic(false),
 131     m_extended(false),
 132     m_advanced(false)
 133 {
 134     bool badconv = m_pattern == convError() || m_data == convError();
 135     //RN:  Removing the std:: here will break MSVC6 compilation
 136     std::vector<const char *>::const_iterator it;
 137
 138     for (it = expected.begin(); it != expected.end(); ++it) {
 139         m_expected.push_back(Conv(*it));
 140         badconv = badconv || *m_expected.rbegin() == convError();
 141     }
 142
 143     failIf(badconv, _T("cannot convert to default character encoding"));
 144
 145     // the flags need further parsing...
 146     parseFlags(m_flags);
 147
 148 #ifndef wxHAS_REGEX_ADVANCED
 149     failIf(!m_basic && !m_extended, _T("advanced regexs not available"));
 150 #endif
 151 }
 152
 153 int wxWcscmp(const wchar_t* s1, const wchar_t* s2)
 154 {
 155     size_t nLen1 = wxWcslen(s1);
 156     size_t nLen2 = wxWcslen(s2);
 157
 158     if (nLen1 != nLen2)
 159         return nLen1 - nLen2;
 160
 161     return wxTmemcmp(s1, s2, nLen1);
 162 }
 163
 164 // convert a string from UTF8 to the internal encoding
 165 //
 166 wxString RegExTestCase::Conv(const char *str)
 167 {
 168     const wxWCharBuffer wstr = wxConvUTF8.cMB2WC(str);
 169     const wxWC2WXbuf buf = wxConvCurrent->cWC2WX(wstr);
 170
 171     if (!buf || wxWcscmp(wxConvCurrent->cWX2WC(buf), wstr) != 0)
 172         return convError();
 173     else
 174         return buf;
 175 }
 176
 177 // Parse flags
 178 //
 179 void RegExTestCase::parseFlags(const wxString& flags)
 180 {
 181     for ( wxString::const_iterator p = flags.begin(); p != flags.end(); ++p )
 182     {
 183         switch ( (*p).GetValue() ) {
 184             // noop
 185             case '-': break;
 186
 187             // we don't fully support these flags, but they don't stop us
 188             // checking for success of failure of the match, so treat as noop
 189             case 'A': case 'B': case 'E': case 'H':
 190             case 'I': case 'L': case 'M': case 'N':
 191             case 'P': case 'Q': case 'R': case 'S':
 192             case 'T': case 'U': case '%':
 193                 break;
 194
 195             // match options
 196             case '^': m_matchFlags |= wxRE_NOTBOL; break;
 197             case '$': m_matchFlags |= wxRE_NOTEOL; break;
 198 #if wxUSE_UNICODE
 199             case '*': break;
 200 #endif
 201             // compile options
 202             case '&': m_advanced = m_basic = true; break;
 203             case 'b': m_basic = true; break;
 204             case 'e': m_extended = true; break;
 205             case 'i': m_compileFlags |= wxRE_ICASE; break;
 206             case 'o': m_compileFlags |= wxRE_NOSUB; break;
 207             case 'n': m_compileFlags |= wxRE_NEWLINE; break;
 208             case 't': if (strchr("ep", m_mode)) break; // else fall through...
 209
 210             // anything else we must skip the test
 211             default:
 212                 fail(wxString::Format(
 213                      _T("requires unsupported flag '%c'"), *p));
 214         }
 215     }
 216 }
 217
 218 // Try test for all flavours of expression specified
 219 //
 220 void RegExTestCase::runTest()
 221 {
 222     if (m_basic)
 223         doTest(wxRE_BASIC);
 224     if (m_extended)
 225         doTest(wxRE_EXTENDED);
 226 #ifdef wxHAS_REGEX_ADVANCED
 227     if (m_advanced || (!m_basic && !m_extended))
 228         doTest(wxRE_ADVANCED);
 229 #endif
 230 }
 231
 232 // Try the test for a single flavour of expression
 233 //
 234 void RegExTestCase::doTest(int flavor)
 235 {
 236     wxRegEx re(m_pattern, m_compileFlags | flavor);
 237
 238     // 'e' - test that the pattern fails to compile
 239     if (m_mode == 'e') {
 240         failIf(re.IsValid(), _T("compile succeeded (should fail)"));
 241         return;
 242     }
 243     failIf(!re.IsValid(), _T("compile failed"));
 244
 245     bool matches = re.Matches(m_data, m_matchFlags);
 246
 247     // 'f' or 'p' - test that the pattern does not match
 248     if (m_mode == 'f' || m_mode == 'p') {
 249         failIf(matches, _T("match succeeded (should fail)"));
 250         return;
 251     }
 252
 253     // otherwise 'm' or 'i' - test the pattern does match
 254     failIf(!matches, _T("match failed"));
 255
 256     if (m_compileFlags & wxRE_NOSUB)
 257         return;
 258
 259     // check wxRegEx has correctly counted the number of subexpressions
 260     wxString msg;
 261     msg << _T("GetMatchCount() == ") << re.GetMatchCount()
 262         << _T(", expected ") << m_expected.size();
 263     failIf(m_expected.size() != re.GetMatchCount(), msg);
 264
 265     for (size_t i = 0; i < m_expected.size(); i++) {
 266         wxString result;
 267         size_t start, len;
 268
 269         msg.clear();
 270         msg << _T("wxRegEx::GetMatch failed for match ") << i;
 271         failIf(!re.GetMatch(&start, &len, i), msg);
 272
 273         // m - check the match returns the strings given
 274         if (m_mode == 'm')
 275             if (start < INT_MAX)
 276                 result = m_data.substr(start, len);
 277             else
 278                 result = _T("");
 279
 280         // i - check the match returns the offsets given
 281         else if (m_mode == 'i')
 282             if (start > INT_MAX)
 283                 result = _T("-1 -1");
 284             else if (start + len > 0)
 285                 result << start << _T(" ") << start + len - 1;
 286             else
 287                 result << start << _T(" -1");
 288
 289         msg.clear();
 290         msg << _T("match(") << i << _T(") == ") << quote(result)
 291             << _T(", expected == ") << quote(m_expected[i]);
 292         failIf(result != m_expected[i], msg);
 293     }
 294 }
 295
 296 // assertion - adds some information about the test that failed
 297 //
 298 void RegExTestCase::fail(const wxString& msg) const
 299 {
 300     wxString str;
 301     wxArrayString::const_iterator it;
 302
 303     str << (wxChar)m_mode << _T(" ") << m_id << _T(" ") << m_flags << _T(" ")
 304         << quote(m_pattern) << _T(" ") << quote(m_data);
 305
 306     for (it = m_expected.begin(); it != m_expected.end(); ++it)
 307         str << _T(" ") << quote(*it);
 308
 309     if (str.length() > 77)
 310         str = str.substr(0, 74) + _T("...");
 311
 312     str << _T("\n ") << msg;
 313
 314     // no lossy convs so using utf8
 315     CPPUNIT_FAIL(string(str.mb_str(wxConvUTF8)));
 316 }
 317
 318 // quote a string so that it can be displayed (static)
 319 //
 320 wxString RegExTestCase::quote(const wxString& arg)
 321 {
 322     const wxChar *needEscape = _T("\a\b\t\n\v\f\r\"\\");
 323     const wxChar *escapes = _T("abtnvfr\"\\");
 324     wxString str;
 325
 326     for (size_t i = 0; i < arg.length(); i++) {
 327         wxUChar ch = (wxChar)arg[i];
 328         const wxChar *p = wxStrchr(needEscape, ch);
 329
 330         if (p)
 331             str += wxString::Format(_T("\\%c"), escapes[p - needEscape]);
 332         else if (wxIscntrl(ch))
 333             str += wxString::Format(_T("\\%03o"), ch);
 334         else
 335             str += (wxChar)ch;
 336     }
 337
 338     return str.length() == arg.length() && str.find(' ') == wxString::npos ?
 339         str : _T("\"") + str + _T("\"");
 340 }
 341
 342
 343 ///////////////////////////////////////////////////////////////////////////////
 344 // Test suite
 345
 346 class RegExTestSuite : public TestSuite
 347 {
 348 public:
 349     RegExTestSuite(string name) : TestSuite(name) { }
 350     void add(const char *mode, const char *id, const char *flags,
 351              const char *pattern, const char *data, const char *expected, ...);
 352 };
 353
 354 // Add a testcase to the suite
 355 //
 356 void RegExTestSuite::add(
 357     const char *mode,
 358     const char *id,
 359     const char *flags,
 360     const char *pattern,
 361     const char *data,
 362     const char *expected, ...)
 363 {
 364     string name = getName() + "." + id;
 365
 366     vector<const char *> expected_results;
 367     va_list ap;
 368
 369     for (va_start(ap, expected); expected; expected = va_arg(ap, const char *))
 370         expected_results.push_back(expected);
 371
 372     va_end(ap);
 373
 374     try {
 375         addTest(new RegExTestCase(
 376             name, mode, id, flags, pattern, data, expected_results));
 377     }
 378     catch (Exception& e) {
 379         wxLogInfo(wxString::Format(_T("skipping: %s\n %s\n"),
 380             wxString(name.c_str(), wxConvUTF8).c_str(),
 381             wxString(e.what(), wxConvUTF8).c_str()));
 382     }
 383 }
 384
 385
 386 // Include the generated tests
 387 //
 388 #include "regex.inc"
 389
 390
 391 #endif // wxHAS_REGEX_ADVANCED