?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump version to 6.4-15
[LibreOffice.git] / sal / qa / rtl / oustring / rtl_ustr.cxx
blobe73ab9124108a116a3bc8daf9549c5058b9edaa2
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <cppunit/TestFixture.h>
21 #include <cppunit/extensions/HelperMacros.h>
22 #include <cppunit/plugin/TestPlugIn.h>
23
24 /** print a UNI_CODE file name.
25 */
26 /*
27 inline void printOUString( OUString const & _suStr )
28 {
29 OString aString;
30
31 printf( "OUString: " );
32 aString = OUStringToOString( _suStr, RTL_TEXTENCODING_ASCII_US );
33 printf( "%s\n", aString.getStr( ) );
34 }
35 */
36
37 namespace rtl_ustr
38 {
39
40 class compare : public CppUnit::TestFixture
41 {
42 public:
43
44 void compare_000()
45 {
46 rtl_ustr_compare( NULL, NULL);
47 // should not GPF
48 }
49
50 void compare_000_1()
51 {
52 OUString aStr1("Line must be equal.");
53 rtl_ustr_compare( aStr1.getStr(), NULL);
54 // should not GPF
55 }
56 void compare_001()
57 {
58 OUString aStr1;
59 OUString aStr2;
60
61 sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr());
62 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
63 }
64
65 void compare_002()
66 {
67 OUString aStr1("Line must be equal.");
68 OUString aStr2("Line must be equal.");
69
70 sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr());
71 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
72 }
73
74 void compare_003()
75 {
76 OUString aStr1("Line must differ.");
77 OUString aStr2("Line foo bar, ok, differ.");
78
79 sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr());
80 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
81 }
82
83 // Change the following lines only, if you add, remove or rename
84 // member functions of the current class,
85 // because these macros are need by auto register mechanism.
86
87 CPPUNIT_TEST_SUITE(compare);
88 CPPUNIT_TEST(compare_000);
89 CPPUNIT_TEST(compare_000_1);
90 CPPUNIT_TEST(compare_001);
91 CPPUNIT_TEST(compare_002);
92 CPPUNIT_TEST(compare_003);
93 CPPUNIT_TEST_SUITE_END();
94 }; // class compare
95
96 class compareIgnoreAsciiCase : public CppUnit::TestFixture
97 {
98 public:
99
100 void compare_000()
101 {
102 rtl_ustr_compareIgnoreAsciiCase( NULL, NULL);
103 }
104
105 void compare_000_1()
106 {
107 OUString aStr1("Line must be equal.");
108 rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), NULL);
109 }
110 void compare_001()
111 {
112 OUString aStr1;
113 OUString aStr2;
114
115 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr());
116 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
117 }
118
119 void compare_002()
120 {
121 OUString aStr1("Line must be equal.");
122 OUString aStr2("Line must be equal.");
123
124 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr());
125 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
126 }
127
128 void compare_002_1()
129 {
130 OUString aStr1("Line must be equal.");
131 OUString aStr2("LINE MUST BE EQUAL.");
132
133 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr());
134 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitive).", nValue == 0);
135 }
136
137 void compare_003()
138 {
139 OUString aStr1("Line must differ.");
140 OUString aStr2("Line foo bar, ok, differ.");
141
142 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr());
143 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
144 }
145
146 // Change the following lines only, if you add, remove or rename
147 // member functions of the current class,
148 // because these macros are need by auto register mechanism.
149
150 CPPUNIT_TEST_SUITE(compareIgnoreAsciiCase);
151 CPPUNIT_TEST(compare_000);
152 CPPUNIT_TEST(compare_000_1);
153 CPPUNIT_TEST(compare_001);
154 CPPUNIT_TEST(compare_002);
155 CPPUNIT_TEST(compare_002_1);
156 CPPUNIT_TEST(compare_003);
157 CPPUNIT_TEST_SUITE_END();
158 }; // class compareIgnoreAsciiCase
159
160 class shortenedCompareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture
161 {
162 public:
163
164 void compare_000()
165 {
166 rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0, 0);
167 }
168
169 void compare_000_1()
170 {
171 OUString aStr1("Line must be equal.");
172 rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0, 1);
173 }
174 void compare_001()
175 {
176 OUString aStr1;
177 OUString aStr2;
178
179 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), aStr2.getStr(), aStr2.getLength(), aStr1.getLength());
180 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
181 }
182
183 void compare_002()
184 {
185 OUString aStr1("Line must be equal.");
186 OUString aStr2("Line must be equal.");
187
188 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(),
189 aStr2.getStr(), aStr2.getLength(),
190 aStr1.getLength());
191 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
192 }
193
194 void compare_002_1()
195 {
196 OUString aStr1("Line must be equal.");
197 OUString aStr2("LINE MUST BE EQUAL.");
198
199 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(),
200 aStr2.getStr(), aStr2.getLength(),
201 aStr1.getLength());
202 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitive).", nValue == 0);
203 }
204
205 void compare_003()
206 {
207 OUString aStr1("Line must differ.");
208 OUString aStr2("Line foo bar, ok, differ.");
209
210 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(),
211 aStr2.getStr(), aStr2.getLength(),
212 5);
213 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal first 5 characters.", nValue == 0);
214 }
215
216 void compare_004()
217 {
218 OUString aStr1("Line must differ.");
219 OUString aStr2("Line foo bar, ok, differ.");
220
221 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(),
222 aStr2.getStr(), aStr2.getLength(),
223 aStr1.getLength());
224 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
225 }
226
227 // Change the following lines only, if you add, remove or rename
228 // member functions of the current class,
229 // because these macros are need by auto register mechanism.
230
231 CPPUNIT_TEST_SUITE(shortenedCompareIgnoreAsciiCase_WithLength);
232 CPPUNIT_TEST(compare_000);
233 CPPUNIT_TEST(compare_000_1);
234 CPPUNIT_TEST(compare_001);
235 CPPUNIT_TEST(compare_002);
236 CPPUNIT_TEST(compare_002_1);
237 CPPUNIT_TEST(compare_003);
238 CPPUNIT_TEST(compare_004);
239 CPPUNIT_TEST_SUITE_END();
240 }; // class compare
241
242 //
243 //
244 // class hashCode : public CppUnit::TestFixture
245 // {
246 // public:
247 //
248 // void hashCode_000()
249 // {
250 // sal_Int32 nHashCode = rtl_ustr_hashCode( NULL );
251 // volatile int dummy = 0;
252 // }
253 //
254 // void hashCode_001()
255 // {
256 // OString aStr1 = "Line for a hashCode.";
257 // sal_Int32 nHashCode = rtl_ustr_hashCode( aStr1.getStr() );
258 // printf("hashcode: %d\n", nHashCode);
259 // // CPPUNIT_ASSERT_MESSAGE("failed.", nValue == 0);
260 // }
261 //
262 // void hashCode_002()
263 // {
264 // OString aStr1 = "Line for a hashCode.";
265 // sal_Int32 nHashCode1 = rtl_ustr_hashCode( aStr1.getStr() );
266 //
267 // OString aStr2 = "Line for a hashCode.";
268 // sal_Int32 nHashCode2 = rtl_ustr_hashCode( aStr2.getStr() );
269 //
270 // CPPUNIT_ASSERT_MESSAGE("hashcodes must be equal.", nHashCode1 == nHashCode2 );
271 // }
272 //
273 // void hashCode_003()
274 // {
275 // OString aStr1 = "Line for a hashCode.";
276 // sal_Int32 nHashCode1 = rtl_ustr_hashCode( aStr1.getStr() );
277 //
278 // OString aStr2 = "Line for another hashcode.";
279 // sal_Int32 nHashCode2 = rtl_ustr_hashCode( aStr2.getStr() );
280 //
281 // CPPUNIT_ASSERT_MESSAGE("hashcodes must differ.", nHashCode1 != nHashCode2 );
282 // }
283 //
284 // // Change the following lines only, if you add, remove or rename
285 // // member functions of the current class,
286 // // because these macros are need by auto register mechanism.
287 //
288 // CPPUNIT_TEST_SUITE(hashCode);
289 // CPPUNIT_TEST(hashCode_000);
290 // CPPUNIT_TEST(hashCode_001);
291 // CPPUNIT_TEST(hashCode_002);
292 // CPPUNIT_TEST(hashCode_003);
293 // CPPUNIT_TEST_SUITE_END();
294 // }; // class compare
295
296 class indexOfChar : public CppUnit::TestFixture
297 {
298 public:
299
300 void indexOfChar_000()
301 {
302 rtl_ustr_indexOfChar( NULL, 0 );
303 }
304
305 void indexOfChar_001()
306 {
307 OUString aStr1("Line for an indexOfChar.");
308
309 sal_Int32 nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'L' );
310 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0);
311
312 /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'i' );
313 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 1);
314
315 /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'n' );
316 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 2);
317
318 /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'e' );
319 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 3);
320 }
321
322 void indexOfChar_002()
323 {
324 OUString aStr1("Line for an indexOfChar.");
325 sal_Int32 nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'y' );
326
327 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 );
328 }
329
330 // Change the following lines only, if you add, remove or rename
331 // member functions of the current class,
332 // because these macros are need by auto register mechanism.
333
334 CPPUNIT_TEST_SUITE(indexOfChar);
335 CPPUNIT_TEST(indexOfChar_000);
336 CPPUNIT_TEST(indexOfChar_001);
337 CPPUNIT_TEST(indexOfChar_002);
338 CPPUNIT_TEST_SUITE_END();
339 }; // class indexOfChar
340
341 class lastIndexOfChar : public CppUnit::TestFixture
342 {
343 public:
344
345 void lastIndexOfChar_000()
346 {
347 rtl_ustr_lastIndexOfChar( NULL, 0 );
348 }
349
350 void lastIndexOfChar_001()
351 {
352 OUString aStr1("Line for a lastIndexOfChar.");
353
354 sal_Int32 nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'C' );
355 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 22);
356
357 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'h' );
358 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 23);
359
360 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'a' );
361 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 24);
362
363 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'r' );
364 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 25);
365 }
366
367 void lastIndexOfChar_002()
368 {
369 OUString aStr1("Line for a lastIndexOfChar.");
370 sal_Int32 nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'y' );
371
372 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 );
373 }
374
375 // Change the following lines only, if you add, remove or rename
376 // member functions of the current class,
377 // because these macros are need by auto register mechanism.
378
379 CPPUNIT_TEST_SUITE(lastIndexOfChar);
380 CPPUNIT_TEST(lastIndexOfChar_000);
381 CPPUNIT_TEST(lastIndexOfChar_001);
382 CPPUNIT_TEST(lastIndexOfChar_002);
383 CPPUNIT_TEST_SUITE_END();
384 }; // class lastIndexOfChar
385
386 class indexOfStr : public CppUnit::TestFixture
387 {
388 public:
389
390 void indexOfStr_000()
391 {
392 rtl_ustr_indexOfStr( NULL, 0 );
393 }
394
395 void indexOfStr_000_1()
396 {
397 OUString aStr1("Line for an indexOfStr.");
398 rtl_ustr_indexOfStr( aStr1.getStr(), 0 );
399 }
400
401 void indexOfStr_001()
402 {
403 OUString aStr1("Line for an indexOfStr.");
404
405 OUString suSearch("Line");
406 sal_Int32 nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch );
407 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0);
408
409 /* OUString */ suSearch("for");
410 /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch );
411 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 5);
412
413 /* OUString */ suSearch("a");
414 /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch );
415 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 9);
416
417 /* OUString */ suSearch("an index");
418 /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch );
419 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex ==9);
420 }
421
422 void indexOfStr_002()
423 {
424 OUString aStr1("Line for an indexOfStr.");
425 OUString suSearch("not exist");
426 sal_Int32 nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch );
427
428 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 );
429 }
430
431 // Change the following lines only, if you add, remove or rename
432 // member functions of the current class,
433 // because these macros are need by auto register mechanism.
434
435 CPPUNIT_TEST_SUITE(indexOfStr);
436 CPPUNIT_TEST(indexOfStr_000);
437 CPPUNIT_TEST(indexOfStr_001);
438 CPPUNIT_TEST(indexOfStr_002);
439 CPPUNIT_TEST_SUITE_END();
440 }; // class compare
441
442 class lastIndexOfStr : public CppUnit::TestFixture
443 {
444 public:
445
446 void lastIndexOfStr_000()
447 {
448 rtl_ustr_lastIndexOfStr( NULL, NULL );
449 }
450
451 void lastIndexOfStr_000_1()
452 {
453 OUString aStr1("Line for a lastIndexOfStr.");
454 rtl_ustr_lastIndexOfStr( aStr1.getStr(), NULL );
455 }
456
457 void lastIndexOfStr_001()
458 {
459 OUString aStr1("Line for a lastIndexOfStr.");
460 OUString aSearchStr("Index");
461
462 sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
463 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 15);
464
465 /* OString */ aSearchStr = OUString("Line");
466 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
467 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0);
468
469 /* OString */ aSearchStr = OUString();
470 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
471 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1);
472 }
473
474 void lastIndexOfStr_002()
475 {
476 OUString aStr1("Line for a lastIndexOfStr.");
477 OUString aSearchStr("foo");
478 sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
479
480 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 );
481 }
482
483 void lastIndexOfStr_003()
484 {
485 OUString aStr1("Line for a lastIndexOfStr.");
486 OUString aSearchStr("O");
487 sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
488
489 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 20 );
490 }
491
492 // Change the following lines only, if you add, remove or rename
493 // member functions of the current class,
494 // because these macros are need by auto register mechanism.
495
496 CPPUNIT_TEST_SUITE(lastIndexOfStr);
497 CPPUNIT_TEST(lastIndexOfStr_000);
498 CPPUNIT_TEST(lastIndexOfStr_001);
499 CPPUNIT_TEST(lastIndexOfStr_002);
500 CPPUNIT_TEST(lastIndexOfStr_003);
501 CPPUNIT_TEST_SUITE_END();
502 }; // class lastIndexOfStr
503
504 class replaceChar : public CppUnit::TestFixture
505 {
506 public:
507
508 void replaceChar_000()
509 {
510 rtl_ustr_replaceChar( NULL, 0, 0 );
511 }
512
513 void replaceChar_001()
514 {
515 OUString aStr1("replace char.");
516 OUString aShouldStr1("ruplacu char.");
517
518 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode);
519 sal_Unicode* pStr = (sal_Unicode*) malloc( nLength + sizeof(sal_Unicode)); // length + 1 (null terminator)
520 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
521 memcpy(pStr, aStr1.getStr(), nLength);
522 pStr[aStr1.getLength()] = 0;
523
524 rtl_ustr_replaceChar( pStr, 'e', 'u' );
525 OUString suStr(pStr, aStr1.getLength());
526
527 CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(suStr) == sal_True);
528 free(pStr);
529 }
530
531 // Change the following lines only, if you add, remove or rename
532 // member functions of the current class,
533 // because these macros are need by auto register mechanism.
534
535 CPPUNIT_TEST_SUITE(replaceChar);
536 CPPUNIT_TEST(replaceChar_000);
537 CPPUNIT_TEST(replaceChar_001);
538 CPPUNIT_TEST_SUITE_END();
539 }; // class replaceChar
540
541 class replaceChar_WithLength : public CppUnit::TestFixture
542 {
543 public:
544
545 void replaceChar_WithLength_000()
546 {
547 rtl_ustr_replaceChar_WithLength( NULL, 0, 0, 0 );
548 }
549
550 void replaceChar_WithLength_000_1()
551 {
552 rtl_ustr_replaceChar_WithLength( NULL, 1, 0, 0 );
553 }
554 void replaceChar_WithLength_001()
555 {
556 OUString aStr1("replace char.");
557 OUString aShouldStr1("ruplace char.");
558
559 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode);
560 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength);
561 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
562 memcpy(pStr, aStr1.getStr(), nLength);
563
564 rtl_ustr_replaceChar_WithLength( pStr, 6, 'e', 'u' );
565 OUString suStr(pStr, aStr1.getLength());
566
567 CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(suStr) == sal_True);
568 free(pStr);
569 }
570
571 void replaceChar_WithLength_002()
572 {
573 OUString aStr1 ("eeeeeeeeeeeee");
574 OUString aShouldStr1("uuuuuueeeeeee");
575
576 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode);
577 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); // no null terminator is need
578 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
579 memcpy(pStr, aStr1.getStr(), nLength);
580
581 rtl_ustr_replaceChar_WithLength( pStr, 6, 'e', 'u' );
582 OUString suStr(pStr, aStr1.getLength());
583
584 CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(suStr) == sal_True);
585 free(pStr);
586 }
587
588 // Change the following lines only, if you add, remove or rename
589 // member functions of the current class,
590 // because these macros are need by auto register mechanism.
591
592 CPPUNIT_TEST_SUITE(replaceChar_WithLength);
593 CPPUNIT_TEST(replaceChar_WithLength_000);
594 CPPUNIT_TEST(replaceChar_WithLength_000_1);
595 CPPUNIT_TEST(replaceChar_WithLength_001);
596 CPPUNIT_TEST(replaceChar_WithLength_002);
597 CPPUNIT_TEST_SUITE_END();
598 }; // class replaceChar
599
600 class toAsciiLowerCase : public CppUnit::TestFixture
601 {
602 public:
603
604 void toAsciiLowerCase_000()
605 {
606 rtl_ustr_toAsciiLowerCase( NULL );
607 }
608
609 void toAsciiLowerCase_001()
610 {
611 OUString aStr1("CHANGE THIS TO ASCII LOWER CASE.");
612 OUString aShouldStr1("change this to ascii lower case.");
613
614 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode);
615 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode) ); // we need to add '\0' so one more
616 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
617 memcpy(pStr, aStr1.getStr(), nLength);
618 pStr[aStr1.getLength()] = 0;
619
620 rtl_ustr_toAsciiLowerCase( pStr );
621 OUString suStr(pStr, aStr1.getLength());
622
623 CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == sal_True);
624 free(pStr);
625 }
626
627 // Change the following lines only, if you add, remove or rename
628 // member functions of the current class,
629 // because these macros are need by auto register mechanism.
630
631 CPPUNIT_TEST_SUITE(toAsciiLowerCase);
632 CPPUNIT_TEST(toAsciiLowerCase_000);
633 CPPUNIT_TEST(toAsciiLowerCase_001);
634 CPPUNIT_TEST_SUITE_END();
635 }; // class replaceChar
636
637 class toAsciiLowerCase_WithLength : public CppUnit::TestFixture
638 {
639 public:
640
641 void toAsciiLowerCase_WithLength_000()
642 {
643 rtl_ustr_toAsciiLowerCase_WithLength( NULL, 0 );
644 }
645
646 void toAsciiLowerCase_WithLength_001()
647 {
648 OUString aStr1("CHANGE THIS TO ASCII LOWER CASE.");
649 OUString aShouldStr1("change thiS TO ASCII LOWER CASE.");
650
651 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode);
652 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength);
653 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
654 memcpy(pStr, aStr1.getStr(), nLength);
655
656 rtl_ustr_toAsciiLowerCase_WithLength( pStr, 10 );
657
658 OUString suStr(pStr, aStr1.getLength());
659 sal_Bool bResult = aShouldStr1.equals(suStr);
660
661 printOUString(suStr);
662 printf("Result length: %d\n", suStr.getLength() );
663 printf("Result: %d\n", bResult);
664
665 CPPUNIT_ASSERT_MESSAGE("failed", bResult == sal_True);
666 free(pStr);
667 }
668
669 // Change the following lines only, if you add, remove or rename
670 // member functions of the current class,
671 // because these macros are need by auto register mechanism.
672
673 CPPUNIT_TEST_SUITE(toAsciiLowerCase_WithLength);
674 CPPUNIT_TEST(toAsciiLowerCase_WithLength_000);
675 CPPUNIT_TEST(toAsciiLowerCase_WithLength_001);
676 CPPUNIT_TEST_SUITE_END();
677 }; // class replaceChar
678
679 class toAsciiUpperCase : public CppUnit::TestFixture
680 {
681 public:
682
683 void toAsciiUpperCase_000()
684 {
685 rtl_ustr_toAsciiUpperCase( NULL );
686 }
687
688 void toAsciiUpperCase_001()
689 {
690 OUString aStr1("change this to ascii upper case.");
691 OUString aShouldStr1("CHANGE THIS TO ASCII UPPER CASE.");
692
693 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode);
694 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator
695 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
696 memcpy(pStr, aStr1.getStr(), nLength);
697 pStr[aStr1.getLength()] = 0;
698
699 rtl_ustr_toAsciiUpperCase( pStr );
700 OUString suStr(pStr, aStr1.getLength());
701
702 CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == sal_True);
703 free(pStr);
704 }
705
706 // Change the following lines only, if you add, remove or rename
707 // member functions of the current class,
708 // because these macros are need by auto register mechanism.
709
710 CPPUNIT_TEST_SUITE(toAsciiUpperCase);
711 CPPUNIT_TEST(toAsciiUpperCase_000);
712 CPPUNIT_TEST(toAsciiUpperCase_001);
713 CPPUNIT_TEST_SUITE_END();
714 }; // class replaceChar
715
716 class toAsciiUpperCase_WithLength : public CppUnit::TestFixture
717 {
718 public:
719
720 void toAsciiUpperCase_WithLength_000()
721 {
722 rtl_ustr_toAsciiUpperCase_WithLength( NULL, 0 );
723 }
724
725 void toAsciiUpperCase_WithLength_001()
726 {
727 OUString aStr1("change this to ascii lower case.");
728 OUString aShouldStr1("CHANGE THIs to ascii lower case.");
729
730 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode);
731 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength);
732 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
733
734 memcpy(pStr, aStr1.getStr(), nLength);
735 rtl_ustr_toAsciiUpperCase_WithLength( pStr, 10 );
736 OUString suStr(pStr, aStr1.getLength());
737
738 // printf("Uppercase with length: '%s'\n", aStr1.getStr());
739 CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == sal_True);
740 free(pStr);
741 }
742
743 // Change the following lines only, if you add, remove or rename
744 // member functions of the current class,
745 // because these macros are need by auto register mechanism.
746
747 CPPUNIT_TEST_SUITE(toAsciiUpperCase_WithLength);
748 CPPUNIT_TEST(toAsciiUpperCase_WithLength_000);
749 CPPUNIT_TEST(toAsciiUpperCase_WithLength_001);
750 CPPUNIT_TEST_SUITE_END();
751 }; // class replaceChar
752
753 class trim_WithLength : public CppUnit::TestFixture
754 {
755 public:
756 void trim_WithLength_000()
757 {
758 rtl_ustr_trim_WithLength(NULL, 0);
759 // should not GPF
760 }
761
762 void trim_WithLength_000_1()
763 {
764 OUString suStr(" trim this");
765
766 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode);
767 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength);
768 memcpy(pStr, suStr.getStr(), nLength);
769
770 rtl_ustr_trim_WithLength( pStr, 0 );
771 free(pStr);
772 }
773
774 void trim_WithLength_001()
775 {
776 OUString suStr(" trim this");
777 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode);
778 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength);
779 memcpy(pStr, suStr.getStr(), nLength);
780
781 rtl_ustr_trim_WithLength( pStr, 2 );
782
783 CPPUNIT_ASSERT_MESSAGE("string should be empty", OUString(pStr).getLength() == 0);
784 free(pStr);
785 }
786
787 void trim_WithLength_002()
788 {
789 OUString suStr("trim this");
790
791 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode);
792 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength);
793 memcpy(pStr, suStr.getStr(), nLength);
794
795 rtl_ustr_trim_WithLength( pStr, 5 );
796
797 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", OUString(pStr).getLength() == 4);
798 free(pStr);
799 }
800
801 void trim_WithLength_003()
802 {
803 OUString suStr(" trim this");
804
805 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode);
806 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength);
807 memcpy(pStr, suStr.getStr(), nLength);
808
809 rtl_ustr_trim_WithLength( pStr, 11 );
810
811 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", OUString(pStr).getLength() == 4);
812 free(pStr);
813 }
814
815 void trim_WithLength_004()
816 {
817 OUString suStr("\r\n\t \n\r trim \n this");
818
819 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode);
820 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength);
821 memcpy(pStr, suStr.getStr(), nLength);
822
823 rtl_ustr_trim_WithLength( pStr, 17 );
824
825 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", OUString(pStr).getLength() == 4);
826 free(pStr);
827 }
828
829 void trim_WithLength_005()
830 {
831 OUString suStr("\r\n\t \n\r trim \t this \n\r\t\t ");
832
833 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode);
834 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength);
835 memcpy(pStr, suStr.getStr(), nLength);
836
837 rtl_ustr_trim_WithLength( pStr, suStr.getLength() );
838
839 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim \\t this'", OUString(pStr).getLength() == 11);
840 free(pStr);
841 }
842
843 // Change the following lines only, if you add, remove or rename
844 // member functions of the current class,
845 // because these macros are need by auto register mechanism.
846
847 CPPUNIT_TEST_SUITE(trim_WithLength);
848 CPPUNIT_TEST(trim_WithLength_000);
849 CPPUNIT_TEST(trim_WithLength_000_1);
850 CPPUNIT_TEST(trim_WithLength_001);
851 CPPUNIT_TEST(trim_WithLength_002);
852 CPPUNIT_TEST(trim_WithLength_003);
853 CPPUNIT_TEST(trim_WithLength_004);
854 CPPUNIT_TEST(trim_WithLength_005);
855 CPPUNIT_TEST_SUITE_END();
856 };
857
858 class valueOfChar : public CppUnit::TestFixture
859 {
860 public:
861 void valueOfChar_000()
862 {
863 rtl_ustr_valueOfChar(NULL, 0);
864 // should not GPF
865 }
866 void valueOfChar_001()
867 {
868 sal_Unicode *pStr = (sal_Unicode*)malloc(RTL_USTR_MAX_VALUEOFCHAR);
869 if (pStr)
870 {
871 rtl_ustr_valueOfChar(pStr, 'A');
872
873 CPPUNIT_ASSERT_MESSAGE("string should contain 'A'", pStr[0] == L'A');
874 free(pStr);
875 }
876 }
877
878 // Change the following lines only, if you add, remove or rename
879 // member functions of the current class,
880 // because these macros are need by auto register mechanism.
881
882 CPPUNIT_TEST_SUITE(valueOfChar);
883 CPPUNIT_TEST(valueOfChar_000);
884 CPPUNIT_TEST(valueOfChar_001);
885 CPPUNIT_TEST_SUITE_END();
886 };
887
888 class ascii_compare_WithLength : public CppUnit::TestFixture
889 {
890 public:
891 void zero_length()
892 {
893 sal_Unicode pUnicode[] = {0xffff, 0xffff};
894 char const * pAscii = "reference";
895
896 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(pUnicode, 0, pAscii);
897 CPPUNIT_ASSERT_MESSAGE("ref string is empty, compare failed, needs to be <0.", value < 0);
898 }
899
900 void equal_ascii_shorter()
901 {
902 OUString refStr("referenceString");
903 char const * pAscii = "reference";
904
905 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii);
906 CPPUNIT_ASSERT_MESSAGE("ref string is bigger, compare failed, needs to be >0.", value > 0);
907 }
908
909 void equal_ascii_shorter_asciiLength()
910 {
911 OUString refStr("referenceString");
912 char const * pAscii = "reference";
913
914 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, rtl_str_getLength(pAscii), pAscii);
915 CPPUNIT_ASSERT_MESSAGE("ref string is bigger despite ascii length, compare failed, needs to be == 0.", value == 0);
916 }
917
918 void equal_ref_shorter()
919 {
920 OUString refStr("reference");
921 char const * pAscii = "referenceString";
922
923 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii);
924 CPPUNIT_ASSERT_MESSAGE("ascii string is bigger, but only compared to ref length, needs to be 0.", value < 0);
925 }
926
927 void equal()
928 {
929 OUString refStr("reference");
930 char const * pAscii = "reference";
931
932 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii);
933 CPPUNIT_ASSERT_MESSAGE("strings are equal, compare failed, needs to be 0.", value == 0);
934 }
935
936 void unequal_reference_bigger()
937 {
938 OUString refStr("defghi");
939 char const * pAscii = "abc";
940
941 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii);
942 CPPUNIT_ASSERT_MESSAGE("strings are unequal and ref is bigger, needs to be >0.", value > 0);
943 }
944
945 void unequal_ascii_bigger()
946 {
947 OUString refStr("abc");
948 char const * pAscii = "defghi";
949
950 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii);
951
952 CPPUNIT_ASSERT_MESSAGE("strings are unequal and ascii is bigger, needs to be <0.", value < 0);
953 }
954
955 CPPUNIT_TEST_SUITE(ascii_compare_WithLength);
956 CPPUNIT_TEST(zero_length);
957 CPPUNIT_TEST(equal_ascii_shorter);
958 CPPUNIT_TEST(equal_ascii_shorter_asciiLength);
959 CPPUNIT_TEST(equal_ref_shorter);
960 CPPUNIT_TEST(equal);
961 CPPUNIT_TEST(unequal_reference_bigger);
962 CPPUNIT_TEST(unequal_ascii_bigger);
963 CPPUNIT_TEST_SUITE_END();
964 };
965
966 class ascii_shortenedCompareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture
967 {
968 public:
969
970 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_000()
971 {
972 rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0);
973 // should not GPF
974 }
975
976 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_1()
977 {
978 OUString aStr1("Line must be equal.");
979 rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0);
980 // should not GPF
981 }
982 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_2()
983 {
984 OUString aStr1("Line must be equal.");
985 OString sStr2 = "Line is shorter.";
986 rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), sStr2.getLength(), sStr2.getStr(), 0);
987 // should not GPF
988 }
989 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_001()
990 {
991 OUString suStr1;
992 OString sStr2;
993
994 sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1, 0, sStr2.getStr(), 0);
995 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
996 }
997
998 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_002()
999 {
1000 OUString suStr1("Line must be equal.");
1001 OString sStr2 = "Line must be equal.";
1002
1003 sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr(), sStr2.getLength());
1004 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
1005 }
1006
1007 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_003()
1008 {
1009 OUString suStr1("Line must differ.");
1010 OString sStr2 = "Line must be differ and longer.";
1011
1012 sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr(), sStr2.getLength());
1013 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
1014 }
1015
1016 // Change the following lines only, if you add, remove or rename
1017 // member functions of the current class,
1018 // because these macros are need by auto register mechanism.
1019
1020 CPPUNIT_TEST_SUITE(ascii_shortenedCompareIgnoreAsciiCase_WithLength);
1021 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_000);
1022 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_1);
1023 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_2);
1024 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_001);
1025 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_002);
1026 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_003);
1027 CPPUNIT_TEST_SUITE_END();
1028 }; // class ascii_shortenedCompareIgnoreAsciiCase_WithLength
1029
1030 class ascii_compareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture
1031 {
1032 public:
1033
1034 void ascii_compareIgnoreAsciiCase_WithLength_000()
1035 {
1036 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( NULL, 0, NULL);
1037 // should not GPF
1038 }
1039
1040 void ascii_compareIgnoreAsciiCase_WithLength_000_1()
1041 {
1042 OUString aStr1("Line must be equal.");
1043 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( aStr1.getStr(), 0, NULL);
1044 // should not GPF
1045 }
1046 void ascii_compareIgnoreAsciiCase_WithLength_000_2()
1047 {
1048 OUString aStr1("Line must be equal.");
1049 OString sStr2 = "Line is shorter.";
1050 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( aStr1.getStr(), sStr2.getLength(), sStr2.getStr());
1051 // should not GPF
1052 }
1053 void ascii_compareIgnoreAsciiCase_WithLength_001()
1054 {
1055 OUString suStr1;
1056 OString sStr2;
1057
1058 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1, 0, sStr2.getStr());
1059 CPPUNIT_ASSERT_MESSAGE("compareIgnoreAsciiCase_WithLength failed, strings are equal.", nValue == 0);
1060 }
1061
1062 void ascii_compareIgnoreAsciiCase_WithLength_002()
1063 {
1064 OUString suStr1("Line must be equal.");
1065 OString sStr2 = "Line must be equal.";
1066
1067 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr());
1068 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
1069 }
1070
1071 void ascii_compareIgnoreAsciiCase_WithLength_003()
1072 {
1073 OUString suStr1("Line must differ.");
1074 OString sStr2 = "Line must be differ and longer.";
1075
1076 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr());
1077 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
1078 }
1079
1080 // Change the following lines only, if you add, remove or rename
1081 // member functions of the current class,
1082 // because these macros are need by auto register mechanism.
1083
1084 CPPUNIT_TEST_SUITE(ascii_compareIgnoreAsciiCase_WithLength);
1085 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_000);
1086 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_000_1);
1087 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_000_2);
1088 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_001);
1089 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_002);
1090 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_003);
1091 CPPUNIT_TEST_SUITE_END();
1092 }; // class ascii_compareIgnoreAsciiCase_WithLength
1093
1094 class ascii_compare : public CppUnit::TestFixture
1095 {
1096 public:
1097
1098 void ascii_compare_000()
1099 {
1100 rtl_ustr_ascii_compare( NULL, NULL);
1101 // should not GPF
1102 }
1103
1104 void ascii_compare_000_1()
1105 {
1106 OUString aStr1("Line must be equal.");
1107 rtl_ustr_ascii_compare( aStr1.getStr(), NULL);
1108 // should not GPF
1109 }
1110 void ascii_compare_001()
1111 {
1112 OUString suStr1;
1113 OString sStr2;
1114
1115 sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1, sStr2.getStr());
1116 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
1117 }
1118
1119 void ascii_compare_002()
1120 {
1121 OUString suStr1("Line must be equal.");
1122 OString sStr2 = "Line must be equal.";
1123
1124 sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1.getStr(), sStr2.getStr());
1125 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
1126 }
1127
1128 void ascii_compare_003()
1129 {
1130 OUString suStr1("Line must differ.");
1131 OString sStr2 = "Line foo bar, ok, differ.";
1132
1133 sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1.getStr(), sStr2.getStr());
1134 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
1135 }
1136
1137 // Change the following lines only, if you add, remove or rename
1138 // member functions of the current class,
1139 // because these macros are need by auto register mechanism.
1140
1141 CPPUNIT_TEST_SUITE(ascii_compare);
1142 CPPUNIT_TEST(ascii_compare_000);
1143 CPPUNIT_TEST(ascii_compare_000_1);
1144 CPPUNIT_TEST(ascii_compare_001);
1145 CPPUNIT_TEST(ascii_compare_002);
1146 CPPUNIT_TEST(ascii_compare_003);
1147 CPPUNIT_TEST_SUITE_END();
1148 }; // class ascii_compare
1149
1150 class ascii_compareIgnoreAsciiCase : public CppUnit::TestFixture
1151 {
1152 public:
1153
1154 void ascii_compareIgnoreAsciiCase_000()
1155 {
1156 rtl_ustr_ascii_compareIgnoreAsciiCase( NULL, NULL);
1157 // should not GPF
1158 }
1159
1160 void ascii_compareIgnoreAsciiCase_000_1()
1161 {
1162 OUString aStr1("Line must be equal.");
1163 rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), NULL);
1164 // should not GPF
1165 }
1166 void ascii_compareIgnoreAsciiCase_001()
1167 {
1168 OUString suStr1;
1169 OString sStr2;
1170
1171 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1, sStr2.getStr());
1172 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
1173 }
1174
1175 void ascii_compareIgnoreAsciiCase_002()
1176 {
1177 OUString suStr1("Line must be equal.");
1178 OString sStr2 = "Line must be equal.";
1179
1180 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr());
1181 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
1182 }
1183
1184 void ascii_compareIgnoreAsciiCase_002_1()
1185 {
1186 OUString suStr1("Line must be equal, when ignore case.");
1187 OString sStr2 = "LINE MUST BE EQUAL, WHEN IGNORE CASE.";
1188
1189 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr());
1190 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitive).", nValue == 0);
1191 }
1192
1193 void ascii_compareIgnoreAsciiCase_003()
1194 {
1195 OUString suStr1("Line must differ.");
1196 OString sStr2 = "Line foo bar, ok, differ.";
1197
1198 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr());
1199 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
1200 }
1201
1202 //! LLA: some more tests with some high level strings
1203
1204 // void ascii_compareIgnoreAsciiCase_001()
1205 // {
1206 // OUString suStr1("change this to ascii upper case.");
1207 // OUString aShouldStr1("CHANGE THIS TO ASCII UPPER CASE.");
1208 //
1209 // sal_uInt32 nLength = suStr1.getLength() * sizeof(sal_Unicode);
1210 // sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator
1211 // CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
1212 // memset(pStr, 0, nLength + sizeof(sal_Unicode));
1213 // memcpy(pStr, suStr1.getStr(), nLength);
1214 //
1215 // rtl_ustr_ascii_compareIgnoreAsciiCase( pStr );
1216 // OUString suStr(pStr, suStr1.getLength());
1217 //
1218 // CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == sal_True);
1219 // free(pStr);
1220 // }
1221
1222 // Change the following lines only, if you add, remove or rename
1223 // member functions of the current class,
1224 // because these macros are need by auto register mechanism.
1225
1226 CPPUNIT_TEST_SUITE(ascii_compareIgnoreAsciiCase);
1227 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000);
1228 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000_1);
1229 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_001);
1230 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002);
1231 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002_1);
1232 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_003);
1233 CPPUNIT_TEST_SUITE_END();
1234 }; // class ascii_compareIgnoreAsciiCase
1235
1236 // sample out of inc/rtl/ustring.hxx
1237 // rtl_uString * pToken = NULL;
1238 // sal_Int32 nIndex = 0;
1239 // do
1240 // {
1241 // ...
1242 // nIndex = rtl_uString_getToken(&pToken, pStr, 0, ';', nIndex);
1243 // ...
1244 // }
1245 // while (nIndex >= 0);
1246
1247 class getToken : public CppUnit::TestFixture
1248 {
1249 public:
1250
1251 void getToken_000()
1252 {
1253 rtl_ustr_ascii_compareIgnoreAsciiCase( NULL, NULL);
1254 // should not GPF
1255 }
1256
1257 void ascii_compareIgnoreAsciiCase_000_1()
1258 {
1259 OUString aStr1("Line must be equal.");
1260 rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), NULL);
1261 // should not GPF
1262 }
1263 void ascii_compareIgnoreAsciiCase_001()
1264 {
1265 OUString suStr1;
1266 OString sStr2;
1267
1268 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1, sStr2.getStr());
1269 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
1270 }
1271
1272 void ascii_compareIgnoreAsciiCase_002()
1273 {
1274 OUString suStr1("Line must be equal.");
1275 OString sStr2 = "Line must be equal.";
1276
1277 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr());
1278 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
1279 }
1280
1281 void ascii_compareIgnoreAsciiCase_002_1()
1282 {
1283 OUString suStr1("Line must be equal, when ignore case.");
1284 OString sStr2 = "LINE MUST BE EQUAL, WHEN IGNORE CASE.";
1285
1286 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr());
1287 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitive).", nValue == 0);
1288 }
1289
1290 void ascii_compareIgnoreAsciiCase_003()
1291 {
1292 OUString suStr1("Line must differ.");
1293 OString sStr2 = "Line foo bar, ok, differ.";
1294
1295 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr());
1296 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
1297 }
1298
1299 //! LLA: some more tests with some high level strings
1300
1301 // void ascii_compareIgnoreAsciiCase_001()
1302 // {
1303 // OUString suStr1("change this to ascii upper case.");
1304 // OUString aShouldStr1("CHANGE THIS TO ASCII UPPER CASE.");
1305 //
1306 // sal_uInt32 nLength = suStr1.getLength() * sizeof(sal_Unicode);
1307 // sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator
1308 // CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
1309 // memset(pStr, 0, nLength + sizeof(sal_Unicode));
1310 // memcpy(pStr, suStr1.getStr(), nLength);
1311 //
1312 // rtl_ustr_ascii_compareIgnoreAsciiCase( pStr );
1313 // OUString suStr(pStr, suStr1.getLength());
1314 //
1315 // CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == sal_True);
1316 // free(pStr);
1317 // }
1318
1319 // Change the following lines only, if you add, remove or rename
1320 // member functions of the current class,
1321 // because these macros are need by auto register mechanism.
1322
1323 CPPUNIT_TEST_SUITE(ascii_compareIgnoreAsciiCase);
1324 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000);
1325 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000_1);
1326 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_001);
1327 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002);
1328 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002_1);
1329 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_003);
1330 CPPUNIT_TEST_SUITE_END();
1331 }; // class ascii_compareIgnoreAsciiCase
1332
1333 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::compare);
1334 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::compareIgnoreAsciiCase);
1335
1336 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::ascii_compare_WithLength);
1337
1338 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::shortenedCompareIgnoreAsciiCase_WithLength);
1339 // CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::hashCode);
1340
1341 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::indexOfChar);
1342 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::lastIndexOfChar);
1343 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::indexOfStr);
1344 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::lastIndexOfStr);
1345
1346 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::replaceChar);
1347 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::replaceChar_WithLength);
1348
1349 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::toAsciiLowerCase);
1350 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::toAsciiLowerCase_WithLength);
1351 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::toAsciiUpperCase);
1352 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::toAsciiUpperCase_WithLength);
1353
1354 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::trim_WithLength);
1355 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::valueOfChar);
1356
1357 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::ascii_compare);
1358 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::ascii_compareIgnoreAsciiCase);
1359 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::ascii_compareIgnoreAsciiCase_WithLength);
1360 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_ustr::ascii_shortenedCompareIgnoreAsciiCase_WithLength);
1361
1362 } // namespace rtl_ustr
1363
1364 // this macro creates an empty function, which will called by the RegisterAllFunctions("")
1365 // to let the user the possibility to also register some functions by hand.
1366 CPPUNIT_PLUGIN_IMPLEMENT();
1367
1368 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE