]>
Commit | Line | Data |
---|---|---|
1cd53e88 VS |
1 | /////////////////////////////////////////////////////////////////////////////// |
2 | // Name: tests/strings/strings.cpp | |
3 | // Purpose: wxString unit test | |
4 | // Author: Vadim Zeitlin, Wlodzimierz ABX Skiba | |
5 | // Created: 2004-04-19 | |
6 | // RCS-ID: $Id$ | |
7 | // Copyright: (c) 2004 Vadim Zeitlin, Wlodzimierz Skiba | |
8 | /////////////////////////////////////////////////////////////////////////////// | |
9 | ||
10 | // ---------------------------------------------------------------------------- | |
11 | // headers | |
12 | // ---------------------------------------------------------------------------- | |
13 | ||
8899b155 | 14 | #include "testprec.h" |
1cd53e88 VS |
15 | |
16 | #ifdef __BORLANDC__ | |
17 | #pragma hdrstop | |
18 | #endif | |
19 | ||
20 | #ifndef WX_PRECOMP | |
21 | #include "wx/wx.h" | |
22 | #endif // WX_PRECOMP | |
23 | ||
1cd53e88 VS |
24 | // ---------------------------------------------------------------------------- |
25 | // test class | |
26 | // ---------------------------------------------------------------------------- | |
27 | ||
28 | class StringTestCase : public CppUnit::TestCase | |
29 | { | |
30 | public: | |
31 | StringTestCase(); | |
32 | ||
33 | private: | |
34 | CPPUNIT_TEST_SUITE( StringTestCase ); | |
35 | CPPUNIT_TEST( String ); | |
36 | CPPUNIT_TEST( PChar ); | |
37 | CPPUNIT_TEST( Format ); | |
38 | CPPUNIT_TEST( Constructors ); | |
39 | CPPUNIT_TEST( Extraction ); | |
e6a99197 | 40 | CPPUNIT_TEST( Trim ); |
1cd53e88 | 41 | CPPUNIT_TEST( Find ); |
1cd53e88 VS |
42 | CPPUNIT_TEST( Replace ); |
43 | CPPUNIT_TEST( Match ); | |
bd7f096d | 44 | CPPUNIT_TEST( CaseChanges ); |
dcb68102 RN |
45 | CPPUNIT_TEST( Compare ); |
46 | CPPUNIT_TEST( CompareNoCase ); | |
c4f35063 | 47 | CPPUNIT_TEST( Contains ); |
4f7ee81a VZ |
48 | CPPUNIT_TEST( ToLong ); |
49 | CPPUNIT_TEST( ToULong ); | |
d6718dd1 VZ |
50 | #ifdef wxLongLong_t |
51 | CPPUNIT_TEST( ToLongLong ); | |
52 | CPPUNIT_TEST( ToULongLong ); | |
53 | #endif // wxLongLong_t | |
4f7ee81a | 54 | CPPUNIT_TEST( ToDouble ); |
db419f1f | 55 | CPPUNIT_TEST( WriteBuf ); |
1cd53e88 VS |
56 | CPPUNIT_TEST_SUITE_END(); |
57 | ||
58 | void String(); | |
59 | void PChar(); | |
60 | void Format(); | |
61 | void Constructors(); | |
62 | void Extraction(); | |
e6a99197 | 63 | void Trim(); |
1cd53e88 | 64 | void Find(); |
1cd53e88 VS |
65 | void Replace(); |
66 | void Match(); | |
bd7f096d | 67 | void CaseChanges(); |
dcb68102 RN |
68 | void Compare(); |
69 | void CompareNoCase(); | |
c4f35063 | 70 | void Contains(); |
4f7ee81a VZ |
71 | void ToLong(); |
72 | void ToULong(); | |
d6718dd1 VZ |
73 | #ifdef wxLongLong_t |
74 | void ToLongLong(); | |
75 | void ToULongLong(); | |
76 | #endif // wxLongLong_t | |
4f7ee81a | 77 | void ToDouble(); |
db419f1f | 78 | void WriteBuf(); |
1cd53e88 VS |
79 | |
80 | DECLARE_NO_COPY_CLASS(StringTestCase) | |
81 | }; | |
82 | ||
83 | // register in the unnamed registry so that these tests are run by default | |
84 | CPPUNIT_TEST_SUITE_REGISTRATION( StringTestCase ); | |
85 | ||
86 | // also include in it's own registry so that these tests can be run alone | |
87 | CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( StringTestCase, "StringTestCase" ); | |
88 | ||
89 | StringTestCase::StringTestCase() | |
90 | { | |
91 | } | |
92 | ||
93 | void StringTestCase::String() | |
94 | { | |
95 | wxString a, b, c; | |
96 | ||
97 | a.reserve (128); | |
98 | b.reserve (128); | |
99 | c.reserve (128); | |
100 | ||
101 | for (int i = 0; i < 2; ++i) | |
102 | { | |
103 | a = _T("Hello"); | |
104 | b = _T(" world"); | |
105 | c = _T("! How'ya doin'?"); | |
106 | a += b; | |
107 | a += c; | |
108 | c = _T("Hello world! What's up?"); | |
109 | CPPUNIT_ASSERT( c != a ); | |
110 | } | |
111 | } | |
112 | ||
113 | void StringTestCase::PChar() | |
114 | { | |
115 | wxChar a [128]; | |
116 | wxChar b [128]; | |
117 | wxChar c [128]; | |
118 | ||
119 | for (int i = 0; i < 2; ++i) | |
120 | { | |
121 | wxStrcpy (a, _T("Hello")); | |
122 | wxStrcpy (b, _T(" world")); | |
123 | wxStrcpy (c, _T("! How'ya doin'?")); | |
124 | wxStrcat (a, b); | |
125 | wxStrcat (a, c); | |
126 | wxStrcpy (c, _T("Hello world! What's up?")); | |
127 | CPPUNIT_ASSERT( wxStrcmp (c, a) != 0 ); | |
128 | } | |
129 | } | |
130 | ||
131 | void StringTestCase::Format() | |
132 | { | |
133 | wxString s1,s2; | |
134 | s1.Printf(_T("%03d"), 18); | |
135 | CPPUNIT_ASSERT( s1 == wxString::Format(_T("%03d"), 18) ); | |
136 | s2.Printf(_T("Number 18: %s\n"), s1.c_str()); | |
137 | CPPUNIT_ASSERT( s2 == wxString::Format(_T("Number 18: %s\n"), s1.c_str()) ); | |
b03cd7e6 VZ |
138 | |
139 | static const size_t lengths[] = { 1, 512, 1024, 1025, 2048, 4096, 4097 }; | |
140 | for ( size_t n = 0; n < WXSIZEOF(lengths); n++ ) | |
141 | { | |
142 | const size_t len = lengths[n]; | |
143 | ||
144 | wxString s(_T('Z'), len); | |
145 | CPPUNIT_ASSERT_EQUAL( len, wxString::Format(_T("%s"), s.c_str()).length()); | |
146 | } | |
1cd53e88 VS |
147 | } |
148 | ||
149 | void StringTestCase::Constructors() | |
150 | { | |
151 | #define TEST_CTOR(args, res) \ | |
152 | { \ | |
153 | wxString s args ; \ | |
154 | CPPUNIT_ASSERT( s == res ); \ | |
155 | } | |
156 | ||
157 | TEST_CTOR((_T('Z'), 4), _T("ZZZZ")); | |
158 | TEST_CTOR((_T("Hello"), 4), _T("Hell")); | |
159 | TEST_CTOR((_T("Hello"), 5), _T("Hello")); | |
160 | ||
161 | static const wxChar *s = _T("?really!"); | |
162 | const wxChar *start = wxStrchr(s, _T('r')); | |
163 | const wxChar *end = wxStrchr(s, _T('!')); | |
164 | TEST_CTOR((start, end), _T("really")); | |
165 | } | |
166 | ||
265d5cce | 167 | |
1cd53e88 VS |
168 | void StringTestCase::Extraction() |
169 | { | |
170 | wxString s(_T("Hello, world!")); | |
171 | ||
172 | CPPUNIT_ASSERT( wxStrcmp( s.c_str() , _T("Hello, world!") ) == 0 ); | |
173 | CPPUNIT_ASSERT( wxStrcmp( s.Left(5).c_str() , _T("Hello") ) == 0 ); | |
174 | CPPUNIT_ASSERT( wxStrcmp( s.Right(6).c_str() , _T("world!") ) == 0 ); | |
175 | CPPUNIT_ASSERT( wxStrcmp( s(3, 5).c_str() , _T("lo, w") ) == 0 ); | |
176 | CPPUNIT_ASSERT( wxStrcmp( s.Mid(3).c_str() , _T("lo, world!") ) == 0 ); | |
177 | CPPUNIT_ASSERT( wxStrcmp( s.substr(3, 5).c_str() , _T("lo, w") ) == 0 ); | |
178 | CPPUNIT_ASSERT( wxStrcmp( s.substr(3).c_str() , _T("lo, world!") ) == 0 ); | |
179 | ||
180 | wxString rest; | |
181 | ||
3affcd07 VZ |
182 | #define TEST_STARTS_WITH(prefix, correct_rest, result) \ |
183 | CPPUNIT_ASSERT_EQUAL(result, s.StartsWith(prefix, &rest)); \ | |
184 | if ( result ) \ | |
185 | CPPUNIT_ASSERT_EQUAL(wxString(correct_rest), rest) | |
1cd53e88 VS |
186 | |
187 | TEST_STARTS_WITH( _T("Hello"), _T(", world!"), true ); | |
188 | TEST_STARTS_WITH( _T("Hello, "), _T("world!"), true ); | |
189 | TEST_STARTS_WITH( _T("Hello, world!"), _T(""), true ); | |
190 | TEST_STARTS_WITH( _T("Hello, world!!!"), _T(""), false ); | |
191 | TEST_STARTS_WITH( _T(""), _T("Hello, world!"), true ); | |
192 | TEST_STARTS_WITH( _T("Goodbye"), _T(""), false ); | |
193 | TEST_STARTS_WITH( _T("Hi"), _T(""), false ); | |
194 | ||
195 | #undef TEST_STARTS_WITH | |
3affcd07 VZ |
196 | |
197 | #define TEST_ENDS_WITH(suffix, correct_rest, result) \ | |
198 | CPPUNIT_ASSERT_EQUAL(result, s.EndsWith(suffix, &rest)); \ | |
199 | if ( result ) \ | |
200 | CPPUNIT_ASSERT_EQUAL(wxString(correct_rest), rest) | |
201 | ||
202 | TEST_ENDS_WITH( _T(""), _T("Hello, world!"), true ); | |
203 | TEST_ENDS_WITH( _T("!"), _T("Hello, world"), true ); | |
204 | TEST_ENDS_WITH( _T(", world!"), _T("Hello"), true ); | |
205 | TEST_ENDS_WITH( _T("ello, world!"), _T("H"), true ); | |
206 | TEST_ENDS_WITH( _T("Hello, world!"), _T(""), true ); | |
207 | TEST_ENDS_WITH( _T("very long string"), _T(""), false ); | |
208 | TEST_ENDS_WITH( _T("?"), _T(""), false ); | |
209 | TEST_ENDS_WITH( _T("Hello, world"), _T(""), false ); | |
210 | TEST_ENDS_WITH( _T("Gello, world!"), _T(""), false ); | |
211 | ||
212 | #undef TEST_ENDS_WITH | |
1cd53e88 VS |
213 | } |
214 | ||
e6a99197 WS |
215 | void StringTestCase::Trim() |
216 | { | |
217 | #define TEST_TRIM( str , dir , result ) \ | |
218 | CPPUNIT_ASSERT( wxString(str).Trim(dir) == result ) | |
219 | ||
220 | TEST_TRIM( _T(" Test "), true, _T(" Test") ); | |
221 | TEST_TRIM( _T(" "), true, _T("") ); | |
222 | TEST_TRIM( _T(" "), true, _T("") ); | |
223 | TEST_TRIM( _T(""), true, _T("") ); | |
224 | ||
225 | TEST_TRIM( _T(" Test "), false, _T("Test ") ); | |
226 | TEST_TRIM( _T(" "), false, _T("") ); | |
227 | TEST_TRIM( _T(" "), false, _T("") ); | |
228 | TEST_TRIM( _T(""), false, _T("") ); | |
229 | ||
230 | #undef TEST_TRIM | |
231 | } | |
232 | ||
1cd53e88 VS |
233 | void StringTestCase::Find() |
234 | { | |
235 | #define TEST_FIND( str , start , result ) \ | |
236 | CPPUNIT_ASSERT( wxString(str).find(_T("ell"), start) == result ); | |
237 | ||
238 | TEST_FIND( _T("Well, hello world"), 0, 1 ); | |
239 | TEST_FIND( _T("Well, hello world"), 6, 7 ); | |
240 | TEST_FIND( _T("Well, hello world"), 9, wxString::npos ); | |
241 | ||
242 | #undef TEST_FIND | |
243 | } | |
244 | ||
1cd53e88 VS |
245 | void StringTestCase::Replace() |
246 | { | |
247 | #define TEST_REPLACE( original , pos , len , replacement , result ) \ | |
248 | { \ | |
249 | wxString s = original; \ | |
250 | s.replace( pos , len , replacement ); \ | |
251 | CPPUNIT_ASSERT( s == result ); \ | |
252 | } | |
253 | ||
254 | TEST_REPLACE( _T("012-AWORD-XYZ"), 4, 5, _T("BWORD"), _T("012-BWORD-XYZ") ); | |
255 | TEST_REPLACE( _T("increase"), 0, 2, _T("de"), _T("decrease") ); | |
256 | TEST_REPLACE( _T("wxWindow"), 8, 0, _T("s"), _T("wxWindows") ); | |
257 | TEST_REPLACE( _T("foobar"), 3, 0, _T("-"), _T("foo-bar") ); | |
258 | TEST_REPLACE( _T("barfoo"), 0, 6, _T("foobar"), _T("foobar") ); | |
259 | ||
7634e443 RN |
260 | |
261 | #define TEST_NULLCHARREPLACE( o , olen, pos , len , replacement , r, rlen ) \ | |
262 | { \ | |
263 | wxString s(o,olen); \ | |
264 | s.replace( pos , len , replacement ); \ | |
265 | CPPUNIT_ASSERT( s == wxString(r,rlen) ); \ | |
266 | } | |
267 | ||
268 | TEST_NULLCHARREPLACE( _T("null\0char"), 9, 5, 1, _T("d"), | |
269 | _T("null\0dhar"), 9 ); | |
270 | ||
271 | #define TEST_WXREPLACE( o , olen, olds, news, all, r, rlen ) \ | |
272 | { \ | |
273 | wxString s(o,olen); \ | |
274 | s.Replace( olds, news, all ); \ | |
275 | CPPUNIT_ASSERT( s == wxString(r,rlen) ); \ | |
276 | } | |
277 | ||
2df0258e RN |
278 | TEST_WXREPLACE( _T("null\0char"), 9, _T("c"), _T("de"), true, |
279 | _T("null\0dehar"), 10 ); | |
7634e443 | 280 | |
4629f07e RN |
281 | TEST_WXREPLACE( _T("null\0dehar"), 10, _T("de"), _T("c"), true, |
282 | _T("null\0char"), 9 ); | |
283 | ||
7634e443 RN |
284 | #undef TEST_WXREPLACE |
285 | #undef TEST_NULLCHARREPLACE | |
1cd53e88 VS |
286 | #undef TEST_REPLACE |
287 | } | |
288 | ||
289 | void StringTestCase::Match() | |
290 | { | |
291 | #define TEST_MATCH( s1 , s2 , result ) \ | |
292 | CPPUNIT_ASSERT( wxString(s1).Matches(s2) == result ) | |
293 | ||
294 | TEST_MATCH( _T("foobar"), _T("foo*"), true ); | |
295 | TEST_MATCH( _T("foobar"), _T("*oo*"), true ); | |
296 | TEST_MATCH( _T("foobar"), _T("*bar"), true ); | |
297 | TEST_MATCH( _T("foobar"), _T("??????"), true ); | |
298 | TEST_MATCH( _T("foobar"), _T("f??b*"), true ); | |
299 | TEST_MATCH( _T("foobar"), _T("f?b*"), false ); | |
300 | TEST_MATCH( _T("foobar"), _T("*goo*"), false ); | |
301 | TEST_MATCH( _T("foobar"), _T("*foo"), false ); | |
302 | TEST_MATCH( _T("foobarfoo"), _T("*foo"), true ); | |
303 | TEST_MATCH( _T(""), _T("*"), true ); | |
304 | TEST_MATCH( _T(""), _T("?"), false ); | |
305 | ||
306 | #undef TEST_MATCH | |
307 | } | |
308 | ||
bd7f096d VS |
309 | |
310 | void StringTestCase::CaseChanges() | |
311 | { | |
312 | wxString s1(_T("Hello!")); | |
313 | wxString s1u(s1); | |
314 | wxString s1l(s1); | |
315 | s1u.MakeUpper(); | |
316 | s1l.MakeLower(); | |
317 | wxString s2u, s2l; | |
318 | s2u.MakeUpper(); | |
319 | s2l.MakeLower(); | |
320 | ||
321 | CPPUNIT_ASSERT( s1u == _T("HELLO!") ); | |
322 | CPPUNIT_ASSERT( s1l == _T("hello!") ); | |
323 | CPPUNIT_ASSERT( s2u == wxEmptyString ); | |
324 | CPPUNIT_ASSERT( s2l == wxEmptyString ); | |
329b43f6 VZ |
325 | |
326 | #if !wxUSE_UNICODE | |
327 | wxLocale locRu(wxLANGUAGE_RUSSIAN, 0 /* flags */); | |
328 | if ( locRu.IsOk() ) | |
329 | { | |
330 | // try upper casing 8bit strings | |
b26ed94e MW |
331 | const wchar_t capital_ya[] = { 0x42f, 0 }, |
332 | small_ya[] = { 0x44f, 0 }; | |
333 | ||
334 | wxString sUpper(wxConvLibc.cWC2MB(capital_ya)), | |
335 | sLower(wxConvLibc.cWC2MB(small_ya)); | |
329b43f6 VZ |
336 | |
337 | CPPUNIT_ASSERT( sUpper.Lower() == sLower ); | |
338 | CPPUNIT_ASSERT( sLower.Upper() == sUpper ); | |
339 | } | |
340 | #endif // !wxUSE_UNICODE | |
bd7f096d | 341 | } |
dcb68102 RN |
342 | |
343 | void StringTestCase::Compare() | |
344 | { | |
345 | wxString s1 = wxT("AHH"); | |
346 | wxString eq = wxT("AHH"); | |
347 | wxString neq1 = wxT("HAH"); | |
348 | wxString neq2 = wxT("AH"); | |
349 | wxString neq3 = wxT("AHHH"); | |
350 | wxString neq4 = wxT("AhH"); | |
0c924034 | 351 | |
dcb68102 RN |
352 | CPPUNIT_ASSERT( s1 == eq ); |
353 | CPPUNIT_ASSERT( s1 != neq1 ); | |
354 | CPPUNIT_ASSERT( s1 != neq2 ); | |
355 | CPPUNIT_ASSERT( s1 != neq3 ); | |
356 | CPPUNIT_ASSERT( s1 != neq4 ); | |
357 | ||
d7330233 VS |
358 | CPPUNIT_ASSERT( s1 == wxT("AHH") ); |
359 | CPPUNIT_ASSERT( s1 != wxT("no") ); | |
360 | CPPUNIT_ASSERT( s1 < wxT("AZ") ); | |
361 | CPPUNIT_ASSERT( s1 <= wxT("AZ") ); | |
362 | CPPUNIT_ASSERT( s1 <= wxT("AHH") ); | |
363 | CPPUNIT_ASSERT( s1 > wxT("AA") ); | |
364 | CPPUNIT_ASSERT( s1 >= wxT("AA") ); | |
365 | CPPUNIT_ASSERT( s1 >= wxT("AHH") ); | |
366 | ||
367 | // test comparison with C strings in Unicode build (must work in ANSI as | |
368 | // well, of course): | |
369 | CPPUNIT_ASSERT( s1 == "AHH" ); | |
370 | CPPUNIT_ASSERT( s1 != "no" ); | |
371 | CPPUNIT_ASSERT( s1 < "AZ" ); | |
372 | CPPUNIT_ASSERT( s1 <= "AZ" ); | |
373 | CPPUNIT_ASSERT( s1 <= "AHH" ); | |
374 | CPPUNIT_ASSERT( s1 > "AA" ); | |
375 | CPPUNIT_ASSERT( s1 >= "AA" ); | |
376 | CPPUNIT_ASSERT( s1 >= "AHH" ); | |
377 | ||
dcb68102 RN |
378 | // wxString _s1 = wxT("A\0HH"); |
379 | // wxString _eq = wxT("A\0HH"); | |
380 | // wxString _neq1 = wxT("H\0AH"); | |
381 | // wxString _neq2 = wxT("A\0H"); | |
382 | // wxString _neq3 = wxT("A\0HHH"); | |
383 | // wxString _neq4 = wxT("A\0hH"); | |
384 | s1.insert(1,1,'\0'); | |
385 | eq.insert(1,1,'\0'); | |
386 | neq1.insert(1,1,'\0'); | |
387 | neq2.insert(1,1,'\0'); | |
388 | neq3.insert(1,1,'\0'); | |
389 | neq4.insert(1,1,'\0'); | |
0c924034 | 390 | |
dcb68102 RN |
391 | CPPUNIT_ASSERT( s1 == eq ); |
392 | CPPUNIT_ASSERT( s1 != neq1 ); | |
393 | CPPUNIT_ASSERT( s1 != neq2 ); | |
394 | CPPUNIT_ASSERT( s1 != neq3 ); | |
395 | CPPUNIT_ASSERT( s1 != neq4 ); | |
396 | } | |
397 | ||
398 | void StringTestCase::CompareNoCase() | |
399 | { | |
400 | wxString s1 = wxT("AHH"); | |
401 | wxString eq = wxT("AHH"); | |
402 | wxString eq2 = wxT("AhH"); | |
403 | wxString eq3 = wxT("ahh"); | |
404 | wxString neq = wxT("HAH"); | |
405 | wxString neq2 = wxT("AH"); | |
406 | wxString neq3 = wxT("AHHH"); | |
0c924034 | 407 | |
dcb68102 RN |
408 | #define CPPUNIT_CNCEQ_ASSERT(s1, s2) CPPUNIT_ASSERT( s1.CmpNoCase(s2) == 0) |
409 | #define CPPUNIT_CNCNEQ_ASSERT(s1, s2) CPPUNIT_ASSERT( s1.CmpNoCase(s2) != 0) | |
410 | ||
411 | CPPUNIT_CNCEQ_ASSERT( s1, eq ); | |
412 | CPPUNIT_CNCEQ_ASSERT( s1, eq2 ); | |
413 | CPPUNIT_CNCEQ_ASSERT( s1, eq3 ); | |
414 | ||
415 | CPPUNIT_CNCNEQ_ASSERT( s1, neq ); | |
416 | CPPUNIT_CNCNEQ_ASSERT( s1, neq2 ); | |
417 | CPPUNIT_CNCNEQ_ASSERT( s1, neq3 ); | |
418 | ||
419 | ||
420 | // wxString _s1 = wxT("A\0HH"); | |
421 | // wxString _eq = wxT("A\0HH"); | |
422 | // wxString _eq2 = wxT("A\0hH"); | |
423 | // wxString _eq3 = wxT("a\0hh"); | |
424 | // wxString _neq = wxT("H\0AH"); | |
425 | // wxString _neq2 = wxT("A\0H"); | |
426 | // wxString _neq3 = wxT("A\0HHH"); | |
0c924034 | 427 | |
dcb68102 RN |
428 | s1.insert(1,1,'\0'); |
429 | eq.insert(1,1,'\0'); | |
430 | eq2.insert(1,1,'\0'); | |
431 | eq3.insert(1,1,'\0'); | |
432 | neq.insert(1,1,'\0'); | |
433 | neq2.insert(1,1,'\0'); | |
434 | neq3.insert(1,1,'\0'); | |
435 | ||
436 | CPPUNIT_CNCEQ_ASSERT( s1, eq ); | |
437 | CPPUNIT_CNCEQ_ASSERT( s1, eq2 ); | |
438 | CPPUNIT_CNCEQ_ASSERT( s1, eq3 ); | |
439 | ||
440 | CPPUNIT_CNCNEQ_ASSERT( s1, neq ); | |
441 | CPPUNIT_CNCNEQ_ASSERT( s1, neq2 ); | |
442 | CPPUNIT_CNCNEQ_ASSERT( s1, neq3 ); | |
0c924034 WS |
443 | } |
444 | ||
c4f35063 VZ |
445 | void StringTestCase::Contains() |
446 | { | |
447 | static const struct ContainsData | |
448 | { | |
449 | const wxChar *hay; | |
450 | const wxChar *needle; | |
451 | bool contains; | |
452 | } containsData[] = | |
453 | { | |
454 | { _T(""), _T(""), true }, | |
455 | { _T(""), _T("foo"), false }, | |
456 | { _T("foo"), _T(""), true }, | |
457 | { _T("foo"), _T("f"), true }, | |
458 | { _T("foo"), _T("o"), true }, | |
459 | { _T("foo"), _T("oo"), true }, | |
460 | { _T("foo"), _T("ooo"), false }, | |
461 | { _T("foo"), _T("oooo"), false }, | |
462 | { _T("foo"), _T("fooo"), false }, | |
463 | }; | |
464 | ||
465 | for ( size_t n = 0; n < WXSIZEOF(containsData); n++ ) | |
466 | { | |
467 | const ContainsData& cd = containsData[n]; | |
468 | CPPUNIT_ASSERT_EQUAL( cd.contains, wxString(cd.hay).Contains(cd.needle) ); | |
469 | } | |
470 | } | |
471 | ||
d6718dd1 VZ |
472 | // flags used in ToLongData.flags |
473 | enum | |
4f7ee81a | 474 | { |
d6718dd1 VZ |
475 | Number_Ok = 0, |
476 | Number_Invalid = 1, | |
477 | Number_Unsigned = 2, // if not specified, works for signed conversion | |
478 | Number_Signed = 4, // if not specified, works for unsigned | |
479 | Number_LongLong = 8, // only for long long tests | |
480 | Number_Long = 16, // only for long tests | |
481 | }; | |
482 | ||
483 | static const struct ToLongData | |
484 | { | |
485 | const wxChar *str; | |
d6718dd1 | 486 | #ifdef wxLongLong_t |
efc57671 VZ |
487 | wxLongLong_t value; |
488 | #else | |
489 | long value; | |
d6718dd1 | 490 | #endif // wxLongLong_t |
d6718dd1 VZ |
491 | int flags; |
492 | ||
efc57671 VZ |
493 | long LValue() const { return value; } |
494 | unsigned long ULValue() const { return value; } | |
495 | #ifdef wxLongLong_t | |
496 | wxLongLong_t LLValue() const { return value; } | |
497 | wxULongLong_t ULLValue() const { return (wxULongLong_t)value; } | |
498 | #endif // wxLongLong_t | |
499 | ||
d6718dd1 VZ |
500 | bool IsOk() const { return !(flags & Number_Invalid); } |
501 | } longData[] = | |
502 | { | |
503 | { _T("1"), 1, Number_Ok }, | |
504 | { _T("0"), 0, Number_Ok }, | |
505 | { _T("a"), 0, Number_Invalid }, | |
506 | { _T("12345"), 12345, Number_Ok }, | |
507 | { _T("--1"), 0, Number_Invalid }, | |
508 | ||
509 | { _T("-1"), -1, Number_Signed | Number_Long }, | |
510 | // this is surprizing but consistent with strtoul() behaviour | |
511 | { _T("-1"), ULONG_MAX, Number_Unsigned | Number_Long }, | |
512 | ||
513 | // this must overflow, even with 64 bit long | |
514 | { _T("922337203685477580711"), 0, Number_Invalid }, | |
515 | ||
516 | #ifdef wxLongLong_t | |
517 | { _T("2147483648"), wxLL(2147483648), Number_LongLong }, | |
518 | { _T("-2147483648"), wxLL(-2147483648), Number_LongLong | Number_Signed }, | |
519 | { _T("9223372036854775808"), wxULL(9223372036854775808), Number_LongLong | | |
520 | Number_Unsigned }, | |
521 | #endif // wxLongLong_t | |
522 | }; | |
523 | ||
524 | void StringTestCase::ToLong() | |
525 | { | |
c4f35063 VZ |
526 | long l; |
527 | for ( size_t n = 0; n < WXSIZEOF(longData); n++ ) | |
4f7ee81a VZ |
528 | { |
529 | const ToLongData& ld = longData[n]; | |
d6718dd1 VZ |
530 | |
531 | if ( ld.flags & (Number_LongLong | Number_Unsigned) ) | |
532 | continue; | |
533 | ||
534 | CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToLong(&l) ); | |
535 | if ( ld.IsOk() ) | |
efc57671 | 536 | CPPUNIT_ASSERT_EQUAL( ld.LValue(), l ); |
4f7ee81a VZ |
537 | } |
538 | } | |
539 | ||
540 | void StringTestCase::ToULong() | |
541 | { | |
542 | unsigned long ul; | |
d6718dd1 | 543 | for ( size_t n = 0; n < WXSIZEOF(longData); n++ ) |
4f7ee81a | 544 | { |
d6718dd1 VZ |
545 | const ToLongData& ld = longData[n]; |
546 | ||
547 | if ( ld.flags & (Number_LongLong | Number_Signed) ) | |
548 | continue; | |
549 | ||
550 | CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToULong(&ul) ); | |
551 | if ( ld.IsOk() ) | |
efc57671 | 552 | CPPUNIT_ASSERT_EQUAL( ld.ULValue(), ul ); |
d6718dd1 VZ |
553 | } |
554 | } | |
555 | ||
556 | #ifdef wxLongLong_t | |
557 | ||
558 | void StringTestCase::ToLongLong() | |
559 | { | |
560 | wxLongLong_t l; | |
561 | for ( size_t n = 0; n < WXSIZEOF(longData); n++ ) | |
4f7ee81a | 562 | { |
d6718dd1 | 563 | const ToLongData& ld = longData[n]; |
4f7ee81a | 564 | |
d6718dd1 VZ |
565 | if ( ld.flags & (Number_Long | Number_Unsigned) ) |
566 | continue; | |
567 | ||
568 | CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToLongLong(&l) ); | |
569 | if ( ld.IsOk() ) | |
efc57671 | 570 | CPPUNIT_ASSERT_EQUAL( ld.LLValue(), l ); |
d6718dd1 VZ |
571 | } |
572 | } | |
573 | ||
574 | void StringTestCase::ToULongLong() | |
575 | { | |
576 | wxULongLong_t ul; | |
577 | for ( size_t n = 0; n < WXSIZEOF(longData); n++ ) | |
4f7ee81a | 578 | { |
d6718dd1 VZ |
579 | const ToLongData& ld = longData[n]; |
580 | ||
581 | if ( ld.flags & (Number_Long | Number_Signed) ) | |
582 | continue; | |
583 | ||
584 | CPPUNIT_ASSERT_EQUAL( ld.IsOk(), wxString(ld.str).ToULongLong(&ul) ); | |
585 | if ( ld.IsOk() ) | |
efc57671 | 586 | CPPUNIT_ASSERT_EQUAL( ld.ULLValue(), ul ); |
4f7ee81a VZ |
587 | } |
588 | } | |
589 | ||
d6718dd1 VZ |
590 | #endif // wxLongLong_t |
591 | ||
4f7ee81a VZ |
592 | void StringTestCase::ToDouble() |
593 | { | |
594 | double d; | |
595 | static const struct ToDoubleData | |
596 | { | |
597 | const wxChar *str; | |
598 | double value; | |
599 | bool ok; | |
600 | } doubleData[] = | |
601 | { | |
602 | { _T("1"), 1, true }, | |
603 | { _T("1.23"), 1.23, true }, | |
604 | { _T(".1"), .1, true }, | |
605 | { _T("1."), 1, true }, | |
606 | { _T("1.."), 0, false }, | |
607 | { _T("0"), 0, true }, | |
608 | { _T("a"), 0, false }, | |
609 | { _T("12345"), 12345, true }, | |
610 | { _T("-1"), -1, true }, | |
611 | { _T("--1"), 0, false }, | |
612 | }; | |
613 | ||
614 | // we need to use decimal point, not comma or whatever is its value for the | |
615 | // current locale | |
616 | wxSetlocale(LC_ALL, _T("C")); | |
617 | ||
618 | size_t n; | |
619 | for ( n = 0; n < WXSIZEOF(doubleData); n++ ) | |
620 | { | |
621 | const ToDoubleData& ld = doubleData[n]; | |
622 | CPPUNIT_ASSERT_EQUAL( ld.ok, wxString(ld.str).ToDouble(&d) ); | |
623 | if ( ld.ok ) | |
624 | CPPUNIT_ASSERT_EQUAL( ld.value, d ); | |
625 | } | |
626 | } | |
db419f1f VZ |
627 | |
628 | void StringTestCase::WriteBuf() | |
629 | { | |
630 | wxString s; | |
631 | wxStrcpy(wxStringBuffer(s, 10), _T("foo")); | |
632 | ||
c9f78968 VS |
633 | CPPUNIT_ASSERT(s[0u] == _T('f') ); |
634 | CPPUNIT_ASSERT(_T('f') == s[0u]); | |
635 | CPPUNIT_ASSERT(_T('o') == s[1]); | |
636 | CPPUNIT_ASSERT(_T('o') == s[2]); | |
e74d43ab | 637 | CPPUNIT_ASSERT_EQUAL((size_t)3, s.length()); |
db419f1f | 638 | |
d8a4b666 | 639 | |
db419f1f | 640 | { |
d8a4b666 VS |
641 | wxStringBufferLength buf(s, 10); |
642 | wxStrcpy(buf, _T("barrbaz")); | |
643 | buf.SetLength(4); | |
644 | } | |
db419f1f | 645 | |
c9f78968 VS |
646 | CPPUNIT_ASSERT(_T('b') == s[0u]); |
647 | CPPUNIT_ASSERT(_T('a') == s[1]); | |
648 | CPPUNIT_ASSERT(_T('r') == s[2]); | |
649 | CPPUNIT_ASSERT(_T('r') == s[3]); | |
d8a4b666 | 650 | CPPUNIT_ASSERT_EQUAL((size_t)4, s.length()); |
db419f1f | 651 | |
d8a4b666 | 652 | CPPUNIT_ASSERT_EQUAL( 0, wxStrcmp(_T("barr"), s) ); |
db419f1f VZ |
653 | } |
654 |