unittests/tests/StringFunctionsTest.cpp

   1 #include <muleunit/test.h>
   2 #include <common/StringFunctions.h>
   3
   4 #include <wx/filename.h>
   5
   6 using namespace muleunit;
   7
   8 DECLARE_SIMPLE(StringFunctions)
   9
  10
  11 ///////////////////////////////////////////////////////////
  12 // Tests for the JoinPaths function
  13
  14 TEST(StringFunctions, JoinPaths)
  15 {
  16         const wxString seps = wxFileName::GetPathSeparators();
  17         const wxString sep = wxFileName::GetPathSeparator();
  18
  19         for (size_t i = 0; i < seps.Length(); ++i) {
  20                 const wxString cur_sep = seps.Mid(i, 1);
  21
  22                 ASSERT_EQUALS(wxT("a") + sep + wxT("b"), JoinPaths(wxT("a"), wxT("b")));
  23                 ASSERT_EQUALS(wxT("a") + sep + wxT("b"), JoinPaths(wxT("a") + cur_sep, wxT("b")));
  24                 ASSERT_EQUALS(wxT("a") + sep + wxT("b"), JoinPaths(wxT("a"), cur_sep + wxT("b")));
  25                 ASSERT_EQUALS(wxT("a") + sep + wxT("b"), JoinPaths(wxT("a") + cur_sep, cur_sep + wxT("b")));
  26                 ASSERT_EQUALS(wxT("a"), JoinPaths(wxT("a"), wxEmptyString));
  27                 ASSERT_EQUALS(wxT("b"), JoinPaths(wxEmptyString, wxT("b")));
  28                 ASSERT_EQUALS(wxEmptyString, JoinPaths(wxEmptyString, wxEmptyString));
  29         }
  30 }
  31
  32
  33 ///////////////////////////////////////////////////////////
  34 // Tests for the FuzzyStrCmp function
  35
  36 //! Returns the number of items in an array.
  37 #define itemsof(x) (sizeof(x)/sizeof(x[0]))
  38
  39 TEST(StringFunctions, FuzzyStrCmp)
  40 {
  41         struct FuzzyTest {
  42                 const wxChar* a;
  43                 const wxChar* b;
  44                 int expected;
  45         };
  46
  47         FuzzyTest checks[] = {
  48                 { wxT("a (10)"),        wxT("a (2)"),            1},
  49                 { wxT("a (10)"),        wxT("b (2)"),           -1},
  50                 { wxT("c3 (7)"),        wxT("c3 (12)"),         -1},
  51                 { wxT("c3 (12)"),       wxT("c3 (7)"),           1},
  52                 { wxT("c3 12d"),        wxT("c3 12d"),           0},
  53                 { wxT("a (10)  "),      wxT("a (2)  "),          1},
  54                 { wxT("a (10)  "),      wxT("b (2)  "),         -1},
  55                 { wxT("  c3 (7)"),      wxT("  c3 (12)"),       -1},
  56                 { wxT("  c3 (12)"),     wxT("  c3 (7)"),         1},
  57                 { wxT("c3 12d"),        wxT("c3 12d"),           0},
  58                 { wxT(""),              wxT(""),                 0},
  59                 { wxT(""),              wxT("c3 12d"),          -1},
  60                 { wxT("c3 12d"),        wxT(""),                 1},
  61                 { wxT(" "),             wxT("c3 12d"),          -1},
  62                 { wxT("c3 12d"),        wxT(" "),                1},
  63                 { wxT("17.10"),         wxT("17.2"),             1},
  64                 { wxT("  c3 (a)"),      wxT("  c3 (12)"),        1},
  65                 { wxT("  c3 (12)"),     wxT("  c3 (a)"),        -1},
  66         };
  67
  68         for (size_t i = 0; i < itemsof(checks); ++i) {
  69                 wxString a = checks[i].a;
  70                 wxString b = checks[i].b;
  71
  72                 ASSERT_EQUALS(checks[i].expected, FuzzyStrCmp(a, b));
  73         }
  74 }
  75
  76
  77 ///////////////////////////////////////////////////////////
  78 // Tests for the CSimpleParser class
  79
  80 DECLARE_SIMPLE(SimpleParser)
  81
  82
  83 TEST(SimpleParser, Constructor)
  84 {
  85         // Empty strings are acceptable and should just return an empty string
  86         {
  87                 CSimpleTokenizer tkz1(wxEmptyString, wxT('-'));
  88                 ASSERT_EQUALS(wxT(""), tkz1.remaining());
  89                 ASSERT_EQUALS(wxEmptyString, tkz1.next());
  90                 ASSERT_EQUALS(wxT(""), tkz1.remaining());
  91                 ASSERT_EQUALS(wxEmptyString, tkz1.next());
  92         }
  93
  94         // String with no tokens should be return immediatly
  95         {
  96                 CSimpleTokenizer tkz2(wxT(" abc "), wxT('-'));
  97                 ASSERT_EQUALS(wxT(" abc "), tkz2.remaining());
  98                 ASSERT_EQUALS(wxT(" abc "), tkz2.next());
  99                 ASSERT_EQUALS(wxEmptyString, tkz2.next());
 100                 ASSERT_EQUALS(wxEmptyString, tkz2.next());
 101         }
 102 }
 103
 104
 105 TEST(SimpleParser, EmptyTokens)
 106 {
 107         {
 108                 CSimpleTokenizer tkz1(wxT(" a"), wxT(' '));
 109                 ASSERT_EQUALS(wxT(" a"), tkz1.remaining());
 110                 ASSERT_EQUALS(0u, tkz1.tokenCount());
 111
 112                 ASSERT_EQUALS(wxEmptyString, tkz1.next());
 113                 ASSERT_EQUALS(wxT("a"), tkz1.remaining());
 114                 ASSERT_EQUALS(1u, tkz1.tokenCount());
 115
 116                 ASSERT_EQUALS(wxT("a"), tkz1.next());
 117                 ASSERT_EQUALS(wxT(""), tkz1.remaining());
 118                 ASSERT_EQUALS(1u, tkz1.tokenCount());
 119
 120                 ASSERT_EQUALS(wxEmptyString, tkz1.next());
 121                 ASSERT_EQUALS(wxT(""), tkz1.remaining());
 122                 ASSERT_EQUALS(1u, tkz1.tokenCount());
 123         }
 124
 125         {
 126                 CSimpleTokenizer tkz2(wxT("c "), wxT(' '));
 127                 ASSERT_EQUALS(wxT("c "), tkz2.remaining());
 128                 ASSERT_EQUALS(0u, tkz2.tokenCount());
 129
 130                 ASSERT_EQUALS(wxT("c"), tkz2.next());
 131                 ASSERT_EQUALS(wxT(""), tkz2.remaining());
 132                 ASSERT_EQUALS(1u, tkz2.tokenCount());
 133
 134                 ASSERT_EQUALS(wxEmptyString, tkz2.next());
 135                 ASSERT_EQUALS(wxT(""), tkz2.remaining());
 136                 ASSERT_EQUALS(1u, tkz2.tokenCount());
 137
 138                 ASSERT_EQUALS(wxEmptyString, tkz2.next());
 139                 ASSERT_EQUALS(wxT(""), tkz2.remaining());
 140                 ASSERT_EQUALS(1u, tkz2.tokenCount());
 141         }
 142
 143         {
 144                 CSimpleTokenizer tkz3(wxT(" a c "), wxT(' '));
 145                 ASSERT_EQUALS(wxT(" a c "), tkz3.remaining());
 146                 ASSERT_EQUALS(0u, tkz3.tokenCount());
 147
 148                 ASSERT_EQUALS(wxEmptyString, tkz3.next());
 149                 ASSERT_EQUALS(wxT("a c "), tkz3.remaining());
 150                 ASSERT_EQUALS(1u, tkz3.tokenCount());
 151
 152                 ASSERT_EQUALS(wxT("a"), tkz3.next());
 153                 ASSERT_EQUALS(wxT("c "), tkz3.remaining());
 154                 ASSERT_EQUALS(2u, tkz3.tokenCount());
 155
 156                 ASSERT_EQUALS(wxT("c"), tkz3.next());
 157                 ASSERT_EQUALS(wxT(""), tkz3.remaining());
 158                 ASSERT_EQUALS(3u, tkz3.tokenCount());
 159
 160                 ASSERT_EQUALS(wxEmptyString, tkz3.next());
 161                 ASSERT_EQUALS(wxT(""), tkz3.remaining());
 162                 ASSERT_EQUALS(3u, tkz3.tokenCount());
 163
 164                 ASSERT_EQUALS(wxEmptyString, tkz3.next());
 165                 ASSERT_EQUALS(wxT(""), tkz3.remaining());
 166                 ASSERT_EQUALS(3u, tkz3.tokenCount());
 167         }
 168 }
 169
 170
 171 TEST(SimpleParser, NormalTokens)
 172 {
 173         CSimpleTokenizer tkz(wxT("a c"), wxT(' '));
 174         ASSERT_EQUALS(wxT("a c"), tkz.remaining());
 175         ASSERT_EQUALS(0u, tkz.tokenCount());
 176
 177         ASSERT_EQUALS(wxT("a"), tkz.next());
 178         ASSERT_EQUALS(wxT("c"), tkz.remaining());
 179         ASSERT_EQUALS(1u, tkz.tokenCount());
 180
 181         ASSERT_EQUALS(wxT("c"), tkz.next());
 182         ASSERT_EQUALS(wxT(""), tkz.remaining());
 183         ASSERT_EQUALS(1u, tkz.tokenCount());
 184
 185         ASSERT_EQUALS(wxEmptyString, tkz.next());
 186         ASSERT_EQUALS(wxT(""), tkz.remaining());
 187         ASSERT_EQUALS(1u, tkz.tokenCount());
 188
 189         ASSERT_EQUALS(wxEmptyString, tkz.next());
 190         ASSERT_EQUALS(wxT(""), tkz.remaining());
 191         ASSERT_EQUALS(1u, tkz.tokenCount());
 192 }
 193