tests/strings/tokenizer.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        tests/strings/strings.cpp
   3 // Purpose:     wxStringTokenizer unit test
   4 // Author:      Vadim Zeitlin
   5 // Created:     2005-12-20 (extacted from strings.cpp)
   6 // Copyright:   (c) 2004-2005 Vadim Zeitlin
   7 ///////////////////////////////////////////////////////////////////////////////
   8
   9 // ----------------------------------------------------------------------------
  10 // headers
  11 // ----------------------------------------------------------------------------
  12
  13 #include "testprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #ifndef WX_PRECOMP
  20     #include "wx/wx.h"
  21 #endif // WX_PRECOMP
  22
  23 #include "wx/tokenzr.h"
  24
  25 // ----------------------------------------------------------------------------
  26 // test class
  27 // ----------------------------------------------------------------------------
  28
  29 class TokenizerTestCase : public CppUnit::TestCase
  30 {
  31 public:
  32     TokenizerTestCase() { }
  33
  34 private:
  35     CPPUNIT_TEST_SUITE( TokenizerTestCase );
  36         CPPUNIT_TEST( GetCount );
  37         CPPUNIT_TEST( GetPosition );
  38         CPPUNIT_TEST( GetString );
  39         CPPUNIT_TEST( LastDelimiter );
  40         CPPUNIT_TEST( StrtokCompat );
  41     CPPUNIT_TEST_SUITE_END();
  42
  43     void GetCount();
  44     void GetPosition();
  45     void GetString();
  46     void LastDelimiter();
  47     void StrtokCompat();
  48
  49     DECLARE_NO_COPY_CLASS(TokenizerTestCase)
  50 };
  51
  52 // register in the unnamed registry so that these tests are run by default
  53 CPPUNIT_TEST_SUITE_REGISTRATION( TokenizerTestCase );
  54
  55 // also include in its own registry so that these tests can be run alone
  56 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( TokenizerTestCase, "TokenizerTestCase" );
  57
  58 // ----------------------------------------------------------------------------
  59 // test data
  60 // ----------------------------------------------------------------------------
  61
  62 static const struct TokenizerTestData
  63 {
  64     // the string to tokenize
  65     const wxChar *str;
  66
  67     // the delimiters to use
  68     const wxChar *delims;
  69
  70     // the tokenizer mode
  71     wxStringTokenizerMode mode;
  72
  73     // expected number of tokens
  74     size_t count;
  75 }
  76 gs_testData[] =
  77 {
  78     { wxT(""),                   wxT(" "),              wxTOKEN_DEFAULT,       0 },
  79     { wxT(""),                   wxT(" "),              wxTOKEN_RET_EMPTY,     0 },
  80     { wxT(""),                   wxT(" "),              wxTOKEN_RET_EMPTY_ALL, 0 },
  81     { wxT(""),                   wxT(" "),              wxTOKEN_RET_DELIMS,    0 },
  82     { wxT(":"),                  wxT(":"),              wxTOKEN_RET_EMPTY,     1 },
  83     { wxT(":"),                  wxT(":"),              wxTOKEN_RET_DELIMS,    1 },
  84     { wxT(":"),                  wxT(":"),              wxTOKEN_RET_EMPTY_ALL, 2 },
  85     { wxT("::"),                 wxT(":"),              wxTOKEN_RET_EMPTY,     1 },
  86     { wxT("::"),                 wxT(":"),              wxTOKEN_RET_DELIMS,    1 },
  87     { wxT("::"),                 wxT(":"),              wxTOKEN_RET_EMPTY_ALL, 3 },
  88
  89     { wxT("Hello, world"),       wxT(" "),              wxTOKEN_DEFAULT,       2 },
  90     { wxT("Hello,   world  "),   wxT(" "),              wxTOKEN_DEFAULT,       2 },
  91     { wxT("Hello, world"),       wxT(","),              wxTOKEN_DEFAULT,       2 },
  92     { wxT("Hello, world!"),      wxT(",!"),             wxTOKEN_DEFAULT,       2 },
  93     { wxT("Hello,, world!"),     wxT(",!"),             wxTOKEN_DEFAULT,       3 },
  94     { wxT("Hello,, world!"),     wxT(",!"),             wxTOKEN_STRTOK,        2 },
  95     { wxT("Hello, world!"),      wxT(",!"),             wxTOKEN_RET_EMPTY_ALL, 3 },
  96
  97     { wxT("username:password:uid:gid:gecos:home:shell"),
  98                                 wxT(":"),              wxTOKEN_DEFAULT,       7 },
  99
 100     { wxT("1:2::3:"),            wxT(":"),              wxTOKEN_DEFAULT,       4 },
 101     { wxT("1:2::3:"),            wxT(":"),              wxTOKEN_RET_EMPTY,     4 },
 102     { wxT("1:2::3:"),            wxT(":"),              wxTOKEN_RET_EMPTY_ALL, 5 },
 103     { wxT("1:2::3:"),            wxT(":"),              wxTOKEN_RET_DELIMS,    4 },
 104     { wxT("1:2::3:"),            wxT(":"),              wxTOKEN_STRTOK,        3 },
 105
 106     { wxT("1:2::3::"),           wxT(":"),              wxTOKEN_DEFAULT,       4 },
 107     { wxT("1:2::3::"),           wxT(":"),              wxTOKEN_RET_EMPTY,     4 },
 108     { wxT("1:2::3::"),           wxT(":"),              wxTOKEN_RET_EMPTY_ALL, 6 },
 109     { wxT("1:2::3::"),           wxT(":"),              wxTOKEN_RET_DELIMS,    4 },
 110     { wxT("1:2::3::"),           wxT(":"),              wxTOKEN_STRTOK,        3 },
 111
 112     { wxT("1 \t3\t4  6   "),     wxDEFAULT_DELIMITERS, wxTOKEN_DEFAULT,       4 },
 113     { wxT("1 \t3\t4  6   "),     wxDEFAULT_DELIMITERS, wxTOKEN_STRTOK,        4 },
 114     { wxT("1 \t3\t4  6   "),     wxDEFAULT_DELIMITERS, wxTOKEN_RET_EMPTY,     6 },
 115     { wxT("1 \t3\t4  6   "),     wxDEFAULT_DELIMITERS, wxTOKEN_RET_EMPTY_ALL, 9 },
 116
 117     { wxT("01/02/99"),           wxT("/-"),             wxTOKEN_DEFAULT,       3 },
 118     { wxT("01-02/99"),           wxT("/-"),             wxTOKEN_RET_DELIMS,    3 },
 119 };
 120
 121 // helper function returning the string showing the index for which the test
 122 // fails in the diagnostic message
 123 static std::string Nth(size_t n)
 124 {
 125     return std::string(wxString::Format(wxT("for loop index %lu"),
 126                                         (unsigned long)n).mb_str());
 127 }
 128
 129 // ----------------------------------------------------------------------------
 130 // the tests
 131 // ----------------------------------------------------------------------------
 132
 133 void TokenizerTestCase::GetCount()
 134 {
 135     for ( size_t n = 0; n < WXSIZEOF(gs_testData); n++ )
 136     {
 137         const TokenizerTestData& ttd = gs_testData[n];
 138
 139         wxStringTokenizer tkz(ttd.str, ttd.delims, ttd.mode);
 140         CPPUNIT_ASSERT_EQUAL_MESSAGE( Nth(n), ttd.count, tkz.CountTokens() );
 141
 142         size_t count = 0;
 143         while ( tkz.HasMoreTokens() )
 144         {
 145             tkz.GetNextToken();
 146             count++;
 147         }
 148
 149         CPPUNIT_ASSERT_EQUAL_MESSAGE( Nth(n), ttd.count, count );
 150     }
 151 }
 152
 153 // call this with the string to tokenize, delimeters to use and the expected
 154 // positions (i.e. results of GetPosition()) after each GetNextToken() call,
 155 // terminate positions with 0
 156 static void
 157 DoTestGetPosition(const wxChar *s, const wxChar *delims, int pos, ...)
 158 {
 159     wxStringTokenizer tkz(s, delims);
 160
 161     CPPUNIT_ASSERT_EQUAL( (size_t)0, tkz.GetPosition() );
 162
 163     va_list ap;
 164     va_start(ap, pos);
 165
 166     for ( ;; )
 167     {
 168         if ( !pos )
 169         {
 170             CPPUNIT_ASSERT( !tkz.HasMoreTokens() );
 171             break;
 172         }
 173
 174         tkz.GetNextToken();
 175
 176         CPPUNIT_ASSERT_EQUAL( (size_t)pos, tkz.GetPosition() );
 177
 178         pos = va_arg(ap, int);
 179     }
 180
 181     va_end(ap);
 182 }
 183
 184 void TokenizerTestCase::GetPosition()
 185 {
 186     DoTestGetPosition(wxT("foo"), wxT("_"), 3, 0);
 187     DoTestGetPosition(wxT("foo_bar"), wxT("_"), 4, 7, 0);
 188     DoTestGetPosition(wxT("foo_bar_"), wxT("_"), 4, 8, 0);
 189 }
 190
 191 // helper for GetString(): the parameters are the same as for DoTestGetPosition
 192 // but it checks GetString() return value instead of GetPosition()
 193 static void
 194 DoTestGetString(const wxChar *s, const wxChar *delims, int pos, ...)
 195 {
 196     wxStringTokenizer tkz(s, delims);
 197
 198     CPPUNIT_ASSERT_EQUAL( wxString(s), tkz.GetString() );
 199
 200     va_list ap;
 201     va_start(ap, pos);
 202
 203     for ( ;; )
 204     {
 205         if ( !pos )
 206         {
 207             CPPUNIT_ASSERT( tkz.GetString().empty() ) ;
 208             break;
 209         }
 210
 211         tkz.GetNextToken();
 212
 213         CPPUNIT_ASSERT_EQUAL( wxString(s + pos), tkz.GetString() );
 214
 215         pos = va_arg(ap, int);
 216     }
 217
 218     va_end(ap);
 219 }
 220
 221 void TokenizerTestCase::GetString()
 222 {
 223     DoTestGetString(wxT("foo"), wxT("_"), 3, 0);
 224     DoTestGetString(wxT("foo_bar"), wxT("_"), 4, 7, 0);
 225     DoTestGetString(wxT("foo_bar_"), wxT("_"), 4, 8, 0);
 226 }
 227
 228 void TokenizerTestCase::LastDelimiter()
 229 {
 230     wxStringTokenizer tkz(wxT("a+-b=c"), wxT("+-="));
 231
 232     tkz.GetNextToken();
 233     CPPUNIT_ASSERT_EQUAL( wxT('+'), tkz.GetLastDelimiter() );
 234
 235     tkz.GetNextToken();
 236     CPPUNIT_ASSERT_EQUAL( wxT('-'), tkz.GetLastDelimiter() );
 237
 238     tkz.GetNextToken();
 239     CPPUNIT_ASSERT_EQUAL( wxT('='), tkz.GetLastDelimiter() );
 240
 241     tkz.GetNextToken();
 242     CPPUNIT_ASSERT_EQUAL( wxT('\0'), tkz.GetLastDelimiter() );
 243 }
 244
 245 void TokenizerTestCase::StrtokCompat()
 246 {
 247     for ( size_t n = 0; n < WXSIZEOF(gs_testData); n++ )
 248     {
 249         const TokenizerTestData& ttd = gs_testData[n];
 250         if ( ttd.mode != wxTOKEN_STRTOK )
 251             continue;
 252
 253 #if wxUSE_UNICODE
 254         wxWCharBuffer
 255 #else
 256         wxCharBuffer
 257 #endif
 258             buf(ttd.str);
 259         wxChar *last;
 260         wxChar *s = wxStrtok(buf.data(), ttd.delims, &last);
 261
 262         wxStringTokenizer tkz(ttd.str, ttd.delims, ttd.mode);
 263         while ( tkz.HasMoreTokens() )
 264         {
 265             CPPUNIT_ASSERT_EQUAL( wxString(s), tkz.GetNextToken() );
 266             s = wxStrtok(NULL, ttd.delims, &last);
 267         }
 268     }
 269 }
 270
 271