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