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