?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merged tag ooo/DEV300_m102
[LibreOffice.git] / sal / qa / rtl_strings / rtl_OString.cxx
blobfc777f11b72331d7308825ca1bcfdc9d18a91833
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2000, 2010 Oracle and/or its affiliates.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * This file is part of OpenOffice.org.
10 *
11 * OpenOffice.org is free software: you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License version 3
13 * only, as published by the Free Software Foundation.
14 *
15 * OpenOffice.org is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License version 3 for more details
19 * (a copy is included in the LICENSE file that accompanied this code).
20 *
21 * You should have received a copy of the GNU Lesser General Public License
22 * version 3 along with OpenOffice.org. If not, see
23 * <http://www.openoffice.org/license.html>
24 * for a copy of the LGPLv3 License.
25 *
26 ************************************************************************/
27
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_sal.hxx"
30 #include <string.h>
31
32 #ifndef _SAL_TYPES_H_
33 #include <sal/types.h>
34 #endif
35
36 // #ifndef _RTL_TRES_H_
37 // #include <rtl/tres.h>
38 // #endif
39
40 #include <testshl/tresstatewrapper.hxx>
41
42 #ifndef _RTL_STRING_HXX_
43 #include <rtl/string.hxx>
44 #endif
45
46 #ifndef _RTL_STRING_CONST_H_
47 #include <rtl_String_Const.h>
48 #endif
49
50 #ifndef _RTL_STRING_UTILS_HXX_
51 #include <rtl_String_Utils.hxx>
52 #endif
53 #include <rtl/ustring.h>
54
55 using namespace rtl;
56
57 //------------------------------------------------------------------------
58 // test classes
59 //------------------------------------------------------------------------
60 const int MAXBUFLENGTH = 255;
61 //------------------------------------------------------------------------
62 // helper functions
63 //------------------------------------------------------------------------
64
65 static void unused()
66 {
67 test_ini_uString();
68 (void)inputChar;
69 (void)input1StrDefault;
70 (void)input1StrNormal;
71 (void)input1StrLastDefault;
72 (void)input1StrLastNormal;
73 unused();
74 }
75
76 //------------------------------------------------------------------------
77 // testing constructors
78 //------------------------------------------------------------------------
79 static sal_Bool test_rtl_OString_ctor_001( hTestResult hRtlTestResult )
80 {
81 ::rtl::OString aStr;
82 rtl_String* pData = aStr.pData;
83
84
85 return
86 (
87 c_rtl_tres_state
88 (
89 hRtlTestResult,
90 pData->length == 0 &&
91 ! *pData->buffer,
92 "New OString containing no characters",
93 "ctor_001"
94 )
95 );
96 }
97
98 //------------------------------------------------------------------------
99
100 static sal_Bool SAL_CALL test_rtl_OString_ctor_002(
101 hTestResult hRtlTestResult )
102 {
103 ::rtl::OString aStr(kTestStr1);
104 rtl_String* pData = aStr.pData;
105
106 return
107 (
108 c_rtl_tres_state
109 (
110 hRtlTestResult,
111 pData->refCount == 1 &&
112 pData->length == kTestStr1Len &&
113 cmpstr( (const sal_Char*)pData->buffer, kTestStr1, kTestStr1Len ),
114 "New OString from a character buffer array",
115 "ctor_002"
116 )
117 );
118 }
119 //------------------------------------------------------------------------
120
121 static sal_Bool SAL_CALL test_rtl_OString_ctor_003(
122 hTestResult hRtlTestResult )
123 {
124 ::rtl::OString aStr(kTestStr2, kTestStr1Len);
125 rtl_String* pData = aStr.pData;
126
127 return
128 (
129 c_rtl_tres_state
130 (
131 hRtlTestResult,
132 pData->refCount == 1 &&
133 pData->length == kTestStr1Len &&
134 cmpstr( (const sal_Char*)pData->buffer, kTestStr2, kTestStr1Len ),
135 "New OString from the first n chars of ascii string",
136 "ctor_003"
137 )
138 );
139 }
140
141 //------------------------------------------------------------------------
142
143 static sal_Bool SAL_CALL test_rtl_OString_ctor_004(
144 hTestResult hRtlTestResult)
145 {
146 ::rtl::OString aStr1(kTestStr1);
147 ::rtl::OString aStr2(aStr1);
148 rtl_String* pData1 = aStr1.pData;
149 rtl_String* pData2 = aStr2.pData;
150
151 return
152 (
153 c_rtl_tres_state
154 (
155 hRtlTestResult,
156 pData1->refCount == pData2->refCount &&
157 pData1->length == kTestStr1Len &&
158 pData1->buffer == pData2->buffer,
159 "New OString from an OString",
160 "ctor_004"
161 )
162 );
163 }
164 //------------------------------------------------------------------------
165
166 static sal_Bool test_rtl_OString_ctor_005( hTestResult hRtlTestResult )
167 {
168 rtl_String *aStr1 = NULL;
169
170 rtl_string_newFromStr( &aStr1, kTestStr1 );
171
172 if ( aStr1 != NULL )
173 {
174 ::rtl::OString aStr2(aStr1);
175 rtl_String* pData2 = aStr2.pData;
176
177 sal_Bool bOK = c_rtl_tres_state
178 (
179 hRtlTestResult,
180 aStr1->refCount == pData2->refCount &&
181 pData2->length == kTestStr1Len &&
182 aStr1->buffer == pData2->buffer,
183 "new OString from a RTL String",
184 "ctor_005"
185 );
186
187 rtl_string_release( aStr1 );
188 aStr1 = NULL;
189 return ( bOK );
190 }
191 return
192 (
193 c_rtl_tres_state
194 (
195 hRtlTestResult,
196 sal_False,
197 "copying an ascii string to a RTL String!",
198 "ctor_005"
199 )
200 );
201 }
202
203 //------------------------------------------------------------------------
204
205 static sal_Bool test_rtl_OString_ctor_006( hTestResult hRtlTestResult )
206 {
207
208 sal_Unicode aStr1[kTestStr1Len+1];
209
210 if ( AStringToUStringNCopy( aStr1, kTestStr1, kTestStr1Len ) )
211 {
212 if ( AStringToUStringNCompare( aStr1, kTestStr1, kTestStr1Len ) == 0 )
213 {
214 // const sal_Char *kTCMessage[2] = { "", "array." };
215
216 ::rtl::OString aStr2
217 (
218 aStr1,
219 kTestStr1Len,
220 kEncodingRTLTextUSASCII,
221 kConvertFlagsOUStringToOString
222 );
223
224 return
225 (
226 c_rtl_tres_state
227 (
228 hRtlTestResult,
229 aStr2 == kTestStr1,
230 "new OString from a unicode character buffer",
231 "ctor_006"
232 )
233 );
234 } /// end if AStringToUStringNCompare
235
236 return
237 (
238 c_rtl_tres_state
239 (
240 hRtlTestResult,
241 sal_False,
242 "compare ascii string with unicode string!",
243 "ctor_006"
244 )
245 );
246 } /// end if AStringToUStringNCopy
247
248 return
249 (
250 c_rtl_tres_state
251 (
252 hRtlTestResult,
253 sal_False,
254 "copy ascii string to unicode string!",
255 "ctor_006"
256 )
257 );
258 }
259 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_ctors(
260 hTestResult hRtlTestResult )
261 {
262
263 c_rtl_tres_state_start(hRtlTestResult, "ctor");
264 sal_Bool bTSState = test_rtl_OString_ctor_001( hRtlTestResult );
265
266 bTSState &= test_rtl_OString_ctor_002( hRtlTestResult);
267 bTSState &= test_rtl_OString_ctor_003( hRtlTestResult);
268 bTSState &= test_rtl_OString_ctor_004( hRtlTestResult);
269 bTSState &= test_rtl_OString_ctor_005( hRtlTestResult);
270 bTSState &= test_rtl_OString_ctor_006( hRtlTestResult);
271
272 c_rtl_tres_state_end(hRtlTestResult, "ctor");
273
274 // return( bTSState );
275 }
276
277
278
279 //------------------------------------------------------------------------
280 // testing the method getLength
281 //------------------------------------------------------------------------
282
283 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_getLength(
284 hTestResult hRtlTestResult)
285 {
286 sal_Char methName[MAXBUFLENGTH];
287 sal_Char* pMeth = methName;
288
289 c_rtl_tres_state_start(hRtlTestResult, "getLength");
290
291 typedef struct TestCase
292 {
293 sal_Char* comments;
294 sal_Int32 expVal;
295 OString* input;
296 ~TestCase() { delete input;}
297 } TestCase;
298
299 TestCase arrTestCase[]={
300
301 {"length of ascii string", kTestStr1Len, new OString(kTestStr1)},
302 {"length of ascci string of size 1", 1, new OString("1")},
303 {"length of empty string (default constructor)", 0, new OString()},
304 {"length of empty string (empty ascii string arg)",0,new OString("")},
305 {"length of empty string (string arg = '\\0')",0,new OString("\0")}
306 };
307
308
309 sal_Bool res = sal_True;
310 sal_uInt32 i;
311
312 for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
313 {
314 sal_Int32 length = arrTestCase[i].input->getLength();
315 sal_Bool lastRes = (length == arrTestCase[i].expVal);
316 c_rtl_tres_state
317 (
318 hRtlTestResult,
319 lastRes,
320 arrTestCase[i].comments,
321 createName( pMeth, "getLength", i )
322
323 );
324 res &= lastRes;
325 }
326 c_rtl_tres_state_end(hRtlTestResult, "getLength");
327 // return ( res );
328 }
329
330
331
332 //------------------------------------------------------------------------
333 // testing the method equals( const OString & aStr )
334 //------------------------------------------------------------------------
335 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_equals(
336 hTestResult hRtlTestResult )
337 {
338 sal_Char methName[MAXBUFLENGTH];
339 sal_Char* pMeth = methName;
340
341 c_rtl_tres_state_start(hRtlTestResult, "equals");
342
343 typedef struct TestCase
344 {
345 sal_Char* comments;
346 sal_Bool expVal;
347 OString* input1;
348 OString* input2;
349 ~TestCase() { delete input1;delete input2;}
350 } TestCase;
351
352 TestCase arrTestCase[]={
353
354 {"same size", sal_True, new OString(kTestStr1),new OString(kTestStr1)},
355 {"different size", sal_False, new OString(kTestStr1),
356 new OString(kTestStr2)},
357 {"same size, no case match", sal_False, new OString(kTestStr1),
358 new OString(kTestStr3)},
359 {"two empty strings(def. constructor)", sal_True, new OString(),
360 new OString()},
361 {"empty(def.constructor) and non empty", sal_False, new OString(),
362 new OString(kTestStr2)},
363 {"non empty and empty(def. constructor)", sal_False,
364 new OString(kTestStr1),new OString()},
365 {"two empty strings(string arg = '\\0')", sal_True,
366 new OString(""),new OString("")},
367 {"empty(string arg = '\\0') and non empty", sal_False,
368 new OString(""),new OString(kTestStr2)},
369 {"non empty and empty(string arg = '\\0')", sal_False,
370 new OString(kTestStr1),new OString("")}
371 };
372
373 sal_Bool res = sal_True;
374 sal_uInt32 i;
375
376 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
377 {
378 sal_Bool lastRes =
379 ( arrTestCase[i].input1->equals(*(arrTestCase[i].input2)) ==
380 arrTestCase[i].expVal );
381
382 c_rtl_tres_state
383 (
384 hRtlTestResult,
385 lastRes,
386 arrTestCase[i].comments,
387 createName( pMeth, "equals", i )
388 );
389
390 res &= lastRes;
391 }
392 c_rtl_tres_state_end(hRtlTestResult, "equals");
393 // return (res);
394 }
395
396 //------------------------------------------------------------------------
397 // testing the method equalsIgnoreAsciiCase( const OString & aStr )
398 //------------------------------------------------------------------------
399
400 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_equalsIgnoreAsciiCase(
401 hTestResult hRtlTestResult )
402 {
403 sal_Char methName[MAXBUFLENGTH];
404 sal_Char* pMeth = methName;
405
406 c_rtl_tres_state_start(hRtlTestResult, "equalsIgnoreAsciiCase");
407 typedef struct TestCase
408 {
409 sal_Char* comments;
410 sal_Bool expVal;
411 OString* input1;
412 OString* input2;
413 ~TestCase() { delete input1;delete input2;}
414 } TestCase;
415
416 TestCase arrTestCase[]={
417 {"same strings but different cases",sal_True,new OString(kTestStr4),
418 new OString(kTestStr5)},
419 {"same strings",sal_True,new OString(kTestStr4),
420 new OString(kTestStr4)},
421 {"with equal beginning",sal_False,new OString(kTestStr2),
422 new OString(kTestStr4)},
423 {"empty(def.constructor) and non empty",sal_False,new OString(),
424 new OString(kTestStr5)},
425 {"non empty and empty(def.constructor)",sal_False,
426 new OString(kTestStr4), new OString()},
427 {"two empty strings(def.constructor)",sal_True,new OString(),
428 new OString()},
429 {"different strings with equal length",sal_False,
430 new OString(kTestStr10), new OString(kTestStr11)}
431 };
432
433 sal_Bool res = sal_True;
434 sal_uInt32 i;
435
436 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
437 {
438 sal_Bool lastRes =
439 (arrTestCase[i].input1->equalsIgnoreAsciiCase(*arrTestCase[i].input2)
440 == arrTestCase[i].expVal);
441
442 c_rtl_tres_state
443 (
444 hRtlTestResult,
445 lastRes,
446 arrTestCase[i].comments,
447 createName( pMeth, "equalsIgnoreAsciiCase", i )
448 );
449
450 res &= lastRes;
451 }
452 c_rtl_tres_state_end(hRtlTestResult, "equalsIgnoreAsciiCase");
453
454 // return (res);
455 }
456
457 static sal_Bool SAL_CALL test_rtl_OString_compareTo_001(
458 hTestResult hRtlTestResult )
459 {
460 sal_Char methName[MAXBUFLENGTH];
461 sal_Char* pMeth = methName;
462
463 typedef struct TestCase
464 {
465 sal_Char* comments;
466 sal_Int32 expVal;
467 OString* input1;
468 OString* input2;
469 ~TestCase() { delete input1;delete input2;}
470 } TestCase;
471
472 TestCase arrTestCase[]={
473
474 {"simple compare, str1 to str5",-1,new OString(kTestStr1),
475 new OString(kTestStr5)},
476 {"simple compare, str2 to str5",-1,new OString(kTestStr2),
477 new OString(kTestStr5)},
478 {"simple compare, str1 to str9",-1,new OString(kTestStr1),
479 new OString(kTestStr9)},
480 {"simple compare, str1 to str2",-1,new OString(kTestStr1),
481 new OString(kTestStr2)},
482 {"simple compare, str4 to str5",-1,new OString(kTestStr4),
483 new OString(kTestStr5)},
484 {"simple compare, str1 to str3",-1,new OString(kTestStr1),
485 new OString(kTestStr3)},
486 {"simple compare, str5 to str1",+1,new OString(kTestStr5),
487 new OString(kTestStr1)},
488 {"simple compare, str2 to str1",+1,new OString(kTestStr2),
489 new OString(kTestStr1)},
490 {"simple compare, str9 to str5",+1,new OString(kTestStr9),
491 new OString(kTestStr5)},
492 {"simple compare, str5 to str4",+1,new OString(kTestStr5),
493 new OString(kTestStr4)},
494 {"simple compare, str1 to str1",0,new OString(kTestStr1),
495 new OString(kTestStr1)},
496 {"simple compare, nullString to nullString",0,new OString(),
497 new OString()},
498 {"simple compare, nullString to str2",-1,new OString(),
499 new OString(kTestStr2)},
500 {"simple compare, str1 to nullString",+1,new OString(kTestStr1),
501 new OString()}
502 };
503
504 sal_Bool res = sal_True;
505 sal_uInt32 i;
506
507 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
508 {
509 sal_Int32 cmpRes =
510 arrTestCase[i].input1->compareTo(*arrTestCase[i].input2);
511 cmpRes = ( cmpRes == 0 ) ? 0 : ( cmpRes > 0 ) ? +1 : -1 ;
512 sal_Bool lastRes = ( cmpRes == arrTestCase[i].expVal);
513
514 c_rtl_tres_state
515 (
516 hRtlTestResult,
517 lastRes,
518 arrTestCase[i].comments,
519 createName( pMeth, "compareTo(const OString&)", i )
520 );
521
522 res &= lastRes;
523 }
524
525 return (res);
526 }
527
528
529 //------------------------------------------------------------------------
530 // testing the method compareTo( const OString & rObj, sal_Int32 length )
531 //------------------------------------------------------------------------
532 static sal_Bool SAL_CALL test_rtl_OString_compareTo_002(
533 hTestResult hRtlTestResult )
534 {
535 sal_Char methName[MAXBUFLENGTH];
536 sal_Char* pMeth = methName;
537
538 typedef struct TestCase
539 {
540 sal_Char* comments;
541 sal_Int32 expVal;
542 sal_Int32 maxLength;
543 OString* input1;
544 OString* input2;
545 ~TestCase() { delete input1;delete input2;}
546 } TestCase;
547
548 TestCase arrTestCase[] =
549 {
550 {"compare with maxlength, str1 to str9, 16",-1,16,
551 new OString(kTestStr1), new OString(kTestStr9)},
552 {"compare with maxlength, str2 to str9, 32",-1,32,
553 new OString(kTestStr2), new OString(kTestStr9)},
554 {"compare with maxlength, str9 to str4, 16",+1,16,
555 new OString(kTestStr9), new OString(kTestStr4)},
556 {"compare with maxlength, str9 to str22, 32",+1,32,
557 new OString(kTestStr9), new OString(kTestStr22)},
558 {"compare with maxlength, str9 to str5, 16",0,16,
559 new OString(kTestStr9), new OString(kTestStr5)},
560 {"compare with maxlength, str9 to str9, 32",0,32,
561 new OString(kTestStr9), new OString(kTestStr9)},
562 {"compare with maxlength, str1 to str2, 32",-1,32,
563 new OString(kTestStr1), new OString(kTestStr2)},
564 {"compare with maxlength, str1 to str2, 32",-1,32,
565 new OString(kTestStr1), new OString(kTestStr2)}
566 };
567
568 sal_Bool res = sal_True;
569 sal_uInt32 i;
570
571 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
572 {
573 sal_Int32 cmpRes =
574 arrTestCase[i].input1->compareTo(*arrTestCase[i].input2,
575 arrTestCase[i].maxLength);
576 cmpRes = (cmpRes == 0) ? 0 : (cmpRes > 0) ? +1 : -1 ;
577 sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal);
578
579 c_rtl_tres_state
580 (
581 hRtlTestResult,
582 lastRes,
583 arrTestCase[i].comments,
584 createName( pMeth, "compareTo(const OString&, sal_Int32)", i )
585 );
586
587 res &= lastRes;
588 }
589
590 return (res);
591 }
592
593 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_compareTo(
594 hTestResult hRtlTestResult )
595 {
596 c_rtl_tres_state_start(hRtlTestResult, "compareTo");
597 sal_Bool res = test_rtl_OString_compareTo_001(hRtlTestResult);
598 res &= test_rtl_OString_compareTo_002(hRtlTestResult);
599 c_rtl_tres_state_end(hRtlTestResult, "compareTo");
600 // return (res);
601 }
602
603 //------------------------------------------------------------------------
604 // testing the operator == ( const OString& rStr1, const OString& rStr2 )
605 // testing the operator == ( const OString& rStr1, const sal_Char *rStr2 )
606 // testing the operator == ( const sal_Char *rStr1, const OString& rStr2 )
607 //------------------------------------------------------------------------
608 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_cmp(
609 hTestResult hRtlTestResult )
610 {
611 c_rtl_tres_state_start(hRtlTestResult, "op_cmp");
612 const sal_Int16 NCASES = 7;
613 sal_Char methName[MAXBUFLENGTH];
614 sal_Char* pMeth = methName;
615 const sal_Char *arrOStr[NCASES][2] =
616 {
617 {kTestStr1, kTestStr1},
618 {kTestStr1, kTestStr3},
619 {kTestStr1, kTestStr2},
620 {0, 0},
621 {0, kTestStr2},
622 {kTestStr1, 0},
623 {"", ""}
624 };
625
626 sal_Bool arrExpVal[NCASES] =
627 {
628 sal_True,
629 sal_False,
630 sal_False,
631 sal_True,
632 sal_False,
633 sal_False,
634 sal_True
635 };
636
637 sal_Char *arrComments[NCASES] =
638 {
639 "'Sun Microsystems'=='Sun Microsystems'",
640 "!('Sun Microsystems'=='Sun microsystems')",
641 "!('Sun Microsystems'=='Sun Microsystems Java Technology')",
642 "two empty strings(def.constructor)",
643 "!(empty string=='Sun Microsystems Java Technology')",
644 "!('Sun Microsystems Java Technology'==empty string)",
645 "''==''"
646 };
647
648 sal_Bool res = sal_True;
649 sal_Int32 i;
650
651 for(i = 0; i < NCASES; i++)
652 {
653 OString *str1, *str2;
654 str1 = (arrOStr[i][0]) ? new OString(arrOStr[i][0]) : new OString() ;
655 str2 = (arrOStr[i][1]) ? new OString(arrOStr[i][1]) : new OString() ;
656
657 sal_Bool cmpRes = (*str1 == *str2);
658 sal_Bool lastRes = (cmpRes == arrExpVal[i]);
659 res &= lastRes;
660
661 c_rtl_tres_state
662 (
663 hRtlTestResult,
664 lastRes,
665 arrComments[i],
666 createName( pMeth, "operator ==(OString&, OString&)", i )
667 );
668
669 cmpRes = (*str1 == arrOStr[i][1]);
670 lastRes = (cmpRes == arrExpVal[i]);
671 res &= lastRes;
672 c_rtl_tres_state
673 (
674 hRtlTestResult,
675 lastRes,
676 arrComments[i],
677 createName( pMeth, "operator ==(OString&, sal_Char *)", i )
678 );
679
680 cmpRes = (arrOStr[i][0] == *str2);
681 lastRes = (cmpRes == arrExpVal[i]);
682 res &= lastRes;
683 c_rtl_tres_state
684 (
685 hRtlTestResult,
686 lastRes,
687 arrComments[i],
688 createName( pMeth, "operator ==(sal_Char *, OString&)", i )
689 );
690
691 delete str2;
692 delete str1;
693 }
694
695 c_rtl_tres_state_end(hRtlTestResult, "op_cmp");
696 // return ( res );
697 }
698
699 //------------------------------------------------------------------------
700 // testing the operator != (const OString& rStr1, const OString& rStr2)
701 // testing the operator != (const OString& rStr1, const sal_Char *rStr2)
702 // testing the operator != (const sal_Char *rStr1, const OString& rStr2)
703 //------------------------------------------------------------------------
704 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_neq(
705 hTestResult hRtlTestResult )
706 {
707 c_rtl_tres_state_start(hRtlTestResult, "op_neq");
708 const sal_Int16 NCASES = 6;
709 sal_Char methName[MAXBUFLENGTH];
710 sal_Char* pMeth = methName;
711
712 const sal_Char *arrOStr[NCASES][2] =
713 {
714 {kTestStr1, kTestStr3},
715 {kTestStr1, kTestStr2},
716 {kTestStr1, kTestStr1},
717 {0, kTestStr2},
718 {kTestStr1, 0},
719 {0, 0}
720 };
721
722 sal_Bool arrExpVal[NCASES] =
723 {
724 sal_True,
725 sal_True,
726 sal_False,
727 sal_True,
728 sal_True,
729 sal_False
730 };
731
732 sal_Char *arrComments[NCASES] =
733 {
734 "'Sun Microsystems'!='Sun microsystems'",
735 "'Sun Microsystems'!='Sun Microsystems Java Technology'",
736 "!('Sun Microsystems'!='Sun Microsystems')",
737 "empty string!='Sun Microsystems Java Technology'",
738 "'Sun Microsystems Java Technology'!=empty string", "!(''!='')"
739 };
740
741 sal_Bool res = sal_True;
742 sal_Int32 i;
743
744 for(i = 0; i < NCASES; i++)
745 {
746 OString *str1, *str2;
747 str1 = (arrOStr[i][0]) ? new OString(arrOStr[i][0]) : new OString() ;
748 str2 = (arrOStr[i][1]) ? new OString(arrOStr[i][1]) : new OString() ;
749
750 sal_Bool cmpRes = (*str1 != *str2);
751 sal_Bool lastRes = (cmpRes == arrExpVal[i]);
752 res &= lastRes;
753 c_rtl_tres_state
754 (
755 hRtlTestResult,
756 lastRes,
757 arrComments[i],
758 createName( pMeth, "operator !=(OString&, OString&)", i )
759 );
760
761 cmpRes = (*str1 != arrOStr[i][1]);
762 lastRes = (cmpRes == arrExpVal[i]);
763 res &= lastRes;
764 c_rtl_tres_state
765 (
766 hRtlTestResult,
767 lastRes,
768 arrComments[i],
769 createName( pMeth, "operator !=(OString&, sal_Char *)", i )
770 );
771
772 cmpRes = (arrOStr[i][0] != *str2);
773 lastRes = (cmpRes == arrExpVal[i]);
774 res &= lastRes;
775 c_rtl_tres_state
776 (
777 hRtlTestResult,
778 lastRes,
779 arrComments[i],
780 createName( pMeth, "operator !=(sal_Char *, OString&)", i )
781 );
782
783 delete str2;
784 delete str1;
785 }
786
787 c_rtl_tres_state_end(hRtlTestResult, "op_neq");
788 // return ( res );
789 }
790
791
792 //------------------------------------------------------------------------
793 // testing the operator > (const OString& rStr1, const OString& rStr2)
794 //------------------------------------------------------------------------
795 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_g(
796 hTestResult hRtlTestResult )
797 {
798 sal_Char methName[MAXBUFLENGTH];
799 sal_Char* pMeth = methName;
800
801 c_rtl_tres_state_start(hRtlTestResult, "op_g");
802 typedef struct TestCase
803 {
804 sal_Char* comments;
805 sal_Bool expVal;
806 OString* input1;
807 OString* input2;
808 ~TestCase() { delete input1;delete input2;}
809 } TestCase;
810
811 TestCase arrTestCase[] =
812 {
813 { "'Sun microsystems'>'Sun Microsystems'",sal_True,
814 new OString(kTestStr3), new OString(kTestStr1)},
815 {"!('Sun Microsystems'>'Sun microsystems')",sal_False,
816 new OString(kTestStr1), new OString(kTestStr3)},
817 {"'Sun Microsystems Java Technology'>'Sun Microsystems'",sal_True,
818 new OString(kTestStr2), new OString(kTestStr1)},
819 {"!('Sun Microsystems'>'Sun Microsystems Java Technology')",sal_False,
820 new OString(kTestStr1), new OString(kTestStr2)},
821 {"!('Sun Microsystems'>'Sun Microsystems'",sal_False,
822 new OString(kTestStr1), new OString(kTestStr1)},
823 {"'Sun Microsystems'>''",sal_True,new OString(kTestStr1),
824 new OString()},
825 {"!(''>'Sun Microsystems')",sal_False,new OString(),
826 new OString(kTestStr1)},
827 {"!(''>'')",sal_False,new OString(), new OString()}
828 };
829
830 sal_Bool res = sal_True;
831 sal_uInt32 i;
832
833 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
834 {
835 sal_Bool cmpRes = (*arrTestCase[i].input1 > *arrTestCase[i].input2);
836 sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal);
837
838 c_rtl_tres_state
839 (
840 hRtlTestResult,
841 lastRes,
842 arrTestCase[i].comments,
843 createName( pMeth, "operator >", i )
844 );
845
846 res &= lastRes;
847
848 }
849
850 c_rtl_tres_state_end(hRtlTestResult, "op_g");
851 // return ( res );
852 }
853
854 //------------------------------------------------------------------------
855 // testing the operator < (const OString& rStr1, const OString& rStr2)
856 //------------------------------------------------------------------------
857
858 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_l(
859 hTestResult hRtlTestResult )
860 {
861 sal_Char methName[MAXBUFLENGTH];
862 sal_Char* pMeth = methName;
863
864 c_rtl_tres_state_start(hRtlTestResult, "op_l");
865 typedef struct TestCase
866 {
867 sal_Char* comments;
868 sal_Bool expVal;
869 OString* input1;
870 OString* input2;
871 ~TestCase() { delete input1;delete input2;}
872 } TestCase;
873
874 TestCase arrTestCase[] =
875 {
876 {"!('Sun microsystems'<'Sun Microsystems')",sal_False,
877 new OString(kTestStr3), new OString(kTestStr1)},
878 {"'Sun Microsystems'<'Sun microsystems'",sal_True,
879 new OString(kTestStr1), new OString(kTestStr3)},
880 {"'Sun Microsystems'<'Sun Microsystems Java Technology'",sal_True,
881 new OString(kTestStr1), new OString(kTestStr2)},
882 {"!('Sun Microsystems Java Technology'<'Sun Microsystems')",sal_False,
883 new OString(kTestStr2), new OString(kTestStr1)},
884 {"!('Sun Microsystems'<'Sun Microsystems'", sal_False,
885 new OString(kTestStr1), new OString(kTestStr1)},
886 {"'Sun Microsystems'<''",sal_False,new OString(kTestStr1),
887 new OString()},
888 {"''<'Sun Microsystems Java Technology'",sal_True,new OString(),
889 new OString(kTestStr2)},
890 {"!(''<'')",sal_False,new OString(), new OString()}
891 };
892
893 sal_Bool res = sal_True;
894 sal_uInt32 i;
895
896 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
897 {
898 sal_Bool cmpRes = (*arrTestCase[i].input1 < *arrTestCase[i].input2);
899 sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal);
900
901 c_rtl_tres_state
902 (
903 hRtlTestResult,
904 lastRes,
905 arrTestCase[i].comments,
906 createName( pMeth, "operator <", i )
907 );
908
909 res &= lastRes;
910
911 }
912
913 c_rtl_tres_state_end(hRtlTestResult, "op_l");
914 // return ( res );
915 }
916
917 //------------------------------------------------------------------------
918 // testing the operator >= (const OString& rStr1, const OString& rStr2)
919 //------------------------------------------------------------------------
920 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_ge(
921 hTestResult hRtlTestResult )
922 {
923 sal_Char methName[MAXBUFLENGTH];
924 sal_Char* pMeth = methName;
925
926 c_rtl_tres_state_start(hRtlTestResult, "op_ge");
927 typedef struct TestCase
928 {
929 sal_Char* comments;
930 sal_Bool expVal;
931 OString* input1;
932 OString* input2;
933 ~TestCase() { delete input1;delete input2;}
934 } TestCase;
935
936 TestCase arrTestCase[] =
937 {
938 {"'Sun microsystems'>='Sun Microsystems'",sal_True,
939 new OString(kTestStr3), new OString(kTestStr1)},
940 {"!('Sun Microsystems'>='Sun microsystems')",sal_False,
941 new OString(kTestStr1), new OString(kTestStr3)},
942 {"!('Sun Microsystems'>='Sun Microsystems Java Technology')",sal_False,
943 new OString(kTestStr1), new OString(kTestStr2)},
944 {"'Sun Microsystems Java Technology'>='Sun Microsystems'",sal_True,
945 new OString(kTestStr2), new OString(kTestStr1)},
946 {"'Sun Microsystems'>='Sun Microsystems'", sal_True,
947 new OString(kTestStr1), new OString(kTestStr1)},
948 {"'Sun Microsystems'>=''",sal_True,new OString(kTestStr1),
949 new OString()},
950 { "''>='Sun microsystems'",sal_False,new OString(),
951 new OString(kTestStr3)},
952 {"''>=''",sal_True,new OString(), new OString()}
953 };
954
955 sal_Bool res = sal_True;
956 sal_uInt32 i;
957
958 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
959 {
960 sal_Bool cmpRes = (*arrTestCase[i].input1 >= *arrTestCase[i].input2);
961 sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal);
962
963 c_rtl_tres_state
964 (
965 hRtlTestResult,
966 lastRes,
967 arrTestCase[i].comments,
968 createName( pMeth, "operator >=", i )
969 );
970
971 res &= lastRes;
972
973 }
974
975 c_rtl_tres_state_end(hRtlTestResult, "op_ge");
976 // return ( res );
977 }
978
979 //------------------------------------------------------------------------
980 // testing the operator <= (const OString& rStr1, const OString& rStr2)
981 //------------------------------------------------------------------------
982 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_le(
983 hTestResult hRtlTestResult )
984 {
985 sal_Char methName[MAXBUFLENGTH];
986 sal_Char* pMeth = methName;
987
988 c_rtl_tres_state_start(hRtlTestResult, "op_le");
989 typedef struct TestCase
990 {
991 sal_Char* comments;
992 sal_Bool expVal;
993 OString* input1;
994 OString* input2;
995 ~TestCase() { delete input1;delete input2;}
996 } TestCase;
997
998 TestCase arrTestCase[] =
999 {
1000 {"!('Sun microsystems'<='Sun Microsystems')",sal_False,
1001 new OString(kTestStr3), new OString(kTestStr1)},
1002 {"'Sun Microsystems'<='Sun microsystems'",sal_True,
1003 new OString(kTestStr1), new OString(kTestStr3)},
1004 {"'Sun Microsystems'<='Sun Microsystems Java Technology'",sal_True,
1005 new OString(kTestStr1),
1006 new OString(kTestStr2)},
1007 {"!('Sun Microsystems Java Technology'<='Sun Microsystems')",sal_False,
1008 new OString(kTestStr2),
1009 new OString(kTestStr1)},
1010 {"!('Sun Microsystems'<='Sun Microsystems'", sal_True,
1011 new OString(kTestStr1), new OString(kTestStr1)},
1012 {"'Sun Microsystems'<=''",sal_False,new OString(kTestStr1),
1013 new OString()},
1014 {"''<='Sun Microsystems Java Technology'",sal_True,new OString(),
1015 new OString(kTestStr2)},
1016 {"!(''<='')",sal_True,new OString(), new OString()}
1017 };
1018
1019 sal_Bool res = sal_True;
1020 sal_uInt32 i;
1021
1022 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1023 {
1024 sal_Bool cmpRes = (*arrTestCase[i].input1 <= *arrTestCase[i].input2);
1025 sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal);
1026
1027 c_rtl_tres_state
1028 (
1029 hRtlTestResult,
1030 lastRes,
1031 arrTestCase[i].comments,
1032 createName( pMeth, "operator <=", i )
1033 );
1034
1035 res &= lastRes;
1036
1037 }
1038
1039 c_rtl_tres_state_end(hRtlTestResult, "op_le");
1040 // return ( res );
1041 }
1042
1043
1044 //------------------------------------------------------------------------
1045 // testing the operator =
1046 //------------------------------------------------------------------------
1047 static sal_Bool test_rtl_OString_op_eq_001( hTestResult hRtlTestResult )
1048 {
1049 sal_Char methName[MAXBUFLENGTH];
1050 sal_Char* pMeth = methName;
1051
1052 typedef struct TestCase
1053 {
1054 sal_Char* comments;
1055 sal_Bool expVal;
1056 OString* input1;
1057 OString* input2;
1058 ~TestCase() { delete input1;delete input2;}
1059 } TestCase;
1060
1061 TestCase arrTestCase[] =
1062 {
1063 {"'' = str1, str1 == str2",sal_True,new OString(kTestStr1),
1064 new OString()},
1065 {"str1 = str2, str1 == str2",sal_True,new OString(kTestStr1),
1066 new OString(kTestStr6)},
1067 {"str2 = '', str1 == str2",sal_True,new OString(),
1068 new OString(kTestStr2)},
1069 {"'' = '', str1 == str2",sal_True,new OString(),
1070 new OString()}
1071 };
1072
1073 sal_Bool res = sal_True;
1074 sal_uInt32 i;
1075
1076 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1077 {
1078 *(arrTestCase[i].input1) = *(arrTestCase[i].input2);
1079
1080 sal_Bool cmpRes =
1081 (*(arrTestCase[i].input1) == *(arrTestCase[i].input2));
1082 sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal);
1083
1084 c_rtl_tres_state
1085 (
1086 hRtlTestResult,
1087 lastRes,
1088 arrTestCase[i].comments,
1089 createName( pMeth, "operator =", i )
1090 );
1091
1092 res &= lastRes;
1093 }
1094
1095 return ( res );
1096 }
1097
1098 static sal_Bool test_rtl_OString_op_eq_002(
1099 hTestResult hRtlTestResult )
1100 {
1101 ::rtl::OString aStr;
1102 aStr = OString(kTestStr1);
1103
1104 return
1105 (
1106 c_rtl_tres_state
1107 (
1108 hRtlTestResult,
1109 aStr == kTestStr1,
1110 "str = OString(\"%s\"), str == \"%s\"",
1111 "operator ="
1112 )
1113 );
1114 }
1115
1116 static sal_Bool test_rtl_OString_op_eq_003(
1117 hTestResult hRtlTestResult )
1118 {
1119 sal_Bool bTCState = false;
1120
1121 ::rtl::OString aStr1(kTestStr1);
1122 ::rtl::OString aStr2;
1123 ::rtl::OString aStr3;
1124
1125 aStr3 = aStr2 = aStr1;
1126
1127 bTCState = ( aStr1 == aStr2 )
1128 && ( aStr1 == aStr3 )
1129 && ( aStr2 == aStr3 );
1130
1131 c_rtl_tres_state
1132 (
1133 hRtlTestResult,
1134 bTCState,
1135 "str3=str2=str1,(str1 == str2)&&(str1 == str3)&&(str2 == str3)",
1136 "operator ="
1137 );
1138
1139 return bTCState;
1140 }
1141
1142 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_eq(
1143 hTestResult hRtlTestResult )
1144 {
1145 c_rtl_tres_state_start(hRtlTestResult, "op_eq");
1146 sal_Bool res = test_rtl_OString_op_eq_001( hRtlTestResult );
1147 res &= test_rtl_OString_op_eq_002( hRtlTestResult );
1148 res &= test_rtl_OString_op_eq_003( hRtlTestResult );
1149 c_rtl_tres_state_end(hRtlTestResult, "op_eq");
1150
1151 // return ( res );
1152 }
1153
1154 //------------------------------------------------------------------------
1155 // testing the operator +
1156 //------------------------------------------------------------------------
1157 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_plus(
1158 hTestResult hRtlTestResult )
1159 {
1160 sal_Char methName[MAXBUFLENGTH];
1161 sal_Char* pMeth = methName;
1162
1163 c_rtl_tres_state_start(hRtlTestResult, "op_plus");
1164 typedef struct TestCase
1165 {
1166 sal_Char* comments;
1167 OString* expVal;
1168 OString* input1;
1169 OString* input2;
1170 ~TestCase() { delete input1;delete input2; delete expVal;}
1171 } TestCase;
1172
1173 TestCase arrTestCase[] =
1174 {
1175 {"str1 = str7 + str8",new OString(kTestStr1),
1176 new OString(kTestStr7), new OString(kTestStr8)},
1177 {"str1 = str1 + '' ",new OString(kTestStr1),
1178 new OString(kTestStr1), new OString("")},
1179 {"str1 = '' + str1", new OString(kTestStr1),
1180 new OString(""), new OString(kTestStr1)},
1181 {" '' = '' + '' ", new OString(""),new OString(""),
1182 new OString("")},
1183 {"str1 = str1 + def.constr", new OString(kTestStr1),
1184 new OString(kTestStr1), new OString()},
1185 {" str1 = def.constr + str1 ",new OString(kTestStr1),
1186 new OString(), new OString(kTestStr1)},
1187 {" def.constr= def.constr + def.constr", new OString(),
1188 new OString(), new OString()}
1189 };
1190
1191 sal_Bool res = sal_True;
1192 sal_uInt32 i;
1193 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1194 {
1195 OString str = (*arrTestCase[i].input1) + (*arrTestCase[i].input2);
1196 sal_Bool lastRes = (str == *arrTestCase[i].expVal);
1197
1198 c_rtl_tres_state
1199 (
1200 hRtlTestResult,
1201 lastRes,
1202 arrTestCase[i].comments,
1203 createName( pMeth, "operator +", i )
1204 );
1205
1206 res &= lastRes;
1207
1208 }
1209
1210 c_rtl_tres_state_end(hRtlTestResult, "op_plus");
1211 // return ( res );
1212 }
1213
1214 //------------------------------------------------------------------------
1215 // testing the operator +=
1216 //------------------------------------------------------------------------
1217 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_peq(
1218 hTestResult hRtlTestResult )
1219 {
1220 sal_Char methName[MAXBUFLENGTH];
1221 sal_Char* pMeth = methName;
1222
1223 c_rtl_tres_state_start(hRtlTestResult, "op_peq");
1224 typedef struct TestCase
1225 {
1226 sal_Char* comments;
1227 OString* expVal;
1228 OString* input1;
1229 OString* input2;
1230 ~TestCase() { delete input1;delete input2; delete expVal;}
1231 } TestCase;
1232
1233 TestCase arrTestCase[] =
1234 {
1235 {"str1 == (str7 += str8)",new OString(kTestStr1),
1236 new OString(kTestStr7), new OString(kTestStr8)},
1237 {"str1 == (str1 += '')",new OString(kTestStr1),
1238 new OString(kTestStr1), new OString("")},
1239 {"str1 == ('' += str1)", new OString(kTestStr1),
1240 new OString(""), new OString(kTestStr1)},
1241 {" '' == ('' += '')", new OString(""),
1242 new OString(""), new OString("")},
1243 {"str1 == (str1 += def.constr)", new OString(kTestStr1),
1244 new OString(kTestStr1), new OString()},
1245 {" str1 == (def.constr += str1)",new OString(kTestStr1),
1246 new OString(), new OString(kTestStr1)},
1247 {" def.constr== (def.constr += def.constr)",
1248 new OString(),new OString(), new OString()}
1249 };
1250
1251 sal_Bool res = sal_True;
1252 sal_uInt32 i;
1253 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1254 { OString str;
1255 str += (*arrTestCase[i].input1); str += (*arrTestCase[i].input2);
1256 sal_Bool lastRes = (str == *arrTestCase[i].expVal);
1257
1258 c_rtl_tres_state
1259 (
1260 hRtlTestResult,
1261 lastRes,
1262 arrTestCase[i].comments,
1263 createName( pMeth, "operator +", i )
1264 );
1265
1266 res &= lastRes;
1267
1268 }
1269
1270 c_rtl_tres_state_end(hRtlTestResult, "op_peq");
1271 // return ( res );
1272 }
1273
1274 //------------------------------------------------------------------------
1275 // testing the operator const sal_Char * (cscs for short)
1276 //------------------------------------------------------------------------
1277 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_cscs(
1278 hTestResult hRtlTestResult )
1279 {
1280 sal_Char methName[MAXBUFLENGTH];
1281 sal_Char* pMeth = methName;
1282
1283 c_rtl_tres_state_start(hRtlTestResult, "op_cscs");
1284 typedef struct TestCase
1285 {
1286 sal_Char* comments;
1287 const sal_Char* expVal;
1288 sal_Int32 cmpLen;
1289 OString* input1;
1290 ~TestCase() { delete input1;}
1291 } TestCase;
1292
1293 TestCase arrTestCase[] =
1294 {
1295 {"test normal string",kTestStr1,kTestStr1Len,new OString(kTestStr1)},
1296 {"test empty string","",1,new OString()}
1297 };
1298
1299 sal_Bool res = sal_True;
1300 sal_uInt32 i;
1301 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1302 {
1303 const sal_Char* pstr = (*arrTestCase[i].input1);
1304
1305 res &= c_rtl_tres_state
1306 (
1307 hRtlTestResult,
1308 cmpstr((sal_Char*)pstr,(sal_Char*)arrTestCase[i].expVal,
1309 arrTestCase[i].cmpLen),
1310 arrTestCase[i].comments,
1311 createName( pMeth, "const sal_Char*", i )
1312 );
1313 }
1314 c_rtl_tres_state_end(hRtlTestResult, "op_cscs");
1315 // return ( res );
1316 }
1317
1318
1319 //------------------------------------------------------------------------
1320 // testing the method getStr()
1321 //------------------------------------------------------------------------
1322
1323
1324 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_getStr(
1325 hTestResult hRtlTestResult )
1326 {
1327 sal_Char methName[MAXBUFLENGTH];
1328 sal_Char* pMeth = methName;
1329
1330 c_rtl_tres_state_start(hRtlTestResult, "getStr");
1331 typedef struct TestCase
1332 {
1333 sal_Char* comments;
1334 const sal_Char* expVal;
1335 sal_Int32 cmpLen;
1336 OString* input1;
1337 ~TestCase() { delete input1;}
1338 } TestCase;
1339
1340 TestCase arrTestCase[] =
1341 {
1342 {"test normal string",kTestStr1,kTestStr1Len,new OString(kTestStr1)},
1343 {"test empty string","",0,new OString()}
1344 };
1345
1346 sal_Bool res = sal_True;
1347 sal_uInt32 i;
1348 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1349 {
1350 const sal_Char* pstr = arrTestCase[i].input1->getStr();
1351 res &= c_rtl_tres_state
1352 (
1353 hRtlTestResult,
1354 cmpstr(pstr, arrTestCase[i].expVal,
1355 arrTestCase[i].cmpLen),
1356 arrTestCase[i].comments,
1357 createName( pMeth, "getStr", i )
1358 );
1359 }
1360 c_rtl_tres_state_end(hRtlTestResult, "getStr");
1361 // return ( res );
1362 }
1363
1364
1365
1366 //------------------------------------------------------------------------
1367 // testing the method copy( sal_Int32 beginIndex )
1368 //------------------------------------------------------------------------
1369 static sal_Bool SAL_CALL test_rtl_OString_copy_001(
1370 hTestResult hRtlTestResult )
1371 {
1372 sal_Char methName[MAXBUFLENGTH];
1373 sal_Char* pMeth = methName;
1374
1375 typedef struct TestCase
1376 {
1377 sal_Char* comments;
1378 const sal_Char* srcStr;
1379 const sal_Char* arrExpStr;
1380 // string for comparing with result
1381 sal_Int32 beginIndex;
1382 // beginIndex for the method copy
1383 sal_Int32 lengthForCmp;
1384 // number of symbols for comparing
1385 // (if value is equal to 0 then pointers to buffers must be equal)
1386 sal_Int32 expLength;
1387 //expected length of the result string
1388 } TestCase;
1389
1390 TestCase arrTestCase[] =
1391 {
1392 {"beginIndex == 0 ( whole string )", kTestStr2,kTestStr2,
1393 0, kTestStr2Len, kTestStr2Len},
1394 {"beginIndex == strlen-2 ( last two char )", kTestStr2,"gy",
1395 kTestStr2Len-2, 2, 2},
1396 {"beginIndex == strlen-1( last char )", kTestStr2, "y",
1397 kTestStr2Len-1, 1, 1}
1398 };
1399
1400 sal_Bool res = sal_True;
1401 sal_uInt32 i;
1402
1403 for(i = 0; i <(sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1404 {
1405 OString src(arrTestCase[i].srcStr);
1406 OString dst;
1407 // rtl_String* pDataSrc = src.pData;
1408
1409 dst = src.copy(arrTestCase[i].beginIndex);
1410
1411 // rtl_String* pDataDst = dst.pData;
1412
1413 sal_Bool lastRes;
1414
1415 lastRes= (dst== arrTestCase[i].arrExpStr);
1416
1417
1418 c_rtl_tres_state
1419 (
1420 hRtlTestResult,
1421 lastRes,
1422 arrTestCase[i].comments,
1423 createName( pMeth,
1424 "copy_001(beginIndex)(check buffer and length)", i )
1425 );
1426
1427 res &= lastRes;
1428
1429 }
1430
1431 return (res);
1432 }
1433
1434
1435 //------------------------------------------------------------------------
1436 // testing the method copy( sal_Int32 beginIndex, sal_Int32 count )
1437 //------------------------------------------------------------------------
1438 static sal_Bool SAL_CALL test_rtl_OString_copy_002(
1439 hTestResult hRtlTestResult )
1440 {
1441 sal_Char methName[MAXBUFLENGTH];
1442 sal_Char* pMeth = methName;
1443
1444 typedef struct TestCase
1445 {
1446 sal_Char* comments;
1447 const sal_Char* arrExpStr;
1448 sal_Int32 beginIndex;
1449 sal_Int32 count;
1450 sal_Int32 expLen;
1451
1452 } TestCase;
1453
1454 TestCase arrTestCase[] ={
1455
1456 {"copy substring", kTestStr6, kTestStr11Len, kTestStr2Len - kTestStr11Len,kTestStr6Len},
1457 /* LLA: it is a bug, beginIndex + count > kTestStr2.getLength() */
1458 /* {"copy normal substring with incorrect count",kTestStr6, kTestStr11Len, 31, 15}, */
1459 {"copy whole string", kTestStr2, 0, kTestStr2Len, kTestStr2Len},
1460 /* {"copy whole string with incorrect count larger than len and index 0", kTestStr2, 0, 40, 32}, */
1461 /* LLA: bug beginIndex + count > kTestStr2 {"copy last character", "y",kTestStr2Len - 1, 31,1}, */
1462 {"copy last character", "y",kTestStr2Len - 1, 1,1},
1463 /* LLA: bug, beginIndex > kTestStr2 {"beginindex larger than len","",60, 0,0}, */
1464 {"beginindex exact as large as it's length","",kTestStr2Len, 0,0}
1465 /* LLA: bug, negative count is not allowed. {"count is nagative int","",3, -1,0} */
1466 };
1467 sal_Bool res = sal_True;
1468
1469 sal_uInt32 i;
1470 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) {
1471 OString src(kTestStr2);
1472 OString dst;
1473 dst = src.copy(arrTestCase[i].beginIndex, arrTestCase[i].count);
1474 // rtl_String* pDataSrc = src.pData;
1475 // rtl_String* pDataDst = dst.pData;
1476
1477 sal_Bool lastRes=sal_True;
1478 // checks buffer and length
1479 //t_print("this is copy__002 #%d\n", i);
1480 //t_print("dst buffer =%s\n", pDataDst->buffer);
1481 //t_print("expStr =%s\n", arrTestCase[i].arrExpStr);
1482 //t_print("dst length =%d\n", pDataDst->length);
1483 //t_print("count =%d\n", arrTestCase[i].count);
1484 //t_print("expLen =%d\n", arrTestCase[i].expLen);
1485
1486 lastRes = (dst.equals(arrTestCase[i].arrExpStr)) ? sal_True : sal_False;
1487
1488 c_rtl_tres_state
1489 (
1490 hRtlTestResult,
1491 lastRes,
1492 arrTestCase[i].comments,
1493 createName( pMeth,
1494 "copy_002(beginIndex,count)(check buffer and length)", i)
1495 );
1496 res &= lastRes;
1497
1498
1499 }
1500
1501 return (res);
1502 }
1503
1504
1505 static sal_Bool SAL_CALL test_rtl_OString_copy_003(
1506 hTestResult hRtlTestResult )
1507 {
1508 sal_Bool res = sal_True;
1509 char comment[] = "copy whole short string to long string";
1510
1511 OString src(kTestStr1);
1512 // rtl_String* pDataSrc = src.pData;
1513 OString dst(kTestStr2);
1514
1515 dst = src.copy(0);
1516 // rtl_String* pDataDst = dst.pData;
1517 //check buffer and length
1518 sal_Bool lastRes =(dst==src);
1519 c_rtl_tres_state
1520 (
1521 hRtlTestResult,
1522 lastRes,
1523 comment,
1524 "copy_003(beginIndex)(check buffer and length)"
1525 );
1526 res &= lastRes;
1527
1528 return (res);
1529 }
1530
1531
1532 static sal_Bool SAL_CALL test_rtl_OString_copy_004(
1533 hTestResult hRtlTestResult )
1534 {
1535 sal_Bool res = sal_True;
1536 sal_Char comment[] = "copy whole long string to short string";
1537
1538 OString src(kTestStr2);
1539 // rtl_String* pDataSrc = src.pData;
1540 OString dst(kTestStr1);
1541
1542 dst = src.copy(0);
1543 // rtl_String* pDataDst = dst.pData;
1544 //check buffer and length
1545 sal_Bool lastRes =(dst==src);
1546 c_rtl_tres_state
1547 (
1548 hRtlTestResult,
1549 lastRes,
1550 comment,
1551 "copy_004(beginIndex)(check buffer and length)"
1552 );
1553
1554 res &= lastRes;
1555 return (res);
1556 }
1557
1558 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_copy(
1559 hTestResult hRtlTestResult )
1560 {
1561 c_rtl_tres_state_start(hRtlTestResult, "copy");
1562 sal_Bool res = test_rtl_OString_copy_001(hRtlTestResult);
1563 res &= test_rtl_OString_copy_002(hRtlTestResult);
1564 res &= test_rtl_OString_copy_003(hRtlTestResult);
1565 res &= test_rtl_OString_copy_004(hRtlTestResult);
1566 c_rtl_tres_state_end(hRtlTestResult, "copy");
1567
1568 // return ( res );
1569 }
1570
1571 //------------------------------------------------------------------------
1572 // testing the method concat( const OString & aStr )
1573 //------------------------------------------------------------------------
1574 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_concat(
1575 hTestResult hRtlTestResult )
1576 {
1577 sal_Char methName[MAXBUFLENGTH];
1578 sal_Char* pMeth =methName;
1579
1580 c_rtl_tres_state_start(hRtlTestResult, "concat");
1581 typedef struct TestCase
1582 {
1583 sal_Char* comments;
1584 OString* expVal;
1585 OString* input1;
1586 OString* input2;
1587 ~TestCase() { delete input1;delete input2; delete expVal;}
1588 } TestCase;
1589
1590 TestCase arrTestCase[] =
1591 {
1592 {"concatenates two strings",new OString(kTestStr1),
1593 new OString(kTestStr7),
1594 new OString(kTestStr8)},
1595 {"concatenates empty string",new OString(kTestStr1),
1596 new OString(kTestStr1),
1597 new OString("")},
1598 {"concatenates to empty string",new OString(kTestStr1),
1599 new OString(""),
1600 new OString(kTestStr1)},
1601 {"concatenates two empty strings",new OString(""),new OString(""),
1602 new OString("")},
1603 {"concatenates string constructed by default constructor",
1604 new OString(kTestStr1),
1605 new OString(kTestStr1), new OString()},
1606 {"concatenates to string constructed by default constructor",
1607 new OString(kTestStr1),
1608 new OString(), new OString(kTestStr1)},
1609 {"concatenates two strings constructed by default constructor",
1610 new OString(),
1611 new OString(), new OString()}
1612 };
1613
1614 sal_Bool res = sal_True;
1615 sal_uInt32 i;
1616 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1617 {
1618 OString str =
1619 arrTestCase[i].input1->concat(*arrTestCase[i].input2);
1620 sal_Bool lastRes = (str == *arrTestCase[i].expVal);
1621
1622 c_rtl_tres_state
1623 (
1624 hRtlTestResult,
1625 lastRes,
1626 arrTestCase[i].comments,
1627 createName( pMeth, "concat", i)
1628 );
1629
1630 res &= lastRes;
1631
1632 }
1633
1634 c_rtl_tres_state_end(hRtlTestResult, "concat");
1635 // return ( res );
1636 }
1637
1638
1639 //------------------------------------------------------------------------
1640 // testing the method toAsciiLowerCase()
1641 //-----------------------------------------------------------------------
1642 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toAsciiLowerCase(
1643 hTestResult hRtlTestResult )
1644 {
1645 sal_Char methName[MAXBUFLENGTH];
1646 sal_Char* pMeth =methName;
1647
1648 c_rtl_tres_state_start(hRtlTestResult, "toAsciiLowerCase");
1649 typedef struct TestCase
1650 {
1651 sal_Char* comments;
1652 OString* expVal;
1653 OString* input1;
1654 ~TestCase() { delete input1; delete expVal;}
1655 } TestCase;
1656
1657 TestCase arrTestCase[] =
1658 {
1659
1660 {"only uppercase",new OString(kTestStr5),new OString(kTestStr4)},
1661 {"different cases",new OString(kTestStr5),new OString(kTestStr1)},
1662 {"different cases",new OString(kTestStr5),new OString(kTestStr3)},
1663 {"only lowercase",new OString(kTestStr5),new OString(kTestStr5)},
1664 {"empty string",new OString(""),new OString("")},
1665 {"string constructed by default constructor",
1666 new OString(),new OString()}
1667 };
1668
1669 sal_Bool res = sal_True;
1670 sal_uInt32 i;
1671
1672 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1673 {
1674 OString str = arrTestCase[i].input1->toAsciiLowerCase();
1675 sal_Bool lastRes = (str ==* arrTestCase[i].expVal);
1676
1677 c_rtl_tres_state
1678 (
1679 hRtlTestResult,
1680 lastRes,
1681 arrTestCase[i].comments,
1682 createName( pMeth, "toAsciiLowerCase", i)
1683 );
1684
1685 res &= lastRes;
1686 }
1687
1688 c_rtl_tres_state_end(hRtlTestResult, "toAsciiLowerCase");
1689 // return ( res );
1690 }
1691
1692 //------------------------------------------------------------------------
1693 // testing the method toAsciiUpperCase()
1694 //------------------------------------------------------------------------
1695 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toAsciiUpperCase(
1696 hTestResult hRtlTestResult )
1697 {
1698 sal_Char methName[MAXBUFLENGTH];
1699 sal_Char* pMeth =methName;
1700
1701 c_rtl_tres_state_start(hRtlTestResult, "toAsciiUpperCase");
1702 typedef struct TestCase
1703 {
1704 sal_Char* comments;
1705 OString* expVal;
1706 OString* input1;
1707 ~TestCase() { delete input1; delete expVal;}
1708 } TestCase;
1709
1710 TestCase arrTestCase[] =
1711 {
1712 {"only lowercase",new OString(kTestStr4),new OString(kTestStr5)},
1713 {"mixed cases",new OString(kTestStr4),new OString(kTestStr3)},
1714 {"miced cases",new OString(kTestStr4),new OString(kTestStr1)},
1715 {"only uppercase",new OString(kTestStr4),new OString(kTestStr4)},
1716 {"empty string",new OString(""),new OString("")},
1717 {"string constructed by default constructor",
1718 new OString(),new OString()}
1719 };
1720
1721 sal_Bool res = sal_True;
1722 sal_uInt32 i;
1723
1724 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1725 {
1726 OString str = arrTestCase[i].input1->toAsciiUpperCase();
1727 sal_Bool lastRes = (str == *arrTestCase[i].expVal);
1728
1729 c_rtl_tres_state
1730 (
1731 hRtlTestResult,
1732 lastRes,
1733 arrTestCase[i].comments,
1734 createName( pMeth, "toAsciiLowerCase", i)
1735 );
1736
1737 res &= lastRes;
1738 }
1739 c_rtl_tres_state_end(hRtlTestResult, "toAsciiUpperCase");
1740
1741 // return ( res );
1742 }
1743
1744
1745 //------------------------------------------------------------------------
1746 // testing the method trim()
1747 //------------------------------------------------------------------------
1748 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_trim(
1749 hTestResult hRtlTestResult )
1750 {
1751 sal_Char methName[MAXBUFLENGTH];
1752 sal_Char* pMeth =methName;
1753
1754 c_rtl_tres_state_start(hRtlTestResult, "trim");
1755 typedef struct TestCase
1756 {
1757 sal_Char* comments;
1758 OString* expVal;
1759 OString* input1;
1760 ~TestCase() { delete input1; delete expVal;}
1761 } TestCase;
1762
1763 TestCase arrTestCase[] =
1764 {
1765 {"removes space from the front",new OString(kTestStr1),
1766 new OString(kTestStr10)},
1767 {"removes space from the end",new OString(kTestStr1),
1768 new OString(kTestStr11)},
1769 {"removes space from the front and end",new OString(kTestStr1),
1770 new OString(kTestStr12)},
1771 {"removes several spaces from the end",new OString(kTestStr1),
1772 new OString(kTestStr13)},
1773 {"removes several spaces from the front",new OString(kTestStr1),
1774 new OString(kTestStr14)},
1775 {"removes several spaces from the front and one from the end",
1776 new OString(kTestStr1),
1777 new OString(kTestStr15)},
1778 {"removes one space from the front and several from the end",
1779 new OString(kTestStr1),
1780 new OString(kTestStr16)},
1781 {"removes several spaces from the front and end",
1782 new OString(kTestStr1),
1783 new OString(kTestStr17)},
1784 {"removes characters that have codes <= 32",new OString(kTestStr20),
1785 new OString("\1\3\5\7\11\13\15\17sun\21\23\25\27\31\33\40")},
1786 {"no spaces",new OString(kTestStr8),new OString(kTestStr8)}
1787 };
1788
1789 sal_Bool res = sal_True;
1790 sal_uInt32 i;
1791
1792 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1793 {
1794 OString strRes = arrTestCase[i].input1->trim();
1795 sal_Bool lastRes = (strRes == *arrTestCase[i].expVal);
1796
1797 c_rtl_tres_state
1798 (
1799 hRtlTestResult,
1800 lastRes,
1801 arrTestCase[i].comments,
1802 createName( pMeth, "trim", i)
1803 );
1804
1805 res &= lastRes;
1806
1807 }
1808
1809 c_rtl_tres_state_end(hRtlTestResult, "trim");
1810 // return ( res );
1811 }
1812
1813
1814
1815 //------------------------------------------------------------------------
1816 // testing the method valueOf( sal_Bool b )
1817 //------------------------------------------------------------------------
1818 sal_Bool SAL_CALL test_rtl_OString_valueOf_sal_Bool(
1819 hTestResult hRtlTestResult )
1820 {
1821 sal_Char methName[MAXBUFLENGTH];
1822 sal_Char* pMeth =methName;
1823
1824 typedef struct TestCase
1825 {
1826 sal_Char* comments;
1827 sal_Bool input1;
1828 OString* expVal;
1829 ~TestCase() {delete expVal;}
1830 } TestCase;
1831
1832 TestCase arrTestCase[] =
1833 {
1834 {"true",sal_True,new OString("true")},
1835 {"false",sal_False, new OString("false")}
1836 };
1837
1838 sal_Bool res = sal_True;
1839 sal_uInt32 i;
1840
1841 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1842 {
1843 ::rtl::OString aStr1;
1844 aStr1 = aStr1.valueOf( arrTestCase[i].input1 );
1845 sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0);
1846
1847 c_rtl_tres_state
1848 (
1849 hRtlTestResult,
1850 lastRes,
1851 arrTestCase[i].comments,
1852 createName( pMeth, "valueof_bool", i)
1853 );
1854
1855 res &= lastRes;
1856
1857 }
1858
1859 return ( res );
1860 }
1861
1862 sal_Bool SAL_CALL test_rtl_OString_valueOf_sal_Char(
1863 hTestResult hRtlTestResult )
1864 {
1865 sal_Char methName[MAXBUFLENGTH];
1866 sal_Char* pMeth =methName;
1867
1868 typedef struct TestCase
1869 {
1870 sal_Char* comments;
1871 sal_Char input1;
1872 OString* expVal;
1873 ~TestCase() {delete expVal;}
1874 } TestCase;
1875
1876 TestCase arrTestCase[] =
1877 {
1878 {"A",'A',new OString("A")},
1879 {"a",'a', new OString("a")},
1880 {"0",'0', new OString("0")},
1881 {"-",'-', new OString("-")},
1882 {"_",'_', new OString("_")},
1883 {"|",'|', new OString("|")},
1884 {"?",'?', new OString("?")},
1885 {"?",'?', new OString("?")},
1886 {"\n",'\n', new OString("\n")},
1887 {"\'",'\'', new OString("\'")},
1888 {"\"",'\"', new OString("\"")}
1889
1890 };
1891
1892 sal_Bool res = sal_True;
1893 sal_uInt32 i;
1894
1895 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
1896 {
1897 ::rtl::OString aStr1;
1898 aStr1 = aStr1.valueOf( arrTestCase[i].input1 );
1899 sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0);
1900
1901 c_rtl_tres_state
1902 (
1903 hRtlTestResult,
1904 lastRes,
1905 arrTestCase[i].comments,
1906 createName( pMeth, "valueof_char", i)
1907 );
1908
1909 res &= lastRes;
1910
1911 }
1912
1913 return ( res );
1914 }
1915
1916 /**
1917 * Calls the method valueOf(T, radix) and compares
1918 * returned strings with strings that passed in the array resArray.
1919 *
1920 * @param T, type of argument, passed to valueOf
1921 * @param resArray, array of result strings to compare to
1922 * @param n the number of elements in the array resArray (testcases)
1923 * @param pTestResult the instance of the class TestResult
1924 * @param inArray [optional], array of value that is passed as first argument
1925 * to valueOf
1926 *
1927 * @return true, if all returned strings are equal to corresponding string in
1928 * resArray else, false.
1929 */
1930 template <class T>
1931 sal_Bool test_valueOf( const char** resArray, int n, sal_Int16 radix,
1932 hTestResult hRtlTestResult, const T *inArray )
1933 {
1934 sal_Bool bRes = sal_True;
1935
1936 sal_Char methName[MAXBUFLENGTH];
1937 sal_Char* pMeth = methName;
1938 sal_Int32 i;
1939
1940 for (i = 0; i < n; i++)
1941 {
1942 ::rtl::OString aStr1;
1943 ::rtl::OString aStr2( resArray[i] );
1944
1945 if (inArray == 0)
1946 aStr1 = ::rtl::OString::valueOf((T)i, radix);
1947 else
1948 {
1949 if ( inArray[i] < 0 )
1950 {
1951 aStr2 = "-";
1952 aStr2 += resArray[i];
1953 }
1954 aStr1 = ::rtl::OString::valueOf((T)inArray[i], radix);
1955 }
1956
1957 bRes &= c_rtl_tres_state
1958 (
1959 hRtlTestResult,
1960 aStr2.compareTo(aStr1) == 0,
1961 (sal_Char*)resArray[i],
1962 createName( pMeth, "valueOf", i )
1963 );
1964 }
1965
1966 return (bRes);
1967 }
1968
1969
1970 #define test_valueOf_Int32 test_valueOf<sal_Int32>
1971 #define test_valueOf_Int64 test_valueOf<sal_Int64>
1972 // LLA: #define test_valueOf_float test_valueOf<float>
1973 // LLA: #define test_valueOf_double test_valueOf<double>
1974
1975 //------------------------------------------------------------------------
1976 // testing the method valueOf( sal_Int32 i, sal_Int16 radix=2 )
1977 // testing the method valueOf( sal_Int32 i, sal_Int16 radix=8 )
1978 // testing the method valueOf( sal_Int32 i, sal_Int16 radix=10 )
1979 // testing the method valueOf( sal_Int32 i, sal_Int16 radix=16 )
1980 // testing the method valueOf( sal_Int32 i, sal_Int16 radix=36 )
1981 //------------------------------------------------------------------------
1982 sal_Bool SAL_CALL test_rtl_OString_valueOf_Int32(
1983 hTestResult hRtlTestResult )
1984 {
1985 sal_Bool bRes = sal_False;
1986
1987 bRes = c_rtl_tres_state
1988 (
1989 hRtlTestResult,
1990 test_valueOf_Int32((const char**)kBinaryNumsStr,
1991 kBinaryNumsCount, kRadixBinary, hRtlTestResult, 0 ),
1992 "kRadixBinary",
1993 "valueOf(sal_Int32, radix 2)"
1994 );
1995
1996
1997 bRes &= c_rtl_tres_state
1998 (
1999 hRtlTestResult,
2000 test_valueOf_Int32((const char**)kOctolNumsStr,
2001 kOctolNumsCount, kRadixOctol, hRtlTestResult, 0),
2002 "kRadixOctol",
2003 "valueOf(sal_Int32, radix 8)"
2004 );
2005
2006 bRes &= c_rtl_tres_state
2007 (
2008 hRtlTestResult,
2009 test_valueOf_Int32((const char**)kDecimalNumsStr,
2010 kDecimalNumsCount, kRadixDecimal, hRtlTestResult, 0),
2011 "kRadixDecimal",
2012 "valueOf(sal_Int32, radix 10)"
2013 );
2014
2015 bRes &= c_rtl_tres_state
2016 (
2017 hRtlTestResult,
2018 test_valueOf_Int32((const char**)kHexDecimalNumsStr,
2019 kHexDecimalNumsCount, kRadixHexdecimal, hRtlTestResult, 0),
2020 "kRadixHexdecimal",
2021 "valueOf(sal_Int32, radix 16)"
2022 );
2023
2024 bRes &= c_rtl_tres_state
2025 (
2026 hRtlTestResult,
2027 test_valueOf_Int32((const char**)kBase36NumsStr,
2028 kBase36NumsCount, kRadixBase36, hRtlTestResult, 0),
2029 "kRadixBase36",
2030 "valueOf(sal_Int32, radix 36)"
2031 );
2032
2033
2034 return ( bRes );
2035 }
2036
2037 //------------------------------------------------------------------------
2038 // testing the method valueOf( sal_Int32 l, sal_Int32 radix=2 )
2039 // where l = large constants
2040 // testing the method valueOf( sal_Int32 l, sal_Int32 radix=8 )
2041 // where l = large constants
2042 // testing the method valueOf( sal_Int32 l, sal_Int32 radix=10 )
2043 // where l = large constants
2044 // testing the method valueOf( sal_Int32 l, sal_Int32 radix=16 )
2045 // where l = large constants
2046 // testing the method valueOf( sal_Int32 l, sal_Int32 radix=36 )
2047 // where l = large constants
2048 //------------------------------------------------------------------------
2049 sal_Bool SAL_CALL test_rtl_OString_valueOf_Int32_Bounderies(
2050 hTestResult hRtlTestResult )
2051 {
2052 sal_Bool bRes = sal_False;
2053
2054 bRes = c_rtl_tres_state
2055 (
2056 hRtlTestResult,
2057 test_valueOf_Int32((const char**)kBinaryMaxNumsStr,
2058 kInt32MaxNumsCount, kRadixBinary, hRtlTestResult,
2059 kInt32MaxNums),
2060 "kRadixBinary",
2061 "valueOf(salInt32, radix 2) Bounderies"
2062 );
2063
2064 bRes &= c_rtl_tres_state
2065 (
2066 hRtlTestResult,
2067 test_valueOf_Int32((const char**)kOctolMaxNumsStr,
2068 kInt32MaxNumsCount, kRadixOctol, hRtlTestResult,
2069 kInt32MaxNums),
2070 "kRadixOctol",
2071 "valueOf(salInt32, radix 8) Bounderies"
2072 );
2073
2074 bRes &= c_rtl_tres_state
2075 (
2076 hRtlTestResult,
2077 test_valueOf_Int32((const char**)kDecimalMaxNumsStr,
2078 kInt32MaxNumsCount, kRadixDecimal,
2079 hRtlTestResult, kInt32MaxNums),
2080 "kRadixDecimal",
2081 "valueOf(salInt32, radix 10) Bounderies"
2082 );
2083
2084 bRes &= c_rtl_tres_state
2085 (
2086 hRtlTestResult,
2087 test_valueOf_Int32((const char**)kHexDecimalMaxNumsStr,
2088 kInt32MaxNumsCount, kRadixHexdecimal,
2089 hRtlTestResult, kInt32MaxNums),
2090 "kRadixHexdecimal",
2091 "valueOf(salInt32, radix 16) Bounderies"
2092 );
2093
2094 bRes &= c_rtl_tres_state
2095 (
2096 hRtlTestResult,
2097 test_valueOf_Int32((const char**)kBase36MaxNumsStr,
2098 kInt32MaxNumsCount, kRadixBase36,
2099 hRtlTestResult, kInt32MaxNums),
2100 "kRadixBase36",
2101 "valueOf(salInt32, radix 36) Bounderies"
2102 );
2103
2104 return ( bRes );
2105 }
2106
2107 //------------------------------------------------------------------------
2108 // testing the method valueOf( sal_Int32 i, sal_Int16 radix=2 )
2109 // for negative value
2110 // testing the method valueOf( sal_Int32 i, sal_Int16 radix=8 )
2111 // for negative value
2112 // testing the method valueOf( sal_Int32 i, sal_Int16 radix=10 )
2113 // for negative value
2114 // testing the method valueOf( sal_Int32 i, sal_Int16 radix=16 )
2115 // for negative value
2116 // testing the method valueOf( sal_Int32 i, sal_Int16 radix=36 )
2117 // for negative value
2118 //------------------------------------------------------------------------
2119 sal_Bool SAL_CALL test_rtl_OString_valueOf_Int32_Negative(
2120 hTestResult hRtlTestResult )
2121 {
2122 sal_Bool bRes = sal_False;
2123 sal_Int32 inArr[kBase36NumsCount];
2124 sal_Int32 i;
2125
2126 for (i = 0; i < kBase36NumsCount; i++ )
2127 inArr[i] = -i;
2128
2129 bRes = c_rtl_tres_state
2130 (
2131 hRtlTestResult,
2132 test_valueOf_Int32( kBinaryNumsStr, kBinaryNumsCount,
2133 kRadixBinary, hRtlTestResult, inArr ),
2134 "negative Int32, kRadixBinary",
2135 "valueOf( negative Int32, radix 2 )"
2136 );
2137
2138 bRes &= c_rtl_tres_state
2139 (
2140 hRtlTestResult,
2141 test_valueOf_Int32( kOctolNumsStr, kOctolNumsCount,
2142 kRadixOctol, hRtlTestResult, inArr ),
2143 "negative Int32, kRadixOctol",
2144 "valueOf( negative Int32, radix 8 )"
2145 );
2146
2147
2148 bRes &= c_rtl_tres_state
2149 (
2150 hRtlTestResult,
2151 test_valueOf_Int32( kDecimalNumsStr, kDecimalNumsCount,
2152 kRadixDecimal, hRtlTestResult, inArr ),
2153 "negative Int32, kRadixDecimal",
2154 "valueOf( negative Int32, radix 10 )"
2155 );
2156
2157 bRes &= c_rtl_tres_state
2158 (
2159 hRtlTestResult,
2160 test_valueOf_Int32( kHexDecimalNumsStr, kHexDecimalNumsCount,
2161 kRadixHexdecimal, hRtlTestResult, inArr ),
2162 "negative Int32, kRadixHexdecimal",
2163 "valueOf( negative Int32, radix 16 )"
2164 );
2165
2166
2167 bRes &= c_rtl_tres_state
2168 (
2169 hRtlTestResult,
2170 test_valueOf_Int32( kBase36NumsStr, kBase36NumsCount,
2171 kRadixBase36, hRtlTestResult, inArr ),
2172 "negative Int32, kRadixBase36",
2173 "valueOf( negative Int32, radix 36 )"
2174 );
2175
2176 return ( bRes );
2177 }
2178 //------------------------------------------------------------------------
2179 // testing the method valueOf( sal_Int32 l, sal_Int32 radix ) where radix = -5
2180 //------------------------------------------------------------------------
2181 sal_Bool SAL_CALL test_rtl_OString_valueOf_Int32_WrongRadix(
2182 hTestResult hRtlTestResult )
2183 {
2184 sal_Bool bRes = sal_False;
2185
2186 sal_Int32 intVal = 11;
2187
2188 ::rtl::OString aStr1;
2189 ::rtl::OString aStr2("11");
2190
2191 aStr1 = aStr1.valueOf( intVal, -5 );
2192
2193 bRes = c_rtl_tres_state
2194 (
2195 hRtlTestResult,
2196 aStr2.compareTo( aStr1 ) == 0,
2197 "if radix not valid then radix must be 10",
2198 "valueOf(sal_Int32, sal_Int32 radix): radix = -5"
2199 );
2200
2201 return (bRes);
2202 }
2203
2204 //------------------------------------------------------------------------
2205 // testing the method valueOf( sal_Int32 l, sal_Int32 radix )
2206 // where l = -2147483648 (smallest negative value)
2207 //------------------------------------------------------------------------
2208 sal_Bool SAL_CALL test_rtl_OString_valueOf_Int32_SmallestNegativeValue(
2209 hTestResult hRtlTestResult)
2210 {
2211 // Standard-conforming way to assign -2147483648 to n:
2212 sal_Int32 n = -1;
2213 for (int i = 1; i < 32; ++i)
2214 n *= 2;
2215 return c_rtl_tres_state
2216 (
2217 hRtlTestResult,
2218 ::rtl::OString::valueOf(n) == "-2147483648",
2219 "-2147483648",
2220 "valueOf(sal_Int32 -2147483648)"
2221 );
2222 }
2223
2224 //------------------------------------------------------------------------
2225 // testing the method valueOf( sal_Int64 l, sal_Int16 radix=2 )
2226 // testing the method valueOf( sal_Int64 l, sal_Int16 radix=8 )
2227 // testing the method valueOf( sal_Int64 l, sal_Int16 radix=10 )
2228 // testing the method valueOf( sal_Int64 l, sal_Int16 radix=16 )
2229 // testing the method valueOf( sal_Int64 l, sal_Int16 radix=36 )
2230 //------------------------------------------------------------------------
2231 sal_Bool SAL_CALL test_rtl_OString_valueOf_Int64(
2232 hTestResult hRtlTestResult )
2233 {
2234 sal_Bool bRes = sal_False;
2235
2236 bRes = c_rtl_tres_state
2237 (
2238 hRtlTestResult,
2239 test_valueOf_Int64((const char**)kBinaryNumsStr,
2240 kBinaryNumsCount, kRadixBinary, hRtlTestResult, 0),
2241 "kRadixBinary",
2242 "valueOf(sal_Int64, radix 2)_"
2243 );
2244
2245 bRes &= c_rtl_tres_state
2246 (
2247 hRtlTestResult,
2248 test_valueOf_Int64((const char**)kOctolNumsStr,
2249 kOctolNumsCount, kRadixOctol, hRtlTestResult, 0),
2250 "kRadixOctol",
2251 "valueOf(sal_Int64, radix 8)_"
2252 );
2253
2254 bRes &= c_rtl_tres_state
2255 (
2256 hRtlTestResult,
2257 test_valueOf_Int64((const char**)kDecimalNumsStr,
2258 kDecimalNumsCount, kRadixDecimal, hRtlTestResult, 0),
2259 "kRadixDecimal",
2260 "valueOf(sal_Int64, radix 10)_"
2261 );
2262 bRes &= c_rtl_tres_state
2263 (
2264 hRtlTestResult,
2265 test_valueOf_Int64((const char**)kHexDecimalNumsStr,
2266 kHexDecimalNumsCount, kRadixHexdecimal, hRtlTestResult, 0),
2267 "kRadixHexdecimal",
2268 "valueOf(sal_Int64, radix 16)_"
2269 );
2270
2271 bRes &= c_rtl_tres_state
2272 (
2273 hRtlTestResult,
2274 test_valueOf_Int64((const char**)kBase36NumsStr,
2275 kBase36NumsCount, kRadixBase36, hRtlTestResult, 0),
2276 "kRadixBase36",
2277 "valueOf(sal_Int64, radix 36)_"
2278 );
2279
2280 return (bRes);
2281 }
2282
2283 //------------------------------------------------------------------------
2284 // testing the method valueOf( sal_Int64 l, sal_Int32 radix=2 )
2285 // where l = large constants
2286 // testing the method valueOf( sal_Int64 l, sal_Int32 radix=8 )
2287 // where l = large constants
2288 // testing the method valueOf( sal_Int64 l, sal_Int32 radix=10 )
2289 // where l = large constants
2290 // testing the method valueOf( sal_Int64 l, sal_Int32 radix=16 )
2291 // where l = large constants
2292 // testing the method valueOf( sal_Int64 l, sal_Int32 radix=36 )
2293 // where l = large constants
2294 //------------------------------------------------------------------------
2295 sal_Bool SAL_CALL test_rtl_OString_valueOf_Int64_Bounderies(
2296 hTestResult hRtlTestResult )
2297 {
2298 sal_Bool bRes = sal_False;
2299
2300 bRes = c_rtl_tres_state
2301 (
2302 hRtlTestResult,
2303 test_valueOf_Int64((const char**)kBinaryMaxNumsStr,
2304 kInt64MaxNumsCount, kRadixBinary,
2305 hRtlTestResult, kInt64MaxNums),
2306 "kRadixBinary",
2307 "valueOf(salInt64, radix 2) Bounderies"
2308 );
2309
2310 bRes &= c_rtl_tres_state
2311 (
2312 hRtlTestResult,
2313 test_valueOf_Int64((const char**)kOctolMaxNumsStr,
2314 kInt64MaxNumsCount, kRadixOctol,
2315 hRtlTestResult, kInt64MaxNums),
2316 "kRadixOctol",
2317 "valueOf(salInt64, radix 8) Bounderies"
2318 );
2319
2320 bRes &= c_rtl_tres_state
2321 (
2322 hRtlTestResult,
2323 test_valueOf_Int64((const char**)kDecimalMaxNumsStr,
2324 kInt64MaxNumsCount, kRadixDecimal,
2325 hRtlTestResult, kInt64MaxNums),
2326 "kRadixDecimal",
2327 "valueOf(salInt64, radix 10) Bounderies"
2328 );
2329
2330 bRes &= c_rtl_tres_state
2331 (
2332 hRtlTestResult,
2333 test_valueOf_Int64((const char**)kHexDecimalMaxNumsStr,
2334 kInt64MaxNumsCount, kRadixHexdecimal,
2335 hRtlTestResult, kInt64MaxNums),
2336 "kRadixHexdecimal",
2337 "valueOf(salInt64, radix 16) Bounderies"
2338 );
2339
2340 bRes &= c_rtl_tres_state
2341 (
2342 hRtlTestResult,
2343 test_valueOf_Int64((const char**)kBase36MaxNumsStr,
2344 kInt64MaxNumsCount, kRadixBase36,
2345 hRtlTestResult, kInt64MaxNums),
2346 "kRadixBase36",
2347 "valueOf(salInt64, radix 36) Bounderies"
2348 );
2349
2350 return ( bRes );
2351 }
2352
2353 //------------------------------------------------------------------------
2354 // testing the method valueOf( sal_Int64 l, sal_Int16 radix=2 )
2355 // for negative value
2356 // testing the method valueOf( sal_Int64 l, sal_Int16 radix=8 )
2357 // for negative value
2358 // testing the method valueOf( sal_Int64 l, sal_Int16 radix=10 )
2359 // for negative value
2360 // testing the method valueOf( sal_Int64 l, sal_Int16 radix=16 )
2361 // for negative value
2362 // testing the method valueOf( sal_Int64 l, sal_Int16 radix=36 )
2363 // for negative value
2364 //------------------------------------------------------------------------
2365 sal_Bool SAL_CALL test_rtl_OString_valueOf_Int64_Negative(
2366 hTestResult hRtlTestResult )
2367 {
2368 sal_Bool bRes = sal_False;
2369
2370 sal_Int64 inArr[36];
2371 sal_Int32 i;
2372
2373 for (i = 0; i < 36; i++) {
2374 inArr[i] = -i;
2375 }
2376
2377
2378 bRes = c_rtl_tres_state
2379 (
2380 hRtlTestResult,
2381 test_valueOf_Int64( kBinaryNumsStr, kBinaryNumsCount,
2382 kRadixBinary, hRtlTestResult, inArr ),
2383 "negative Int64, kRadixBinary",
2384 "valueOf( negative Int64, radix 2 )"
2385 );
2386
2387 bRes &= c_rtl_tres_state
2388 (
2389 hRtlTestResult,
2390 test_valueOf_Int64( kOctolNumsStr, kOctolNumsCount,
2391 kRadixOctol, hRtlTestResult, inArr ),
2392 "negative Int64, kRadixOctol",
2393 "valueOf( negative Int64, radix 8 )"
2394 );
2395
2396 bRes &= c_rtl_tres_state
2397 (
2398 hRtlTestResult,
2399 test_valueOf_Int64( kDecimalNumsStr, kDecimalNumsCount,
2400 kRadixDecimal, hRtlTestResult, inArr ),
2401 "negative Int64, kRadixDecimal",
2402 "valueOf( negative Int64, radix 10 )"
2403 );
2404
2405 bRes &= c_rtl_tres_state
2406 (
2407 hRtlTestResult,
2408 test_valueOf_Int64( kHexDecimalNumsStr, kHexDecimalNumsCount,
2409 kRadixHexdecimal, hRtlTestResult, inArr ),
2410 "negative Int64, kRadixHexDecimal",
2411 "valueOf( negative Int64, radix 16 )"
2412 );
2413
2414 bRes &= c_rtl_tres_state
2415 (
2416 hRtlTestResult,
2417 test_valueOf_Int64( kBase36NumsStr, kBase36NumsCount,
2418 kRadixBase36, hRtlTestResult, inArr),
2419 "negative Int64, kRadixBase36",
2420 "valueOf( negative Int64, radix 36 )"
2421 );
2422
2423 return (bRes);
2424 }
2425 //------------------------------------------------------------------------
2426 // testing the method valueOf( sal_Int64 l, sal_Int32 radix )
2427 // where radix = -5
2428 //------------------------------------------------------------------------
2429 sal_Bool SAL_CALL test_rtl_OString_valueOf_Int64_WrongRadix(
2430 hTestResult hRtlTestResult )
2431 {
2432 sal_Bool bRes = sal_False;
2433
2434 sal_Int64 intVal = 11;
2435
2436 ::rtl::OString aStr1;
2437 ::rtl::OString aStr2("11");
2438
2439 aStr1 = aStr1.valueOf( intVal, -5 );
2440
2441 bRes = c_rtl_tres_state
2442 (
2443 hRtlTestResult,
2444 aStr2.compareTo(aStr1) == 0,
2445 "if radix not valid then radix must be 10",
2446 "valueOf(sal_Int64, sal_Int32 radix): radix = -5"
2447 );
2448
2449 return (bRes);
2450 }
2451
2452 //------------------------------------------------------------------------
2453 // testing the method valueOf( sal_Int64 l, sal_Int32 radix )
2454 // where l = -9223372036854775808 (smallest negative value)
2455 //------------------------------------------------------------------------
2456 sal_Bool SAL_CALL test_rtl_OString_valueOf_Int64_SmallestNegativeValue(
2457 hTestResult hRtlTestResult)
2458 {
2459 // Standard-conforming way to assign -9223372036854775808 to n:
2460 sal_Int64 n = -1;
2461 for (int i = 1; i < 64; ++i)
2462 n *= 2;
2463 return c_rtl_tres_state
2464 (
2465 hRtlTestResult,
2466 ::rtl::OString::valueOf(n) == "-9223372036854775808",
2467 "-9223372036854775808",
2468 "valueOf(sal_Int64 -9223372036854775808)"
2469 );
2470 }
2471
2472 //------------------------------------------------------------------------
2473 // testing the method valueOf( float f )
2474 //------------------------------------------------------------------------
2475 // LLA: sal_Bool SAL_CALL test_rtl_OString_valueOf_float(
2476 // LLA: hTestResult hRtlTestResult )
2477 // LLA: {
2478 // LLA: sal_Char methName[MAXBUFLENGTH];
2479 // LLA: sal_Char* pMeth =methName;
2480 // LLA:
2481 // LLA: typedef struct TestCase
2482 // LLA: {
2483 // LLA: sal_Char* comments;
2484 // LLA: float input1;
2485 // LLA: OString* expVal;
2486 // LLA:
2487 // LLA: ~TestCase() {delete expVal;}
2488 // LLA: } TestCase;
2489 // LLA:
2490 // LLA: TestCase arrTestCase[] =
2491 // LLA: {
2492 // LLA: { "3.0", 3.0, new OString("3.0") },
2493 // LLA: { "3.5", 3.5f, new OString("3.5")},
2494 // LLA: { "3.0625", 3.0625f, new OString("3.0625")},
2495 // LLA: { "3.502525", 3.502525f, new OString("3.502525") },
2496 // LLA: { "3.141592", 3.141592f, new OString("3.141592") },
2497 // LLA: { "3.5025255", 3.5025255f, new OString("3.5025255") },
2498 // LLA: { "3.0039062", 3.00390625f, new OString("3.0039062") }
2499 // LLA: };
2500 // LLA:
2501 // LLA: sal_Bool res = sal_True;
2502 // LLA: sal_Int32 i;
2503 // LLA:
2504 // LLA: for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
2505 // LLA: {
2506 // LLA: ::rtl::OString aStr1;
2507 // LLA: aStr1 = aStr1.valueOf( arrTestCase[i].input1 );
2508 // LLA: sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0);
2509 // LLA:
2510 // LLA: c_rtl_tres_state
2511 // LLA: (
2512 // LLA: hRtlTestResult,
2513 // LLA: lastRes,
2514 // LLA: arrTestCase[i].comments,
2515 // LLA: createName( pMeth, "valueof_float", i)
2516 // LLA: );
2517 // LLA:
2518 // LLA: res &= lastRes;
2519 // LLA:
2520 // LLA: }
2521 // LLA:
2522 // LLA: return ( res );
2523 // LLA: }
2524
2525
2526
2527
2528 //------------------------------------------------------------------------
2529 // testing the method valueOf( float f ) for negative value
2530 //------------------------------------------------------------------------
2531 // LLA: sal_Bool SAL_CALL test_rtl_OString_valueOf_Float_Negative(
2532 // LLA: hTestResult hRtlTestResult )
2533 // LLA: {
2534 // LLA: sal_Char methName[MAXBUFLENGTH];
2535 // LLA: sal_Char* pMeth =methName;
2536 // LLA:
2537 // LLA: typedef struct TestCase
2538 // LLA: {
2539 // LLA: sal_Char* comments;
2540 // LLA: float input1;
2541 // LLA: OString* expVal;
2542 // LLA:
2543 // LLA: ~TestCase() {delete expVal;}
2544 // LLA: } TestCase;
2545 // LLA:
2546 // LLA: TestCase arrTestCase[] =
2547 // LLA: {
2548 // LLA: { "-3.0", -3.0, new OString("-3.0") },
2549 // LLA: { "-3.5", -3.5f, new OString("-3.5")},
2550 // LLA: { "-3.0625", -3.0625f, new OString("-3.0625")},
2551 // LLA: { "-3.502525", -3.502525f, new OString("-3.502525") },
2552 // LLA: { "-3.141592", -3.141592f, new OString("-3.141592") },
2553 // LLA: { "-3.5025255", -3.5025255f, new OString("-3.5025255") },
2554 // LLA: { "-3.0039062", -3.00390625f, new OString("-3.0039062") }
2555 // LLA: };
2556 // LLA:
2557 // LLA: sal_Bool res = sal_True;
2558 // LLA: sal_Int32 i;
2559 // LLA:
2560 // LLA: for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
2561 // LLA: {
2562 // LLA: ::rtl::OString aStr1;
2563 // LLA: aStr1 = aStr1.valueOf( arrTestCase[i].input1 );
2564 // LLA: sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0);
2565 // LLA:
2566 // LLA: c_rtl_tres_state
2567 // LLA: (
2568 // LLA: hRtlTestResult,
2569 // LLA: lastRes,
2570 // LLA: arrTestCase[i].comments,
2571 // LLA: createName( pMeth, "valueof_negative float", i)
2572 // LLA: );
2573 // LLA:
2574 // LLA: res &= lastRes;
2575 // LLA:
2576 // LLA: }
2577 // LLA:
2578 // LLA: return ( res );
2579 // LLA: }
2580
2581 //------------------------------------------------------------------------
2582 // testing the method valueOf( double f )
2583 //------------------------------------------------------------------------
2584 // LLA: sal_Bool SAL_CALL test_rtl_OString_valueOf_double(
2585 // LLA: hTestResult hRtlTestResult )
2586 // LLA: {
2587 // LLA: sal_Char methName[MAXBUFLENGTH];
2588 // LLA: sal_Char* pMeth =methName;
2589 // LLA:
2590 // LLA: typedef struct TestCase
2591 // LLA: {
2592 // LLA: sal_Char* comments;
2593 // LLA: double input1;
2594 // LLA: OString* expVal;
2595 // LLA:
2596 // LLA: ~TestCase() {delete expVal;}
2597 // LLA: } TestCase;
2598 // LLA:
2599 // LLA: TestCase arrTestCase[] =
2600 // LLA: {
2601 // LLA: {"3.0", 3.0, new OString("3.0")},
2602 // LLA: {"3.5", 3.5, new OString("3.5")},
2603 // LLA: {"3.0625", 3.0625, new OString("3.0625")},
2604 // LLA: {"3.1415926535", 3.1415926535, new OString("3.1415926535")},
2605 // LLA: {"3.1415926535897931", 3.141592653589793,
2606 // LLA: new OString("3.1415926535897931")},
2607 // LLA: {"3.1415926535897931", 3.1415926535897932,
2608 // LLA: new OString("3.1415926535897931")},
2609 // LLA: {"3.1415926535897931", 3.14159265358979323,
2610 // LLA: new OString("3.1415926535897931")},
2611 // LLA: {"3.1415926535897931", 3.141592653589793238462643,
2612 // LLA: new OString("3.1415926535897931")}
2613 // LLA: };
2614 // LLA:
2615 // LLA: sal_Bool res = sal_True;
2616 // LLA: sal_Int32 i;
2617 // LLA:
2618 // LLA: for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
2619 // LLA: {
2620 // LLA: ::rtl::OString aStr1;
2621 // LLA: aStr1 = aStr1.valueOf( arrTestCase[i].input1 );
2622 // LLA: sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0);
2623 // LLA:
2624 // LLA: c_rtl_tres_state
2625 // LLA: (
2626 // LLA: hRtlTestResult,
2627 // LLA: lastRes,
2628 // LLA: arrTestCase[i].comments,
2629 // LLA: createName( pMeth, "valueof_double", i)
2630 // LLA: );
2631 // LLA:
2632 // LLA: res &= lastRes;
2633 // LLA:
2634 // LLA: }
2635 // LLA:
2636 // LLA: return ( res );
2637 // LLA: }
2638
2639
2640 //------------------------------------------------------------------------
2641 // testing the method valueOf( double f ) for negative value
2642 //------------------------------------------------------------------------
2643 // LLA: sal_Bool SAL_CALL test_rtl_OString_valueOf_Double_Negative(
2644 // LLA: hTestResult hRtlTestResult )
2645 // LLA: {
2646 // LLA: sal_Char methName[MAXBUFLENGTH];
2647 // LLA: sal_Char* pMeth =methName;
2648 // LLA:
2649 // LLA: typedef struct TestCase
2650 // LLA: {
2651 // LLA: sal_Char* comments;
2652 // LLA: double input1;
2653 // LLA: OString* expVal;
2654 // LLA:
2655 // LLA: ~TestCase() {delete expVal;}
2656 // LLA: } TestCase;
2657 // LLA:
2658 // LLA: TestCase arrTestCase[] =
2659 // LLA: {
2660 // LLA: {"-3.0", -3.0, new OString("-3.0")},
2661 // LLA: {"-3.5", -3.5, new OString("-3.5")},
2662 // LLA: {"-3.0625", -3.0625, new OString("-3.0625")},
2663 // LLA: {"-3.1415926535", -3.1415926535, new OString("-3.1415926535")},
2664 // LLA: {"-3.1415926535897931", -3.141592653589793,
2665 // LLA: new OString("-3.1415926535897931")},
2666 // LLA: {"-3.1415926535897931", -3.1415926535897932,
2667 // LLA: new OString("-3.1415926535897931")},
2668 // LLA: {"-3.1415926535897931", -3.14159265358979323,
2669 // LLA: new OString("-3.1415926535897931")},
2670 // LLA: {"-3.1415926535897931", -3.141592653589793238462643,
2671 // LLA: new OString("-3.1415926535897931")}
2672 // LLA: };
2673 // LLA:
2674 // LLA: sal_Bool res = sal_True;
2675 // LLA: sal_Int32 i;
2676 // LLA:
2677 // LLA: for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
2678 // LLA: {
2679 // LLA: ::rtl::OString aStr1;
2680 // LLA: aStr1 = aStr1.valueOf( arrTestCase[i].input1 );
2681 // LLA: sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0);
2682 // LLA:
2683 // LLA: c_rtl_tres_state
2684 // LLA: (
2685 // LLA: hRtlTestResult,
2686 // LLA: lastRes,
2687 // LLA: arrTestCase[i].comments,
2688 // LLA: createName( pMeth, "valueof_nagative double", i)
2689 // LLA: );
2690 // LLA:
2691 // LLA: res &= lastRes;
2692 // LLA:
2693 // LLA: }
2694 // LLA:
2695 // LLA: return ( res );
2696 // LLA: }
2697
2698 //------------------------------------------------------------------------
2699 // testing the method valueOf()
2700 //------------------------------------------------------------------------
2701 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_valueOf(
2702 hTestResult hRtlTestResult )
2703 {
2704 c_rtl_tres_state_start(hRtlTestResult, "valueOf");
2705 sal_Bool bTState = test_rtl_OString_valueOf_sal_Bool( hRtlTestResult );
2706
2707 bTState &= test_rtl_OString_valueOf_sal_Char( hRtlTestResult );
2708
2709 bTState &= test_rtl_OString_valueOf_Int32( hRtlTestResult );
2710 bTState &= test_rtl_OString_valueOf_Int32_Bounderies( hRtlTestResult );
2711 bTState &= test_rtl_OString_valueOf_Int32_Negative( hRtlTestResult );
2712 bTState &= test_rtl_OString_valueOf_Int32_WrongRadix( hRtlTestResult );
2713 bTState &= test_rtl_OString_valueOf_Int32_SmallestNegativeValue(
2714 hRtlTestResult );
2715
2716 bTState &= test_rtl_OString_valueOf_Int64( hRtlTestResult );
2717 bTState &= test_rtl_OString_valueOf_Int64_Bounderies( hRtlTestResult );
2718 bTState &= test_rtl_OString_valueOf_Int64_Negative( hRtlTestResult );
2719 bTState &= test_rtl_OString_valueOf_Int64_WrongRadix( hRtlTestResult );
2720 bTState &= test_rtl_OString_valueOf_Int64_SmallestNegativeValue(
2721 hRtlTestResult );
2722
2723 // LLA: the tests for valueOf(float) and valueOf(double) are moved to file
2724 // sal/qa/rtl/ostring/rtl_OString2.cxx
2725
2726 // LLA: bTState &= test_rtl_OString_valueOf_float( hRtlTestResult );
2727 // LLA: bTState &= test_rtl_OString_valueOf_Float_Negative( hRtlTestResult );
2728
2729 // LLA: bTState &= test_rtl_OString_valueOf_double( hRtlTestResult );
2730 // LLA: bTState &= test_rtl_OString_valueOf_Double_Negative( hRtlTestResult );
2731
2732 c_rtl_tres_state_end(hRtlTestResult, "valueOf");
2733 // return ( bTState );
2734 }
2735
2736
2737 //------------------------------------------------------------------------
2738 // testing the method toChar()
2739 //------------------------------------------------------------------------
2740 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toChar(
2741 hTestResult hRtlTestResult )
2742 {
2743 sal_Char methName[MAXBUFLENGTH];
2744 sal_Char* pMeth = methName;
2745
2746 c_rtl_tres_state_start(hRtlTestResult, "toChar");
2747 typedef struct TestCase
2748 {
2749 sal_Char* comments;
2750 sal_Char expVal;
2751 OString* input1;
2752 ~TestCase() {delete input1;}
2753 } TestCase;
2754
2755
2756 TestCase arrTestCase[] =
2757 {
2758 {"A", 'A', new OString("A")},
2759 {"a", 'a', new OString("a")},
2760 {"0", '0',new OString("0")},
2761 {"-", '-',new OString("-")},
2762 {"_", '_',new OString("_")},
2763
2764 // TODO: may be UTF-8 values
2765 // {"�0„6", '�0„6',new OString("�0„6")},
2766 // { "�0„7", '�0„7',new OString("�0„7")},
2767 // {"�0‹0", '�0‹0',new OString("�0‹0")},
2768 // {"�0�6", '�0�6',new OString("�0�6")},
2769 {"\n", '\n',new OString("\n")},
2770 {"\'", '\'',new OString("\'")},
2771 {"\"", '\"',new OString("\"")},
2772 {"\0", '\0',new OString("\0")},
2773 {"", '\0',new OString("")},
2774 {"Sun Microsystems", 'S', new OString(kTestStr1)}
2775 };
2776
2777
2778 // sal_Bool res = sal_True;
2779 sal_uInt32 i;
2780
2781 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++ )
2782 {
2783 sal_Char strRes = arrTestCase[i].input1->toChar();
2784 sal_Bool lastRes = ( strRes == arrTestCase[i].expVal );
2785
2786 char com[MAXBUFLENGTH];
2787 com[0] = '\'';
2788 cpynstr(com + 1, (*arrTestCase[i].input1), MAXBUFLENGTH);
2789 int length = AStringLen( (*arrTestCase[i].input1) );
2790 com[length + 1] = '\'';
2791 com[length + 2] = 0;
2792
2793 c_rtl_tres_state
2794 (
2795 hRtlTestResult,
2796 lastRes,
2797 com,
2798 createName( pMeth, "toChar", i )
2799 );
2800
2801 }
2802
2803 c_rtl_tres_state_end(hRtlTestResult, "toChar");
2804 // return (res);
2805 }
2806
2807
2808 //------------------------------------------------------------------------
2809 // testing the method toFloat()
2810 //------------------------------------------------------------------------
2811 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toFloat(
2812 hTestResult hRtlTestResult )
2813 {
2814 sal_Char methName[MAXBUFLENGTH];
2815 sal_Char* pMeth = methName;
2816
2817 c_rtl_tres_state_start(hRtlTestResult, "toFloat");
2818 typedef struct TestCase
2819 {
2820 float expVal;
2821 OString* input1;
2822 float m_nPrecision;
2823 ~TestCase() {delete input1;}
2824 } TestCase;
2825
2826
2827 TestCase arrTestCase[] =
2828 {
2829 {3.0f, new OString("3"), 3e-7f},
2830 {3.1f, new OString("3.1"), 3e-7f},
2831 {3.1415f, new OString("3.1415"), 3e-7f},
2832 {3.14159f, new OString("3.14159"), 3e-7f},
2833 {3.141592f, new OString("3.141592"), 3e-7f},
2834 {3.1415926f, new OString("3.1415926"), 3e-7f},
2835 {3.14159265f, new OString("3.14159265"), 3e-7f},
2836 {3.141592653589793238462643f,
2837 new OString("3.141592653589793238462643"), 3e-7f},
2838 {6.5822e-16f, new OString("6.5822e-16"), 6e-16f * 1e-7f},
2839 {9.1096e-31f, new OString("9.1096e-31"), 9e-31f * 1e-7f},
2840 {2.997925e8f, new OString("2.997925e8"), 3e8f * 1e-7f},
2841 {6.241e18f, new OString("6.241e18"), 6e18f * 1e-7f},
2842 {3.1f, new OString("03.1"), 3e-7f},
2843 {3.1f, new OString(" 3.1"), 3e-7f},
2844 {-3.1f, new OString("-3.1"), 3e-7f},
2845 {3.1f, new OString("+3.1"), 3e-7f},
2846 {0.0f, new OString("-0.0"), 1e-7f}
2847 };
2848
2849
2850 // sal_Bool res = sal_True;
2851 sal_uInt32 i;
2852
2853 t_print("sizeof(float)=%d, sizeof(double)=%d\n", sizeof(float), sizeof(double));
2854
2855 for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++ )
2856 {
2857 float fA = arrTestCase[i].input1->toFloat();
2858 float fB = arrTestCase[i].expVal;
2859 float fPrec = arrTestCase[i].m_nPrecision;
2860 float fResult = (float) fabs(fA - fB);
2861 // t_print("float result: A:(%.9f) B:(%.9f) fabs(A-B):%E\n", fA, fB, fResult);
2862 t_print("float result: A:(%E) B:(%E) fabs(A-B):%E\n", fA, fB, (float) fResult);
2863 sal_Bool lastRes = ( fResult <= fPrec );
2864
2865 char com[MAXBUFLENGTH];
2866 com[0] = '\'';
2867 cpynstr(com + 1, (*arrTestCase[i].input1), MAXBUFLENGTH);
2868 int length = AStringLen( (*arrTestCase[i].input1) );
2869 com[length + 1] = '\'';
2870 com[length + 2] = 0;
2871
2872 c_rtl_tres_state
2873 (
2874 hRtlTestResult,
2875 lastRes,
2876 com,
2877 createName( pMeth, "toFloat", i )
2878 );
2879
2880 }
2881
2882 c_rtl_tres_state_end(hRtlTestResult, "toFloat");
2883 // return (res);
2884 }
2885
2886
2887 //------------------------------------------------------------------------
2888 // testing the method toDouble()
2889 //------------------------------------------------------------------------
2890 // LLA: extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toDouble(
2891 // LLA: hTestResult hRtlTestResult )
2892 // LLA: {
2893 // LLA: sal_Char methName[MAXBUFLENGTH];
2894 // LLA: sal_Char* pMeth = methName;
2895 // LLA:
2896 // LLA: c_rtl_tres_state_start(hRtlTestResult, "toDouble");
2897 // LLA: typedef struct TestCase
2898 // LLA: {
2899 // LLA: double expVal;
2900 // LLA: double expDiff;
2901 // LLA: OString* input1;
2902 // LLA: ~TestCase() {delete input1;}
2903 // LLA: } TestCase;
2904 // LLA:
2905 // LLA:
2906 // LLA: TestCase arrTestCase[] =
2907 // LLA: {
2908 // LLA: {3.0, 1e-35, new OString("3")},
2909 // LLA: {3.1, 1e-2, new OString("3.1")},
2910 // LLA: {3.1415, 1e-5, new OString("3.1415")},
2911 // LLA: {3.1415926535, 1e-11, new OString("3.1415926535")},
2912 // LLA: {3.141592653589793, 1e-15,
2913 // LLA: new OString("3.141592653589793")},
2914 // LLA: {3.1415926535897932, 1e-16,
2915 // LLA: new OString("3.1415926535897932")},
2916 // LLA: {3.14159265358979323, 1e-15,
2917 // LLA: new OString("3.14159265358979323")},
2918 // LLA: {3.141592653589793238462643, 1e-15,
2919 // LLA: new OString("3.141592653589793238462643")},
2920 // LLA: {6.5822e-16, 1e-20, new OString("6.5822e-16")},
2921 // LLA: {9.1096e-31, 1e-35, new OString("9.1096e-31")},
2922 // LLA: {2.997925e8, 10, new OString("2.997925e8")},
2923 // LLA: {6.241e18, 100, new OString("6.241e18")},
2924 // LLA: {1.7e-308, 1e-35, new OString("1.7e-308")},
2925 // LLA: {1.7e+308, 100, new OString("1.7e+308")},
2926 // LLA: {3.1, 1e-2, new OString("03.1")},
2927 // LLA: {3.1, 1e-2, new OString(" 3.1")},
2928 // LLA: {-3.1, 1e-2, new OString("-3.1")},
2929 // LLA: {3.1, 1e-2, new OString("+3.1")},
2930 // LLA: {0.0, 1e-2, new OString("-0.0")}
2931 // LLA: };
2932 // LLA:
2933 // LLA: sal_Bool res = sal_True;
2934 // LLA: sal_Int32 i;
2935 // LLA:
2936 // LLA: for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++ )
2937 // LLA: {
2938 // LLA: double dRes = arrTestCase[i].input1->toDouble();
2939 // LLA: double dErg = dRes - arrTestCase[i].expVal ;
2940 // LLA: double dComp = fabs( dErg );
2941 // LLA: sal_Bool lastRes = ( dComp <= arrTestCase[i].expDiff );
2942 // LLA:
2943 // LLA: char com[MAXBUFLENGTH];
2944 // LLA: com[0] = '\'';
2945 // LLA: cpynstr(com + 1, (*arrTestCase[i].input1), MAXBUFLENGTH);
2946 // LLA: int length = AStringLen( (*arrTestCase[i].input1) );
2947 // LLA: com[length + 1] = '\'';
2948 // LLA: com[length + 2] = 0;
2949 // LLA:
2950 // LLA: c_rtl_tres_state
2951 // LLA: (
2952 // LLA: hRtlTestResult,
2953 // LLA: lastRes,
2954 // LLA: com,
2955 // LLA: createName( pMeth, "toDouble", i )
2956 // LLA: );
2957 // LLA:
2958 // LLA: }
2959 // LLA:
2960 // LLA: c_rtl_tres_state_end(hRtlTestResult, "toDouble");
2961 // LLA: // return (res);
2962 // LLA: }
2963
2964 //------------------------------------------------------------------------
2965 // testing the method toBoolean()
2966 //------------------------------------------------------------------------
2967
2968 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toBoolean(
2969 hTestResult hRtlTestResult)
2970 {
2971 sal_Char methName[MAXBUFLENGTH];
2972 sal_Char* pMeth = methName;
2973
2974 c_rtl_tres_state_start(hRtlTestResult, "toBoolean");
2975 typedef struct TestCase
2976 {
2977 sal_Char* comments;
2978 sal_Bool expVal;
2979 OString* input;
2980
2981 } TestCase;
2982
2983 TestCase arrTestCase[]={
2984
2985 {"expected true", sal_True, new OString("True")},
2986 {"expected false", sal_False, new OString("False")},
2987 {"expected true", sal_True, new OString("1")}
2988 };
2989
2990
2991 sal_Bool res = sal_True;
2992 sal_uInt32 i;
2993
2994 for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
2995 {
2996 sal_Bool bRes = arrTestCase[i].input->toBoolean();
2997 sal_Bool lastRes = (bRes == arrTestCase[i].expVal);
2998 c_rtl_tres_state
2999 (
3000 hRtlTestResult,
3001 lastRes,
3002 arrTestCase[i].comments,
3003 createName( pMeth, "toBoolean", i )
3004
3005 );
3006 res &= lastRes;
3007 }
3008 c_rtl_tres_state_end(hRtlTestResult, "toBoolean");
3009 // return ( res );
3010 }
3011
3012
3013
3014 //------------------------------------------------------------------------
3015 // testing the method toInt32( sal_Int16 radix = 2,8,10,16,36 )
3016 //------------------------------------------------------------------------
3017 sal_Bool test_toInt32( int num, const sal_Char** in,
3018 const sal_Int32 *expVal,sal_Int16 radix, hTestResult hRtlTestResult )
3019 {
3020 sal_Bool res = sal_True;
3021 sal_Char methName[MAXBUFLENGTH];
3022 sal_Char* pMeth = methName;
3023 sal_Int32 i;
3024
3025 for( i = 0; i < num; i++ )
3026 {
3027 OString str(in[i]);
3028 sal_Int32 intRes = str.toInt32(radix);
3029 sal_Bool lastRes = (intRes == expVal[i]);
3030
3031 char buf[MAXBUFLENGTH];
3032 buf[0] = '\'';
3033 cpynstr( buf + 1, in[i], MAXBUFLENGTH );
3034 int length = AStringLen( in[i] );
3035 buf[length + 1] = '\'';
3036 buf[length + 2] = 0;
3037
3038 c_rtl_tres_state
3039 (
3040 hRtlTestResult,
3041 lastRes,
3042 buf,
3043 createName( pMeth,"toInt32", i )
3044 );
3045
3046 res &= lastRes;
3047 }
3048
3049 return( res );
3050 }
3051
3052 sal_Bool SAL_CALL test_rtl_OString_toInt32_wrongRadix(
3053 hTestResult hRtlTestResult )
3054 {
3055 ::rtl::OString str("0");
3056
3057 sal_Int32 iRes = str.toInt32(-1);
3058
3059 return
3060 (
3061 c_rtl_tres_state
3062 (
3063 hRtlTestResult,
3064 iRes == 0,
3065 "wrong radix -1",
3066 "toInt32( 0, wrong radix -1 )"
3067 )
3068 );
3069 }
3070
3071 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toInt32(
3072 hTestResult hRtlTestResult )
3073 {
3074 sal_Int32 expValues[kBase36NumsCount];
3075 sal_Int32 i;
3076
3077 c_rtl_tres_state_start(hRtlTestResult, "toInt32");
3078 for ( i = 0; i < kBase36NumsCount; i++ )
3079 expValues[i] = i;
3080
3081 sal_Bool res = c_rtl_tres_state
3082 (
3083 hRtlTestResult,
3084 test_toInt32( kBinaryNumsCount, kBinaryNumsStr,
3085 expValues, kRadixBinary, hRtlTestResult ),
3086 "kBinaryNumsStr",
3087 "toInt32( radix 2 )"
3088 );
3089 res &= c_rtl_tres_state
3090 (
3091 hRtlTestResult,
3092 test_toInt32( kInt32MaxNumsCount, kBinaryMaxNumsStr,
3093 kInt32MaxNums, kRadixBinary, hRtlTestResult ),
3094 "kBinaryMaxNumsStr",
3095 "toInt32_Boundaries( radix 2 )"
3096 );
3097
3098 res &= c_rtl_tres_state
3099 (
3100 hRtlTestResult,
3101 test_toInt32( kOctolNumsCount, kOctolNumsStr,
3102 expValues, kRadixOctol, hRtlTestResult ),
3103 "kOctolNumsStr",
3104 "toInt32( radix 8 )"
3105 );
3106
3107 res &= c_rtl_tres_state
3108 (
3109 hRtlTestResult,
3110 test_toInt32( kInt32MaxNumsCount, kOctolMaxNumsStr,
3111 (sal_Int32*)kInt32MaxNums, kRadixOctol, hRtlTestResult ),
3112 "kOctolMaxNumsStr",
3113 "toInt32_Boundaries( radix 8 )"
3114 );
3115
3116 res &= c_rtl_tres_state
3117 (
3118 hRtlTestResult,
3119 test_toInt32( kDecimalNumsCount, kDecimalNumsStr, expValues,
3120 kRadixDecimal, hRtlTestResult ),
3121 "kDecimalNumsStr",
3122 "toInt32( radix 10 )"
3123 );
3124
3125 res &= c_rtl_tres_state
3126 (
3127 hRtlTestResult,
3128 test_toInt32( kInt32MaxNumsCount, kDecimalMaxNumsStr,
3129 (sal_Int32*)kInt32MaxNums, kRadixDecimal, hRtlTestResult ),
3130 "kDecimalMaxNumsStr",
3131 "toInt32_Boundaries( radix 10 )"
3132 );
3133
3134 res &= c_rtl_tres_state
3135 (
3136 hRtlTestResult,
3137 test_toInt32( kHexDecimalNumsCount, kHexDecimalNumsStr, expValues,
3138 kRadixHexdecimal, hRtlTestResult ),
3139 "kHexDecimalNumsStr",
3140 "toInt32( radix 16 )"
3141 );
3142
3143 res &= c_rtl_tres_state
3144 (
3145 hRtlTestResult,
3146 test_toInt32( kInt32MaxNumsCount, kHexDecimalMaxNumsStr,
3147 (sal_Int32*)kInt32MaxNums, kRadixHexdecimal, hRtlTestResult ),
3148 "kHexDecimalMaxNumsStr",
3149 "toInt32_Boundaries( radix 16 )"
3150 );
3151
3152 res &= c_rtl_tres_state
3153 (
3154 hRtlTestResult,
3155 test_toInt32( kBase36NumsCount, kBase36NumsStr, expValues,
3156 kRadixBase36, hRtlTestResult ),
3157 "kBase36NumsStr",
3158 "toInt32( radix 36 )"
3159 );
3160
3161 res &= c_rtl_tres_state
3162 (
3163 hRtlTestResult,
3164 test_toInt32( kInt32MaxNumsCount, kBase36MaxNumsStr,
3165 (sal_Int32*)kInt32MaxNums, kRadixBase36, hRtlTestResult ),
3166 "kBase36MaxNumsStr",
3167 "toInt32_Boundaries( radix 36 )"
3168 );
3169
3170 const sal_Int16 nSpecCases = 5;
3171 static const sal_Char *spString[nSpecCases] =
3172 {
3173 "-1",
3174 "+1",
3175 " 1",
3176 " -1",
3177 "001"
3178 };
3179
3180 sal_Int32 expSpecVal[nSpecCases] =
3181 {
3182 -1,
3183 1,
3184 1,
3185 -1,
3186 1
3187 };
3188
3189 res &= c_rtl_tres_state
3190 (
3191 hRtlTestResult,
3192 test_toInt32( nSpecCases, spString, expSpecVal,
3193 kRadixDecimal, hRtlTestResult ),
3194 "special cases",
3195 "toInt32( specialcases )"
3196 );
3197
3198 res &= test_rtl_OString_toInt32_wrongRadix( hRtlTestResult );
3199
3200 c_rtl_tres_state_end(hRtlTestResult, "toInt32");
3201 // return ( res );
3202 }
3203
3204 //------------------------------------------------------------------------
3205 // testing the method toInt64( sal_Int16 radix = 2,8,10,16,36 )
3206 //------------------------------------------------------------------------
3207 sal_Bool test_toInt64( int num, const sal_Char** in,
3208 const sal_Int64 *expVal,sal_Int16 radix, hTestResult hRtlTestResult )
3209 {
3210 sal_Bool res = sal_True;
3211 sal_Char methName[MAXBUFLENGTH];
3212 sal_Char* pMeth = methName;
3213 sal_Int32 i;
3214
3215 for( i = 0; i < num; i++ )
3216 {
3217 OString str( in[i] );
3218 sal_Int64 intRes = str.toInt64( radix );
3219 sal_Bool lastRes = ( intRes == expVal[i] );
3220
3221 char buf[MAXBUFLENGTH];
3222 buf[0] = '\'';
3223 cpynstr( buf + 1, in[i], MAXBUFLENGTH );
3224 int length = AStringLen(in[i]);
3225 buf[length + 1] = '\'';
3226 buf[length + 2] = 0;
3227
3228 c_rtl_tres_state
3229 (
3230 hRtlTestResult,
3231 lastRes,
3232 buf,
3233 createName( pMeth, "toInt64", i )
3234 );
3235
3236 res &= lastRes;
3237 }
3238 return (res);
3239 }
3240
3241 sal_Bool SAL_CALL test_rtl_OString_toInt64_wrongRadix(
3242 hTestResult hRtlTestResult )
3243 {
3244 ::rtl::OString str("0");
3245
3246 sal_Int64 iRes = str.toInt64(-1);
3247
3248 return (
3249
3250 c_rtl_tres_state
3251 ( hRtlTestResult,
3252 iRes == 0,
3253 "wrong radix -1",
3254 "toInt64( wrong radix -1)"
3255 )
3256 );
3257 }
3258
3259 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toInt64(
3260 hTestResult hRtlTestResult )
3261 {
3262 sal_Int64 expValues[kBase36NumsCount];
3263 sal_Int32 i;
3264
3265 c_rtl_tres_state_start(hRtlTestResult, "toInt64");
3266 for (i = 0; i < kBase36NumsCount; expValues[i] = i, i++);
3267
3268 sal_Bool res = c_rtl_tres_state
3269 (
3270 hRtlTestResult,
3271 test_toInt64( kBinaryNumsCount, kBinaryNumsStr, expValues,
3272 kRadixBinary, hRtlTestResult ),
3273 "kBinaryNumsStr",
3274 "toInt64( radix 2 )"
3275 );
3276
3277 res &= c_rtl_tres_state
3278 (
3279 hRtlTestResult,
3280 test_toInt64( kInt32MaxNumsCount, kBinaryMaxNumsStr,
3281 (sal_Int64*)kInt64MaxNums, kRadixBinary, hRtlTestResult ),
3282 "kBinaryMaxNumsStr",
3283 "toInt64_Boundaries( radix 2 )"
3284 );
3285
3286 res &= c_rtl_tres_state
3287 (
3288 hRtlTestResult,
3289 test_toInt64( kOctolNumsCount, kOctolNumsStr, expValues,
3290 kRadixOctol, hRtlTestResult ),
3291 "kOctolNumsStr",
3292 "toInt64( radix 8 )"
3293 );
3294
3295 res &= c_rtl_tres_state
3296 (
3297 hRtlTestResult,
3298 test_toInt64( kInt32MaxNumsCount, kOctolMaxNumsStr,
3299 (sal_Int64*)kInt64MaxNums, kRadixOctol, hRtlTestResult ),
3300 "kOctolMaxNumsStr",
3301 "toInt64_Boundaries( radix 8 )"
3302 );
3303
3304 res &= c_rtl_tres_state
3305 (
3306 hRtlTestResult,
3307 test_toInt64( kDecimalNumsCount, kDecimalNumsStr, expValues,
3308 kRadixDecimal, hRtlTestResult ),
3309 "kDecimalNumsStr",
3310 "toInt64( radix 10 )"
3311 );
3312
3313 res &= c_rtl_tres_state
3314 (
3315 hRtlTestResult,
3316 test_toInt64( kInt32MaxNumsCount, kDecimalMaxNumsStr,
3317 (sal_Int64*)kInt64MaxNums, kRadixDecimal, hRtlTestResult ),
3318 "kDecimalMaxNumsStr",
3319 "toInt64_Boundaries( radix 10 )"
3320 );
3321
3322 res &= c_rtl_tres_state
3323 (
3324 hRtlTestResult,
3325 test_toInt64( kHexDecimalNumsCount, kHexDecimalNumsStr, expValues,
3326 kRadixHexdecimal, hRtlTestResult ),
3327 "kHexDecimalNumsStr",
3328 "toInt64( radix 16 )"
3329 );
3330
3331 res &= c_rtl_tres_state
3332 (
3333 hRtlTestResult,
3334 test_toInt64( kInt32MaxNumsCount, kHexDecimalMaxNumsStr,
3335 (sal_Int64*)kInt64MaxNums, kRadixHexdecimal, hRtlTestResult ),
3336 "kHexDecimalMaxNumsStr",
3337 "toInt64_Boundaries( radix 16 )"
3338 );
3339
3340 res &= c_rtl_tres_state
3341 (
3342 hRtlTestResult,
3343 test_toInt64( kBase36NumsCount, kBase36NumsStr, expValues,
3344 kRadixBase36, hRtlTestResult ),
3345 "kBase36NumsStr",
3346 "toInt64( radix 36 )"
3347 );
3348
3349 res &= c_rtl_tres_state
3350 (
3351 hRtlTestResult,
3352 test_toInt64( kInt32MaxNumsCount, kBase36MaxNumsStr,
3353 (sal_Int64*)kInt64MaxNums, kRadixBase36, hRtlTestResult ),
3354 "kBase36MaxNumsStr",
3355 "toInt64_Boundaries( radix 36 )"
3356 );
3357
3358
3359
3360 const sal_Int16 nSpecCases = 5;
3361 static const sal_Char *spString[nSpecCases] =
3362 {
3363 "-1",
3364 "+1",
3365 " 1",
3366 " -1",
3367 "001"
3368 };
3369
3370 sal_Int64 expSpecVal[nSpecCases] =
3371 {
3372 -1,
3373 1,
3374 1,
3375 -1,
3376 1
3377 };
3378
3379 res &= c_rtl_tres_state
3380 (
3381 hRtlTestResult,
3382 test_toInt64( nSpecCases, spString, expSpecVal,
3383 kRadixDecimal, hRtlTestResult ),
3384 "special cases",
3385 "toInt64( specialcases )"
3386 );
3387
3388 res &= test_rtl_OString_toInt64_wrongRadix( hRtlTestResult );
3389
3390 c_rtl_tres_state_end(hRtlTestResult, "toInt64");
3391 // return (res);
3392 }
3393
3394 //------------------------------------------------------------------------
3395 // testing the method replace( sal_Char oldChar, sal_Char newChar )
3396 //------------------------------------------------------------------------
3397 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_replace(
3398 hTestResult hRtlTestResult)
3399 {
3400 sal_Char methName[MAXBUFLENGTH];
3401 sal_Char* pMeth = methName;
3402
3403 c_rtl_tres_state_start(hRtlTestResult, "replace");
3404 typedef struct TestCase
3405 {
3406 sal_Char* comments;
3407 OString* expVal;
3408 OString* input;
3409 sal_Char oldChar;
3410 sal_Char newChar;
3411
3412 ~TestCase() { delete input; delete expVal;}
3413 } TestCase;
3414
3415 TestCase arrTestCase[]={
3416
3417 {"string differs", new OString(kTestStr18),
3418 new OString(kTestStr4),'S','s'},
3419 {"string differs", new OString(kTestStr19),
3420 new OString(kTestStr17),(sal_Char)' ',(sal_Char)'-'},
3421 {"same string, no replace ", new OString(kTestStr22),
3422 new OString(kTestStr22),'*','8'}
3423 };
3424
3425
3426 sal_Bool res = sal_True;
3427 sal_uInt32 i;
3428
3429 for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
3430 {
3431 ::rtl::OString aStr1;
3432 aStr1= arrTestCase[i].input->replace(arrTestCase[i].oldChar,
3433 arrTestCase[i].newChar);
3434
3435 res &= c_rtl_tres_state
3436 (
3437 hRtlTestResult,
3438 (arrTestCase[i].expVal->compareTo(aStr1) == 0),
3439 arrTestCase[i].comments,
3440 createName( pMeth, "replace", i )
3441
3442 );
3443 }
3444 c_rtl_tres_state_end(hRtlTestResult, "replace");
3445 // return ( res );
3446 }
3447
3448
3449
3450 //------------------------------------------------------------------------
3451 // testing the method replaceAt( sal_Int32 index, sal_Int32 count,
3452 // const OString& newStr )
3453 //------------------------------------------------------------------------
3454 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_replaceAt(
3455 hTestResult hRtlTestResult)
3456 {
3457 sal_Char methName[MAXBUFLENGTH];
3458 sal_Char* pMeth = methName;
3459
3460 c_rtl_tres_state_start(hRtlTestResult, "replaceAt");
3461 typedef struct TestCase
3462 {
3463 sal_Char* comments;
3464 OString* expVal;
3465 OString* input;
3466 OString* newStr;
3467 sal_Int32 index;
3468 sal_Int32 count;
3469
3470 ~TestCase() { delete input; delete expVal; delete newStr;}
3471 } TestCase;
3472
3473 TestCase arrTestCase[]=
3474 {
3475
3476 { "string differs", new OString(kTestStr2), new OString(kTestStr22),
3477 new OString(kTestStr2), 0, kTestStr22Len },
3478
3479 { "larger index", new OString(kTestStr1), new OString(kTestStr7),
3480 new OString(kTestStr8), 64, kTestStr8Len },
3481
3482 { "larger count", new OString(kTestStr2), new OString(kTestStr22),
3483 new OString(kTestStr2),0, 64 },
3484
3485 { "navigate index", new OString(kTestStr2), new OString(kTestStr22),
3486 new OString(kTestStr2), -64, 64 },
3487
3488 { "null string", new OString(""),
3489 new OString(kTestStr14),new OString(""), 0, kTestStr14Len }
3490 };
3491
3492 sal_Bool res = sal_True;
3493 sal_uInt32 i;
3494
3495 for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
3496 {
3497 ::rtl::OString aStr1;
3498 aStr1= arrTestCase[i].input->replaceAt( arrTestCase[i].index,
3499 arrTestCase[i].count, *arrTestCase[i].newStr );
3500
3501 sal_Bool lastRes = ( arrTestCase[i].expVal->compareTo(aStr1) == 0 );
3502
3503 c_rtl_tres_state
3504 (
3505 hRtlTestResult,
3506 lastRes,
3507 arrTestCase[i].comments,
3508 createName( pMeth, "replaceAt", i )
3509
3510 );
3511 res &= lastRes;
3512 }
3513 c_rtl_tres_state_end(hRtlTestResult, "replaceAt");
3514 // return ( res );
3515 }
3516
3517 extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString( hTestResult hRtlTestResult )
3518 {
3519
3520 c_rtl_tres_state_start(hRtlTestResult, "rtl_OString" );
3521
3522 test_rtl_OString_ctors( hRtlTestResult );
3523 test_rtl_OString_getLength( hRtlTestResult );
3524 test_rtl_OString_equals( hRtlTestResult );
3525 test_rtl_OString_equalsIgnoreAsciiCase( hRtlTestResult );
3526 test_rtl_OString_compareTo( hRtlTestResult );
3527 test_rtl_OString_op_cmp( hRtlTestResult );
3528 test_rtl_OString_op_neq( hRtlTestResult );
3529 test_rtl_OString_op_g( hRtlTestResult );
3530 test_rtl_OString_op_l( hRtlTestResult );
3531 test_rtl_OString_op_ge( hRtlTestResult );
3532 test_rtl_OString_op_le( hRtlTestResult );
3533 test_rtl_OString_op_eq( hRtlTestResult );
3534 test_rtl_OString_op_plus( hRtlTestResult );
3535 test_rtl_OString_op_peq( hRtlTestResult );
3536 test_rtl_OString_op_cscs( hRtlTestResult );
3537 test_rtl_OString_getStr( hRtlTestResult );
3538 test_rtl_OString_copy( hRtlTestResult );
3539 test_rtl_OString_concat( hRtlTestResult );
3540 test_rtl_OString_toAsciiLowerCase( hRtlTestResult );
3541 test_rtl_OString_toAsciiUpperCase( hRtlTestResult );
3542 test_rtl_OString_trim( hRtlTestResult );
3543 test_rtl_OString_valueOf( hRtlTestResult );
3544 test_rtl_OString_toChar( hRtlTestResult );
3545 test_rtl_OString_toFloat( hRtlTestResult );
3546 // LLA: test_rtl_OString_toDouble( hRtlTestResult );
3547 test_rtl_OString_toBoolean( hRtlTestResult );
3548 test_rtl_OString_toInt32( hRtlTestResult );
3549 test_rtl_OString_toInt64( hRtlTestResult );
3550 test_rtl_OString_replace( hRtlTestResult );
3551 test_rtl_OString_replaceAt( hRtlTestResult );
3552
3553 c_rtl_tres_state_end(hRtlTestResult, "rtl_OString");
3554 }
3555
3556
3557 // -----------------------------------------------------------------------------
3558 void RegisterAdditionalFunctions(FktRegFuncPtr _pFunc)
3559 {
3560 if (_pFunc)
3561 {
3562 (_pFunc)(&test_rtl_OString, "");
3563
3564 //# (_pFunc)(&test_rtl_OString_ctors, "");
3565 //# (_pFunc)(&test_rtl_OString_getLength, "");
3566 //# (_pFunc)(&test_rtl_OString_equals, "");
3567 //# (_pFunc)(&test_rtl_OString_equalsIgnoreAsciiCase, "");
3568 //# (_pFunc)(&test_rtl_OString_compareTo, "");
3569 //# (_pFunc)(&test_rtl_OString_op_cmp, "");
3570 //# (_pFunc)(&test_rtl_OString_op_neq, "");
3571 //# (_pFunc)(&test_rtl_OString_op_g, "");
3572 //# (_pFunc)(&test_rtl_OString_op_l, "");
3573 //# (_pFunc)(&test_rtl_OString_op_ge, "");
3574 //# (_pFunc)(&test_rtl_OString_op_le, "");
3575 //# (_pFunc)(&test_rtl_OString_op_eq, "");
3576 //# (_pFunc)(&test_rtl_OString_op_plus, "");
3577 //# (_pFunc)(&test_rtl_OString_op_peq, "");
3578 //# (_pFunc)(&test_rtl_OString_op_cscs, "");
3579 //# (_pFunc)(&test_rtl_OString_getStr, "");
3580 //# (_pFunc)(&test_rtl_OString_copy, "");
3581 //# (_pFunc)(&test_rtl_OString_concat, "");
3582 //# (_pFunc)(&test_rtl_OString_toAsciiLowerCase, "");
3583 //# (_pFunc)(&test_rtl_OString_toAsciiUpperCase, "");
3584 //# (_pFunc)(&test_rtl_OString_trim, "");
3585 //# (_pFunc)(&test_rtl_OString_valueOf, "");
3586 //# (_pFunc)(&test_rtl_OString_toChar, "");
3587 //# (_pFunc)(&test_rtl_OString_toFloat, "");
3588 //# (_pFunc)(&test_rtl_OString_toDouble, "");
3589 //# (_pFunc)(&test_rtl_OString_toBoolean, "");
3590 //# (_pFunc)(&test_rtl_OString_toInt32, "");
3591 //# (_pFunc)(&test_rtl_OString_toInt64, "");
3592 //# (_pFunc)(&test_rtl_OString_replace, "");
3593 //# (_pFunc)(&test_rtl_OString_replaceAt, "");
3594 }
3595 }
3596
3597 /*
3598 D:\local\644\SRX644\sal\qa\rtl_OString.cxx(3559) : error C2664:
3599 'unsigned char (void (__cdecl *)(void *),const char *)'
3600 : cannot convert parameter 1 from
3601 'unsigned char (__cdecl *)(void *)' to 'void (__cdecl *)(void *)'
3602
3603 This conversion requires a reinterpret_cast, a C-style cast or function-
3604 style cast
3605 */
FREE OFFICE SUITE